A A
[ํ˜ผ๊ณต๋จธ์‹ ] Stochastic Gradient Descent (ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•)

ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•

ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•(Stochastic Gradient Descent)์€ ์ ์ง„์  ํ•™์Šต ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์ค‘ ํ•˜๋‚˜์ž…๋‹ˆ๋‹ค. 
  • ๊ทธ ์ „์— ์ ์ง„์  ํ•™์Šต ์•Œ๊ณ ๋ฆฌ์ฆ˜์— ๋Œ€ํ•˜์—ฌ ์„ค๋ช…์„ ๋“œ๋ฆฌ๋ฉด, ์ด์ „์— ํ›ˆ๋ จํ•œ ๋ชจ๋ธ์„ ๋ฒ„๋ฆฌ๊ณ  ์ƒˆ๋กœ์šด ๋ชจ๋ธ์„ ํ›ˆ๋ จํ•˜๋Š” ๊ฒƒ์ด ์•„๋‹Œ, ๊ธฐ์กด์˜ ํ›ˆ๋ จํ•œ ๋ชจ๋ธ์€ ๊ทธ๋Œ€๋กœ ๋‘๊ณ , ์ƒˆ๋กœ์šด ๋ฐ์ดํ„ฐ์— ๋ฐํ•œ ํ›ˆ๋ จ์„ ๊ธฐ์กด์˜ ๋ชจ๋ธ์„ ์ด์šฉํ•˜์—ฌ ํ•™์Šต ํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์ž…๋‹ˆ๋‹ค.
  • ๊ทธ๋ž˜์„œ ๋ณธ๋ก ์œผ๋กœ ๋Œ์•„์˜ค๋ฉด, ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์—์„œ ํ™•๋ฅ ์ ์ด๋ž€ ๋ง์€ '๋ฌด์ž‘์œ„ํ•˜๊ฒŒ' ํ˜น์€ '๋žœ๋คํ•˜๊ฒŒ' ์˜ ๊ธฐ์ˆ ์ ์ธ ํ‘œํ˜„์ž…๋‹ˆ๋‹ค.
  • ๊ทธ๋ฆฌ๊ณ  ๊ฒฝ์‚ฌ๋Š”, ๊ธฐ์šธ๊ธฐ๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ์ฆ‰, ๊ทธ๋Ÿฌ๋ฉด ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์€ ๊ฒฝ์‚ฌ๋ฅผ ๋”ฐ๋ผ ๋‚ด๋ ค๊ฐ€๋Š” ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค.
  • ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•์˜ ํŠน์ง•์€ ๊ฐ€์žฅ ๊ฐ€ํŒŒ๋ฅธ ๊ฒฝ์‚ฌ๋ฅผ ๋”ฐ๋ผ ์›ํ•˜๋Š” ์ง€์ ์— ๋„๋‹ฌํ•˜๋Š”๊ฒƒ์„ ๋ชฉํ‘œ๋กœ ์‚ผ๊ณ ์žˆ์Šต๋‹ˆ๋‹ค. ๋‹ค๋งŒ, ๊ฐ€ํŒŒ๋ฅธ ๊ฒฝ์‚ฌ๋ฅผ ๋‚ด๋ ค๊ฐˆ๋•Œ์—๋Š” ์ผ๋ฐ˜์ ์œผ๋กœ ์ฒœ์ฒœํžˆ ์กฐ๊ธˆ์”ฉ ๋‚ด๋ ค์™€์•ผํ•ฉ๋‹ˆ๋‹ค. ์ด๋Ÿฌํ•œ ๋ฐฉ์‹์œผ๋กœ ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ• ๋ชจ๋ธ์„ ํ›ˆ๋ จํ•ฉ๋‹ˆ๋‹ค.
  • ์•ž์˜ ํ™•๋ฅ ์  ์ด๋ผ๋Š” ๋ง์€ ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์œผ๋กœ ๋‚ด๋ ค์˜ฌ๋•Œ, ํ›ˆ๋ จ ์„ธํŠธ๋ฅผ ์‚ฌ์šฉํ•ด์„œ ๋ชจ๋ธ์„ ํ›ˆ๋ จํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•๋„ ๋‹น์—ฐํžˆ ํ›ˆ๋ จ์„ธํŠธ๋ฅผ ์ด์šฉํ•ด ๊ฐ€์žฅ ๊ฐ€ํŒŒ๋ฅธ ๊ฒฝ์‚ฌ๋ฅผ ์ฐพ์„๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๋ ‡์ง€๋งŒ, ์ „์ฒด ์ƒ˜ํ”Œ์„ ์‚ฌ์šฉํ•˜์ง€ ์•Š๊ณ  ํ•˜๋‚˜์˜ ์ƒ˜ํ”Œ์„ ํ›ˆ๋ จ์„ธํŠธ์—์„œ ๋žœ๋คํ•˜๊ฒŒ ๊ณจ๋ผ์„œ ๊ฐ€์žฅ ๊ฐ€ํŒŒ๋ฅธ ๊ธธ์„ ์ฐพ์Šต๋‹ˆ๋‹ค. 
  • ์ฆ‰, ๊ฐ„๋žตํžˆ ํ•˜๋ฉด ํ›ˆ๋ จ์„ธํŠธ์—์„œ ๋žœ๋คํ•˜๊ฒŒ ํ•˜๋‚˜์˜ ์ƒ˜ํ”Œ์„ ๊ณจ๋ผ์„œ ๊ฐ€ํŒŒ๋ฅธ ๊ฒฝ์‚ฌ๋ฅผ ๊ฐ€์ง„ ๊ธธ์„ ์ฐพ๋Š” ๋ฐฉ๋ฒ•์ด ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ• ์ž…๋‹ˆ๋‹ค.

 

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

 

