PyTorch Basics

데이터셋 다운로드

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)

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

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

# transforms.Normalize: torchvision을 통해 불러온 데이터셋은 0,1 범위의 pilimage인데, 이 스케일된 데이터를 -1~1 범위의 텐서로 정규화해줌. 기존의 mean, std가 각각 0.5, 0.5였기 때문에 이를 둘다 0으로 맞춰주는것(zero mean). 인자로 준 숫자만큼 값을 내린다.

 

 

클래스와 이미지 출력해보기

import matplotlib.pyplot as plt
import numpy as np

def imshow(img):
    img = img / 2 + 0.5     # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))

dataiter = iter(trainloader)  #배치 단위로 iteration
images, labels = dataiter.next()	#다음 배치 가져오기
imshow(torchvision.utils.make_grid(images))	#배치 내 이미지를 그리드로 만들어 출력
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))	#클래스 출력

 

 

모델 설계

class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 3)
        self.conv2 = nn.Conv2d(6, 16, 3)
        self.fc1 = nn.Linear(16 * 6 * 6, 120) 
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(1, -1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
        
net = Net()
net	#모델 구조 출력

 

 

파라미터 확인

params = list(net.parameters())	# 모델의 파라미터를 params에 저장
print(len(params))	#파라미터 개수 확인
print(params[0].size())  # 첫 번째 레이어인 conv1 weight의 사이즈. torch.Size([6, 1, 3, 3])

 

 

Optimizer, loss function 정의

criterion = nn.MSELoss()
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)	#weight를 업데이트하는 방식

 

 

모델 학습

for epoch in range(10):
  totaloss = 0.0

  for i, data in enumerate(trainloader):  #enumerate(trainloader, 1)으로 하면 1부터 시작함.
    images, labels = data
    optimizer.zero_grad()
    outputs = net(images)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()

    totaloss += loss.item()

    if i % 2000 == 1999:
      print(epoch, 'epoch', i, 'loss:', totaloss/2000)
      totaloss=0.0  #출력한 후 누적 loss 초기화

optimizer.zero_grad() : 모든 변수의 그라디언트값을 0으로 초기화. 하지 않으면 값이 수정(update)이 아니라 누적되어버림

loss.backward() : grad_fn 속성을 따라 역방향으로 전파시킴. loss function에서부터 그 전의 linear, 그 전의 activation(relu)으로... 그래프 내의 requires_grad=True인 모든 텐서는 loss에 대해 미분되어 값이 누적/수정됨.

optimizer.step() : 업데이트 진행

 

 

테스트

correct = 0
total = 0

with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))

values, indices = torch.max(outputs.data, 1)

: axis=1, 배치 내 데이터별로 10개 클래스 중 max값만을 뽑아냄. values에 값, indices에 인덱스 저장됨

 

 

클래스 별 정확도 확인

class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))

with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels)

        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1

for i in range(10):
    print('Accuracy of %5s : %2d %%' % (classes[i], 100 * class_correct[i] / class_total[i]))

 

 

모델 저장 및 불러오기

PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)	#모델 저장

net = Net()
net.load_state_dict(torch.load(PATH))	#학습한 모델 로드