吴恩达课后作业学习2-week1-1 初始化

2022-10-24 19:53:26

参考：https://blog.csdn.net/u013733326/article/details/79847918

希望大家直接到上面的网址去查看代码，下面是本人的笔记

初始化、正则化、梯度校验

1. 初始化参数：
    1.1：使用0来初始化参数。
    1.2：使用随机数来初始化参数。
    1.3：使用抑梯度异常初始化参数（参见视频中的梯度消失和梯度爆炸）。
2. 正则化模型：
    2.1：使用二范数对二分类模型正则化——L2正则化方法，尝试避免过拟合。
    2.2：使用随机删除节点的方法——dropout正则化方法精简模型，同样是为了尝试避免过拟合。
3. 梯度校验：对模型使用梯度校验，检测它是否在梯度下降的过程中出现误差过大的情况。

1.导入相关的库

import numpy as np

import matplotlib.pyplot as plt

import sklearn

import sklearn.datasets

import init_utils   #第一部分，初始化

import reg_utils    #第二部分，正则化

import gc_utils     #第三部分，梯度校验

#%matplotlib inline #如果你使用的是Jupyter Notebook，请取消注释。

plt.rcParams['figure.figsize'] = (7.0, 4.0) # set default size of plots

plt.rcParams['image.interpolation'] = 'nearest'

plt.rcParams['image.cmap'] = 'gray'

警告：

/Users/user/pytorch/jupyter/-week1/reg_utils.py:: SyntaxWarning: assertion is always true, perhaps remove parentheses?

  assert(parameters['W' + str(l)].shape == layer_dims[l], layer_dims[l-])

/Users/user/pytorch/jupyter/-week1/reg_utils.py:: SyntaxWarning: assertion is always true, perhaps remove parentheses?

  assert(parameters['W' + str(l)].shape == layer_dims[l], )

2.导入数据

train_X, train_Y, test_X, test_Y = init_utils.load_dataset(is_plot=True)

执行返回图示：

该神经网络目标：建立一个分类器将蓝点和红点分开，建立一个三层网络LINEAR ->RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID

3.初始化参数

首先可见神经网络模型为：

def model(X,Y,learning_rate=0.01,num_iterations=,print_cost=True,initialization="he",is_polt=True):

    """

    实现一个三层的神经网络：LINEAR ->RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID

    参数：

        X - 输入的数据，维度为(, 要训练/测试的数量)

        Y - 标签，表示输入为红点还是蓝点【 | 】，维度为(，对应的是输入的数据的标签)

        learning_rate - 学习速率

        num_iterations - 迭代的次数

        print_cost - 是否打印成本值，每迭代1000次打印一次

        initialization - 字符串类型，初始化的类型【"zeros" | "random" | "he"】

        is_polt - 是否绘制梯度下降的曲线图

    返回

        parameters - 学习后的参数

    """

    grads = {}

    costs = []

    m = X.shape[] #训练/测试的数量

    layers_dims = [X.shape[],,,] #设置神经网络层数

    #选择初始化参数的类型

    if initialization == "zeros":

        parameters = initialize_parameters_zeros(layers_dims)

    elif initialization == "random":

        parameters = initialize_parameters_random(layers_dims)

    elif initialization == "he":

        parameters = initialize_parameters_he(layers_dims)

    else :

        print("错误的初始化参数！程序退出")

        exit

    #开始学习

    for i in range(,num_iterations):

        #前向传播

        a3 , cache = init_utils.forward_propagation(X,parameters)

        #计算成本

        cost = init_utils.compute_loss(a3,Y)

        #反向传播

        grads = init_utils.backward_propagation(X,Y,cache)

        #更新参数

        parameters = init_utils.update_parameters(parameters,grads,learning_rate)

        #记录成本

        if i %  == :

            costs.append(cost)

            #打印成本

            if print_cost:

                print("第" + str(i) + "次迭代，成本值为：" + str(cost))

    #学习完毕，绘制成本曲线

    if is_polt:

        plt.plot(costs)

        plt.ylabel('cost')

        plt.xlabel('iterations (per hundreds)')

        plt.title("Learning rate =" + str(learning_rate))

        plt.show()

    #返回学习完毕后的参数

    return parameters

1）初始化为0

在输入参数中全部初始化为0，参数名为initialization = “zeros”，核心代码：

 parameters['W' + str(l)] = np.zeros((layers_dims[l], layers_dims[l - ]))

