deeplearning.ai 改善深层神经网络 week2 优化算法

这一周的主题是优化算法。

1.  Mini-batch：

　　上一门课讨论的向量化的目的是去掉for循环加速优化计算，X = [x⁽¹⁾ x⁽²⁾ x⁽³⁾ ... x^(m)]，X的每一个列向量x⁽ⁱ⁾是一个样本，m是样本个数。但当样本很多时（比如m=500万），向量化依然不能解决问题。所以提出了mini-batch的概念（Batch是指对整个样本都操作，mini-batch指只对所有样本的子集进行操作）。把若干样本合并成一个mini-batch，比如这里选择1000，X^{1} = [x⁽¹⁾ x⁽²⁾ ... x⁽¹⁰⁰⁰⁾]，X^{2} = [x⁽¹⁰⁰¹⁾ x⁽¹⁰⁰²⁾ ... x⁽²⁰⁰⁰⁾]，等等。则我们一共有5000个mini-batch，此时 X = [X^{1} X^{2} ... X^{5000}]。同样的，把输出Y也做这样的操作，得到 Y = [Y^{1} Y^{2} ... Y^{5000}] 。

　　Notation：x⁽ⁱ⁾表示第i个样本，z^[l]表示第l层的z值，X^{t}表示第t个mini-batch。

　　具体算法：

repeat { #不断重复迭代优化
    for t = 1, ..., 5000 { #对于普通的batch处理手段，遍历一次样本更新一次参数。而在mini-batch的方法中，遍历一次样本更新了5000次参数。
        Forward prop on X{t} #用向量化的手段依次处理每一个mini-batch
            Z[1] = W[1]X{t} + b[1]
            A[1] = g[1](Z[1])
                .
                .
                .
            A[l] = g[l](Z[l])
        Compute cost J = 1/1000*(∑L(y_hat(i), y(i))）+ 正则化项
        Back prop to compute gradients with respect to J{t} (using X{t}, Y{t})
        W[l] = W[l] - αdW[l], b[l] = b[l] - αdb[l]
    }
}　

　　对于batch处理方式来说，cost function J随着优化的进行是越来越小的，单调递减。而对于mini-batch的处理方式来说，则是震荡着下降，或者说下降的曲线夹杂了噪音。

　　一个超参数是mini-batch的大小，size。如果size = m，则意味着就是batch gradient descent，用整个数据集训练。如果size = 1，则是stochastic gradient descent，每个样本都是独立的mini-batch。前者的问题是每次迭代的计算太费时，后者的问题是随机性太严重，效率过于低下，失去了向量化带来的加速计算效果。mini-batch的大小介于两者之间，能获得平衡的效果，一方面有向量化的加速效果，另一方面又不需要计算全部样本。关于mini-batch的大小，NG的建议：1）如果小数据集（少于2000），直接使用batch方法；2）一般的mini-batch大小是64~512，考虑到CPU/GPU的内存存储方式，2的幂的大小算得更快。不用担心mini-batch的大小不能整除样本数的问题，最后一个样本就少一点没事。也有人用1024，但不常见。这是一个超参数，所以NG建议多尝试几个不同的2的幂，找个最好的。mini-batch越大，减少了噪音，也减少了正则化效果。

def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):
    """
    Creates a list of random minibatches from (X, Y)
 
    Arguments:
    X -- input data, of shape (input size, number of examples)
    Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (1, number of examples)
    mini_batch_size -- size of the mini-batches, integer
 
    Returns:
    mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)
    """
 
    np.random.seed(seed)            # To make your "random" minibatches the same as ours
    m = X.shape[1]                  # number of training examples
    mini_batches = []
 
    # Step 1: Shuffle (X, Y)
    permutation = list(np.random.permutation(m))
    shuffled_X = X[:, permutation]
    shuffled_Y = Y[:, permutation].reshape((1,m))
 
    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.
    num_complete_minibatches = math.floor(m/mini_batch_size) # number of mini batches of size mini_batch_size in your partitionning
    for k in range(0, num_complete_minibatches):
        mini_batch_X = shuffled_X[:, k*mini_batch_size : (k+1)*mini_batch_size]
        mini_batch_Y = shuffled_Y[:, k*mini_batch_size : (k+1)*mini_batch_size]
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)
 
    # Handling the end case (last mini-batch < mini_batch_size)
    if m % mini_batch_size != 0:
        mini_batch_X = shuffled_X[:, (k+1)*mini_batch_size : m-1]
        mini_batch_Y = shuffled_Y[:, (k+1)*mini_batch_size : m-1]
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)
 
    return mini_batches

　　

2. 指数加权平均（指数加权移动平均）：

　　v_t = βv_t-1 + (1-β)θ_t 。这个公式可以看成 v_t 近似等于 1/(1-β) 个数据的平均值，比如β = 0.9，则近似可以看成是10个数据的平均值。展开来看，v_t = (1-β)*θ_t  + (1-β)*β*θ_t-1  + (1-β)*β²*θ_t  + ...(1-β)*βⁿ*θ_t ，权重指数衰减。（为什么近似等于1/(1-β) 个数据的平均值？NG解释说，如果β接近1，β^1/(1-β)≈1/e=0.37，0.37的权重已经很小了，所以说近似等于 1/(1-β) 个数据的平均值。）

