๐ ๋ชฉ์ฐจ
1์ฅ: Practical aspects of Deep Learning
2์ฅ: Optimization algorithms
3์ฅ: Hyperparameter tuning, Batch Normalization and Programming Frameworks
1st course์์๋ neural network, ์ธ๊ณต์ ๊ฒฝ๋ง์ ๊ตฌํํ๋ ๋ฒ์ ๋ํด์ ๋ฐฐ์ ๋ค๋ฉด 2nd course์ธ Improvng Deep Neural Networks์์๋ ์ ๊ฒฝ๋ง์ด ๋ณด๋ค ์ข์ ์ฑ๋ฅ์ ๋ผ ์ ์๋ ๋ฌธ์ ์ ๋ํด ๋ค๋ค๋ณด๊ณ ์ ํ๋ค. ์ธ๊ณต์ ๊ฒฝ๋ง์ ์ฑ๋ฅ ์ต์ ํ ๋ฐ ํฅ์์ ์ํ ๋ฐ์ดํฐ ์
์ค๋น๋ถํฐ regularization, hyperparameter ํ๋๊น์ง ๋ค์ํ ์ ๊ทผ๋ฒ์ ๋ํด์ ์๊ฐํ๊ณ ์๋ค.
๊ฐ ์ ๊ทผ๋ฒ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ํด์ ์ด๋์ ๋ ์ดํดํ๊ณ ์๋ค๋ฉด ๊ณผ์ ์ ๋ชฉ์ ํน์ ๋ชฉํ, ๋ฐ์ดํฐ์ ํน์ง์ ๋ฐ๋ผ ์ต์ ์ ๊ฒฐ๊ณผ๋ฅผ ์ด๋์ด๋ด๊ธฐ ๋ณด๋ค ์์ํ ๊ฒ์ผ๋ก ์๊ฐํ๋ค.
๋จผ์ train / dev / test์ ๊ฐ์ ๋ฐ์ดํฐ ์ ์ ์ ๊ตฌ์ถํ๋ฉด ์ข์ ์ฑ๋ฅ์ ๊ฐ๋ neural network๋ฅผ ์ฐพ๋ ๊ฒ์ ๋์์ด ๋จ
neural network์ ๊ตฌํํ ๋์๋, layer์ ์, hidden unit์ ์, learning rate, activation function ๋ฑ๊ณผ ๊ฐ์ ๊ฒฐ์ ํด์ผํ hyperparameter๊ฐ ๋ง๊ธฐ ๋๋ฌธ์ ๋ฐ๋ณต์ ์ธ ๊ณผ์ ์ ๊ฑฐ์น ์ ๋ฐ์ ์์
์ด๋ฌํ ๋ฐ๋ณต์ ์ธ ๊ณผ์ ์ ๊ฑฐ์น๋ ๊ฒ์ด ํ์๋ถ๊ฐ๊ฒฐํ ๋, ๋ฐ์ดํฐ๋ฅผ ์ ์ ํ๊ฒ train / dev / test ๋ก ๋๋์ผ๋ก์จ ๋ณด๋ค ํจ์จ์ ์ผ๋ก ์ํํ ์ ์์
์ผ๋ฐ์ ์ผ๋ก ๊ธฐ๊ณํ์ต์์๋ train / test ์ 70:30, train / dev / test ์ 60:20:20 ์ผ๋ก ๋๋๊ฒ ๋จ
ํ์ง๋ง ๋น ๋ฐ์ดํฐ ์๋์ ๋์ ํ๊ฒ ๋๋ฉด์, ๋ค๋ฃจ๊ณ ์ํ๋ ๋ฐ์ดํฐ๋ ์๋ฐฑ๋ง๊ฐ๋ฅผ ๋์ด์๊ธฐ ๋๋ฌธ์ dev์ test ๋ฐ์ดํฐ๊ฐ 20%, 30%์ ๋น์จ์ด๋ผ๋ฉด ๋งค์ฐ ํฐ ๋ถ๋ถ์ ์ฐจ์งํ๊ฒ ๋จ
๊ฐ๋จํ๊ฒ logistic regression์ ํ์ต ๊ฒฐ๊ณผ๋ก ์์ ๊ฐ์ 3๊ฐ์ง ๊ฒฐ๋ก ์ด ๋์ถ๋ ์ ์์
๋จผ์ , ์ข์ธก ๊ฒฐ๊ณผ๋ ํ์ต์ด ์ ๋๋ก ๋์ง ์์ underfitting๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ฉฐ, ์ด๋ฅผ high bias(๋์ ํธํฅ)์ด๋ผ๊ณ ํจ
๋ฐ๋๋ก, ์ฐ์ธก ๊ฒฐ๊ณผ๋ ๋ฐ์ดํฐ๋ฅผ ์๋ฒฝํ๊ฒ fittingํจ์ผ๋ก์จ ์ ํํ๊ฒ ๋ถ๋ฅํ ์ ์์ง๋ง overfitting ๋ฌธ์ ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ๋์ผ๋ฉฐ, ์ด๋ฅผ high variance๋ผ๊ณ ํจ
deep neural network์์๋ train / dev / test ๋ฐ์ดํฐ์ error ๋น์จ์ ํตํด bias์ variance ๋ฌธ์ ๋ฅผ ํ์ธํด๋ณผ ์ ์์
์ฃผ์ด์ง ์ด๋ฏธ์ง์์ ๊ณ ์์ด๋ฅผ classificationํ๋ ๋ฌธ์ ๋ก ๊ฐ์ ํ์ ๋, ์ฌ๋์ด ์ง์ ํ๋จํ๋ ๊ฒฝ์ฐ๋ ๋๋ถ๋ถ ์ ํํ๊ธฐ ๋๋ฌธ์ human error๋ 0%์ ๊ฐ๊น์
train / dev ์ error๊ฐ 1% / 11% ๋ผ๊ณ ํ๋ค๋ฉด train ๋ฐ์ดํฐ์๋ง overfitting๋ high variance ๋ฌธ์ ๋ฅผ ํ์ธํ ์ ์์
train / dev์ error๊ฐ 15% / 16% ๋ผ๋ฉด, train๊ณผ dev์ ๋ชจ๋ ๋ง์ง ์๊ฒ ํ์ต๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ underfitting๋ high bias ๋ฌธ์ ๋ฅผ ํ์ธํ ์ ์์
train / dev์ error๊ฐ 15% / 30% ๋ผ๋ฉด, ๋๋ฒ์งธ ๊ฒฝ์ฐ์ฒ๋ผ high bias ๋ฌธ์ ๋ฟ๋ง ์๋๋ผ train์ overfitting๋ ๋ฌธ์ ๋ ํฌํจ๋๋ high variance๊น์ง ๋ํ๋๋ ๊ฐ์ฅ ์์ข์ ๊ฒฐ๊ณผ๋ฅผ ๋งํจ
train / dev์ error๊ฐ 0.5% / 1% ๋ผ๋ฉด human error์ ๋น๊ตํ์ ๋์๋ ๊ต์ฅํ ์ ํํ๊ฒ ๋ถ๋ฅํ model์ด๋ผ๊ณ ๋ณผ ์ ์์
ํ์ง๋ง train / dev์ error ๋น์จ์ ํตํ bias์ variance ๋ฌธ์ ๋ ๋ฐ์ดํฐ์ ๋ชจ๋ธ์ ํน์ง, Human error, Optimal Error์ ๋ฐ๋ผ ์๋์ ์ผ๋ก ๋ฌ๋ผ์ง๊ธฐ ๋๋ฌธ์ ์ ์คํ ๋ถ์์ด ํ์ํจ
train / dev์ error๋ฅผ ํตํด์ bias์ variance ๋ฌธ์ ๋ฅผ ํ์ธํ ์ ์๋ ๋ฐฉ๋ฒ์ ๊ธฐ๊ณํ์ต์ baic recipe(๊ธฐ๋ณธ์ ์ธ ๋ฐฉ๋ฒ?)์ด๋ฉฐ ์ด ๊ณผ์ ์ ํตํด ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ์ ํฅ์ ์ํฌ ์ ์์
์ข์ธก ๊ฒฐ๊ณผ์๋, high bias์ ๊ฒฝ์ฐ์๋
์ฐ์ธก ๊ฒฐ๊ณผ์๋, high variance์ ๊ฒฝ์ฐ์๋
๋ฅ๋ฌ๋ ์ด๊ธฐ์๋ bias์ variance๋ ์ฝ๊ฐ์ trade-off ๊ด๊ณ๋ผ๊ณ ์๊ฐ๋์์ง๋ง ์ต๊ทผ์๋ ๋ณด๋ค deepํ neural network๋ฅผ ํ์ตํ ์ ์๋ ํ๊ฒฝ์ด ๊ฐ๋ฅํด์ง๋ฉด์ bias์ variance๋ฅผ ๋ชจ๋ ์ค์ผ ์ ์์
์์์ overfitting๋ high variance ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ๋ฐฉ๋ฒ์ผ๋ก Regularization์ด ์ ์๋์์
logistic regression์ Regularization์ ์ ์ฉํ๊ธฐ ์ํด์๋ cost function ์ข์ธก์ Regularization ํญ์ ์ถ๊ฐํ๊ฒ ๋จ
Regularization์ ๋ชฉ์ ์ ๋ฐ๋ณต์ ์ผ๋ก ๋ฐ์ํ๋ cost์ ์ํฅ์ ๋ฏธ์น๋ w(weight)๊ฐ ๋ณด๋ค ์ ์ ์ํฅ์ ๋ฏธ์น๋๋ก ์กฐ์ ํด์ฃผ๋ ์ญํ ์ ํจ
Neural Network์ ์ ์ฉ๋๋ Regularization์ ๊ฐ layer์ ์์นํ๊ฒ ๋๋ฉด์ backpropagation ๊ณผ์ ์์ ์ ๋ฐ์ดํธ๋๋ parameter์ ์ํฅ์ ๋ฏธ์น๊ฒ ๋จ
์์์ L2 Regularization์ 'weight decay'๋ผ๊ณ ๋ถ๋ฆฌ๋ ์ด์ ๋ก ์ํฅ์ ํ์ธํ ์ ์์
์ ์์์ ๋ฅผ ์ค์ ํด์ค์ผ๋ก์จ ์ ๋ํ ์ํฅ๋ ฅ์ ์กฐ์ ํด์ค ์ ์์
๋ฅผ ํฌ๊ฒ ์ค์ ํ๊ฒ ๋๋ฉด, ์ 0์ ๊ฐ๊น๊ฒ ์๋ ตํ๊ฒ ๋จ
์๋ ์ฐ์ธก ๊ฒฐ๊ณผ, high variance ์ํ์์ L2 Regularization์ ์ ์ฉํ๊ฒ ํด์ฃผ๋ฉด ์ข์ธก ์๋จ์ ๊ทธ๋ฆผ์ฒ๋ผ ๊ฐ hidden unit์ ์ ์ํฅ๋ ฅ์ด ์ค์ด๋ค๊ณ variance๊ฐ ์ค์ด๋๋ ํ์์ ๋ณผ ์ ์๊ฒ ๋จ(์ฝ๊ฐ ๊ทธ๋ฆผ์ dropout๊ณผ ๋น์ทํ๋ค๋ ๋๋์ด ๋ฆ)
L1, L2 Regularization์๋ ์ด์ธ๋ก dropout์ด๋ผ ๋ถ๋ฆฌ๋ Regularization๋ ์กด์ฌํจ
dropout์ ์ ์ํฅ๋ ฅ์ ์ค์ด๋ L1, L2์๋ ๋ฌ๋ฆฌ, ํน์ node๋ฅผ ์๋ตํจ์ผ๋ก์จ ์์ ๋ก ๋ฐ์ํ๋ ๊ณ์ฐ์ ๊ณผ์ ์ ์ค์ด๋ ๊ฒ์
node๋ฅผ ์๋ตํ๋ ๊ณผ์ ์์๋ ์ค์ ๋ก ๋ฌด์์๋ก node๋ฅผ ์๋ตํ๊ธฐ ์ํด์ keep-prob์ด๋ผ๋ ๊ฐ๋ ์ด ๋ฑ์ฅํจ
keep-prob์ ๋ฌด์์๋ก node๋ฅผ ์๋ตํ๊ณ ๋จ์ node์ ๋น์จ์ ์๋ฏธํจ
๋ง์ฝ keep-prob์ด 1์ด๋ผ๋ฉด, dropout, ์๋ตํ node๊ฐ ์๋ค๋ ๊ฒ์ ์๋ฏธํจ
dropout ์ค ๊ฐ์ฅ ํํ๊ฒ ์ฌ์ฉ๋๋ Inverted dropout๊ฐ ๊ตฌํ๋๋ ๊ณผ์ ์ ๋ค์๊ณผ ๊ฐ์
ํน์ layer์ ์ฐจ์๋งํผ random initialize๋ฅผ ์์ฑํด์ค
keep-prob(0.8)๋ฅผ ์ค์ ํ๊ณ ํด๋น keep-prob๋ณด๋ค ์์ ๊ฒฝ์ฐ๋ ์ค์ ๋ 0.8์ keep-prob๋งํผ์ ๋ ธ๋๊ฐ True๋ฅผ ๊ฐ์ง๊ฒ ๋๊ณ 0.2๋งํผ์ ๋ ธ๋๊ฐ False๋ฅผ ๊ฐ์ง๊ฒ ๋จ
layer์ ๋ ธ๋์ keep-prob๋ก ์ค์ ๋ True/False๋ฅผ ๊ณฑํด์ค์ผ๋ก์จ ๋จ์์๊ฑฐ๋ ์๋ต๋๋ ๋ ธ๋๋ค์ ํ์ธํ ์ ์์
๋ง์ง๋ง์ผ๋ก๋ ์ด์๋จ์ ๋ ธ๋๋ค์ ๋ํด์ keep-prob๋ฅผ ๋๋ ์ค์ผ๋ก์จ ํด๋น layer์ expected value๋ฅผ ๋์ผํ๊ฒ ์ ์งํด์ค
assignment์์ ๋์จ ์ฝ๋๋ฅผ ๊ฐ๋จํ ์ดํด๋ณด์๋ฉด ๋ค์๊ณผ ๊ฐ์
D1 = np.random.rand(A1.shape[0], A1.shape[1]) # Step 1: initialize matrix D1 = np.random.rand(..., ...)
D1 = (D1 < keep_prob).astype(int) # Step 2: convert entries of D1 to 0 or 1 (using keep_prob as the threshold)
A1 = np.multiply(A1, D1) # Step 3: shut down some neurons of A1
A1 = np.divide(A1, keep_prob) # Step 4: scale the value of neurons that haven't been shut down
dropout์ด Regularization ํจ๊ณผ๊ฐ ๋ํ๋๋ ์ด์ ๋ ๋ฌด์์๋ก node๋ฅผ ์ ๊ฑฐํจ์ผ๋ก์จ neural network์ ํฌ๊ธฐ๋ฅผ ์ค์ด๋ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์๊ธฐ ๋๋ฌธ์
dropout์ ๊ตฌํํ๊ธฐ ์ํด keep-prob๋ฅผ ์ค์ ํ๋ ๊ฒ์ ๊ฐ layer๋ง๋ค ๋ค๋ฅด๊ฒ ์ค์ ๊ฐ๋ฅํ๋ฉฐ, keep-prob๋ฅผ ๋๊ฒ ์ค์ ํ๋ ๊ฒ์ L2 regularization์์ ๋ฅผ ๋๊ฒ ์ค์ ํ๋ ๊ฒ๊ณผ ๋์ผํจ
๋ฐ๋ฉด์ dropout์ ๋จ์ ์ผ๋ก๋ cost function์ด ์ ํํ๊ฒ ์ ์๋์ง ์๋๋ค๋ ์ ๊ณผ ๋ฌด์์๋ผ๋ ์ ์์ ์ฑ๋ฅ ์ฒดํฌ ๋ฐ ๋๋ฒ๊น ์ด ํ๋ค๊ธฐ๋ ํจ
Regularization์ ํ ์ ์๋ ์ถ๊ฐ์ ์ธ ๋ฐฉ๋ฒ์ผ๋ก Data Augmentation๊ณผ Early Stopping๊ณผ ๊ฐ์ ๊ธฐ๋ฒ๋ค์ด ์์
Data Augmentation์ image classification์์ ์ฃผ๋ก ์ฌ์ฉ๋๋ ๊ธฐ๋ฒ์
๊ฐ์ง๊ณ ์๋ ๋ฐ์ดํฐ์์ ์ข์ฐ๋ฐ์ , ํ๋, ์ถ์, ํ์ , ๋๋ฆผ ๋ฑ์ ๋ฐฉ๋ฒ์ ํตํด ๋ค๋ฅธ ํํ์ ๋ฐ์ดํฐ๋ก ์ธ์ํ๋๋ก ๋ณํ๋ฅผ ์ฃผ๋ ๋ฐฉ๋ฒ์
ํ์ง๋ง ์ด๋ฌํ ๋ฐฉ๋ฒ์ผ๋ก ์์ฑ๋ ์๋ก์ด(๊ฐ์ง) ์ด๋ฏธ์ง๋ ์ค์ ์๋ก์ด ๋ฐ์ดํฐ๋ฅผ ๊ตฌํ๋ ๊ฒ๋ณด๋ค๋ ์ข์ ํจ๊ณผ๋ฅผ ๋ณผ ์ ์๊ฒ ์ง๋ง cost๊ฐ ์๋ ๋ฐฉ๋ฒ์
Early Stopping์ ํ์ต์ด ์งํ๋๋ ๊ณผ์ ์ ๋ชจ๋ํฐํ๋ฉด์ ์๋ ์ค์ ํ ์ข ๋ฃ ์์ ๋ณด๋ค ์ผ์ฐ ์ข ๋ฃํจ์ผ๋ก์จ overfitting์ ๋ฐฉ์งํ๋ ๊ธฐ๋ฒ์
Neural Network์ ํ์ต์ ๋ณด๋ค ์ต์ ํํ ์ ์๋ ๋ฐฉ๋ฒ์ผ๋ก input ๋ฐ์ดํฐ๋ฅผ normalize ํ ์ ์์
๋ฐ์ดํฐ๋ฅผ normalize ํ ์ ์๋ ๋ฐฉ๋ฒ์ ๊ธฐ์กด ๋จธ์ ๋ฌ๋ ๋ฐ์ดํฐ๋ฅผ normalize ํ๋ ๊ฒ์ฒ๋ผ, ํ๊ท ์ ๋นผ์ฃผ๊ฑฐ๋, ํ๊ท ์ 0์ผ๋ก ๋ง๋ค์ด์ฃผ๊ฑฐ๋, ๋ถ์ฐ์ ์ฌ์ฉํ์ฌ normalize ํ ์ ์์
์ด๋ ๊ฒ normalize๋ฅผ ํด์ฃผ๋ ์ด์ ๋, input ๋ฐ์ดํฐ์ scale์ด ๋ค๋ฅผ ๋, ํ์ตํ๊ณ parameter๋ฅผ ์ ๋ฐ์ดํธ๋ฅผ ํด์ฃผ๋ ๊ณผ์ ์์ ์๋ก ๋ค๋ฅธ scale์ ๋ํ parameter๊ฐ ์ ์ฉ๋์ด gradient๊ฐ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ๋งค์ฐ ๋๋ฆฌ๊ฒ ๋ฐ๋ณต ๊ณผ์ ์ ๊ฑฐ์น๊ธฐ ๋๋ฌธ์
normalize๋ฅผ ํ๊ฒ ๋๋ฉด ๋ชจ๋ input ๋ฐ์ดํฐ์ scale์ด ๊ฐ๊ณ , ๊ทธ์ ๋ฐ๋ฅธ parameter๊ฐ ๋ฏธ์น๋ ์ํฅ์ ๋ฒ์๊ฐ ๋์ผํ๊ธฐ ๋๋ฌธ์ gradient descent ๊ณผ์ ์ด ๋ณด๋ค ํจ์จ์ ์ผ๋ก ์งํ๋จ
deep neural network์์๋ ํ์ตํ๋ ๊ณผ์ ์์ ๊ธฐ์ธ๊ธฐ๊ฐ, ์ฆ ๋ณํ๋์ด ๋งค์ฐ ํฌ๊ฑฐ๋ ์๊ฒ ์๋ ดํ๋ ๋ฌธ์ ๋ฅผ Exploding / Vanishing gradients problem์ด ๋ฐ์ํจ
layer์ ์๋งํผ ๊ณฑํด์ง๋ ๊ฐ ๊ธฐํ๊ธ์์ ์ผ๋ก ์ฆ๊ฐํ๊ฑฐ๋ 0์ ์๋ ดํ ์ ๋๋ก ๊ณ์ํด์ ์์์ง ์ ์๊ธฐ ๋๋ฌธ์ ๋ฐ์ํจ
ํนํ ๊ธฐ์ธ๊ธฐ๊ฐ ๊ณ์ํด์ ์์์ง ๊ฒฝ์ฐ์๋, gradient ๋ณํ๋์ด ๋งค์ฐ ์๊ธฐ ๋๋ฌธ์ ์ ๋ฐ์ดํธ๋ฅผ ์ํ ํ์ต ๊ณผ์ ์ด ๋งค์ฐ ๋๋ฆฌ๊ฒ ์๋๋จ
์ด๋ ๊ฒ gradient๊ฐ ์์ค๋๊ฑฐ๋ ์ฆํญ๋๋ ๋ฌธ์ ๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํด์ Weight Initialization์ ์ค์ ํด ์ค ์ ์์
ํ๋์ ๊ณ์ฐ์ ์ฌ๋ฌ ๊ฐ์ ๊ฐ ๋ค์ด์ค๊ฒ ๋๋ฉด ๋ ์์ฐ์ค๋ฝ๊ฒ ์ฆ๊ฐํ ์ ๋ฐ์ ์๊ธฐ ๋๋ฌธ์ ๊ฐ ๋ฅผ normalizeํ๋ ๊ฒ์ฒ๋ผ ์กฐ์ ํด์ค ์ ์์
activation function์ ๋ฐ๋ผ์ Weight Initialization๋ฅผ ์กฐ๊ธ์ฉ ๋ค๋ฅด๊ฒ ์ค์ ํ๋ ๊ฒ์ด ๋ณด๋ค ํจ๊ณผ์ ์
Relu ์ผ ๋๋,
tanh ์ผ ๋๋, ํน์
backpropagation์ ํ ๊ฒฝ์ฐ์๋, ํด๋น ๊ณผ์ ์ด ์ ํํ๊ฒ ์ด๋ค์ก๋์ง ํ์ธํ๊ธฐ ์ํด gradient checking ์์ ์ ์ค์ํ ์ ์์
gradient checking์ ๋ง๊ทธ๋๋ก ๋ฏธ๋ถ๊ฐ, ๋ณํ๋์ ๋น๊ตํ๋ ๊ฒ์ธ๋ฐ ์ฐ์ ์ ์ผ๋ก ๊ธฐ์ธ๊ธฐ๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ผ๋ก๋ ์ฌ๊ธฐ์ 'one-sided difference' ์ 'two-sided difference'๊ฐ ์๊ฐ๋จ
one-sided difference:
two-sided difference:
two-sided difference ๋ฐฉ๋ฒ์ด ๋ณํ๋ ๊ฐ์ ๋ํ ์ค์ฐจ๊ฐ ๋ณด๋ค ์๊ธฐ ๋๋ฌธ์ gradient checking์ ํ ๋์๋ ํด๋น ๋ฐฉ๋ฒ์ ์ ํธํจ
gradient checking์ ํตํ ๋๋ฒ๊น ์ ๋ฒ๊ทธ๋ฅผ ์ฐพ์์ค์ผ๋ก์จ ์ ์ฒด ๊ฐ๋ฐ ์๊ฐ์ ํจ์จ์ ์ผ๋ก ์ค์ฌ์ค ์ ์๋ ๋ฐฉ๋ฒ์
gradient checking ๊ณผ์ ์ backpropagation์์ ๋ฐ์ํ๋ ๋ณํ๋๊ณผ ํด๋น ์ง์ ์์ ๊ณ์ฐ๋๋ ๊ธฐ์ธ๊ธฐ๊ฐ์ ๋น๊ตํจ์ผ๋ก์จ ์ค์ฐจ๋ฅผ ํ์ธํ์ฌ ๋ฒ๊ทธ๋ฅผ ๋ฐ๊ฒฌํ๋ ๊ณผ์ ์
backpropagation์์ ๊ตฌํ ์ two-sided difference๋ฅผ ํตํด ๊ตฌํ ๋ฅผ ๋น๊ตํ๊ฒ๋จ
์ค์ฐจ๋ฅผ ํตํด ๋ฒ๊ทธ๋ฅผ ํ์ธํ๋ ๋ฐฉ๋ฒ์ผ๋ก๋, ์ค์ฐจ๊ฐ ๋ณด๋ค ์๊ฒ ๋๋ฉด ๋ง์กฑํ ๋งํ ๊ฒฐ๊ณผ์ด๋ฉฐ, ์ด๋ฉด ๋ค๋ฅธ ์์์ ๋ฐ๋ผ ๋ค์ ํ์ธํด ๋ณผ ํ์๊ฐ ์์ผ๋ฉฐ, ๋ณด๋ค ํฌ๊ฒ ๋๋ฉด ๋ฒ๊ทธ๊ฐ ์์ ๊ฐ๋ฅ์ฑ์ด ๋์
gradient checking์ ์ ์ฉํ๊ธฐ ํ ๋, ๋ช ๊ฐ์ง ์ฃผ์ ์ฌํญ์ด ์์
Donโt use in training โ only to debug: ๋ฏธ๋ถ ๊ทผ์ฌ๋ฅผ ๊ตฌํ๋ ์ผ์ ์๋นํ ๋๋ฆฐ ์์ ์ด๊ธฐ์ ํ์ต(training)์์๋ ์ฌ์ฉํ์ง ์์
If algorithm fails grad check, look at components to try to identify bug: ์ค์ฐจ๊ฐ ํฌ๊ฒ ๋ฐ์ํ๋ค๋ฉด, ๊ฐ๊ฐ์ component๋ฅผ ๋น๊ตํด์, ๋ฌธ์ ๋๋ component๋ฅผ ์ฐพ์ ์ ์์ผ๋ฉฐ ์ค๋ฅ๋ฅผ ๋ฐ๊ฒฌํ ์ ์์
Remember regularization : regularization์ ์ฌ์ฉํ๋ค๋ฉด, cost function(J)์ lambda ์์ด ๋ํด์ง๋ฏ๋ก, ๋ฏธ๋ถ ๊ทผ์ฌ์น์ ๋น๊ตํ ๋ ์ฒ๋ฆฌํด ์ฃผ์ด์ผ ํจ
Doesnโt work with dropout: dropout์ ํ๊ฒ ๋๋ฉด, Jํจ์๊ฐ ์ฐ๊ธฐ๊ฐ ๋ฌด์ฒ ๊น๋ค๋ก์์ง. keep-prob๋ฅผ 1๋ก ์ค์ ํ์ฌ dropout์ ๋๊ณ grad checking์ ์งํํจ
Run at random initialization; perhaps again after some training: random ์ด๊ธฐํ๋ฅผ ํ๋ ๊ฒฝ์ฐ์๋, ํ์ต์ ํตํด W,b๋ฅผ ์ ๋ฐ์ดํธํ ์ดํ์ grad checking์ ์งํํจ