[2024 하계 모각코] 4차 개인 계획 및 결과

활동 목표

• torch 기초
• torch를 통한 model 구현 실습

활동 결과

1. PyTorch 기초

1.1. 텐서(Tensor)

텐서는 PyTorch의 기본 데이터 구조로, NumPy 배열과 유사하다. 텐서는 GPU를 활용하여 연산을 가속할 수 있다.

1.1.1. 텐서 생성

다양한 방법으로 텐서를 생성할 수 있다. 직접 데이터를 입력하거나, NumPy 배열로부터 생성하거나, 다른 텐서로부터 생성할 수 있다.

import torch
import numpy as np

# 직접 데이터로부터 텐서 생성
data = [[1, 2], [3, 4]]
x_data = torch.tensor(data)

# NumPy 배열로부터 텐서 생성
np_array = np.array(data)
x_np = torch.from_numpy(np_array)

# 다른 텐서로부터 텐서 생성
x_ones = torch.ones_like(x_data) # x_data의 속성을 유지
x_rand = torch.rand_like(x_data, dtype=torch.float) # 명시적으로 데이터 타입을 변경

1.1.2. 텐서의 속성

생성한 텐서의 모양(shape), 데이터 타입(dtype), 저장된 장치(device)를 확인할 수 있다:

tensor = torch.rand(3, 4)

print(f"Shape of tensor: {tensor.shape}")
print(f"Datatype of tensor: {tensor.dtype}")
print(f"Device tensor is stored on: {tensor.device}")

1.1.3. 텐서 연산

텐서에 다양한 연산을 수행할 수 있다. 인덱싱, 슬라이싱, 텐서 결합, 산술 연산 등의 기본적인 연산 또한 가능하다.

# GPU가 사용 가능하면 텐서를 이동
if torch.cuda.is_available():
    tensor = tensor.to('cuda')

# 기본적인 인덱싱과 슬라이싱
tensor = torch.ones(4, 4)
print('First row: ', tensor[0])
print('First column: ', tensor[:, 0])
print('Last column:', tensor[..., -1])

# 텐서 결합
t1 = torch.cat([tensor, tensor, tensor], dim=1)
print(t1)

# 산술 연산
y1 = tensor @ tensor.T
y2 = tensor.matmul(tensor.T)
y3 = torch.rand_like(tensor)
torch.add(tensor, tensor, out=y3)
print(y3)

1.2. 자동 미분(Autograd)

PyTorch의 자동 미분(Autograd) 기능은 신경망 훈련에서 중요한 역할을 한다. 텐서의 requires_grad 속성을 True로 설정하면 모든 연산을 추적할 수 있다.

1.2.1. 역전파

역전파는 손실 함수의 기울기를 계산하는 과정이다. 

x = torch.ones(2, 2, requires_grad=True)
y = x + 2
z = y * y * 3
out = z.mean()

print(z, out)
out.backward()
print(x.grad)

out.backward()를 호출하면 x에 대한 기울기를 계산하고 x.grad에 저장한다.

2. 데이터 처리와 준비

2.1. 데이터셋과 데이터로더

데이터를 효율적으로 처리하기 위해 torch.utils.data.Dataset과 torch.utils.data.DataLoader를 사용한다.

2.1.1. 데이터셋(Dataset)

데이터셋은 데이터를 저장하고 필요에 따라 데이터를 반환하는 클래스이다. 사용자 정의 데이터셋을 만들기 위해 커스텀 데이터셋 클래스에 __init__, __len__, __getitem__ 메서드를 구현했다.

from torch.utils.data import Dataset

class CustomDataset(Dataset):
    def __init__(self, data, targets):
        self.data = data
        self.targets = targets

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        return self.data[idx], self.targets[idx]

2.1.2. 데이터로더(DataLoader)

데이터로더는 데이터셋을 반복적으로 불러오고, 미니 배치(mini-batch)를 만들어 모델 학습을 돕는다.

from torch.utils.data import DataLoader

data = [[i] for i in range(10)]
targets = [i for i in range(10)]
dataset = CustomDataset(data, targets)
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)

for batch in dataloader:
    data, targets = batch
    print(data, targets)

2.2. 변환(Transform)

데이터 변환은 torchvision.transforms 모듈을 사용하여 데이터를 전처리하는 데 유용하다. 예를 들어, 이미지 데이터를 텐서로 변환하거나 정규화할 수 있다.

from torchvision import transforms

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# 변환을 적용하여 데이터셋을 로드
from torchvision.datasets import MNIST

train_dataset = MNIST(root='data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

3. 인공지능 모델 설계

3.1. 신경망 구성

신경망은 torch.nn 모듈을 사용하여 구성할 수 있다. nn.Module을 상속하여 새로운 모듈을 만들고, forward 메서드를 정의하여 학습 시 해당 메소드를 사용하도록 한다.

import torch.nn as nn
import torch.nn.functional as F

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()
        self.linear_relu_stack = nn.Sequential(
            nn.Linear(28*28, 512),
            nn.ReLU(),
            nn.Linear(512, 512),
            nn.ReLU(),
            nn.Linear(512, 10)
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

model = NeuralNetwork()
print(model)

forward 메서드는 입력 데이터를 받아 모델의 출력을 계산하는 역할을 한다.

3.2. 모델 학습과 최적화

모델을 학습시키기 위해 손실 함수를 최적화해야 한다. PyTorch는 torch.optim 모듈을 통해 다양한 최적화 알고리즘을 제공한다.

import torch.optim as optim

# 하이퍼파라미터 설정
learning_rate = 1e-3
batch_size = 64
epochs = 5

# 손실 함수와 옵티마이저 설정
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)

# 학습
for epoch in range(epochs):
    for batch in train_loader:
        X, y = batch
        pred = model(X)
        loss = loss_fn(pred, y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print(f"Epoch {epoch+1}, Loss: {loss.item()}")

3.3. 모델 평가

모델의 성능을 평가하기 위해 테스트 데이터셋을 사용한다. 모델이 학습하지 않은 데이터를 사용하여 모델의 추론 능력을 확인한다.

def evaluate(model, test_loader):
    model.eval()
    test_loss, correct = 0, 0

    with torch.no_grad():
        for X, y in test_loader:
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()

    test_loss /= len(test_loader.dataset)
    correct /= len(test_loader.dataset)

    print(f"Test Error: \\n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \\n")

모델을 평가할 때는 model.eval()을 호출하여 평가 모드로 전환하고, 기울기 계산을 하지 않기 위해 torch.no_grad() 블록을 사용한다.

참고 자료

• Introduction to PyTorch/Tensors
• Introduction to PyTorch/Datasets & DataLoaders
• Introduction to PyTorch/Build the Neural Network