Course 2 改善深层神经网络 Week 1 零初始化、随机初始化和抑梯度异常初始化（He initialization）

最新推荐文章于 2024-04-16 12:53:51 发布
最新推荐文章于 2024-04-16 12:53:51 发布
阅读量842 收藏 3
点赞数
分类专栏： 深度学习 文章标签： He initialization 随机初始化 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Reanon/article/details/100006178
版权

开始之前

选用合适的初始化可以

  • 加速梯度下降的收敛
  • 增加梯度下降的几率，收敛到较低的训练（和泛化）误差

准备数据

导入相关的库

import numpy as np
import matplotlib.pyplot as plt
import sklearn
import sklearn.datasets

读取数据

def load_dataset(is_plot=True):
    np.random.seed(1)
    train_X, train_Y = sklearn.datasets.make_circles(n_samples=300, noise=.05)
    np.random.seed(2)
    test_X, test_Y = sklearn.datasets.make_circles(n_samples=100, noise=.05)
    # Visualize the data
    if is_plot:
        plt.scatter(train_X[:, 0], train_X[:, 1], c=train_Y, s=40, cmap=plt.cm.Spectral);
    train_X = train_X.T
    train_Y = train_Y.reshape((1, train_Y.shape[0]))
    test_X = test_X.T
    test_Y = test_Y.reshape((1, test_Y.shape[0]))
    return train_X, train_Y, test_X, test_Y

导入数据并绘制图形边界

def plot_decision_boundary(model, X, y):
    # Set min and max values and give it some padding
    x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1
    y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1
    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[0, :], X[1, :], c=np.squeeze(y), cmap=plt.cm.Spectral)  # 需要将c=y改为c=np.squeeze(y)
    plt.show()

主文件中读取数据并且绘制图像

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

# 读取并绘制数据，圆圈中的蓝色/红色圆点
train_X, train_Y, test_X, test_Y = load_dataset(is_plot=True)
plt.show() # 显示图像

执行结果:
在这里插入图片描述

三层神经网络来建立一个分类器

我们将要建立一个分类器把蓝点和红点分开，在之前我们已经实现过一个3层的神经网络，我们将对它进行初始化：

我们将会尝试下面三种初始化方法:

  • 初始化为0：在输入参数中全部初始化为0，参数名为initialization = “zeros”，核心代码：parameters['W' + str(l)] = np.zeros((layers_dims[l], layers_dims[l - 1]))

  • 初始化为随机数：把输入参数设置为随机值，权重初始化为大的随机值。参数名为initialization = “random”，核心代码：parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) * 10

  • 抑梯度异常初始化：参见梯度消失和梯度爆炸的那一个视频，参数名为initialization = “he”，核心代码：parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) * np.sqrt(2 / layers_dims[l - 1])

前向传播

def sigmoid(x):
    """
    Compute the sigmoid of x

    Arguments:
    x -- A scalar or numpy array of any size.

    Return:
    s -- sigmoid(x)
    """
    s = 1 / (1 + np.exp(-x))
    return s

def relu(x):
    """
    Compute the relu of x

    Arguments:
    x -- A scalar or numpy array of any size.

    Return:
    s -- relu(x)
    """
    s = np.maximum(0, x)

    return s

def forward_propagation(X, parameters):
    """
    Implements the forward propagation (and computes the loss) presented in Figure 2.

    Arguments:
    X -- input dataset, of shape (input size, number of examples)
    Y -- true "label" vector (containing 0 if cat, 1 if non-cat)
    parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3":
                    W1 -- weight matrix of shape ()
                    b1 -- bias vector of shape ()
                    W2 -- weight matrix of shape ()
                    b2 -- bias vector of shape ()
                    W3 -- weight matrix of shape ()
                    b3 -- bias vector of shape ()

    Returns:
    loss -- the loss function (vanilla logistic loss)
    """

    # retrieve parameters
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    W3 = parameters["W3"]
    b3 = parameters["b3"]

    # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID
    z1 = np.dot(W1, X) + b1
    a1 = relu(z1)
    z2 = np.dot(W2, a1) + b2
    a2 = relu(z2)
    z3 = np.dot(W3, a2) + b3
    a3 = sigmoid(z3)

    cache = (z1, a1, W1, b1, z2, a2, W2, b2, z3, a3, W3, b3)

    return a3, cache