๊ทธ๋Ÿฐ๋ฐ, ๋ฌด์ž‘์œ„๋กœ ์ƒ˜ํ”Œ์„ ์„ ํƒํ•ด์„œ ์‚ฐ์„ ๋‚ด๋ ค๊ฐ€๋ฉด ๋ฌด์Šจ ๋ฌธ์ œ๊ฐ€ ์ƒ๊ธธ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋ž˜์„œ ์•„์ฃผ ์กฐ๊ธˆ์”ฉ ๋‚ด๋ ค๊ฐ€์•ผํ•ฉ๋‹ˆ๋‹ค. 
  • ๊ทผ๋ฐ, ์šฐ๋ฆฌ๊ฐ€ ๊ฑฑ์ •ํ•˜๋Š”๊ฒƒ๋ณด๋‹จ ํ™•๋ฅ ์  ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•์€ ์ž˜ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋ž˜๋„ ๊ฑฑ์ •๋˜๋ฉด ๋ฌด์ž‘์œ„๋กœ ์—ฌ๋Ÿฌ๊ฐœ์˜ ์ƒ˜ํ”Œ์„ ์„ ํƒํ•ด์„œ ๊ฒฝ์‚ฌ๋ฅผ ๋‚ด๋ ค๊ฐ€๋Š” ๋ฐฉ๋ฒ•๋„ ์žˆ์Šต๋‹ˆ๋‹ค.
  • ์ด๋ ‡๊ฒŒ, ์—ฌ๋Ÿฌ๊ฐœ์˜ ์ƒ˜ํ”Œ์„ ์‚ฌ์šฉํ•ด ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์„ ์ˆ˜ํ–‰ํ•˜๋Š” ๋ฐฉ์‹์„ ๋ฏธ๋‹ˆ๋ฐฐ์น˜ ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ• (Mini-Batch Gradient descent) ์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค.

 

๊ทน๋‹จ์ ์œผ๋กœ, ํ•œ๋ฒˆ ๊ฒฝ์‚ฌ๋กœ๋ฅผ ์ด๋™ํ•˜๋ ค๊ณ  ์ „์ฒด ์ƒ˜ํ”Œ์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒฝ์šฐ๋„ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด ๋ฐฉ์‹์„ ๋ฐฐ์น˜ ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ• (Batch Gradient Descent)๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค.
  • ์ด ๋ฐฉ๋ฒ•์€ ์ „์ฒด ๋ฐ์ดํ„ฐ๋ฅผ ์‚ฌ์šฉํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๊ฐ€์žฅ ์•ˆ์ •์ ์ธ ๋ฐฉ๋ฒ•์ด ๋ ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค. ๋‹ค๋งŒ ์ „์ฒด ๋ฐ์ดํ„ฐ๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์ปดํ“จํ„ฐ์˜ ์ž์›์„ ๋งŽ์ด ์จ๋จน๊ธฐ ๋•Œ๋ฌธ์—, ๊ฒฝ์šฐ์— ๋”ฐ๋ผ ๋ฐ์ดํ„ฐ๊ฐ€ ๋„ˆ๋ฌด ๋งŽ์œผ๋ฉด ํ•œ๋ฒˆ์— ์ „์ฒด ๋ฐ์ดํ„ฐ๋ฅผ ๋ถˆ๋Ÿฌ ์˜ค์ง€ ๋ชปํ• ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

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

์†์‹ค ํ•จ์ˆ˜ (Loss Function)

์†์‹ค ํ•จ์ˆ˜(Loss Function)๋Š” ์–ด๋–ค๋ฌธ์ œ์—์„œ ๋จธ์‹ ๋Ÿฌ๋‹ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๊ฐ’์ด ์–ผ๋งˆ๋‚˜ ์—‰ํ„ฐ๋ฆฌ ์ธ์ง€ ์ธก์ •ํ•˜๋Š” ๊ธฐ์ค€์ž…๋‹ˆ๋‹ค.
  • ์†์‹คํ•จ์ˆ˜์˜ ๊ฐ’์ด ํด์ˆ˜๋ก ์•ˆ์ข‹์€๊ฑฐ๊ณ , ์ž‘์„์ˆ˜๋ก ์ข‹์€๊ฒ๋‹ˆ๋‹ค. ๊ทผ๋ฐ, ์–ด๋– ํ•œ ๊ฐ’์ด ์ตœ์†Œ๊ฐ’์ธ์ง€๋Š” ์†์‹คํ•จ์ˆ˜๋กœ ์•Œ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.
  • ๊ฐ€๋Šฅํ•œ ์ตœ๋Œ€ํ•œ ๋งŽ์ด ์ฐพ์•„๋ณด๊ณ  ๊ดœ์ฐฎ์œผ๋ฉด, ์–ด๋А์ •๋„ ์‚ฐ์„ ๋‹ค ๋‚ด๋ ค์™”๋‹ค๊ณ  ์ƒ๊ฐํ•˜๋Š”๊ฒƒ์ด ๋งž์„๋“ฏ ํ•ฉ๋‹ˆ๋‹ค. 
  • ์ด ๋ฐฉ๋ฒ•์ด๋ฉด ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์ด ์ ํ•ฉํ• ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋ฉด ์—ฌ๊ธฐ์„œ ์–ด๋– ํ•œ ์†์‹ค ํ•จ์ˆ˜(Loss Function)์„ ์‚ฌ์šฉํ•ด์•ผ ํ•˜๋Š”์ง€ ์•Œ์•„๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