代码为：

def initialize_parameters_zeros(layers_dims):

    """

    将模型的参数全部设置为0

    参数：

        layers_dims - 列表，模型的层数和对应每一层的节点的数量

    返回

        parameters - 包含了所有W和b的字典

            W1 - 权重矩阵，维度为（layers_dims[], layers_dims[]）

            b1 - 偏置向量，维度为（layers_dims[],）

            ···

            WL - 权重矩阵，维度为（layers_dims[L], layers_dims[L -]）

            bL - 偏置向量，维度为（layers_dims[L],）

    """

    parameters = {}

    L = len(layers_dims) #网络层数

    for l in range(,L): #即每一层的参数w,b都设置为0

        parameters["W" + str(l)] = np.zeros((layers_dims[l],layers_dims[l-]))

        parameters["b" + str(l)] = np.zeros((layers_dims[l],))

        #使用断言确保我的数据格式是正确的

        assert(parameters["W" + str(l)].shape == (layers_dims[l],layers_dims[l-]))

        assert(parameters["b" + str(l)].shape == (layers_dims[l],))

    return parameters

测试：

parameters = initialize_parameters_zeros([,,]) #三层神经元数量

print("W1 = " + str(parameters["W1"]))

print("b1 = " + str(parameters["b1"]))

print("W2 = " + str(parameters["W2"]))

print("b2 = " + str(parameters["b2"]))

W1 = [[. . .]

 [. . .]]

b1 = [[.]

 [.]]

W2 = [[. .]]

b2 = [[.]]

可以看到W和b全部被初始化为0了，那么我们使用这些参数来训练模型，结果会怎样呢？

parameters = model(train_X, train_Y, initialization = "zeros",is_polt=True)

第0次迭代，成本值为：0.6931471805599453

第1000次迭代，成本值为：0.6931471805599453

第2000次迭代，成本值为：0.6931471805599453

第3000次迭代，成本值为：0.6931471805599453

第4000次迭代，成本值为：0.6931471805599453

第5000次迭代，成本值为：0.6931471805599453

第6000次迭代，成本值为：0.6931471805599453

第7000次迭代，成本值为：0.6931471805599453

第8000次迭代，成本值为：0.6931471805599453

第9000次迭代，成本值为：0.6931471805599453

第10000次迭代，成本值为：0.6931471805599455

第11000次迭代，成本值为：0.6931471805599453

第12000次迭代，成本值为：0.6931471805599453

第13000次迭代，成本值为：0.6931471805599453

第14000次迭代，成本值为：0.6931471805599453

可见成本基本没有变化，说明这个模型根本没有学习

图示为：

查看下预测结果：

print ("训练集:")

predictions_train = init_utils.predict(train_X, train_Y, parameters)

print ("测试集:")

predictions_test = init_utils.predict(test_X, test_Y, parameters)

训练集:

Accuracy: 0.5

测试集:

Accuracy: 0.5

性能确实很差，而且成本并没有真正降低，算法的性能也比随机猜测要好。为什么？让我们看看预测和决策边界的细节：

这里调用init_utils.plot_decision_boundary()函数的时候还是会遇见问题（运行再jupyter notebook时）：

'c' argument has  elements, which is not acceptable for use with 'x' with ...

在init_utils.py函数中更改为：

def plot_decision_boundary(model, X, y):

    # Set min and max values and give it some padding

    x_min, x_max = X[, :].min() - , X[, :].max() +

    y_min, y_max = X[, :].min() - , X[, :].max() +

    h = 0.01

    # Generate a grid of points with distance h between them

    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

    # Predict the function value for the whole grid

    Z = model(np.c_[xx.ravel(), yy.ravel()])

    Z = Z.reshape(xx.shape)

    # Plot the contour and training examples

    plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)

    plt.ylabel('x2')

    plt.xlabel('x1')

    plt.scatter(X[, :], X[, :], c=np.squeeze(y), cmap=plt.cm.Spectral) #更改这里的y

    plt.show()

也没有效果，将该函数直接在jupyter中声明，然后直接调用直接plot_decision_boundary()就不会有问题了

细节检测为：

print("predictions_train = " + str(predictions_train))

print("predictions_test = " + str(predictions_test))

plt.title("Model with Zeros initialization")

axes = plt.gca()

axes.set_xlim([-1.5, 1.5])