计算成本

def compute_loss(a3, Y):
    """
    Implement the loss function

    Arguments:
    a3 -- post-activation, output of forward propagation
    Y -- "true" labels vector, same shape as a3

    Returns:
    loss - value of the loss function
    """

    m = Y.shape[1]
    logprobs = np.multiply(-np.log(a3), Y) + np.multiply(-np.log(1 - a3), 1 - Y)
    loss = 1. / m * np.nansum(logprobs)

    return loss

反向传播

def backward_propagation(X, Y, cache):
    """
    Implement the backward propagation presented in figure 2.

    Arguments:
    X -- input dataset, of shape (input size, number of examples)
    Y -- true "label" vector (containing 0 if cat, 1 if non-cat)
    cache -- cache output from forward_propagation()

    Returns:
    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables
    """
    m = X.shape[1]
    (z1, a1, W1, b1, z2, a2, W2, b2, z3, a3, W3, b3) = cache

    dz3 = 1. / m * (a3 - Y)
    dW3 = np.dot(dz3, a2.T)
    db3 = np.sum(dz3, axis=1, keepdims=True)

    da2 = np.dot(W3.T, dz3)
    dz2 = np.multiply(da2, np.int64(a2 > 0))
    dW2 = np.dot(dz2, a1.T)
    db2 = np.sum(dz2, axis=1, keepdims=True)

    da1 = np.dot(W2.T, dz2)
    dz1 = np.multiply(da1, np.int64(a1 > 0))
    dW1 = np.dot(dz1, X.T)
    db1 = np.sum(dz1, axis=1, keepdims=True)

    gradients = {"dz3": dz3, "dW3": dW3, "db3": db3,
                 "da2": da2, "dz2": dz2, "dW2": dW2, "db2": db2,
                 "da1": da1, "dz1": dz1, "dW1": dW1, "db1": db1}

    return gradients

更新参数

def update_parameters(parameters, grads, learning_rate):
    """
    Update parameters using gradient descent

    Arguments:
    parameters -- python dictionary containing your parameters
    grads -- python dictionary containing your gradients, output of n_model_backward

    Returns:
    parameters -- python dictionary containing your updated parameters
                  parameters['W' + str(i)] = ...
                  parameters['b' + str(i)] = ...
    """

    L = len(parameters) // 2  # number of layers in the neural networks

    # Update rule for each parameter
    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

三层神经网络模型

def model(X, Y, learing_rate=0.01, num_iterations=15000, print_cost=True, initialization="he", is_plot=True):
    '''
    实现三层的神经网络：LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID
    :param X:输入数据，维度为（2，样本数）
    :param Y:标签向量，[0是红点，1是蓝点]，维度为（1，样本数）
    :param learing_rate:梯度下降的学习速率
    :param num_iterations:迭代次数
    :param print_cost:是否打印成本值，每迭代1000次打印一次
    :param initialization:字符串类型，初始化的类型("zeros","random" or "he")
    :param is_plot:是否绘制梯度下降的曲线图
    :return:
        parameters:学习后的参数
    '''
    grads = {}  # 梯度值
    costs = []  # 成本
    m = X.shape[1]  # 样本数
    layers_dims = [X.shape[0], 10, 5, 1]  # 三层神经网络

    # 初始化参数的类型
    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(0, num_iterations):
        # 前向传播
        a3, cache = forward_propagation(X, parameters)
        # 计算成本
        cost = compute_loss(a3, Y)
        # 反向传播
        grads = backward_propagation(X, Y, cache)
        # 更新参数
        parameters = update_parameters(parameters, grads, learing_rate)

        # 记录成本
        if i % 1000 == 0:
            costs.append(cost)
            # 打印成本
            if print_cost:
                print("第" + str(i) + "次迭代，成本值为：" + str(cost))

    # 学习完毕，绘制成本函数
    if is_plot:
        plt.plot(costs)
        plt.xlabel("iterations")  # 绘制图像只能用英文
        plt.ylabel("costs")
        plt.title("learning rate=" + str(learing_rate))
        plt.show()

    # 返回学习好的参数
    return parameters

