深层神经网络的优化算法

神经网络发展至今，每天都有新的优化算法被提出，但是鲜有通用性好的优化算法，在课程中吴恩达老师介绍了优化效果和通用性都非常好的几种优化算法：mini-batch梯度下降、momentum梯度下降、RMSprop、Adam算法等等，下面逐一讲诉各算法的原理及程序，最后结合神经网络对比应用各优化算法后性能的改善情况。

程序所需的库文件如下

import numpy as np
import matplotlib.pyplot as plt
import scipy.io
import math
import sklearn
import sklearn.datasets


from opt_utils import *
from testCases_opt import *


plt.rcParams['figure.figsize'] = (7.0, 4.0)
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'

opt_utils和testCases_opt是吴恩达老师给出的辅助程序，可在这里获取。

一、梯度下降法

在构建神经网络的反向传播过程中，我们使用梯度下降法对dW，db等参数进行迭代。

def update_parameters_with_gd(parameters, grads, learning_rate):

    L = len(parameters) // 2

    for l in range(L):

        parameters['W' + str(l+1)] =  parameters['W' + str(l+1)] - learning_rate * \
                                     grads['dW' + str(l+1)]

        parameters['b' + str(l+1)] = parameters['b' + str(l+1)] - learning_rate * \
                                     grads['db' + str(l+1)]
         
    return parameters

通常我们在每次迭代中把样本集中的m个数据一起处理，这种梯度下降就称为batch梯度下降法。

X = data_input
Y = labels
parameters = initialize_parameters(layers_dims)
for i in range(0, num_iterations):

    a, caches = forward_propagation(X, paramters)

    cost = compute_cost(a, Y)

    grads = backward_propagation(a, caches, paramters)

    paramters = update_paramters(paramters, grads)

更极端的例子是每次迭代只处理一个数据，这种方法称为随机梯度下降。

X = data_input
Y = labels
parameters = initialize_parameters(layers_dims)

for i in range(0,num_iterations):

    for j in range(0, m):
        
        a, caches = forward_propagation(X[:,j], paramters)

        cost = compute_cost(a, Y[:,j])

        grads = backward_propagation(a, caches, paramters)

        paramters = update_paramters(paramters, grads)

二、mini-batch梯度下降法

batch梯度下降法适用于样本数量较少（一般少于2000）的情况，因为每次迭代都处理整个训练集的m个样本相当消耗时间，尤其是在数据量非常大的情况下（比如500W），那么我们需要选择mini-batch梯度下降法，将整个训练集分成若干个batch，分批处理。

步骤一：调序。需保持调序后X[i]与Y[i]仍然匹配。

步骤二：划分。通常mini-batch的大小需要根据CPU或者GPU的大小而定，常用大小为：64、128、256、512.

如果样本数量不能被mini-batch-size整除，那么最后一个batch的大小为:

m - mini_batch_size * math.floors(m / mini_batch_size)

def initialize_velocity(parameters):
    L = len(parameters) // 2

    for l in range(L):
        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)

    return v

def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):

    np.random.seed(seed)
    m = X.shape[1]
    mini_batches = []

    permutation = list(np.random.permutation(m))
    shuffled_X = X[:,permutation]
    shuffled_Y = Y[:,permutation].reshape((1,m))

    num_complete_minibatches = math.floor(m / mini_batch_size)
    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)

    if m