bp神经网络推导及python实例_依据bp网络的计算实例,利用py

bp神经网络

BP（back propagation，反向传播）神经网络（neural network），通常指具有三层网络结构的浅层神经网络。神经网络由一个个神经元（Neuron）组成，神经元由输入、计算、输出单元组成。

对应上图输入为$x_1,x_2,\cdots ,x_n$和截距$+1$，输出为：
$$\hat{y}=h_{w,b}(X)=f(w^{T}X)=f(\sum _{i=1}^n{w}_i{x}_i+b)$$
其中w表示权重值，函数f为激活函数，有如下激活函数：
$$sigmoid:f(x)=\frac{1}{1+ex{p}^{-x}}$$
$$tanh:f(x)=\frac{e^x-e^{-x}}{e^x+e^{-x}}$$
$$ReLu:f(x)=max(0,x)$$
$$SoftPlus:f(x)=lo{g}_e(1+e^x)$$
对应图像为：

一个三层的神经网络结构图：

相关参数说明

• 网络层数$n_l$，三层网络$n_l=3$，第$l$层记为$L_l$
• $L_1,L_2,L_3$分别为输入层，隐藏层，输出层
• 权重$w=(w^1,w^2)$，其中$w_{ij}^l$表示$l$层的第$j$个神经元与$l+1$层的第$i$个神经元的参数，如$w_{21}^1$表示1层第1个神经元与2层第2个神经元的连接参数
• 偏置$b_i^l$表示第$l+1$层的第i个神经元的偏置项，如$b_2^1$表示2层第2个神经元的偏置项
• $z_i^l$表示$l$层第$i$个神经元的输入
• $a_i^l$表示$l$层第$i$个神经元的输出
• $S_l$表示$l$层的神经元个数，如$S_3$表示3层有2个神经元

参数计算关系如下：
$$a_2^2=f(z_2^2)=f(w_{21}^1{x}_1+w_{22}^1{x}_2+w_{23}^1{x}_3+b_2^1)$$
即每个神经元的输入为上一层所有神经元输出的加权求和，神经元输入值经过激活函数处理后得到神经元输出。

损失函数

对于每个训练样本$(X,y)$，损失函数为：
$$J(W,b;X,y)=\frac{1}{2}||h_{w,b}(X)-y|{|}^2$$
表示最后一层输出层的输出值与实际值的欧式距离，结果是一个向量，向量维度等于输出层神经元数量。

为得到损失函数最小值，首先对参数进行初始化，初始化为一个接近0的随机值。再利用前向传播得到预测值，从而计算损失值。此时需要利用损失函数调整参数，可使用梯度下降法，梯度下降公式为：
$$W_{ij}^l=W_{ij}^l-\alpha \frac{\partial J(W,b)}{\partial W_{ij}^l}$$
$$b_i^l=b_i^l-\alpha \frac{\partial J(W,b)}{\partial b_i^l}$$
其中偏导部分：
$$\frac{\partial J(W,b)}{\partial W_{ij}^l}=[\frac{1}{m}\sum _{k=1}^m\frac{\partial J(W,b;x^k,y^k)}{\partial W_{ij}^l}]$$
$$\frac{\partial J(W,b)}{\partial b_i^l}==[\frac{1}{m}\sum _{k=1}^m\frac{\partial J(W,b;x^k,y^k)}{\partial b_i^l}]$$
由于每两层之间有$W$参数矩阵，考虑到预测值在最后一层输出层，可以先求解$W_{ij}^{n_l-1}$，推导如下：
$$\frac{\partial J(W,b)}{\partial W_{ij}^{n_l-1}}=\frac{\partial \frac{1}{2}||a^{n_l}-y|{|}^2}{\partial W_{ij}^{n_l-1}}=$$
$$\frac{\partial \frac{1}{2}{\sum }_{k=1}^{S_{n_l}}(a_k^{n_l}-y_k{)}^2}{\partial W_{ij}^{n_l-1}}=$$
$$\frac{\partial \frac{1}{2}{\sum }_{k=1}^{S_{n_l}}(f(z_k^{n_l})-y_k{)}^2}{\partial W_{ij}^{n_l-1}}$$
其中$z_i^{n_l}$等于：
$$z_i^{n_l}=\sum _{p=1}^{S_{n_l-1}}[W_{ip}^{n_l-1}{a}_p^{n_l-1}+b_i^{n_l-1}]$$
即$z_i^{n_l}$对$W_{ij}^{n_l-1}$可导，可以使用链式法则求导：
$$\frac{\partial J(W,b)}{\partial W_{ij}^{n_l-1}}=$$
$$\frac{\partial \frac{1}{2}{\sum }_{k=1}^{S_{n_l}}(f(z_k^{n_l})-y_k{)}^2}{\partial z_i^{n_l}}\cdot \frac{\partial z_i^{n_l}}{\partial W_{ij}^{n_l-1}}=$$
$$[f(z_i^{n_l})-y_i]\cdot f^{\prime }(z_i^{n_l})\cdot \frac{\partial z_i^{n_l}}{\partial W_{ij}^{n_l-1}}=$$
$$[f(z_i^{n_l})-y_i]\cdot f^{\prime }(z_i^{n_l})\cdot a_j^{n_l-1}$$