进行预测

def predict(X, y, parameters):
    """
    This function is used to predict the results of a  n-layer neural network.

    Arguments:
    X -- data set of examples you would like to label
    parameters -- parameters of the trained model

    Returns:
    p -- predictions for the given dataset X
    """

    m = X.shape[1]
    p = np.zeros((1, m), dtype=np.int)

    # Forward propagation
    a3, caches = forward_propagation(X, parameters)

    # convert probas to 0/1 predictions
    for i in range(0, a3.shape[1]):
        if a3[0, i] > 0.5:
            p[0, i] = 1
        else:
            p[0, i] = 0

    # print results
    print("Accuracy: " + str(np.mean((p[0, :] == y[0, :]))))

    return p

绘制决策边界图形

组件

def predict_dec(parameters, X):
    """
    Used for plotting decision boundary.

    Arguments:
    parameters -- python dictionary containing your parameters
    X -- input data of size (m, K)

    Returns
    predictions -- vector of predictions of our model (red: 0 / blue: 1)
    """

    # Predict using forward propagation and a classification threshold of 0.5
    a3, cache = forward_propagation(X, parameters)
    predictions = (a3 > 0.5)
    return predictions

绘制决策边界图形，需要注意的是，要将c=y改为c=np.squeeze(y)

def plot_decision_boundary(model, X, y):
    # Set min and max values and give it some padding
    x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1
    y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1
    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[0, :], X[1, :], c=np.squeeze(y), cmap=plt.cm.Spectral)  # 需要将c=y改为c=np.squeeze(y)
    plt.show()

使用0来初始化参数

神经网络中有两种参数需要初始化：

  • 权重矩阵 ( W [ 1 ] , W [ 2 ] , W [ 3 ] , . . . , W [ L − 1 ] , W [ L ] ) (W^{[1]}, W^{[2]}, W^{[3]}, ..., W^{[L-1]}, W^{[L]}) (W[1],W[2],W[3],...,W[L−1],W[L])
  • 偏置向量 ( b [ 1 ] , b [ 2 ] , b [ 3 ] , . . . , b [ L − 1 ] , b [ L ] ) (b^{[1]}, b^{[2]}, b^{[3]}, ..., b^{[L-1]}, b^{[L]}) (b[1],b[2],b[3],...,b[L−1],b[L])

实现以下函数将所有参数初始化为零。稍后你会看到它不能很好地工作，因为它不能“破坏对称性”。使用np.zeros（shape=（..，..））初始化参数，注意这里有两层括号.

def initialize_parameters_zeros(layers_dim):
    '''
    将模型参数全部设置为0
    :param layers_dim: 列表，模型的层数对应每一层节点的数
    :return:
         W1 -- weight matrix of shape (layers_dims[1], layers_dims[0])
         b1 -- bias vector of shape (layers_dims[1], 1)
         ...
         WL -- weight matrix of shape (layers_dims[L], layers_dims[L-1])
         bL -- bias vector of shape (layers_dims[L], 1)
    '''
    parameters = {}
    L = len(layers_dim)  # 网络层数，包含了输入层
    for l in range(1, L):  # 1 -> L-1，如果L=4，则只有W1,b1……W3,b3.
        parameters['W' + str(l)] = np.zeros((layers_dim[l], layers_dim[l - 1]))
        parameters['b' + str(l)] = np.zeros((layers_dim[l], 1))

        # 使用断言
        assert (parameters['W' + str(l)].shape == (layers_dim[l], layers_dim[l - 1]))
        assert (parameters['b' + str(l)].shape == (layers_dim[l], 1))
    return parameters

结果分析

训练模型

