深度学习基础---吴恩达课后编程练习（五）-----优化算法

最新推荐文章于 2024-06-19 21:37:28 发布

wyjxlj666

最新推荐文章于 2024-06-19 21:37:28 发布

阅读量1k

点赞数

本文链接：https://blog.csdn.net/qq_44934596/article/details/127035032

版权

吴恩达深度学习---Course 2 week2---优化算法

5.3 使用mini_batch梯度下降算法

前言

本实验基于吴恩达机器学习Course2_week2的学习视频，对梯度算法进行优化，以达到提高运行速度的目的，使用的优化算法有：mini_batch，Momentum，Adam。参考：http://t.csdn.cn/g5qBa

导入相关库

import numpy as np
import matplotlib.pyplot as plt
import scipy.io     ####scipy是构建numpy的基础上的，提供了许多的操作numpy数组的函数
                    ####scipy.io包提供了多种功能来解决不同格式的文件的输入和输出
import math
import sklearn      ###基于pythin语言的机器学习工具，有六大任务模块，分别是：分类，回归，聚类，降维，模型选择，和预处理
import sklearn.datasets
import opt_utils
import testCase

plt.rcParams['figure.figsize']=(7.0,4.0)  ####设置图像大小
plt.rcParams['image.interpolation']='nearest'      ####最近邻插值，像素为正方形
plt.rcParams['image.cmap']='gray'          ####使用灰度输出

一、不使用任何优化算法

就是普通的梯度下降算法，前面我们都多次用到，公式：

$W^{[l]}$ = $W^{[l]}$ - $\alpha dW^{[l]}$

$b^{[l]}=b^{[l]}-\alpha db^{[l]}$

####简单的梯度下降，没有任何优化算法
def update_parameters_with_gd(parameters,grads,learning_rate):
    """

    Parameters
    ----------
    parameters-----字典，包含了要更新的参数
           parameters['W'+str(l)]=Wl
           parameters['b'+str(l)]=bl

    grads----------包含梯度值，用以更新参数
           grads['dW'+str(l)]=dWl
           grads['db'+str(l)]=dbl

    learning_rate

    Returns
    -------
    parameters-----字典，包含了更新后的参数

    """
    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

二、使用mini_batch优化算法

将训练集分割为小一点的子集训练，这些子集称为mini_batch，mini_batch需要讲过两个步骤：

1. 把训练集打乱，但是X和Y依旧是对应的，乱序步骤确保将样本被随机分成不同的小批次。 kiank_shuffle

2. 我们把训练集打乱之后，我们就可以对它进行切分了。这里切分的大小是64

kiank_partition

#####min-batch梯度下降法：（既加快了下降速度，又减少了波动）
#####1.打乱训练集，但X，Y依旧一一对应
#####2.切分，大小要与CPU内存相符，为2^n次方
def random_mini_batches(X,Y,mini_batch_size=64,seed=0):
    """

    Parameters
    ----------
    X-------维度是（输入节点的数量，样本的数量）
    Y
    mini_batch_size------每个mini_batch的样本数量
    seed

    Returns
    -------
    mini-batchese------一个同步列表，维度为（mini_batch_X,mini_batch_Y）


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

    ######第一步：打乱顺序
    permutation=list(np.random.permutation(m))######生成一个随机数组，且里面的数是0到m-1
    shuffled_X=X[:,permutation]   ###将每一列的数据按permutation的顺序来重新排列
    shuffled_Y = Y[:,permutation].reshape((1,m))  ###将每一列的数据按permutation的顺序来重新排列



   #######第二步：分割
    num_complete_minibatches=math.floor(m/mini_batch_size)
    ####把你的训练集分割成多少份，如果值是99.99，那么返回99，剩下的0.99会被舍弃
    ####math.floor()向下取整
    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)
    #####如果训练集的大小是mini_batches的整数倍，这里就够了
    ####如果不是，我们还要把剩余部分处理了
    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

测试：

#####测试random_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)

说明：

普通梯度算法，一次遍历所有数据集，进行一次梯度下降
mini_batch，一次遍历若干小子集，进行若干次梯度下降
若训练集较小<2000，mini_batch作用小，一般直接用普通的梯度下降
若数目较大，考虑到电脑的内存设置和使用方式，一般的mini_batch的大小为64到512（ $2^{n}$ ）

三、使用Momentum优化算法

mini_batch中每个子集的更新方向不一样，这就导致下降的路径将“振荡地”走向收敛，使用Momentum可以减少这些振荡，动量考虑了过去的梯度以平滑更新。

公式：

初始化：

######包含动量的梯度下降
######由于小批量梯度下降只看到了一个子集的参数更新，更新的方向有一定的差异，所以小批量梯度下降的路径将“振荡的”走向收敛
#####使用动量可以减少这些震荡，，，动量考虑了过去的梯度以平衡更新
####我们将把以前梯度的方向存储在变量v中，从形式上讲，这将是前面的梯度的指数加权平均值
####当然我们不仅要观察梯度，还要让v影响梯度，然后朝v方向前进一步,尽量让前进的方向指向最小值
###既然我们要影响梯度的方向，而梯度需要使用到dW和db，那么我们就要建立一个和dW和db相同结构的变量来影响他们，
# ##我们现在来进行初始化：
def initialize_velocity(parameters):
    """
    初始化速度，velocity是一个字典：
        ---keys:"dW1",db1,......"dWL","dbL"
        ---values:与相应的梯度·、参数维度相同的值为零的矩阵。
    Parameters
    ----------
    parameters

    Returns
    -------
    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)])
        #######维度与parameters相同，且初始化为0
    return v

