吴恩达深度学习笔记（五） —— 优化算法：Mini-Batch GD、Momentum、RMSprop、Adam、学习率衰减
主要内容：
一.Mini-Batch Gradient descent
二.Momentum
四.RMSprop
五.Adam
六.优化算法性能比较
七.学习率衰减
一.Mini-Batch Gradient descent
1.一般地，有三种梯度下降算法：
1）（Batch ）Gradient Descent，即我们平常所用的。它在每次求梯度的时候用上所有数据集，此种方式适合用在数据集规模不大的情况下。
X = data_input Y = labels parameters = initialize_parameters(layers_dims) for i in range(0, num_iterations): # Forward propagation a, caches = forward_propagation(X, parameters) # Compute cost. cost = compute_cost(a, Y) # Backward propagation. grads = backward_propagation(a, caches, parameters) # Update parameters. parameters = update_parameters(parameters, grads)
2）Stochastic Gradient Descent，它在每次求梯度的时候只用上一个数据，无疑，这种方式对噪声敏感，且梯度的方向往往偏离较大。
X = data_input Y = labels parameters = initialize_parameters(layers_dims) for i in range(0, num_iterations): for j in range(0, m): # Forward propagation a, caches = forward_propagation(X[:,j], parameters) # Compute cost cost = compute_cost(a, Y[:,j]) # Backward propagation grads = backward_propagation(a, caches, parameters) # Update parameters. parameters = update_parameters(parameters, grads)
3）Mini-Batch Gradient Descent，就是是在计算梯度时，仅仅利用数据集中的一部分，而不是全部。这样在忽略了梯度准确性的代价下，提升了梯度下降收敛的速度。mini-batch适合用在数据集规模庞大的时。由此可知，min-batch gradient descent 在 batch gradient descent 和 stochastic gradient descent 这两个极端之前采取了折衷的方式，这样既考虑到了梯度的精确性，又考虑到了训练速度，或许这就是中庸之道。
2.执行min-batch gradient descent之前，需要对数据集进行两步操作
1）Shuffle，即打乱数据集的顺序，以此保证数据集随机地分配到mini-batches中。
2）Partition，即把数据集分成多个大小相等batches，由于数据集大小可能不被batch size整除，所以最后一个batch的大小可能小于batch size。
代码如下：
# GRADED FUNCTION: random_mini_batches 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): ### START CODE HERE ### (approx. 2 lines) 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] ### END CODE HERE ### 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: ### START CODE HERE ### (approx. 2 lines) mini_batch_X = shuffled_X[:,num_complete_minibatches*mini_batch_size:] mini_batch_Y = shuffled_Y[:,num_complete_minibatches*mini_batch_size:] ### END CODE HERE ### mini_batch = (mini_batch_X, mini_batch_Y) mini_batches.append(mini_batch) return mini_batches
二.Momentum
1.由于min-batch GD在一次迭代求梯度时，只是用了部分数据集，这就不可避免地导致了梯度出现了偏差（因为掌握的信息不足以作出最明智的选择），由此使得在梯度下降的过程中出现了轻微震荡，如下图在纵向出现了震荡，而momentum可以很好地解决这个问题。
2.momentum的核心思想就是指数加权平均，最通俗的解释就是：在求当前的梯度时，把前面一部分的梯度也考虑进来，然后通过权值计算求和，最终确定当前的梯度。与普通gradient descent的每次求梯度都是相互独立的不同，momentum对于当前的梯度加入了“经验”的元素，且如果某一轴出现了震荡，那么“正反经验”相互抵消，慢慢地梯度方向也趋于平滑，最终达到消除震荡的效果。
3.那如何用数学表达式去实现momentum呢？如下：
这里引入了v变量，即velocity速度的缩写。那么这个变量与速度又有什么关联？这里或许可以用物理的思想去考虑：dW就是加速度、vdW就是速度。由第一条式子可知，vdW的当前值受到原始速度vdW和加速度dW的加权影响，这样vdW就综合了两者的因素。然后在看第二个式子：W减去学习率乘以vdW，而vdW就是“过往经验”和“当前情况”的综合考虑。
代码如下（v可初始化为0，超级参数 β 一般设置为0.9）：
# GRADED FUNCTION: update_parameters_with_momentum def update_parameters_with_momentum(parameters, grads, v, beta, learning_rate): """ Update parameters using Momentum Arguments: parameters -- python dictionary containing your parameters: parameters['W' + str(l)] = Wl parameters['b' + str(l)] = bl grads -- python dictionary containing your gradients for each parameters: grads['dW' + str(l)] = dWl grads['db' + str(l)] = dbl v -- python dictionary containing the current velocity: v['dW' + str(l)] = ... v['db' + str(l)] = ... beta -- the momentum hyperparameter, scalar learning_rate -- the learning rate, scalar Returns: parameters -- python dictionary containing your updated parameters v -- python dictionary containing your updated velocities """ L = len(parameters) // 2 # number of layers in the neural networks # Momentum update for each parameter for l in range(L): ### START CODE HERE ### (approx. 4 lines) # compute velocities v["dW" + str(l+1)] = beta * v["dW" + str(l+1)] + (1-beta) * grads["dW" + str(l+1)] v["db" + str(l+1)] = beta * v["db" + str(l+1)] + (1-beta) * grads["db" + str(l+1)] # update parameters parameters["W" + str(l+1)] = parameters["W" + str(l+1)] - learning_rate * v["dW" + str(l+1)] parameters["b" + str(l+1)] = parameters["b" + str(l+1)] - learning_rate * v["db" + str(l+1)] ### END CODE HERE ### return parameters, v
3.指数加权平均的偏差修正：指数加权平均有一个问题，细看表达式：
，一般地v初始化为0，β初始化为0.9，所以v一开始是非常小的，要到后面才进入轨道。如下图，绿色曲线是理想中的曲线，但实际的曲线为紫色曲线：
为了解决这个问题，需要引入修正：即在计算完之后，v还有除以一个系数（1-β^t），即 v = v / (1-β^t)，其中t是当前迭代次数。一开始时β^t小于1但接近于1，于是(1-β^t)就是一个比较小的数，v除以它之后，就能够增大数值，随着迭代次数t的增加β^t接近于0，v / (1-β^t) 就约等于v / 1，即在v进入轨道之后，修正就不再其作用，从而起到对前面的值有修正的作用。
四.RMSprop
1.momentum解决震荡的问题，但是所谓精益求精，我们想在距离长的一方向轴上加速，在距离短的一方向轴上减速。如下图，w轴距离长二b轴距离短：
2.根据上图，可以注意到：距离长的一轴，其斜率小（平缓）；距离短的一轴，其斜率大（陡峭）。因此可以：当斜率大时，将斜率除以一个大的数；当斜率小时，反之。RMSprop的具体做法如下：
五.Adam
Adam则是moment和RMSprop的综合（且加入了修正），即能避免震荡，又能自动调速。其数学表达是：
对于上面的几个超级参数，一般如下设置：
初始化v、s（一般初始化为0）：
# GRADED FUNCTION: initialize_adam def initialize_adam(parameters) : """ Initializes v and s as two python dictionaries with: - keys: "dW1", "db1", ..., "dWL", "dbL" - values: numpy arrays of zeros of the same shape as the corresponding gradients/parameters. Arguments: parameters -- python dictionary containing your parameters. parameters["W" + str(l)] = Wl parameters["b" + str(l)] = bl Returns: v -- python dictionary that will contain the exponentially weighted average of the gradient. v["dW" + str(l)] = ... v["db" + str(l)] = ... s -- python dictionary that will contain the exponentially weighted average of the squared gradient. s["dW" + str(l)] = ... s["db" + str(l)] = ... """ L = len(parameters) // 2 # number of layers in the neural networks v = {} s = {} # Initialize v, s. Input: "parameters". Outputs: "v, s". for l in range(L): ### START CODE HERE ### (approx. 4 lines) v["dW" + str(l+1)] = np.zeros( parameters["W" + str(l+1)].shape) v["db" + str(l+1)] = np.zeros( parameters["b" + str(l+1)].shape) s["dW" + str(l+1)] = np.zeros( parameters["W" + str(l+1)].shape) s["db" + str(l+1)] = np.zeros( parameters["b" + str(l+1)].shape) ### END CODE HERE ### return v, s
Adam更新参数：
# GRADED FUNCTION: update_parameters_with_adam def update_parameters_with_adam(parameters, grads, v, s, t, learning_rate = 0.01, beta1 = 0.9, beta2 = 0.999, epsilon = 1e-8): """ Update parameters using Adam Arguments: parameters -- python dictionary containing your parameters: parameters['W' + str(l)] = Wl parameters['b' + str(l)] = bl grads -- python dictionary containing your gradients for each parameters: grads['dW' + str(l)] = dWl grads['db' + str(l)] = dbl v -- Adam variable, moving average of the first gradient, python dictionary s -- Adam variable, moving average of the squared gradient, python dictionary learning_rate -- the learning rate, scalar. beta1 -- Exponential decay hyperparameter for the first moment estimates beta2 -- Exponential decay hyperparameter for the second moment estimates epsilon -- hyperparameter preventing division by zero in Adam updates Returns: parameters -- python dictionary containing your updated parameters v -- Adam variable, moving average of the first gradient, python dictionary s -- Adam variable, moving average of the squared gradient, python dictionary """ L = len(parameters) // 2 # number of layers in the neural networks v_corrected = {} # Initializing first moment estimate, python dictionary s_corrected = {} # Initializing second moment estimate, python dictionary # Perform Adam update on all parameters for l in range(L): # Moving average of the gradients. Inputs: "v, grads, beta1". Output: "v". ### START CODE HERE ### (approx. 2 lines) v["dW" + str(l+1)] = beta1 * v["dW" + str(l+1)] + (1-beta1) * grads["dW" + str(l+1)] v["db" + str(l+1)] = beta1 * v["db" + str(l+1)] + (1-beta1) * grads["db" + str(l+1)] ### END CODE HERE ### # Compute bias-corrected first moment estimate. Inputs: "v, beta1, t". Output: "v_corrected". ### START CODE HERE ### (approx. 2 lines) v_corrected["dW" + str(l+1)] = v["dW" + str(l+1)]/(1-beta1**t) v_corrected["db" + str(l+1)] = v["db" + str(l+1)]/(1-beta1**t) ### END CODE HERE ### # Moving average of the squared gradients. Inputs: "s, grads, beta2". Output: "s". ### START CODE HERE ### (approx. 2 lines) s["dW" + str(l+1)] = beta2 * s["dW" + str(l+1)] + (1-beta2) * grads["dW" + str(l+1)]**2 s["db" + str(l+1)] = beta2 * s["db" + str(l+1)] + (1-beta2) * grads["db" + str(l+1)]**2 ### END CODE HERE ### # Compute bias-corrected second raw moment estimate. Inputs: "s, beta2, t". Output: "s_corrected". ### START CODE HERE ### (approx. 2 lines) s_corrected["dW" + str(l+1)] = s["dW" + str(l+1)]/(1-beta2**t) s_corrected["db" + str(l+1)] = s["db" + str(l+1)]/(1-beta2**t) ### END CODE HERE ### # Update parameters. Inputs: "parameters, learning_rate, v_corrected, s_corrected, epsilon". Output: "parameters". ### START CODE HERE ### (approx. 2 lines) parameters["W" + str(l+1)] = parameters["W" + str(l+1)] - learning_rate * v_corrected["dW" + str(l+1)]/(s_corrected["dW" + str(l+1)]+epsilon)**0.5 parameters["b" + str(l+1)] = parameters["b" + str(l+1)] - learning_rate * v_corrected["db" + str(l+1)]/(s_corrected["db" + str(l+1)]+epsilon)**0.5 ### END CODE HERE ### return parameters, v, s
六.优化算法性能比较
接下来分别用mini-batch gradient descent 、 momentum 、 Adam 来对模型进行训练，并比较三者的性能。
模型如下（需要接收一个参数更新的方式）：
# GRADED FUNCTION: update_parameters_with_adam def update_parameters_with_adam(parameters, grads, v, s, t, learning_rate = 0.01, beta1 = 0.9, beta2 = 0.999, epsilon = 1e-8): """ Update parameters using Adam Arguments: parameters -- python dictionary containing your parameters: parameters['W' + str(l)] = Wl parameters['b' + str(l)] = bl grads -- python dictionary containing your gradients for each parameters: grads['dW' + str(l)] = dWl grads['db' + str(l)] = dbl v -- Adam variable, moving average of the first gradient, python dictionary s -- Adam variable, moving average of the squared gradient, python dictionary learning_rate -- the learning rate, scalar. beta1 -- Exponential decay hyperparameter for the first moment estimates beta2 -- Exponential decay hyperparameter for the second moment estimates epsilon -- hyperparameter preventing division by zero in Adam updates Returns: parameters -- python dictionary containing your updated parameters v -- Adam variable, moving average of the first gradient, python dictionary s -- Adam variable, moving average of the squared gradient, python dictionary """ L = len(parameters) // 2 # number of layers in the neural networks v_corrected = {} # Initializing first moment estimate, python dictionary s_corrected = {} # Initializing second moment estimate, python dictionary # Perform Adam update on all parameters for l in range(L): # Moving average of the gradients. Inputs: "v, grads, beta1". Output: "v". ### START CODE HERE ### (approx. 2 lines) v["dW" + str(l+1)] = beta1 * v["dW" + str(l+1)] + (1-beta1) * grads["dW" + str(l+1)] v["db" + str(l+1)] = beta1 * v["db" + str(l+1)] + (1-beta1) * grads["db" + str(l+1)] ### END CODE HERE ### # Compute bias-corrected first moment estimate. Inputs: "v, beta1, t". Output: "v_corrected". ### START CODE HERE ### (approx. 2 lines) v_corrected["dW" + str(l+1)] = v["dW" + str(l+1)]/(1-beta1**t) v_corrected["db" + str(l+1)] = v["db" + str(l+1)]/(1-beta1**t) ### END CODE HERE ### # Moving average of the squared gradients. Inputs: "s, grads, beta2". Output: "s". ### START CODE HERE ### (approx. 2 lines) s["dW" + str(l+1)] = beta2 * s["dW" + str(l+1)] + (1-beta2) * grads["dW" + str(l+1)]**2 s["db" + str(l+1)] = beta2 * s["db" + str(l+1)] + (1-beta2) * grads["db" + str(l+1)]**2 ### END CODE HERE ### # Compute bias-corrected second raw moment estimate. Inputs: "s, beta2, t". Output: "s_corrected". ### START CODE HERE ### (approx. 2 lines) s_corrected["dW" + str(l+1)] = s["dW" + str(l+1)]/(1-beta2**t) s_corrected["db" + str(l+1)] = s["db" + str(l+1)]/(1-beta2**t) ### END CODE HERE ### # Update parameters. Inputs: "parameters, learning_rate, v_corrected, s_corrected, epsilon". Output: "parameters". ### START CODE HERE ### (approx. 2 lines) parameters["W" + str(l+1)] = parameters["W" + str(l+1)] - learning_rate * v_corrected["dW" + str(l+1)]/(s_corrected["dW" + str(l+1)]+epsilon)**0.5 parameters["b" + str(l+1)] = parameters["b" + str(l+1)] - learning_rate * v_corrected["db" + str(l+1)]/(s_corrected["db" + str(l+1)]+epsilon)**0.5 ### END CODE HERE ### return parameters, v, s
1）mini-batch gradient descent
可见其代价函数抖动得比较厉害，可能这是“mini-batch”这种选取部分数据的方式所无法避免的吧。而且准确率也不高。
2）momentum
momentum居然跟mini-batch gradient descent 的效果无异，在进行理论解释时明明是那么的美好，为什么会这样？
3）Adam
Adam不仅收敛速度快，而且震荡也较之不明显，更重要的是准确率高，性能明显优于mini-batch gradient descent 、 momentum。由此可见，在梯度下降的优化算法方面，Adam做得十分出色！
七.学习率衰减
1.在使用min-batch gradient descent的时候，由于没有使用到全部数据（或者说batch里面存在噪声），梯度下降时方向很可能不是指向局部最优点，而是有些偏差，就像一个醉汉一样颠颠簸簸地往前走，如下图：
2.在靠近局部走优点的过程中，应该逐渐降低学习率，即以更细的步伐行走，才能更加精确地靠近局部最优点。其过程如下图的绿色曲线：