axes.set_ylim([-1.5, 1.5])

plot_decision_boundary(lambda x: init_utils.predict_dec(parameters, x.T), train_X, train_Y)

predictions_train = [[                                   

             ]]

predictions_test = [[                                   

                             ]]

图示：

分类失败，该模型预测每个都为0。通常来说，零初始化都会导致神经网络无法打破对称性，最终导致的结果就是无论网络有多少层，最终只能得到和Logistic函数相同的效果。

2）随机初始化

把输入参数设置为随机值，权重初始化为大的随机值。参数名为initialization = “random”，核心代码：

parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - ]) *

为了打破对称性，我们可以随机地把参数赋值。在随机初始化之后，每个神经元可以开始学习其输入的不同功能，这里设置比较大的参数值，因为乘于10，看看会发生什么。

代码：

def initialize_parameters_random(layers_dims):

    """

    参数：

        layers_dims - 列表，模型的层数和对应每一层的节点的数量

    返回

        parameters - 包含了所有W和b的字典

            W1 - 权重矩阵，维度为（layers_dims[], layers_dims[]）

            b1 - 偏置向量，维度为（layers_dims[],）

            ···

            WL - 权重矩阵，维度为（layers_dims[L], layers_dims[L -]）

            b1 - 偏置向量，维度为（layers_dims[L],）

    """

    np.random.seed()               # 指定随机种子

    parameters = {}

    L = len(layers_dims)            # 层数

    for l in range(, L):

        parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - ]) *  #使用10倍缩放

        parameters['b' + str(l)] = np.zeros((layers_dims[l], )) #b仍初始化为0

        #使用断言确保我的数据格式是正确的

        assert(parameters["W" + str(l)].shape == (layers_dims[l],layers_dims[l-]))

        assert(parameters["b" + str(l)].shape == (layers_dims[l],))

    return parameters

测试：

parameters = initialize_parameters_random([, , ])

print("W1 = " + str(parameters["W1"]))

print("b1 = " + str(parameters["b1"]))

print("W2 = " + str(parameters["W2"]))

print("b2 = " + str(parameters["b2"]))

W1 = [[ 17.88628473   4.36509851   0.96497468]

 [-18.63492703  -2.77388203  -3.54758979]]

b1 = [[.]

 [.]]

W2 = [[-0.82741481 -6.27000677]]

b2 = [[.]]

看起来这些参数都是比较大的，我们来看看实际运行会怎么样：

parameters = model(train_X, train_Y, initialization = "random",is_polt=True)

print("训练集：")

predictions_train = init_utils.predict(train_X, train_Y, parameters)

print("测试集：")

predictions_test = init_utils.predict(test_X, test_Y, parameters)

print(predictions_train)

print(predictions_test)

警告：

/Users/user/pytorch/jupyter/-week1/init_utils.py:: RuntimeWarning: divide by zero encountered in log

  logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log( - a3),  - Y)

/Users/user/pytorch/jupyter/-week1/init_utils.py:: RuntimeWarning: invalid value encountered in multiply

  logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log( - a3),  - Y)

第0次迭代，成本值为：inf

第1000次迭代，成本值为：0.6250676215287511

第2000次迭代，成本值为：0.5981418252875961

第3000次迭代，成本值为：0.563858109377261

第4000次迭代，成本值为：0.5501823050061752

第5000次迭代，成本值为：0.5444756668990652

第6000次迭代，成本值为：0.5374638179631746

第7000次迭代，成本值为：0.4770885368883873

第8000次迭代，成本值为：0.397834663330821

第9000次迭代，成本值为：0.3934832163377203

第10000次迭代，成本值为：0.39203323866307854

第11000次迭代，成本值为：0.3892818629893498

第12000次迭代，成本值为：0.3861521882410713

第13000次迭代，成本值为：0.38499297516135134

第14000次迭代，成本值为：0.38280470097181446

训练集：

Accuracy: 0.83

测试集：

Accuracy: 0.86

[[                                   

             ]]

[[                                   

                             ]]

图示：

我们来把图绘制出来，看看分类的结果是怎样的。

plt.title("Model with large random initialization")

axes = plt.gca()

axes.set_xlim([-1.5, 1.5])

axes.set_ylim([-1.5, 1.5])

plot_decision_boundary(lambda x: init_utils.predict_dec(parameters, x.T), train_X, train_Y)

图示：

