04-2. Loading Data(Mini batch and data load)
๋ณธ ๊ธ์ '๋ชจ๋๋ฅผ ์ํ ๋ฅ๋ฌ๋ ์์ฆ 2'์ 'pytorch๋ก ์์ํ๋ ๋ฅ ๋ฌ๋ ์ ๋ฌธ'์ ๋ณด๋ฉฐ ๊ณต๋ถํ ๋ด์ฉ์ ์ ๋ฆฌํ ๊ธ์ ๋๋ค.
ํ์์ ์๊ฒฌ์ด ์์ฌ ๋ค์ด๊ฐ ๋ถ์ ํํ ๋ด์ฉ์ด ์กด์ฌํ ์ ์์ต๋๋ค.
๋ณต์กํ ๋ชจ๋ธ๋ค์ ์์ฒญ๋ ์์ ๋ฐ์ดํฐ๊ฐ ํ์ํ๋ค!
⇒ ๊ทธ๋ฐ๋ฐ ์ฌ๋ฌ๊ฐ์ง ์ด์ (์๊ฐ ๋ฑ๋ฑ) ๋๋ฌธ์ ํ๋ฒ์ ํ์ตํ๋๊ฒ ๋ถ๊ฐ๋ฅํ๋ค.
⇒ ๊ทธ๋ ๋ค๋ฉด ์ผ๋ถ์ ๋ฐ์ดํฐ๋ก๋ง ํ์ตํ๋ค๋ฉด ๋น ๋ฅด๊ฒ ํ์ตํ ์ ์์ง ์์๊น?
1. Mini Batch and batch size
๋ฏธ๋ ๋ฐฐ์น : ์ ์ฒด ๋ฐ์ดํฐ๋ฅผ ๋ ์์ ๋จ์๋ก ๋๋ ์ด ํด๋น ๋จ์๋ก ํ์ตํ๋ ๊ฐ๋ ์์, ๋จ์!
๋ฏธ๋ ๋ฐฐ์น ํ์ต์ ํ๊ฒ ๋๋ค๋ฉด, ํ ๋ฏธ๋ ๋ฐฐ์น๋งํผ๋ง ๊ฐ์ ธ๊ฐ์ ํ์ต์ ์ํํ๋ค, ๊ทธ๋ฆฌ๊ณ ๊ทธ ๋ค์ ๋ฏธ๋๋ฐฐ์น๋ฅผ ๊ฐ์ ธ๊ฐ์ ํ์ต์ ์ํํ๊ณ ....
์ด๋ ๊ฒ ์ ์ฒด ๋ฐ์ดํฐ์ ๋ํ ํ์ต์ด 1ํ ๋๋๋ฉด 1 Epoch๊ฐ ๋๋๊ฒ ๋๋ค.
๋ฏธ๋ ๋ฐฐ์น์ ํฌ๊ธฐ๋ฅผ ๋ฐฐ์น ํฌ๊ธฐ(batch size)๋ผ๊ณ ํ๋ค.
๋ฏธ๋ ๋ฐฐ์น ๋จ์๋ก ๊ฒฝ์ฌ ํ๊ฐ๋ฒ์ ์ํํ๋ ๋ฐฉ๋ฒ์ '๋ฏธ๋ ๋ฐฐ์น ๊ฒฝ์ฌ ํ๊ฐ๋ฒ'์ด๋ผ๊ณ ํ๋ฉฐ, ์ผ๋ฐ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ์ด ์ต์ ๊ฐ์ ์๋ ดํ๋ ๊ณผ์ ์ด ๋งค์ฐ ์์ ์ ์ด์ง๋ง, ๊ณ์ฐ๋์ด ๋ง์ด ๋๋ ๋ฐ๋ฉด ๋ฏธ๋ ๋ฐฐ์น ๊ฒฝ์ฌํ๊ฐ๋ฒ์ ํ๋ จ ์๋๊ฐ ๋น ๋ฅด๋ค.
๋ฐฐ์น ํฌ๊ธฐ๋ ์ฃผ๋ก 2์ ์ ๊ณฑ์๋ฅผ ์ฌ์ฉํ๋ค. (๋ฐ์ดํฐ ์ก์์ ์ ํจ์จ์ ๋์ด๊ธฐ ์ํด)
์ ์ฒด ๋ฐ์ดํฐ๋ฅผ ๋ฐฐ์น ํฌ๊ธฐ๋ก ๋๋ ๊ฐ์ ์ดํฐ๋ ์ด์ (Iteration)์ด๋ผ๊ณ ํ๋๋ฐ, ์ด๋ ํ๋ฒ์ ์ํฌํฌ ๋ด์์ ์ด๋ค์ง๋ ๋งค๊ฐ๋ณ์ W์ b์ ์ ๋ฐ์ดํธ ํ์์ด๋ค.(ํ์ต์ด ์ผ์ด๋๋ ํ์)
2. Data Load
pytorch์๋ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๊ธฐ ์ฝ๊ฒ ํด์ฃผ๋ ์ ์ฉํ ๋๊ตฌ๋ค์ด ๋ง์๋ฐ, ๊ทธ ์ค ๋ฐ์ดํฐ์ (Dataset)๊ณผ ๋ฐ์ดํฐ๋ก๋(DataLoader)๋ฅผ ์์๋ณด์.
์ด๋ฅผ ์ด์ฉํ๋ฉด ๋ฏธ๋ ๋ฐฐ์น ํ์ต, ๋ฐ์ดํฐ ์ ํ, ๋ณ๋ ฌ ์ฒ๋ฆฌ๊น์ง ๊ฐ๋จํ ์ํํ ์ ์๋ค.
๊ธฐ๋ณธ์ ์ธ ์ฌ์ฉ ๋ฐฉ๋ฒ์ Dataset์ ์ ์ํ๊ณ , ์ด๋ฅผ DataLoader์ ์ ๋ฌํ๋ ๊ฒ์ด๋ค.
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import TensorDataset # ํ
์๋ฐ์ดํฐ์
from torch.utils.data import DataLoader # ๋ฐ์ดํฐ๋ก๋
x_train = torch.FloatTensor([[73, 80, 75],
[93, 88, 93],
[89, 91, 90],
[96, 98, 100],
[73, 66, 70]])
y_train = torch.FloatTensor([[152], [185], [180], [196], [142]])
#dataset์ผ๋ก ์ ์ฅ
dataset = TensorDataset(x_train, y_train)
dataset์ ๋ง๋ค์๋ค๋ฉด dataloader๋ฅผ ์ฌ์ฉํ ์ ์๋ค. ๋ฐ์ดํฐ ๋ก๋๋ ๋ฐ์ดํฐ ์ , ๋ฏธ๋ ๋ฐฐ์น์ ํฌ๊ธฐ๋ฅผ ๊ธฐ๋ณธ ์ธ์๋ก ์ ๋ ฅ๋ฐ๋๋ค. ์ถ๊ฐ์ ์ผ๋ก๋ shuffle์ด ์๋๋ฐ, True๋ฅผ ์ ํํ๋ฉด epoch๋ง๋ค ๋ฐ์ดํฐ ์ ์ ์์ด์ค๋ค. ์์์ ์ต์ํด ์ง๋ ๊ฒ์ ๋ฐฉ์งํ๊ธฐ ์ํจ์ด๋ค.
#๋ฐ์ดํฐ ๋ก๋ ์ค์
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)
model = nn.Linear(3,1)
optimizer = torch.optim.SGD(model.parameters(), lr=1e-5)
nb_epochs = 20
for epoch in range(nb_epochs + 1):
for batch_idx, samples in enumerate(dataloader):
#dataloader์์ ๋ฐ์ดํฐ๋ฅผ ๋บ๋, x์ y๊ฐ ๋ฌถ์ฌ์ ๋์จ๋ค.
x_train, y_train = samples
# H(x) ๊ณ์ฐ
prediction = model(x_train)
# cost ๊ณ์ฐ
cost = F.mse_loss(prediction, y_train)
# cost๋ก H(x) ๊ณ์ฐ
optimizer.zero_grad()
cost.backward()
optimizer.step()
print('Epoch {:4d}/{} Batch {}/{} Cost: {:.6f}'.format(
epoch, nb_epochs, batch_idx+1, len(dataloader),
cost.item()
))
3. Custom Dataset
torch.utils.data.Dataset์ ์์๋ฐ์ ์ง์ ์ปค์คํ ๋ฐ์ดํฐ์ ์ ๋ง๋๋ ๊ฒฝ์ฐ๋ ์๋ค.
torch.utils.data.Dataset์ ํ์ดํ ์น์์ ๋ฐ์ดํฐ์ ์ ์ ๊ณตํ๋ ์ถ์ ํด๋์ค์ด๋ค.
class CustomDataset(torch.utils.data.Dataset):
def __init__(self):
#๋ฐ์ดํฐ์
์ ์ ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ๋ ๋ถ๋ถ
def __len__(self):
#๋ฐ์ดํฐ์
์ ๊ธธ์ด. ์ฆ, ์ด ์ํ์ ์๋ฅผ ์ ์ด์ฃผ๋ ๋ถ๋ถ
def __getitem__(self, idx):
#๋ฐ์ดํฐ์
์์ ํน์ 1๊ฐ์ ์ํ์ ๊ฐ์ ธ์ค๋ ํจ์
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import Dataset
class CustomDataset(Dataset): #์ปค์คํ
๋ฐ์ดํฐ ์
๋ง๋ค๊ธฐ
def __init__(self):
self.x_data= [[73, 80, 75],
[93, 88, 93],
[89, 91, 90],
[96, 98, 100],
[73, 66, 70]]
self.y_data = [[152], [185], [180], [196], [142]]
def __len__(self):
return len(self.x_data)
def __getitem__(self, idx):
x = torch.FloatTensor(self.x_data[idx])
y = torch.FloatTensor(self.y_data[idx])
return x, y
dataset= CustomDataset() #๊ฐ์ฒด ์์ฑ
from torch.utils.data import DataLoader
dataloader = DataLoader(
dataset,
batch_size = 2,
shuffle=True, #๋ถ๋ฌ์ฌ ๋ ๋ง๋ค ๋ฐ์ดํฐ ์๊ธฐ(์์์ธ์ฐ๊ธฐ ๋ชปํ๊ฒ ํ๋ ค๊ณ )
)
#---------------------------------------------
class MultivariateLinearRegressionModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(3, 1)
def forward(self, x):
return self.linear(x)
# ๋ฐ์ดํฐ
x_train = torch.FloatTensor([[73, 80, 75],
[93, 88, 93],
[89, 91, 90],
[96, 98, 100],
[73, 66, 70]])
y_train = torch.FloatTensor([[152], [185], [180], [196], [142]])
# ๋ชจ๋ธ ์ด๊ธฐํ
model = MultivariateLinearRegressionModel()
# optimizer ์ค์
optimizer = optim.SGD(model.parameters(), lr=1e-5)
nb_epochs = 20
for epoch in range(nb_epochs+1):
for batch_idx, samples in enumerate(dataloader):
x_train, y_train = samples
# H(x) ๊ณ์ฐ
prediction = model(x_train)
# cost ๊ณ์ฐ
cost = F.mse_loss(prediction, y_train)
# cost๋ก H(x) ๊ฐ์
optimizer.zero_grad()
cost.backward()
optimizer.step()
# 20๋ฒ๋ง๋ค ๋ก๊ทธ ์ถ๋ ฅ
print('Epoch {:4d}/{} Batch {}/{} Cost: {:.6f}'.format(
epoch, nb_epochs, batch_idx+1, len(dataloader), cost.item()
))#์ดํฐ๋ ์ด์
์ 3! (๊ฐ์ค์น์ ํธํฅ์ ์
๋ฐ์ดํธ ํ์ per 1์ํฌํฌ)
<Reference>
https://deeplearningzerotoall.github.io/season2/lec_pytorch.html