【神经网络学习笔记】梯度下降优化算法

神经网络优化算法

本文优化算法将分为两步，首先是分割数据集，然后再选择梯度下降的优化算法，同时比较各种优化算法的效果。使用的优化算法如下：

• mini-batch梯度下降法
• Momentum梯度下降法
• Adam算法

一、前期准备

1.1导入包

import numpy as np
import matplotlib.pyplot as plt
import testCase
import opt_utils
import math

1.2普通梯度下降更新参数

我们先来实现一个最普通的更新参数的函数，因为之前已经实现过很多次了，这里不多加赘述。

def update_parameters_with_gd(parameters,grads,learning_rate):
    L = len(parameters) // 2
    for k in range(L):
        parameters["W" + str(k + 1)] = parameters["W" + str(k + 1)] - learning_rate * grads["dW" + str(k + 1)]
        parameters["b" + str(k + 1)] = parameters["b" + str(k + 1)] - learning_rate * grads["db" + str(k + 1)]

    return parameters

1.3mini-batch梯度下降法

小批量梯度下降法是一种综合了梯度下降法和随机梯度下降法的方法，在它的每次迭代中，将所有数据集分割为一小块一小块的来学习，随机选取一小块。这样做一方面能充分利用GPU的并行性，另一方面，不会让计算时间特别长，如下图比较：

可以看见使用mini-batch后，下降更加平滑，速度更快。

这个方法比较简单，只需要两步。第一步把训练集打乱，如图：

第二步再给训练集分块，这里是将64个数据放到一块：

直接上代码就懂了~！

# 1.mini-batch梯度下降
def random_mini_batches(X,Y,mini_batch_size,seed=0):
    """
    参数：
        mini_batch_size - 每个mini_batch的样本数量
    返回：
        mini-bacthers - 一个同步列表，维度为（mini_batch_X,mini_batch_Y）
    """
    np.random.seed(seed)
    m = X.shape[1]
    mini_batches = []

    # step1.打乱顺序
    permutation = list(np.random.permutation(m))
    shuffled_X = X[:,permutation]
    shuffled_Y = Y[:,permutation].reshape((1,m))

    # step2.分割
    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 % mini_batch_size != 0:
        # 获取最后剩余部分
        mini_batch_X = shuffled_X[:,mini_batch_size * num_complete_minibatches:]
        mini_batch_Y = shuffled_Y[:,mini_batch_size * num_complete_minibatches:]

        mini_batch = (mini_batch_X,mini_batch_Y)
        mini_batches.append(mini_batch)

    return mini_batches

测试一下：

print("-------------测试random_mini_batches-------------")
X_assess,Y_assess,mini_batch_size = testCase.random_mini_batches_test_case()
mini_batches = random_mini_batches(X_assess,Y_assess,mini_batch_size)

print("第1个mini_batch_X 的维度为：",mini_batches[0][0].shape)
print("第1个mini_batch_Y 的维度为：",mini_batches[0][1].shape)
print("第2个mini_batch_X 的维度为：",mini_batches[1][0].shape)
print("第2个mini_batch_Y 的维度为：",mini_batches[1][1].shape)
print("第3个mini_batch_X 的维度为：",mini_batches[2][0].shape)
print("第3个mini_batch_Y 的维度为：",mini_batches[2][1].shape)

-------------测试random_mini_batches-------------
第1个mini_batch_X 的维度为： (12288, 64)
第1个mini_batch_Y 的维度为： (1, 64)
第2个mini_batch_X 的维度为： (12288, 64)
第2个mini_batch_Y 的维度为： (1, 64)
第3个mini_batch_X 的维度为： (12288, 20)
第3个mini_batch_Y 的维度为： (1, 20)

1.4Momentum梯度下降法

该方法也可以叫作包含动量的梯度下降，由于小批量（mini-batch）梯度下降只看到了一个子集的参数更新，更新方向有一定的差异，所以小批量梯度下降的路径将“振荡地”走向收敛，使用动量可以减少这些振荡，动量考虑了过去的梯度以平滑更新， 我们将把以前梯度的方向存储在变量$v$中，从形式上讲，这将是前面的梯度的指数加权平均值。我们也可以把V看作是滚下坡的速度，根据山坡的坡度建立动量。

红色箭头显示具有动量的小批量梯度下降一步时所采取的方向,蓝色的点显示每个步骤的梯度方向（相对于当前的小批量）。当然我们不仅要观察梯度，还要让$v$影响梯度，然后朝$v$方向前进一步,尽量让前进的方向指向最小值。既然我们要影响梯度的方向，而梯度需要使用到dW和db，那么我们就要建立一个和dW和db相同结构的变量来影响他们，我们现在来进行初始化：

