๋ฅ๋ฌ๋
๋ฅ๋ฌ๋๊ณผ ์ ๊ฒฝ๋ง
๋จธ์ ๋ฌ๋์ ํ ๋ถ์ผ๋ก, ์ธ๊ณต ์ ๊ฒฝ๋ง(ANN)์ ๊ธฐ๋ฐ์ผ๋ก ๋๋์ ๋ฐ์ดํฐ๋ฅผ ํ์ตํ์ฌ ๋ฐ์ด๋ ์ฑ๋ฅ์ ๋ฐํํ๋ ์๊ณ ๋ฆฌ์ฆ
๋ฅ๋ฌ๋์ ์ฌ๋ฌ ์ธต์ ํตํด ์ ์ ๋ ์ถ์ํ๋ ํน์ง์ ํ์ตํ๋ฉฐ, ๋ณต์กํ ํจํด์ ์ธ์ํ๊ณ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ ๋ฐ์ด๋ ์ฑ๋ฅ์ ๋ณด์ธ๋ค.
ํนํ ๋ฅ๋ฌ๋์ ๋๊ท๋ชจ ๋ฐ์ดํฐ์ ๊ฐ๋ ฅํ ๊ณ์ฐ ๋ฅ๋ ฅ์ ํ์ฉํ์ฌ ๋ชจ๋ธ์ด ์ ์ ๋ ๊ฐ๋ ฅํ ์์ธก ๋ฅ๋ ฅ์ ๋ฐํํ๋๋ก ํ๋ค.
๋ฅ๋ฌ๋ vs ์ ํต์ ์ธ ๋จธ์ ๋ฌ๋
- ์ ํต์ ์ธ ๋จธ์ ๋ฌ๋์์๋ ํน์ง ์ถ์ถ(Feature Engineering)์ ์ฌ๋์ด ์ง์ ํด์ผ ํ๋ค.
- ๋ฅ๋ฌ๋์ ์๋ ํน์ง ํ์ต(Representation Learning)์ ํตํด ๋ฐ์ดํฐ๋ฅผ ์๋์ผ๋ก ๋ถ์ํ๊ณ ์ค์ํ ํน์ง์ ํ์ตํ๋ค.
- ์ ํต์ ์ธ ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ์ฃผ๋ก ๋จ์ผ ์ธต์์ ์ฃผ์ด์ง ํน์ง์ ๋ฐํ์ผ๋ก ์์ธก์ ์ํ
- ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ๋ค์ธต ์ ๊ฒฝ๋ง์ ์ฌ์ฉํ์ฌ ์ ์ ๋ ๋ณต์กํ ํจํด์ ์๋์ผ๋ก ํ์ต
์ฅ์ , ๋จ์
์ฅ์
- ๋ณต์กํ ๋ฌธ์ ํด๊ฒฐ: ์ฌ๋ฌ ์ธต์ ํตํด ๋ณต์กํ ํจํด์ ํ์ต
- ์๋ํ๋ ํน์ง ํ์ต: ์ฌ๋์ด ์ง์ ํน์ง์ ์ถ์ถํ ํ์ ์์ด, ๋ชจ๋ธ์ด ์๋์ผ๋ก ์ค์ํ ํน์ง์ ํ์ต
๋จ์
- ๋ฐ์ดํฐ ์๊ตฌ๋: ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ๋ง์ ์์ ๋ฐ์ดํฐ๊ฐ ํ์
- ์๊ฐ๊ณผ ์์: ํ๋ จ ๊ณผ์ ์ด ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋ฉฐ, ๊ฐ๋ ฅํ ํ๋์จ์ด(GPU)๊ฐ ํ์
์ธ๊ณต ์ ๊ฒฝ๋ง(ANN)
๊ฐ๋ : ์ธ๊ฐ์ ๋๋ฅผ ๋ชจ๋ฐฉํ ํ์ต ์์คํ ์ผ๋ก, ์ฌ๋ฌ ๊ฐ์ ๋ด๋ฐ์ด ์ฐ๊ฒฐ๋์ด ์ ๋ณด๋ฅผ ์ฒ๋ฆฌ
๋ด๋ฐ: ๋ ธ๋์ ์ฐ๊ฒฐ๋ก ๊ตฌ์ฑ ( Input -> ์ฒ๋ฆฌ -> Output)
๊ฐ ๋ด๋ฐ์ ์ ๋ ฅ๊ฐ์ ๊ฐ์ค์น๋ฅผ ๊ณฑํ๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ํ์ฑํ ํจ์๋ฅผ ํตํด ์ถ๋ ฅ์ผ๋ก ๋ณํ
์ ๊ฒฝ๋ง์ ๊ธฐ๋ณธ ๊ตฌ์ฑ ์์๋ ์ ๋ ฅ์ธต, ์๋์ธต, ์ถ๋ ฅ์ธต์ผ๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ๊ฐ ์ธต์ ์ด์ ์ธต์ ์ถ๋ ฅ์ ์ ๋ ฅ์ผ๋ก ๋ฐ์ ์ฒ๋ฆฌํ๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ค์ ์ธต์ผ๋ก ์ ๋ฌํ๋ค.
๊ธฐ๋ณธ์ ์ธ ์ ๊ฒฝ๋ง์ ์ ๋ ฅ์ธต๊ณผ ์ถ๋ ฅ์ธต๋ง ์์ ์ ์์ง๋ง, ์๋์ ์ถ๊ฐํ๋ฉด ์ ๊ฒฝ๋ง์ ์ ํ๋๊ฐ ํฌ๊ฒ ํฅ์๋๋ค. ์ฌ๋ฌ ๋ด๋ฐ๋ค์ด ์๋ก ๋ค๋ฅธ ์ ๋ ฅ์ ์กฐํฉ์ ํตํด ๋ ๋ณต์กํ ํจํด์ ํ์ตํ ์ ์๊ฒ ํ๊ณ , ์ด๋ ๋ชจ๋ ์ฐ๊ฒฐ์ ๊ฐ์ค์น๊ฐ ๋ถ์ฌ๋๋ ๊ฒ์ ์๋๋ค. ์๋ฅผ ๋ค์ด, ๋ฉด์ ๊ณผ ๋์์์ ๊ฑฐ๋ฆฌ๋ ๊ฐ์ค์น๋ฅผ ๊ฐ์ง ์ ์์ง๋ง, ์นจ์ค ์๋ ๋ถ๋์ฐ ์ฐ๋ น์ ๊ฐ์ค์น๊ฐ ์์ ์๋ ์๋ค. ์ด์ฒ๋ผ ์ ๊ฒฝ๋ง์ ๋ณ์๋ค ์ค ์ค์ํ ๊ฒ๋ง ์ ํํ์ฌ ๊ณ์ฐ์ ๋ฐ์ํ๋ค.
์ ๊ฒฝ๋ง์ ์ธต
- ์ ๋ ฅ์ธต: ์ฒซ ๋ฒ์งธ ์ธต์ผ๋ก ์ ๋ ฅ ๋ณ์๋ค์ด ๋ค์ด๊ฐ
- ์๋์ธต: ์ด ์ธต์ ๋ด๋ฐ๋ค์ด ์ ๋ ฅ์ ์ฒ๋ฆฌํ๊ณ ๊ฐ์ค์น๋ฅผ ํตํด ๋ณ์์ ์ค์๋๊ฐ ์ถ๋ ฅ์ ์ํฅ์ ๋ฏธ์น๋ค.
- ์ถ๋ ฅ์ธต: ๋ง์ง๋ง ์ธต์ผ๋ก, ๊ฐ์ค์น์ ํ์ฑํ๋ ์ ๋ ฅ์ ๋ฐํ์ผ๋ก ์์ธก๋ ๊ฐ์ ์ถ๋ ฅ
- ์ ๋ ฅ ์ ํธ ์ฒ๋ฆฌ: ์ ํธ๋ฅผ ํก์ํ ํ ์ถ๋ ฅ ๊ฒฐ์
- Threshold(์๊ณ๊ฐ): ์ผ์ ์ ํธ๋ ์ด๊ณผ ์ ์ถ๋ ฅ
- Computation(๊ณ์ฐ): ์ ๋ ฅ๊ฐ๊ณผ ๊ฐ์ค์น์ ํฉ์ฐ ํ ํ์ฑํ ํจ์ ์ ์ฉ
- Summation = x1w1 + x2w2 + ... + xnwn
- Threshold๋ณด๋ค ํฌ๋ฉด 1, ์์ผ๋ฉด 0 ์ถ๋ ฅ
์ ๊ฒฝ๋ง ํ์ฑํ ํจ์
ํ์ฑํ ํจ์๋ ๋ด๋ฐ์ด ์ ํธ๋ฅผ ์ ๋ฌํ ์ง ๋ง์ง๋ฅผ ๊ฒฐ์ ํ๋ ์ญํ
Summation ๊ฒฐ๊ณผ์ ๋ฐ๋ผ ์ถ๋ ฅ ๊ฒฐ์
- ์๊ณ๊ฐ ํจ์ (Threshold Function): ์ด์ง ๋ถ๋ฅ์์ ์ฌ์ฉ๋๋ฉฐ, ์ ๋ ฅ๊ฐ์ด ์ผ์ ๊ธฐ์ค์ ๋์ผ๋ฉด 1, ๊ทธ๋ ์ง ์์ผ๋ฉด 0์ ์ถ๋ ฅ
- ์๊ทธ๋ชจ์ด๋ ํจ์ (Sigmoid Function): ์ถ๋ ฅ๊ฐ์ด 0๊ณผ 1 ์ฌ์ด๋ก, ํ๋ฅ ์ ์์ธกํ๋ ๋ฐ ์ ์ฉ
- ์ ๋ฅํ ํจ์ (ReLU, Rectified Linear Unit): 0 ์ดํ์ ๊ฐ์ 0์ผ๋ก ์ฒ๋ฆฌํ๊ณ , ๊ทธ ์ด์์ ๊ฐ์ ๊ทธ๋๋ก ์ถ๋ ฅ
- ํ์ดํผ๋ณผ๋ฆญ ํ์ ํธ ํจ์ (Tanh): ์๊ทธ๋ชจ์ด๋์ ์ ์ฌํ์ง๋ง, ์ถ๋ ฅ๊ฐ์ด -1๊ณผ 1 ์ฌ์ด๋ก ๋ณ๊ฒฝ
์ค์ฐจ ์ญ์ ํ(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๋ก ์ค์ ๋ ํ ์๋ ๋ฏธ๋ถ(๊ธฐ์ธ๊ธฐ ๊ณ์ฐ) ๊ณผ์ ์ ์ถ์
๋ชจ๋ธ ํ๋ จ ๋ฐ ํ์ต ํ๋ฆ
- ๋ฐ์ดํฐ์ ์ค๋น: ํ๋ จ ๋ฐ์ดํฐ์ ํ ์คํธ ๋ฐ์ดํฐ๋ฅผ ๋ถ๋ฆฌ
- ๋ชจ๋ธ ์ ์: ์ ๊ฒฝ๋ง ๋ชจ๋ธ์ ์ ์
- ํ๋ จ: ๊ฒฝ์ฌํ๊ฐ๋ฒ๊ณผ ์ญ์ ํ๋ฅผ ํตํด ๋ชจ๋ธ์ ํ์ต
- ํ๊ฐ: ํ์ต๋ ๋ชจ๋ธ์ ํ๊ฐํ์ฌ ์ฑ๋ฅ์ ํ์ธ
- ๊ฐ์ค์น ์ ์ฅ: ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ ์ฅํ๊ณ , ๋์ค์ ๋ค์ ์ฌ์ฉ
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}")
ํ๊ท ์ ๊ณฑ ์ค์ฐจ๋ฅผ ์ฌ์ฉํด ์์ธก ๊ฐ๊ณผ ์ค์ ๊ฐ์ ์ฐจ์ด๋ฅผ ๊ณ์ฐํ๊ณ , ํ๋ฅ ์ ๊ฒฝ์ฌํ๊ฐ๋ฒ์ ์ฌ์ฉํด ๋ชจ๋ธ์ ํ์ต