这一周的主题是优化算法。
1. Mini-batch：
上一门课讨论的向量化的目的是去掉for循环加速优化计算，X = [x(1) x(2) x(3) ... x(m)]，X的每一个列向量x(i)是一个样本，m是样本个数。但当样本很多时（比如m=500万），向量化依然不能解决问题。所以提出了mini-batch的概念（Batch是指对整个样本都操作，mini-batch指只对所有样本的子集进行操作）。把若干样本合并成一个mini-batch，比如这里选择1000，X{1} = [x(1) x(2) ... x(1000)]，X{2} = [x(1001) x(1002) ... x(2000)]，等等。则我们一共有5000个mini-batch，此时 X = [X{1} X{2} ... X{5000}]。同样的，把输出Y也做这样的操作，得到 Y = [Y{1} Y{2} ... Y{5000}] 。
Notation：x(i)表示第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. 指数加权平均（指数加权移动平均）：
vt = βvt-1 + (1-β)θt 。这个公式可以看成 vt 近似等于 1/(1-β) 个数据的平均值，比如β = 0.9，则近似可以看成是10个数据的平均值。展开来看，vt = (1-β)*θt + (1-β)*β*θt-1 + (1-β)*β2*θt + ...(1-β)*βn*θt ，权重指数衰减。（为什么近似等于1/(1-β) 个数据的平均值？NG解释说，如果β接近1，β1/(1-β)≈1/e=0.37，0.37的权重已经很小了，所以说近似等于 1/(1-β) 个数据的平均值。）
指数加权平均的一大好处是可以迭代计算，占内存很小。相比之下，如果记录过去n个数值，然后算平均数，显然耗内存很多。
偏差矫正：偏差产生的原因是头部缺数据，造成求得的指数加权平均比较小。偏差矫正的公式是 vt / (1 - βt)，注意这里是计算完vt后矫正，而不是在迭代过程中实时矫正。直观地说，如果β大，比如0.98，则需要平均更多的数据，于是1 - βt更小，从而把 vt 放大。
3. Momentum (Gradient descent with momentum)
这种方法几乎总是比标准的梯度下降快。基本想法是：用梯度的指数加权平均数来更新权重。如果优化的问题有大的condition number，则优化过程中，会在一个方向剧烈震荡。这导致我们只能选用小的学习率，降低了优化的速度。如果学习率大，很容易就发散了。我们希望的是在震荡的方向上迭代步长小一点，而在没有震荡的方向上迭代步长大一点。指数加权平均的做法在震荡方向上把数据正负抵消了，所以得到很小的数，而在没有震荡的方向上则持续增加。物理的直观解释是想象一个小球从碗的边沿滚下去，梯度是它的加速度，momentum是它的速度，β是和摩擦力相关的量。相比于标准的梯度下降，当前迭代只与当前梯度相关，而momentum的方法把当前迭代和过往梯度也联系起来。
具体算法：
vdW = 0, vdb = 0
对于每一步的迭代：
计算当前mini-batch的梯度dW, db。
vdW = βvdW + (1-β)dW # NG解释说也有的教材写成 vdW = βvdW + dW，他自己不喜欢这种，因为更难调参数，调β的时候，会再需要调α。
vdb = βvdb + (1-β)db
W = W - αvdW, b = b- αvdb
α和β是超参数，不过经验上看β取0.9是非常不错的。一般人们不用偏差矫正，因为通过初始阶段后就无偏了。
4. RMSprop(Root mean square prop): NG说这个方法最开始是Geoffrey Hinton在coursera的课上提出来的。
具体算法：
SdW = 0, Sdb = 0
对于每一步的迭代：
计算当前mini-batch的梯度dW, db。
SdW = βSdW + (1-β)dW2 # dW2是把向量的每个元素各自平方。
Sdb = βvdb + (1-β)db2
W = W - αdW/(sqrt(SdW)+ε), b = b- αdb/(sqrt(Sdb)+ε) # 分母加上ε为了防止除以0的情况，ε可以随便设一个很小的数，比如e-8
直观地解释：对于震荡的优化方向，S值会比较大，从而更新参数时步长会比较小，从而消除震荡。
5. Adam(Adaptive moment estimation)：将Momentum和RMSprop结合起来。
具体算法：
vdW = 0，SdW = 0, vdb = 0，Sdb = 0
对于每一步的迭代：
计算当前mini-batch的梯度dW, db。
vdW = β1vdW + (1-β1)dW，vdb = β1vdb + (1-β1)db # β1对应Momentum。
SdW = β2SdW + (1-β2)dW2 ， Sdb = β2vdb + (1-β2)db2 # β2对应RMSprop。
vdW_corrected = vdW / (1 - β1t)，vdb_corrected = vdb / (1 - β1t)，
SdW_corrected = SdW / (1 - β2t)，Sdb_corrected = Sdb / (1 - β2t)，
W = W - αvdW_corrected / (sqrt(SdW_corrected)+ε), b = b - αvdb_corrected / (sqrt(Sdb_corrected)+ε)
超参数：α需要调试，β1可以设为0.9，β2可以设为0.999，ε可以设为e-8。一般大家都只调α，另外几个就按照默认值。
Adam非常非常牛逼，默认选项。
6. 学习率衰减(Learning rate decay)：
1 epoch的意思是遍历一次数据集。
一种典型的decay方法：α = α0 / (1+decay_rate*epoch_num)，decay_rate是另一个需要调的超参数。
其他decay方法：α = 0.95epoch_numα0；α = k*α0 / sqrt(epoch_num)；α = k*α0 / sqrt(t)，t是迭代次数；还有分段离散衰减的。
NG说学习率衰减并不是他优先考虑的东西，他优先还是选一个好一些的固定的α。
7. 深度学习中的局部最优：
传统的理解中，局部最优是要避免的。但是在深度学习优化的问题里（比如有2万个参数，或者说在2万维的空间），梯度为0的点往往并不是局部最优，而是鞍点。NG说：我们对低纬度空间的大部分直觉不能应用到高纬度空间中。所以深度学习的优化中，并不担心陷入局部最优，而是担心在平稳段（导数在很大的区域都接近0）优化变慢。Momentum、RMSprop、Adam等算法可以加速对平稳段的优化。