深度学习-神经网络

机器学习 同时被 3 个专栏收录
4 篇文章 0 订阅
1 篇文章 0 订阅
1 篇文章 0 订阅

一、深度学习概述

神经网路的核心组件是层(layer),它是一种数据处理模,可以将层看成数据过滤器,进去一些数据,出来的数据变得更加有用。大多数深度学习都是简单的层简单的成链接起来,从而实现间接式的数据蒸馏。

层是通过数据张量的运算实现,因此神经网络完全由一系列的张量运算组成,而这些张量运算都是输入数据的几何变换。可以将神经网路解释为高纬空间中非常复杂的几何变换,这种几何变化可以通过许多步骤来实现。

想象有两张彩纸:一张红色,一张蓝色。将其中一张纸放在另一张上。现在讲两张纸一起揉成小球。这个皱巴巴的纸球就是你的输入数据,每张纸对应于分类问题中的一个类别,神经网络(或者任何机器学习模型)要做的就是找到可以让纸球恢复平整的变换,从而能够再次让两个类别明确可分。通过深度学习,这一过程可以用三维空间中一系列简单的变换来实现,比如你用手指对纸球做的变换,每次做一个动作。神经网络将复杂的几何变换逐步分解 为一长串基本的几何变换,这与人类展开纸球所采取的策略大致相同。深度网络的每一层都通过变换使数据解开一点点——许多层堆叠在一起,可以实现非常复杂的解开过程。

二、神经网络的“引擎”:基于梯度的优化

每个神经层都用下述方法对输入数据进行变换:

 output = relu(dot(W, input) + b)

在这个表达式中,W 和 b 都是张量,均为该层的属性。它们被称为该层的权重(weight)或可训练参数(trainable parameter),这些权重包含网络从观察训练数据中学到的信息。

一开始这些权重矩阵取较小的随机值,这一步叫作随机初始化(random initialization)。 W和b都是随机的,relu(dot(W, input) + b)肯定不会得到任何有用的表示。虽然得到的表示是没有意义的,但这是一个起点。下一步则是根据反馈信号逐渐调节这些权重。这个逐渐调节的过程叫作训练,也就是机器学习中的学习。

上述过程发生在一个训练循环(training loop)内,其具体过程如下。必要时一直重复这些步骤。

(1) 抽取训练样本 x 和对应目标 y 组成的数据批量。
(2) 在 x 上运行网络[这一步叫作前向传播(forward pass)],得到预测值 y_pred。
(3) 计算网络在这批数据上的损失,用于衡量 y_pred 和 y 之间的距离。
(4) 更新网络的所有权重,使网络在这批数据上的损失略微下降。

利用网络中所有运算都是可微(differentiable)的这一事实,计算损失相对于网络系数的梯度(gradient),然后向梯度的反方向改变系数,从而使损失降低。

假设有一个连续的光滑函数f(x) = y,将实数x映射为另一个实数y。由于函数是连续的,x 的微小变化只能导致 y 的微小变化——这就是函数连续性的直观解释。假设 x 增大了一个很小的因子 epsilon_x,这导致 y 也发生了很小的变化,

即 epsilon_y:f(x + epsilon_x) = y + epsilon_y

此外,由于函数是光滑的(即函数曲线没有突变的角度),在某个点 p 附近,如果 epsilon_x足够小,就可以将f近似为斜率为a的线性函数,这样epsilon_y就变成了a * epsilon_x:

f(x + epsilon_x) = y + a * epsilon_x

显然,只有在 x 足够接近 p 时,这个线性近似才有效。

斜率 a 被称为 f 在 p 点的导数(derivative)。如果 a 是负的,说明 x 在 p 点附近的微小变 化将导致 f(x) 减小;如果 a 是正的,那么 x 的微小变化将导致 f(x) 增大。 此外,a 的绝对值(导数大小)表示增大或减小的速度快慢。

如果你想要将 x 改变一个小因子 epsilon_x,目的是将 f(x) 最小化,并且知道 f 的导数, 那么问题解决了:导数完全描述了改变 x 后 f(x) 会如何变化。如果你希望减小 f(x) 的值,只需将 x 沿着导数的反方向移动一小步。

梯度(gradient)是张量运算的导数。它是导数这一概念向多元函数导数的推广。

沿着梯度的反方向更新权重,损失每次都会变小一点。

  1. (1)  抽取训练样本 x 和对应目标 y 组成的数据批量。

  2. (2)  在 x 上运行网络,得到预测值 y_pred。

  3. (3)  计算网络在这批数据上的损失,用于衡量 y_pred 和 y 之间的距离。

  4. (4)  计算损失相对于网络参数的梯度[一次反向传播(backward pass)]。

  5. (5)  将参数沿着梯度的反方向移动一点,比如W -= step * gradient,从而使这批数据上的损失减小一点。

这很简单!刚刚描述的方法叫作小批量随机梯度下降(mini-batch stochastic gradient descent,又称为小批量 SGD)。

