๐Ÿฆญ AI&Big Data/DL

๋”ฅ๋Ÿฌ๋‹

๊ณ„๋ž€์†Œ๋…„ 2025. 3. 5. 19:10

๋”ฅ๋Ÿฌ๋‹๊ณผ ์‹ ๊ฒฝ๋ง

 

๋จธ์‹ ๋Ÿฌ๋‹์˜ ํ•œ ๋ถ„์•ผ๋กœ, ์ธ๊ณต ์‹ ๊ฒฝ๋ง(ANN)์„ ๊ธฐ๋ฐ˜์œผ๋กœ ๋Œ€๋Ÿ‰์˜ ๋ฐ์ดํ„ฐ๋ฅผ ํ•™์Šตํ•˜์—ฌ ๋›ฐ์–ด๋‚œ ์„ฑ๋Šฅ์„ ๋ฐœํœ˜ํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜

๋”ฅ๋Ÿฌ๋‹์€ ์—ฌ๋Ÿฌ ์ธต์„ ํ†ตํ•ด ์ ์  ๋” ์ถ”์ƒํ™”๋œ ํŠน์ง•์„ ํ•™์Šตํ•˜๋ฉฐ, ๋ณต์žกํ•œ ํŒจํ„ด์„ ์ธ์‹ํ•˜๊ณ  ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š” ๋ฐ ๋›ฐ์–ด๋‚œ ์„ฑ๋Šฅ์„ ๋ณด์ธ๋‹ค.

ํŠนํžˆ ๋”ฅ๋Ÿฌ๋‹์€ ๋Œ€๊ทœ๋ชจ ๋ฐ์ดํ„ฐ์™€ ๊ฐ•๋ ฅํ•œ ๊ณ„์‚ฐ ๋Šฅ๋ ฅ์„ ํ™œ์šฉํ•˜์—ฌ ๋ชจ๋ธ์ด ์ ์  ๋” ๊ฐ•๋ ฅํ•œ ์˜ˆ์ธก ๋Šฅ๋ ฅ์„ ๋ฐœํœ˜ํ•˜๋„๋ก ํ•œ๋‹ค.

 

๋”ฅ๋Ÿฌ๋‹ vs ์ „ํ†ต์ ์ธ ๋จธ์‹ ๋Ÿฌ๋‹

 

  • ์ „ํ†ต์ ์ธ ๋จธ์‹ ๋Ÿฌ๋‹์—์„œ๋Š” ํŠน์ง• ์ถ”์ถœ(Feature Engineering)์„ ์‚ฌ๋žŒ์ด ์ง์ ‘ ํ•ด์•ผ ํ•œ๋‹ค.
  • ๋”ฅ๋Ÿฌ๋‹์€ ์ž๋™ ํŠน์ง• ํ•™์Šต(Representation Learning)์„ ํ†ตํ•ด ๋ฐ์ดํ„ฐ๋ฅผ ์ž๋™์œผ๋กœ ๋ถ„์„ํ•˜๊ณ  ์ค‘์š”ํ•œ ํŠน์ง•์„ ํ•™์Šตํ•œ๋‹ค.

 

  • ์ „ํ†ต์ ์ธ ๋จธ์‹ ๋Ÿฌ๋‹ ๋ชจ๋ธ์€ ์ฃผ๋กœ ๋‹จ์ผ ์ธต์—์„œ ์ฃผ์–ด์ง„ ํŠน์ง•์„ ๋ฐ”ํƒ•์œผ๋กœ ์˜ˆ์ธก์„ ์ˆ˜ํ–‰
  • ๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์€ ๋‹ค์ธต ์‹ ๊ฒฝ๋ง์„ ์‚ฌ์šฉํ•˜์—ฌ ์ ์  ๋” ๋ณต์žกํ•œ ํŒจํ„ด์„ ์ž๋™์œผ๋กœ ํ•™์Šต

 

์žฅ์ , ๋‹จ์ 

 

์žฅ์ 

  • ๋ณต์žกํ•œ ๋ฌธ์ œ ํ•ด๊ฒฐ: ์—ฌ๋Ÿฌ ์ธต์„ ํ†ตํ•ด ๋ณต์žกํ•œ ํŒจํ„ด์„ ํ•™์Šต
  • ์ž๋™ํ™”๋œ ํŠน์ง• ํ•™์Šต: ์‚ฌ๋žŒ์ด ์ง์ ‘ ํŠน์ง•์„ ์ถ”์ถœํ•  ํ•„์š” ์—†์ด, ๋ชจ๋ธ์ด ์ž๋™์œผ๋กœ ์ค‘์š”ํ•œ ํŠน์ง•์„ ํ•™์Šต