　　指数加权平均的一大好处是可以迭代计算，占内存很小。相比之下，如果记录过去n个数值，然后算平均数，显然耗内存很多。

　　偏差矫正：偏差产生的原因是头部缺数据，造成求得的指数加权平均比较小。偏差矫正的公式是 v_t / (1 - β^t)，注意这里是计算完v_t后矫正，而不是在迭代过程中实时矫正。直观地说，如果β大，比如0.98，则需要平均更多的数据，于是1 - β^t更小，从而把 v_t 放大。

3. Momentum (Gradient descent with momentum)

　　这种方法几乎总是比标准的梯度下降快。基本想法是：用梯度的指数加权平均数来更新权重。如果优化的问题有大的condition number，则优化过程中，会在一个方向剧烈震荡。这导致我们只能选用小的学习率，降低了优化的速度。如果学习率大，很容易就发散了。我们希望的是在震荡的方向上迭代步长小一点，而在没有震荡的方向上迭代步长大一点。指数加权平均的做法在震荡方向上把数据正负抵消了，所以得到很小的数，而在没有震荡的方向上则持续增加。物理的直观解释是想象一个小球从碗的边沿滚下去，梯度是它的加速度，momentum是它的速度，β是和摩擦力相关的量。相比于标准的梯度下降，当前迭代只与当前梯度相关，而momentum的方法把当前迭代和过往梯度也联系起来。

　　具体算法：

　　v_{dW = 0,} v_db = 0

　　对于每一步的迭代：

　　　　计算当前mini-batch的梯度dW, db。

　　　　v_dW = βv_dW + (1-β)dW  # NG解释说也有的教材写成 v_dW = βv_dW + dW，他自己不喜欢这种，因为更难调参数，调β的时候，会再需要调α。

　　　　v_db = βv_db + (1-β)db

　　　　W = W - αv_dW, b = b- αv_db

　　α和β是超参数，不过经验上看β取0.9是非常不错的。一般人们不用偏差矫正，因为通过初始阶段后就无偏了。

4. RMSprop(Root mean square prop): NG说这个方法最开始是Geoffrey Hinton在coursera的课上提出来的。

　　具体算法：

　　S_{dW = 0,} S_db = 0

　　对于每一步的迭代：

　　　　计算当前mini-batch的梯度dW, db。

　　　　S_dW = βS_dW + (1-β)dW²   # dW²是把向量的每个元素各自平方。

　　　　S_db = βv_db + (1-β)db²

　　　　W = W - αdW/(sqrt(S_dW)+ε), b = b- αdb/(sqrt(S_db)+ε) # 分母加上ε为了防止除以0的情况，ε可以随便设一个很小的数，比如e-8

　　直观地解释：对于震荡的优化方向，S值会比较大，从而更新参数时步长会比较小，从而消除震荡。

5. Adam(Adaptive moment estimation)：将Momentum和RMSprop结合起来。

　　具体算法：　

　　v_{dW = 0}，S_{dW = 0},  v_db = 0，S_db = 0

　　对于每一步的迭代：

　　　　计算当前mini-batch的梯度dW, db。

　　　　v_dW = β₁v_dW + (1-β₁)dW，v_db = β₁v_db + (1-β₁)db  # β₁对应Momentum。

　　　　S_dW = β₂S_dW + (1-β₂)dW² ， S_db = β₂v_db + (1-β₂)db²  # β₂对应RMSprop。

　　　　v_{dW_corrected} = v_dW / (1 - β₁^t)，v_{db_corrected} = v_db / (1 - β₁^t)，

　　　　S_{dW_corrected} = S_dW / (1 - β₂^t)，S_{db_corrected} = S_db / (1 - β₂^t)，

　　　　W = W - αv_{dW_corrected} / (sqrt(S_{dW_corrected})+ε), b = b - αv_{db_corrected} / (sqrt(S_{db_corrected})+ε)

　　超参数：α需要调试，β₁可以设为0.9，β₂可以设为0.999，ε可以设为e-8。一般大家都只调α，另外几个就按照默认值。

　　Adam非常非常牛逼，默认选项。

6. 学习率衰减(Learning rate decay)：

　　1 epoch的意思是遍历一次数据集。

　　一种典型的decay方法：α = α₀ / (1+decay_rate*epoch_num)，decay_rate是另一个需要调的超参数。

　　其他decay方法：α = 0.95^epoch_numα_0；α = k*α₀ / sqrt(epoch_num)；α = k*α₀ / sqrt(t)，t是迭代次数；还有分段离散衰减的。

　　NG说学习率衰减并不是他优先考虑的东西，他优先还是选一个好一些的固定的α。

7. 深度学习中的局部最优：

　　传统的理解中，局部最优是要避免的。但是在深度学习优化的问题里（比如有2万个参数，或者说在2万维的空间），梯度为0的点往往并不是局部最优，而是鞍点。NG说：我们对低纬度空间的大部分直觉不能应用到高纬度空间中。所以深度学习的优化中，并不担心陷入局部最优，而是担心在平稳段（导数在很大的区域都接近0）优化变慢。Momentum、RMSprop、Adam等算法可以加速对平稳段的优化。