反向传播算法的思路为，对于给定训练数据$(X,y)$，通过前向传播算法计算每个神经元的输出值，当所有神经元的输出都计算完成后，对每个神经元计算残差，如第$l$层的第i个神经元的残差表示为${\delta }_i^l$，该残差表示该神经元对最终残差的影响，最后一层的残差公式为：
$${\delta }_i^{n_l}=\frac{\partial J(W,b)}{\partial z_i^{n_l}}=[f(z_i^{n_l})-y_i]\cdot f^{\prime }(z_i^{n_l})$$
将${\delta }_i^l$代入，得出：
$$\frac{\partial J(W,b)}{\partial W_{ij}^{n_l-1}}={\delta }_i^{n_l}\cdot a_j^{n_l-1}$$

其中$a_j^{n_l-1}$可以通过前向传播得到，需要求解${\delta }_i^{n_l}$，可以推导倒数第二层残差与最后一层残差的关系：
$${\delta }_i^{n_l-1}=\frac{\partial J(W,b)}{\partial z_i^{n_l-1}}=$$
$$\frac{\partial \frac{1}{2}{\sum }_{k=1}^{S_{n_l}}(f(z_k^{n_l})-y_k{)}^2}{\partial z_i^{n_l-1}}=$$
$$\frac{1}{2}\sum _{k=1}^{S_{n_l}}\frac{\partial (f(z_k^{n_l})-y_k{)}^2}{\partial z_i^{n_l-1}}=$$
$$\frac{1}{2}\sum _{k=1}^{S_{n_l}}\frac{\partial (f(z_k^{n_l})-y_k{)}^2}{\partial z_k^{n_l}}\cdot \frac{\partial z_k^{n_l}}{\partial z_i^{n_l-1}}=$$
$$\sum _{k=1}^{S_{n_l}}{\delta }_k^{n_l}\cdot \frac{\partial z_k^{n_l}}{\partial z_i^{n_l-1}}=$$
$$\sum _{k=1}^{S_{n_l}}{\delta }_k^{n_l}\cdot \frac{\partial {\sum }_{j=1}^{S_{n_l-1}}[f(z_j^{n_l-1})\cdot W_{kj}^{n_l-1}+b_j^{n_l-1}]}{\partial z_i^{n_l-1}}=$$
$$\sum _{k=1}^{S_{n_l}}{\delta }_k^{n_l}\cdot W_{ki}^{n_l-1}{f}^{\prime }(z_i^{n_l-1})=$$
$$[\sum _{k=1}^{S_{n_l}}{\delta }_k^{n_l}\cdot W_{ki}^{n_l-1}]\cdot f^{\prime }(z_i^{n_l-1})$$
即
$${\delta }_i^{n_l-1}=[\sum _{k=1}^{S_{n_l}}{\delta }_k^{n_l}\cdot W_{ki}^{n_l-1}]\cdot f^{\prime }(z_i^{n_l-1})$$
推导到一般情况：
$${\delta }_i^l=[\sum _{k=1}^{S_{l+1}}{\delta }_k^{l+1}\cdot W_{ki}^l]\cdot f^{\prime }(z_i^l)$$
$$\frac{\partial J(W,b)}{\partial W_{ij}^l}={\delta }_i^{l+1}\cdot a_j^l$$
$$\frac{\partial J(W,b)}{\partial b_i^l}={\delta }_i^{l+1}$$