๋‹จ์ 

  • ๋ฐ์ดํ„ฐ ์š”๊ตฌ๋Ÿ‰: ๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์€ ๋งŽ์€ ์–‘์˜ ๋ฐ์ดํ„ฐ๊ฐ€ ํ•„์š”
  • ์‹œ๊ฐ„๊ณผ ์ž์›: ํ›ˆ๋ จ ๊ณผ์ •์ด ์‹œ๊ฐ„์ด ์˜ค๋ž˜ ๊ฑธ๋ฆฌ๋ฉฐ, ๊ฐ•๋ ฅํ•œ ํ•˜๋“œ์›จ์–ด(GPU)๊ฐ€ ํ•„์š”

 

์ธ๊ณต ์‹ ๊ฒฝ๋ง(ANN) 

 

๊ฐœ๋…: ์ธ๊ฐ„์˜ ๋‡Œ๋ฅผ ๋ชจ๋ฐฉํ•œ ํ•™์Šต ์‹œ์Šคํ…œ์œผ๋กœ, ์—ฌ๋Ÿฌ ๊ฐœ์˜ ๋‰ด๋Ÿฐ์ด ์—ฐ๊ฒฐ๋˜์–ด ์ •๋ณด๋ฅผ ์ฒ˜๋ฆฌ

๋‰ด๋Ÿฐ: ๋…ธ๋“œ์™€ ์—ฐ๊ฒฐ๋กœ ๊ตฌ์„ฑ ( Input -> ์ฒ˜๋ฆฌ -> Output)

๊ฐ ๋‰ด๋Ÿฐ์€ ์ž…๋ ฅ๊ฐ’์— ๊ฐ€์ค‘์น˜๋ฅผ ๊ณฑํ•˜๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ํ™œ์„ฑํ™” ํ•จ์ˆ˜๋ฅผ ํ†ตํ•ด ์ถœ๋ ฅ์œผ๋กœ ๋ณ€ํ™˜

์‹ ๊ฒฝ๋ง์˜ ๊ธฐ๋ณธ ๊ตฌ์„ฑ ์š”์†Œ๋Š” ์ž…๋ ฅ์ธต, ์€๋‹‰์ธต, ์ถœ๋ ฅ์ธต์œผ๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์œผ๋ฉฐ, ๊ฐ ์ธต์€ ์ด์ „ ์ธต์˜ ์ถœ๋ ฅ์„ ์ž…๋ ฅ์œผ๋กœ ๋ฐ›์•„ ์ฒ˜๋ฆฌํ•˜๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋‹ค์Œ ์ธต์œผ๋กœ ์ „๋‹ฌํ•œ๋‹ค.

 

๊ธฐ๋ณธ์ ์ธ ์‹ ๊ฒฝ๋ง์€ ์ž…๋ ฅ์ธต๊ณผ ์ถœ๋ ฅ์ธต๋งŒ ์žˆ์„ ์ˆ˜ ์žˆ์ง€๋งŒ, ์€๋‹‰์„ ์ถ”๊ฐ€ํ•˜๋ฉด ์‹ ๊ฒฝ๋ง์˜ ์ •ํ™•๋„๊ฐ€ ํฌ๊ฒŒ ํ–ฅ์ƒ๋œ๋‹ค. ์—ฌ๋Ÿฌ ๋‰ด๋Ÿฐ๋“ค์ด ์„œ๋กœ ๋‹ค๋ฅธ ์ž…๋ ฅ์˜ ์กฐํ•ฉ์„ ํ†ตํ•ด ๋” ๋ณต์žกํ•œ ํŒจํ„ด์„ ํ•™์Šตํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•˜๊ณ , ์ด๋•Œ ๋ชจ๋“  ์—ฐ๊ฒฐ์— ๊ฐ€์ค‘์น˜๊ฐ€ ๋ถ€์—ฌ๋˜๋Š” ๊ฒƒ์€ ์•„๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, ๋ฉด์ ๊ณผ ๋„์‹œ์™€์˜ ๊ฑฐ๋ฆฌ๋Š” ๊ฐ€์ค‘์น˜๋ฅผ ๊ฐ€์งˆ ์ˆ˜ ์žˆ์ง€๋งŒ, ์นจ์‹ค ์ˆ˜๋‚˜ ๋ถ€๋™์‚ฐ ์—ฐ๋ น์€ ๊ฐ€์ค‘์น˜๊ฐ€ ์—†์„ ์ˆ˜๋„ ์žˆ๋‹ค. ์ด์ฒ˜๋Ÿผ ์‹ ๊ฒฝ๋ง์€ ๋ณ€์ˆ˜๋“ค ์ค‘ ์ค‘์š”ํ•œ ๊ฒƒ๋งŒ ์„ ํƒํ•˜์—ฌ ๊ณ„์‚ฐ์— ๋ฐ˜์˜ํ•œ๋‹ค.

