【连载】深度学习笔记6：神经网络优化算法之从SGD到Adam

Game

      从前面的学习中，带大家一起学会了如何手动搭建神经网络，以及神经网络的正则化等实用层面的内容。这些都使得我们能够更深入的理解神经网络的机制，而并不是初次接触深度学习就上手框架，虽然对外宣称神经网络是个黑箱机制，但是作为学习者我们极度有必要搞清楚算法在每个环节到底都干了些什么。

      今天讲的是深度学习的一个大的主题——优化算法。采用何种方式对损失函数进行迭代优化，这是机器学习的一大主题之一，当一个机器学习问题有了具体的模型和评估策略，所有的机器学习问题都可以形式化为一个最优化问题。这也是为什么我们说优化理论和凸优化算法等学科是机器学习一大支柱的原因所在。从纯数学的角度来看，所有的数学模型尽管形式不一，各有头面，但到最后几乎到可以归约为最优化问题。所以，有志于奋战在机器学习和深度学习领域的各位，学好最优化，责无旁贷啊。

      要说机器学习和深度学习的优化算法，梯度下降必然是核心所在。神经网络发展至今，优化算法层出不穷，但大底是出不了梯度下降的框框架架。这一篇笔记，笔者就和大家一起学习和回顾深度学习中常用的优化算法。在前面手动搭建神经网络的代码实践中，我们对于损失函数的优化采用了一般的梯度下降法，所以本篇总结就从梯度下降法开始。

梯度下降法 Gradient Descent

      想必大家对于梯度下降是很熟悉了，选择负梯度方向进行参数更新算是常规操作了。话不多说，对于多层神经网络如何执行梯度下降：

1. def update_parameters_with_gd(parameters, grads, learning_rate):
   
2.     """
   
3.     Update parameters using one step of gradient descent
   
4. 
   
5.     Arguments:
   
6.     parameters -- python dictionary containing your parameters to be updated:
   
7.                     parameters['W' + str(l)] = Wl
   
8.                     parameters['b' + str(l)] = bl
   
9.     grads -- python dictionary containing your gradients to update each parameters:
   
10.                     grads['dW' + str(l)] = dWl
    
11.                     grads['db' + str(l)] = dbl
    
12.     learning_rate -- the learning rate, scalar.
    
13.     Returns:
    
14.     parameters -- python dictionary containing your updated parameters
    
15.     """
    
16.     L = len(parameters) // 2 # number of layers in the neural networks
    
17.     # Update rule for each parameter
    
18.     for l in range(L):  
    
19.         parameters['W' + str(l+1)] = parameters['W' + str(l+1)] - learning_rate * grads['dW' + str(l+1)]
    
20.         parameters['b' + str(l+1)] = parameters['b' + str(l+1)] - learning_rate * grads['db' + str(l+1)]  
    
21.     return parameters

复制代码

      在上述代码中，我们传入含有权值和偏置的字典、梯度字段和更新的学习率作为参数，按照开头的公式编写权值更新代码，一个简单的多层网络的梯度下降算法就写出来了。

小批量梯度下降法 mini-batch Gradient Descent

      在工业数据环境下，直接对大数据执行梯度下降法训练往往处理速度缓慢，这时候将训练集分割成小一点的子集进行训练就非常重要了。这个被分割成的小的子集就叫做 mini-batch，意为小批量。对每一个小批量同时执行梯度下降会大大提高训练效率。在实际利用代码实现的时候，小批量梯度下降算法通常包括两个步骤：充分打乱数据（shuffle）和分组组合数据(partition)。如下图所示。

shuffle

partition

      具体代码实现为：

1. def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):
   
2.     """
   
3.     Creates a list of random minibatches from (X, Y)
   
4. 
   
5.     Arguments:
   
6.     X -- input data, of shape (input size, number of examples)
   
7.     Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (1, number of examples)
   
8.     mini_batch_size -- size of the mini-batches, integer
   
9. 
   
10.     Returns:
    
11.     mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)
    
12.     """
    
13. 
    
14.     np.random.seed(seed)        
    
15.     m = X.shape[1]                 
    
16.     mini_batches = []    # Step 1: Shuffle (X, Y)
    
17.     permutation = list(np.random.permutation(m))
    
18.     shuffled_X = X[:, permutation]
    
19.     shuffled_Y = Y[:, permutation].reshape((1,m))    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.
    
20.     num_complete_minibatches = math.floor(m/mini_batch_size)
    
21.     for k in range(0, num_complete_minibatches):
    
22.         mini_batch_X = shuffled_X[:, 0:mini_batch_size]
    
23.         mini_batch_Y = shuffled_Y[:, 0:mini_batch_size]
    
24. 
    
25.         mini_batch = (mini_batch_X, mini_batch_Y)
    
