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

杨利霞

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

. i% h9 ?8 E4 U背景
初次接触反向传播算法，根据C语言中文网的站长提供的思路，照着做一遍找一下感觉，其中链接如下
+ ~+ Z6 B4 v, \: t
! b' L- v' V8 y0 E4 u+ }* A( o' E【神经网络分类算法原理详解】

注意
站长提供的图片有点小问题，我们更正如下

6 x. ^' @; A: \/ J; I7 w) W
3 \7 V& L, t9 v) O
问题
. }2 J' u  N8 b. b, e根据上图所示，我们有已知
! h( b# ]: J1 U$ T. v6 w4 l2 U
6 c+ N3 ^. I' Q4 U0 b#输入层
1 o% b0 K# k, m7 K5 F# Si1=0.05
) j; V5 m8 E6 G7 t& Bi2=0.1
2 t7 z9 F! z- P$ F6 g4 T
2 R; M! B- i1 G8 g1 |#输出层
% o) n. b1 y# _( P8 }/ bo1=0.01
o2=0.99
5 o) V4 G5 t  y4 ]' g* [3 [这个神经网络是我们假想的，我们假想从输入层[i1,i2]==>>[o1,o2]的过程是这样的
; ~/ T5 O9 K( Q/ J6 p
) R# E: c; v6 I1 n4 j神经元h1的输入（h1 input 简写为 hi1)=w1*i1+w2*i2+b1

神经元h2的输入  (hi2)=w3*i1+w4*i2+b1

神经元h1接收到输入后，通过非线性转换函数【这里选择Sigmoid函数】变换得到神经元h1的输出
; ?. o' x' U+ f
神经元h1的输出  (ho1)=1.0/(1+math.exp((-1)*神经元h1的输入))
& J  z* ~) k* h
同理

/ H% ?/ W8 B7 y% s神经元h2的输出  (ho2)=1.0/(1+math.exp((-1)*神经元h2的输入))
. P# b& T- z4 u: h/ j
) x7 |% W* P6 `' i接下来我们再把隐藏层当作输入层，输出层当作隐藏层，类比推出有关神经元o1，神经元o2的一些表达式
6 u2 F+ k3 F- \0 L  p8 i. M
8 U( m" I# A8 C% D1 `3 J神经元o1的输入 (oi1)=w5*ho1+w6*ho2+b2
7 j5 Z/ c/ H" F( @: ^5 K
& r+ Z7 ^9 y& U) H: V* W神经元o2的输入 (oi2)=w7*ho1+w8*ho2+b2
& {7 ]: k0 J0 G  z$ q$ ?
再经过非线性变换Sigmoid函数得到
/ j/ ?& P' S; `2 t
神经元o1的输出 (oo1)=1.0/(1+math.exp((-1)*oi1))

) Z/ T- Y% W  y7 m* j2 z4 w神经元o2的输出 (oo2)=1.0/(1+math.exp((-1)*oi2))

+ X" W5 b; j! I3 j我们将得到的神经元o1输出，神经元o2输出跟我们知道的期望值o1,o2进行比对，定义其损失函数为
, e2 ~1 u3 [1 ~; {! g9 J& M! l) L
损失值  ( error 简写为 eo)=((oo1-o1)^2+(oo2-o2)^2)/2

0 R' t) G0 T5 c* S. Q3 ]2 J/ u由于我们的期望值精确到小数点后两位，损失函数为平方，所以我们仅需让损失容忍度(eo_allow)调整到1e-5即可满足

学习次数 (learning_time 简写为 lt)我们限定最大为10000次

学习率 (learning_rate 简写为 lr)我们设定为0.5
  Y$ A- }, {. D! d2 h6 d! d! `' S% ?
( o% p8 h% \5 J+ k; G依次求解代求参数

w1~w8，以及b1,b2
% q; K  |8 M! w+ M
跟

损失值 (eo) 的偏导数

再更新该参数，更新公式为
5 r2 j- i+ t7 D* N% ?* O# f: `
' U" g, X' A3 Q5 d参数_new=参数-学习率*偏导(eo,参数)
随后进入下一轮学习
3 e+ c5 Y. O7 o. v% y& i" {
终止条件（满足其中一个即可停止训练）

6 C2 k. F: \) W  z( `" J+ q% l# V1.学习次数达到上限
6 F$ r- e  ^) O2 H
2.损失值达到可容忍的范围

导数
0 i3 Y, A2 v7 k, j( `f(x)=1/(1+e^(-x))的导数是
2 Y9 c/ p# x! F; E. M) \0 Df'(x)=f(x)*(1-f(x))
源码
& }& r6 n0 g6 k% c# B& o  |" f% Jimport math
4 h4 {0 h5 i0 V6 n
  E" u/ r. M, m8 w#参考自网址【http://c.biancheng.net/ml_alg/ann-principle.html】
8 O. P/ J/ b$ ^! g7 l0 Y2 a#网址中图片有误，请看我博文上的图片
' Z3 q5 p, I8 w8 o" G
#输入层
i1=0.05
i2=0.1
! w* c6 B# ~6 b' d. ~( h) p! H* }#权值参数
  }4 R8 g$ G0 tw1=0.15
