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

杨利霞

人工神经网络——反向传播算法初体验（python实现）
, p( K' X. g8 }, y! @+ u
9 M7 F0 f- K( C背景
& k/ t7 b; Q) H; C& q初次接触反向传播算法，根据C语言中文网的站长提供的思路，照着做一遍找一下感觉，其中链接如下
, N7 r/ @& d& n! D  U
【神经网络分类算法原理详解】

注意
4 P5 ?+ C" r( h4 |( Q; N站长提供的图片有点小问题，我们更正如下


; t; l4 N/ n1 r+ |2 h1 u
问题
+ v: i" A+ q, }1 L根据上图所示，我们有已知

: j2 _: R' ]. L* ^* x( i#输入层
i1=0.05
i2=0.1

#输出层
' i4 s! ?( F8 r- [5 C8 y; Lo1=0.01
o2=0.99
- y8 x) {  c0 a! c0 p6 ?% @& i这个神经网络是我们假想的，我们假想从输入层[i1,i2]==>>[o1,o2]的过程是这样的
3 w/ }" S+ ~/ s& z/ T
神经元h1的输入（h1 input 简写为 hi1)=w1*i1+w2*i2+b1
6 h' C, }4 E: _( g# k0 M2 m
& K) V! u. c- p! O. j& J. b神经元h2的输入  (hi2)=w3*i1+w4*i2+b1

2 T$ }8 x/ T, V: T神经元h1接收到输入后，通过非线性转换函数【这里选择Sigmoid函数】变换得到神经元h1的输出
' m2 y8 F( t5 C0 q3 o
神经元h1的输出  (ho1)=1.0/(1+math.exp((-1)*神经元h1的输入))

同理

$ j0 ?7 R% E; l神经元h2的输出  (ho2)=1.0/(1+math.exp((-1)*神经元h2的输入))
- {1 p" ?& Q. l3 v0 @, O
接下来我们再把隐藏层当作输入层，输出层当作隐藏层，类比推出有关神经元o1，神经元o2的一些表达式

8 c% T2 s: }' g7 |* j神经元o1的输入 (oi1)=w5*ho1+w6*ho2+b2

! i1 h( y* ^* B  w+ g0 \; J" ?神经元o2的输入 (oi2)=w7*ho1+w8*ho2+b2
$ E( r0 _4 W5 t/ T/ S4 t. k
4 W9 K: {9 J& S* K/ ]# `; ~4 H3 U再经过非线性变换Sigmoid函数得到
8 Y3 r! p  ]8 P7 _$ c8 i# E- p0 `
9 E1 Q/ b5 M) C4 U! H+ W  b. g神经元o1的输出 (oo1)=1.0/(1+math.exp((-1)*oi1))
4 \" L' ]! P0 _8 Y
8 l! ]/ O3 p4 u( W9 F; Y- G神经元o2的输出 (oo2)=1.0/(1+math.exp((-1)*oi2))

我们将得到的神经元o1输出，神经元o2输出跟我们知道的期望值o1,o2进行比对，定义其损失函数为

损失值  ( error 简写为 eo)=((oo1-o1)^2+(oo2-o2)^2)/2
5 l6 A( t% A3 V+ J
由于我们的期望值精确到小数点后两位，损失函数为平方，所以我们仅需让损失容忍度(eo_allow)调整到1e-5即可满足
, Y0 q3 _* g; J& Z3 J4 U! l" O7 r
- L0 S3 Q& W+ z学习次数 (learning_time 简写为 lt)我们限定最大为10000次
8 O- a' {5 C$ i8 M. l& ]
学习率 (learning_rate 简写为 lr)我们设定为0.5
- B$ r0 F: `: i1 B0 j
依次求解代求参数

8 f4 Y6 d8 a7 e) B( F9 J! u: x7 Hw1~w8，以及b1,b2
5 u& n% X, m$ A5 h4 c' {0 \7 @$ u
6 y1 c* w' [: L' Z* z9 ?. r. p跟
- }: _* ^& L/ Y4 y: _9 X1 Q
损失值 (eo) 的偏导数

再更新该参数，更新公式为
0 H* x* G# ^% ]& X6 k* s; _7 `
参数_new=参数-学习率*偏导(eo,参数)
) x7 t* j" Q. H/ f1 r) \+ i6 J" P! K随后进入下一轮学习
, w* n+ q, T* Y1 G
# K  @5 O  x* a# @/ n9 _) ?终止条件（满足其中一个即可停止训练）
" [# ~) G- W# h2 Z$ c$ i
$ S5 }* N# f, p+ Z1.学习次数达到上限