๋ถ„๋ฅ˜

  • ๋ถ„๋ฅ˜์—์„œ ์†์‹ค์€ ๊ฐ„๋‹จํ•ฉ๋‹ˆ๋‹ค. ์ •๋‹ต์„ ๋ชป๋งž์ถ”๋Š” ๊ฒƒ์ด์ฃ . ์˜ˆ๋กœ 2์ง„๋ถ„๋ฅ˜๋ฅผ ๋“ค์–ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.
  • ๋„๋ฏธ๊ฐ€ ์–‘์„ฑ(1), ๋น™์–ด๊ฐ€ ์Œ์„ฑ(0)์ด๋ผ๊ณ  ๊ฐ€์ •ํ•˜๊ณ  ์•„๋ž˜ ๊ทธ๋ฆผ์„ ํ•œ๋ฒˆ ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

  • ์ •ํ™•๋„๋Š” 4๊ฐœ์˜ ์˜ˆ์ธก์ค‘ 2๊ฐœ๋งŒ ๋งž์•˜์œผ๋ฏ€๋กœ 2/4 = 0.5 ์ž…๋‹ˆ๋‹ค. ๊ทผ๋ฐ, ์—ฌ๊ธฐ์„œ ์ •ํ™•๋„๋ฅผ ์†์‹ค ํ•จ์ˆ˜๋กœ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์„๊นŒ์š”? 
  • ์˜ˆ๋ฅผ ๋“ค์–ด์„œ ์ •ํ™•๋„์— ์Œ์ˆ˜๋ฅผ ์ทจํ•˜๋ฉด -1.0์ด ์ œ์ผ ๋‚ฎ๊ณ  0.0์ด ์ œ์ผ ๋†’์Šต๋‹ˆ๋‹ค. ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์„๊นŒ์š”?
  • ๊ทผ๋ฐ, ์ •ํ™•๋„์—๋Š” ๋‹จ์ ์ด ์žˆ์Šต๋‹ˆ๋‹ค ์•ž์˜ ๊ทธ๋ฆผ์ฒ˜๋Ÿผ 4๊ฐœ์˜ ์ƒ˜ํ”Œ๋งŒ ์žˆ๋‹ค๋ฉด ๊ฐ€๋Šฅํ•œ ์ •ํ™•๋„๋Š” 0, 0.25, 0.5, 0.75, 1 ๋‹ค์„ฏ๊ฐ€์ง€ ๋ฟ์ž…๋‹ˆ๋‹ค.
  • ๊ทธ๋ฆฌ๊ณ  ์ •ํ™•๋„์˜ ๊ฐœ์ˆ˜๊ฐ€ ๋งŽ์ด ์—†์–ด์„œ ์ค‘๊ฐ„์ด ๋“ฌ์„ฑ๋“ฌ์„ฑํ•˜๋‹ค๋ฉด ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•์„ ์ด์šฉํ•ด์„œ ์กฐ๊ธˆ์”ฉ ์›€์ง์ผ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ์‚ฐ์˜ ๊ฒฝ์‚ฌ๋ฉด์€ ์—ฐ์†์ ์ด์—ฌ์•ผ ํ•˜๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.

  • ๊ทธ๋Ÿฌ๋ฉด ์–ด๋–ป๊ฒŒ ํ•ด์•ผ ์—ฐ์†์ ์ธ ์†์‹คํ•จ์ˆ˜๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์„๊นŒ์š”? ํ˜น์‹œ 'Logistic Regression(๋กœ์ง€์Šคํ‹ฑ ํšŒ๊ท€)'์—์„œ ํšŒ๊ท€ ๋ชจ๋ธ์ด ํ™•๋ฅ ์„ ์ถœ๋ ฅํ•œ ๊ฒƒ์„ ๊ธฐ์–ตํ•˜์‹œ๋‚˜์š”?
  • ์˜ˆ์ธกํ•˜๋Š” ๊ฐ’์€ 0 ๋˜๋Š” 1์ด์ง€๋งŒ, ํ™•๋ฅ ์€ 0~1 ์‚ฌ์ด์˜ ์–ด๋– ํ•œ ๊ฐ’๋„ ๋ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ฆ‰, ์—ฐ์†์ ์ด์ฃ . ํ•œ๋ฒˆ ์˜ˆ์‹œ๋ฅผ ๋“ค์–ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

Logistic Loss Function (๋กœ์ง€์Šคํ‹ฑ ์†์‹ค ํ•จ์ˆ˜)

  • ์ƒ˜ํ”Œ 4๊ฐœ์˜ ํ™•๋ฅ ์„ ๊ฐ๊ฐ 0.8, 0.7, 0.4, 0.2 ๋ผ๊ณ  ๊ฐ€์ •ํ•ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. ์ด๋Ÿฐ ๊ฒฝ์šฐ, ์˜ˆ์ธก์ด 1์— ๊ฐ€๊นŒ์šธ์ˆ˜๋ก ์ข‹์€ ๋ชจ๋ธ์ž…๋‹ˆ๋‹ค.
  • ์˜ˆ์ธก ๊ฐ’์ด 1์— ๊ฐ€๊นŒ์šธ์ˆ˜๋ก ์˜ˆ์ธก๊ณผ ํƒ€๊นƒ์˜ ๊ณฑ์˜ ์Œ์ˆ˜๋Š” ์ ์  ์ž‘์•„์ง‘๋‹ˆ๋‹ค. ์ด ๊ฐ’์„ ์†์‹ค ํ•จ์ˆ˜๋กœ๋„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
