pytorch 시작하기

pytorch 공부하기 part_1

import torch
import torch.nn as nn
# model 
import torch.optim as optim
# optimizer
import torch.nn.functional as f
# functional cross_entropy 등등
from torchvision import transforms, datasets
-----------------------------------------------
epochs = 30
batch_size = 64

transform = transforms.Compose([transforms.ToTensor()])
------------------------------------------------
# 데이터 저장

trainset = datasets.FashionMNIST(
root = 'data',
train = True,
download = False,
# True이면 현재 경로에 root 이름으로 폴더 만들어서 데이터 저장 
transform = transform)

testset = datasets.FashionMNIST(
root = 'data',
train = False, # testset =False
download = False,
transform = transform)
------------------------------------------------
#데이터 불러오기 = torch.utils.data.DataLoader

train_loader = torch.utils.data.DataLoader(
dataset  = trainset,
batch_size = batch_size,
shuffle = True)

test_loader = torch.utils.data.DataLoader(
dataset = testset,
batch_size = batch_size,
shuffle = True)
------------------------------------------------
#model 만들기

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(784, 256)
        self.fc2 = nn.Linear(256, 128)
        self.fc3 = nn.Linear(128, 10) # 마지막 10개 class
        
    def forward(self, x):
        #x.shape = torch.Size([64, 1, 28, 28])
        x = x.view(-1, 784) # view를 통해 1차원으로 만듦 linear layer를 거치기 위해 
        # x.shape = torch.Size([64, 784])
        x = f.relu(self.fc1(x))
        # x.shape = torch.Size([64, 256])
        x = f.relu(self.fc2(x))
        # x.shape = torch.Size([64, 126])
        x = self.fc3(x)
        # x.shape = torch.Size([64, 10])
        return x

model = Net().to('cuda')# gpu 정의
optimizer = optim.SGD(model.parameters(), lr = 0.01)
--------------------------------------------------

def train(model, train_loader, optimizer):
    # 학습 모드
    model.train()
    
    for batch_idx, (data, target) in enumerate(train_loader):
        
        data, target = data.to('cuda'), target.to('cuda')
        
        optimizer.zero_grad()
        # 매 반복마다 기울기를 계산하기 위해 zero_grad
        # 이전 루프에서 .grad에 저장된 값이 backward 할 때 방해를 주기에 적용 
        output = model(data)
        # loss = mini batch인 64개의 클래스의 오차 평균 값
        loss = f.cross_entropy(output, target)
        # cross_entropy - 다중 분류
        loss.backward()
        optimizer.step()
 --------------------------------------------------
 def evaluate(model, test_loader):
    # 평가 모드
    model.eval()
    
    test_loss = 0
    # test 과정에서 Loss
    correct = 0
    #실제 모델 예측이 정답과 맞은 횟수
    with torch.no_grad():# 평가 과정에서는 기울기를 계산하지 않기에, no_grad
        for data, target in test_loader:
            data, target = data.to('cuda'), target.to('cuda')
            output = model(data)
            
            test_loss += f.cross_entropy(output, target, reduction='sum').item()
            
            pred = output.max(1, keepdim=True)[1]
            correct += pred.eq(target.view_as(pred)).sum().item()
    
    test_loss /= len(test_loader.dataset)
    
    test_accuracy = 100. * correct / len(test_loader.dataset) #정확도 계산
    return test_loss, test_accuracy
--------------------------------------------------
#모델 적용하기
for epoch in range(1, epochs + 1):
    train(model, train_loader, optimizer)
    test_loss, test_accuracy = evaluate(model, test_loader)
    
    print('[{}] Test Loss: {:.4f}, Accuracy: {:.2f}%'.format(epoch, test_loss, test_accuracy))