def initialize_velocity(parameters):
    """
    初始化速度,velocity是一个字典：
        key - "dW1","db1",...,"dWL","dbL"
        values - 与相应的梯度/参数维度相同的值为0的矩阵
    参数：
        parameters - 一个字典，包含了以下参数：
            parameters["W" + str(l)] = Wl
            parameters["b" + str(l)] = bl
    返回:
        v - 一个字典变量，包含了以下参数：
            v["dW" + str(l)] = dWl的速度
            v["db" + str(l)] = dbl的速度
    """
    L = len(parameters) // 2
    v = {}

    for l in range(L):
        v['dW' + str(l+1)] = np.zeros_like(parameters['W' + str(l+1)])
        v["db" + str(l+1)] = np.zeros_like(parameters["b" + str(l+1)])

    return v

这里是将v初始化为0，测试一下：

print("-------------测试initialize_velocity-------------")
parameters = testCase.initialize_velocity_test_case()
v = initialize_velocity(parameters)

print('v["dW1"] = ' + str(v["dW1"]))
print('v["db1"] = ' + str(v["db1"]))
print('v["dW2"] = ' + str(v["dW2"]))
print('v["db2"] = ' + str(v["db2"]))

-------------测试initialize_velocity-------------
v["dW1"] = [[0. 0. 0.]
 [0. 0. 0.]]
v["db1"] = [[0.]
 [0.]]
