随机梯度下降算法SGD（Stochastic gradient descent）

2744557306

SGD是什么
SGD是Stochastic Gradient Descent（随机梯度下降）的缩写，是深度学习中常用的优化算法之一。SGD是一种基于梯度的优化算法，用于更新深度神经网络的参数。它的基本思想是，在每一次迭代中，随机选择一个小批量的样本来计算损失函数的梯度，并用梯度来更新参数。这种随机性使得算法更具鲁棒性，能够避免陷入局部极小值，并且训练速度也会更快。
$ g: G- \. A' W7 s怎么理解梯度？
5 I& q7 b& b5 ~2 H# i5 k假设你在爬一座山，山顶是你的目标。你知道自己的位置和海拔高度，但是不知道山顶的具体位置和高度。你可以通过观察周围的地形来判断自己应该往哪个方向前进，并且你可以根据海拔高度的变化来判断自己是否接近山顶。
7 E' l4 l* O  R0 B$ d4 \
在这个例子中，你就可以把自己看作是一个模型，而目标就是最小化海拔高度（损失函数）。你可以根据周围的地形（梯度）来判断自己应该往哪个方向前进，这就相当于使用梯度下降法来更新模型的参数（你的位置和海拔高度）。

' y/ K& d) _+ u7 A; b! A每次你前进一步，就相当于模型更新一次参数，然后重新计算海拔高度。如果你发现海拔高度变小了，就说明你走对了方向，可以继续往这个方向前进；如果海拔高度变大了，就说明你走错了方向，需要回到上一个位置重新计算梯度并选择一个新的方向前进。通过不断重复这个过程，最终你会到达山顶，也就是找到了最小化损失函数的参数。

为什么引入SGD
深度神经网络通常有大量的参数需要学习，因此优化算法的效率和精度非常重要。传统的梯度下降算法需要计算全部样本的梯度，非常耗时，并且容易受到噪声的影响。随机梯度下降算法则可以使用一小部分样本来计算梯度，从而大大提高了训练速度和鲁棒性。此外，SGD还可以避免陷入局部极小值，使得训练结果更加准确。
, W! @. {/ Z8 j- g2 h
& q7 X. R# x. _9 ~/ S6 I怎么用SGD

1. import torch- o8 J$ ]/ d  a; j
   
2. 
   : ]* y3 W( C* N\" _
3. from torch import nn
   ( v\" V6 Y6 }' o0 o* n2 I8 u) E
4. 8 f: f# [' J' e! A/ I0 y
   
5. from torch import optim) A7 B; z8 N$ B( W1 ^
   
6. ; Y0 d- w+ \) B* X\" G  x' w. A
   
7. 
   $ Q0 ?1 o: @5 R: C
8. 
   ! d: q' t3 ?! s0 f
9. data = torch.tensor([[0,0],[0,1],[1,0],[1,1.]], requires_grad=True)
   ) W& f; a' Z( }5 s+ c/ a
10. 
    \" w4 k; ~5 f$ z; j& K8 v4 w
11. target = torch.tensor([[0],[0],[1],[1.]], requires_grad=True)
    , Z\" _# I- r+ D1 M) J\" I3 `
12. * C* B7 }% N, F' d6 @\" N
    
