超参数调试、Batch正则化和程序框架
1. 调试处理
需要处理的参数：
| 参数 | 重要程度 |
|---|---|
| 学习率 α \alpha α | ★★★★ |
| Momentum（动量梯度下降法）参数 β = 0.9 \beta = 0.9 β=0.9 | ★★★ |
| 隐藏单元数量 | ★★★ |
| mini-batch size | ★★★ |
| 网络层数 | ★★ |
| 学习衰减率 | ★★ |
| Adam 优化算法的 β 1 = 0.9 , β 2 = 0.999 , ε = 1 e − 8 \beta_1=0.9,\beta_2=0.999, \varepsilon=1e^{-8} β1=0.9,β2=0.999,ε=1e−8 | ★ |
- 在深度学习领域，常采用随机选点进行参数搜索（试验了更多的不同的超参数值）
- 由粗糙到精细的策略（集中计算资源到可能更优的小区域进行更密集的搜索）
2. 为超参数选择合适的范围
随机取值，并不是在范围内均匀取值。
-
使用对数标尺搜索超参数的方式会更合理，比如想取参数 α ∈ [ 0.0001 , 1 ] \alpha \in [0.0001, 1] α∈[0.0001,1]
-
r = -4*np.random.rand()， r ∈ [ − 4 , 0 ] r \in [-4,0] r∈[−4,0]，然后取 α = 1 0 r \alpha = 10^{r} α=10r，在 r 的区间均匀取值
再比如计算指数的加权平均值参数 β ∈ [ 0.9 , 0.999 ] \beta \in [0.9, 0.999] β∈[0.9,0.999] -
我们考察 1 − β ∈ [ 0.001 , 0.1 ] 1-\beta \in [0.001, 0.1] 1−β∈[0.001,0.1]，那么我们令 r ∈ [ − 3 , − 1 ] r \in [-3, -1] r∈[−3,−1]， r 在里面均匀取值， 1 − β = 1 0 r → β = 1 − 1 0 r 1-\beta=10^r \rightarrow \beta = 1-10^r 1−β=10r→β=1−10r
因为加权平均值大概是基于过去 1 1 − β \frac{1}{1-\beta} 1−β1个值进行平均，当 β \beta β 接近 1 的时候，对细微的变化非常敏感，需要更加密集的取值
当然，如果你使用均匀取值，应用从粗到细的搜索方法，取足够多的数值，最后也会得到不错的结果
3. 超参数调试的实践
- 在数据更新后，要重新评估超参数是否依然合适
- 没有计算资源，你可以试验一个或者少量的模型，不断的调试和观察效果（熊猫式）
- 有计算资源，尽管试验不同参数的模型，最后选择一个最好的（鱼子酱式）
4. 归一化网络的激活函数
Batch归一化 会使你的参数搜索问题变得很容易，使神经网络对超参数的选择更加稳定，超参数的范围会更加庞大，工作效果也很好，也会使你的训练更加容易
那么对于任意一层的输入 我们将其归一化
z
[
l
]
z^{[l]}
z[l]（有争议，归一化激活函数值
a
[
l
]
a^{[l]}
a[l]）
z
norm
(
i
)
=
z
(
i
)
−
μ
σ
2
+
ε
z_{\text {norm }}^{(i)}=\frac{z^{(i)}-\mu}{\sqrt{\sigma^{2}+\varepsilon}}
znorm (i)=σ2+εz(i)−μ
但是我们不想让每一层的均值都为0，方差为1，也许有不同的分布有意义，加上2个超参数
γ
,
β
\gamma, \beta
γ,β
z
~
(
i
)
=
γ
z
norm
(
i
)
+
β
\tilde{z}^{(i)}=\gamma z_{\text {norm }}^{(i)}+\beta
z~(i)=γznorm (i)+β
通过赋予 γ , β \gamma, \beta γ,β 其它值，可以使你构造含其它均值和方差的隐藏单元值
5. 将 Batch Norm 拟合进神经网络
前向传播：
计算完前一层的输出，先进行归一化，再计算激活函数值
反向传播：
现在网络里引入了新的参数
β
,
γ
\beta, \gamma
β,γ（跟优化算法的
β
\beta
β 是两个东西） ，然后可以用之前学到的 Adam、RMSprop、Momentum梯度下降来更新参数
β [ l ] = β [ l ] − α ∗ d β [ l ] γ [ l ] = γ [ l ] − α ∗ d γ [ l ] w [ l ] = w [ l ] − α ∗ d w [ l ] \begin{aligned} \beta^{[l]}&=\beta^{[l]}-\alpha *d \beta^{[l]}\\ \gamma^{[l]}&=\gamma^{[l]}-\alpha *d \gamma^{[l]}\\ w^{[l]}&=w^{[l]}-\alpha* d w^{[l]} \end{aligned} β[l]γ[l]w[l]=β[l]−α∗dβ[l]=γ[l]−α∗dγ[l]=w[l]−α∗dw[l]
b [ l ] b^{[l]} b[l]参数没有用，做归一化会被减去。
6. Batch Norm 为什么奏效
- 原因1，使得输入特征、隐藏单元的值获得类似的范围，可以加速学习。
- 原因2，在前面层输入值改变的情况下，BN 使得他们的均值和方差不变（更稳定），即使输入分布改变了一些，它会改变得更少。
它减弱了前层参数的作用与后层参数的作用之间的联系，它使得网络每层都可以自己学习，稍稍独立于其它层，这有助于加速整个网络的学习。
另外，BN 有轻微的正则化效果，因为它在 mini-batch 上计算的均值和方差是有小的噪声，给隐藏单元添加了噪声，迫使后部单元不过分依赖任何一个隐藏单元（类似于 dropout），当增大 mini-batch size ，那么噪声会降低，因此正则化效果减弱
不要把 Batch归一化当作正则化
把它当作将你归一化隐藏单元激活值并加速学习的方式
注意：
Batch归一化一次只能处理一组mini-batch数据
7. 测试时的 Batch Norm
μ
=
1
m
∑
i
z
(
i
)
σ
2
=
1
m
∑
i
(
z
(
i
)
−
μ
)
2
z
norm
(
i
)
=
z
(
i
)
−
μ
σ
2
+
ε
z
~
(
i
)
=
γ
z
norm
(
i
)
+
β
\begin{aligned} \mu &=\frac{1}{m} \sum_{i} z^{(i)} \\ \sigma^{2} &=\frac{1}{m} \sum_{i}\left(z^{(i)}-\mu\right)^{2} \\ z_{\text {norm }}^{(i)} &=\frac{z^{(i)}-\mu}{\sqrt{\sigma^{2}+\varepsilon}} \\ \tilde{z}^{(i)} &=\gamma z_{\text {norm }}^{(i)}+\beta \end{aligned}
μσ2znorm (i)z~(i)=m1i∑z(i)=m1i∑(z(i)−μ)2=σ2+εz(i)−μ=γznorm (i)+β
Batch归一化 将你的数据以 mini-batch 的形式逐一处理，但是测试的时候，你可能不能将一个 mini-batch 中的所有样本同时处理。
- 用指数加权平均来估算, 这个平均数涵盖了所有 mini-batch (训练过程中计算 μ , σ 2 \mu, \sigma^{2} μ,σ2 的加权平均)
- 其他合理的方法也可以, 比如对整个训练集进行估计 μ , σ 2 \mu, \sigma^{2} μ,σ2
使用 Batch归一化，你能够训练更深的网络，学习算法运行速度更快
8. Softmax 回归
Softmax 回归可以用于多分类问题
Softmax 激活函数：
- 先计算
t = e z [ l ] t = e^{z^{[l]}} t=ez[l] - 再每个元素除以总和
a [ l ] = e z [ l ] ∑ j = 1 C t j a^{[l]}=\frac{e^{z^{[l]}}}{\sum_{j=1}^{C} t_{j}} a[l]=∑j=1Ctjez[l]
Softmax 激活函数需要将所有可能的输出归一化，需要输入一个向量，最后输出一个向量
9. 训练一个 Softmax 分类器
Softmax 层反向传播时的梯度计算 ： d z [ l ] = y ^ − y dz^{[l]}=\hat{y}-y dz[l]=y^−y
Softmax分类可以运用学习算法将输入分成不止两类，而是 C C C 个不同类别
10. 深度学习框架
Caffe/Caffe2
CNTK
DL4J
Keras
Lasagne
mxnet
Paddlepaddle
TensorFlow
Theano
Torch
选择标准：
- 便于编程，包括神经网络的开发和迭代，还包括为产品进行配置，为巨大的用户的实际使用考虑
- 运行速度，特别是训练大数据集时，一些框架能让你更高效地运行和训练神经网络
- 框架是否真的开放，不仅需要开源，而且需要良好的管理。
程序框架 通过提供比数值线性代数库更高程度的抽象化，让你在开发深度学习应用时更加高效
11. TensorFlow
import numpy as np
import tensorflow as tf
import tensorflow.compat.v1 as tf # 防止1.0版本语句报错
tf.disable_v2_behavior()
# 定义参数w
w = tf.Variable(0, dtype=tf.float32)
# 定义损失函数 w**2-10w+25
# cost = tf.add(tf.add(w**2,tf.multiply(-10.,w)),25)
# 以下写法也是可以的
cost = w**2-10*w+25
# 0.01的学习率，目标是最小化损失函数
# train 为学习算法，使用梯度下降
train = tf.train.GradientDescentOptimizer(0.01).minimize(cost)
# 初始化
init = tf.global_variables_initializer()
# 开启 tf session
session = tf.Session()
# 初始化全局变量
session.run(init)
# 让tf评估一个变量
session.run(train) # 运行一次梯度下降
print(session.run(w)) # 打印w的现在的值 0.099999994
# 运行1000次梯度下降迭代
for i in range(1000):
session.run(train)
print(session.run(w)) # 4.999988 很接近最优值5了
# 定义参数w
w = tf.Variable(0, dtype=tf.float32)
# 定义损失函数 w**2-10w+25
# cost = tf.add(tf.add(w**2,tf.multiply(-10.,w)),25)
# 以下写法也是可以的
# cost = w**2-10*w+25
# 上面是对固定的函数而言的
# 给上面的函数添加变化的3个系数(placeholder,稍后给你数据)
x = tf.placeholder(tf.float32, [3,1])
cost = x[0][0]*w**2 + x[1][0]*w + x[2][0]
# 定义系数 coeff 提供给 x
coefficient = np.array([[1.],[-10.],[25.]])
# 0.01的学习率，目标是最小化损失函数
# train 为学习算法，使用梯度下降
train = tf.train.GradientDescentOptimizer(0.01).minimize(cost)
# 初始化
init = tf.global_variables_initializer()
# 开启 tf session
session = tf.Session()
# 初始化全局变量
session.run(init)
# 让tf评估一个变量
session.run(train, feed_dict={x:coefficient}) # 运行一次梯度下降
print(session.run(w)) # 打印w的现在的值 0.099999994
# 运行1000次梯度下降迭代
for i in range(1000):
session.run(train, feed_dict={x:coefficient})
print(session.run(w)) # 4.999988
TensorFlow中的placeholder是一个你之后会赋值的变量，这种方式便于把训练数据加入损失方程
运行训练迭代，用feed_dict来让x=coefficients。
如果在做mini-batch梯度下降，在每次迭代时，需要插入不同的mini-batch，那么每次迭代，你就用feed_dict来喂入训练集的不同子集，把不同的mini-batch喂入损失函数需要数据的地方
TensorFlow如此强大，只需说明如何计算损失函数，它就能求导，用一两行代码就能运用梯度优化器，Adam优化器 或 其他优化器
扫一扫
3716
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
