代码参考《深度学习图解》书籍的P116，在此基础上进行了注释和新增测试函数（sim）。
说实在的，这本书写得还不错。但个别地方理解起来还是比较晦涩的。比如为什么误差反向传播公式是误差乘输入，如何推导出来的，什么情况下适用，书中没有直接给出理论说明。不过，瑕不掩瑜。姑且看下去吧。公式这种头疼的东西，让它随风去吧。
在给代码之前，先画出网络结构图，如下所示。
反向传播
权值调整公式：
Wnew = Wold - 误差节点输入值alpha
理论如下(假设只有一个输入、一个输出和一个权值）
线性传递函数：
y = Wx。
评估函数采用均方误差：
MSE = (Wx-O) ^2 （公式1）
对W求导得：
dMSE/dW = 2(Wx-O)x=2errorx （公式2）
式中，O为网络目标输出值。
系数2不影响梯度方向，省略掉。
于是：
dMSE/dW = errorx （公式3） （√）一般性，假设网络的传递函数为h = f(x)，则：
y = f(Wx)
同样地，
MSE = (f(Wx)-O)^2
根据链式法则求导得：
dMSE/dW = 2(f(Wx-O)(d(f(Wx))x = error(d(f(Wx))x
代码
注意，训练数据集与上一个例子不同，数量上少了几个，要统一，不然会掉坑里。
# streetlight_bp_network.py
# 利用bp神经网络学习信号灯，三层网络结构
# 中间层的传递函数为Relu函数
import numpy as np
np.random.seed(1) # 设置随机种子（0-1）
# 隐藏层传递函数Relu定义，如果输入大于0，返回输入，否则返回0.
# 言外之意，负数对系统不起作用
def relu(x):
return (x>0)*x
# Relu的导数，大于0导数值为1（y=x的导数）；小于0导数值为0.
def relu2derivative(output):
return (output>0)
# 输入层的输入变量，训练样本的输入
streetlights = np.array([[1, 0, 1],
[0, 1, 1],
[0, 0, 1],
[1, 1, 1]])
# 输出层的目标值，训练样本的目标值，列向量
walk_vs_stop = np.array([[1, 1, 0, 0]]).T
alpha = 0.2 #learn rate，学习率
hidden_size = 4 #隐层节点数
# 权重矩阵定义，取随机值[0-1]
weights_0_1 = 2*np.random.random((3,hidden_size))-1
weights_1_2 = 2*np.random.random((hidden_size,1))-1
# 训练函数，迭代次数可自定义
def train(iteration_times):
global weights_0_1
global weights_1_2
global streetlights
global walk_vs_stop
for iteration in range(iteration_times):
layer_2_error = 0
for i in range(len(streetlights)):
layer_0 = streetlights[i:i+1]
layer_1 = relu(np.dot(layer_0,weights_0_1)) # layer1 output
layer_2 = np.dot(layer_1,weights_1_2) #layer2 output
layer_2_error = layer_2_error + np.sum((layer_2 - walk_vs_stop[i:i+1])**2) #求总的误差, 评估函数为MSE
layer_2_delta = (layer_2 - walk_vs_stop[i:i+1]) #网络训练值与目标值的误差
layer_1_delta = layer_2_delta.dot(weights_1_2.T)*relu2derivative(layer_1)
# 更新权重，由误差反向传播
weights_1_2 = weights_1_2 - alpha*layer_1.T.dot(layer_2_delta)
weights_0_1 = weights_0_1 - alpha*layer_0.T.dot(layer_1_delta) #矩阵相乘
if(iteration % 10 == 9): #每迭代10次，打印误差
print("Error:"+str(layer_2_error))
def sim(streetlights_input):
global weights_0_1
global weights_1_2
layer_1 = relu(np.dot(streetlights_input,weights_0_1)) # layer1 output
layer_2 = np.dot(layer_1,weights_1_2) #layer2 output
#print(layer_2)
return layer_2
def main():
input_str = input("请输入网络训练迭代次数:")
iteration_times = int(input_str)
if iteration_times>0 :
train(iteration_times)
else:
print("迭代次数输入有误，程序终止！")
return
#训练完成，提示用户使用训练好的网络
while(True):
a,b,c = input("输入信号灯状态，用逗号,隔开:").split(',')
a = int(a)
b = int(b)
c = int(c)
input_data = np.array([a,b,c])
prediction = sim(input_data)
print("Prediction:"+str(prediction)+"\n")
prediction = int(round(prediction[0],0))
if prediction == 1:
print("walk now is safe.\n")
else:
print("stop,or walk to hell.\n")
if __name__ == '__main__':
main()
运行
训练100次，误差小的可以。使用训练集数据验证，效果还不错。
反向传播代码运行示例
