【吴恩达深度学习笔记】2.3超参数调试、Batch正则化和程序框架Hyperparameter tuning

柔光的暖阳◎ 2022-11-20 09:36 14阅读 0赞

# 第二门课 改善深层神经网络：超参数调试、正则化以及优化（Improving Deep Neural Networks:Hyperparameter tuning,Regularization and Optimization） #

## 3.1调试处理（Tuning process） ##

超参数（按调试重要程度排序）：

*  学习速率 α \\alpha α
 *  动量梯度下降法（Momentum）中的 β \\beta β
 *  不同层中隐藏单元数量 h i d d e n   u n i t s hidden \\space units hidden units
 *   m i n i − b a t c h   s i z e mini-batch \\space size mini−batch size
 *  网络层数 l a y e r s layers layers
 *  学习率衰减 l e a r i n g   r a t e   d e c a y learing \\space rate \\space decay learing rate decay
 *  Adam中的 β 1 ， β 2 ， ϵ \\beta\_1，\\beta\_2，\\epsilon β1，β2，ϵ

**调试值的选择**：随机取值、精确搜索，使用由粗糙到精细的搜索过程

## 3.2为超参数选择合适的范围（Using an appropriate scale） ##

用对数标尺搜索超参数的方式要优于使用均值的数轴。如果想要确定 α \\alpha α的值，怀疑其值属于 \[ 0.0001 , 1 \] \[0.0001,1\] \[0.0001,1\]，在python中可以这样

> r = -4 \* np.random.rand()

得出 r ∈ \[ − 4 , 0 \] r\\in \[-4,0\] r∈\[−4,0\]，然后随机取值 a = 1 0 r ∈ \[ 1 0 − 4 , 1 0 0 \] a = 10^r\\in\[10^\{-4\},10^0\] a=10r∈\[10−4,100\]。对于 β \\beta β，如果想要在0.9到0.999区间搜索，可以设定 1 − β = 1 0 r 1-\\beta=10^r 1−β=10r

## 3.3超参数调试的时间：Pandas VS Caviar（Hyperparameters tuning in practice:Pandas VS Caviar） ##

搜索超参数的方式：

*  Babysitting one model熊猫方式
 *  Training many models in parallel鱼子酱方式  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center]  
    两种方式的选择由你拥有的计算资源决定的，如果拥有足够的计算机去平行试验许多模型，采用鱼子酱方式，尝试许多不同的超参数。如果需要试验大量的模型，同时试验大量的模型是很困难的，它的确是依赖于应用的过程，使用熊猫式。

## 3.4归一化网络的激活函数（Normalizing activations in a network） ##

**Batch归一化**使得参数搜索问题变得容易，使神经网络对超参数的选择更加稳定，超参数的范围会更加庞大，工作效果也很好，也会使得训练更加容易，甚至是深层网络。当训练一个模型，如logistic回归时，归一化输入特征 x x x可以加快学习过程。归一化 a \[ l − 1 \] a^\{\[l-1\]\} a\[l−1\]的平均值和方差可以使 w \[ l \] w^\{\[l\]\} w\[l\]和 b \[ l \] b^\{\[l\]\} b\[l\]的训练更有效率，实际是对 z \[ l − 1 \] z^\{\[l-1\]\} z\[l−1\]的归一化。

针对 l l l层进行归一化： μ = 1 m ∑ i m z ( i ) \\mu = \\frac\{1\}\{m\}\\sum^m\_iz^\{(i)\} μ=m1i∑mz(i)

σ = 1 m ∑ i m ( z ( i ) − μ ) 2 \\sigma = \\frac\{1\}\{m\}\\sum^m\_i(z^\{(i)\}-\\mu)^2 σ=m1i∑m(z(i)−μ)2

z n o r m ( i ) = z ( i ) − μ σ 2 + ϵ z^\{(i)\}\_\{norm\}=\\frac\{z^\{(i)\}-\\mu\}\{\\sqrt\{\\sigma^2+\\epsilon\}\} znorm(i)=σ2\+ϵz(i)−μ

z z z标准化后化为含平均值0和标准单位方差， z z z的每一个分量都含有平均值0和方差1，但我们不想让隐藏单元总是含有平均值0和方差1，隐藏单元有了不同的分布会有意义。下面计算 z ~ ( i ) \\tilde z^\{(i)\} z~(i)：

