02. Linear Regression
๋ณธ ๊ธ์ '๋ชจ๋๋ฅผ ์ํ ๋ฅ๋ฌ๋ ์์ฆ 2'์ 'pytorch๋ก ์์ํ๋ ๋ฅ ๋ฌ๋ ์ ๋ฌธ'์ ๋ณด๋ฉฐ ๊ณต๋ถํ ๋ด์ฉ์ ์ ๋ฆฌํ ๊ธ์ ๋๋ค.
ํ์์ ์๊ฒฌ์ด ์์ฌ ๋ค์ด๊ฐ ๋ถ์ ํํ ๋ด์ฉ์ด ์กด์ฌํ ์ ์์ต๋๋ค.
์ ํ ํ๊ท = ํ์ต ๋ฐ์ดํฐ์ ๊ฐ์ฅ ์ ๋ง๋ ํ๋์ ์ง์ ์ ์ฐพ๋ ๊ณผ์ !
0. ์ ์ฒด์ ์ธ ํ์ต ๋ฐฉ๋ฒ
(๋ค๋ฅธ ํ์ต์๋ ์ ์ฉ๋จ!)
1) ๋ฐ์ดํฐ์ ์ ํฉํ ๊ฐ์ค์ ์ค์ ํ๋ค.
2) cost function, ์ฆ ์ค์ฐจ๋น์ฉ loss๋ฅผ ๊ตฌํ ํจ์๋ฅผ ๊ฒฐ์ ํ๋ค.
3) ์ค์ฐจํจ์์ ๊ธฐ์ธ๊ธฐ๋ฅผ ์ด์ฉํด์ ๋ชจ๋ธ์ ๊ฐ์ ํ๋ค.(optimizer)
4) ๋ง์กฑ์ค๋ฌ์ด ๊ฒฐ๊ณผ๊ฐ ๋์ฌ ๋ ๊น์ง 3์ ๋ฐ๋ณตํ๋ค.
1. x๊ฐ ํ๋์ธ linear regression ๊ตฌํํ๊ธฐ
1) Hypothesis
๊ฐ์ค์ ์ธ๊ณต์ ๊ฒฝ๋ง์ ๊ตฌ์กฐ๋ฅผ ๋ํ๋ธ๋ค. ์ฆ, ์ฃผ์ด์ง x์ ๋ํด ์ด๋ค y๋ฅผ ๋ฑ์ ์ง ์๋ ค์ค๋ค.
W = weight (๊ฐ์ค์น)
b = bias (ํธํฅ)
2) ๋น์ฉํจ์ ๊ณ์ฐ
(๋น์ฉ ํจ์(cost function) = ์์ค ํจ์(loss function) = ์ค์ฐจ ํจ์(error function) = ๋ชฉ์ ํจ์(objective function))
MSE(Mean Squered Error, ํ๊ท ์ ๊ณฑ ์ค์ฐจ)๋ฅผ ์ด์ฉํด ๊ณ์ฐ.
์ฝ๊ฒ ๋งํด์, ๊ฐ๊ฐ์ ์ค์ฐจ์ ์ ๊ณฑํฉ์ ๋ํ ํ๊ท !
3) ์ต์ ํ optimizer
์ด ๊ณผ์ ์ ํตํด์ cost function์ ๊ฐ์ ์ต์๋ก ํ๋ W์ b๋ฅผ ์ฐพ๋๋ค.
๊ทธ๋ฆฌ๊ณ W์ b๋ฅผ ์ฐพ์๋ด๋ ๊ณผ์ ์ 'ํ์ต'์ด๋ผ๊ณ ํ๋ค.
์ฌ๊ธฐ์๋ ๊ฒฝ์ฌํ๊ฐ๋ฒ, Gradient Descent๋ฅผ ์ด์ฉํด์ ์ต์ ํํ๋ค. ์ฆ, ๊ธฐ์ธ๊ธฐ๋ฅผ ์ฐพ์์ ๊ธฐ์ธ๊ธฐ๊ฐ ์์์ง๋ ์ชฝ์ผ๋ก ์์ง์ด๊ฒ ๋ง๋ ๋ค.
๊ธฐ์ธ๊ธฐ๊ฐ ์์์ผ ๋๋ ์ฆ๊ฐ, ์์์ผ ๋์ ๊ฐ์ํด์ผ ํ๋ค.
๐ก ํ๊ณ ์ํ๋ ๊ฐ ๋ฌธ์ ์ ๋ฐ๋ผ ๊ฐ์ค, ๋น์ฉ ํจ์, ์ตํฐ๋ง์ด์ ๋ ์ ๋ถ ๋ค๋ฅผ ์ ์์ผ๋ฉฐ ์ ํ ํ๊ท์ ๊ฐ์ฅ ์ ํฉํ ๋น์ฉ ํจ์๋ ํ๊ท ์ ๊ณฑ ์ค์ฐจ, ์ตํฐ๋ง์ด์ ๋ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ์ ๋๋ค.
3. full code
import torch
import torch.nn as nn #์ ๊ฒฝ๋ง ์์ฑํ ๋ ์ฌ์ฉ
import torch.nn.functional as F
import torch.optim as optim #๊ฐ์ค์น ๊ฐฑ์ ํ ๋ ์ฌ์ฉ
# ๋ฐ์ดํฐ
x_train = torch.FloatTensor([[1], [2], [3]])
y_train = torch.FloatTensor([[2], [4], [6]])
# x๋ ์
๋ ฅ๊ฐ, y๋ ๊ฒฐ๊ณผ๊ฐ
#x๋ฅผ ๋ฃ์์ ๋ y๊ฐ ๋์ค๋ ๋ชจ๋ธ์ ๋ง๋ค์ด์ผํจ.
# ๋ชจ๋ธ ์ด๊ธฐํ
W = torch.zeros(1, requires_grad=True)
b = torch.zeros(1, requires_grad=True)
# requires_grad๋ก ์ด ํ
์๊ฐ ํ์ต๋ ์ ์๋ค๊ณ ๋ช
์.(์๋ ๋ฏธ๋ถ ๊ฐ๋ฅ)
# optimizer ์ค์
optimizer = optim.SGD([W, b], lr=0.01)
nb_epochs = 2900
for epoch in range(nb_epochs + 1):
# H(x) ๊ณ์ฐ - ๊ฐ์ค ๊ณ์ฐ
hypothesis = x_train * W + b
# cost ๊ณ์ฐ - ์ค์ฐจ ๋น์ฉ! - ์ค์ฐจ์ ์ ๊ณฑ๊ทผ์ ํ๊ท (MSE)
cost = torch.mean((hypothesis - y_train) ** 2)
# cost๋ก H(x) ๊ฐ์
optimizer.zero_grad() #gradient๋ฅผ 0์ผ๋ก ์ด๊ธฐํ(W, b๊ฐ ์
๋ฐ์ดํธ ๋ ๋ ๋ง๋ค ๋ฏธ๋ถ๊ฐ์ด ๋ฌ๋ผ์ง)
cost.backward() #cost์ ๊ธฐ์ธ๊ธฐ๋ฅผ ๊ตฌํจ
optimizer.step() #w, b ์
๋ฐ์ดํธ
# 100๋ฒ๋ง๋ค ๋ก๊ทธ ์ถ๋ ฅ
if epoch % 100 == 0:
print('Epoch {:4d}/{} W: {:.3f}, b: {:.3f} Cost: {:.6f}'.format(
epoch, nb_epochs, W.item(), b.item(), cost.item()
))
<Reference>
https://deeplearningzerotoall.github.io/season2/lec_pytorch.html