v["dW2"] = [[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
v["db2"] = [[0.]
 [0.]
 [0.]]

初始化完成，开始影响梯度的方向，使用以下公式：

def update_parameters_with_momentun(parameters,grads,v,beta,learning_rate):
    """
    使用动量更新参数
    参数：
        v - 包含当前速度的字典变量
            v["dW" + str(l)] = ...
            v["db" + str(l)] = ...
        beta - 一个超参数，动量
    """
    L = len(parameters) // 2
    for l in range(1,L+1):
        v["dW" + str(l)] = beta * v['dW' + str(l)] + (1-beta) * grads['dW' + str(l)]
        v["db" + str(l)] = beta * v["db" + str(l)] + (1-beta) * grads["db" + str(l)]

        parameters['W' + str(l)] = parameters['W' + str(l)] - learning_rate * v['dW' + str(l)]
        parameters['b' + str(l)] = parameters['b' + str(l)] - learning_rate * v['db' + str(l)]

    return parameters,v

测试一下：

print("-------------测试update_parameters_with_momentun-------------")
parameters,grads,v = testCase.update_parameters_with_momentum_test_case()
update_parameters_with_momentun(parameters,grads,v,beta=0.9,learning_rate=0.01)

print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
print('v["dW1"] = ' + str(v["dW1"]))
print('v["db1"] = ' + str(v["db1"]))
print('v["dW2"] = ' + str(v["dW2"]))
print('v["db2"] = ' + str(v["db2"]))

-------------测试update_parameters_with_momentun-------------
W1 = [[ 1.62544598 -0.61290114 -0.52907334]
 [-1.07347112  0.86450677 -2.30085497]]
b1 = [[ 1.74493465]
 [-0.76027113]]
W2 = [[ 0.31930698 -0.24990073  1.4627996 ]
 [-2.05974396 -0.32173003 -0.38320915]
 [ 1.13444069 -1.0998786  -0.1713109 ]]
b2 = [[-0.87809283]
 [ 0.04055394]
 [ 0.58207317]]
v["dW1"] = [[-0.11006192  0.11447237  0.09015907]
 [ 0.05024943  0.09008559 -0.06837279]]
v["db1"] = [[-0.01228902]
 [-0.09357694]]
v["dW2"] = [[-0.02678881  0.05303555 -0.06916608]
 [-0.03967535 -0.06871727 -0.08452056]
 [-0.06712461 -0.00126646 -0.11173103]]
v["db2"] = [[0.02344157]
 [0.16598022]
 [0.07420442]]

需要注意的是速度v是用0来初始化的，因此，该算法需要经过几次迭代才能把速度提升上来并开始跨越更大步伐。当beta=0时，该算法相当于是没有使用momentum算法的标准的梯度下降算法。当beta越大的时候，说明平滑的作用越明显。

1.5 Adam算法

Adam算法是训练神经网络中最有效的算法之一，它是RMSProp算法与Momentum算法的结合体。公式如下：

1. 计算梯度的指数加权平均值，将其存储在v(偏差校正前)和vcorrect（偏差矫正后）中。
2. 计算其梯度的平方的指数加权平均值，将其存储在变量s(偏差校正前)和scorrect（偏差校正后）中。
   首先要初始化Adam算法的参数：

def initialize_adam(parameters):
    """
    初始化adam所需参数，v和s，它们都是字典类型的变量，都包含了以下字段：
        - keys: "dW1", "db1", ..., "dWL", "dbL"
        - values：与对应的梯度/参数相同维度的值为零的numpy矩阵

    参数：
        parameters - 包含了以下参数的字典变量：
            parameters["W" + str(l)] = Wl
            parameters["b" + str(l)] = bl
    返回：
        v - 包含梯度的指数加权平均值，字段如下：
            v["dW" + str(l)] = ...
            v["db" + str(l)] = ...
        s - 包含平方梯度的指数加权平均值，字段如下：
            s["dW" + str(l)] = ...
            s["db" + str(l)] = ...
    """
    L = len(parameters) // 2
    v = {}
    s = {}

    for l in range(1,L+1):
        v["dW" + str(l)] = np.zeros_like(parameters["W" + str(l)])
        v["db" + str(l)] = np.zeros_like(parameters["b" + str(l)])

        s["dW" + str(l)] = np.zeros_like(parameters["W" + str(l)])
        s["db" + str(l)] = np.zeros_like(parameters["b" + str(l)])

    return (v,s)

然后就可以根据公式更新参数：

def update_parameters_with_adam(parameters,grads,v,s,t,learning_rate=0.01,beta1=0.9,beta2=0.999,epsilon=1e-8):
    """
    v - Adam的变量，第一个梯度的移动平均值
    s - Adam的变量，平方梯度的移动平均值
    t - 当前迭代次数
    beta1 - 用于第一阶段，使得曲线的Y值不从0开始
    beta2 - RMSprop的一个参数，是超参数
    epsilon - 防止出现除0
    """
    L = len(parameters) // 2
    v_corrected = {}
    s_corrected = {}

    for l in range(L):
        # 梯度的移动平均值,输入："v , grads , beta1",输出：" v "
        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)]

        # 计算第一阶段的偏差修正后的估计值，输入"v , beta1 , t" , 输出："v_corrected"
        v_corrected["dW" + str(l + 1)] = v["dW" + str(l + 1)] / (1 - np.power(beta1, t))
        v_corrected["db" + str(l + 1)] = v["db" + str(l + 1)] / (1 - np.power(beta1, t))

        # 计算平方梯度的移动平均值，输入："s, grads , beta2"，输出："s"
        s["dW" + str(l + 1)] = beta2 * s["dW" + str(l + 1)] + (1 - beta2) * np.square(grads["dW" + str(l + 1)])
        s["db" + str(l + 1)] = beta2 * s["db" + str(l + 1)] + (1 - beta2) * np.square(grads["db" + str(l + 1)])

        # 计算第二阶段的偏差修正后的估计值，输入："s , beta2 , t"，输出："s_corrected"
        s_corrected["dW" + str(l + 1)] = s["dW" + str(l + 1)] / (1 - np.power(beta2, t))
        s_corrected["db" + str(l + 1)] = s["db" + str(l + 1)] / (1 - np.power(beta2, t))

        # 更新参数，输入: "parameters, learning_rate, v_corrected, s_corrected, epsilon". 输出: "parameters".
        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))
        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))

    return (parameters, v, s)

测试一下：

print("-------------测试update_with_parameters_with_adam-------------")
parameters , grads , v , s = testCase.update_parameters_with_adam_test_case()
update_parameters_with_adam(parameters,grads,v,s,t=2)

print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
print('v["dW1"] = ' + str(v["dW1"]))
print('v["db1"] = ' + str(v["db1"]))
print('v["dW2"] = ' + str(v["dW2"]))
print('v["db2"] = ' + str(v["db2"]))
print('s["dW1"] = ' + str(s["dW1"]))
print('s["db1"] = ' + str(s["db1"]))
print('s["dW2"] = ' + str(s["dW2"]))
print('s["db2"] = ' + str(s["db2"]))

-------------测试update_with_parameters_with_adam-------------
W1 = [[ 1.63178673 -0.61919778 -0.53561312]
 [-1.08040999  0.85796626 -2.29409733]]
b1 = [[ 1.75225313]
 [-0.75376553]]