0.8(์˜ˆ์ธก) x 1 (์ •๋‹ต/Target) = - 0.8
0.7(์˜ˆ์ธก) x 1 (์ •๋‹ต/Target) = - 0.7
1 - 0.4 -> 0.6(์˜ˆ์ธก) x 0 -> 1 (์ •๋‹ต/Target) = - 0.6
1 - 0.2 -> 0.8(์˜ˆ์ธก) x 0 -> 1 (์ •๋‹ต/Target) = - 0.8
  • ์ฒซ,2๋ฒˆ์งธ ์ƒ˜ํ”Œ๋“ค์€ ์–‘์„ฑ ํด๋ž˜์Šค ์ž„์œผ๋กœ, ์–‘์„ฑ ํด๋ž˜์Šค์˜ ํƒ€๊นƒ์ธ 1๊ณผ ๊ณฑํ•ด์„œ ์Œ์ˆ˜๋กœ ๋ด๊ฟ€ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. 
  • 3,4๋ฒˆ์งธ ์ƒ˜ํ”Œ๋“ค์€ ์Œ์„ฑ ํด๋ž˜์Šค ์ž„์œผ๋กœ, ์Œ์„ฑ ํด๋ž˜์Šค์˜ ํƒ€๊นƒ์ธ 0๊ณผ ๊ณฑํ•˜๋ฉด? ๋ฌด์กฐ๊ฑด 0์ด ๋จ์œผ๋กœ ๊ฒฐ๋ก ์„ ๋‚ด๋ฆด์ˆ˜๋Š” ์—†์Šต๋‹ˆ๋‹ค.
  • ๊ทธ๋ž˜์„œ ๋ฐฉ๋ฒ•์€ ํƒ€๊นƒ์„ ์–‘์„ฑ ํด๋ž˜์Šค์ฒ˜๋Ÿผ ๋ด๊ฟ”์„œ 1๋กœ ๋ด๊ฟ‰๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด์„œ 1 - 0.4 = 0.6์œผ๋กœ ๋ด๊ฟ”์„œ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๊ณฑํ•ด์„œ ์Œ์ˆ˜๋กœ ๋ด๊พธ๋Š”๊ฒƒ์€ ๋™์ผํ•ฉ๋‹ˆ๋‹ค. 
  • ๊ทธ๋ž˜์„œ ์˜ˆ์ธก ํ™•๋ฅ ์˜ ๋ฒ”์œ„๋Š” 0~1 ์‚ฌ์ด์ธ๋ฐ, ๋กœ๊ทธํ•จ์ˆ˜๋Š” ์ด ์‚ฌ์ด์—์„œ ์Œ์ˆ˜๊ฐ€ ๋จ์œผ๋กœ ์ตœ์ข… ์†์‹ค๊ฐ’์€ ์–‘์ˆ˜๊ฐ€ ๋ฉ๋‹ˆ๋‹ค. ์†์‹ค์ด ์–‘์ˆ˜๊ฐ€ ๋˜๋ฉด ๋” ์ดํ•ดํ•˜๊ธฐ ์‰ฝ์Šต๋‹ˆ๋‹ค.
  • ๊ทธ๋ฆฌ๊ณ  ๋กœ๊ทธ ํ•จ์ˆ˜๋Š” 0์— ๊ฐ€๊นŒ์šธ์ˆ˜๋ก ์•„์ฃผ ํฐ ์Œ์ˆ˜๊ฐ€ ๋จ์œผ๋กœ ์†์‹ค์„ ํฌ๊ฒŒ ๋งŒ๋“ค์–ด์„œ ๋ชจ๋ธ์— ์˜ํ–ฅ์„ ๋ฏธ์น˜๋Š”๊ฒƒ๋„ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.
๊ฒฐ๋ก ์ ์œผ๋กœ. loss์˜ ๊ฐ’์ด 0์— ๊ฐ€๊นŒ์šธ์ˆ˜๋ก ๋†’์€ ์†์‹ค, 1์— ๊ฐ€๊นŒ์šธ์ˆ˜๋ก ๋‚ฎ์€ ์†์‹ค์„ ๊ธฐ๋กํ•ฉ๋‹ˆ๋‹ค. 

์ •๋ฆฌํ•˜๋ฉด ์œ„์˜ ๊ทธ๋ฆผ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค. ์–‘์„ฑ ํด๋ž˜์Šค(Target = 1)์ผ๋•Œ, ์†์‹ค์€ -log(์˜ˆ์ธก ํ™•๋ฅ )๋กœ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค. ํ™•๋ฅ ์ด 1์—์„œ ๋ฉ€์–ด์งˆ์ˆ˜๋ก, ์†์‹ค์ด ์•„์ฃผ ํฐ ์–‘์ˆ˜๊ฐ€ ๋ฉ๋‹ˆ๋‹ค. ์Œ์ˆ˜ ํด๋ž˜์Šค (Target = 0)์ผ๋•Œ, ์†์‹ค์€ -log(1 - ์˜ˆ์ธก ํ™•๋ฅ )๋กœ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค. ์ด ํ™•๋ฅ ์ด 0์—์„œ ๋ฉ€์–ด์งˆ์ˆ˜๋ก ์†์‹ค์€ ์•„์ฃผ ํฐ ์–‘์ˆ˜๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.
  • ์ด ์†์‹คํ•จ์ˆ˜๋ฅผ Logistic loss function(๋กœ์ง€์Šคํ‹ฑ ์†์‹ค ํ•จ์ˆ˜) or Binary cross-entropy loss function(์ด์ง„ ํฌ๋กœ์Šค์—”ํŠธ๋กœํ”ผ ์†์‹ค ํ•จ์ˆ˜) ๋ผ๊ณ  ๋ถ€๋ฆ…๋‹ˆ๋‹ค.
  • ์ด์ง„ ๋ถ„๋ฅ˜์—๋Š” Logistic loss function(๋กœ์ง€์Šคํ‹ฑ ์†์‹ค ํ•จ์ˆ˜)๋ฅผ ์‚ฌ์šฉํ•˜๊ณ  ๋‹ค์ค‘๋ถ„๋ฅ˜๋ฅผ ํ• ๋•Œ์—๋Š” Binary cross-entropy loss function(์ด์ง„ ํฌ๋กœ์Šค์—”ํŠธ๋กœํ”ผ ์†์‹ค ํ•จ์ˆ˜)๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.
  • ๊ทธ๋Ÿฌ๋ฉด ์ด๋ฒˆ์— ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์„ ์‚ฌ์šฉํ•œ ๋ถ„๋ฅ˜ ๋ชจ๋ธ์„ ํ•œ๋ฒˆ ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