# 用初始化为0来训练参数
parameters = model(train_X, train_Y, initialization="zeros", is_plot=True)

执行结果

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

在这里插入图片描述
预测结果

# 预测结果
print("训练集")
predictions_train = predict(train_X, train_Y, parameters)  # 预测测试集
print("测试集")
predictions_test = predict(test_X, test_Y, parameters)  # 预测训练集

执行结果

训练集
Accuracy: 0.5
测试集
Accuracy: 0.5

预测和决策边界

# 绘制决策边界
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: predict_dec(parameters, x.T), train_X, train_Y)
plt.show() # 显示图像

执行结果

predictions_train = [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0]]
predictions_test = [[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]

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

使用随机数来初始化参数

为了打破对称性，让我们随机初始化权重。 在随机初始化之后，每个神经元然后可以继续学习其输入的不同功能。 ，您将看到如果权重是随机初始化比较大的参数值。
实现以下函数将权重初始化为大的随机值（按* 10缩放np.random.randn(..,..) * 10），将偏差初始化为零 np.zeros((.., ..))

def initialize_parameters_random(layers_dim):
    '''
    将模型参数随机初始化
    :param layers_dim: 列表，模型的层数对应每一层节点的数
    :return:
         W1 -- weight matrix of shape (layers_dims[1], layers_dims[0])
         b1 -- bias vector of shape (layers_dims[1], 1)
         ...
         WL -- weight matrix of shape (layers_dims[L], layers_dims[L-1])
         bL -- bias vector of shape (layers_dims[L], 1)
    '''
    np.random.seed(3)  # 一定要指定随机种子
    parameters = {}
    L = len(layers_dim)  # 网络层数，包含了输入层
    for l in range(1, L):  # 1 -> L-1，如果L=4，则只有W1,b1……W3,b3.
        parameters['W' + str(l)] = np.random.randn(layers_dim[l], layers_dim[l - 1]) * 10  # 用十倍缩放
        parameters['b' + str(l)] = np.zeros((layers_dim[l], 1))  # zeros需要两层括号，rand()只需要一层

        # 使用断言
        assert (parameters['W' + str(l)].shape == (layers_dim[l], layers_dim[l - 1]))
        assert (parameters['b' + str(l)].shape == (layers_dim[l], 1))
    return parameters

结果分析

训练模型

# 用随机初始化为来训练参数
parameters = model(train_X, train_Y, initialization="random", is_plot=True)

执行结果

第0次迭代，成本值为：inf
第1000次迭代，成本值为：0.6250982793959966
:
:
第13000次迭代，成本值为：0.384984728909703
第14000次迭代，成本值为：0.3827828308349524

成本值下降
在这里插入图片描述
预测结果

# 预测结果
print("训练集")
predictions_train = predict(train_X, train_Y, parameters)  # 预测测试集
print("测试集")
predictions_test = predict(test_X, test_Y, parameters)  # 预测训练集

执行结果

训练集
Accuracy: 0.83
测试集
Accuracy: 0.86

预测和决策边界

# 绘制决策边界
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: predict_dec(parameters, x.T), train_X, train_Y)
plt.show() # 显示图像

执行结果

predictions_train = [[1 0 1 1 0 0 1 1 1 1 1 0 1 0 0 1 0 1 1 0 0 0 1 0 1 1 1 1 1 1 0 1 1 0 0 1
  1 1 1 1 1 1 1 0 1 1 1 1 0 1 0 1 1 1 1 0 0 1 1 1 1 0 1 1 0 1 0 1 1 1 1 0
  0 0 0 0 1 0 1 0 1 1 1 0 0 1 1 1 1 1 1 0 0 1 1 1 0 1 1 0 1 0 1 1 0 1 1 0
  1 0 1 1 0 0 1 0 0 1 1 0 1 1 1 0 1 0 0 1 0 1 1 1 1 1 1 1 0 1 1 0 0 1 1 0
  0 0 1 0 1 0 1 0 1 1 1 0 0 1 1 1 1 0 1 1 0 1 0 1 1 0 1 0 1 1 1 1 0 1 1 1
  1 0 1 0 1 0 1 1 1 1 0 1 1 0 1 1 0 1 1 0 1 0 1 1 1 0 1 1 1 0 1 0 1 0 0 1
  0 1 1 0 1 1 0 1 1 0 1 1 1 0 1 1 1 1 0 1 0 0 1 1 0 1 1 1 0 0 0 1 1 0 1 1
  1 1 0 1 1 0 1 1 1 0 0 1 0 0 0 1 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 0 0 1 1 1
  1 1 1 1 0 0 0 1 1 1 1 0]]