์‹ ๊ฒฝ๋ง์˜ ์ธต

  • ์ž…๋ ฅ์ธต: ์ฒซ ๋ฒˆ์งธ ์ธต์œผ๋กœ ์ž…๋ ฅ ๋ณ€์ˆ˜๋“ค์ด ๋“ค์–ด๊ฐ
  • ์€๋‹‰์ธต: ์ด ์ธต์˜ ๋‰ด๋Ÿฐ๋“ค์ด ์ž…๋ ฅ์„ ์ฒ˜๋ฆฌํ•˜๊ณ  ๊ฐ€์ค‘์น˜๋ฅผ ํ†ตํ•ด ๋ณ€์ˆ˜์˜ ์ค‘์š”๋„๊ฐ€ ์ถœ๋ ฅ์— ์˜ํ–ฅ์„ ๋ฏธ์นœ๋‹ค. 
  • ์ถœ๋ ฅ์ธต: ๋งˆ์ง€๋ง‰ ์ธต์œผ๋กœ, ๊ฐ€์ค‘์น˜์™€ ํ™œ์„ฑํ™”๋œ ์ž…๋ ฅ์„ ๋ฐ”ํƒ•์œผ๋กœ ์˜ˆ์ธก๋œ ๊ฐ’์„ ์ถœ๋ ฅ

  • ์ž…๋ ฅ ์‹ ํ˜ธ ์ฒ˜๋ฆฌ: ์‹ ํ˜ธ๋ฅผ ํก์ˆ˜ํ•œ ํ›„ ์ถœ๋ ฅ ๊ฒฐ์ •
  • Threshold(์ž„๊ณ„๊ฐ’): ์ผ์ • ์‹ ํ˜ธ๋Ÿ‰ ์ดˆ๊ณผ ์‹œ ์ถœ๋ ฅ
  • Computation(๊ณ„์‚ฐ): ์ž…๋ ฅ๊ฐ’๊ณผ ๊ฐ€์ค‘์น˜์˜ ํ•ฉ์‚ฐ ํ›„ ํ™œ์„ฑํ™” ํ•จ์ˆ˜ ์ ์šฉ
  • Summation = x1w1 + x2w2 + ... + xnwn
  • Threshold๋ณด๋‹ค ํฌ๋ฉด 1, ์ž‘์œผ๋ฉด 0 ์ถœ๋ ฅ

 

์‹ ๊ฒฝ๋ง ํ™œ์„ฑํ™” ํ•จ์ˆ˜

 

ํ™œ์„ฑํ™” ํ•จ์ˆ˜๋Š” ๋‰ด๋Ÿฐ์ด ์‹ ํ˜ธ๋ฅผ ์ „๋‹ฌํ• ์ง€ ๋ง์ง€๋ฅผ ๊ฒฐ์ •ํ•˜๋Š” ์—ญํ• 