SGDClassifier

import pandas as pd
fish = pd.read_csv('https://bit.ly/fish_csv_data')
fish_input = fish[['Weight','Length','Diagonal','Height','Width']].to_numpy()
fish_target = fish['Species'].to_numpy()
  • ์—ฌ๊ธฐ์„œ Species์—ด์„ ์ œ์™ธํ•œ ๋‚˜๋จธ์ง€ 5๊ฐœ ๋ฐ์ดํ„ฐ๋Š” input data๋กœ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. Species์—ด์€ Target data๋กœ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.
  • ์ด์ œ scikit-learn์˜ train_test_split() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด ์ด ๋ฐ์ดํ„ฐ๋ฅผ train & test set๋กœ ๋‚˜๋ˆ•๋‹ˆ๋‹ค.
from sklearn.model_selection import train_test_split
train_input, test_input, train_target, test_target = train_test_split(fish_input, fish_target, random_state=42)
  • ๊ทธ๋ฆฌ๊ณ , ๊ฐ ๋ฐ์ดํ„ฐ ์„ธํŠธ์˜ ํŠน์„ฑ์„ ํ‘œ์ค€ํ™” ์ „๋Ÿฌ๋ฆฌ๋ฅผ ํ•ฉ๋‹ˆ๋‹ค. ๊ผญ, ํ›ˆ๋ จ์„ธํŠธ์—์„œ ํ•œ์Šตํ•œ ํ†ต๊ณ„ ๊ฐ’์œผ๋กœ ํ…Œ์ŠคํŠธ ์„ธํŠธ๋กœ ๋ณ€ํ™˜ ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(train_input)
train_scaled = ss.transform(train_input)
test_scaled = ss.transform(test_input)
  • ์ด๋ ‡๊ฒŒ ํŠน์„ฑ๊ฐ’์˜ Scale์„ ๋งž์ถ”๊ณ  2๊ฐœ์˜ Numpy์˜ ๋ฐฐ์—ด์„ ์ค€๋น„ํ•˜์—ฌ, ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์„ ์ œ๊ณตํ•˜๋Š” ๋Œ€ํ‘œ์ ์ธ ๋ถ„๋ฅ˜๋ฒ•์ธ SGDClassifier ํด๋ž˜์Šค๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ import ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.
  • ๊ฐ์ฒด๋ฅผ ๋งŒ๋“ค๋•Œ 2๊ฐœ์˜ ๋งค๊ฐœ๋ณ€์ˆ˜๋ฅผ ์ง€์ •์„ ํ•˜๋Š”๋ฐ, loss='log_loss'๋ฅผ ์ง€์ •ํ•˜์—ฌ ๋กœ์ง€์Šคํ‹ฑ ์†์‹ค ํ•จ์ˆ˜๋ฅผ ์ง€์ •ํ•˜๊ณ , max_iter๋Š” ์ˆ˜ํ–‰ํ•  epoch ํšŸ์ˆ˜๋ฅผ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„ ๋А 10์œผ๋กœ ์ง€์ •ํ•ด์„œ ์ „์ฒด ํ›ˆ๋ จ์„ธํŠธ๋ฅผ 10๋ฒˆ ๋ฐ˜๋ณตํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.
from sklearn.linear_model import SGDClassifier
# scikit-learn์˜ SGDClassifier๋Š” ํ™•๋ฅ ์  ๊ฒฝ์‚ฌํ•˜๊ฐ•๋ฒ•๋งŒ ์ง€์›ํ•œ๋‹ค.
# ConvergenceWarning ๋ฐœ์ƒ์‹œ, max_iter์˜ ๊ฐ’์„ ๋Š˜๋ ค์ฃผ๋Š”๊ฒƒ์ด ์ข‹๋‹ค.
sc = SGDClassifier(loss='log_loss', max_iter=10, random_state=42)
sc.fit(train_scaled, train_target)

print(sc.score(train_scaled, train_target)) # ์ •ํ™•๋„
print(sc.score(test_scaled, test_target)) # ์ •ํ™•๋„
0.8151260504201681
0.8
  • ์ด๋ ‡๊ฒŒ ์ •ํ™•๋„๊ฐ€ ๋‚ฎ์œผ๋ฉด ๋ฐ˜๋ณตํšŸ์ˆ˜๋ฅผ ๋†’์ด๋ฉด ๋ฉ๋‹ˆ๋‹ค.
์—ฌ๊ธฐ์„œ ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์€ ์ ์ง„์  ํ•™์Šต์ด ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค. SGDClassifier ๊ฐ์ฒด๋ฅผ ๋‹ค์‹œ ๋งŒ๋“ค์ง€ ๋ง๊ณ , ํ›ˆ๋ จํ•œ ๋ชจ๋ธ sc๋ฅผ ๋” ํ›ˆ๋ จ์‹œ์ผœ ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. ๋ชจ๋ธ์„ ๊ณ„์† ์ด์–ด์„œ ํ›ˆ๋ จ ์‹œํ‚ค๋Ÿฌ๋ฉด? partial_fit() Method๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.
# scikit-learn ์—์„œ epoch๋ฅผ ๋Š˜๋ ค๊ฐ€๋ฉด, max_iter๋ฅผ ํฌ๊ฒŒ ํ•˜๋ฉด ๋ชจ๋ธ์ด ๋งŽ์ด ํ›ˆ๋ จ๋œ ๊ณผ๋Œ€ ์ ํ•ฉ์œผ๋กœ ๊ฐˆ ์ˆ˜ ์žˆ๋‹ค.
sc.partial_fit(train_scaled, train_target)