初始化参数如果没有很好地话会导致梯度消失、爆炸，这也会减慢优化算法。如果我们对这个网络进行更长时间的训练，我们将看到更好的结果，但是使用过大的随机数初始化会减慢优化的速度。

3）抑梯度异常（即梯度爆炸或梯度消失）初始化——最好选择该方法

参见梯度消失和梯度爆炸的那一个视频，参数名为initialization = “he”，核心代码：

parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - ]) * np.sqrt( / layers_dims[l - ])

代码：

def initialize_parameters_he(layers_dims):

    """

    参数：

        layers_dims - 列表，模型的层数和对应每一层的节点的数量

    返回

        parameters - 包含了所有W和b的字典

            W1 - 权重矩阵，维度为（layers_dims[], layers_dims[]）

            b1 - 偏置向量，维度为（layers_dims[],）

            ···

            WL - 权重矩阵，维度为（layers_dims[L], layers_dims[L -]）

            b1 - 偏置向量，维度为（layers_dims[L],）

    """

    np.random.seed()               # 指定随机种子

    parameters = {}

    L = len(layers_dims)            # 层数

    for l in range(, L):

        parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - ]) * np.sqrt( / layers_dims[l - ])

        parameters['b' + str(l)] = np.zeros((layers_dims[l], ))

        #使用断言确保我的数据格式是正确的

        assert(parameters["W" + str(l)].shape == (layers_dims[l],layers_dims[l-]))

        assert(parameters["b" + str(l)].shape == (layers_dims[l],))

    return parameters

测试：

parameters = initialize_parameters_he([, , ])

print("W1 = " + str(parameters["W1"]))

print("b1 = " + str(parameters["b1"]))

print("W2 = " + str(parameters["W2"]))

print("b2 = " + str(parameters["b2"]))

W1 = [[ 1.78862847  0.43650985]

 [ 0.09649747 -1.8634927 ]

 [-0.2773882  -0.35475898]

 [-0.08274148 -0.62700068]]

b1 = [[.]

 [.]

 [.]

 [.]]

W2 = [[-0.03098412 -0.33744411 -0.92904268  0.62552248]]

b2 = [[.]]

这样就基本把参数W初始化到了1附近，我们来实际运行一下看看效果：

parameters = model(train_X, train_Y, initialization = "he",is_polt=True)

print("训练集:")

predictions_train = init_utils.predict(train_X, train_Y, parameters)

print("测试集:")

init_utils.predictions_test = init_utils.predict(test_X, test_Y, parameters)

第0次迭代，成本值为：0.8830537463419761

第1000次迭代，成本值为：0.6879825919728063

第2000次迭代，成本值为：0.6751286264523371

第3000次迭代，成本值为：0.6526117768893807

第4000次迭代，成本值为：0.6082958970572938

第5000次迭代，成本值为：0.5304944491717495

第6000次迭代，成本值为：0.4138645817071794

第7000次迭代，成本值为：0.3117803464844441

第8000次迭代，成本值为：0.23696215330322556

第9000次迭代，成本值为：0.18597287209206836

第10000次迭代，成本值为：0.15015556280371817

第11000次迭代，成本值为：0.12325079292273551

第12000次迭代，成本值为：0.09917746546525935

第13000次迭代，成本值为：0.08457055954024278

第14000次迭代，成本值为：0.07357895962677366

训练集:

Accuracy: 0.9933333333333333

测试集:

Accuracy: 0.96

图示：

可见效果很好，绘制预测情况：

plt.title("Model with He initialization")

axes = plt.gca()

axes.set_xlim([-1.5, 1.5])

axes.set_ylim([-1.5, 1.5])

plot_decision_boundary(lambda x: init_utils.predict_dec(parameters, x.T), train_X, train_Y)

图示：

总结：

不同的初始化方法可能导致性能最终不同
随机初始化有助于打破对称，使得不同隐藏层的单元可以学习到不同的参数。
初始化时，初始值不宜过大。
He初始化搭配ReLU激活函数常常可以得到不错的效果。

在深度学习中，如果数据集没有足够大的话，可能会导致一些过拟合的问题。过拟合导致的结果就是在训练集上有着很高的精确度，但是在遇到新的样本时，精确度下降会很严重。

为了避免过拟合的问题，接下来我们要讲解的方式就是正则化。
接下来可见吴恩达课后作业学习2-week1-2正则化—不发布

码农公寓

相关文章