13. 
    , B( Z: J\" ~# t) u+ ]2 O. U% M) s
14. # y% t  R, ?6 J) k6 D8 U3 c$ j1 y( x
    
15. model = nn.Linear(2, 1)
    ! w( m6 z9 l. Y6 \  I
16. 
    % d: r$ d' i4 T- x( s: Z
17. 
    - _& [! O9 g4 X4 L% m2 l
18. 3 K0 X7 p/ F! L
    
19. def train():1 F, S5 a; V% h; `+ G1 V
    
20. - s% y/ H\" s. C) n, {0 y6 p
    
21.     opt = optim.SGD(params=model.parameters(), lr=0.1)
    / p6 w. w! N, p* P
22. 
    ; W! o9 W7 _3 K9 i8 v8 p, d- \5 o
23.     for iter in range(20):
    * S; g- R# Y3 R/ y* o7 N' V
24. 
    - L; ?* U) \4 J' l: \1 P+ t
25.         # 1) 消除之前的梯度（如果存在）! j' P4 F- N. H6 \- @
    
26. 5 I( D# O( L; j\" s3 }& f9 |
    
27.         opt.zero_grad()( e% [* ?! q* ?. [
    
28. * P; p  I  l- X$ O% S
    
29. 2 [' Y' Q; R9 R/ I9 w! `
    
30. % K+ Y9 E' l. }+ B$ e- c7 o
    
31.         # 2) 预测9 v7 v# V+ D8 d% T: y
    
32. 
    # @\" _% r0 C+ S; N$ U9 m& h. [
33.         pred = model(data)
    : N8 K1 l3 Q# q5 X6 k
34. 
    / s4 t5 G* N4 B5 y, A1 ?( D
35. 8 w. k* l+ {+ z: s
    
36. ! P: x5 Y) N8 k$ J
    
37.         # 3) 计算损失, I0 d3 |. A3 y! B0 Y
    
38. 
    & I4 z. j/ a. T& p% N\" i$ r7 I
39.         loss = ((pred - target)**2).sum()+ c$ Y; a  C' n' p7 a, U+ L
    
40. 
    6 `' D: p1 D' \1 n1 I% N
41. 
    ! h3 ]; W$ m\" {+ p8 ~3 X; O
42. 
    \" D! V3 V( E, n0 M6 Z2 V# l' G+ D$ O
43.         # 4) 指出那些导致损失的参数（损失回传）! E9 Z! v- C. a/ b( D6 ~- U1 D' I
    
44. - X$ I# C* B, {$ t
    
45.         loss.backward()
    ; e) g7 i7 N- h: i0 ]
46. * O# W; }9 F6 q0 j( G* A
    
47.     for name, param in model.named_parameters():
    % t, K) d\" [6 b0 O8 N3 o1 r
48. / e6 O2 T& x& U7 s\" g
    
49.             print(name, param.data, param.grad)
    + g' Q$ h3 i& W2 @/ _0 r' n+ }( C  K
50. 
    ' y\" d. x6 G8 q1 P, l) V\" V6 k
51.         # 5) 更新参数2 J8 L  L7 T' q# W0 e9 `$ q5 [' q
    
52. 
    & c0 Q8 z& T- K+ l6 m# Q; H2 s) p
53.         opt.step()5 }) p6 e9 T! {* ^3 Y
    
54. 4 a3 N- K, B4 N+ R1 K$ b3 q: Q
    
55. 
    . f! z' z/ H% W8 S3 {
56. ; P2 U8 _1 @9 N% {0 @2 x
    
57.         # 6) 打印进程- O2 d9 `1 S\" }4 T& x\" M7 K
    
58. + a0 w9 x; B4 `% j4 T% v
    
59.         print(loss.data)4 b# y$ x, a5 @: w' ^7 Z  q/ U/ P
    
60. 
    ; `0 B3 h/ M8 L, O/ X/ S- C' i2 ^
61. : v. B% I% L# F
    
62. 
    5 F! f) x# s! J5 u
63. if __name__ == "__main__":
    ! u6 Z( L5 P6 H( h0 p# v( {+ k
64. & x, o) Z+ M( L9 \$ C
    
65.     train()
    9 \1 g9 O9 i# ^! j) W: R/ U# Y
66. 
    4 a0 F7 ]$ d* _4 `) u9 o

复制代码

param.data是参数的当前值，而param.grad是参数的梯度值。在进行反向传播计算时，每个参数都会被记录其梯度信息，以便在更新参数时使用。通过访问param.data和param.grad，可以查看参数当前的值和梯度信息。值得注意的是，param.grad在每次调用backward()后都会自动清空，因此如果需要保存梯度信息，应该在计算完梯度之后及时将其提取并保存到其他地方。
0 x1 ~0 g; I' R0 K: z' W: t- n
' C/ b! u7 t* J! R( H& I计算结果：

1. weight tensor([[0.4456, 0.3017]]) tensor([[-2.4574, -0.7452]])3 ~( N+ t/ g) n0 w# k. t# n* ?
   
2. ( \6 d0 q8 I% C5 a* _/ G
   
3. bias tensor([-0.2108]) tensor([-2.6971])* s  H0 A; r0 w1 G) R
   
4. 
   - d$ \2 K+ G& S1 ?
5. tensor(0.8531), ?8 M. e6 i: T
   
6. 
   6 [: d& L: z: w& x; s
7. weight tensor([[0.6913, 0.3762]]) tensor([[-0.2466,  1.1232]])
   9 l! \+ D9 u2 {4 R& A1 {4 p
8. 9 }7 s5 ^3 V5 R# M3 `. g- b
   
9. bias tensor([0.0589]) tensor([0.7416])
   * Y: y% \  ^+ Y6 O3 I! k
10. 
    5 w6 j\" I6 d1 M
11. tensor(0.2712)
    + Z1 [& {# q3 B9 d1 e6 w
12. 
    # D9 R' d5 c, x, E9 i7 p6 G% \# D' C6 F
13. weight tensor([[0.7160, 0.2639]]) tensor([[-0.6692,  0.4266]])
    4 X\" d: F\" f9 B
14. 
    $ O5 Z4 Y: O  b
15. bias tensor([-0.0152]) tensor([-0.2023])
    6 V! l! H$ N( g& M& O: H0 `% R& h0 y
16. 6 V  o- P9 d- Q& ^# Q
    
17. tensor(0.1529)
    % G4 w* W5 B4 J& W
18. 
    : F* D* \/ p: q8 a8 t
19. weight tensor([[0.7829, 0.2212]]) tensor([[-0.4059,  0.4707]])
    5 ~2 G/ a  d% S* j
20. / m: Z1 s/ d1 m* l8 M
    
21. bias tensor([0.0050]) tensor([0.0566])& l! r# f1 `# }
    
22. ! X  h+ _# N2 t9 h  T4 T
    
23. tensor(0.0963); m6 D( G; g! c! b2 H5 e
    
24. 
    + x4 r; _$ S) H5 x\" l# D4 C
25. weight tensor([[0.8235, 0.1741]]) tensor([[-0.3603,  0.3410]])9 Y6 h1 g% [# ?8 W
    
26. 
    + Z! }1 y5 d( `
27. bias tensor([-0.0006]) tensor([-0.0146])
    ) l; W4 Y; N  H7 ~3 h\" L5 M
28. 
    , ^8 C* Q2 C2 d# J/ S& c  M# s
29. tensor(0.0615)
    # [$ u0 o' i7 ?7 E: p. Q
30. ' f0 p. f% E4 {' y7 V
    
31. weight tensor([[0.8595, 0.1400]]) tensor([[-0.2786,  0.2825]])' s  U. c) v& w% G\" w4 u9 ]! L( n
    
32. 
    3 a2 q- r, g5 C  H/ q5 U
33. bias tensor([0.0008]) tensor([0.0048])$ `/ P' N% x- b7 \
    
34. 9 w* ?; T1 V2 v0 S
    
35. tensor(0.0394)# k1 D5 S! L& u, `! u
    
36. 
    7 }5 c# _. R7 p3 M4 a
37. weight tensor([[0.8874, 0.1118]]) tensor([[-0.2256,  0.2233]])/ |! i, Q! o( o
    
38. ) n9 |/ l) H9 z# f1 y7 n1 x# W
    
39. bias tensor([0.0003]) tensor([-0.0006])& U' P8 {: _4 P7 z\" z
    
40. 
    6 t! h& ]& l5 M# U7 r% e) R% a
41. tensor(0.0252)
    : [1 N! M0 q5 U
42. 5 C4 h$ ^: o( p. G
    
43. weight tensor([[0.9099, 0.0895]]) tensor([[-0.1797,  0.1793]])  d) S0 @. N/ i. W- t2 g6 l( G- f1 G
    
44. 
    . a9 q- M% g! P6 G1 Q- X9 w* g) t
45. bias tensor([0.0004]) tensor([0.0008])
    7 X* D! K5 m* a1 \
46. 6 I# T% q  B% [7 z
    
47. tensor(0.0161); c0 U& g/ Q( N2 S: j' x  ~$ x% A
    
48. 
    ' J9 _* J- f# \4 q0 S( W: d/ k+ ]5 N
49. weight tensor([[0.9279, 0.0715]]) tensor([[-0.1440,  0.1432]])
    5 f8 y) \$ F! `+ @- r0 z
50. 
    0 K8 \/ [  |6 X
51. bias tensor([0.0003]) tensor([0.0003])
    ' n' T1 ?- a% `  b) T
52. 
    % Q9 O3 Y, q0 }6 ]5 I) t
53. tensor(0.0103)\" k. v, y2 x' O8 m! W1 L; I: W
    
54. 5 \4 B9 o% N5 G  m
    
55. weight tensor([[0.9423, 0.0572]]) tensor([[-0.1152,  0.1146]])6 H. V& ]  \' z, A
    
56. 
    6 J6 V( Y! ]5 \8 @$ z1 W
57. bias tensor([0.0003]) tensor([0.0004]); l2 X7 r+ y) Q; a6 t3 E' s
    
58. 
    0 S1 N; g  \' }9 ~
59. tensor(0.0066)5 u0 M( W% C; [$ p
    
60. 
    0 x6 S, d# _; U$ |
61. weight tensor([[0.9538, 0.0458]]) tensor([[-0.0922,  0.0917]])
    3 G. K# x, u, S! [( q
62. 
    , l$ |/ W( |. f* F
63. bias tensor([0.0003]) tensor([0.0003])
    9 n4 Q- V! {; A+ D
64. 
    $ z0 n. K( e2 _7 D7 ~. q
65. tensor(0.0042). g! r9 V9 F' u) o# z1 n- m
    
66. 
    2 q* l( m6 b% h; o* }) Y
67. weight tensor([[0.9630, 0.0366]]) tensor([[-0.0738,  0.0733]])0 n$ J6 [6 _5 C; f! O) A\" ^
    
68. 
    0 P1 ]6 T6 j2 I: F6 f1 z  j0 p
69. bias tensor([0.0002]) tensor([0.0003]). |& H3 s( _; x1 G: C$ E. B7 k
    
70. 9 X. H9 T: U2 T& E1 t* P: g
    
71. tensor(0.0027)
    ! m$ [) M' H1 {% z
72. 5 B4 c1 w) a1 _
    
73. weight tensor([[0.9704, 0.0293]]) tensor([[-0.0590,  0.0586]])
    + K: ~4 S\" ~5 j$ T$ a
74. 
    ! k0 `& u& y1 `  Q7 |
75. bias tensor([0.0002]) tensor([0.0002])
    2 Y# |4 b; v+ r: V- ~
76. 
    : |5 D( M3 m5 w$ T# P8 n9 X8 @9 q
77. tensor(0.0017)
    0 S) P5 \\" s0 J, A
78. ' C1 ]% j& b% L8 v' k
    
79. weight tensor([[0.9763, 0.0234]]) tensor([[-0.0472,  0.0469]])7 \7 ~2 c& I! H9 P* Q9 C9 r' t
    
80. & y9 N1 L4 b/ L- ^0 _1 y+ A
    
81. bias tensor([0.0002]) tensor([0.0002])
    1 i0 r6 `5 S3 O  V
82. . F2 g) N! i  \
    
83. tensor(0.0011)
    9 F8 t; h! t, ^- H
84. ) R9 S  X- N' [1 z& K$ C
    
85. weight tensor([[0.9811, 0.0187]]) tensor([[-0.0378,  0.0375]])% v2 w3 i' q2 G9 u4 J9 D
    
86. 
    % N6 w$ z  B  _& y% ]
87. bias tensor([0.0001]) tensor([0.0002])
    6 A6 O$ E2 x3 g( B) h3 O8 k- D
88. ! W8 t2 J3 p\" D
    
89. tensor(0.0007)5 h' W# v2 y\" V! K' l
    
90. 
    3 t( `) R  ?, v8 y
91. weight tensor([[0.9848, 0.0150]]) tensor([[-0.0303,  0.0300]])+ n( o1 J; h) i$ H7 p- `6 B
    
92. ! J* r2 j1 b: b7 \! r
    
93. bias tensor([0.0001]) tensor([0.0002])! M! K! Q0 s8 M
    
94. : v% w: U, M6 H! U! D  ]
    
95. tensor(0.0005)
    8 N( J: d\" q( T/ W3 K9 u
96. 
    5 X: [. C! e( U/ F4 }+ l7 L* f, Z& D6 x% \
97. weight tensor([[0.9879, 0.0120]]) tensor([[-0.0242,  0.0240]])
    8 d& p$ L: L1 B# {- @* t/ t8 B. k
98. 
    . o( p' S! a* Y8 M# u
99. bias tensor([0.0001]) tensor([0.0001])
    + {. `2 @$ B- W& z4 S( @
100. 
     , u: V$ a& l% T6 r6 m1 R
101. tensor(0.0003)
     + J0 D' r1 E9 w
102. 9 I% c$ G. z4 O! v\" u7 W$ Q8 W
     
103. weight tensor([[0.9903, 0.0096]]) tensor([[-0.0194,  0.0192]])
     * t6 Z0 p  n4 e, ~! n! x, N
104. ! M) w0 B. \. I/ U, K7 G) E8 X\" K& P) l
     
105. bias tensor([9.7973e-05]) tensor([0.0001])
     ! v1 F# X% e$ c1 v- H( u2 H( E
106. $ R: L# o, S, O/ A\" G5 J
     
107. tensor(0.0002), \( }4 A3 M, \1 e: T3 C
     
108. 
     . ?2 x/ m! c$ u\" a$ k7 z; k# j. _
109. weight tensor([[0.9922, 0.0076]]) tensor([[-0.0155,  0.0153]])
     8 H$ _1 d% ~9 p  D: q3 c8 t, n
110. : g/ \  p2 B$ z- m, t: d
     
111. bias tensor([8.5674e-05]) tensor([0.0001])/ ~$ P* Y8 d! J4 P, {) j
     
112. 
     9 ~) C- [7 C4 w, H3 h
113. tensor(0.0001)
     ( U7 O8 ^2 q! [. ]% l
114. 
     9 L0 n' U' D  X' d0 D7 r! t) q$ J8 z
115. weight tensor([[0.9938, 0.0061]]) tensor([[-0.0124,  0.0123]])
     , K3 K4 _# {' q
116. 0 }  {! l) E: w# P4 z. G, k  [7 d
     
117. bias tensor([7.4933e-05]) tensor([9.4233e-05])1 e3 R! R$ {, n) X
     
118. 
     % r! F, y& z# q$ R
119. tensor(7.6120e-05)

复制代码

" a' W8 n8 f4 i) r