ํด๋น ๊ธ์ FastCampus - '[skill-up] ์ฒ์๋ถํฐ ์์ํ๋ ๋ฅ๋ฌ๋ ์ ์น์ ๊ฐ์๋ฅผ ๋ฃ๊ณ ,
์ถ๊ฐ ํ์ตํ ๋ด์ฉ์ ๋ง๋ถ์ฌ ์์ฑํ์์ต๋๋ค.
1. ๋ฏธ๋ถ (Derivative)
1.1 ๊ธฐ์ธ๊ธฐ
- ํจ์ ์
๋ ฅ๊ฐ(x) ๋ณํ์ ๋ฐ๋ฅธ ์ถ๋ ฅ๊ฐ(y) ๋ณํ ๋น์จ

1.2 ๊ทนํ๊ณผ ์ ์
- ๋ ์ ์ด ๋ฌดํํ ๊ฐ๊น์์ง ๋ ์ ์ ์ ๊ธฐ์ธ๊ธฐ ๊ฐ๋
์ผ๋ก ๋์
- ๋ฏธ๋ถ์ ์ด ์ ์ ์ ๊ธฐ์ธ๊ธฐ๋ฅผ ๊ตฌํ๋ ๊ณผ์

1.3 ๋ํจ์
- ํน์ ์ง์ ์ด ์๋ ์ ๋ฒ์์ ๋ํด ๊ธฐ์ธ๊ธฐ๋ฅผ ์ผ๋ฐํํ ํจ์

1.4 ๋ดํด ๋ฏธ๋ถ๋ฒ vs ๋ผ์ดํ๋์ธ ๋ฏธ๋ถ๋ฒ
๋ดํด ๋ฏธ๋ถ๋ฒ: ๋ณ์๊ฐ ํ๋์ผ ๋ ํธ๋ฆฌ

๋ผ์ดํ๋์ธ ๋ฏธ๋ถ๋ฒ: ๋ณ์๊ฐ ๋ ๊ฐ ์ด์์ผ ๋ ํธ๋ฆฌ

1.5 ํฉ์ฑํจ์ ๋ฏธ๋ถ

2. ํธ๋ฏธ๋ถ (Partial Derivative)
2.1 ๋ค๋ณ์ ํจ์(Multivariable function)
- ๋ณ์๊ฐ ๋ ๊ฐ ์ด์์ธ ํจ์

2.2 ํธ๋ฏธ๋ถ์ด๋?
- ๋ค๋ณ์ ํจ์์์ ํ๋์ ๋ณ์๋ง ๋จ๊ธฐ๊ณ ๋๋จธ์ง๋ฅผ ์์๋ก ๊ฐ์ฃผํ๊ณ ๋ฏธ๋ถํ๋ ๊ฒ
- ๊ธฐํธ: โ(Round, Partial)

2.3 Gradient ๋ฒกํฐ: ๊ณ ์ฐจ์ ํจ์์ ๋ฏธ๋ถ
- ์
๋ ฅ/์ถ๋ ฅ์ด ๋ฒกํฐ ๋๋ ํ๋ ฌ์ผ ๋๋ ๊ฐ๊ฐ ํธ๋ฏธ๋ถ ๊ฐ๋ฅ
- ๊ธฐํธ: โฝ(nabla, del)
- ๊ฒฐ๊ณผ๋ gradient ๋ฒกํฐ๋ก ํํ๋๋ฉฐ ๋ฐฉํฅ๊ณผ ํฌ๊ธฐ ๋ชจ๋ ํฌํจ
- ์ฆ, gradient ๋ฒกํฐ๋ ๊ฐ ๋ณ์์ ๋ํ ํธ๋ฏธ๋ถ์ ๋ชจ์๋์ ๋ฒกํฐ