26.         mini_batches.append(mini_batch)    # Handling the end case (last mini-batch < mini_batch_size)
    
27.     if m % mini_batch_size != 0:
    
28.         mini_batch_X = shuffled_X[:, 0: m-mini_batch_size*math.floor(m/mini_batch_size)]
    
29.         mini_batch_Y = shuffled_Y[:, 0: m-mini_batch_size*math.floor(m/mini_batch_size)]
    
30. 
    
31.         mini_batch = (mini_batch_X, mini_batch_Y)
    
32.         mini_batches.append(mini_batch)   
    
33.     return mini_batches

复制代码

      小批量梯度下降的实现思路非常清晰，先打乱数据在分组数据，需要注意的细节在于最后一个小批量所含的训练样本数，通常而言最后一个小批量会少于前面批量所含样本数。

随机梯度下降 Stochastic Gradient Descent

      当小批量所含的训练样本数为 1 的时候，小批量梯度下降法就变成了随机梯度下降法（SGD）。SGD虽然以单个样本为训练单元训练速度会很快，但牺牲了向量化运算所带来的便利性，在较大数据集上效率并不高。
      我们可以看一下梯度下降和随机梯度下降在实现上的差异：

1. # GD
   
2. X = data_input
   
3. Y = labels
   
4. parameters = initialize_parameters(layers_dims)
   
5. for i in range(0, num_iterations):    # Forward propagation
   
6.     a, caches = forward_propagation(X, parameters)    # Compute cost.
   
7.     cost = compute_cost(a, Y)    # Backward propagation.
   
8.     grads = backward_propagation(a, caches, parameters)    # Update parameters.
   
9.     parameters = update_parameters(parameters, grads)
   
10. 
    
11. # SGDX = data_input
    
12. Y = labels
    
13. parameters = initialize_parameters(layers_dims)
    
14. for i in range(0, num_iterations):   
    
15.     for j in range(0, m):        # Forward propagation
    
16.         a, caches = forward_propagation(X[:,j], parameters)        # Compute cost
    
17.         cost = compute_cost(a, Y[:,j])        # Backward propagation
    
18.         grads = backward_propagation(a, caches, parameters)        # Update parameters.
    
19.         parameters = update_parameters(parameters, grads)

复制代码

      所以，从本质上看，梯度下降法、小批量梯度下降法和随机梯度下降法，并没有区别。唯一的区别就在于它们执行一次训练过程所需要用到的训练样本数。梯度下降法用到的是全集训练数据，随机梯度下降则是单个样本数据，而小批量则是介于二者之间。

带动量的梯度下降法（momentum）

      正如上图中看到的一样，我们假设梯度下降的横向为参数 W 的下降方向，而偏置 b 的下降方向为纵轴，我们总是希望在纵轴上的震荡幅度小一点，学习速度慢一点，而在横轴上学习速度快一点，无论是小批量梯度下降还是随机梯度下降，好像都不能避免这个问题。为了解决这个问题，带动量的梯度下降法来了。带动量的梯度下降考虑历史梯度的加权平均值作为速率进行优化。执行公式如下：

      根据上述公式编写带动量的梯度下降法实现代码：

1. def update_parameters_with_momentum(parameters, grads, v, beta, learning_rate):
   
2.     """
   
3.     Update parameters using Momentum
   
4. 
   
5.     Arguments:
   
6.     parameters -- python dictionary containing your parameters:
   
7.                     parameters['W' + str(l)] = Wl
   
8.                     parameters['b' + str(l)] = bl
   
9.     grads -- python dictionary containing your gradients for each parameters:
   
10.                     grads['dW' + str(l)] = dWl
    
11.                     grads['db' + str(l)] = dbl
    
12.     v -- python dictionary containing the current velocity:
    
13.                     v['dW' + str(l)] = ...
    
14.                     v['db' + str(l)] = ...
    
15.     beta -- the momentum hyperparameter, scalar
    
16.     learning_rate -- the learning rate, scalar
    
17. 
    
18.     Returns:
    
19.     parameters -- python dictionary containing your updated parameters
    
20.     v -- python dictionary containing your updated velocities
    
21.     """
    
22. 
    
23.     L = len(parameters) // 2 # number of layers in the neural networks
    
24. 
    
25.     # Momentum update for each parameter
    
26.     for l in range(L):        # compute velocities
    
27.         v['dW' + str(l+1)] = beta * v['dW' + str(l+1)] + (1-beta)* grads['dW' + str(l+1)]
    
28.         v['db' + str(l+1)] = beta * v['db' + str(l+1)] + (1-beta)* grads['db' + str(l+1)]        # update parameters
    
29.         parameters['W' + str(l+1)] = parameters['W' + str(l+1)] - learning_rate*v['dW' + str(l+1)]
    
30.         parameters['b' + str(l+1)] = parameters['b' + str(l+1)] - learning_rate*v['db' + str(l+1)]
    
