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

2744557306

SGD是什么
" W' p/ n0 b. v6 w/ b5 O6 iSGD是Stochastic Gradient Descent（随机梯度下降）的缩写，是深度学习中常用的优化算法之一。SGD是一种基于梯度的优化算法，用于更新深度神经网络的参数。它的基本思想是，在每一次迭代中，随机选择一个小批量的样本来计算损失函数的梯度，并用梯度来更新参数。这种随机性使得算法更具鲁棒性，能够避免陷入局部极小值，并且训练速度也会更快。
8 I" l3 e( v, \4 N怎么理解梯度？
# T8 N3 k/ C$ R9 \% l假设你在爬一座山，山顶是你的目标。你知道自己的位置和海拔高度，但是不知道山顶的具体位置和高度。你可以通过观察周围的地形来判断自己应该往哪个方向前进，并且你可以根据海拔高度的变化来判断自己是否接近山顶。

4 _- S* k- y  w5 w* ?在这个例子中，你就可以把自己看作是一个模型，而目标就是最小化海拔高度（损失函数）。你可以根据周围的地形（梯度）来判断自己应该往哪个方向前进，这就相当于使用梯度下降法来更新模型的参数（你的位置和海拔高度）。
& H3 b! I- p3 M2 d6 ]
每次你前进一步，就相当于模型更新一次参数，然后重新计算海拔高度。如果你发现海拔高度变小了，就说明你走对了方向，可以继续往这个方向前进；如果海拔高度变大了，就说明你走错了方向，需要回到上一个位置重新计算梯度并选择一个新的方向前进。通过不断重复这个过程，最终你会到达山顶，也就是找到了最小化损失函数的参数。
5 W8 u- M8 B; K+ w: Q( J
$ V$ O8 Z0 o6 h; J# c为什么引入SGD
1 N2 s+ Z1 |* q1 y2 T深度神经网络通常有大量的参数需要学习，因此优化算法的效率和精度非常重要。传统的梯度下降算法需要计算全部样本的梯度，非常耗时，并且容易受到噪声的影响。随机梯度下降算法则可以使用一小部分样本来计算梯度，从而大大提高了训练速度和鲁棒性。此外，SGD还可以避免陷入局部极小值，使得训练结果更加准确。
7 a  M0 [7 v2 {# `# X
怎么用SGD

1. import torch
   # |+ Z  T/ E- p: e8 f& t
2. # P7 Z! t' {2 t
   
3. from torch import nn, N2 j1 z& v4 M3 [/ y$ ]
   
4. 
   1 H9 T! A7 Z0 Z# K
5. from torch import optim
   , C5 a+ x% j0 P; P
6. \" N# W8 I9 s4 g/ @
   
7. 
   3 U$ z! o% A/ B) o# e& S
8. : N0 `; w% ~# v# F3 l$ J
   
9. data = torch.tensor([[0,0],[0,1],[1,0],[1,1.]], requires_grad=True)
   4 @- D2 q1 D6 U' i; ~# n
10. 
    3 z9 n* I* B+ N% D
11. target = torch.tensor([[0],[0],[1],[1.]], requires_grad=True); b( [9 i\" S) m0 V3 W: k
    
12. 
    : M8 D' o( v1 C* q) M. J5 r
13. . V3 c0 ~) S, ]+ a: ]+ Q0 e
    
14. / n  ?7 p6 J- j3 J' G
    
15. model = nn.Linear(2, 1)
    5 B  x$ w6 T; V1 G. ]) E) @  w# r
16. 
    - m1 h& o( E0 y) W5 f
17. 
    $ R9 q. c. `8 ^/ v
18. 
    ! X; X+ C  ~) E; F5 C
19. def train():: _% O8 ^' t% H; @$ v
    
20. . C$ D. J% I& c# l
    
21.     opt = optim.SGD(params=model.parameters(), lr=0.1)2 M  V! h- o1 o% @3 n5 X1 L' S
    
22. 7 V. q\" ?8 ~& h# ~, G8 d
    
23.     for iter in range(20):
    . D\" S/ f\" `1 q, R  l
24. 1 e( }; L& I9 T* M
    
25.         # 1) 消除之前的梯度（如果存在）
    3 v8 r8 B) v$ o  l
26. 
    0 Q% d& g) Y# x
27.         opt.zero_grad(). j1 M% Z) z' j6 w6 _) F\" ^1 h
    
28. 
    ! P% s$ Y+ m& z
29. 
    , f3 y2 ^; n) j; H3 |
