- loss์ ์ต์๊ฐ์ ์ฐพ์๋๊ฐ๋ ์ผ๋ จ์ ๊ณผ์ ์ด๋ค.
- Backpropagation ๊ณผ์ ์ค์ ๊ฐ์ค์น๋ฅผ ์ ๋ฐ์ดํธํ๋ฉด์ ์งํ๋๋๋ฐ, ์ด ๋ ํ ์คํ ๋ง๋ค ์ด๋ํ๋ ๋ฐ์๊ตญ์ ํฌ๊ธฐ(๋ณดํญ)์ดย ํ์ต๋ฅ (learning rate)๋ก ์ ์๋๊ณ , ์์ผ๋ก ์ด๋ํ ๋ฐฉํฅ์ย ํ ์ง์ ์ ๊ธฐ์ธ๊ธฐ(gradient)๋ฅผ ํตํด ์ ์๋๋ค.
- ๋งค ์คํ ๋ง๋ค forward pass์ ๋๋จ์์ ๊ณ์ฐ๋๋ ์์ค ํจ์๊ฐ์ ์ง๊ธ๊น์ง ์ ๋ฐ์ดํธ๋ ๊ฐ์ค์น๋ค์ด ์ผ๋ง๋ ์ ์ค์ ๋์ด ์๋์ง๋ฅผ ๋ํ๋ด๋ ์งํ์๋ ๊ฐ๋ค.
ย
SGD(Stochastic Gradient Descent)
# Vanilla update x += - learning_rate * dx #dx: x์์์ loss์ ๋ํ ๊ธฐ์ธ๊ธฐ
- loss์ ๊ฐ์ด ์ต์๊ฐ ๋๋ ๋ฐฉํฅ์ผ๋ก ๊ฐ์ค์น๋ฅผ ์ ๋ฐ์ดํธํ๋ ๋ฐฉ๋ฒ์ผ๋ก ๊ณ์ ๋ฐ๋ณตํด์ optimization์ ์งํํ๋ค.
ย
๋ฌธ์ ์
slow
๋นจ๊ฐ์ ์์ ์ต์ ์ ์ ์ฐพ์์ ์ด๋ํ๋ค๊ณ ์๊ฐํ๋ฉด, ์ํ ๋ฐฉํฅ์ผ๋ก๋ ๊ธฐ์ธ๊ธฐ ๋ณํ๊ฐ ์๊ธฐ ๋๋ฌธ์ ๋งค์ฐ ๋๋ฆฌ๊ฒ ์ด๋ํ๊ณ , ์์ง ๋ฐฉํฅ์ผ๋ก๋ ๊ธฐ์ธ๊ธฐ ๋ณํ๊ฐ ํฌ๊ธฐ ๋๋ฌธ์ ์๋๊ฐ ๋น ๋ฅด๋ค. ๊ทธ๋์ Loss๋ ์์ง ๋ฐฉํฅ์ ๊ฐ์ค์น ๋ณํ์ ํจ์ฌ ๋ ๋ฏผ๊ฐํ๊ฒ ๋ฐ์ํ๊ฒ ๋๋ค. loss๊ฐ ์์ง๋ฐฉํฅ์ ๋ฒกํฐ์ ์ํ ๋ฐฉํฅ ๋ฒกํฐ์ ํฉ์งํฉ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ๊ธฐ ๋๋ฌธ์ ์ง๊ทธ์ฌ๊ทธ๋ก ์ด๋ํ๋ค. ์ด๋ฌํ ๋ฌธ์ ๋ high demension์ผ์๋ก ๋์ฑ ๋ฌธ์ ๊ฐ ์ฌ๊ฐํด์ง๋ค.
ย
local minima & saddle point
- local minima
๊ทน๋๊ฐ๋ค ์ฌ์ด์ ๊ทน์๊ฐ์ ์์ฐฉํ๋ ๊ฒฝ์ฐ ๋ ์ด์ ๊ฐ์ค์น๊ฐ ์
๋ฐ์ดํธ ๋์ง ์๊ณ ๋ฉ์ถ๋ค. ๊ธฐ์ธ๊ธฐ๊ฐ 0์ธ ์ง์ ์ loss์ ์ต์๊ฐ์ผ๋ก ์ธ์ํด ํด๋น ์ง์ (local minima)์ ์ต์ ์ ์ผ๋ก ํ๋จํ์ฌ ๋ ์ด์ ์
๋ฐ์ดํธ๊ฐ ์ด๋ค์ง์ง ์๋ ๊ฒ์ด๋ค. ๋ณดํต 2์ฐจ์์์ ๋น๋ฒํ๊ฒ ๋ฐ์ํ๋ค.
- saddle point
๊ธฐ์ธ๊ธฐ๊ฐ ์๋ฒฝํ๊ฒ 0์ ์๋์ง๋ง ๊ทธ ์ฃผ๋ณ์ด ๊ต์ฅํ ์๋งํด์ ์
๋ฐ์ดํธ๊ฐ ๋๋ฆฌ๊ฒ ์งํ๋๋ฉด์ ๋ฐ์ํ๋ ๋ฌธ์ ์ด๋ค. ๋ณดํต ๊ณ ์ฐจ์ ๊ทธ๋ํ์์ ๋น๋ฒํ๊ฒ ๋ฐ์ํ๋ค.
ย
noisy
- Mini-Batch Gradient Descent์ ๊ฒฝ์ฐ ๋ฏธ๋๋ฐฐ์น๋ง๋ค loss๋ฅผ ๊ณ์ฐํ์ฌ ์ต์ ํ๋ฅผ ์งํํ๋๋ฐ ์ด๋ ๋งค์ฐ ๋นํจ์จ์ ์ด๋ค. ๋ฐ๋ผ์ ๋ง์ noise๊ฐ ๋ฐ์ํ๊ฒ ๋๋ค.
ย
Momentum
vx = 0 while True: dx = compute_gradient(x) vx = rho * vx + dx x -= learning_rate * vx
- SGD์ Momentum term ์ถ๊ฐํ ๊ฒ์ด๋ค. ์ฆ, ๊ฐ์ค์น x๋ฅผ ์ ๋ฐ์ดํธํ ๋ ์๋ vx์ ๊ฐ๋ ์ ์ถ๊ฐํ ๊ฒ์ด๋ค.
- v๋ ๊ฐ์๋๋ฅผ ์๋ฏธํ๋ฉฐ, rho๋ ๋ณดํต 0.9, 0.99๋ฅผ ์ด์ฉํ์ฌ ๊ฐ์๋์ ์ฝ๊ฐ์ ๋ง์ฐฐ๊ฐ์ ๋ฃ์ด์ฃผ๋ ํ๋ผ๋ฏธํฐ๋ค. v๋ ์ด์ gradients์ ๊ฐ์คํฉ์ด๋ผ๊ณ ๋ด๋ ๋ฌด๋ฐฉํ๋ค. gradient ๋ฅผ ๊ณ์ฐํ ๋ ๊ธฐ์ธ๊ธฐ๋ฐฉํฅ์ผ๋ก ์ด๋ํ๋ ๊ฒ์ด ์๋ ์๋ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ๋ค.
ย
์์
local minima & saddle point ํ๊ณ ๊ทน๋ณต
๊ณต์ด ์ธ๋์ ๋ด๋ ค์จ๋ค๊ณ ๊ฐ์ ์ ํด๋ณด์. ๊ทธ ๊ณต์ ๊ธฐ์ธ๊ธฐ๊ฐ 0์ธ ์ง์ ์์๋ ์ด๋๊น์ง ๋ด๋ ค์ค๋ ์๋์ ์ํด ๊ทธ ๊ณจ์ง๊ธฐ๋ฅผ ์ง๋ ๊ณ์ ๊ตด๋ฌ๊ฐ ๊ฒ์ด๋ค. ์ฆ, ๊ธฐ์ธ๊ธฐ๊ฐ 0์ธ ์ง์ ์์๋ ์
๋ฐ์ดํธ๊ฐ ๋๋ฉฐ ์ด ์ง์ ๊น์ง ๋ด๋ ค์ค๋ ์๋์ ๊ฐ๋
์ ์ถ๊ฐํ ๊ฒ์ด๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ local minima & saddle point์ ํ๊ณ๋ฅผ ๊ทน๋ณตํ ์ ์๋ค.
ย
noise ํ๊ท ํ
- Momentum์ ์ถ๊ฐํด์ velocity๊ฐ ์๊ธฐ๋ฉด ๊ฐ์๋๊ฐ ์๊ธฐ๋ฉฐ, momentum์ด ์ํ๋ฐฉํฅ์ผ๋ก๋ ๊ฐ์๋๋ฅผ ์ ์งํ๊ฒ ๋์ด SGD์์ ์ฒ๋ผ ์ง๊ทธ์ฌ๊ทธ๋ก ์์ง์ด์ง ์๋๋ก step์ ๊ฐ๋๋ค. step์ด ์ปค์ง์ ๋ฐ๋ผ noise๋ ํ๊ท ํ๋๋ค.
ย
Nestero Momentum
- ๋นจ๊ฐ์ ์์ velocity ๋ฐฉํฅ์ผ๋ก ์ถ๋ฐํ ๋ค ๊ฑฐ๊ธฐ์ gradient๋ฅผ ๊ณ์ฐํ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ค์ ์์ ์ผ๋ก๊ฐ์ actual step์ผ๋ก ์ต์ ํ๋ฅผ ์งํํ๋ค.
ย
- ์ด์ ์คํ ์ velocity ๋ฐฉํฅ์ ๋ฐ๋ผ ๋จผ์ ์ด๋ํ์ฌย ๊ทธ ์๋ฆฌ์์ gradient๋ฅผ ๊ณ์ฐํ๊ณ ย ๋ค์ ๋ณธ๋ ์๋ฆฌ๋ก ๋์์ actual step์ ์ด๋ํ๋ค. ์ฆ, gradient๋ฅผ ๊ณ์ฐํ๋ ์ง์ ๊ณผ ์ค์ ์ด๋ํ๋ ์ง์ ์ด ๋ค๋ฅด๋ค. ์ด๋ ๊ฒ ๋๋ฉด ์๋กญ๊ฒ ๋ณํ๋๋ ์์์ย error-correcting term์ด๋ผ๋ ๊ฒ์ด ์๊ธฐ๋๋ฐ ์ด๋ย ์ด์ velocity์ ํ์ฌ velocity์ ์ฐจ์ด๋ฅผ ๋ฐ์ํ์ฌย ๊ธ๊ฒฉํ ์ํ ์ ๋ฐฉ์งํ๋ค๋ ์ธก๋ฉด์์ ํจ๊ณผ๊ฐ ์๊ณ ๋ ๋น ๋ฅธ ํ์ต์ ๊ฐ๋ฅํ๊ฒ ํ๋ค๊ณ ํ๋ค. (https://velog.io/@yookyungkho/๋ฅ๋ฌ๋-์ตํฐ๋ง์ด์ -์ ๋ณต๊ธฐ๋ถ์ -CS231n-Lecture7-Review ์ฐธ๊ณ )
- Convex optimization์์๋ ์ ์๋ํ์ง๋ง, Neural Network์ ๊ฐ์ non-convex์์๋ ์ ์ฌ์ฉํ์ง ์๋๋ค.
ย
AdaGrad
grad_sqaured = 0 while True: dx = compute_gradient(x) grad_squared += dx * dx x -= learning_rate * dx/(np.sqart(grad_squared) + 1e-7)
- grad_squared๋ฅผ ์ด์ฉํ์ฌ dx์ ์ ๊ณฑ์ ๋ฃจํธ๋ฅผ ์์ด ๊ฐ์ x๊ฐ ์ ๋ฐ์ดํธํ ๋ ๋๋ ์ฃผ๋ ๋ฐฉ์์ด๋ค. ํ์ต ์ค์ ๊ธฐ์ธ๊ธฐ์ ์ ๊ณฑ๊ฐ์ grad_squred์ ๊ณ์ ๋ํด์ update step์์ ๋๋ ์ค๋ค. small gradient์ธ ๊ฒฝ์ฐ์๋ grad_squared๊ฐ ์์ ๊ฐ์ผ๋ก ๋๋ ์ฃผ๋ ์๋๊ฐ ๋ ์๋ถ๊ณ , large gradient์ธ ๊ฒฝ์ฐ์๋ ํฐ ์๋ก ๋๋์ด์ wiggling dimension์ slowdownํด์ ์ฒ์ฒํ ๋ด๋ ค์ค๊ฒ ๋๋ค. ์ฆ ํ๋ผ๋ฏธํฐ x๋ค ๋ง๋คย ๋ค๋ฅธ ํ์ต๋ฅ ์ ์ ๊ณตํ๋ค.
- ์์ง์ถ๊ณผ ์ํ์ถ์ ์ ๋ฐ์ดํธ ์๋๋ฅผ ์ ์ ํ ๋ง์ถ๋ค.
ย
๋ฌธ์ ์
- step size๊ฐ ์ค๋์๊ฐ ์ง์๋๋ ์ํฉ์์๋ grad๊ฐ ๋งค์ฐ ์์์ง๊ฒ ๋์ด ์ ์ฒด์ ์ธ ์๋๊ฐ ๋งค์ฐ ๋๋ ค์ง๊ฒ ๋๋ฉฐ ๊ฐ์ค์น๊ฐ 0์ด ๋์ด ํ์ต์ด ์ข ๋ฃ๋ ์ ์๋ค.
- non-convex์์๋ saddle point์ ๊ฑธ๋ฆฐ๋ค.
- ์ ์ฐ์ด์ง ์๋๋ค.
ย
ย
RMSProp update
grad_squared = 0 while True: dx = compute_Gradient(x) grad_sqaured = decay_rate * grad_sqaured + (1-decay_rate) * dx * dx x -= learning_rate * dx / (np.sqrt(grad_squared) + 1e-7)
- AdaGrad๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก grad_squared๋ฅผ ์ด์ฉํ์ง๋ง, RMSProp update์์๋ ํ๋ จํ๋ ๋์์ ๊ฐ์ ๊ณ์ํด์ ์ถ์ ์ํจ๋ค๋ ์ฐจ์ด๊ฐ ์๋ค. ๋์ ๋ grad_squaredํญ์ย decay_rate๋ฅผ ๊ณฑํ๊ณ , ํ์ฌ์ dxํญ์๋ (1-decay_rate)๋ฅผ ๊ณฑํด grad_squared๊ฐ ๋์ ๋๋ ์๋๋ฅผ ์ค์ฌ์ค๋ค. Momentum ๋ฐฉ์๊ณผ ์ ์ฌํ๋ค.
- ๋ณดํต decay rate์ผ๋ก 0.9๋ 0.99๋ฅผ ์ฌ์ฉํ๋ฉฐ ์ค๋ฒ์ํ ์ด ์ฌํ์ง ์์ ํธ์ด๋ค.
ย
Adam
# almost first_moment = 0 second_moment = 0 while True: dx = compute_gradient(x) first_moment = beta1 * first_moment + (1-beta1)*dx second_moment = beta2 * second_moment + (1-beta2) * dx * dx x -= learning_rate * first_moment / (np.sqrt(second_moment) + 1e-7))
- RMSProp + Momentum
- First moment์ second moment๋ฅผ ์ด์ฉํด ์ด์ ์ ๋ณด๋ฅผ ์ ์งํ๊ณ gradients์ ์ ๊ณฑ์ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ด๋ค. ์ด๋ First moment๋ velocity๋ฅผ ๋ด๋นํ๋ค. ๊ทธ๋ฆฌ๊ณ second moment๋ AdaGrad์ด๋ RMSProp์ฒ๋ผ gradient ์ ๊ณฑ ํ์ฉํ๋ค. ์ด๊ธฐ์ second moment๋ฅผ 0์ผ๋ก ์ด๊ธฐํํ ํ 1ํ ์ ๋ฐ์ดํธํ๊ณ ๋์๋ beta2 = decay_rate๋ก 0.9๋๋ 0.99๋ก 1์ ๊ฐ๊น์ด ๊ฐ์ด๊ธฐ ๋๋ฌธ์ ์ฌ์ ํ 0์ ๊ฐ๊น๋ค. update step์์ second moment๋ก ๋๋๊ธฐ ๋๋ฌธ์ ์ด๊ธฐ step์ด ์์ฒญ๋๊ฒ ์ปค์ ธ๋ฒ๋ฆด ์ ์๊ธฐ ๋๋ฌธ์ Adam์ ์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ํ์ฌ ์คํ ์ ๋ง๋ bias correction term ์ถ๊ฐํ๋ค. first/second moments๋ฅผ Updateํ๊ณ ๋ ํ ํ์ฌ Step์ ๋ง๋ ์ ์ ํ unbiased term ์ ๊ณ์ฐํ๋ ๋ฐฉ์์ด๋ผ๊ณ ํ ์ ์๋ค.
- ํ์ ๋ ํ์(poor conditioning) ๋ฌธ์ ๋ ์ฌ์ ํ ํด๊ฒฐํ ์ ์๋ค๋ ํ๊ณ๊ฐ ์๋ค.
ย
Ensemble
- ์ฌ๋ฌ๊ฐ์ ๋ชจ๋ธ์ ๊ฐ๊ฐ ๋ฐ๋ก ํ์ต์์ผ ๊ทธ ํ๊ท ๊ฐ์ ์ด์ฉํ๋ ๋ฐฉ์์ด๋ค. train/test error์ ๊ฒฉ์ฐจ๋ฅผ ์ค์ด๋ ๊ฐ์ฅ ์ฌ์ด ๋ฐฉ๋ฒ์ด๋ค.
- ๋ชจ๋ธ์ ๋ ๋ฆฝ์ ์ผ๋ก ํ์ต์ํค๋ ๊ฒ์ด ์๋๋ผ ํ์ต ๋์ค ์ค๊ฐ ๋ชจ๋ธ๋ค์ ์ ์ฅ(sanpshots)ํ๊ณ ์์๋ธ๋ก ์ฌ์ฉํ ์ ์๋ค. ๊ทธ๋ฆฌ๊ณ Test time์๋ ์ฌ๋ฌ snapshots์์ ๋์จ ์์ธก๊ฐ๋ค์ ํ๊ท ์ ๋ด์ ์ฌ์ฉํ๋๋ฐ ์ด๋ฐ snapshots์ Training ๊ณผ์ ์ค๊ฐ์ ์ ์ฅํ๋ค.
ย
ย
ย