如你所见,直观上来看,为 step 因子选取合适的值是很重要的。如果取值太小,则沿着曲线的下降需要很多次迭代,而且可能会陷入局部极小点。如果取值太大,则更新权重值之后可能会出现在曲线上完全随机的位置。

注意,小批量 SGD 算法的一个变体是每次迭代时只抽取一个样本和目标,而不是抽取一批 数据。这叫作真 SGD(有别于小批量 SGD)。还有另一种极端,每一次迭代都在所有数据上 运行,这叫作批量 SGD。这样做的话,每次更新都更加准确,但计算代价也高得多。这两个极 端之间的有效折中则是选择合理的批量大小。

此外,SGD 还有多种变体,其区别在于计算下一次权重更新时还要考虑上一次权重更新, 而不是仅仅考虑当前梯度值,比如带动量的 SGD、Adagrad、RMSProp 等变体。这些变体被称 为优化方法(optimization method)或优化器(optimizer)。其中动量的概念尤其值得关注,它在 许多变体中都有应用。动量解决了 SGD 的两个问题:收敛速度和局部极小点。

根据微积分的知识,这种函数链可以利用下面这个恒等式进行求导,它称为链式法则(chain rule):(f(g(x)))' = f'(g(x)) * g'(x)。将链式法则应用于神经网络梯度值的计算,得 到的算法叫作反向传播(backpropagation,有时也叫反式微分,reverse-mode differentiation)。

三、关键网络架构

以下三种网络架构:密集连接网络、卷积网络和循环网络。每种类型的网络都针对于特定的输入模式,网络架构(密集网络、卷积网络、循环网络)中包含对数据结构的假设, 即搜索良好模型所在的假设空间。某种架构能否解决某个问题,这完全取决于数据结构与网络架构的假设之间的匹配度。

快速看一下输入模式与适当 的网络架构之间的对应关系。

  •  向量数据: 密集连接网络(Dense 层)。
  •  图像数据: 二维卷积神经网络。声音数据(比如波形):一维卷积神经网络(首选)或循环神经网络。
  •  文本数据: 一维卷积神经网络(首选)或循环神经网络。
  •  时间序列数据: 循环神经网络(首选)或一维卷积神经网络。
  •  其他类型的序列数据: 循环神经网络或一维卷积神经网络。如果数据顺序非常重要(比如时间序列,但文本不是),那么首选循环神经网络。
  •  视频数据: 三维卷积神经网络(如果你需要捕捉运动效果),或者帧级的二维神经网络(用于特征提取)+循环神经网络或者一维卷积神经网络(用于处理得到的序列)。
  • 立体数据: 三纬卷积神经网络。

1、密集连接网络

请记住:对于二分类问题(binary classification),层堆叠的最后一层是使用sigmoid激活 且只有一个单元的 Dense 层,并使用 binary_crossentropy 作为损失。目标应该是 0 或 1。

from keras.datasets import imdb
# 下载数据集
(train_data,train_labels),(test_data,test_labels) = imdb.load_data(num_words=10000)

#将整数序列编码为二进制矩阵
import numpy as np

def vectorize_sequences( sequences, dimension = 10000):
    results = np.zeros((len(sequences),dimension))
    for i,sequence in enumerate(sequences):
        results[i,sequence] = 1.
    return results
    
x_train = vectorize_sequences(train_data)
x_test = vectorize_sequences(test_data)


y_train = np.asarray(train_labels).astype('float32')
y_test = np.asarray(test_labels).astype('float32')

x_val = x_train[:10000]
partial_x_train = x_train[10000:]

y_val = y_train[:10000]
partial_y_train = y_train[10000:]

from keras import models
from keras import layers

model = models.Sequential()
model.add(layers.Dense(16, activation='relu', input_shape=(10000,)))
model.add(layers.Dense(16, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))

model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])

history  = model.fit(partial_x_train,
                            partial_y_train,
                            epochs=20,
                            batch_size=512,
                            validation_data=(x_val, y_val)
                            )

#模型过拟合,选择epoch=4
history  = model.fit(partial_x_train,
                            partial_y_train,
                            epochs=4,
                            batch_size=512,
                            validation_data=(x_val, y_val)
                            )

result = model.evaluate(x_test, y_test)

对于单标签多分类问题(single-label categorical classification,每个样本只有一个类别,不会超过一个),层堆叠的最后一层是一个 Dense 层,它使用 softmax 激活,其单元个数等于类 别个数。如果目标是 one-hot 编码的,使用categorical_crossentropy 作为损失;如果目标是整数,那么使用 sparse_categorical_crossentropy 作为损失。

model = models.Sequential()
model.add(layers.Dense(32, activation='relu', input_shape=(num_input_features,))) 
model.add(layers.Dense(32, activation='relu')) model.add(layers.Dense(num_classes, activation='softmax'))
model.compile(optimizer='rmsprop', loss='categorical_crossentropy')