z ~ ( i ) = γ z n o r m ( i ) + β \\tilde z^\{(i)\}=\\gamma z^\{(i)\}\_\{norm\}+\\beta z~(i)=γznorm(i)\+β

γ \\gamma γ和 β \\beta β是模型的学习参数，我们使用梯度下降或一些其它类似梯度下降的算法，比如Momentum或者Nesterov，Adam更新 γ \\gamma γ和 β \\beta β，正如更新神经网络的权重一样。可以随意设置 z ~ ( i ) \\tilde z^\{(i)\} z~(i)的平均值，如果 γ = σ 2 + ϵ \\gamma=\\sqrt\{\\sigma^2+\\epsilon\} γ=σ2\+ϵ， β = μ \\beta=\\mu β=μ，则 z ~ ( i ) = z ( i ) \\tilde z^\{(i)\}=z^\{(i)\} z~(i)=z(i)。通过赋予 γ \\gamma γ和 β \\beta β其它值可以构造含其它平均值和方差的隐藏单元值。在网络匹配这个单元的方式，之前可能是用 z ( 1 ) , z ( 2 ) z^\{(1)\},z^\{(2)\} z(1),z(2)等等，现在则会用 z ~ ( i ) \\tilde z^\{(i)\} z~(i)取代 z ( i ) z^\{(i)\} z(i)，方便神经网络中的后续计算。

## 3.5将Batch Norm拟合进神经网络（Fitting Batch Norm into a neural network） ##

/![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 1]  
无论的 b \[ l \] b^\{\[l\]\} b\[l\]值是多少，都是要被减去的，因为在Batch归一化的过程中，要计算 z \[ l \] z^\{\[l\]\} z\[l\]的均值，再减去平均值，在此例中的mini-batch中增加任何常数，数值都不会改变，因为加上的任何常数都将会被均值减去所抵消。所以如果使用Batch归一化，可以消除 b \[ l \] b^\{\[l\]\} b\[l\]参数，或者设置为0。则参数变成 z \[ l \] = w \[ l \] a \[ l − 1 \] z^\{\[l\]\}=w^\{\[l\]\}a^\{\[l-1\]\} z\[l\]=w\[l\]a\[l−1\]，归一化的 z ~ \[ l \] = γ \[ l \] z \[ l \] + β \[ l \] \\tilde z^\{\[l\]\}=\\gamma^\{\[l\]\} z^\{\[l\]\}+\\beta^\{\[l\]\} z~\[l\]=γ\[l\]z\[l\]\+β\[l\]，最后会用参数 β \[ l \] \\beta^\{\[l\]\} β\[l\]影响偏移或偏置条件，决定的 z ~ \[ l \] \\tilde z^\{\[l\]\} z~\[l\]的取值。

z \[ l \] z^\{\[l\]\} z\[l\]的维数是 ( n \[ l \] , 1 ) (n^\{\[l\]\},1) (n\[l\],1)， b \[ l \] ， β \[ l \] b^\{\[l\]\}，\\beta^\{\[l\]\} b\[l\]，β\[l\]和 γ \[ l \] \\gamma^\{\[l\]\} γ\[l\]的维数是 ( n \[ l \] , 1 ) (n^\{\[l\]\},1) (n\[l\],1)。隐藏单元为 n \[ l \] n^\{\[l\]\} n\[l\]，所以 β \[ l \] \\beta^\{\[l\]\} β\[l\]和 γ \[ l \] \\gamma^\{\[l\]\} γ\[l\]用来将每个隐藏层的均值和方差缩放为网络想要的值。