* Z/ u) s; N' s2.损失值达到可容忍的范围

导数
, y4 C8 T6 F$ ?+ [0 g" ff(x)=1/(1+e^(-x))的导数是
0 [4 d! o9 ~. p' Q% U; a4 t, N8 ^f'(x)=f(x)*(1-f(x))
源码
import math
  u, e: Y) |# @' R5 M8 u
#参考自网址【http://c.biancheng.net/ml_alg/ann-principle.html】
#网址中图片有误，请看我博文上的图片
) L3 [& m% u: o% e4 \4 @# w9 T
#输入层
0 @' B5 Z, D/ [, [, Vi1=0.05
i2=0.1
& z- l, e; m0 P2 l3 \3 x#权值参数
$ `5 r: }! Q, t3 f3 cw1=0.15
w2=0.2
w3=0.25
  K9 q8 L, w$ Z0 t7 ~+ gw4=0.3
w5=0.4
w6=0.45
: |8 {) H4 v" Mw7=0.5
! A9 V' n: k4 q+ S" ?7 ]! c6 ?w8=0.55
#输出层标记（即期望值）
o1=0.01
$ S8 Y4 l% M$ I' [o2=0.99
#偏置项参数
- s/ O! z2 S+ I7 n) P; ^* F( A1 |b1=0.35
b2=0.6

5 O2 ]( d. s& {& D/ W#学习率
lr=0.5
#学习周期
lt=0
! E% h. f  d. w% |$ n% F4 W$ ~0 Amax_lt=10000
; Z, S3 V# C$ n! K#允许误差
eo_allow=1e-5

2 m0 m) k; j1 }. O2 d) s7 A1 ~  O#线性转换
def linear(w_one,w_two,i_one,i_two,b):
    return w_one*i_one+w_two*i_two+b
8 E& ]  ~2 ^6 c% y#非线性转换
def none_linear(i):
    return 1.0/(1+math.exp(-i))

/ |, f: A! \0 j+ L$ R! O6 Kprint("训练开始")
) `9 c: P; A1 D8 [#学习周期结束前一直学习
% H5 G3 R) C8 i( P- v/ E4 Z; Kwhile lt<max_lt:
2 ]% a7 n4 ]. D8 \' n8 Q8 U    lt+=1
    #求h1和h2输入值
    hi1=linear(w1,w2,i1,i2,b1)
    hi2=linear(w3,w4,i1,i2,b1)
    #求h1和h2输出值
