BP神经网络1

import math
import numpy as np
import pandas as pd
from pandas import DataFrame

y =[0.14 ,0.64 ,0.28 ,0.33 ,0.12 ,0.03 ,0.02 ,0.11 ,0.08 ]
x1 =[0.29 ,0.50 ,0.00 ,0.21 ,0.10 ,0.06 ,0.13 ,0.24 ,0.28 ]
x2 =[0.23 ,0.62 ,0.53 ,0.53 ,0.33 ,0.15 ,0.03 ,0.23 ,0.03 ]
theata = [-1,-1,-1,-1,-1,-1,-1,-1,-1]
x = np.array([x1,x2,theata])

W_mid = DataFrame(0.5,index=['input1','input2','theata'],columns=['mid1','mid2','mid3','mid4'])
W_out = DataFrame(0.5,index=['input1','input2','input3','input4','theata'],columns=['a'])

def sigmoid(x):  #映射函数
    return 1/(1+math.exp(-x))


#训练神经元
def train(W_out, W_mid,data,real):
    #中间层神经元输入和输出层神经元输入
    Net_in = DataFrame(data,index=['input1','input2','theata'],columns=['a'])
    Out_in = DataFrame(0,index=['input1','input2','input3','input4','theata'],columns=['a'])
    Out_in.loc['theata'] = -1

    #中间层和输出层神经元权值
    W_mid_delta = DataFrame(0,index=['input1','input2','theata'],columns=['mid1','mid2','mid3','mid4'])
    W_out_delta = DataFrame(0,index=['input1','input2','input3','input4','theata'],columns=['a'])

    #中间层的输出
    for i in range(0,4):
        Out_in.iloc[i] = sigmoid(sum(W_mid.iloc[:,i]*Net_in.iloc[:,0]))
    #输出层的输出/网络输出
    res = sigmoid(sum(Out_in.iloc[:,0]*W_out.iloc[:,0]))
    #误差
    error = abs(res-real)


    #输出层权值变化量
    #yita =学习率
    yita =0.8
    W_out_delta.iloc[:,0] = yita*res*(1-res)*(real-res)*Out_in.iloc[:,0]
    W_out_delta.iloc[4,0] = -(yita*res*(1-res)*(real-res))
    W_out = W_out + W_out_delta #输出层权值更新

    #中间层权值变化量
    for i in range(0,4):
        W_mid_delta.iloc[:,i] = yita*Out_in.iloc[i,0]*(1-Out_in.iloc[i,0])*W_out.iloc[i,0]*res*(1-res)*(real-res)*Net_in.iloc[:,0]
        W_mid_delta.iloc[2,i] = -(yita*Out_in.iloc[i,0]*(1-Out_in.iloc[i,0])*W_out.iloc[i,0]*res*(1-res)*(real-res))
    W_mid = W_mid + W_mid_delta #中间层权值更新
    return W_out,W_mid,res,error

def reault(data,W_out, W_mid):
    Net_in = DataFrame(data,index=['input1','input2','theata'],columns=['a'])
    Out_in = DataFrame(0,index=['input1','input2','input3','input4','theata'],columns=['a'])
    Out_in.loc['theata'] = -1

    #中间层的输出
    for i in range(0,4):
        Out_in.iloc[i] = sigmoid(sum(W_mid.iloc[:,i]*Net_in.iloc[:,0]))
    #输出层的输出/网络输出
    res = sigmoid(sum(Out_in.iloc[:,0]*W_out.iloc[:,0]))
    return res

for i in range(0,9):
    W_out,W_mid,res,error = train(W_out,W_mid,x[0:,i],y[i])
    
res1 = reault([0.38 ,0.49,-1 ], W_out, W_mid)
res2 = reault([0.29 ,0.47 ,-3], W_out, W_mid)
print(res1,res2)

结果：

手工搭建神经网络（书上）

 1 import numpy as np
 2 import scipy.special
 3 import scipy.misc
 4 import matplotlib.pyplot
 5 import scipy.ndimage
 6 #神经网络类定义
 7 class NeuralNetwork():
 8     #初始化神经网络
 9     def __init__(self,inputnodes,hiddenodes,outputnodes,learningrate):
10         #设置输入层节点、隐藏层节点和输出层节点的数量
11         self.inodes = inputnodes
12         self.hnodes = hiddenodes
13         self.onodes = outputnodes
14         #学习率设置
15         self.lr = learningrate
16         #权重矩阵设置，正态分布
17         self.wih = np.random.normal(0.0,pow(self.hnodes, -0.5),(self.hnodes,self.inodes))
18         self.who = np.random.normal(0.0,pow(self.onodes, -0.5),(self.onodes,self.hnodes))
19         #激活函数设置，Sigmiod函数
20         self.activation_function = lambda x:scipy.special.expit(x)
21         pass
22     #训练神经网络
23     def train(self,input_list,target_list):
24         inputs = np.array(input_list,ndmin = 2).T                  #转换输入/输出列表到二维数组
25         targets = np.array(target_list,ndmin = 2).T
26         hidden_inputs = np.dot(self.wih,inputs)                     #计算到隐藏层的信号
27         hidden_outputs = self.activation_function(hidden_inputs)    #计算隐藏层输出的信号
28         final_inputs = np.dot(self.who,hidden_outputs)               #计算到输出层的信号
29         final_outputs = self.activation_function(final_inputs)
30         output_errors = targets - final_outputs
31         hidden_errors = np.dot(self.who.T,output_errors)
32         #隐藏层和输入层权重更新
33         self.who += self.lr * np.dot((output_errors * final_outputs *(0 - final_outputs)),np.transpose(hidden_outputs))
34         #输入层和隐藏层权重更新
35         self.wih += self.lr * np.dot((hidden_errors * hidden_outputs * (0 - hidden_outputs)),np.transpose(inputs))
36         pass
37     #查询神经网络
38     def query(self,input_list):
39         inputs = np.array(input_list,ndmin = 2).T                 #转换输入列表到二维数组
40         hidden_inputs = np.dot(self.wih,inputs)                   #计算到隐藏层的信号
41         hidden_outputs = self.activation_function(hidden_inputs)  #计算隐藏层输出的信号
42         final_inputs = np.dot(self.who,hidden_outputs)            #计算到输出层的信号
43         final_outputs = self.activation_function(final_inputs)
44         return final_outputs
45         print('n')                                               #验证
46 input_nodes = 3                                             #输入层节点
47 hidden_nodes = 15                                            #隐藏层节点
48 output_nodes = 10                                           #输出层节点
49 learning_rate = 0.01                                       #学习率
50 n = NeuralNetwork(input_nodes,hidden_nodes,output_nodes,learning_rate)   #创建神经网络
51 print(n.query([0,0.5,-5]))