用Batch归一化来应用梯度下降法：  
 f o r   t = 1... n u m \_ m i n i b a t c h e s for\\space t=1...num\\\_minibatches for t=1...num\_minibatches，在mini-batches  X \{ t \} X^\{\\\{t\\\}\} X\{ t\}上应用正向**prop**，每个隐藏层都应用正向prop，用Batch归一化 z ~ \[ l \] \\tilde z^\{\[l\]\} z~\[l\]取代 z \[ l \] z^\{\[l\]\} z\[l\]，确保在这个mini-batch中， z z z有归一化的均值和方差，归一化均值和方差后是 z ~ ( i ) \\tilde z^\{(i)\} z~(i)，然后用反向**prop**计算 d w \[ l \] dw^\{\[l\]\} dw\[l\]和 d b \[ l \] db^\{\[l\]\} db\[l\]，及所有 l l l层所有的参数 d β \[ l \] d\\beta^\{\[l\]\} dβ\[l\]和 d γ \[ l \] d\\gamma^\{\[l\]\} dγ\[l\]。最后更新参数 β \[ l \] = β \[ l \] − α d β \[ l \] \\beta^\{\[l\]\}=\\beta^\{\[l\]\}-\\alpha d\\beta^\{\[l\]\} β\[l\]=β\[l\]−αdβ\[l\]， γ \[ l \] = γ \[ l \] − α d γ \[ l \] \\gamma^\{\[l\]\}=\\gamma^\{\[l\]\}-\\alpha d\\gamma^\{\[l\]\} γ\[l\]=γ\[l\]−αdγ\[l\]，也可以使用其他算法更新。

## 3.6Batch Norm为什么奏效（Why does Batch Norm work?） ##

*  像归一化输入一样归一化隐藏单元的值加速学习。
 *  可以使权重比网络更滞后或更深层，比如第10层的权重更能经受得住变化，相比于神经网络中前层的权重。限制了在前层的参数更新会影响数值分布的程度，减弱了前层参数的作用与后层参数的作用之间的联系，使得网络每层都可以自己学习，有助于加速网络学习。
 *  有轻微的正则化效果  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 2]

**Covariate shift**：使数据改变分布

## 3.7测试时的Batch Norm（Batch Norm at test time） ##

在训练时， μ \\mu μ和 σ 2 \\sigma^2 σ2是在整个mini-batch上计算出来的包含了像是64或28或其它一定数量的样本，但在测试时，你可能需要逐一处理样本，方法是根据你的训练集估算 μ \\mu μ和 σ 2 \\sigma^2 σ2，估算的方式有很多种，理论上你可以在最终的网络中运行整个训练集来得到 μ \\mu μ和 σ 2 \\sigma^2 σ2，但在实际操作中，我们通常运用指数加权平均来追踪在训练过程中你看到的 μ \\mu μ和 σ 2 \\sigma^2 σ2的值。还可以用指数加权平均，有时也叫做流动平均来粗略估算 μ \\mu μ和 σ 2 \\sigma^2 σ2，然后在测试中使用 μ \\mu μ和 σ 2 \\sigma^2 σ2的值来进行你所需要的隐藏单元值的调整。

## 3.8Softmax回归（Softmax regression） ##

有一种logistic回归为**Softmax**回归能识别多个分类 C C C。如果最后的输出 a \[ l \] a^\{\[l\]\} a\[l\]是 4 × 1 4×1 4×1维向量，即 C = 4 C=4 C=4，在神经网络的最后一层需要应用Softmax激活函数。首先要计算一个临时变量 t = e z \[ l \] t=e^\{z^\{\[l\]\}\} t=ez\[l\]，这适用于每个元素， z \[ l \] z^\{\[l\]\} z\[l\]是 4 × 1 4×1 4×1的四维向量，则 t t t也是四维向量，输出 a \[ l \] a^\{\[l\]\} a\[l\]，需要将 t t t进行归一化，使其和为1。基本上就是向量，但是会归一化，使和为1。因此 a \[ l \] = e z \[ l \] ∑ j = 1 4 t i a^\{\[l\]\}=\\frac\{e^\{z^\{\[l\]\}\}\}\{\\sum^4\_\{j=1\}t\_i\} a\[l\]=∑j=14tiez\[l\]  
，这个四维向量的第 i i i个元素是 a i \[ l \] = t i ∑ j = 1 4 t i a^\{\[l\]\}\_i=\\frac\{t\_i\}\{\\sum^4\_\{j=1\}t\_i\} ai\[l\]=∑j=14titi。

