BP神经网络的基本原理及Python实现

神经网络由三部分组成：输入层、隐藏层以及输出层，基本结构如下图所示

其通过正向的推导得出预测的结果，这个过程称为前向反馈，

而通过预测的结果与真实结果的误差反向传播求得每个w参数对于误差E的贡献进而更新w参数，这个过程称为反向传播；

以下以二分类为例

a、前向反馈

以单个示例为例

输入层 X=[x1,x2]

隐藏层a=[a1,a2,a3]

输出层o=[o1,o2]

则有

z1=x1*w1+x2*w2+b1

z2=x1*w3+x2*w4+b1

z3=x1*w5+x2*w6+b1

隐藏层[a1,a2,a3]为

a1=f(z1) 这里激活函数f(x)以sigmoid为例

a2=f(z2)

a3=f(z3)

输出层

o1=f(a1*w7+a2*w8+a3*w9+b2)

o2=f(a1*w10+a2*w11+a3*w12+b2)

b、反向传播

通过反向传播方法对每个w参数进行求解，并通过学习速率加快优化速度，最终求出w的最优解。

c、具体的实现方法

这里使用两种方法，一种是矩阵直接求解，另一种通过迭代的方式进行求解。

# #__Author__:随心

importnumpyasnp

defsigmoid(x):

return1/(1+np.exp(-x))

defder(x):

returnx*(1-x)

train_x=np.array([[,,1],[,1,1],[1,,1],[1,1,1]])

labels=np.array([[],[1],[1],[]])

input_weight=np.random.uniform(-1.0,1.0,[3,5])

out_weight=np.random.uniform(-1.0,1.0,[5,1])

#矩阵求解

defm1(input_weight,out_weight):

forjinrange(500):

h1=sigmoid(np.dot(train_x,input_weight))

o1=sigmoid(np.dot(h1,out_weight))

error=labels-o1

error_out_w=error*der(o1)

error_input=error_out_w.dot(out_weight.T)

error_input_w=error_input*der(h1)

out_weight+=0.5*h1.T.dot(error_out_w)

input_weight+=0.5*train_x.T.dot(error_input_w)

returno1

m1(input_weight,out_weight)

#迭代求解

#第1步，求解隐含层

defhidden_(train_x,w1,n=5):

hidden_result=[]

forjinrange(n):

total=0.0

foriinrange(len(train_x)):

total+=train_x[i]*w1[i][j]

total_sim=sigmoid(total)

hidden_result.append(total_sim)

returnhidden_result

#第2步，求解输出层结果

defout_(hidden,w2):

out_result=[]

total=0.0

foriinrange(len(hidden)):

total+=hidden[i]*w2[i]

total_sim=sigmoid(total)

out_result.append(total_sim)

returnout_result[]

#第3步，反向传播算法

defback_propagate(train_data,label,input_weight,out_weight):

E_w_1=[]

E_w_2=[]

out_result=[]

hidden_arr=[]

foriinrange(len(train_data)):

hidden=hidden_(train_data[i], input_weight)

hidden_arr.append(hidden)

out=out_(hidden, out_weight)

out_result.append(out)

error=label[i]-out

E_w2=error*der(np.array(out))

E_w_2.append(E_w2)

result= []

forjinrange(len(out_weight)):

ss=E_w2*out_weight[j]

result.extend(ss)

E_w_1.append(np.array(result)*der(np.array(hidden)))

E_w1=np.array(E_w_1)

returntrain_data,np.array(hidden_arr),E_w1,np.array(E_w_2),np.array(out_result)

defmain(input_weight,out_weight,train_data,label,learn=0.5):

foriinrange(500):

train_data,hidden,E_w1,E_w2,out=back_propagate(train_data,label,input_weight,out_weight)

out_weight+=learn*hidden.T.dot(E_w2)

input_weight+=learn*train_data.T.dot(E_w1)

print(out)

if__name__=="__main__":

main(input_weight,out_weight,train_x,labels)

欢迎加群一起讨论学习~

加入我们，一起学习，一起成长，一起吹牛逼～

论坛地址：

Excel 相关ＱＱ群：

Python QQ群：

微信公众号：