使用动量更新参数：

#####初始化完成，我们就开始影响梯度的方向
def update_parameters_with_momentun(parameters,grads,v,beta,learning_rate):
    """
    使用动量更新参数
    Parameters
    ----------
    parameters-----包含W,b
    grads----包含dW,db
    v-----包含当前速度
    beta-----超参数动量
    learning_rate------学习率

    Returns
    -------
    parameters----更新后的参数字典
    v------包含了更新的速度变量

    """
    L=len(parameters)//2
    for l in range(L):
        #计算速度
        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)]
        ###更新参数
        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)]

    return parameters,v

测试：

#测试update_parameters_with_momentun
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]]

说明：

beta越大，曲线越平滑
beta一般为0.9，可加快梯度下降

四、使用Adam优化算法

Adam梯度下降算法，是RMSprop算法和Momentum算法的结合

公式：

初始化：

#####Adam算法
####Adam算法结合了RMSprop算法和Momentum算法
###1. 计算以前的梯度的指数加权平均值，并将其存储在变量v和v_corrected
###2.计算以前的梯度的平方的指数加权平均值，并将其存储在变量s和s_corrected
##3.根据1，2更新参数


####初始化Adam所需要的参数
def initialize_adam(parameters):
    """
    初始化V和S
    Parameters
    ----------
    parameters

    Returns
    -------
     v----一个字典变量，包含以下参数：
         v["dW"+str(l)]=dwl的速度
         v["db"+str(l)]=dbl的速度
          v----一个字典变量，包含以下参数：
     s---- 包含平方梯度的指数加权平均值
         s["dW"+str(l)]= dWl的速度的平方
         s["db"+str(l)]=dbl的速度的平方

    """
    L=len(parameters)//2
    v={}
    s={}
    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)])

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

    return (v,s)

用Adam梯度下降算法更新参数：

def update_parameters_with_adam(parameters,grads,v,s,t,learning_rate=0.01,beta1=0.9,beta2=0.999,epsilon=1e-8):
    """
    使用adam更新参数
    Parameters
    ----------
    parameters
    grads
    v-----第一个梯度的移动平均值
    s-----平方梯度的移动平均值
    t----当前迭代的次数
    learning_rate-----学习率
    beta1------动量，超参数
    beta2----RMSProp参数
    epsilon-----防止除零操作

    Returns
    -------
    v
    s

    """

    L = len(parameters) // 2
    v_corrected = {}
    s_corrected = {}

    for l in range(L):
        # 计算速度
        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_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["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_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["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)

测试：

###测试update_parameters_with_adam
#测试update_with_parameters_with_adam
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]]

说明：

beta1 一般取0.9
beta2 一般取0.99
$\varepsilon$ 常为1e-8
学习率learning_rate可尝试取值

五、测试四种梯度下降算法

四个神经网络梯度下降算法都已经做好，现在我们分别放在神经网络中看看效果