print(sc.score(train_scaled, train_target))
print(sc.score(test_scaled, test_target))
  • partial_fit() Method๋Š” ์ผ๋ฐ˜ fit() Method์™€ ์‚ฌ์šฉ๋ฒ•์ด ๊ฐ™์ง€๋งŒ ํ˜ธ์ถœํ• ๋•Œ ๋งˆ๋‹ค, 1 epoch์”ฉ ์ด์–ด์„œ ํ›ˆ๋ จํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค

Epoch์™€ ๊ณผ๋Œ€/๊ณผ์†Œ์ ํ•ฉ

ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์„ ์‚ฌ์šฉํ•œ ๋ชจ๋ธ์€ epoch์˜ ํšŸ์ˆ˜์— ๋”ฐ๋ผ ๊ณผ์†Œor๊ณผ๋Œ€ ์ ํ•ฉ์ด ๋ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ํšŸ์ˆ˜๊ฐ€ ์ ์œผ๋ฉด ํ›ˆ๋ จ์„ธํŠธ๋ฅผ ๋œ ํ•™์Šตํ•˜๊ณ , ๋งŽ์œผ๋ฉด ์™„์ „ํžˆ ํ•™์Šตํ•ด์„œ ์•„์ฃผ ์ž˜ ๋งž๋Š” ๋ชจ๋ธ์ด ๋งŒ๋“ค์–ด ์ง‘๋‹ˆ๋‹ค. ๋‹ค๋งŒ ์ด๋Ÿฌํ•œ ๋ฌธ์ œ๋“ค์€ ๋ชจ๋ธ์ด ๊ณผ์†Œ/๊ณผ๋Œ€ ์ ํ•ฉ์ด ๋ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

  • ํ›ˆ๋ จ์„ธํŠธ ์ ์ˆ˜๋Š” epoch๊ฐ€ ์ง„ํ–‰๋ ์ˆ˜๋ก ๊พธ์ค€ํžˆ ์ฆ๊ฐ€ํ•˜์ง€๋งŒ, ํ…Œ์ŠคํŠธ ์„ธํŠธ ์ ์ˆ˜๋Š” ์–ด๋А์ง€์ ๋ถ€ํ„ฐ ๊ฐ์†Œํ•˜๊ธฐ ์‹œ์ž‘ํ•ฉ๋‹ˆ๋‹ค. ๋ฐ”๋กœ ์ด ์ง€์ ์ด ๋ชจ๋ธ์ด ๊ณผ๋Œ€์ ํ•ฉ ๋˜๊ธฐ ์‹œ์ž‘ํ•˜๋Š” ๊ณณ์ž…๋‹ˆ๋‹ค.
  • ์ด๋Ÿด๋•Œ, ๊ณผ๋Œ€์ ํ•ฉ์ด ๋˜๊ธฐ์ „์— ๋ชจ๋ธ์„ ํ›ˆ๋ จ์„ ์ข…๋ฃŒ ์‹œํ‚ค๋Š”๋ฐ ์ด๊ฒƒ์„ ์กฐ๊ธฐ์ข…๋ฃŒ(early stopping)์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค.  ํ•œ๋ฒˆ ๊ทธ๋ž˜ํ”„๋ฅผ ๋งŒ๋“ค์–ด์„œ ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.
 ์—ฌ๊ธฐ์„œ๋Š” partial_fit() Method๋งŒ ์‚ฌ์šฉํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค. ์ด Method๋งŒ ์‚ฌ์šฉํ•˜๋ ค๋ฉด, ํ›ˆ๋ จ์„ธํŠธ์— ์žˆ๋Š” ์ „์ฒด ํด๋ž˜์Šค์˜ label์„ partial_fit() Method์— ์ „๋‹ฌ์„ ํ•ด์ฃผ์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด๋ฅผ ์œ„ํ•ด์„œ np.unique() ํ•จ์ˆ˜๋กœ train_target์— ์žˆ๋Š” 7๊ฐœ์˜ ์ƒ์„  ๋ชฉ๋ก์„ ๋งŒ๋“ญ๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๊ฐ epoch ๋งˆ๋‹ค ํ›ˆ๋ จ, ํ…Œ์ŠคํŠธ ์„ธํŠธ์— ๋Œ€ํ•œ ์ ์ˆ˜๋ฅผ ๊ธฐ๋กํ•˜๊ธฐ ์œ„ํ•ด์„œ 2๊ฐœ์˜ list๋ฅผ ์ค€๋น„ํ•ฉ๋‹ˆ๋‹ค.
import numpy as np
sc = SGDClassifier(loss='log_loss', random_state=42)
train_score = []
test_score = []

classes = np.unique(train_target)
  • 300๋ณ€์˜ epoch๋ฅผ ์ฃผ์–ด์„œ ํ›ˆ๋ จ์„ ์ง„ํ–‰ํ•ฉ๋‹ˆ๋‹ค. ๋ฐ˜๋ณตํ• ๋•Œ ๋งˆ๋‹ค, train, test_set์˜ ์ ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•˜์—ฌ train_score, test_score list์— ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
# 300๋ฒˆ์˜ epoch ๋ฐ˜๋ณตํ•ด์„œ ํ›ˆ๋ จ
# partial_fit๋Š” ํ›ˆ๋ จ์„ธํŠธ์˜ ์ผ๋ถ€๋งŒ ์ฃผ์–ด์ง„๋‹ค๊ณ  ๊ฐ€์ •, ์ „์ฒด sample์˜ ๋‚˜์˜ฌ์ˆ˜ ์žˆ๋Š” class๊ฐœ์ˆ˜ ๋ชฉ๋ก๋ฅผ ์ „๋‹ฌํ•ด์ค˜์•ผํ•จ
for _ in range(0,300):
    sc.partial_fit(train_scaled, train_target, classes=classes)
    train_score.append(sc.score(train_scaled, train_target))
    test_score.append(sc.score(test_scaled, test_target))
