๋ค์ํ ๋ฅ๋ฌ๋ ํ๋ ์์ํฌ
๊ฐ ์กด์ฌํ๋๋ฐ, ๊ทธ ์ค์์๋ ๊ฐ์ฅ ๋ํ์ ์ธ PyTorch
์ ๋ํด ์์๋ณด๋ ค๊ณ ํ๋ค.
๋
๋ค ๋ฅ๋ฌ๋ ํ์ต์ ์ํค๊ณ ํ๋ก์ ํธ๋ฅผ ํ๋ค๋ณด๋ฉด, ํ๋ ์์ํฌ๋ฅผ ๊ทธ๋ฅ ์ํฌํธํด์ ์ฐ๊ฒ ๋๋ค.
PyTorch์ ๋ํด์ ๋ ์๊ณ ํ์ฉํ๊ณ ์ถ๋ค๋ฉด ์ ์ฒด์ ์ธ ํ๋ฆ์ ๋ํด์ ์๊ณ ์๋ ๊ฒ์ด ์ข๋ค.
๐ ํ๋ ์์ํฌ: ์์ ์ ํจ์จ์ ์ผ๋ก ํ ์ ์๋๋ก ์ง๋์ ํ
- ํน์ ์์ ์ ๋์์ค ์ ์๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ํจ์๋ฅผ ๋ชจ์๋ ์งํฉ์ฒด
- PyTorch, Tensorlfow, Keras ๋ฑ์ด ์กด์ฌ
- ์ต๊ทผ ๋ฅ๋ฌ๋ ๋ถ์ผ์์๋ PyTorch์ ๋น์ค์ด ๋์์ง๊ณ ์์
๊ณผ๊ฑฐ facebook์์ ๊ฐ๋ฐํ ํ๋ ์์ํฌ
Tensor(ํ ์)๋ผ๋ ๊ฐ๋ ์ ๊ธฐ๋ฐ์ผ๋ก ํจ
Numpy(๋ํ์ด) ๋ฐฐ์ด๊ณผ ์ ์ฌํ์ง๋ง, ๋ฅ๋ฌ๋์ ์ต์ ํ๋ ๋ค์ํ ๊ธฐ๋ฅ์ ์ ๊ณต
GPU ๊ฐ์์ ์ง์ํ์ฌ ๋ ๋น ๋ฅธ ์ฐ์ฐ ์ํ ๊ฐ๋ฅ
ํ ์๋ฅผ GPU๋ก ์ฐ์ฐํ ์ ์๋๋ก ์ด๋
.to(device)
์ํค๋ฉด PyTorch๊ฐ ์๋์ผ๋ก GPU์์ ๊ณ์ฐ์ ์ํ
Pytorch๋ ํ์ต๋ชจ๋ธ์ ๊ตฌ์ถํ๊ณ , ํ์ต๋ ๋ชจ๋ธ(Pre-trained Model)์ ์ ์ฅํ๊ฑฐ๋ ๋ถ๋ฌ์ค๊ธฐ ํธํจ
๋ชจ๋ธ์ ์ํ, ์ํคํ ์ฒ ๋ฐ ํ์ต๋ ํ๋ผ๋ฏธํฐ๋ฅผ ํ์ผ์ ์ ์ฅ ๊ฐ๋ฅ
import numpy as np # ์ฃผ๋ก ์ถ์ฝ์ด์ธ np๋ก ๋ถ๋ฌ์ต๋๋ค.
arr = np.array([1, 2, 3, 4, 5])
print(arr + 1)
print(arr * 2)
>>> Output: [2 3 4 5 6]
>>> Output: [2 4 6 8 10]
torch.tensor()
import torch
# Tensor ์์ฑ
x = torch.tensor([1, 2, 3])
y = torch.tensor([4, 5, 6])
# Tensor ์ฐ์ฐ ์ํ
z = x + y
print(z)
>>> tensor([5, 7, 9])
[1, 2, 3, 4, 5, 6]
์ ๊ฒฐ๊ณผ[5, 7, 9]
์ ๊ฒฐ๊ณผ ์์ฑ => ํ
์์ฐ์ฐtorch.zeros()
| torch.ones()
# 0์ผ๋ก ์ฑ์์ง ๋ชจ์์ด (3, 4)์ธ ํ
์ ์์ฑ
zeros_tensor = torch.zeros(3, 4)
>>> tensor([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])
# 1๋ก ์ฑ์์ง ๋ชจ์์ด (2, 2, 2)์ธ ํ
์ ์์ฑ
ones_tensor = torch.ones(2, 2, 2)
>>> tensor([[[1., 1.],
[1., 1.]],
[[1., 1.],
[1., 1.]]])
torch.matmul()
# ํ๋ ฌ ๊ณฑ์
์ํ
A = torch.tensor([[1, 2], [3, 4]])
B = torch.tensor([[5, 6], [7, 8]])
result = torch.matmul(A, B)
>>> tensor([[19, 22],
[43, 50]])
matmul
์ ํ๋ ฌ๊ณฑ์ธ Matrix Multiplication์ ์ค์๋ง์A
์๋ ์
๋ ฅ๊ฐ, B
์๋ ๊ฐ์ค์น ํ๋ ฌ๊ฐ์ด ์ฃผ๋ก ํ ๋น๋จtorch.cuda
# CUDA ์ฌ์ฉ ๊ฐ๋ฅ ์ฌ๋ถ ํ์ธ
if torch.cuda.is_available():
device = torch.device("cuda")
else:
print("CUDA๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.")
x = torch.tensor([1, 2, 3]).to(device) # ํ
์๋ฅผ GPU๋ก ์ด๋
y = torch.tensor([4, 5, 6]).to(device) # ํ
์๋ฅผ GPU๋ก ์ด๋
z = x + y # GPU์์ ๊ณ์ฐ ์ํ
result = z # ํ
์๋ฅผ ๋ค์ CPU๋ก ์ด๋
>>> tensor([5, 7, 9], device='cuda:0')
๐ CUDA
CUDA(Compute Unified Device Architecture)๋ NVIDIA์์ ๊ฐ๋ฐํ ๋ณ๋ ฌ ์ปดํจํ ํ๋ซํผ ๋ฐ ํ๋ก๊ทธ๋๋ฐ ๋ชจ๋ธ์ ๋๋ค. ์ด๋ ๊ฐ๋ฐ์๋ค์ด ๊ทธ๋ํฝ ์ฒ๋ฆฌ ์ธ์๋ NVIDIA GPU(๊ทธ๋ํฝ ์ฒ๋ฆฌ ์ฅ์น)์ ์ฑ๋ฅ์ ํ์ฉํ์ฌ ์ผ๋ฐ ๋ชฉ์ ์ ์ปดํจํ ์์ ์ ์ํํ ์ ์๊ฒ ํด์ค๋๋ค.
torch.nn
-Pytorch์์๋ nn.Module
์ ์ฌ์ฉํ์ฌ ๊ฐ๋จํ ์ ๊ฒฝ๋ง ๋ชจ๋ธ ์ ์ ๊ฐ๋ฅ
__init__
๊ณผ forward
๊ตฌ์กฐ ํ์
์ค์import torch
import torch.nn as nn
# ์ ๊ฒฝ๋ง ๋ชจ๋ธ ์ ์
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# ์
๋ ฅ ํฌ๊ธฐ๊ฐ 10์ด๊ณ , ์ถ๋ ฅํฌ๊ธฐ๊ฐ 5์ธ ํ๋์ ์์ ์ฐ๊ฒฐ์ธต
self.fc = nn.Linear(10, 5) # Fully-Connected Layer
# forward-> ์์ ํ ์ฐ์ฐ
def forward(self, x):
x = self.fc(x)
return x
# ๋ชจ๋ธ์ ์ธ์คํด์ค ์์ฑ
model = Net()
# ๋ชจ๋ธ ๊ตฌ์กฐ ์ถ๋ ฅ
input = torch.randn(1, 10)
output = model(input)
torch.nn.Loss()
| loss.backward()
์์คํจ์์ ์ญ์ ํ๋ฅผ ๊ตฌํ ๋, Pytorch์ ์ฅ์ ์ด ๋๋๋ฌ์ง
๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ก ์์ค๊ณ์ฐ, ์ญ์ ํ ์ฝ๊ฒ ๊ตฌํ ๊ฐ๋ฅ
์์คํจ์๋ฅผ MSE(ํ๊ท ์ ๊ณฑ์ค์ฐจ)๋ก ์ ์: nn.MSELoss()
-> ์
๋ ฅ ํ
์์ ํ๊ฒ ํ
์๋ฅผ ๋น๊ตํด ์์ค๊ฐ ๊ณ์ฐ
loss.backward()
๋ก ์ญ์ ํ ์ํ
์ ๋ ฅ ํ ์์ ๋ํ ์์ค์ ๊ธฐ์ธ๊ธฐ๋ฅผ ์ถ๋ ฅ
import torch
import torch.nn as nn
# ๋ฌด์์ ์
๋ ฅ๊ณผ ํ๊ฒ ํ
์ ์์ฑ
input = torch.randn(3, requires_grad=True)
target = torch.tensor([0.5, -1, 2])
# ์์ค ํจ์ ์ ์
loss_fn = nn.MSELoss()
# ์์ค๊ฐ ๊ณ์ฐ
loss = loss_fn(input, target)
# ์ญ์ ํ ์ํ
loss.backward()
# ๊ธฐ์ธ๊ธฐ ์ถ๋ ฅ
print(input.grad)
torch.optim
import torch
import torch.nn as nn
import torch.optim as optim
# ๋ฌด์์ ๋ชจ๋ธ๊ณผ ์
๋ ฅ Tensor ์์ฑ
model = nn.Linear(5,1)
input = torch.randn(2, 5)
# ์ตํฐ๋ง์ด์ ์ ์ -> SGD(ํ๋ฅ ์ ๊ฒฝ์ฌํ๊ฐ๋ฒ)์ผ๋ก ์ ์
optimizer = optim.SGD(model.parameters(), lr=0.1)
# ๊ธฐ์ธ๊ธฐ ์ด๊ธฐํ
optimizer.zero_grad()
# ์์ ํ
output = model(input)
# ์์ค ๊ณ์ฐ
loss = output.mean()
# ์ญ์ ํ
loss.backward()
# ๋ชจ๋ธ ํ๋ผ๋ฏธํฐ ์
๋ฐ์ดํธ
optimizer.step()
# ์
๋ฐ์ดํธ๋ ํ๋ผ๋ฏธํฐ ์ถ๋ ฅ
print(model.weight)
SGD
: Stochastic Gradient Descent, ํ๋ฅ ์ ๊ฒฝ์ฌ ํ๊ฐ๋ฒoptimizer.zero_grad()
: ๊ธฐ์ธ๊ธฐ ์ด๊ธฐํIr
: Learning Rate, ํ์ต๋ฅ loss.backward()
์ optimizer.step()
๋ฅผ ์คํํ์ฌ ์ญ์ ํ์ ํ๋ผ๋ฏธํฐ ์
๋ฐ์ดํธ๋ฅผ ์ํtorch.save()
๋ฅผ ์ฌ์ฉํ์ฌ ์ฝ๊ฒ ์ ์ฅ => .pt
๋๋ .pth
ํ์ฅ์๋ก ์ ์ฅtorch.load()
๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ฅ๋ ๋ชจ๋ธ์ ๋ถ๋ฌ์ดmodel.load_state_dict()
๋ฅผ ์ฌ์ฉํด model
๋ณ์์ ๊ธฐ์กด ๊ฐ์ค์น ๊ฐ ํ ๋นtorch.save()
| torch.load()
import torch
import torch.nn as nn
# ๊ฐ๋จํ ๋ชจ๋ธ ์ ์ => ์์์ ์ ์ํ ์ ๊ฒฝ๋ง ๋ชจ๋ธ๊ณผ ๊ตฌ์กฐ๊ฐ ๋์ผ
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc = nn.Linear(10, 5)
def forward(self, x):
x = self.fc(x)
return x
# ๋ชจ๋ธ ์ธ์คํด์ค ์์ฑ
model = Net()
# ๋ชจ๋ธ ์ํ ์ ์ฅ
torch.save(model.state_dict(), 'model.pth')
# ๋ชจ๋ธ ์ํ ๋ถ๋ฌ์ค๊ธฐ
model.load_state_dict(torch.load('model.pth'))
# ๋ถ๋ฌ์จ ๋ชจ๋ธ์ ์ฌ์ฉํ์ฌ ์ถ๋ก ์ํ
input = torch.randn(1, 10)
output = model(input)
print(output)
[์ถ์ฒ | ๋ฅ๋ค์ด๋ธ Code.zip ๋งค๊ฑฐ์ง]