๋ฐ์ํ
ํ๋ฅ ์ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ
ํ๋ฅ ์ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ(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()
๋ฐ์ดํฐ๊ฐ ์๊ธฐ ๋๋ฌธ์ ์ ๋ํ๋์ง๋ ์์ต๋๋ค. ๋ค๋ง, 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์์ ๋์ผํ๊ฒ ์ฌ์ฉ๋ฉ๋๋ค.
๋ฐ์ํ
'๐น๏ธ ํผ๊ณต๋จธ์ ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํผ๊ณต๋จธ์ ] Cross-Validation & Grid Search (0) | 2024.07.30 |
---|---|
[ํผ๊ณต๋จธ์ ] Decision Tree (๊ฒฐ์ ํธ๋ฆฌ) (0) | 2023.11.06 |
[ํผ๊ณต๋จธ์ ] Logistic Regression (๋ก์ง์คํฑ ํ๊ท) (0) | 2023.09.25 |
[ML] ํน์ฑ ๊ณตํ๊ณผ ๊ท์ (0) | 2023.09.24 |
[ํผ๊ณต๋จธ์ ] Linear Regression (0) | 2023.09.23 |