python实例

# 代码来自《Python机器学习算法》一书
def bp_train(feature, label, n_hidden, maxCycle, alpha, n_output):
    '''计算隐含层的输入
    input:  feature(mat):特征
            label(mat):标签
            n_hidden(int):隐含层的节点个数
            maxCycle(int):最大的迭代次数
            alpha(float):学习率
            n_output(int):输出层的节点个数
    output: w0(mat):输入层到隐含层之间的权重
            b0(mat):输入层到隐含层之间的偏置
            w1(mat):隐含层到输出层之间的权重
            b1(mat):隐含层到输出层之间的偏置
    '''
    m, n = np.shape(feature)
    # 1、初始化
    w0 = np.mat(np.random.rand(n, n_hidden))
    w0 = w0 * (8.0 * sqrt(6) / sqrt(n + n_hidden)) - \
     np.mat(np.ones((n, n_hidden))) * \
      (4.0 * sqrt(6) / sqrt(n + n_hidden))
    b0 = np.mat(np.random.rand(1, n_hidden))
    b0 = b0 * (8.0 * sqrt(6) / sqrt(n + n_hidden)) - \
     np.mat(np.ones((1, n_hidden))) * \
      (4.0 * sqrt(6) / sqrt(n + n_hidden))
    w1 = np.mat(np.random.rand(n_hidden, n_output))
    w1 = w1 * (8.0 * sqrt(6) / sqrt(n_hidden + n_output)) - \
     np.mat(np.ones((n_hidden, n_output))) * \
      (4.0 * sqrt(6) / sqrt(n_hidden + n_output))
    b1 = np.mat(np.random.rand(1, n_output))
    b1 = b1 * (8.0 * sqrt(6) / sqrt(n_hidden + n_output)) - \
     np.mat(np.ones((1, n_output))) * \
      (4.0 * sqrt(6) / sqrt(n_hidden + n_output))

    # 2、训练
    i = 0
    while i <= maxCycle:
        # 2.1、信号正向传播
        # 2.1.1、计算隐含层的输入
        hidden_input = hidden_in(feature, w0, b0)  # mXn_hidden
        # 2.1.2、计算隐含层的输出
        hidden_output = hidden_out(hidden_input)
        # 2.1.3、计算输出层的输入
        output_in = predict_in(hidden_output, w1, b1)  # mXn_output
        # 2.1.4、计算输出层的输出
        output_out = predict_out(output_in)

        # 2.2、误差的反向传播
        # 2.2.1、隐含层到输出层之间的残差
        delta_output = -np.multiply((label - output_out), partial_sig(output_in))
        # 2.2.2、输入层到隐含层之间的残差
        delta_hidden = np.multiply((delta_output * w1.T), partial_sig(hidden_input))

        # 2.3、 修正权重和偏置       
        w1 = w1 - alpha * (hidden_output.T * delta_output)
        b1 = b1 - alpha * np.sum(delta_output, axis=0) * (1.0 / m)
        w0 = w0 - alpha * (feature.T * delta_hidden)
        b0 = b0 - alpha * np.sum(delta_hidden, axis=0) * (1.0 / m)
        if i % 100 == 0:
            print "\t-------- iter: ", i, \
            " ,cost: ",  (1.0/2) * get_cost(get_predict(feature, w0, w1, b0, b1) - label)
        i += 1
    return w0, w1, b0, b1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

（1）初始化参数

• 样本特征数 n=2

• 隐藏层节点数 n_hidden=20

• 输出层节点数（分类数量） n_output=2

• 构成 2*20*2 的三层神经网络结构

• 输入层到隐藏层的权重w0 = np.mat(np.random.rand(n, n_hidden))，即2*20个

• 输入层到隐藏层的偏置b0 = np.mat(np.random.rand(1, n_hidden))，即20个

• 隐藏层到输出层的权重w1 = np.mat(np.random.rand(n_hidden, n_output))，即20*2个

• 隐藏层到输出层的偏置b1 = np.mat(np.random.rand(1, n_output))，即2个

可以利用更科学的随机算法，得到随机化的w0,b0,w1,b1

（2）正向传播