# ๊ทธ๋ž˜ํ”„๋ฅผ ๋ณด๋ฉด 100์ •๋„์˜ epoch๊ฐ€ ์ ˆ์ถฉ์ ์ด๋ผ๊ณ  ํŒ๋‹จ.
import matplotlib.pyplot as plt
plt.plot(train_score) # training_score(blue)
plt.plot(test_score) # test_score(yellow)
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.show()

blue: training_set_score, yellow: test_set_score

๋ฐ์ดํ„ฐ๊ฐ€ ์ž‘๊ธฐ ๋•Œ๋ฌธ์— ์ž˜ ๋‚˜ํƒ€๋‚˜์ง€๋Š” ์•Š์Šต๋‹ˆ๋‹ค. ๋‹ค๋งŒ, 100๋ฒˆ์งธ epoch ์ดํ›„ ๊ฐ ์ ์ˆ˜๊ฐ€ ๋ฒŒ์–ด์ง€๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๊ฒƒ์„ ๋ณด๋ฉด 100๋ฒˆ์งธ epoch๊ฐ€ ๊ฐ€์žฅ ์ ์ ˆํ•œ ์ ์ˆ˜๋กœ ๋ณด์ž…๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋ฉด 100์— ๋งž์ถ”๊ณ  ํ•œ๋ฒˆ ํ›ˆ๋ จ์‹œํ‚ค๊ณ , ์ ์ˆ˜๋ฅผ ํ‘œํ˜„ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.
sc = SGDClassifier(loss='log_loss', max_iter=100, tol=None, random_state=42)
sc.fit(train_scaled, train_target)

print(sc.score(train_scaled, train_target)) # training_set ์„ฑ๋Šฅ: 96%
print(sc.score(test_scaled, test_target)) # test_set ์„ฑ๋Šฅ: 93%
0.957983193277311
0.925
  • SGDClassifier ํด๋ž˜์Šค๋Š” ์ผ์ • epoch ๋™์•ˆ ์„ฑ๋Šฅ์ด ํ–ฅ์ƒ๋˜์ง€ ์•Š์„์‹œ, ๋” ํ›ˆ๋ จํ•˜์ง€ ์•Š๊ณ , ์ž๋™์œผ๋กœ ๋ฉˆ์ถค๋‹ˆ๋‹ค. tol ๋งค๊ฐœ ๋ณ€์ˆ˜๋ฅผ None์œผ๋กœ ์ง€์ •ํ•˜๋ฉด ์ž๋™์œผ๋กœ ๋ฉˆ์ถ”์ง€ ์•Š๊ณ , max_iter=100 ๋งŒํผ ๋ฌด์กฐ๊ฑด ๋ฐ˜๋ณตํ•˜๋„๋ก ํ•ฉ๋‹ˆ๋‹ค.

Hinge loss (ํฐ์ง€ ์†์‹ค)

์ด ๊ธ€์„ ๋งˆ๋ฌด๋ฆฌ ํ•˜๊ธฐ ์ „์—, SGDClassifier์˜ loss ๋งค๊ฐœ ๋ณ€์ˆ˜๋ฅผ ์ž ์‹œ ์„ค๋ช…์„ ๋“œ๋ฆฌ๊ฒ ์Šต๋‹ˆ๋‹ค. loss ๋งค๊ฐœ๋ณ€์ˆ˜์˜ ๊ธฐ๋ณธ๊ฐ’์€ 'hinge'์ž…๋‹ˆ๋‹ค. 
ํฐ์ง€ ์†์‹ค (Hinge loss)๋Š” Support Vector Machine ์ด๋ผ๊ณ  ๋ถˆ๋ฆฌ๋Š” ๋จธ์‹ ๋Ÿฌ๋‹ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์œ„ํ•œ ์†์‹ค ํ•จ์ˆ˜์ž…๋‹ˆ๋‹ค.
  • ์ž์„ธํžˆ๋Š” ์„ค๋ช… ๋“œ๋ฆฌ์ง€๋Š” ์•Š๊ฒ ์Šต๋‹ˆ๋‹ค๋งŒ, Support Vector Machine์ด ๋„๋ฆฌ ์‚ฌ์šฉํ•˜๋Š” ๋จธ์‹ ๋Ÿฌ๋‹ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ค‘ ํ•˜๋‚˜๋ผ๋Š” ์ 
  • SGDClassifier๊ฐ€ ์—ฌ๋Ÿฌ ์ข…๋ฅ˜์˜ ์†์‹ค ํ•จ์ˆ˜๋ฅผ loss ๋งค๊ฐœ ๋ณ€์ˆ˜์— ์ง€์ •ํ•˜์—ฌ ๋‹ค์–‘ํ•œ ML ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์ง€์›ํ•˜๋Š”๊ฒƒ๋งŒ ์•Œ๋ ค๋“œ๋ฆฌ๊ฒ ์Šต๋‹ˆ๋‹ค.
  • ์˜ˆ์‹œ๋กœ Hinge loss๋ฅผ ์‚ฌ์šฉํ•ด์„œ ๊ฐ™์€ ๋ฐ˜๋ณต ํšŸ์ˆ˜๋™์•ˆ ๋ชจ๋ธ์„ ํ›ˆ๋ จ์‹œ์ผœ ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.
sc = SGDClassifier(loss='hinge', max_iter=100, tol=None, random_state=42)
sc.fit(train_scaled, train_target)

print(sc.score(train_scaled, train_target)) # training_set ์„ฑ๋Šฅ: 95%
print(sc.score(test_scaled, test_target)) # test_set ์„ฑ๋Šฅ: 93%
0.9495798319327731
0.925

