大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

1.写在前面

BP神经网络算法作为作为机器学习最基础的算法，非常适合入门。透彻掌握其原理将对于今后的机器学习有很大的帮助。

2.BP神经网络推导

2.1前向传播

前向传播过程可以表示为：
$$O^{[l]}=\sigma \left(w^{[l]}{I}^{[l-1]}+b^{[l]}\right)$$

2.2反向传播

2.2.1求解梯度矩阵

假设函数 $f:R^{n\times 1}\to R$ 将输入的列向量（shape: $n\times 1$ ）映射为一个实数。那么，函数 $f$ 的梯度定义为：

${\nabla }_{x}f(x)=\left[\begin{array}{c}\frac{\partial f(x)}{\partial x_1}\\ \frac{\partial f(x)}{\partial x_2}\\ ⋮\\ \frac{\partial f(x)}{\partial x_n}\end{array}\right]$

同理，假设函数 $f:R^{m\times n}\to R$ 将输入的矩阵（shape: $m\times n$ ）映射为一个实数。函数 $f$ 的梯度定义为：

${\nabla }_{A}f(A)=\left[\begin{array}{cccc}\frac{\partial f(A)}{\partial A_{11}}& \frac{\partial f(A)}{\partial A_{12}}& \dots & \frac{\partial f(A)}{\partial A_{13}}\\ \frac{\partial f(A)}{\partial A_{21}}& \frac{\partial f(A)}{\partial A_{22}}& \dots & \frac{\partial f(A)}{\partial A_{2n}}\\ ⋮& ⋮& \ddots & ⋮\\ \frac{\partial f(A)}{\partial A_{m1}}& \frac{\partial f(A)}{\partial A_{m2}}& \dots & \frac{\partial f(A)}{\partial A_{mn}}\end{array}\right]$

可以简化为：

${\left({\nabla }_{A}f(A)\right)}_{ij}=\frac{\partial f(A)}{\partial A_{ij}}$

2.2.2梯度下降法

​ 从几何意义，梯度矩阵代表了函数增加最快的方向，沿着梯度相反的方向可以更快找到最小值。

​ 反向传播的过程就是利用梯度下降法原理，逐步找到成本函数的最小值，得到最终的模型参数。

2.2.3反向传播公式推导

输出层误差

$${\delta }_j^{[L]}=\frac{\partial L}{\partial a_j^{[L]}}{\sigma }^{\prime }\left(z_j^{[L]}\right)$$

L表示输出层层数。以下用 $\partial L$ 表示 $\partial L\left(a^{[L]},y\right)$

推导

计算输出层的误差 ${\delta }_j^{[L]}=\frac{\partial L}{\partial z_j^{[L]}}$ ，根据链式法则

${\delta }_j^{[L]}={\sum }_k\frac{\partial L}{\partial a_k^{[L]}}\frac{\partial a_k^{[L]}}{\partial z_j^{[L]}}$

输出层不一定只有一个神经元，可能有多个神经元。成本函数是每个输出神经元的损失函数之和，每个输出神经元的误差与其它神经元没有关系，所以只有$k=j$ 的时候值不是0。

当$k\ne j$ 时，$\frac{\partial L}{\partial z_j^{[L]}}=0$ ，简化误差 ${\delta }_j^{[L]}$ ，得到

${\delta }_j^{[L]}=\frac{\partial L}{\partial a_j^{[L]}}\frac{\partial a_j^{[L]}}{\partial z_j^{[L]}}$

$\sigma$ 表示激活函数，由$a_j^{[L]}=\sigma \left(z_j^{[L]}\right)$，计算出 $\frac{\partial a_j^{[L]}}{\partial z_j^{[L]}}={\sigma }^{\prime }\left(z_j^{[L]}\right)$ ，代入最后得到

${\delta }_j^{[L]}=\frac{\partial L}{\partial a_j^{[L]}}{\sigma }^{\prime }\left(z_j^{[L]}\right)$