31.     return parameters, v

复制代码

      实现带动量的梯度下降的关键点有两个：一是动量是考虑历史梯度进行梯度下降的，二是这里的需要指定的超参数变成了两个：一个是学习率 learning_rate，一个是梯度加权参数beta。

Adam算法

      Adam 全称为 Adaptive Moment Estimation，是在带动量的梯度下降法的基础上融合了一种称为 RMSprop（加速梯度下降）的算法而成的。相较于带动量的梯度下降法，无论是RMSprop 还是 Adam，其中的改进思路都在于如何让横轴上的学习更快以及让纵轴上的学习更慢。RMSprop 和 Adam 在带动量的梯度下降法的基础上，引入了平方梯度，并对速率进行了偏差纠正。具体计算公式如下：

      实现代码如下：

1. def update_parameters_with_adam(parameters, grads, v, s, t, learning_rate = 0.01,
   
2.                                 beta1 = 0.9, beta2 = 0.999,  epsilon = 1e-8):
   
3.     """
   
4.     Update parameters using Adam
   
5. 
   
6.     Arguments:
   
7.     parameters -- python dictionary containing your parameters:
   
8.                     parameters['W' + str(l)] = Wl
   
9.                     parameters['b' + str(l)] = bl
   
10.     grads -- python dictionary containing your gradients for each parameters:
    
11.                     grads['dW' + str(l)] = dWl
    
12.                     grads['db' + str(l)] = dbl
    
13.     v -- Adam variable, moving average of the first gradient, python dictionary
    
14.     s -- Adam variable, moving average of the squared gradient, python dictionary
    
15.     learning_rate -- the learning rate, scalar.
    
16.     beta1 -- Exponential decay hyperparameter for the first moment estimates
    
17.     beta2 -- Exponential decay hyperparameter for the second moment estimates
    
18.     epsilon -- hyperparameter preventing division by zero in Adam updates
    
19. 
    
20.     Returns:
    
21.     parameters -- python dictionary containing your updated parameters
    
22.     v -- Adam variable, moving average of the first gradient, python dictionary
    
23.     s -- Adam variable, moving average of the squared gradient, python dictionary
    
24.     """
    
25. 
    
26.     L = len(parameters) // 2                 
    
27.     v_corrected = {}                        
    
28.     s_corrected = {}                        
    
29. 
    
30.     # Perform Adam update on all parameters
    
31.     for l in range(L):
    
32.         v["dW" + str(l+1)] = beta1 * v["dW" + str(l+1)] + (1 - beta1) * grads['dW'+str(l+1)]
    
33.         v["db" + str(l+1)] = beta1 * v["db" + str(l+1)] + (1 - beta1) * grads['db'+str(l+1)]        # Compute bias-corrected first moment estimate. Inputs: "v, beta1, t". Output: "v_corrected".   
    
34.         v_corrected["dW" + str(l+1)] = v["dW" + str(l+1)] / (1 - beta1**t)
    
35.         v_corrected["db" + str(l+1)] = v["db" + str(l+1)] / (1 - beta1**t)        # Moving average of the squared gradients. Inputs: "s, grads, beta2". Output: "s".
    
36.         s["dW" + str(l+1)] = beta2 * s["dW" + str(l+1)] + (1 - beta2) * (grads["dW" + str(l+1)])**2
    
37.         s["db" + str(l+1)] = beta2 * s["db" + str(l+1)] + (1 - beta2) * (grads["db" + str(l+1)])**2
    
38. 
    
39. 
    
40.         # Compute bias-corrected second raw moment estimate. Inputs: "s, beta2, t". Output: "s_corrected".
    
41.         s_corrected["dW" + str(l+1)] = s["dW" + str(l+1)] / (1 - beta2**t)
    
42.         s_corrected["db" + str(l+1)] = s["db" + str(l+1)] / (1 - beta2**t)        # Update parameters. Inputs: "parameters, learning_rate, v_corrected, s_corrected, epsilon". Output: "parameters".
    
43. 
    
44.         parameters["W" + str(l+1)] = parameters["W" + str(l+1)] - learning_rate * v_corrected["dW" + str(l+1)] / (np.sqrt(s_corrected["dW" + str(l+1)]) + epsilon)
    
45.         parameters["b" + str(l+1)] = parameters["b" + str(l+1)] - learning_rate * v_corrected["db" + str(l+1)] / (np.sqrt(s_corrected["db" + str(l+1)]) + epsilon)   
    
46.     return parameters, v, s

复制代码

      除了以上这些算法，还有一些像 Adadelta 之类的算法我们没有提到，有需要了解的同学可以自行查找相关资料。最后用一个图来展示各种优化算法的效果：

本文来自《自兴动脑人工智能》项目部：凯文

morinson

赞