5.1 定义神经网络模型

######opt_utils是一个已经写好了的三层神经网络，我们要封装成一个模型
###加载数据集
train_X,train_Y=opt_utils.load_dataset(is_plot=True)
plt.show()

###定义模型
def model(X,Y,layers_dims,optimizer,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):
    """
    可以运行在不同优化器模式下的三层神经网络模型
    Parameters
    ----------
    X
    Y
    layers_dims------包含层数和节点数量
    optimizer-----字符串类型的参数，用于优化类型【“gd”/momentum/"adam"】
    learning_rate
    mini_batch_size
    beta
    beta1
    beta2
    epsilon-----用于adam中避免除零操作的超参数
    num_epochs----整个训练集遍历次数
    print_cost----是否打印误差值
    is_plot-----是否绘制曲线图

    Returns
    -------
    PARAMETERS----包含了学习后的参数

    """
    L=len(layers_dims)
    costs=[]
    t=0    ###每学习完一个minibatch就增加1
    seed=10#####随机种子

    ###初始化参数
    parameters=opt_utils.initialize_parameters(layers_dims)
    ###选择优化器
    if optimizer=="gd":
        parameters = opt_utils.initialize_parameters(layers_dims) ###不使用任何优化器，直接使用梯度下降算法
    elif optimizer=="momentum":
        v=initialize_velocity(parameters) ###使用动量
    elif optimizer == "adam":
        v,s=initialize_adam(parameters)  ###使用Adam优化
    else:
        print("参数错误")
        exit(1)

    ###开始学习
    for i in range(num_epochs):
        ###定义随机minibatches,我们在每次遍历数据集之后增加种子以重新排列数据集，使每次数据的顺序都不同
        seed=seed+1
        mini_batches=random_mini_batches(X,Y,mini_batch_size,seed)
        #####选择mini_batch,一次遍历数据集就能够进行num次梯度下降
        for mini_batch in mini_batches:
            (mini_batch_X,mini_batch_Y)=mini_batch
            ###前向传播
            a3,cache=opt_utils.forward_propagation(mini_batch_X,parameters)
            ###计算误差
            cost=opt_utils.compute_cost(a3,mini_batch_Y)
            ###反向传播
            grads=opt_utils.backward_propagation(mini_batch_X,mini_batch_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

数据集：

5.2 不使用任何优化算法

这里直接将mini_batch_size设置成了数据集的大小，一次遍历就覆盖了整个数据集

#####使用普通的梯度下降
layers_dims=[train_X.shape[0],5,2,1]
m=train_X.shape[1]
parameters=model(train_X,train_Y,layers_dims,optimizer="gd",mini_batch_size=m,is_plot=True)
#预测
predictions=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)

结果：

5.3 使用mini_batch梯度下降算法

这里mini_batch_size默认为64，即划分了若干个大小为64的子集，一次遍历就可以经历若干个的梯度下降。

#####使用普通的梯度下降
layers_dims=[train_X.shape[0],5,2,1]
parameters=model(train_X,train_Y,layers_dims,optimizer="gd",is_plot=True)
#预测
predictions=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)

结果：

5.3 使用Momentum梯度下降算法

这里是在使用了mini_batch对数据集进行划分之后，进一部对梯度下降算法进行了优化，使用了Momentum

####momentumn梯度下降法
#####具有动量的梯度下降通常可以有很好的效果，但是由于小的学习速率和简单的数据集。所以它的影响不起作用了
layers_dims=[train_X.shape[0],5,2,1]
parameters=model(train_X,train_Y,layers_dims,optimizer="momentum",is_plot=True)
predictions=opt_utils.predict(train_X,train_Y,parameters)
plt.title("Model with Momentum 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)

结果：

5.4 使用Adam梯度下降算法

同样的这里在使用了mini_batch的基础上，进一步用来Adam对梯度下降进行优化（定义的模型是这样写的，，把梯度下降选择放在了mini_batch的循环里）

#####Adam优化算法
layers_dims=[train_X.shape[0],5,2,1]
parameters=model(train_X,train_Y,layers_dims,optimizer="adam",is_plot=True)
predictions=opt_utils.predict(train_X,train_Y,parameters)
plt.title("Model with Adam 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)

结果：