Summation ๊ฒฐ๊ณผ์— ๋”ฐ๋ผ ์ถœ๋ ฅ ๊ฒฐ์ •

  1. ์ž„๊ณ„๊ฐ’ ํ•จ์ˆ˜ (Threshold Function): ์ด์ง„ ๋ถ„๋ฅ˜์—์„œ ์‚ฌ์šฉ๋˜๋ฉฐ, ์ž…๋ ฅ๊ฐ’์ด ์ผ์ • ๊ธฐ์ค€์„ ๋„˜์œผ๋ฉด 1, ๊ทธ๋ ‡์ง€ ์•Š์œผ๋ฉด 0์„ ์ถœ๋ ฅ 
  2. ์‹œ๊ทธ๋ชจ์ด๋“œ ํ•จ์ˆ˜ (Sigmoid Function): ์ถœ๋ ฅ๊ฐ’์ด 0๊ณผ 1 ์‚ฌ์ด๋กœ, ํ™•๋ฅ ์„ ์˜ˆ์ธกํ•˜๋Š” ๋ฐ ์œ ์šฉ
  3. ์ •๋ฅ˜ํ™” ํ•จ์ˆ˜ (ReLU, Rectified Linear Unit): 0 ์ดํ•˜์˜ ๊ฐ’์€ 0์œผ๋กœ ์ฒ˜๋ฆฌํ•˜๊ณ , ๊ทธ ์ด์ƒ์˜ ๊ฐ’์€ ๊ทธ๋Œ€๋กœ ์ถœ๋ ฅ
  4. ํ•˜์ดํผ๋ณผ๋ฆญ ํƒ„์  ํŠธ ํ•จ์ˆ˜ (Tanh): ์‹œ๊ทธ๋ชจ์ด๋“œ์™€ ์œ ์‚ฌํ•˜์ง€๋งŒ, ์ถœ๋ ฅ๊ฐ’์ด -1๊ณผ 1 ์‚ฌ์ด๋กœ ๋ณ€๊ฒฝ

https://wikidocs.net/250622

์˜ค์ฐจ ์—ญ์ „ํŒŒ(Backpropagation) ๊ณผ์ •์—์„œ ํ™œ์„ฑํ™” ํ•จ์ˆ˜์˜ ๋„ํ•จ์ˆ˜ ๊ฐ’์ด ์—ฌ๋Ÿฌ ๋ฒˆ ๊ณฑํ•ด์ง€๋ฉด ๊ธฐ์šธ๊ธฐ ์†Œ์‹ค ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ๋‹ค.

Sigmoid์™€ ๊ฐ™์€ ํ™œ์„ฑํ™” ํ•จ์ˆ˜์—์„œ ๋ฐœ์ƒํ•˜๋Š”๋ฐ,  ๋„ํ•จ์ˆ˜๊ฐ€ 0๊ณผ 1/4 ์‚ฌ์ด ๊ฐ’์„ ๊ฐ€์ง€๊ธฐ ๋•Œ๋ฌธ

๊ทธ๋ผ๋””์–ธํŠธ๊ฐ€ ์—ฌ๋Ÿฌ ๋ฒˆ ๊ณฑํ•ด์งˆ์ˆ˜๋ก ๊ฐ’์ด 0์— ์ˆ˜๋ ดํ•˜๊ฒŒ ๋˜์–ด, ๊ฒฐ๊ตญ ์˜ค์ฐจ์˜ ๊ธฐ์šธ๊ธฐ(dE/dw)๊ฐ€ 0์ด ๋˜์–ด ๊ฐ€์ค‘์น˜ ์—…๋ฐ์ดํŠธ๊ฐ€ ๋ฉˆ์ถ”๊ฒŒ ๋œ๋‹ค.

-> ReLUํ•จ์ˆ˜ ์‚ฌ์šฉ

  • ReLU๋Š” ๋„ํ•จ์ˆ˜ ๊ฐ’์ด 0 ๋˜๋Š” 1๋กœ ๊ฒฐ์ •๋˜๊ธฐ ๋•Œ๋ฌธ์—, ๊ธฐ์šธ๊ธฐ๊ฐ€ 0์œผ๋กœ ์‚ฌ๋ผ์ง€๋Š” ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•˜์ง€ ์•Š๋Š”๋‹ค.
  • ์ฆ‰, ์˜ค์ฐจ๊ฐ€ ์ „๋‹ฌ๋˜์ง€ ์•Š๊ฑฐ๋‚˜ 100% ์ „๋‹ฌ๋˜๊ธฐ ๋•Œ๋ฌธ์— ๊ธฐ์šธ๊ธฐ ์†Œ์‹ค ๋ฌธ์ œ๊ฐ€ ๋ฐฉ์ง€
  • ๊ทธ๋Ÿฌ๋‚˜ ReLU๋„ ๋ชจ๋“  ๋‰ด๋Ÿฐ์˜ ๋„ํ•จ์ˆ˜ ๊ฐ’์ด 0์ด ๋˜์–ด ๊ธฐ์šธ๊ธฐ ์†Œ์‹ค์ด ๋ฐœ์ƒํ•  ์ˆ˜ ์žˆ์œผ๋ฉฐ ->  Leaky ReLU ์‚ฌ์šฉ์œผ๋กœ ๋ฐฉ์ง€

 