2.4 ์ Gradient ๋ฒกํฐ๊ฐ ํ์ํ ๊น?
- Loss๋ผ๋ ์ค์นผ๋ผ ๊ฐ์ ํ๋ผ๋ฏธํฐ ํ๋ ฌ๋ก ๋ฏธ๋ถํ๊ณ ์ถ๋ค!

- DNN์ ์ค๊ฐ ๊ฒฐ๊ณผ๋ฌผ ๋ฒกํฐ๋ฅผ ํ๋ผ๋ฏธํฐ(๊ฐ์ค์น) ํ๋ ฌ๋ก ๋ฏธ๋ถํด์ผ ํ๋ค๋ฉด?

2.5 Pytorch์ Autograd ๊ธฐ๋ฅ
x = torch.FloatTensor([[1, 2],
[3, 4]])
x.requires_grad = True
x1 = x + 2
x2 = x - 2
x3 = x1 * x2
y = x3.sum()
y.backward()
print(x.grad)
3. Gradient Descent ์๊ณ ๋ฆฌ์ฆ
3.1 Gradient Descent ์๊ณ ๋ฆฌ์ฆ์ด๋?
- Loss ๊ฐ์ด ์ต์ํ๋๋ ํ๋ผ๋ฏธํฐ ฮธ๋ฅผ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ
- ์ฆ, ์ฃผ์ด์ง ๋ฐ์ดํฐ์ ๋ํด ์ถ๋ ฅ๊ฐ์ด ์ ๋ง๋ ํจ์๋ฅผ ์ฐพ๊ธฐ ์ํ ์๊ณ ๋ฆฌ์ฆ
3.2 1D ์์
- x์ ๋ํด ๋ฏธ๋ถํ ๊ธฐ์ธ๊ธฐ๋ฅผ ์ด์ฉํด ๋ฎ์ ๋ฐฉํฅ์ผ๋ก ์ด๋

- ๊ฐ์ฅ loss๊ฐ ๋ฎ์ ๊ณณ(Globla minima)์ด ์๋ ๊ณจ์ง๊ธฐ(Local minima)์ ๋น ์ง ๊ฐ๋ฅ์ฑ์ด ์์
- ์ฌ์ค ์ง๊ธ ์ฐพ์ minima๊ฐ global minima์ผ ๊ฒ์ด๋ผ๊ณ ๋ณด์ฅํ ์ ์๋ค
- Gradient Descent Equation

- L: Loss function (scalar)
- ฮธ: Parameters (vector)
- ฮท: Learning Rate (๊ฒฝํ์ ์ผ๋ก ์ง์ ํด์ฃผ๋ Hyper parameter 0 ~ 1)
- Loss๋ฅผ ๊ฐ ํ๋ผ๋ฏธํฐ์ ๋ํด ํธ๋ฏธ๋ถํ gradient ๋ฒกํฐ๋ฅผ ํตํด ๋ชจ๋ ํ๋ผ๋ฏธํฐ๋ฅผ ๋์์ ์
๋ฐ์ดํธ
3.3 ๊ณ ์ฐจ์ ํ์ฅ
- ฮธ(W,b)๊ฐ ๋ค์ฐจ์์ผ ๋๋ ๋์ผ ์๋ฆฌ ์ ์ฉ
- 2์ฐจ์์ธ ๊ฒฝ์ฐ