& W/ E# C7 r9 B5 p( [w2=0.2
# Y. W" F" @8 Hw3=0.25
* `$ k8 j. A, Q' z: I( g- mw4=0.3
/ P9 Q6 H* y; S, x! ww5=0.4
1 B- R4 H; E5 `5 Y- U' Z. o5 m( Nw6=0.45
w7=0.5
- L5 C+ g- j$ V* p* F, a: jw8=0.55
#输出层标记（即期望值）
% x- i- e2 b; k# U# D$ b6 {, F0 |o1=0.01
o2=0.99
# ~# N( c. `: Z2 j* G#偏置项参数
b1=0.35
3 A+ V8 o! w5 r* }- jb2=0.6

! J5 A. N0 a' n- Q, i#学习率
. ~5 `) v  |/ @, p  ylr=0.5
; C1 G4 i& ]. \2 g7 k' d. u#学习周期
4 [4 G7 d* g* h% R7 m) v& {) klt=0
max_lt=10000
#允许误差
eo_allow=1e-5
3 x* H9 \! |1 a, V
5 C" h1 x  y7 ]$ w. g#线性转换
def linear(w_one,w_two,i_one,i_two,b):
0 o6 c: D7 F7 G    return w_one*i_one+w_two*i_two+b
#非线性转换
5 ?$ D- [( D' ]( udef none_linear(i):
    return 1.0/(1+math.exp(-i))

7 c, Q5 S) S+ d2 Kprint("训练开始")
# B) ]/ O* q5 j5 v2 y8 z$ Z#学习周期结束前一直学习
: E$ T5 w4 s& c5 V* R5 E( iwhile lt<max_lt:
- r% _) }2 O2 L- `    lt+=1
    #求h1和h2输入值
    hi1=linear(w1,w2,i1,i2,b1)
    hi2=linear(w3,w4,i1,i2,b1)
    #求h1和h2输出值
1 u' \" y3 G8 y% ~" N3 f    ho1=none_linear(hi1)
    ho2=none_linear(hi2)
    #求o1和o2输入值
& \) e7 z9 ]+ `' Z) K5 U  D    oi1=linear(w5,w6,ho1,ho2,b2)
$ N) i6 p) B$ m, ^; {; O4 T    oi2=linear(w7,w8,ho1,ho2,b2)
. l- G5 J3 Y# T( x$ M    #求o1和o2输出值
    oo1=none_linear(oi1)
$ o3 t& i. B7 B- C) m" d    oo2=none_linear(oi2)

3 ]) \6 V9 I" l9 H    #求当前计算总误差
    eo=(math.pow(oo1-o1,2)+math.pow(oo2-o2,2))/2
6 R: `9 |3 |5 M. n4 p! v% r7 E    print(f"第{lt}次训练，当前计算总误差={eo}")
    #误差已经在允许范围，退出训练
/ k+ ]  a, S; f$ N- l0 J    if eo<eo_allow:
        print("误差已经在允许范围，训练结束\n")
3 _5 ~. Y) P6 r! w% q; [        break
    #偏导
$ ]6 ^1 j& y5 S    d_eo_oo1=oo1-o1
    d_eo_oo2=oo2-o2
    d_oo1_oi1=oo1*(1-oo1)
    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
    d_oi1_w5=ho1
