人工神经网络——反向传播算法初体验（python实现）

杨利霞

人工神经网络——反向传播算法初体验（python实现）
7 |* K; l% ?( a  k, }3 _
2 ], d- G6 O; p# T/ C1 p0 q背景
初次接触反向传播算法，根据C语言中文网的站长提供的思路，照着做一遍找一下感觉，其中链接如下
* }7 p! C1 T& T8 s# N$ P0 r
1 ?4 T" i5 q: e6 U' {$ l【神经网络分类算法原理详解】

0 g! d+ U) Z# V. N3 \注意
6 Y9 y2 s0 m8 [- v$ ^站长提供的图片有点小问题，我们更正如下
$ J0 O- E6 a$ c; F) N( q. \
7 h; B% |- j) u* h% ]

$ c. [3 L; J$ h( W; J* g问题
根据上图所示，我们有已知
! c: S, I( ?: l0 N/ R
2 U$ ^& U9 U( j2 B5 P' J#输入层
i1=0.05
i2=0.1
; N( m" X' J3 F) ?$ p# y& g9 f
#输出层
o1=0.01
o2=0.99
这个神经网络是我们假想的，我们假想从输入层[i1,i2]==>>[o1,o2]的过程是这样的
) ?' v* W- B) j8 C9 ~
, ?  B$ N7 X& \7 D神经元h1的输入（h1 input 简写为 hi1)=w1*i1+w2*i2+b1

神经元h2的输入  (hi2)=w3*i1+w4*i2+b1
' t6 H- A6 v" n# p0 x
神经元h1接收到输入后，通过非线性转换函数【这里选择Sigmoid函数】变换得到神经元h1的输出
( I! K% [  R9 _, W$ `
  n7 }) n* ], I8 L: v! [* C# {神经元h1的输出  (ho1)=1.0/(1+math.exp((-1)*神经元h1的输入))

同理
$ X8 v& M% ~0 ^$ k& b# |
4 W5 f- `. E' m0 r) I) Q神经元h2的输出  (ho2)=1.0/(1+math.exp((-1)*神经元h2的输入))

接下来我们再把隐藏层当作输入层，输出层当作隐藏层，类比推出有关神经元o1，神经元o2的一些表达式
$ H6 X( |9 V- P& ?+ o
$ b, Q- ]; N1 `' D# w) j神经元o1的输入 (oi1)=w5*ho1+w6*ho2+b2

神经元o2的输入 (oi2)=w7*ho1+w8*ho2+b2

再经过非线性变换Sigmoid函数得到
+ V9 a+ S2 P! h8 D  G
神经元o1的输出 (oo1)=1.0/(1+math.exp((-1)*oi1))
$ t0 x2 a; t" \4 G* b7 G* Y5 W
5 _* k1 a6 ]) E8 u, ]: k4 [神经元o2的输出 (oo2)=1.0/(1+math.exp((-1)*oi2))
# K9 G! F7 V, D. d. ~! K% H. h, d
3 I, \, c+ K8 j我们将得到的神经元o1输出，神经元o2输出跟我们知道的期望值o1,o2进行比对，定义其损失函数为
; t9 d6 O* k& S& d
3 F$ l5 |+ i/ i& o损失值  ( error 简写为 eo)=((oo1-o1)^2+(oo2-o2)^2)/2
6 o/ C# X8 ]4 o
' I8 g: J* @( M% o由于我们的期望值精确到小数点后两位，损失函数为平方，所以我们仅需让损失容忍度(eo_allow)调整到1e-5即可满足
3 _5 n6 s( k% b' s  ]+ N3 E
& R) v" R" H2 u7 y学习次数 (learning_time 简写为 lt)我们限定最大为10000次
$ w  }/ e3 t: Q/ \: H7 I7 ~
学习率 (learning_rate 简写为 lr)我们设定为0.5

) V+ o/ Z) x! }+ S依次求解代求参数

$ w& ]* F! V+ J" _8 @w1~w8，以及b1,b2
( M: i* S; b- a1 x' p3 @
6 I) r$ k+ G: [* n2 ~$ V跟
% ~3 N6 s8 S& Q9 A$ T1 f
( J5 w- o. ]( g" W损失值 (eo) 的偏导数
% E, F  L' J: \  x4 B( B
2 B. j* ]7 |4 ]. _  q2 C5 H+ y+ s再更新该参数，更新公式为

( a* Y1 d- N6 V$ {2 A参数_new=参数-学习率*偏导(eo,参数)
随后进入下一轮学习
% ?& x& y( t# w  }
终止条件（满足其中一个即可停止训练）

3 d7 t7 o3 [$ M: G, j" H2 ?" _/ i1.学习次数达到上限

: T9 m+ v& `, \% ^2.损失值达到可容忍的范围

4 ]/ }# ^% R* m- Z& U6 y- G导数
f(x)=1/(1+e^(-x))的导数是
f'(x)=f(x)*(1-f(x))
源码
import math

  ^' M5 C+ m0 Y) H: a8 C' ~3 M: X8 |#参考自网址【http://c.biancheng.net/ml_alg/ann-principle.html】
#网址中图片有误，请看我博文上的图片

#输入层
i1=0.05
i2=0.1
#权值参数
8 o  a* s! z9 t: d* t* S% H7 `2 Cw1=0.15
( L1 ?! W, G$ u" G1 h  Ww2=0.2
w3=0.25
' r4 j- D0 S! ?! sw4=0.3
w5=0.4
9 y' O+ E) u3 Q6 ]9 O" c% P3 p8 Gw6=0.45
9 ?( M1 Y! n$ R6 P* \w7=0.5
w8=0.55
5 U/ ~4 [  i% o/ x8 B3 D#输出层标记（即期望值）
o1=0.01
o2=0.99
#偏置项参数
  z+ ^6 D4 q3 w+ `8 _: xb1=0.35
, q7 y( |' ~3 j* i3 S" gb2=0.6

#学习率
lr=0.5
#学习周期
lt=0
9 G" D! b+ d2 W. _$ x! Nmax_lt=10000
, \5 N, ]" }+ [! `1 u3 O#允许误差
* F0 @0 I, `+ N( Feo_allow=1e-5
3 h  [: J5 ~; n- J& T* Y
1 _2 v, y+ i3 }+ O8 |. w$ Q#线性转换
def linear(w_one,w_two,i_one,i_two,b):
    return w_one*i_one+w_two*i_two+b
#非线性转换
8 Q+ w$ _3 }2 udef none_linear(i):
; a$ A3 p  K5 r& x    return 1.0/(1+math.exp(-i))

print("训练开始")
#学习周期结束前一直学习
6 W1 Q( E$ O* N  U6 `5 Xwhile lt<max_lt:
    lt+=1
    #求h1和h2输入值
: B% O8 w7 S+ J% j+ H    hi1=linear(w1,w2,i1,i2,b1)
    hi2=linear(w3,w4,i1,i2,b1)
    #求h1和h2输出值
    ho1=none_linear(hi1)
    ho2=none_linear(hi2)
, h0 }' V7 N8 u. ?1 Y/ z    #求o1和o2输入值
    oi1=linear(w5,w6,ho1,ho2,b2)
    oi2=linear(w7,w8,ho1,ho2,b2)
    #求o1和o2输出值
9 {6 T% }/ C8 M7 o9 s1 U    oo1=none_linear(oi1)
4 r4 d" H. ~- o  j1 r$ y& j) @    oo2=none_linear(oi2)

7 S$ b- ^; u. F0 A; H0 W0 C9 s    #求当前计算总误差
/ m% c: o& R! G2 J1 c. D    eo=(math.pow(oo1-o1,2)+math.pow(oo2-o2,2))/2
    print(f"第{lt}次训练，当前计算总误差={eo}")
    #误差已经在允许范围，退出训练
9 X% K" S" C" T% p) T2 T    if eo<eo_allow:
        print("误差已经在允许范围，训练结束\n")
        break
    #偏导
    d_eo_oo1=oo1-o1
    d_eo_oo2=oo2-o2
    d_oo1_oi1=oo1*(1-oo1)
/ O( E* c( s; s. Q5 s# h/ Y    d_oo2_oi2=oo2*(1-oo2)
    d_eo_oi1=d_eo_oo1*d_oo1_oi1
    d_eo_oi2=d_eo_oo2*d_oo2_oi2
    #求w5_new
4 j: e+ T4 E0 [: c    d_oi1_w5=ho1
: }9 B& b4 ]7 |+ |0 E4 H# m$ {    d_eo_w5=d_eo_oi1*d_oi1_w5
    w5_new=w5-lr*d_eo_w5
    #求w6_new
* e, u; {7 D& w# t+ L# T    d_oi1_w6=ho2
    d_eo_w6=d_eo_oi1*d_oi1_w6
    w6_new=w6-lr*d_eo_w6
    #求w7_new
    d_oi2_w7=ho1
    d_eo_w7=d_eo_oi2*d_oi2_w7
    w7_new=w7-lr*d_eo_w7
0 B7 E9 T: P3 s$ c2 S9 D$ I& x    #求w8_new
5 M9 B0 q5 g  t+ q% w    d_oi2_w8=ho2
( A# A. y* O& G; R% Y' Q    d_eo_w8=d_eo_oi2*d_oi2_w8
0 V3 w5 F$ i+ W* a3 J* K    w8_new=w8-lr*d_eo_w8
    #求b2_new
    d_oi1_b2=1
! E3 H( V/ \7 r8 r( ^0 ]* L, o    d_oi2_b2=1
9 B7 k9 G8 n/ Y+ c' X  S& ~/ M8 ^    d_eo_b2=d_eo_oi1*d_oi1_b2+d_eo_oi2*d_oi2_b2
    b2_new=b2-lr*d_eo_b2
    d_oi1_ho1=w5
* G$ D; O! F" P9 m9 ]7 f' h; E' S/ U    d_oi1_ho2=w6
  l$ V8 X3 c  f& f# T) z" P  X    d_oi2_ho1=w7
    d_oi2_ho2=w8
0 E! v: m: j6 S" u4 P    d_eo_ho1=d_eo_oi1*d_oi1_ho1+d_eo_oi2*d_oi2_ho1
* F% w9 Q/ G8 z2 [7 `2 b$ D    d_eo_ho2=d_eo_oi1*d_oi1_ho2+d_eo_oi2*d_oi2_ho2
    d_ho1_hi1=ho1*(1-ho1)
7 N' W" L4 \1 f% ^8 \    d_ho2_hi2=ho2*(1-ho2)
    d_eo_hi1=d_eo_ho1*d_ho1_hi1
    d_eo_hi2=d_eo_ho2*d_ho2_hi2
    #求w1_new
    d_hi1_w1=i1
    d_eo_w1=d_eo_hi1*d_hi1_w1
    w1_new=w1-lr*d_eo_w1
- m% f, ?, [9 G3 A9 ?6 r    #求w2_new
    d_hi1_w2=i2
    d_eo_w2=d_eo_hi1*d_hi1_w2
    w2_new=w2-lr*d_eo_w2
    #求w3_new
7 a" q' t9 p0 U  }* S    d_hi2_w3=i1
# G- x' R/ J- l7 @0 R, H5 Y( ]    d_eo_w3=d_eo_hi2*d_hi2_w3
8 T/ _8 D& D. F5 q. K    w3_new=w3-lr*d_eo_w3
    #求w4_new
6 [. m5 }8 ]9 O6 F  R    d_hi2_w4=i2
    d_eo_w4=d_eo_hi2*d_hi2_w4
) q6 K- A( ?; w    w4_new=w4-lr*d_eo_w4
    #求b1_new
# D" q: {" ~6 L% I1 _+ V) ^; }' O9 Y    d_hi1_b1=1
    d_hi2_b1=1
    d_eo_b1=d_eo_hi1*d_hi1_b1+d_eo_hi2*d_hi2_b1
+ }; S7 [4 q- v4 h9 k- Y$ \    b1_new=b1-lr*d_eo_b1
    #更新反向传播
4 ^  g- T3 N+ v" u. Y    w1=w1_new
2 {5 m7 p. ]$ B9 X( Q    w2=w2_new
    w3=w3_new
- x' }9 ~% c# ~    w4=w4_new
    b1=b1_new
    w5=w5_new
) F/ W) ^+ h0 I! m8 Z- H+ O4 b* n& O    w6=w6_new
    w7=w7_new
4 x# k* n* K7 a0 s. x0 m. \+ J    w8=w8_new
    b2=b2_new
" P, ]. j- X4 ]8 \1 @print(f"当前计算总误差={eo}")
print(f"w1={w1}\nw2={w2}\nw3={w3}\nw4={w4}\nb1={b1}\n")
print(f"w5={w5}\nw6={w6}\nw7={w7}\nw8={w8}\nb2={b2}\n")
9 z) @5 x; F( \) yprint(f"期望值:[{o1},{o2}]，预测值:[{oo1},{oo2}]")

结果
, A* P$ S7 `0 Y' I8 U$ q+ v$ ?  T
7 Q; a% m3 ^/ ]8 w, Q
/ n. v( a4 ?, c% ]结语
可以看到，在经过七千多次训练之后，我们找到了一组参数满足我们假想的关系，本次人工神经网络训练完成，反向传播算法体验结果良好。

4 l2 V' Y" K+ r( n' ^8 O补充
4 p( @  N8 \+ y" ]6 J, P2 ?程序中d_{a}_{b}格式的变量表示a对b偏导
& ?: ?1 q# H. X& N$ M0 Z3 O1 U————————————————
版权声明：本文为CSDN博主「冰凌呀」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
6 h2 C6 D# R3 P. v* X6 _4 R3 p原文链接：https://blog.csdn.net/qq_36694133/article/details/126667954
5 M; i" o( ]! u$ c7 Y: Y

1 b; ^- A6 m1 g) e+ t; n+ P