隐藏层误差

$$\begin{array}{c}{\delta }_j^{[l]}={\sum }_k{w}_{kj}^{[l+1]}{\delta }_k^{[l+1]}{\sigma }^{\prime }\left(z_j^{[l]}\right)\end{array}$$

推导

$z_k^{[l+1]}={\sum }_j{w}_{kj}^{[l+1]}{a}_j^{[l]}+b_k^{[l+1]}={\sum }_j{w}_{kj}^{[l+1]}\sigma \left(z_j^{[l]}\right)+b_k^{[l+1]}$

对 $z_j^{[l]}$ 求偏导

$\frac{\partial z_k^{[l+1]}}{\partial z_j^{[l]}}=w_{kj}^{[l+1]}{\sigma }^{\prime }\left(z_j^{[l]}\right)$

根据链式法则

${\delta }_j^{[l]}=\frac{\partial L}{\partial z_j^{[l]}}=\frac{\partial L}{\partial z_k^{[l+1]}}\frac{\partial z_k^{[l+1]}}{\partial z_j^{[l]}}={\sum }_k{w}_{kj}^{[l+1]}{\delta }_k^{[l+1]}{\sigma }^{\prime }\left(z_j^{[l]}\right)$

参数变化率

$$\begin{array}{c}\frac{\partial L}{\partial b_j^{[l]}}={\delta }_j^{[l]}\\ \frac{\partial L}{\partial w_{jk}^{[l]}}=a_k^{[l-1]}{\delta }_j^{[l]}\end{array}$$

推导

$z_j^{[l]}={\sum }_k{w}_{jk}^{[l]}{a}_k^{[l-1]}+b_k^{[l]}$

L 对 $b_j^{[l]}$ 求偏导，根据链式法则得到

$\frac{\partial L}{\partial b_j^{[l]}}=\frac{\partial L}{\partial z_j^{[l]}}\frac{\partial z_j^{[l]}}{b_j^{[l]}}=\frac{\partial L}{\partial z_j^{[l]}}\ast 1={\delta }_j^{[l]}$

L 对 $w_{jk}^{[l]}$ 求偏导，根据链式法则得到

$\frac{\partial L}{\partial w_{jk}^{[l]}}=\frac{\partial L}{\partial z_j^{[l]}}\frac{\partial z_j^{[l]}}{w_{jk}^{[l]}}=a_k^{[l-1]}{\delta }_j^{[l]}$

参数更新

根据梯度下降法原理，朝着梯度的反方向更新参数
$$\begin{array}{c}{b}_j^{[l]}\leftarrow b_j^{[l]}-\alpha \frac{\partial L}{\partial b_j^{[l]}}\\ w_{jk}^{[l]}\leftarrow w_{jk}^{[l]}-\alpha \frac{\partial L}{\partial w_{jk}^{[l]}}\end{array}$$

3.代码实现

3.1过程解释

本次代码实现决定考虑四层神经网络，即含有两个隐层。其中，有三个输入单元，一个输出单元，第一层隐层含有四个节点，第二层隐层含有二个节点。
并且，激励函数采用sigmoid函数。

3.1.1导入库

import numpy as np

3.1.2定义sigmoid函数

def sigmoid(x, deriv = False):
    if(deriv == True):
        return x*(1-x)
    else:
        return 1/(1+np.exp(-x))

当deriv为默认值False时，进行sigmoid函数的运算；
当deriv为True时，对函数求导运算。（其中，求导运算时输入的x值应为函数值而非自变量）

3.1.3导入数据集

#input dataset
X = np.array([[0,0,1],
             [0,1,1],
             [1,0,1],
             [1,1,1]])
 
#output dataset
y = np.array([[0,1,1,0]]).T

3.1.4初始化权重和偏倚

权重weight01表示从第0层（即输入层）到第1层（第一隐层）的权重矩阵；
偏倚bias1表示第1层（第一隐层）的偏倚矩阵。