predictions_test = [[1 1 1 1 0 1 0 1 1 0 1 1 1 0 0 0 0 1 0 1 0 0 1 0 1 0 1 1 1 1 1 0 0 0 0 1
  0 1 1 0 0 1 1 1 1 1 0 1 1 1 0 1 0 1 1 0 1 0 1 0 1 1 1 1 1 1 1 1 1 0 1 0
  1 1 1 1 1 0 1 0 0 1 0 0 0 1 1 0 1 1 0 0 0 1 1 0 1 1 0 0]]

在这里插入图片描述
我们可以看到误差开始很高。这是因为由于具有较大的随机权重，最后一个激活(sigmoid)输出的结果非常接近于0或1，而当它出现错误时，它会导致非常高的损失。初始化参数如果没有很好地话会导致梯度消失、爆炸，这也会减慢优化算法。如果我们对这个网络进行更长时间的训练，我们将看到更好的结果，但是使用过大的随机数初始化会减慢优化的速度。
总而言之，将权重初始化为非常大的时候其实效果并不好，下面我们试试小一点的参数值。

使用抑梯度异常初始化参数

最后，尝试 "He Initialization"它以He et al.,为名。它十分类似于 “Xavier initialization”。 Xavier initialization 使用的比例因子是 W [ l ] W^{[l]} W[l] of sqrt(1./layers_dims[l-1]) ，而He initialization 使用的是 sqrt(2./layers_dims[l-1]).)

抑梯度异常初始化参数和上面的随机初始化initialize_parameters_random(...)十分类似，唯一不同点在于上面的的np.random.randn(..,..)是用10相乘，这里的抑梯度异常初始化参数是与 2 上一层的维度 \sqrt{\frac{2}{\text{上一层的维度}}} 上一层的维度2​ ​相乘。抑梯度异常初始化参数最好与RELU激活相配套使用。

def initialize_parameters_he(layers_dims):
    '''
    将模型参数抑梯度异常初始化
    :param layers_dim: 列表，模型的层数对应每一层节点的数
    :return:
         W1 -- weight matrix of shape (layers_dims[1], layers_dims[0])
         b1 -- bias vector of shape (layers_dims[1], 1)
         ...
         WL -- weight matrix of shape (layers_dims[L], layers_dims[L-1])
         bL -- bias vector of shape (layers_dims[L], 1)
    '''
    np.random.seed(3)  # 一定要指定随机种子
    parameters = {}
    L = len(layers_dims)  # 网络层数，包含了输入层
    for l in range(1, L):  # 1 -> L-1，如果L=4，则只有W1,b1……W3,b3.
        parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) * np.sqrt(
            2 / layers_dims[l - 1])  # rand()只需要一层
        parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))

        # 使用断言
        assert (parameters['W' + str(l)].shape == (layers_dims[l], layers_dims[l - 1]))
        assert (parameters['b' + str(l)].shape == (layers_dims[l], 1))
    return parameters

结果分析

训练模型

# 用抑梯度异常初始化来训练参数
parameters = model(train_X, train_Y, initialization="he", is_plot=True)

执行结果

第0次迭代，成本值为：0.8830537463419761
第1000次迭代，成本值为：0.6879825919728063
：
：
第13000次迭代，成本值为：0.08457055954024274
第14000次迭代，成本值为：0.07357895962677366

成本值下降
在这里插入图片描述
预测结果