## 3.9训练一个Softmax分类器（Training a Softmax classifier） ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 3]  
损失函数所做的就是找到训练集中的真实类别，然后试图使该类别相应的概率尽可能地高。Softmax分类中单个样本的损失函数是： L ( y ^ , y ) = − ∑ j = 1 4 y j l o g y ^ j L(\\hat y,y)=-\\sum^4\_\{j=1\}y\_jlog\\hat y\_j L(y^,y)=−j=1∑4yjlogy^j

整个训练集的损失为： J ( w \[ 1 \] , b \[ 1 \] , . . . ) = 1 m ∑ i = 1 m L ( y ^ ( i ) , y ( i ) ) J(w^\{\[1\]\},b^\{\[1\]\},...)=\\frac\{1\}\{m\}\\sum^m\_\{i=1\}L(\\hat y^\{(i)\},y^\{(i)\}) J(w\[1\],b\[1\],...)=m1i=1∑mL(y^(i),y(i))

若 C = 4 C=4 C=4， y y y是一个4×1的向量，若实现向量化，矩阵 Y = \[ y ( 1 ) , y ( 2 ) , . . . , y ( m ) \] Y=\[y^\{(1)\},y^\{(2)\},...,y^\{(m)\}\] Y=\[y(1),y(2),...,y(m)\]是一个4×m的矩阵，矩阵 Y ^ \\hat Y Y^也是一个4×m的矩阵。

反向传播时的原理公式： d z \[ l \] = y ^ − y dz^\{\[l\]\}=\\hat y-y dz\[l\]=y^−y

## 3.10深度学习框架（Deep Learning frameworks） ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 4]

## 3.11TensorFlow ##

利用TensorFlow最小化损失函数 J w = w 2 − 10 w + 25 Jw=w^2-10w+25 Jw=w2−10w\+25

import numpy as np
    import tensorflow as tf
    print(tf.__version__)   # 1.15.3
    
    
    # 利用tf.Variable定义参数，并且初始化为0
    w = tf.Variable(0, dtype=tf.float32)
    
    # 定义损失函数
    # cost = tf.add(tf.add(w**2, tf.multiply(-10., w)), 25)
    cost = w**2 - 10 * w + 25
    
    # 定义学习算法，使用0.01的学习率，目标是最小化损失
    train = tf.train.GradientDescentOptimizer(0.01).minimize(cost)
    
    # 惯用表达
    init = tf.global_variables_initializer()
    session = tf.Session()  # 开启TensorFlow session
    session.run(init)   # 初始化全局变量
    print(session.run(w))   # 0.0 让TensorFlow评估变量
    """ # 用with方便清理，这种初始化方式可以自动关闭session with tf.Session() as session: session.run(init) print(session.run(w)) """
    
    # session.run(train)
    # print(session.run(w)) # 0.099999994 在一步梯度下降算法后，w是0.1
    #
    # # 运行梯度下降1000次迭代
    # for i in range(1000):
    # session.run(train)
    # print(session.run(w)) # 4.9999886
    
    
    """ 把训练集数据加入TensorFlow程序 """
    x = tf.placeholder(tf.float32, [3, 1])
    cost = x[0][0]*w**2 + x[1][0]*w + x[2][0]
    coefficient = np.array([[1.], [-10.], [25.]])
    feed_dict = { x: coefficient}    # 把系数数组接入变量
    
    session.run(train, feed_dict={ x: coefficient})
    print(session.run(w))   # 0.099999994
    
    # 运行梯度下降1000次迭代
    for i in range(1000):
        session.run(train, feed_dict={ x: coefficient})
    print(session.run(w))   # 4.9999886

TensorFlow之类的编程框架已经内置了必要的反向函数，通过内置函数来计算前向函数可以自动用反向函数来实现反向传播，即便函数非常复杂，再帮你计算导数，所以不需要明确实现反向传播。

## 错题 ##

> 在训练具有批处理规范的神经网络之后，在测试时间，在新样本上评估神经网络，您应该：执行所需的标准化，在训练期间使用使用了μ和σ2的指数加权平均值来估计mini-batches的情况。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/c9c8a9281d7743d7a410b5edf8279d5f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/7143684c2a784065b285a9a142f8ab6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/a09feb76dfd448b6b139f96d259dc606.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/60f1a59440644837a44acd747a1d5adf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tlaXZlbl8_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/d82fda33304e41e783ac91fff56bc6e3.png