- ๋ฅ๋ฌ๋์์๋ ์๋ฐฑ๋ง ๊ฐ์ ํ๋ผ๋ฏธํฐ๊ฐ ์กด์ฌ โ local minima์ ๋น ์ง ๊ฐ๋ฅ์ฑ์ ์ ์
- ์๋ฐฑ๋ง, ์์ฒ, ์์ต๋ง ์ฐจ์์ loss ํจ์ surface์์ global minima๋ฅผ ์ฐพ๋ ๋ฌธ์ ์์,
- ๋์์ local minima๋ฅผ ์ํ ์กฐ๊ฑด์ด ๋ง์กฑ๋๊ธฐ๋ ์ด๋ ต๊ธฐ ๋๋ฌธ
- ๋ฐ๋ผ์, local minima์ ๋ํ ๊ฑฑ์ ์ ํฌ๊ฒ ํ ํ์ ์์
3.4 Pytorch๋ก ๊ตฌํํด๋ณด๊ธฐ
import torch
import torch.nn.functional as F
target = torch.FloatTensor([[.1, .2, .3],
[.4, .5, .6],
[.7, .8, .9]])
x = torch.rand_like(target)
x.requires_grad = True
loss = F.mse_loss(x, target)
threshold = 1e-5
learning_rate = 1.0
iter_cnt = 0
while loss > threshold:
iter_cnt += 1
loss.backward()
x = x - learning_rate * x.grad
x.detach_()
x.requires_grad_(True)
loss = F.mse_loss(x, target)
print('%d-th Loss: %.4e' % (iter_cnt, loss))
print(x)
4. Learning Rate
4.1 Learning Rate์ ์ญํ
- ํ์ต ์ ํ๋ผ๋ฏธํฐ ์
๋ฐ์ดํธ ํฌ๊ธฐ๋ฅผ ๊ฒฐ์ ํ๋ step size
- ์ ์ ํ์ง ์์ผ๋ฉด loss๊ฐ ๋ฐ์ฐํ๊ฑฐ๋ ์๋ ด ์๋๊ฐ ๋๋ ค์ง
4.2 Learning Rate์ ์ต์ ํ
- ๋๋ฌด ํฐ learning rate โ ๋ฐ์ฐ(Loss๊ฐ inf, NaN์ด ๋์ด)
- ๋๋ฌด ์์ learning rate โ ๋๋ฌด ๋๋ฆฐ ์๋ ด,
local minima์ ๋จธ๋ฌด๋ฅผ ์ ์์(ํ๋ผ๋ฏธํฐ๊ฐ ๋ง์ผ๋ฉด ์ฃผ๋ก ๋ฐ์ X)

4.3 Learning Rate Tip
- ๋ชจ๋ธ์ ๋ฐ๋ผ ์ ์ ํ ๊ฐ์ด ๋ฌ๋ผ์ง๋ฉฐ, ์ ๋์ ์ธ ๊ธฐ์ค์ ์์
- ๋ด ๋ชจ๋ธ์ ์ ์ ํ ํ์ดํผ ํ๋ผ๋ฏธํฐ๋ฅผ ์ฐพ์ ์ ์๋๋ก ์คํ์ ํตํด ์ต์ ํํ๋ ๊ฒ์ด ํ์
- ์ ์ ํ ๊ฐ์ ์ฐพ๊ธฐ ์ด๋ ต๋ค๋ฉด 1e-4 ๊ฐ์ด ์์ ๊ฐ์ ์ฌ์ฉํ๊ณ ์ค๋ ํ์ต
- Adam Optimizer ๋ฑ์ผ๋ก ์๋ ์กฐ์ ๋ ๊ฐ๋ฅ
5. Summary
- ์ ์ ์๋ ์ฐธ ํจ์๋ฅผ ๊ทผ์ฌํ๊ธฐ ์ํด ๋ชจ๋ธ์ ํ์ต์ํด
- ์์คํจ์๋ฅผ ์ค์ด๋ ๋ฐฉํฅ์ผ๋ก ํ๋ผ๋ฏธํฐ๋ฅผ ์
๋ฐ์ดํธ
- ์ด๋ฅผ ์ํด ๊ธฐ์ธ๊ธฐ(gradient)๋ฅผ ๊ณ์ฐํ๊ณ
- ํ์ต๋ฅ (learning rate)์ ๊ณฑํด ์
๋ฐ์ดํธ ์งํ
- Gradient Descent๋ ์์ค์ ์ต์ํํ๊ธฐ ์ํ ๊ธฐ๋ณธ์ ์ธ ์ต์ ํ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.