Pytorch - Basic Code in Pytorch
Pytorch for AI
๋ธ๋ก๊ทธ๋ฅผ ์ ๋ฆฌํ๋ ค๊ณ ๋ง์ ๋จน์ผ๋ฉด์ ํ์ฐธ ์ ์ ๋ค์๋ Pytorch ๊ฐ์ข๋ฅผ ๋ค์ ๋ณด๋ฉด์ ์๋ ์๋ ์ ๋ง ์ดํด๊ฐ ์๋๋๋ฐ ์ด์ ๋ ์กฐ๊ธ ์ต์ํด์ง ๊ฒ์ ํฌ์คํ ํ๋ ค ํ๋ค.
torch.nn.Module
pytorch
๋ด์์ nn ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ Neural Network
๋ฅผ ๊ตฌ์ฑํ๋ Layer ์ base class ์ด๋ค. ๊ธฐ๋ณธ์ ์ผ๋ก nn.Module ์ 4๊ฐ์ง๋ฅผ ์ ์ํด์ผ ํ๋๋ฐ
input ์ด ๋ฌด์์ธ์ง
output ์ด ๋ฌด์์ธ์ง
forward ๋ ์ผ์ด๋๋ ์ผ์ด ๋ฌด์์ธ์ง
backward ๋ ์ผ์ด๋๋ ์ผ์ด ๋ฌด์์ธ์ง
๋ฑ์ ์๊ฐํด์ผ ํ๋ค. ๋ํ ํ์ต์ ๋์์ด ๋๋ parameter(weights)
๋ฅผ ์ ์ํด์ฃผ๋ฉด backward
๋ autograd
๋ก ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํด์ง๋ค.
torch.nn.Parameter
Parameter ํด๋์ค
๋ Tensor ๊ฐ์ฒด์ ์์ ๊ฐ์ฒด๋ก nn.Module
๋ด์ ์์ฑ์ด ๋ ๋๋ required_grad=True
๋ก ์ง์ ๋์ด ํ์ต ๋์์ด ๋๋ Tensor ์ด๋ค. ์ด ๋ง์ AutoGrad
์ ๋์์ด ๋๋ค๋ ๋ง๊ณผ ๋๊ฐ์ ๋ง๋ก ๊ต์ฅํ ํต์ฌ ํฌ์ธํธ์ด๋ค.
๋ค๋ง ์ฐ๋ฆฌ๊ฐ ์ง์ ์ง์ ํ ์ผ์ ์ ์๋๋ฐ ๊ทธ ์ด์ ๋ ๋๋ถ๋ถ์ layer ์๋ weights ๊ฐ๋ค์ด ์ง์ ๋์ด ์๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋๋ ์ค์ํ ๋ถ๋ถ์ด๋ฏ๋ก ์์๋ ํ์๊ฐ ์๋ค.
Example Model
class MyLinear(nn.Module): #nn.Module ์ ์์๋ฐ๋ ๋ชจ์ต
def __init__(self, in_features, out_features, bias=True):
super().__init__()
self.in_features = in_features
self.out_features = out_features
# ์ค์ ๋ก ์ด๋ ๊ฒ Parameter ๋ฅผ ํตํด
# weight ๊ฐ์ ์ก์์ฃผ๋ ์ผ์ ๊ฑฐ์ ์์
self.weights = nn.Parameter(
torch.randn(in_features, out_features)
)
self.bias = nn.Parameter(torch.randn(out_features))
def forward(self, x : Tensor):
return x @ self.weights + self.bias
์์ ์ง ๋คํธ์ํฌ๋ ์ ๋ง ์ ๋ ๊ฒ ์งค ์ผ์ด ๊ฑฐ์ ์๋ค. nn ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ด์ฅ๋์๋ ๋ค๋ฅธ neural network(cnn, rnn ๋ฑ)
๋ฅผ ์ฌ์ฉํ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋๋ network ์ ๊ตฌ์กฐ๋ฅผ ํ์
ํ๊ธฐ์๋ ๊ด์ฐฎ์ ์ฝ๋์ผ ๊ฒ์ด๋ค.
Backward
๊ฐ Layer ๋ค์ ์จ์ด์๋ weight ๋ค์ ๋ฏธ๋ถ์ ์ํํ๋ ์ญํ ์ ํ๋ค. forward ํจ์๋ฅผ ๊ฑฐ์ณ ๋์จ ๊ฒฐ๊ณผ๊ฐ(Prediction)
๊ณผ ์ค์ ๊ฐ(Ground Truth)
๊ฐ์ ์ฐจ์ด(loss) ์ ๋ํด ๋ฏธ๋ถ์ ์ํํ๋ค. ์ด๋ ๊ฒ ์ป์ด๋ธ ๋ฏธ๋ถ๊ฐ์ผ๋ก weight ๋ค์ ์
๋ฐ์ดํธํ๋ค. ์ฝ๋๋ฅผ ๋ณด๋ฉด ์ดํดํด๋ณด์.
Code
for epoch in range(epochs):
optimizer.zero_grad()
"""model = MyLinear(3, 7)"""
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
์ฝ๋๋ฅผ ์ฐจ๊ทผ์ฐจ๊ทผ ๋ด๋ณด์.
์ผ๋จ optimizer
๋ ์ต์ ํ๋ฅผ ๋งก๋๋ค. ์ต์ ํ๋ ๊ฐ ํ์ต ๋จ๊ณ์์ ๋ชจ๋ธ์ loss๋ฅผ ์ค์ด๊ธฐ ์ํด ๋ชจ๋ธ ๋งค๊ฐ๋ณ์๋ฅผ ์กฐ์ ํ๋ ๊ณผ์ ์ด๋ผ ๋ณผ ์ ์๋ค. ๊ฐ epoch ๋ ๋ง๋ค ๊ฐ layer
์ weights
๋ค์ gradient
๊ฐ์ 0์ผ๋ก ์ฌ์ค์ ํ๋ค. ์ด์ ๋ ์ด์ ์ ํ์ตํ gradient
๊ฐ ์ด๋ฒ ํ์ต์์ ์ํฅ์ ์ฃผ์ง ์๊ฒ ํ๊ธฐ ์ํด์์ด๋ค.
๊ทธ ๋ค์ model์ inputs ์ ๋ฃ์ผ๋ฉด outputs(์์ธก๊ฐ) ์ด ๋์ฌํ
๋ฐ ๊ทธ๊ฒ์ ์ค์ label ๊ณผ ๋น๊ตํ์ฌ loss ๊ฐ์ ๊ตฌํด๋ธ๋ค. ๊ฐ์ฅ ์ค์ํ backward ํจ์๋ฅผ ํตํด ๊ฐ loss ์ ๋ํ ๋ชจ๋ weights ๊ฐ์ ๊ณ์ฐํ๊ณ optimizer.step
ํจ์๋ฅผ ํตํด weight ๋ฅผ ์
๋ฐ์ดํธํ๋ค.
์ด๊ฒ์ด ํ์ต์ ๊ธฐ๋ณธ ๋ผ๋์ด๋ค. ๋น์์ ๋ฐฐ์ธ๋๋ ์ฉ์ด ์์ฒด๋ ๋ฏ์ค๊ณ ์ฝ๋๋ ์ ์ดํด๊ฐ ์๋์ ํ์ฐธ ์ด๋ ค์ํ๋ ๊ธฐ์ต์ด ๋๋ค. ๋ฅ๋ฌ๋์ ๊ณต๋ถํ๋ฉด์ ๋๋ ๊ฒ์ ๊ธฐ์ด๊ฐ ํํํ๋ฉด ๋ค๋ฅธ ์ด๋ ค์ด ๊ฒ ๋์๋ ์ดํด๊ฐ ๋น ๋ฅด๋ค๋ ์ ์ด๋ค. ๋ค๋ค ๊ธฐ์ด์ ์ถฉ์คํ๋๋ก ํ์.