[파이썬] PyTorch 활용 연구 사례

07 Sep 2023

PyTorch

PyTorch는 머신 러닝 및 딥 러닝 연구 및 개발을 위해 매우 강력한 프레임워크입니다. 이 문서에서는 PyTorch를 사용한 몇 가지 실제 연구 사례에 대해 알아보겠습니다. 이러한 사례는 PyTorch의 다양한 기능과 사용 방법을 보여줄 것입니다.

1. 이미지 분류

PyTorch는 이미지 분류 작업을 수행하기 위한 강력한 기능을 제공합니다. 예를 들어, CIFAR-10 데이터셋을 사용한 이미지 분류 작업에 PyTorch를 활용할 수 있습니다.

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# CIFAR-10 데이터셋 로드 및 전처리
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

# 신경망 정의
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()

# 손실 함수 및 옵티마이저 정의
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# 신경망 학습
for epoch in range(2):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 2000 == 1999:
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

위의 예제는 CIFAR-10 데이터셋을 사용하여 간단한 신경망을 학습하는 방법을 보여줍니다. PyTorch는 torchvision 패키지를 통해 데이터셋의 로드 및 전처리를 쉽게 할 수 있습니다. 또한, nn.Module 클래스를 상속받은 사용자 정의 신경망을 정의하고, CrossEntropyLoss와 SGD 옵티마이저를 사용하여 학습을 수행할 수 있습니다.

2. 자연어 처리

PyTorch는 자연어 처리 작업에도 매우 유용한 기능을 제공합니다. 예를 들어, IMDB 영화 리뷰 데이터셋을 사용한 감정 분석 작업에 PyTorch를 활용할 수 있습니다.

import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.datasets import IMDB
from torchtext.data import Field, LabelField, TabularDataset, BucketIterator

# 필드 정의
TEXT = Field(tokenize='spacy', lower=True)
LABEL = LabelField(dtype=torch.float)

# 데이터셋 로드 및 전처리
train_data, test_data = IMDB.splits(TEXT, LABEL)
train_data, valid_data = train_data.split()

# 단어장 생성
TEXT.build_vocab(train_data, max_size=25000, vectors="glove.6B.100d")
LABEL.build_vocab(train_data)

# 배치 이터레이터 생성
train_loader, valid_loader, test_loader = BucketIterator.splits(
    (train_data, valid_data, test_data), batch_size=64)

# 모델 정의
class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(LSTM, self).__init__()
        self.hidden_size = hidden_size
        self.embedding = nn.Embedding(input_size, hidden_size)
        self.lstm = nn.LSTM(hidden_size, hidden_size)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        embedded = self.embedding(x)
        output, (hidden, cell) = self.lstm(embedded)
        hidden = hidden[-1]
        return self.fc(hidden)

model = LSTM(len(TEXT.vocab), 100, 1)

# 손실 함수 및 옵티마이저 정의
criterion = nn.BCEWithLogitsLoss()
optimizer = optim.Adam(model.parameters())

# 모델 학습
for epoch in range(10):
    for batch in train_loader:
        text, labels = batch.text, batch.label
        optimizer.zero_grad()
        predictions = model(text).squeeze(1)
        loss = criterion(predictions, labels)
        loss.backward()
        optimizer.step()

# 모델 평가
correct = 0
total = 0
with torch.no_grad():
    for batch in test_loader:
        text, labels = batch.text, batch.label
        predictions = model(text).squeeze(1)
        predicted_labels = torch.round(torch.sigmoid(predictions))
        total += labels.size(0)
        correct += (predicted_labels == labels).sum().item()

accuracy = correct / total
print('Test Accuracy: {:.2f}%'.format(accuracy * 100))

위의 예제는 IMDB 영화 리뷰 데이터셋을 사용하여 LSTM 모델을 학습하는 방법을 보여줍니다. PyTorch의 torchtext 패키지를 사용하여 텍스트 데이터셋의 로드 및 전처리를 쉽게 할 수 있습니다. 또한, nn.Embedding과 nn.LSTM을 사용하여 LSTM 모델을 정의하고, BCEWithLogitsLoss와 Adam 옵티마이저를 사용하여 학습을 수행할 수 있습니다.

이러한 예제를 통해 PyTorch의 다양한 기능과 활용 방법을 알아볼 수 있습니다. PyTorch는 머신 러닝 및 딥 러닝 연구에 효율적이고 유연한 프레임워크로서 많은 사례에서 활용될 수 있습니다.