有监督的反向传播神经网络模型，三层网络，多输入单输出，python实现

以红绿灯为例：（用python实现）

输入集：

[[1,0,1], [0,1,1], [0,0,1],[1,1,1]]

给定输出集：[0,1,0,1]

设定的隐藏层的节点为4个，可以自由更改，alpha为0.2

import numpy as np
streetlightings = np.array([[1,0,1],
                            [0,1,1],
                            [0,0,1],
                            [1,1,1]])

walk_stop = np.array([[0,1,0,1]]).T   #做转置是为了为后面的计算方便
alpha = 0.2
hidden_size=4 #隐藏层节点数

 

这幅图像就是本模型的形象表现

def relu(x):
    return (x > 0) * x # returns x if x > 0
                       # return 0 otherwise

def relu2deriv(output):
    return output>0 # returns 1 for input > 0
                    # return 0 otherwise

for i in range(150):
    layer_2_error = 0
    print('第',i,'步')
    for a in range(len(streetlightings)):
        layer_0 = streetlightings[a:a+1]   #输入
        layer_1 = relu(np.dot(layer_0,weights0_1))  #隐藏层=输入*权重，并且将权重小于0的置为0
        layer_2 = np.dot(layer_1,weights1_2)   #输出=隐藏层*权重
        layer_2_error += np.sum((layer_2 - walk_stop[a:a+1])**2)   
        layer_2_delta = (walk_stop[a:a+1]-layer_2)     #layer2层的delta=真实值-预测值
        layer_1_delta = layer_2_delta.dot(weights1_2.T)*relu2(layer_1)    #layer1层的delta=layer_2_delta*weights1_2
        weights1_2 += alpha*layer_1.T.dot(layer_2_delta)  #第二层权重更新规则：+=alpha*第二层输入（隐藏层结果）*第二层delta
        weights0_1 += alpha*layer_0.T.dot(layer_1_delta)   #第一层权重更新规则： +=alpha*第一层输入*第一层delta
    print("error:",layer_2_error)