W2 = [[ 0.32648046 -0.25681174  1.46954931]
 [-2.05269934 -0.31497584 -0.37661299]
 [ 1.14121081 -1.09245036 -0.16498684]]
b2 = [[-0.88529978]
 [ 0.03477238]
 [ 0.57537385]]
v["dW1"] = [[-0.11006192  0.11447237  0.09015907]
 [ 0.05024943  0.09008559 -0.06837279]]
v["db1"] = [[-0.01228902]
 [-0.09357694]]
v["dW2"] = [[-0.02678881  0.05303555 -0.06916608]
 [-0.03967535 -0.06871727 -0.08452056]
 [-0.06712461 -0.00126646 -0.11173103]]
v["db2"] = [[0.02344157]
 [0.16598022]
 [0.07420442]]
s["dW1"] = [[0.00121136 0.00131039 0.00081287]
 [0.0002525  0.00081154 0.00046748]]
s["db1"] = [[1.51020075e-05]
 [8.75664434e-04]]
s["dW2"] = [[7.17640232e-05 2.81276921e-04 4.78394595e-04]
 [1.57413361e-04 4.72206320e-04 7.14372576e-04]
 [4.50571368e-04 1.60392066e-07 1.24838242e-03]]
s["db2"] = [[5.49507194e-05]
 [2.75494327e-03]
 [5.50629536e-04]]

二、测试

优化算法写完了，就可以开始测试了，首先把数据集加载进来看看。

train_X, train_Y = opt_utils.load_dataset(is_plot=True)
plt.show()

之前我们是实现过一个三层神经网络的，这里就再写一次，同时加入不同的优化算法。

def model(X,Y,layers_dims,optimizer='gd',learning_rate=0.0007,mini_batch_size=64,
          beta=0.9,beta1=0.9,beta2=0.999,epsilon=1e-8,num_epochs=10000,
          print_cost=True,is_plot=True):
    """
    可以运行在不同优化器模式下的3层神经网络模型
    参数：
        X - 输入数据，维度（2，输入的数据集里面样本数量）
        Y - 与X对应的标签
        layers_dims - 包含层数和节点数量的列表
        optimizer - 选择优化类型【“gd" | "momentum" | "adam"】
        mini_batch_size - 小批量数据集的大小
        beta - 动量优化的一个超参数
        beta1 - 计算梯度后的指数衰减的估计的超参数
        beta2 - 计算平方梯度后的指数衰减的估计的超参数
        epsilon - Adam中避免除0的超参数
        num_epochs - 整个训练集的遍历次数，相当于以前的num_iteration
    """
    L = len(layers_dims)
    costs = []
    # 学习了多少个minibatch
    t = 0
    seed = 10

    # 初始化参数
    parameters = opt_utils.initialize_parameters(layers_dims)

    # 选择优化器
    if optimizer == 'gd':
        pass
    elif optimizer == 'momentum':
        v = initialize_velocity(parameters)
    elif optimizer == 'adam':
        v,s = initialize_adam(parameters)
    else:
        print('optimizer参数出错！！！')
        exit()

    # 开始学习
    for i in range(num_epochs):
        # 定义随机minibatches，每次遍历数据集后增加种子使其重新排列数据
        seed = seed + 1
        minibatches = random_mini_batches(X,Y,mini_batch_size,seed)

        # 从minibatches列表中取出每个分片，为元组
        for minibatch in minibatches:
            minibatch_X,minibatch_Y = minibatch

            # 正向传播
            A3,cache = opt_utils.forward_propagation(minibatch_X,parameters)

            # 计算误差
            cost = opt_utils.compute_cost(A3,minibatch_Y)

            # 反向传播
            grads = opt_utils.backward_propagation(minibatch_X,minibatch_Y,cache)

            # 更新参数
            if optimizer == 'gd':
                parameters = update_parameters_with_gd(parameters,grads,learning_rate)
            elif optimizer == 'momentum':
                parameters,v = update_parameters_with_momentun(parameters,grads,v,beta,learning_rate)
            elif optimizer == 'adam':
                t = t + 1
                parameters,v,s = update_parameters_with_adam(parameters,grads,v,s,t,learning_rate,beta1,beta2,epsilon)

        if i % 100 == 0:
            costs.append(cost)
            if print_cost and i % 1000 == 0:
                print("第" + str(i) + "次遍历整个数据集，当前误差值：" + str(cost))

    if is_plot:
        plt.plot(costs)
        plt.ylabel('cost')
        plt.xlabel('epochs (per 100)')
        plt.title("Learning rate = " + str(learning_rate))
        plt.show()

    return parameters