# 2.1.1、计算隐含层的输入
hidden_input = hidden_in(feature, w0, b0)  # mXn_hidden
# 2.1.2、计算隐含层的输出
hidden_output = hidden_out(hidden_input)
# 2.1.3、计算输出层的输入
output_in = predict_in(hidden_output, w1, b1)  # mXn_output
# 2.1.4、计算输出层的输出
output_out = predict_out(output_in)
1
2
3
4
5
6
7
8

hidden_in方法计算隐藏层的输入值，对应公式：
$$z_i^l=\sum _{k=1}^{S_{l-1}}[W_{ik}^{l-1}{a}_k^{l-1}+b_i^{l-1}]$$

def hidden_in(feature, w0, b0):
    '''计算隐含层的输入
    input:  feature(mat):特征
            w0(mat):输入层到隐含层之间的权重
            b0(mat):输入层到隐含层之间的偏置
    output: hidden_in(mat):隐含层的输入
    '''
    m = np.shape(feature)[0]
    hidden_in = feature * w0
    for i in xrange(m):
        hidden_in[i, ] += b0
    return hidden_in
1
2
3
4
5
6
7
8
9
10
11
12

hidden_out方法计算隐藏层的输出，对应公式：
$$a_i^l=f(z_i^l)$$

def hidden_out(hidden_in):
    '''隐含层的输出
    input:  hidden_in(mat):隐含层的输入
    output: hidden_output(mat):隐含层的输出
    '''
    hidden_output = sig(hidden_in)
    return hidden_output;
1
2
3
4
5
6
7

predict_in方法等同于hidden_in，predict_out方法等同于hidden_out。

（3）反向传播

# 2.2.1、隐含层到输出层之间的残差
delta_output = -np.multiply((label - output_out), partial_sig(output_in))
# 2.2.2、输入层到隐含层之间的残差
delta_hidden = np.multiply((delta_output * w1.T), partial_sig(hidden_input))
1
2
3
4

partial_sig方法计算输入值的偏导值，delta_output对应最后一层的残差公式：
$${\delta }_i^{n_l}=\frac{\partial J(W,b)}{\partial z_i^{n_l}}=[f(z_i^{n_l})-y_i]\cdot f^{\prime }(z_i^{n_l})$$
delta_hidden对应一般情况的残差公式：
$${\delta }_i^l=[\sum _{k=1}^{S_{l+1}}{\delta }_k^{l+1}\cdot W_{ki}^l]\cdot f^{\prime }(z_i^l)$$

def partial_sig(x):
    '''Sigmoid导函数的值
    input:  x(mat/float):自变量，可以是矩阵或者是任意实数
    output: out(mat/float):Sigmoid导函数的值
    '''
    m, n = np.shape(x)
    out = np.mat(np.zeros((m, n)))
    for i in xrange(m):
        for j in xrange(n):
            out[i, j] = sig(x[i, j]) * (1 - sig(x[i, j]))
    return out
1
2
3
4
5
6
7
8
9
10
11

（4）更新权重和偏置

w1 = w1 - alpha * (hidden_output.T * delta_output)
b1 = b1 - alpha * np.sum(delta_output, axis=0) * (1.0 / m)
w0 = w0 - alpha * (feature.T * delta_hidden)
b0 = b0 - alpha * np.sum(delta_hidden, axis=0) * (1.0 / m)
1
2
3
4

对应公式：
$$\frac{\partial J(W,b)}{\partial W_{ij}^l}={\delta }_i^{l+1}\cdot a_j^l$$
$$\frac{\partial J(W,b)}{\partial b_i^l}={\delta }_i^{l+1}$$

（5）预测

def get_predict(feature, w0, w1, b0, b1):
    '''计算最终的预测
    input:  feature(mat):特征
            w0(mat):输入层到隐含层之间的权重
            b0(mat):输入层到隐含层之间的偏置
            w1(mat):隐含层到输出层之间的权重
            b1(mat):隐含层到输出层之间的偏置
    output: 预测值
    '''
    return predict_out(predict_in(hidden_out(hidden_in(feature, w0, b0)), w1, b1))
1
2
3
4
5
6
7
8
9
10

传入训练完成的参数，计算测试样本在输出层每个神经元的输出值，选取最大值的神经元作为分类结果。