ํผ์…‰ํŠธ๋ก  ๊ตฌ์„ฑ ์š”์†Œ

  • ์—ฐ๊ฒฐ ๊ฐ•๋„
  • ์ž…๋ ฅ์˜ ์„ ํ˜• ์กฐํ•ฉ
  • ์ž…๋ ฅ์˜ ๋น„์„ ํ˜• ๋ณ€ํ™˜

์ธ๊ณต ๋‰ด๋Ÿฐ(ํผ์…‰ํŠธ๋ก ) ๋ชจ์œผ๋ฉด -> ์ธ๊ณต์‹ ๊ฒฝ๋ง(ANN)์ด ๋œ๋‹ค.

์ฃผ์–ด์ง„ Perceptron์˜ ์ถœ๋ ฅ์„ ๊ตฌํ•ด๋ณด์ž.

1. ๊ฐ€์ค‘ํ•ฉ ๊ณ„์‚ฐ (Weighted Sum)

๊ฐ ์ž…๋ ฅ๊ฐ’๊ณผ ๊ฐ€์ค‘์น˜๊ฐ€ ์ฃผ์–ด์กŒ์œผ๋ฏ€๋กœ, ๊ฐ€์ค‘ํ•ฉ์„ ๊ณ„์‚ฐ

  • Summation = x1w1 + x2w2 + ... + xnwn

2. Hard Limit Activation Function ์ ์šฉ

f(x) = 1 (if x>= 0) , 0 (if x < 0)

3. ์ตœ์ข… ์ถœ๋ ฅ ๊ฐ’

Perceptron์˜ ์ถœ๋ ฅ ๊ฐ’ y=f(x)

 

Multi-Layer Perceptron (MLP)

 

  • ์—ฌ๋Ÿฌ ๊ฐœ์˜ ๋‰ด๋Ÿฐ์„ ์Œ“์€ ์ธต์„ ์—ฌ๋Ÿฌ ๊ฐœ ์—ฐ๊ฒฐํ•˜์—ฌ ๋งŒ๋“  ๋ชจ๋ธ
  • Fully Connected Layer: ๊ฐ ๋‰ด๋Ÿฐ์ด ๋‹ค์Œ ์ธต์˜ ๋ชจ๋“  ๋‰ด๋Ÿฐ๊ณผ ์—ฐ๊ฒฐ

 

๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ• (Gradient Descent)

 

๋ชจ๋ธ์˜ ๊ฐ€์ค‘์น˜๋ฅผ ์—…๋ฐ์ดํŠธํ•˜๋Š” ์ตœ์ ํ™” ์•Œ๊ณ ๋ฆฌ์ฆ˜

์˜ค์ฐจ ํ•จ์ˆ˜(์†์‹ค ํ•จ์ˆ˜)์˜ ๊ธฐ์šธ๊ธฐ๋ฅผ ๊ณ„์‚ฐํ•˜๊ณ , ์ด๋ฅผ ํ†ตํ•ด ๊ฐ€์ค‘์น˜๋ฅผ ์˜ค์ฐจ๊ฐ€ ์ตœ์†Œํ™”๋˜๋Š” ๋ฐฉํ–ฅ์œผ๋กœ ์กฐ์ •ํ•œ๋‹ค.

๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•์„ ํ†ตํ•ด ๋ชจ๋ธ์€ ๋ฐ˜๋ณต์ ์œผ๋กœ ๊ฐ€์ค‘์น˜๋ฅผ ์—…๋ฐ์ดํŠธํ•˜๋ฉฐ ์ ์  ๋” ์ •ํ™•ํ•œ ์˜ˆ์ธก์„ ํ•  ์ˆ˜ ์žˆ๋„๋ก ํ•™์Šต๋œ๋‹ค.