; P. [# k9 k" r6 n' \/ k; d    ho1=none_linear(hi1)
3 s1 p! B( c. r" p5 Y  k2 x    ho2=none_linear(hi2)
6 R- I' n5 V( m" L( o+ L/ Z7 K    #求o1和o2输入值
    oi1=linear(w5,w6,ho1,ho2,b2)
- f, K) D8 B4 s% V2 r/ k" q) \6 |    oi2=linear(w7,w8,ho1,ho2,b2)
    #求o1和o2输出值
* P  L0 M9 w# p" o6 z, s& l9 x" J. T    oo1=none_linear(oi1)
    oo2=none_linear(oi2)

    #求当前计算总误差
* b9 r' `* m5 _    eo=(math.pow(oo1-o1,2)+math.pow(oo2-o2,2))/2
    print(f"第{lt}次训练，当前计算总误差={eo}")
0 V4 k5 w  b6 b# v: e2 m2 C    #误差已经在允许范围，退出训练
& N' k' e( `: h9 [    if eo<eo_allow:
        print("误差已经在允许范围，训练结束\n")
6 u. s& i! z) T; A+ H        break
. {4 Q7 k& A2 U) B, P    #偏导
    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
# s  K% L: [* K7 L$ d. F$ D4 B    #求w5_new
    d_oi1_w5=ho1
    d_eo_w5=d_eo_oi1*d_oi1_w5
7 o/ S1 a0 s. \/ A, P    w5_new=w5-lr*d_eo_w5
- e& n3 X( F% `    #求w6_new
0 r. R9 ~, f8 {: m, N    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
$ t+ j. S; z7 `5 }    #求w8_new
# O& y8 ]: p3 V. \( M  ?    d_oi2_w8=ho2
5 D  H$ x/ P/ |; @, y: t    d_eo_w8=d_eo_oi2*d_oi2_w8
    w8_new=w8-lr*d_eo_w8
    #求b2_new
" o7 k' q! a3 T    d_oi1_b2=1
% f3 G1 s3 R/ D' O: A% p    d_oi2_b2=1
  h1 y3 h0 f+ C) [3 E% k- N+ B  M    d_eo_b2=d_eo_oi1*d_oi1_b2+d_eo_oi2*d_oi2_b2
    b2_new=b2-lr*d_eo_b2
; z9 Y2 S0 G  `" ~, U    d_oi1_ho1=w5
" H4 [& m. F7 g    d_oi1_ho2=w6
    d_oi2_ho1=w7
+ F8 ~5 W( ?2 m* z    d_oi2_ho2=w8
    d_eo_ho1=d_eo_oi1*d_oi1_ho1+d_eo_oi2*d_oi2_ho1
: e* G! _, N6 ~: a! s1 J- P    d_eo_ho2=d_eo_oi1*d_oi1_ho2+d_eo_oi2*d_oi2_ho2
: F  @! J% V2 k. J    d_ho1_hi1=ho1*(1-ho1)
! U# s/ y2 ]5 f7 _2 }    d_ho2_hi2=ho2*(1-ho2)
    d_eo_hi1=d_eo_ho1*d_ho1_hi1
. ]& ~4 a. n" c2 Q: h$ e    d_eo_hi2=d_eo_ho2*d_ho2_hi2
6 Z  ?7 C8 n: c( L1 W    #求w1_new
, U1 x2 W$ @( D7 A! K# c    d_hi1_w1=i1
    d_eo_w1=d_eo_hi1*d_hi1_w1
- i2 v! c' `: w5 a3 E3 r    w1_new=w1-lr*d_eo_w1
    #求w2_new
    d_hi1_w2=i2
8 N& e; i% x/ E    d_eo_w2=d_eo_hi1*d_hi1_w2
2 i- D* J, ~7 C. Q    w2_new=w2-lr*d_eo_w2
9 p  k+ g9 G2 A+ [    #求w3_new
7 X4 w+ T# q/ M* n/ ^+ a8 C  u: }8 i    d_hi2_w3=i1
    d_eo_w3=d_eo_hi2*d_hi2_w3
% h& C( B: M- _4 ~5 g; l' i, `) X! m$ @    w3_new=w3-lr*d_eo_w3
    #求w4_new
    d_hi2_w4=i2
. E  W& q* }8 g9 @    d_eo_w4=d_eo_hi2*d_hi2_w4
    w4_new=w4-lr*d_eo_w4
; {) t3 e* A2 P$ A; B    #求b1_new
    d_hi1_b1=1
    d_hi2_b1=1
0 L' l8 }! H- u0 T# ^: P    d_eo_b1=d_eo_hi1*d_hi1_b1+d_eo_hi2*d_hi2_b1
: h) n7 |" ^/ J    b1_new=b1-lr*d_eo_b1
    #更新反向传播
5 V* Z; m& W# i3 s' v    w1=w1_new
# Y# l) d: k+ V5 [" E7 }4 S    w2=w2_new
    w3=w3_new
" Q) b$ y0 U/ k    w4=w4_new
    b1=b1_new
    w5=w5_new
    w6=w6_new
    w7=w7_new
( j8 T5 J" J5 j  S# }    w8=w8_new
! B8 S, }8 U* m. k    b2=b2_new
print(f"当前计算总误差={eo}")
) z! [- ~# N' Q3 wprint(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")
print(f"期望值:[{o1},{o2}]，预测值:[{oo1},{oo2}]")

结果
+ j. L! P! j) o$ |
. t5 N1 W. w- t0 H; d: R4 ~
结语
可以看到，在经过七千多次训练之后，我们找到了一组参数满足我们假想的关系，本次人工神经网络训练完成，反向传播算法体验结果良好。

补充
程序中d_{a}_{b}格式的变量表示a对b偏导
/ ?1 @( S% \2 \————————————————
+ c/ F% m5 \0 z. m4 u版权声明：本文为CSDN博主「冰凌呀」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_36694133/article/details/126667954
! Z4 j8 y+ O( t& ?# `$ e