30. 
    % \5 h( c7 N% u9 k( W
31.         # 2) 预测9 A* a! I& X5 U
    
32. 
    + X  `! K) h( S$ T
33.         pred = model(data), z1 y8 G0 P9 I% v9 E
    
34. 
    + O' z1 K# s; f) U* V5 S
35. % d  S: v1 h7 N. `
    
36. 9 S5 R# Q  T& n- K
    
37.         # 3) 计算损失
    \" L2 x9 l! x2 u\" r0 r; d
38. 
    $ l7 h( B, ~/ f/ V
39.         loss = ((pred - target)**2).sum()
    # Z0 M, i% g: w1 {/ u+ k! q* A' l
40. # Z/ j7 i6 G# Y; E+ v* Z5 o
    
41. 6 m+ X' O$ z% P5 ]
    
42. * X$ ^6 e\" q& a) d9 O/ E
    
43.         # 4) 指出那些导致损失的参数（损失回传）
      N* X  A1 C6 D# J1 j
44. 8 Y8 s% z! d! ^2 g
    
45.         loss.backward(), V* b+ U$ `\" H
    
46. 
    $ g# S0 C& w1 S2 a# E4 o! p+ M& j
47.     for name, param in model.named_parameters():$ O\" n0 a6 X: r
    
48. 
      Z5 A4 U+ w+ Q' d
49.             print(name, param.data, param.grad)9 N1 t3 \/ I3 Z
    
50. 2 R/ v9 ^! N* }) E* J% s: c' w* L% U
    
51.         # 5) 更新参数
    2 J/ t: n2 w/ b1 {8 r
52. 0 t2 C. M4 Z\" y/ [: c# h$ q
    
53.         opt.step()
    0 O# ~) l5 J& E  H8 e
54. # h\" d: M3 Y& n& p; O7 o1 }
    
55. 
    * I# M  h( m: g: M; X
56. 
    2 f) d# q; M2 S2 o
57.         # 6) 打印进程
    9 T4 ~- C& G8 y+ L
58. 
    5 y% [% {9 ~: P2 z9 j. K- }) b! }/ c. t3 ]
59.         print(loss.data)
    . d( ]2 |0 t9 T! Y' s
60. 
    0 J6 I$ h5 x( q. |! u6 K; [8 n
61. + W& D9 ?5 _! e
    
62. 
    \" T# L: X9 E8 E& g/ Q2 i
63. if __name__ == "__main__":
    * o4 G! q\" Q# @- z
64. 
    9 N4 j9 x; j9 T8 S3 o+ h! R
65.     train()
    * T$ J& S% c5 ~8 R# f( A  p
66. 
    , @: V; |  n8 }8 K$ q

复制代码

param.data是参数的当前值，而param.grad是参数的梯度值。在进行反向传播计算时，每个参数都会被记录其梯度信息，以便在更新参数时使用。通过访问param.data和param.grad，可以查看参数当前的值和梯度信息。值得注意的是，param.grad在每次调用backward()后都会自动清空，因此如果需要保存梯度信息，应该在计算完梯度之后及时将其提取并保存到其他地方。
( B8 H+ ?4 j: g6 ]
计算结果：

1. weight tensor([[0.4456, 0.3017]]) tensor([[-2.4574, -0.7452]])
   $ ?2 Y) F3 H7 `' T6 g
2. 
   3 z0 R; D0 Z9 f1 l& u+ q
3. bias tensor([-0.2108]) tensor([-2.6971])
   & v- G& t5 a0 W1 R
4. : {( \0 N+ u, u
   
5. tensor(0.8531)
   7 J2 L5 S  `5 M& h& n
6. 
   2 c+ i2 E6 u2 ~
7. weight tensor([[0.6913, 0.3762]]) tensor([[-0.2466,  1.1232]])
   6 z' n4 B9 }\" _
8. 7 J, C) p% R. b8 e4 D6 ~7 v  u
   
9. bias tensor([0.0589]) tensor([0.7416])
   0 N( ^( S! N7 ?/ a) C
10. 
    , b9 r/ K1 a* R7 E: ^& R
11. tensor(0.2712)
    / R6 ~\" Y2 K$ P2 O: e
12. 
    % k  J$ i: m2 b! [' y
13. weight tensor([[0.7160, 0.2639]]) tensor([[-0.6692,  0.4266]])1 Y+ @6 o\" v7 i8 d
    
14. 
    6 W$ H+ U2 j4 i( v; j
15. bias tensor([-0.0152]) tensor([-0.2023])
    5 b/ S8 K# \: O6 m: }
16. 
    7 @\" C* A0 D: E
17. tensor(0.1529)0 T0 J\" r\" z* |) x) B6 ~8 t
    
18. 
    / l2 |# c, e& z
19. weight tensor([[0.7829, 0.2212]]) tensor([[-0.4059,  0.4707]]); k( H1 ~) Z: a9 g: L  @$ [
    
20. ! Q/ K& I7 \5 \( R, a6 f5 }
    
21. bias tensor([0.0050]) tensor([0.0566])1 e' }; P; l; w% R% V4 l
    
22. - L3 _, |0 w% K1 V; n
    
23. tensor(0.0963)
    $ U% W9 \% J# C) x! V8 k
24. 5 T/ `+ z3 Z! B8 g
    
25. weight tensor([[0.8235, 0.1741]]) tensor([[-0.3603,  0.3410]])
    * S* `+ d( _9 @6 u& \7 H! ~! c. @
26. ( L) k  R, f+ j! C) G! @
    
27. bias tensor([-0.0006]) tensor([-0.0146])
    $ w6 g8 Q& l* p' H4 V
28. 8 b4 Y/ O& h. s  Y6 x9 I& P$ D- Q
    
29. tensor(0.0615)
    3 _. I' Q' r* l1 e
30. 
    \" ^/ e1 u# H8 @7 A4 p
31. weight tensor([[0.8595, 0.1400]]) tensor([[-0.2786,  0.2825]]); g1 z1 a) ^* X5 y/ u+ K+ C
    
32. / j: I( t( a& {
    
33. bias tensor([0.0008]) tensor([0.0048])
    % O4 b\" r1 q' Y0 k' z9 S1 |
34. 
    / E$ v0 R  y0 T3 x
35. tensor(0.0394)) W0 M$ X; j7 T
    
36. 
    2 A\" F% @\" e& ]\" Y1 u  n
37. weight tensor([[0.8874, 0.1118]]) tensor([[-0.2256,  0.2233]])
    ; o+ x$ Z\" |& a1 x4 V5 a7 Y
38. 2 V4 p) M( {4 H4 V! h# U' Q8 Z
    
39. bias tensor([0.0003]) tensor([-0.0006])
    , o* D# h# }! S# E1 h* p
40. : c0 f& I0 `5 g
    
41. tensor(0.0252)
    ; w' P& J8 b( l+ |
42. 6 w2 D: x8 g4 T3 e
    
43. weight tensor([[0.9099, 0.0895]]) tensor([[-0.1797,  0.1793]]), @* A  f' ?2 K8 k
    
44. 
    - K# w: h+ `0 Q\" A# a$ N# ~6 Y# x
45. bias tensor([0.0004]) tensor([0.0008])
    3 r5 B/ l& `$ [' T: w\" n
46. 3 {: z4 H3 ~) t2 `) L/ ^0 z
    
47. tensor(0.0161)' }. q5 f; f: u9 g: R5 K4 T' i
    
48. 
    4 G! U0 E# k1 u
49. weight tensor([[0.9279, 0.0715]]) tensor([[-0.1440,  0.1432]])( Y7 ~9 v' E# F
    
50. 
    1 G- b. }) W3 c: a4 W- M
51. bias tensor([0.0003]) tensor([0.0003])+ [. c; S0 `6 c$ N! e
    
52. % X9 e$ E0 B/ f9 ^) l% k2 K
    
53. tensor(0.0103)! x+ D. V( T) l$ n+ D( \7 c
    
54. 
    ! B7 @/ F0 g& d3 d/ b! |
55. weight tensor([[0.9423, 0.0572]]) tensor([[-0.1152,  0.1146]])
    . A4 W3 I; w5 \  {! F2 E3 v
56. 
    $ T5 x- c, y+ o; c' z6 g
57. bias tensor([0.0003]) tensor([0.0004])
    + h5 }( y4 l% I, W
58. 
    ; E6 d! Z8 `* s) `
59. tensor(0.0066)
    ; s- `& M3 O( i5 J3 E3 J
60. 
    1 G. a5 v7 i7 q% \! a4 k
61. weight tensor([[0.9538, 0.0458]]) tensor([[-0.0922,  0.0917]])
    ; K7 r9 e( G  u+ G+ D; r
62. 
    4 r9 Q\" |4 @+ M- m
63. bias tensor([0.0003]) tensor([0.0003])
    2 Z+ m* o7 Q+ Y
64. 0 g8 Z# N* E6 X
    
65. tensor(0.0042)# R, ~1 v# W0 V+ |' c4 V% c
    
66. 
      i' b% L- B4 D0 P; U% F- }
67. weight tensor([[0.9630, 0.0366]]) tensor([[-0.0738,  0.0733]])
      I  W& v) k8 U' H: ?5 @
68. 
    2 u5 [3 K' Y$ Q7 r
69. bias tensor([0.0002]) tensor([0.0003])
    6 J4 Y& P: F% e/ x
70. 
    0 I% Z- I\" c2 F
71. tensor(0.0027)  y1 m* d0 ^5 R  U: {5 n$ K
    
72. 
      i' N\" Q# K, L7 _& n1 Q9 p% G
73. weight tensor([[0.9704, 0.0293]]) tensor([[-0.0590,  0.0586]])
    ; A6 ~6 j1 w+ s- V* U
74. . [; Q* Y! I* Z( i6 F# i
    
75. bias tensor([0.0002]) tensor([0.0002])
    + }! m5 S* ]. l: `: h
76. # Q2 [: c# P  n6 d  m  Q
    
77. tensor(0.0017)
    ( T6 r/ G0 q6 X, Z' C
78. 
    0 ^8 E& [  g& c$ a  V4 l4 o
79. weight tensor([[0.9763, 0.0234]]) tensor([[-0.0472,  0.0469]])
    ! Y  v4 G( d- [/ _+ s
80. 4 ]# R- D! ]/ {! E; S0 n/ e8 h
    
81. bias tensor([0.0002]) tensor([0.0002])7 p5 s, y6 X0 K. Z, |
    
82. 
    ' O6 p) Z: C3 o/ M! U* X
83. tensor(0.0011)' n: R# B. a  w% k' Y
    
84. + e! t6 c2 i1 v1 ]/ \
    
85. weight tensor([[0.9811, 0.0187]]) tensor([[-0.0378,  0.0375]]): g8 h  d( E( q6 ^0 C
    
86. 4 x1 h9 l$ M- l
    
87. bias tensor([0.0001]) tensor([0.0002])
    - w- |+ Y- w+ H3 `1 w
88. 8 B/ ~7 M6 C: I. b6 [$ Z
    
89. tensor(0.0007)
    8 q2 }  q* A# u1 q
90. ) n. I, |4 O1 k  l5 M* _
    
91. weight tensor([[0.9848, 0.0150]]) tensor([[-0.0303,  0.0300]])
    : `' r1 j9 V7 c7 l
92. ! D0 B# `) P6 g4 F8 v7 R3 {/ ^' L
    
93. bias tensor([0.0001]) tensor([0.0002])4 h4 L4 v( V5 v/ A- x) S% K2 E8 g
    
94. 5 w, W; h: _/ a8 _% [; ~2 A0 a
    
95. tensor(0.0005)* X$ d* p\" J\" ^. g
    
96. + u( E5 K3 D4 ~2 y9 x
    
97. weight tensor([[0.9879, 0.0120]]) tensor([[-0.0242,  0.0240]])
    & v4 Z  }. [# f+ `0 k* X
98. 
    % a, C1 U4 ^6 d% s4 j) v/ q0 j
99. bias tensor([0.0001]) tensor([0.0001])3 u3 h- e$ c7 F2 ~# i
    
100. 
     / c) D: J! Z, b/ g3 t5 q! A
101. tensor(0.0003)
     / E6 X; G* E5 a1 J1 U3 f
102. 9 X7 M7 w2 J8 |3 W7 m0 U
     
103. weight tensor([[0.9903, 0.0096]]) tensor([[-0.0194,  0.0192]])
     . _- W; q8 ^4 j6 l
104. 
     7 C/ h7 _+ W  |+ Q- G% g) M$ n
105. bias tensor([9.7973e-05]) tensor([0.0001])% j# y8 f& p- `; c( H
     
106. ' Y+ m0 y2 s  f
     
107. tensor(0.0002)
     % }: y# L. Y) e% T
108. + f' U& U7 S, g$ i1 m
     
109. weight tensor([[0.9922, 0.0076]]) tensor([[-0.0155,  0.0153]])
       A\" A( }' ~3 {5 r+ ~
110. 0 k0 e% K) \1 J: s- P% a! N
     
111. bias tensor([8.5674e-05]) tensor([0.0001]); C/ T& }; A. V' F
     
112. \" |9 H\" Q* l/ C0 L
     
113. tensor(0.0001)4 |, R- S& t, {' p& c
     
114. + ~) L$ h2 G9 R* {' I# G
     
115. weight tensor([[0.9938, 0.0061]]) tensor([[-0.0124,  0.0123]])
     , T: y4 a' p3 q; r
116. 
     - }\" l! E: K6 T: U: J\" r
117. bias tensor([7.4933e-05]) tensor([9.4233e-05]): g+ Z# w. C: m' a
     
118. \" b9 F* m/ \# I& ]1 Q: }
     
119. tensor(7.6120e-05)

复制代码