模型也搭建完成了，接下来就可以真正开始梯度下降测试了

2.1普通梯度下降测试

layers_dims = [train_X.shape[0],5,2,1]
parameters = model(train_X, train_Y, layers_dims)
preditions = opt_utils.predict(train_X,train_Y,parameters)

#绘制分类图
plt.title("Model with Gradient Descent optimization")
axes = plt.gca()
axes.set_xlim([-1.5, 2.5])
axes.set_ylim([-1, 1.5])
opt_utils.plot_decision_boundary(lambda x: opt_utils.predict_dec(parameters, x.T), train_X, train_Y)

第0次遍历整个数据集，当前误差值：0.690735512291113
第1000次遍历整个数据集，当前误差值：0.6852725328458241
第2000次遍历整个数据集，当前误差值：0.6470722240719002
第3000次遍历整个数据集，当前误差值：0.6195245549970402
第4000次遍历整个数据集，当前误差值：0.5765844355950943
第5000次遍历整个数据集，当前误差值：0.6072426395968575
第6000次遍历整个数据集，当前误差值：0.5294033317684576
第7000次遍历整个数据集，当前误差值：0.46076823985930115
第8000次遍历整个数据集，当前误差值：0.465586082399045
第9000次遍历整个数据集，当前误差值：0.4645179722167684

Accuracy: 0.7966666666666666

2.2Momentum梯度下降测试

layers_dims = [train_X.shape[0],5,2,1]
parameters = model(train_X, train_Y, layers_dims,optimizer='momentum')
preditions = opt_utils.predict(train_X,train_Y,parameters)

#绘制分类图
plt.title("Model with Gradient Descent optimization")
axes = plt.gca()
axes.set_xlim([-1.5, 2.5])
axes.set_ylim([-1, 1.5])
opt_utils.plot_decision_boundary(lambda x: opt_utils.predict_dec(parameters, x.T), train_X, train_Y)

第0次遍历整个数据集，当前误差值：0.6907412988351506
第1000次遍历整个数据集，当前误差值：0.6853405261267578
第2000次遍历整个数据集，当前误差值：0.6471448370095255
第3000次遍历整个数据集，当前误差值：0.6195943032076022
第4000次遍历整个数据集，当前误差值：0.5766650344073023
第5000次遍历整个数据集，当前误差值：0.607323821900647
第6000次遍历整个数据集，当前误差值：0.5294761758786997
第7000次遍历整个数据集，当前误差值：0.46093619004872366
第8000次遍历整个数据集，当前误差值：0.465780093701272
第9000次遍历整个数据集，当前误差值：0.4647395967922748

Accuracy: 0.7966666666666666

因为测试样本较少，所以使用动量的效果不明显。

2.3Adam梯度下降测试

layers_dims = [train_X.shape[0],5,2,1]
parameters = model(train_X, train_Y, layers_dims,optimizer='adam')
preditions = opt_utils.predict(train_X,train_Y,parameters)

#绘制分类图
plt.title("Model with Gradient Descent optimization")
axes = plt.gca()
axes.set_xlim([-1.5, 2.5])
axes.set_ylim([-1, 1.5])
opt_utils.plot_decision_boundary(lambda x: opt_utils.predict_dec(parameters, x.T), train_X, train_Y)

第0次遍历整个数据集，当前误差值：0.6905522446113365
第1000次遍历整个数据集，当前误差值：0.18550136438550577
第2000次遍历整个数据集，当前误差值：0.1508304657525321
第3000次遍历整个数据集，当前误差值：0.0744543857099718
第4000次遍历整个数据集，当前误差值：0.1259591565133716
第5000次遍历整个数据集，当前误差值：0.10434443534245483
第6000次遍历整个数据集，当前误差值：0.10067637504120651
第7000次遍历整个数据集，当前误差值：0.031652030135115625
第8000次遍历整个数据集，当前误差值：0.11197273131244206
第9000次遍历整个数据集，当前误差值：0.1979400715246548

Accuracy: 0.94

可以看见使用adam算法后收敛得更快，而曲线更加平滑。

三、总结

可以看到在这次实验中Adam算法的准确率最高，最终呈现的效果最好。在一般情况下Momentum梯度下降也是可以有很好的效果，但由于小的学习率和简单的数据集，所以它的影响不明显，而Adam明显优于小批量梯度下降和具有动量的梯度下降，如果在这个简单的模型上运行更多时间的数据集，这三种方法应该都会产生非常好的结果。

本文参考这里优化算法，工具包什么可以到原文下载哦。