1. ๋ฐฐ์น˜ ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ• (Batch Gradient Descent)

    • ์ „์ฒด ๋ฐ์ดํ„ฐ์…‹์„ ํ•œ ๋ฒˆ์— ์‚ฌ์šฉํ•˜์—ฌ ๊ธฐ์šธ๊ธฐ๋ฅผ ๊ณ„์‚ฐํ•˜๊ณ , ํ•œ ๋ฒˆ์˜ ๊ฐ€์ค‘์น˜ ์—…๋ฐ์ดํŠธ๋ฅผ ์ˆ˜ํ–‰
    • ์žฅ์ : ์ „์ฒด ๋ฐ์ดํ„ฐ์…‹์„ ๋ฐ”ํƒ•์œผ๋กœ ๊ณ„์‚ฐํ•˜๋ฏ€๋กœ ์ˆ˜๋ ด ๊ฒฝ๋กœ๊ฐ€ ์•ˆ์ •์ ์ด๊ณ , ์ตœ์ ํ•ด๋ฅผ ์ฐพ์„ ๊ฐ€๋Šฅ์„ฑ์ด ๋†’๋‹ค.
    • ๋‹จ์ : ์ „์ฒด ๋ฐ์ดํ„ฐ์…‹์„ ๋ฉ”๋ชจ๋ฆฌ์— ์˜ฌ๋ ค์•ผ ํ•˜๋ฏ€๋กœ ๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ์…‹์—์„œ ์‹œ๊ฐ„์ด ๋งŽ์ด ๊ฑธ๋ฆฌ๊ณ , ๋ฉ”๋ชจ๋ฆฌ ๋ถ€๋‹ด์ด ํฌ๋‹ค.
    • ๊ตญ์†Œ์  ์ตœ์ ๊ฐ’(local minimum)์— ๋น ์งˆ ์ˆ˜ ์žˆ๋Š” ์œ„ํ—˜์ด ์žˆ๋‹ค. ์™œ๋ƒํ•˜๋ฉด, ๋ฐฐ์น˜ ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•์€ ์ „์ฒด ๋ฐ์ดํ„ฐ์— ๋Œ€ํ•œ ํ‰๊ท ์ ์ธ ๊ธฐ์šธ๊ธฐ๋ฅผ ๊ธฐ๋ฐ˜์œผ๋กœ ์—…๋ฐ์ดํŠธ๋ฅผ ํ•˜๊ธฐ ๋•Œ๋ฌธ์—, ๋ฐ์ดํ„ฐ์˜ ์ „์ฒด์ ์ธ ๊ฒฝํ–ฅ๋งŒ ๋ฐ˜์˜ -> ์ด๋กœ ์ธํ•ด ๊ฒฝ๋กœ๊ฐ€ ๊ตญ์†Œ์  ์ตœ์ ๊ฐ’์— ๋น ์ ธ๋ฒ„๋ฆด ์ˆ˜ ์žˆ๋‹ค.

2. ํ™•๋ฅ ์  ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ• (Stochastic Gradient Descent)

  • ๊ฐ ๋ฐ์ดํ„ฐ ์ƒ˜ํ”Œ์„ ํ•˜๋‚˜์”ฉ ์ฒ˜๋ฆฌํ•˜๋ฉด์„œ ๊ฐ€์ค‘์น˜๋ฅผ ์—…๋ฐ์ดํŠธํ•˜๋Š” ๋ฐฉ์‹
  • ๋ฐฐ์น˜ ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•๋ณด๋‹ค ํ›จ์”ฌ ๋น ๋ฅด๊ฒŒ ์—…๋ฐ์ดํŠธ
  • ์žฅ์ : ์ฒ˜๋ฆฌ ์†๋„๊ฐ€ ๋น ๋ฅด๊ณ , ๊ฐ ์ƒ˜ํ”Œ์— ๋Œ€ํ•ด ๋น ๋ฅด๊ฒŒ ๊ฐ€์ค‘์น˜๋ฅผ ์กฐ์ •ํ•  ์ˆ˜ ์žˆ์–ด ๋กœ์ปฌ ์ตœ์†Œ๊ฐ’์„ ํ”ผํ•˜๋Š” ๋ฐ ์œ ๋ฆฌ
  • ๋‹จ์ : ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•์˜ ์ˆ˜๋ ด ๊ฒฝ๋กœ๊ฐ€ ๋ถˆ์•ˆ์ •ํ•  ์ˆ˜ ์žˆ์œผ๋ฉฐ, ๋„ˆ๋ฌด ๋งŽ์€ ์—…๋ฐ์ดํŠธ๊ฐ€ ์ด๋ฃจ์–ด์ ธ์„œ ์ˆ˜๋ ด ์†๋„๊ฐ€ ๋А๋ ค์งˆ ์ˆ˜ ์žˆ๋‹ค.