# 预测结果
print("训练集")
predictions_train = predict(train_X, train_Y, parameters)  # 预测测试集
print("测试集")
predictions_test = predict(test_X, test_Y, parameters)  # 预测训练集

执行结果

训练集
Accuracy: 0.9933333333333333
测试集
Accuracy: 0.96

预测和决策边界

# 绘制决策边界
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: predict_dec(parameters, x.T), train_X, train_Y)
plt.show() # 显示图像

执行结果

predictions_train = [[1 0 1 1 0 0 1 0 1 1 1 0 1 0 0 0 0 1 1 0 1 0 1 0 0 0 1 0 1 1 0 1 1 0 0 0
  0 1 0 1 1 1 1 0 0 1 1 1 0 1 0 1 1 1 1 0 0 1 1 1 1 1 0 1 0 1 0 1 0 1 1 0
  0 0 0 0 1 0 0 0 1 0 1 0 0 1 1 1 1 1 1 0 0 0 1 1 0 1 1 0 1 0 0 1 0 1 1 0
  0 0 1 1 0 0 1 0 0 1 0 0 1 1 1 0 0 0 0 1 0 1 1 0 1 1 1 1 0 1 1 0 0 0 0 0
  0 0 1 0 1 0 1 0 1 1 1 0 0 1 1 0 1 0 1 1 0 1 0 1 1 0 1 1 1 1 0 1 0 0 1 0
  1 0 0 0 1 0 1 1 1 0 0 1 1 0 0 1 0 1 0 0 1 0 1 1 0 1 1 1 1 0 1 0 1 0 0 1
  0 1 0 0 0 1 1 1 1 0 1 0 0 1 1 0 0 1 0 1 0 0 1 0 0 1 1 0 0 0 0 1 1 0 1 0
  1 1 0 1 1 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 1 1 0 0 0 0 0 1 1 0 0 1 1 1 1
  1 1 1 0 0 0 0 1 1 0 1 0]]
predictions_test = [[1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 1 0 0 0 0 1 1 1 1 0 1 0 0 1
  0 1 1 0 0 1 1 1 1 0 0 0 1 1 0 1 0 1 1 0 1 0 1 0 1 1 1 1 1 1 1 1 1 1 1 0
  1 1 1 1 0 1 1 0 0 1 0 0 0 0 1 0 1 1 0 0 0 1 1 0 0 0 0 0]]

在这里插入图片描述
抑梯度异常初始化参数的模型将蓝色和红色的点在少量的迭代中很好地分离出来

总结一下：

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

在深度学习中，如果数据集没有足够大的话，可能会导致一些过拟合的问题。过拟合导致的结果就是在训练集上有着很高的精确度，但是在遇到新的样本时，精确度下降会很严重。为了避免过拟合的问题，接下来我们要讲解的方式就是正则化。