Keywords

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

  • ํ›ˆ๋ จ ์„ธํŠธ์—์„œ ์ƒ˜ํ”Œ ํ•˜๋‚˜์”ฉ ๊บผ๋‚ด ์†์‹ค ํ•จ์ˆ˜์˜ ๊ฒฝ์‚ฌ๋ฅผ ๋”ฐ๋ผ ์ตœ์ ์˜ ๋ชจ๋ธ์„ ์ฐพ๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์ž…๋‹ˆ๋‹ค. ์ƒ˜ํ”Œ์„ ํ•˜๋‚˜์”ฉ ์‚ฌ์šฉํ•˜์ง€ ์•Š๊ณ  ์—ฌ๋Ÿฌ ๊ฐœ๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋ฏธ๋‹ˆ๋ฐฐ์น˜ ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ• ์ด ๋ฉ๋‹ˆ๋‹ค. ํ•œ ๋ฒˆ์— ์ „์ฒด ์ƒ˜ํ”Œ์„ ์‹œ์šฉํ•˜๋ฉด ๋ฐฐ์น˜ ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์ด ๋ฉ๋‹ˆ๋‹ค.

์†์‹ค ํ•จ์ˆ˜ (Loss Function)

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

์—ํฌํฌ (Epochs)

  • ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์—์„œ ์ „์ฒด ์ƒ˜ํ”Œ์„ ๋ชจ๋‘ ์‚ฌ์šฉํ•˜๋Š” ํ•œ ๋ฒˆ ๋ฐ˜๋ณต์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ์ผ๋ฐ˜ ์ ์œผ๋กœ ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ• ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ์ˆ˜์‹ญ์—์„œ ์ˆ˜๋ฐฑ ๋ฒˆ์˜ ์—ํฌํฌ๋ฅผ ๋ฐ˜๋ณตํ•ฉ๋‹ˆ๋‹ค.

scikit-learn

  • SGDClassifier๋Š” ํ™•๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์„ ์‚ฌ์šฉํ•œ ๋ถ„๋ฅ˜ ๋ชจ๋ธ์„ ๋งŒ๋“ญ๋‹ˆ๋‹ค. loss ๋งค๊ฐœ๋ณ€์ˆ˜๋Š” ํš๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์œผ๋กœ ์ตœ์ ํ™”ํ•  ์†์‹ค ํ•จ์ˆ˜๋ฅผ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค.
  • ๊ธฐ๋ณธ๊ฐ’์€ ์„œํฌํŠธ ๋ฒกํ„ฐ ๋จธ์‹ ์„ ์œ„ํ•œ ‘hinge’ ์†์‹ค ํ•จ์ˆ˜์ž…๋‹ˆ๋‹ค. ๋กœ์ง€์Šคํ‹ฑ ํšŒ๊ท€๋ฅผ ์œ„ํ•ด์„œ๋Š” ‘log’๋กœ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค.
  • penalty ๋งค๊ฐœ๋ณ€์ˆ˜์—์„œ ๊ทœ์ œ์˜ ์ข…๋ฅ˜๋ฅผ ์ง€์ •ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ธฐ๋ณธ๊ฐ’์€ L2 ๊ทœ์ œ๋ฅผ ์œ„ํ•œ ‘12’์ž…๋‹ˆ ๋‹ค. L1 ๊ทœ์ œ๋ฅผ ์ ์šฉํ•˜๋ ค๋ฉด ‘11’๋กœ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค. ๊ทœ์ œ ๊ฐ•๋„๋Š” alpha ๋งค๊ฐœ๋ณ€์ˆ˜์—์„œ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค. ๊ธฐ๋ณธ๊ฐ’์€ 0.0001์ž…๋‹ˆ๋‹ค.
  • max_iter ๋งค๊ฐœ๋ณ€์ˆ˜๋Š” ์—ํฌํฌ ํšŸ์ˆ˜๋ฅผ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค. ๊ธฐ๋ณธ๊ฐ’์€ 1000์ž…๋‹ˆ๋‹ค.
  • tol ๋งค๊ฐœ๋ณ€์ˆ˜๋Š” ๋ฐ˜๋ณต์„ ๋ฉˆ์ถœ ์กฐ๊ฑด์ž…๋‹ˆ๋‹ค. n iter_no_change ๋งค๊ฐœ๋ณ€์ˆ˜์—์„œ ์ง€์ •ํ•œ ์—ํฌํฌ ๋™ ์•ˆ ์†์‹ค์ด tol ๋งŒํผ ์ค„์–ด๋“ค์ง€ ์•Š์œผ๋ฉด ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด ์ค‘๋‹จ๋ฉ๋‹ˆ๋‹ค. tol ๋งค๊ฐœ๋ณ€์ˆ˜์˜ ๊ธฐ๋ณธ๊ฐ’์€ 0.001 ์ด๊ณ  n_iter_no_change ๋งค๊ฐœ๋ณ€์ˆ˜์˜ ๊ธฐ๋ณธ๊ฐ’์€ 5์ž…๋‹ˆ๋‹ค.

SGDRegressor

  • ํš๋ฅ ์  ๊ฒฝ์‚ฌ ํ•˜๊ฐ•๋ฒ•์„ ์‚ฌ์šฉํ•œ ํšŒ๊ท€ ๋ชจ๋ธ์„ ๋งŒ๋“ญ๋‹ˆ๋‹ค. loss ๋งค๊ฐœ๋ณ€์ˆ˜์—์„œ ์†์‹ค ํ•จ์ˆ˜๋ฅผ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค. ๊ธฐ๋ณธ๊ฐ’์€ ์ œ๊ณฑ ์˜ค์น˜๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ‘squared_loss’ ์ž…๋‹ˆ๋‹ค.
  • ์•ž์˜ SGDClassifier์—์„œ ์„ค๋ช…ํ•œ ๋งค๊ฐœ๋ณ€์ˆ˜๋Š” ๋ชจ๋‘ SGDRegressor์—์„œ ๋™์ผํ•˜๊ฒŒ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.