3. ๋ฏธ๋‹ˆ ๋ฐฐ์น˜ ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ• (Mini-Batch Gradient Descent)

  • ๋ฐฐ์น˜ ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•๊ณผ ํ™•๋ฅ ์  ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•์˜ ์žฅ์ ์„ ๊ฒฐํ•ฉํ•œ ๋ฐฉ์‹
  • ๋ฐ์ดํ„ฐ์…‹์„ mini batch๋กœ ๋‚˜๋ˆ„์–ด, ๊ฐ ๋ฐฐ์น˜์— ๋Œ€ํ•ด ๊ธฐ์šธ๊ธฐ๋ฅผ ๊ณ„์‚ฐํ•˜๊ณ  ๊ฐ€์ค‘์น˜๋ฅผ ์—…๋ฐ์ดํŠธ
  • ์žฅ์ : ๋ฐฐ์น˜ ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•์˜ ์•ˆ์ •์„ฑ๊ณผ ํ™•๋ฅ ์  ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•์˜ ๋น ๋ฅธ ์†๋„๋ฅผ ๋™์‹œ์— ์–ป์„ ์ˆ˜ ์žˆ๋‹ค.
  • ๋‹จ์ : ๋ฏธ๋‹ˆ ๋ฐฐ์น˜ ํฌ๊ธฐ๋ฅผ ์„ ํƒํ•˜๋Š” ๊ฒƒ์ด ์ˆ˜๋ ด ์„ฑ๋Šฅ์— ์˜ํ–ฅ์„ ๋ฏธ์น  ์ˆ˜ ์žˆ์œผ๋ฉฐ, ๋„ˆ๋ฌด ํฐ ๋ฐฐ์น˜๋Š” ๊ณ„์‚ฐ ํšจ์œจ์„ฑ์„ ๋–จ์–ด๋œจ๋ฆด ์ˆ˜ ์žˆ๋‹ค.

 

์—ญ์ „ํŒŒ์™€ Autograd

 

๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์€ ์—ญ์ „ํŒŒ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์‚ฌ์šฉํ•˜์—ฌ ์‹ ๊ฒฝ๋ง์˜ ๊ฐ€์ค‘์น˜๋ฅผ ์กฐ์ •ํ•œ๋‹ค.

PyTorch๋Š” Autograd ์‹œ์Šคํ…œ์„ ํ†ตํ•ด ์ž๋™ ๋ฏธ๋ถ„์„ ์ง€์›ํ•˜๋ฉฐ, ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•์„ ์‰ฝ๊ฒŒ ์ ์šฉํ•  ์ˆ˜ ์žˆ๋„๋ก ํ•œ๋‹ค.

์—ญ์ „ํŒŒ ๊ณผ์ •์—์„œ๋Š” ์ถœ๋ ฅ์ธต์—์„œ ์˜ค์ฐจ๋ฅผ ๊ณ„์‚ฐํ•˜๊ณ , ์ด๋ฅผ ์—ญ๋ฐฉํ–ฅ์œผ๋กœ ์ „ํŒŒํ•˜์—ฌ ๊ฐ ๊ฐ€์ค‘์น˜์˜ ๊ธฐ์šธ๊ธฐ๋ฅผ ๊ณ„์‚ฐํ•˜๊ณ , ์ด๋ฅผ ํ†ตํ•ด ์‹ ๊ฒฝ๋ง์€ ์ ์  ๋” ์ •ํ™•ํ•œ ์˜ˆ์ธก์„ ํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋œ๋‹ค.

 

 

PyTorch์™€ ํ…์„œ ์—ฐ์‚ฐ

 

๋”ฅ๋Ÿฌ๋‹ ๋ชจ๋ธ์„ ๊ตฌํ˜„, ํ•™์Šต ์œ„ํ•œ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ

ํ…์„œ(Tensor)

  • ํ…์„œ: ๋ฒกํ„ฐ์™€ ํ–‰๋ ฌ์„ ์ผ๋ฐ˜ํ™”ํ•œ ๊ฐœ๋…์œผ๋กœ, ๋‹ค์ฐจ์› ๋ฐฐ์—ด
  • ๋žญํฌ(rank): ํ…์„œ์˜ ์ฐจ์› ์ˆ˜
  • Shape: ๊ฐ ์ถ•์˜ ํฌ๊ธฐ๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ํŠœํ”Œ
  • Type: ํ…์„œ์˜ ๋ฐ์ดํ„ฐ ํƒ€์ž…

CUDA & cuDNN

  • CUDA: GPU๋ฅผ ํ†ตํ•ด ๋ณ‘๋ ฌ ์—ฐ์‚ฐ์„ ์ฒ˜๋ฆฌํ•˜๋Š” ํ”Œ๋žซํผ
  • cuDNN: GPU ์—ฐ์‚ฐ์„ ์ตœ์ ํ™”ํ•˜๋Š” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ
import torch