对于多标签多分类问题(multilabel categorical classification,每个样本可以有多个类别), 层堆叠的最后一层是一个 Dense 层,它使用 sigmoid 激活,其单元个数等于类别个数,并使 用 binary_crossentropy 作为损失。目标应该是 k-hot 编码的。

model = models.Sequential()
model.add(layers.Dense(32, activation='relu', input_shape=(num_input_features,)))
model.add(layers.Dense(32, activation='relu')) 
model.add(layers.Dense(num_classes, activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy')

对于连续值向量的回归(regression)问题,层堆叠的最后一层是一个不带激活 Dense 层, 其单元个数等于你要预测的值的个数(通常只有一个值,比如房价)。有几种损失可用于回归问 题,最常见的是 mean_squared_error(均方误差,MSE)和 mean_absolute_error(平均绝对误差,MAE)。

model = models.Sequential()
model.add(layers.Dense(32, activation='relu', input_shape=(num_input_features,))) 
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(num_values))
model.compile(optimizer='rmsprop', loss='mse')

2、卷积神经网络

卷积层能够查看空间局部模式,其方法是对输入张量的不同空间位置(图块)应用相同的 几何变换。这样得到的表示具有平移不变性,这使得卷积层能够高效利用数据,并且能够高度 模块化。这个想法适用于任何维度的空间,包括一维(序列)、二维(图像)、三维(立体数据)等。 你可以使用 Conv1D 层来处理序列(特别是文本,它对时间序列的效果并不好,因为时间序列 通常不满足平移不变的假设),使用 Conv2D 层来处理图像,使用 Conv3D 层来处理立体数据。

卷积神经网络或卷积网络是卷积层和最大池化层的堆叠。池化层可以对数据进行空间下采样, 这么做有两个目的:随着特征数量的增大,我们需要让特征图的尺寸保持在合理范围内;让后面 的卷积层能够“看到”输入中更大的空间范围。卷积神经网络的最后通常是一个 Flatten 运算 或全局池化层,将空间特征图转换为向量,然后再是 Dense 层,用于实现分类或回归。

注意,大部分(或者全部)?通卷积很可能不久后会被深度可分离卷积(depthwise separable convolution,SeparableConv2D 层)所替代,后者与前者等效,但速度更快、表示效率更高。 对于三维、二维和一维的输入来说都是如此。如果你从头开始构建一个新网络,那么一定要使用 深度可分离卷积。SeparableConv2D 层可直接替代 Conv2D 层,得到一个更小、更快的网络, 在任务上的表现也更好。

model = models.Sequential() 
model.add(layers.SeparableConv2D(32, 3, activation='relu',
input_shape=(height, width, channels)))
model.add(layers.SeparableConv2D(64, 3, activation='relu'))
model.add(layers.MaxPooling2D(2))
model.add(layers.SeparableConv2D(64, 3, activation='relu')) 
model.add(layers.SeparableConv2D(128, 3, activation='relu')) model.add(layers.MaxPooling2D(2))
model.add(layers.SeparableConv2D(64, 3, activation='relu'))
model.add(layers.SeparableConv2D(128, 3, activation='relu')) model.add(layers.GlobalAveragePooling2D())
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(num_classes, activation='softmax'))
model.compile(optimizer='rmsprop', loss='categorical_crossentropy')

3. 循环神经网络

循环神经网络(RNN,recurrent neural network)的工作原理是,对输入序列每次处理一个 时间步,并且自始至终保存一个状态(state,这个状态通常是一个向量或一组向量,即状态几 何空间中的点)。如果序列中的模式不具有时间平移不变性(比如时间序列数据,最近的过去比 遥远的过去更加重要),那么应该优先使用循环神经网络,而不是一维卷积神经网络。 

Keras 中有三种 RNN 层:SimpleRNN、GRU 和 LSTM。对于大多数实际用途,你应该使用GRU 或 LSTM。两者中 LSTM 更加强大,计算代价也更高。你可以将 GRU 看作是一种更简单、计 算代价更小的替代方法。

想要将多个 RNN 层逐个堆叠在一起,最后一层之前的每一层都应该返回输出的完整序列 (每个输入时间步都对应一个输出时间步)。如果你不再堆叠更多的 RNN 层,那么通常只返回最后一个输出,其中包含关于整个序列的信息。

#下面是一个单层 RNN 层,用于向量序列的二分类。
model = models.Sequential()
model.add(layers.LSTM(32, input_shape=(num_timesteps, num_features))) model.add(layers.Dense(num_classes, activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy')

#下面是 RNN 层的堆叠,用于向量序列的二分类。
model = models.Sequential() 
model.add(layers.LSTM(32, return_sequences=True,
input_shape=(num_timesteps, num_features))) 
model.add(layers.LSTM(32, return_sequences=True))
model.add(layers.LSTM(32)) 
model.add(layers.Dense(num_classes, activation='sigmoid'))
model.compile(optimizer='rmsprop', loss='binary_crossentropy')

四、神经网络的优化

 

  • 0
    点赞
  • 0
    评论
  • 2
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值