#初始化权重
weight01 = 2*np.random.random((3,4)) - 1 
weight12 = 2*np.random.random((4,2)) - 1
weight23 = 2*np.random.random((2,1)) - 1

#初始化偏倚
b1 = 2*np.random.random((1,4)) - 1 
b2 = 2*np.random.random((1,2)) - 1
b3 = 2*np.random.random((1,1)) - 1
bias1=np.array([b1[0],b1[0],b1[0],b1[0]])
bias2=np.array([b2[0],b2[0],b2[0],b2[0]])
bias3=np.array([b3[0],b3[0],b3[0],b3[0]])

3.1.5开始训练

I0表示第0层输入，O0表示第0层输出。

for j in range(60000):
    I0 = X
    O0=I0
    I1=np.dot(O0,weight01)+bias1
    O1=sigmoid(I1)
    I2=np.dot(O1,weight12)+bias2
    O2=sigmoid(I2)
    I3=np.dot(O2,weight23)+bias3
    O3=sigmoid(I3)

    f3_error = y-O3       
    
    f3_delta = f3_error*sigmoid(O3,deriv = True)
 
    f2_error = f3_delta.dot(weight23.T)
 
    f2_delta = f2_error*sigmoid(O2,deriv = True)
 
    f1_error = f2_delta.dot(weight12.T)     
 
    f1_delta = f1_error*sigmoid(O1,deriv = True)


    weight23 += O2.T.dot(f3_delta) #调整权重
    weight12 += O1.T.dot(f2_delta)
    weight01 += O0.T.dot(f1_delta)

    bias3 += f3_delta #调整偏倚
    bias2 += f2_delta
    bias1 += f1_delta

3.2完整代码

import numpy as np
#定义sigmoid函数 
def sigmoid(x, deriv = False):
if(deriv == True):
return x*(1-x)
else:
return 1/(1+np.exp(-x))
#input dataset
X = np.array([[0,0,1],
[0,1,1],
[1,0,1],
[1,1,1]])
#output dataset
y = np.array([[0,1,1,0]]).T
#初始化权重
weight01 = 2*np.random.random((3,4)) - 1 
weight12 = 2*np.random.random((4,2)) - 1
weight23 = 2*np.random.random((2,1)) - 1
#初始化偏倚
b1 = 2*np.random.random((1,4)) - 1 
b2 = 2*np.random.random((1,2)) - 1
b3 = 2*np.random.random((1,1)) - 1
bias1=np.array([b1[0],b1[0],b1[0],b1[0]])
bias2=np.array([b2[0],b2[0],b2[0],b2[0]])
bias3=np.array([b3[0],b3[0],b3[0],b3[0]])
#开始训练
for j in range(60000):
I0 = X
O0=I0
I1=np.dot(O0,weight01)+bias1
O1=sigmoid(I1)
I2=np.dot(O1,weight12)+bias2
O2=sigmoid(I2)
I3=np.dot(O2,weight23)+bias3
O3=sigmoid(I3)
f3_error = y-O3       
if(j%10000) == 0:
print ("Error:"+str(np.mean(f3_error)))
f3_delta = f3_error*sigmoid(O3,deriv = True)
f2_error = f3_delta.dot(weight23.T)
f2_delta = f2_error*sigmoid(O2,deriv = True)
f1_error = f2_delta.dot(weight12.T)     
f1_delta = f1_error*sigmoid(O1,deriv = True)
weight23 += O2.T.dot(f3_delta) #调整权重
weight12 += O1.T.dot(f2_delta)
weight01 += O0.T.dot(f1_delta)
bias3 += f3_delta #调整偏倚
bias2 += f2_delta
bias1 += f1_delta
print ("outout after Training:")
print (O3)

3.3预测结果

迭代次数为1000时，预测结果为：

迭代次数为5000时，预测结果为：

迭代次数为10000时，预测结果为：

迭代次数为60000时，预测结果为：

可见，已经十分逼近预期结果。