BP神经网络python算法实现

BP神经网络python算法实现

• 误差逆传播(errorBackPropagation)算法，简称BP算法

例.用BP神经网络解决异或问题
异或运算结果是0或者1，属于分类问题。
输入数据为$(0,0),(0,1),(1,0),(1,1)$输出为0,1,1,0

偏置量设置为$x_0=1$，则输入神经元为$x_0,x_1,x_2$，隐藏层设置10个神经元，输入层到隐藏层的权重系数为$v$,隐藏层到输出层权重系数为$w$,通过BP神经网络训练得到$v,w$的取值。

训练目标：让代价函数取得最小值。

代价函数/目标函数/损失函数:$E=\frac{1}{2}(\hat{y}-y{)}^2$

输入：$X=(x_0,x_1,x_2)$
输出/label $Y=[0,1,1,0{]}^T$

X = np.array([[1,0,0],
             [1,0,1],
             [1,1,0],
             [1,1,1]])
Y = np.array([[0],
              [1],
              [1],
              [0]])

$W,V$都以随机数初始化，同时设置学习率

# 生成 -1~1的随机数
V = np.random.random([3,10]) * 2 - 1
W = np.random.random([10,1]) * 2 - 1
# 学习率
lr = 0.21

$\delta$学习规则：
激活函数：sigmoid函数$f(x)=\frac{1}{1-e^{-x}}$,求导得$f^{\prime }(x)=f(1-f)$

最后一层学习信号$\delta =(\hat{y}-y)f^{\prime }(L_{1}W)$

前一层学习信号${\delta }^l={\delta }^{l+1}{W}^T{f}^{\prime }(XV)$

$\Delta W^l=-\eta \frac{\partial E}{\partial W^l}=\eta X^T{\delta }^l$(梯度下降法，$\Delta W^l$是第$l$层权重变化，$\eta$是学习率,${\delta }^l$是第$l$层学习信号)

尾层学习信号与输入信号和输入权重有关，非尾层学习信号与它后一层(右一层)学习信号和后一层输入权重有关，因此要从最后一层信号往前算。(误差逆传播)
输入权值变化受到输入信号和当前层的学习信号影响。$\Delta V$是第一层输入权重变化，与输入$X$和第一层学习信号${\delta }^1$有关,$\Delta W$是第二层输入权重变化，与输入$L_1$和第一层学习信号${\delta }^2$有关。

# 权值调整函数
def update():
    global V,W
    
    # 每一层输出 
    L1 = sigmoid(np.dot(X,V))
    L2 = sigmoid(np.dot(L1,W))
    # 每一层的学习信号
    L2_delta = (Y - L2)*dsigmoid(np.dot(L1,W)) 
    L1_delta = np.dot(L2_delta,W.T)*dsigmoid(np.dot(X,V))
    
    # 求每一层权值的变化
    delta_W = lr*np.dot(L1.T,L2_delta)
    delta_V = lr*np.dot(X.T,L1_delta)
    
    W = W + delta_W
    V = V + delta_V

输入输出都是矩阵，为了便于理解代码，这里将部分矩阵运算关系写出来
第一层输入：$X=(x_0,x_1,x_2)$
第一层输出/第二层输入：$L_1=(l_1,l_2,...,l_{10})$
第二次层输出：$L_2=({\hat{y}}_1,{\hat{y}}_2,{\hat{y}}_3,{\hat{y}}_4)$
权重$V=(v_1,v_2,v_3{)}^T$
权重$W=(w_1,w_2,...,w_{10}{)}^T$

$L_1=(l_1,l_2,...,l_{10})=f(x_0{v}_0+x_1{v}_1+x_2{v}_2)=f(XV)$
$L_2=({\hat{y}}_1,{\hat{y}}_2,{\hat{y}}_3,{\hat{y}}_4)=f(l_1{w}_1+l_2{w}_2+...+l_{10}{w}_{10})=f(L_{1}W)$

训练并判断
loss为损失函数的向量，这里进行了一个求均值的操作

for i in range(10001):
    update()
    if i%500 == 0:
        L1 = sigmoid(np.dot(X,V))
        L2 = sigmoid(np.dot(L1,W))   
        loss = np.mean(np.square(Y-L2)/2)
        print("loss:",loss)

print(L2)
def judge(x):
    if x >= 0.5:
        return 1
    else:
        return 0
for i in map(judge,L2):
    print(i)

输出训练结果

loss: 0.1503049849879402
loss: 0.11292215088746196
loss: 0.055260106483890375
loss: 0.012689599356839564
loss: 0.005019800627645192
loss: 0.002838688933267325
loss: 0.0019049200410914762
loss: 0.0014063388085483982
loss: 0.0011023445653717398
loss: 0.000900027309043023
loss: 0.0007567885904853457
loss: 0.000650615357323275
loss: 0.0005690855354596988
loss: 0.0005047001580278678
loss: 0.0004526842864463839
loss: 0.00040986323784031537
loss: 0.0003740495228501279
loss: 0.0003436899378899049
loss: 0.0003176530747398405
loss: 0.00029509639853180273
loss: 0.0002753803240158825
[[0.01758859]
 [0.97396267]
 [0.97818043]
 [0.02719647]]
0
1
1
0

分类正确
完整代码如下

import numpy as np

X = np.array([[1,0,0],
             [1,0,1],
             [1,1,0],
             [1,1,1]])
Y = np.array([[0],
              [1],
              [1],
              [0]])
# 3-10-1
# 生成 -1~1的随机数
V = np.random.random([3,10]) * 2 - 1
W = np.random.random([10,1]) * 2 - 1
# 学习率
lr = 0.21

def sigmoid(x):
    return 1/(1+np.exp(-x))
def dsigmoid(x):
    s = 1/(1+np.exp(-x))
    return s*(1-s)
# 权值调整函数
def update():
    global V,W
    
    # 每一层输出 
    L1 = sigmoid(np.dot(X,V))
    L2 = sigmoid(np.dot(L1,W))
    # 每一层的学习信号
    L2_delta = (Y - L2)*dsigmoid(np.dot(L1,W)) 
    L1_delta = np.dot(L2_delta,W.T)*dsigmoid(np.dot(X,V))
    
    # 求每一层权值的变化
    delta_W = lr*np.dot(L1.T,L2_delta)
    delta_V = lr*np.dot(X.T,L1_delta)
    
    W = W + delta_W
    V = V + delta_V
    
for i in range(10001):
    update()
    if i%500 == 0:
        L1 = sigmoid(np.dot(X,V))
        L2 = sigmoid(np.dot(L1,W))   
        loss = np.mean(np.square(Y-L2)/2)
        print("loss:",loss)

print(L2)

def judge(x):
    if x >= 0.5:
        return 1
    else:
        return 0
# map函数可以将L2带入judge中运算
for i in map(judge,L2):
    print(i)