【AI系列】<3>生成神经网络以及初始化详细过程

版权声明：本文为博主原创文章，欢迎转载。转载请注明出处http://blog.csdn.net/jobbofhe https://blog.csdn.net/jobbofhe/article/details/80529944

内容简介

本文将会介绍神经网络的生成过程，通过生成一个[2, 5, 3, 1]的神经网络，详细讲解每一步骤的运算过程。[2, 5, 3, 1] 表示：两个输入，第一层 5各神经元，第二层3个神经元，第三层 1个神经元。

• 生成输入数据

np.random.seed(1)
#画一个圈
train_X, train_Y = sklearn.datasets.make_circles(n_samples=300, noise=.05)
# Visualize the data
plt.scatter(train_X[:, 0], train_X[:, 1], c=train_Y, s=40, cmap=plt.cm.Spectral);

我们假设输入是一个点（x1,y1）.共有300个点，这些点随机分布呈椭圆形。这些点组成一个矩阵就是所有输入参数，我们用你X表示。

这里生成的X是一个300*2的矩阵。如下：

对X进行转置，得到一个2*300的矩阵，如下

• 整个网络权值初始化为0

def initialize_parameters_zeros(layers_dims):
    """
    Arguments:
    layer_dims -- python array (list) containing the size of each layer.

    Returns:
    parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                    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_dims)            # number of layers in the network
    """
    l = 1
        W1: 5行 2列
    l = 2
        W2: 3行 5列
    l = 3
        W3: 1行3列
    """
    for l in range(1, L):
        parameters['W' + str(l)] = np.zeros((layers_dims[l], layers_dims[l-1]))
        parameters['b' + str(l)] = 0
    return parameters
#生成网络
X = train_X.T
layers_dims = [X.shape[0], 5, 3, 1]   #[2, 5, 3, 1]
parameters = initialize_parameters_zeros(layers_dims)

到这里我们将每一层的权值都初始化为零了。现在我们来分析一下现在每一层的权值详细情况。
第一层 W1： 5*2的矩阵
b1 ：5*1 列向量
第二层 W2：3*5 矩阵
b2 ：3*1
第三层 W3：1*3 矩阵
b3 : 0
前向传播计算过程

• 前向传播代码以及注释

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   #W1: [5, 2]  X[2, 300]，矩阵乘法可乘条件：前者 列= 后者行  z1:[5,300]
    a1 = relu(z1)          #激活函数
    z2 = np.dot(W2, a1) + b2  #W2:[3, 5]  a1[5,300]  z2:[3,300]
    a2 = relu(z2)          
    z3 = np.dot(W3, a2) + b3  #W3:[1,3]  a2:[3,300]  z3:[1,300]
    a3 = sigmoid(z3)
    cache = (z1, a1, W1, b1, z2, a2, W2, b2, z3, a3, W3, b3)

    return a3, cache  #a3 即是最后的记过Y’值，之后根据提前期望的Y值，进行误差反向传播。

神经网络层数与权值W 的矩阵形式有以下对应形式：
假设神经网络是 [2, 10, 20, 5, 1], 很明显这是一个2分类问题。
那么
W1 就是 10*2 的矩阵 b1 ： 10*1
W2: 20*10 b2: 20*1
W3: 5*20 b3: 5*1
W4: 1*5 b4: 1*1
相信规律已经很明白了。这里W看做与神经元连接的每一条线，b看做每一个神经元。