Reanon
关注
专栏目录
深度学习优化——He初始化
talkAC的博客
12-08 5087
1 背景 He初始化是何凯明等提出的一种鲁棒的神经网络参数（W）初始化方法，可以保证信息在前向传播和反向传播过程中能够有效流动，使不同层的输入信号的方差大致相等。 He初始化对应的是非线性激活函数（Relu 和 Prelu）。 2 方法 任意层的权重，按照均值为 0，且方差为的高斯分布进行初始化，可以保证每一层的输入方差尺度一致。 def initialize_parameters_he(layers_dims): np.random.seed(3) parameters =..
深层神经网络参数初始化方式对训练精度的影响
u013093426的博客
07-05 4199
本文是基于吴恩达老师《深度学习》第二周第一课练习题所做，目的在于探究参数初始化对模型精度的影响。文中所用到的辅助程序在这里。
神经网络之Initialization
知难行更难
05-17 1384
1、前言    神经网络参数众多，权值w的初始化对网络训练影响很大，好的初始化可以加快网络训练的速度，也有可能可以使得网络收敛到更小的误差点。前面学习的时候我们使用了服从（0,1）正态分布的随机初始化方法，网络也基本可以用，使用正态分布的原因是均值为0的正态分布能够让大部分的参数接近0，能加速训练速度。    一个极端的情况就是，w全部使用0来初始化，这个是行不通的，原因是每个神经元的参数都一样的...
抑梯度异常初始化
qq_27489699的博客
10-12 589
parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l - 1]) * np.sqrt(2 / layers_dims[l - 1]) parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))  
改善深层神经网络第一周-Initialization
Suika_Neko的博客
11-27 3388
InitializationWelcome to the first assignment of “Improving Deep Neural Networks”. Training your neural network requires specifying an initial value of the weights. A well chosen initialization method
(pytorch深度学习)利用三层网络实现数据分类
scarecrow_sun的博客
07-03 2819
目录写在前面深度学习的大致过程过程一、图像预处理化函数定义二、数据导入三、模型搭建 写在前面 这一段时间上课在学习简单的神经网络，最后结课的时候要求搭建一个简单的网络模型，并训练识别几类交通标志牌。写下博客记录，供日后学习。这个简易模型可以根据不同的数据集实现对不同的类别的图片识别。但是层数只有三层，只能训练简易的数据集。 深度学习的大致过程 这段时间的学习下来，我理解的深度学习的流程大致如下： #mermaid-svg-fFPt69gL2zAJivwr .label{font-family:'trebuc
吴恩达深度学习笔记(21)-神经网络的权重初始化为什么要随机初始化？
Harpoon_fly的博客
12-06 6558
随机初始化（Random+Initialization） 当你训练神经网络时，权重随机初始化是很重要的。 对于逻辑回归，把权重初始化为0当然也是可以的。 但是对于一个神经网络，如果你把权重或者参数都初始化为0，那么梯度下降将不会起作用。 让我们看看这是为什么？ 有两个输入特征，n([0])=2，2个隐藏层单元n([1])就等于2。 因此与一个隐藏层相关的矩阵，或者说W([1])是2*2的矩阵，假设...
神经网络参数初始化-He初始化
u010505915的博客
06-11 6345
Glorot和Bengio提出了Xavier方法来初始化网络参数。该方法基于激活是线性的假设。但该假设对ReLU不适用。何凯明（He kaiming）在论文《Delving Deep into Rectifiers:Surpassing Human-Level Performance on ImageNet Classification》中提出了针对 ReLU激活网络的初始化方法。 He初始化 与Xavier方法一样，He初始化方法也希望初始化使得正向传播时，状态值的方差保持不变；反向传播时，关于激活.
神经网络的初始化方法总结 | 又名“如何选择合适的初始化方法”
CV技术指南（微信公众号）
10-04 1693
前言 本文介绍了为什么初始化很重要，总结了常用的几种初始化方法：全零或等值初始化、正态初始化、均匀初始化、Xavier初始化、He初始化和Pre-trained初始化，并介绍了几个还活跃的初始化方向：数据相关初始化、稀疏权重矩阵和随机正交矩阵初始化。 本文来自公众号CV技术指南的技术总结系列 欢迎关注CV技术指南 ，专注于计算机视觉的技术总结、最新技术跟踪、经典论文解读。 为什么初始化很重要 不正确初始化的权重会导致梯度消失或爆炸问题，从而对训练过程产生负面影响。 对于梯度消失问题，权重更新
c语言初始化列表,Initialization（初始化）
weixin_39621495的博客
05-19 1495
对象的声明可以通过称为初始化的过程提供其初始值。对于每个声明符，如果不省略，初始化符可能是以下之一：= expression(1)= { initializer-list }(2)其中 initializer-list 是一个非空的以逗号分隔的初始化器列表(带有可选的尾随逗号)，其中每个初始化器都有三种可能的形式之一：expression(1){ initializer-list }(2)de...
第 2 章 创建分类器
最新发布
weixin_44259522的博客
04-16 655
在学习过程中，可以看到二元（binary）分类器，将数据分成两类，也可以看。https://archive.ics.uci.edu/ml/datasets/Car+Evaluation下载数据集。和F1得分（F1 score）。(1)使用simple_classifier.py文件作为参考。(4) 为了对数据有个直观的认识，把图像画出来，如下所示：plt.figure()(1) 我们使用naive_bayes.py文件作为参考。模型时，通常关心3个指标：精度（precision）、召回率（recall）
Python吴恩达深度学习作业6 -- 深度神经网络的初始化
qq_41476257的博客
05-29 1135
初始化 训练神经网络需要指定权重的初始值，而一个好的初始化方法将有助于网络学习。 如果你完成了本系列的上一课程，则可能已经按照我们的说明完成了权重初始化。但是，如何为新的神经网络选择初始化？在本笔记本中，你能学习看到不同的初始化导致的不同结果。 好的初始化可以： 加快梯度下降、模型收敛 减小梯度下降收敛过程中训练（和泛化）出现误差的几率 首先，运行以下单元格以加载包和用于分类的二维数据集。 import numpy as np import matplotlib.pyplot as plt import
2020-7-18 吴恩达-改善深层NN-w1 深度学习的实用层面(课后编程1-Initialization-3种不同方法对比-He/MSRA初始化)
weixin_42555985的博客
07-19 383
原文链接 如果打不开，也可以复制链接到https://nbviewer.jupyter.org中打开。 初始化 Initialization1.NN模型 欢迎来到改善深层NN的第一个编程作业。 训练NN需要指定权重初始值。一个好的初始化方法将有利于模型的学习。 如果你已经完成了前面的编程作业，那么你应该根据指导进行了权重初始化，到目前为止它已经成功运行。 但是对于一个新的NN你如何初始化呢？通过本作业，你将会了解不同的初始化将会有怎样不同的结果。 一个好的初始化能够 加速梯度下降的收敛 增加梯度下降收敛到
吴恩达课后作业学习1-week3-homework-one-hidden-layer
weixin_33851177的博客
04-01 225
参考：https://blog.csdn.net/u013733326/article/details/79702148 希望大家直接到上面的网址去查看代码，下面是本人的笔记 建立一个带有隐藏层的神经网络 导入一些软件包numpy：是用Python进行科学计算的基本软件包。sklearn：为数据挖掘和数据分析提供的简单高效的工具。matplotlib ：是一个用于在Python中绘制...
4-拟合问题
qq_55655082的博客
07-13 175
1
深度学习中的He初始化
gaoxueyi551的专栏
02-19 7111
一、背景 He初始化是何凯明等提出的一种鲁棒的神经网络参数初始化方法，动机同Xaviar初始化基本一致，都是为了保证信息在前向传播和反向传播过程中能够有效流动，使不同层的输入信号方差大致相等。 二、一些假设 关于参数的大部分假设同Xaviar初始化一致，但是，He初始化对应的是非线性激活函数（Relu 和 Prelu），而Xaviar初始化对应的是线性激活函数。符号假设参考原论文。 三、推导 ...
Xavier初始化和He初始化
热门推荐
xxy_的博客
11-22 2万+
Xavier初始化： 条件：正向传播时，激活值的方差保持不变；反向传播时，关于状态值的梯度的方差保持不变。 初始化方法： W∼U[−6ni+ni+1,6ni+ni+1]W\sim U[-\frac{\sqrt6}{\sqrt{n_i+n_{i+1}}},\frac{\sqrt6}{\sqrt{n_i+n_{i+1}}}]W∼U[−ni​+ni+1​​6​​,ni​+ni+1​​6​​] 假设...
He initialization使用方法参考教程
开飞机的小毛驴儿
01-28 1909
转载自：https://github.com/rasbt/deeplearning-models/blob/master/pytorch_ipynb/cnn/cnn-he-init.ipynb，本文只做个人记录学习使用，版权归原作者所有。 Deep Learning Models -- A collection of various deep learning architectures, mo...
C++初始化方式深度解析：默认、值初始化与零初始化
本文主要探讨了C++中几种常见的初始化方法，包括默认初始化、值初始化和零初始化，并通过实例解释了它们之间的差异。 1. 默认初始化（Default Initialization） 默认初始化通常发生在对象声明时没有指定初始值的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值