8 k% U+ R% G2 e    d_eo_w5=d_eo_oi1*d_oi1_w5
5 [( W( D5 h' n( S2 n    w5_new=w5-lr*d_eo_w5
: W5 g+ S8 u7 q" h. E" K: ~- u    #求w6_new
% _$ j2 u. k' r) o$ S1 s: ~    d_oi1_w6=ho2
& v2 |* ~% @5 Q8 f% y    d_eo_w6=d_eo_oi1*d_oi1_w6
1 \5 x' O/ J  D& ~    w6_new=w6-lr*d_eo_w6
; W7 s/ t* ]/ S3 Q+ A' z9 X    #求w7_new
" A: F; \" X: J0 b    d_oi2_w7=ho1
& z- j8 F8 W! O+ k    d_eo_w7=d_eo_oi2*d_oi2_w7
. ?) p& {( M& f; p. ]    w7_new=w7-lr*d_eo_w7
    #求w8_new
    d_oi2_w8=ho2
( E- W  o1 d) |# D# a* O& i4 ~    d_eo_w8=d_eo_oi2*d_oi2_w8
    w8_new=w8-lr*d_eo_w8
& g  ?+ `% q! o7 ^1 W  `    #求b2_new
    d_oi1_b2=1
+ M! j; ^/ d  E: i3 \    d_oi2_b2=1
/ C/ [4 g% @( p7 L' C) L    d_eo_b2=d_eo_oi1*d_oi1_b2+d_eo_oi2*d_oi2_b2
; E$ w0 r& w- _. ~9 `    b2_new=b2-lr*d_eo_b2
# n% Q) H2 h2 Y5 o) U; i    d_oi1_ho1=w5
; X9 s" G4 ~  Q- |  Q" J    d_oi1_ho2=w6
3 p! f8 I9 ?6 s: }$ n1 |    d_oi2_ho1=w7
  H3 m% S1 j% U    d_oi2_ho2=w8
% r) {, k3 T/ F# M& [    d_eo_ho1=d_eo_oi1*d_oi1_ho1+d_eo_oi2*d_oi2_ho1
+ Q9 S/ p/ Z; v2 u3 v: ^- v    d_eo_ho2=d_eo_oi1*d_oi1_ho2+d_eo_oi2*d_oi2_ho2
4 L' c. V% t2 h    d_ho1_hi1=ho1*(1-ho1)
    d_ho2_hi2=ho2*(1-ho2)
+ L" A, K' p  ]% Y4 `    d_eo_hi1=d_eo_ho1*d_ho1_hi1
    d_eo_hi2=d_eo_ho2*d_ho2_hi2
/ `$ G' e4 v. X% j0 |' K9 L    #求w1_new
4 P$ N( J8 _/ K" }$ Z8 P- X. ^    d_hi1_w1=i1
    d_eo_w1=d_eo_hi1*d_hi1_w1
    w1_new=w1-lr*d_eo_w1
, L$ O% e5 ?1 ^  N8 V6 s    #求w2_new
" z) `  O' e7 t  Z1 o    d_hi1_w2=i2
    d_eo_w2=d_eo_hi1*d_hi1_w2
$ ^7 ~3 f* @0 I/ Z    w2_new=w2-lr*d_eo_w2
    #求w3_new
    d_hi2_w3=i1
    d_eo_w3=d_eo_hi2*d_hi2_w3
0 c( n+ A5 r/ ~; `; n    w3_new=w3-lr*d_eo_w3
& A0 C1 H8 e6 p2 K' ]  R/ q    #求w4_new
    d_hi2_w4=i2
    d_eo_w4=d_eo_hi2*d_hi2_w4
    w4_new=w4-lr*d_eo_w4
, b6 M8 d: s5 V( `! \. e    #求b1_new
    d_hi1_b1=1
# i6 a& C( N" j    d_hi2_b1=1
    d_eo_b1=d_eo_hi1*d_hi1_b1+d_eo_hi2*d_hi2_b1
    b1_new=b1-lr*d_eo_b1
    #更新反向传播
    w1=w1_new
    w2=w2_new
    w3=w3_new
    w4=w4_new
    b1=b1_new
    w5=w5_new
) j" d! Y% x* `7 o    w6=w6_new
' K* Q/ E5 [+ E8 |8 F    w7=w7_new
. ]; ?, L4 J/ O4 T8 Y, J! U$ ]    w8=w8_new
    b2=b2_new
# F9 {/ V) Z* H5 `! k3 U! _0 T  ^& gprint(f"当前计算总误差={eo}")
print(f"w1={w1}\nw2={w2}\nw3={w3}\nw4={w4}\nb1={b1}\n")
* T3 C& C* K1 k7 y& |+ @print(f"w5={w5}\nw6={w6}\nw7={w7}\nw8={w8}\nb2={b2}\n")
print(f"期望值:[{o1},{o2}]，预测值:[{oo1},{oo2}]")
# h( C2 q0 w, r8 }. q* _( o
5 I, b0 ~4 _1 g6 V0 }+ s结果

: ^" c/ A% D0 _) V6 c) k8 H$ p
% E. A$ g( B% Y. f结语
0 V# u$ v: }  C% g! x9 t可以看到，在经过七千多次训练之后，我们找到了一组参数满足我们假想的关系，本次人工神经网络训练完成，反向传播算法体验结果良好。

6 [% U# z, Z, Z0 J" L8 C补充
程序中d_{a}_{b}格式的变量表示a对b偏导
/ U: S( \1 J- `& H3 |————————————————
8 j* c. I$ r3 _0 w, S  ?4 {' k1 y版权声明：本文为CSDN博主「冰凌呀」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
( ?: y) r6 V; ~$ U; c% Y4 \原文链接：https://blog.csdn.net/qq_36694133/article/details/126667954


6 {3 x/ n3 A0 v