[Deep Learning, Pytorch] CNN, RNN 실습 (MNIST, IMDB)

[Deep Learning] RNN 실습 : IMDB 감정 분석 (with 임베딩하는 이유)

 

[Deep Learning] CNN 실습 : MNIST 분류기 (with 정규화, 차원 확장)

 

위와 같이 RNN, CNN 실습은 Tensor로 진행했다. 최근 데이콘, Hugging face를 보면 pytorh가 대부분이다.. 안그랬던거 같은데 그래서 pytorch로 갈아탈 예정. 갈아타면서 할건? 실습 다시 올리기다. 코드에 대한 설명과 접근방법은 위 두 포스팅에 있으니 이번엔 코드만 진행

 

1. CNN

1) 데이터 로딩 및 전처리

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 이미지 정규화 및 텐서 변환
transform = transforms.Compose([
    transforms.ToTensor(), # 0~255를 0-1로
    transforms.Normalize((0.5,), (0.5,)) # 정규화 -> -1~+1
])

# 데이터셋 다운로드
train_dataset = datasets.MNIST(root='./data',
                               train = True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data',
                               train = False, download=True, transform=transform)

# 데이터로더
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=True)

 

2)  모델 정의

class CNN(nn.Module):
  def __init__(self):
    super(CNN, self).__init__()
    self.conv_layer = nn.Sequential(
        nn.Conv2d(1, 32, kernel_size = 3, padding = 1), # 28x28 -> 28x28
        nn.ReLU(),
        nn.MaxPool2d(2), #28x28 -> 14x14
        nn.Conv2d(32, 64, kernel_size = 3, padding = 1), #14x14 -> 14x14
        nn.ReLU(),
        nn.MaxPool2d(2)
    )
    self.fc_layer = nn.Sequential(
        nn.Flatten(),
        nn.Linear(64 * 7 * 7, 64),
        nn.ReLU(),
        nn.Linear(64, 10)
    )

  def forward(self, x):
    x = self.conv_layer(x)
    x = self.fc_layer(x)
    return x

 

3) 손실 함수 및 옵티마이저

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = CNN().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

 

4) 모델 요약

from torchsummary import summary
summary(model, (1, 28, 28))

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1           [-1, 32, 28, 28]             320
              ReLU-2           [-1, 32, 28, 28]               0
         MaxPool2d-3           [-1, 32, 14, 14]               0
            Conv2d-4           [-1, 64, 14, 14]          18,496
              ReLU-5           [-1, 64, 14, 14]               0
         MaxPool2d-6             [-1, 64, 7, 7]               0
           Flatten-7                 [-1, 3136]               0
            Linear-8                   [-1, 64]         200,768
              ReLU-9                   [-1, 64]               0
           Linear-10                   [-1, 10]             650
================================================================
Total params: 220,234
Trainable params: 220,234
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.67
Params size (MB): 0.84
Estimated Total Size (MB): 1.51
----------------------------------------------------------------

 

5) 모델 훈련

for epoch in range(5): 	# 64배치 5에포크 train 시행
  model.train() 		# train mode 시행
  running_loss = 0.0 	# 현재 에포크에서 전체 손실 합계 변수 초기화
  for images, labels in train_loader:
    images, labels = images.to(device), labels.to(device) # 데이터를 학습 장치로 이동
    outputs = model(images) # 결과 확인
    loss = criterion(outputs, labels)   # 손실 계산
    optimizer.zero_grad() # gradient 초기화
    loss.backward() 	# 역전파 시행. 손실 기준으로 각 파라미터에 대한 gradient 계산
    optimizer.step()
    running_loss += loss.item() # 현재 배치의 loss를 누적

  print(f'Epoch {epoch +1}, Loss: {running_loss / len(train_loader):.4f}')

Epoch 1, Loss: 0.0528
Epoch 2, Loss: 0.0370
Epoch 3, Loss: 0.0303
Epoch 4, Loss: 0.0216
Epoch 5, Loss: 0.0185

 

6) 테스트 세트 성능 확인

model.eval()
correct = 0; total = 0

with torch.no_grad():
  for images, labels in test_loader:
    images, labels = images.to(device), labels.to(device)
    outputs = model(images)
    _, predicted = torch.max(outputs.data, 1) # 예측값의 클래스 추출

    total += labels.size(0)
    correct += (predicted == labels).sum().item()

accuracy = 100 * correct / total
print(f"Test ACC: {accuracy:.2f}%")

Test ACC: 99.00%

 

1. RNN

CNN과 순서는 유사하고 모델 구조만 크게 달라짐

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from keras.datasets import imdb
from keras.preprocessing.sequence import pad_sequences
import numpy as np

# 하이퍼파라미터 지정

num_words = 10000 # imdb에서 볼 단어수
max_len = 200 # 최대 길이 같게
batch_size = 64
embed_dim = 64
hidden_dim = 32
epochs = 5

(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words = num_words)
X_train = pad_sequences(X_train, maxlen = max_len)
X_test = pad_sequences(X_test, maxlen = max_len)

# Pytorch 텐서로 변환
X_train = torch.tensor(X_train, dtype=torch.long)
y_train = torch.tensor(y_train, dtype=torch.float32)
X_test = torch.tensor(X_test, dtype=torch.long)
y_test = torch.tensor(y_test, dtype=torch.float32)

train_dataset = TensorDataset(X_train, y_train)
test_dataset = TensorDataset(X_test, y_test)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size)

# ===============================================================
# SIMPLE RNN MODEL
class SimpleRNNModel(nn.Module):
  def __init__(self):
    super(SimpleRNNModel, self).__init__()
    self.embedding = nn.Embedding(num_words, embed_dim)
    self.rnn = nn.RNN(embed_dim, hidden_dim, batch_first=True)
    self.fc = nn.Linear(hidden_dim, 1)
    self.sigmoid = nn.Sigmoid()

  def forward(self, x):
    x = self.embedding(x)
    out, _ = self.rnn(x)
    out = out[:, -1, :] # [batch, 32]
    out = self.fc(out)
    return self.sigmoid(out).squeeze()
# ===============================================================

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = SimpleRNNModel().to(device)
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters())

for epoch in range(epochs):
  model.train()
  total_loss = 0
  correct = 0 
  total = 9
  for batch_x, batch_y in train_loader:
    batch_x, batch_y = batch_x.to(device), batch_y.to(device)

    optimizer.zero_grad()
    output = model(batch_x)
    loss = criterion(output,batch_y)
    loss.backward()
    optimizer.step()

    total_loss += loss.item()
    pred = (output> 0.5).float()
    correct += (pred == batch_y).sum().item()
    total += batch_y.size(0)

  print(f'Epoch: {epoch+1}, Loss: {total_loss/len(train_loader):.4f}, Accuracy: {correct/total:.4f}')

Epoch: 1, Loss: 0.6781, Accuracy: 0.5542
Epoch: 2, Loss: 0.6116, Accuracy: 0.6682
Epoch: 3, Loss: 0.5417, Accuracy: 0.7349
Epoch: 4, Loss: 0.5071, Accuracy: 0.7586
Epoch: 5, Loss: 0.5931, Accuracy: 0.6828

 

model.eval()
correct = 0
total = 0 

with torch.no_grad():
  for batch_x, batch_y in test_loader:
    batch_x, batch_y = batch_x.to(device), batch_y.to(device)
    output = model(batch_x)
    pred = (output > 0.5).float()
    correct += (pred == batch_y).sum().item()
    total += batch_y.size(0)

print(f'Test Accuracy: {correct/total:.4f}')

Test Accuracy: 0.6920