# ํ…์„œ ์ •์˜ ๋ฐ ๊ธฐ์šธ๊ธฐ ๊ณ„์‚ฐ
w = torch.tensor(1.0, requires_grad=True)  # ๊ธฐ์šธ๊ธฐ ๊ณ„์‚ฐ์„ ์œ„ํ•œ ํ…์„œ
a = w * 3
l = a ** 2

# ์—ญ์ „ํŒŒ(backpropagation)
l.backward()

# ๊ธฐ์šธ๊ธฐ ์ถœ๋ ฅ
print(w.grad)  # ๊ธฐ์šธ๊ธฐ ๊ฐ’ 18 ์ถœ๋ ฅ

requires_grad=True๋กœ ์„ค์ •๋œ ํ…์„œ๋Š” ๋ฏธ๋ถ„(๊ธฐ์šธ๊ธฐ ๊ณ„์‚ฐ) ๊ณผ์ •์„ ์ถ”์ 

 

๋ชจ๋ธ ํ›ˆ๋ จ ๋ฐ ํ•™์Šต ํ๋ฆ„

  1. ๋ฐ์ดํ„ฐ์…‹ ์ค€๋น„: ํ›ˆ๋ จ ๋ฐ์ดํ„ฐ์™€ ํ…Œ์ŠคํŠธ ๋ฐ์ดํ„ฐ๋ฅผ ๋ถ„๋ฆฌ
  2. ๋ชจ๋ธ ์ •์˜: ์‹ ๊ฒฝ๋ง ๋ชจ๋ธ์„ ์ •์˜
  3. ํ›ˆ๋ จ: ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•๊ณผ ์—ญ์ „ํŒŒ๋ฅผ ํ†ตํ•ด ๋ชจ๋ธ์„ ํ•™์Šต
  4. ํ‰๊ฐ€: ํ•™์Šต๋œ ๋ชจ๋ธ์„ ํ‰๊ฐ€ํ•˜์—ฌ ์„ฑ๋Šฅ์„ ํ™•์ธ
  5. ๊ฐ€์ค‘์น˜ ์ €์žฅ: ํ•™์Šต๋œ ๊ฐ€์ค‘์น˜๋ฅผ ์ €์žฅํ•˜๊ณ , ๋‚˜์ค‘์— ๋‹ค์‹œ ์‚ฌ์šฉ 
import torch
import torch.nn as nn
import torch.optim as optim

# ๊ฐ„๋‹จํ•œ ์‹ ๊ฒฝ๋ง ๋ชจ๋ธ ์ •์˜
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(2, 4)
        self.fc2 = nn.Linear(4, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# ๋ชจ๋ธ, ์†์‹ค ํ•จ์ˆ˜, ์˜ตํ‹ฐ๋งˆ์ด์ € ์„ค์ •
model = SimpleNN()
criterion = nn.MSELoss()  # ํ‰๊ท  ์ œ๊ณฑ ์˜ค์ฐจ
optimizer = optim.SGD(model.parameters(), lr=0.01)

# ๋ฐ์ดํ„ฐ ์˜ˆ์‹œ
x_train = torch.tensor([[1.0, 2.0], [2.0, 3.0], [3.0, 4.0]])
y_train = torch.tensor([[5.0], [7.0], [9.0]])

# ํ•™์Šต ๊ณผ์ •
for epoch in range(100):
    optimizer.zero_grad()  # ๊ธฐ์šธ๊ธฐ ์ดˆ๊ธฐํ™”
    output = model(x_train)  # ๋ชจ๋ธ ์˜ˆ์ธก
    loss = criterion(output, y_train)  # ์˜ค์ฐจ ๊ณ„์‚ฐ
    loss.backward()  # ์—ญ์ „ํŒŒ
    optimizer.step()  # ๊ฐ€์ค‘์น˜ ์—…๋ฐ์ดํŠธ

    if epoch % 10 == 0:
        print(f"Epoch [{epoch+1}/100], Loss: {loss.item():.4f}")

 

ํ‰๊ท  ์ œ๊ณฑ ์˜ค์ฐจ๋ฅผ ์‚ฌ์šฉํ•ด ์˜ˆ์ธก ๊ฐ’๊ณผ ์‹ค์ œ ๊ฐ’์˜ ์ฐจ์ด๋ฅผ ๊ณ„์‚ฐํ•˜๊ณ , ํ™•๋ฅ ์  ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•์„ ์‚ฌ์šฉํ•ด ๋ชจ๋ธ์„ ํ•™์Šต