CHAPTER4 패션 아이템을 구분하는 DNN

from torchvision import datasets, transforms, utils
from torch.utils import data

import matplotlib.pyplot as plt
import numpy as np

# 이미지를 텐서로 바꿔주는 코드
transform = transforms.Compose([
    transforms.ToTensor()
    # transforms.Resize() 이미지 크기 조정
    # transforms.Normalize() 정규화
    # transforms.RandomHorizontalFlip 무작위로 이미지 오른쪽과 왼쪽 뒤집기
    # transforms.RandomCrop 이미지를 무작위로 자르는 기능
])

# 데이터셋 가져오기
trainset = datasets.FashionMNIST(
    root = './.data/',
    train = True, # train 데이터셋을 받을 것인지
    download = True,
    transform = transform # Compose로 만들어 둔 이미지 변환 실행
)

testset = datasets.FashionMNIST(
    root = './.data/',
    train = False, # test 데이터셋을 받을 것인지 선택
    download = True,
    transform = transform
)

# 배치 크기(batch size) : 한 번에 처리하는 데이터 개수
batch_size = 16

# 앞에서 Dataset을 상속받은 애들은
# DataLoader 를 통해 학습에 필요한 데이터 로딩해준다
train_loader = data.DataLoader(
    dataset = trainset,
    batch_size = batch_size
)

test_loader = data.DataLoader(
    dataset = testset,
    batch_size = batch_size
)

# 배치 하나(현재 배치 하나: 16개)를 뽑아 데이터가 어떻게 생겼는지 확인하기
dataiter = iter(train_loader)
images, labels = next(dataiter)

img = utils.make_grid(images, padding = 0) # make_grid 로 여러 이미지를 하나의 이미지로 만들기
npimg = img.numpy() # 현재 img는 텐서이기 떄문에 matplotlib과 호환되는 numpy 행렬로 바꿔준다
plt.figure(figsize = (10, 7))
plt.imshow(np.transpose(npimg, (1, 2, 0))) # matplotlib이 인식하는 차원 순서 다르기 때문에 바꿔줘야함
plt.show()

print(labels)

CLASSES = {
    0: 'T-shirt/top', # 티셔츠/윗옷
    1: 'Trouser',     # 바지
    2: 'Pullover',    # 스웨터
    3: 'Dress',       # 드레스
    4: 'Coat',        # 코트
    5: 'Sandal',      # 샌들
    6: 'Shirt',       # 셔츠
    7: 'Sneaker',     # 운동화
    8: 'Bag',         # 가방
    9: 'Ankle boot'   # 앵클부츠
}

for label in labels:
    idx = label.item()
    print(CLASSES[idx])

# 개별 이미지 꺼내 보기
idx = 1
item_img = images[idx]
item_npimg = item_img.squeeze().numpy() # matplotlib에서 이용가능한 numpy 행렬 만들기
plt.title(CLASSES[labels[idx].item()])
plt.imshow(item_npimg, cmap = 'gray')
plt.show()

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torchvision import transforms, datasets

# 현재 컴퓨터에서 CUDA 사용 가능한 지
USE_CUDA = torch.cuda.is_available()
DEVICE = torch.device("cuda" if USE_CUDA else "cpu")

EPOCHS = 30
BATCH_SIZE = 64

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 픽셀값 784개를 입력받아, 가중치를 행렬곱하고 편향을 더해 값 256개 출력.
        self.fc1 = nn.Linear(784, 256)
        # 256개 입력, 128개 출력
        self.fc2 = nn.Linear(256, 128)
        # 128개 입력, 10개 출력 => 10개는 각각의 패션 아이템의 클래스
        self.fc3 = nn.Linear(128, 10)

    def forward(self, x):# 데이터를 입력받아서
        x = x.view(-1, 784) # 요소 수가 784 개인 1차원 행렬로 만들고
        x = F.relu(self.fc1(x)) # fc1 ,2거치고 활성화 함수 relu
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 선언과 동시에 어디서 연산을 수행할지 to()로 정할 수 있음.
model= Net().to(DEVICE) # 아까 앞에서 CUDA 유무에 따라 미리 선언해뒀던 이유

# 최적화 알고리즘으로 optim.SGD 사용.
# SGD = 확률적 경사하강법
optimizer = optim.SGD(model.parameters(), lr = 0.01)

# 학습 = 데이터를 보고, 가중치를 조절하는 작업 반복.
def train(model, train_loader, optimizer):
    model.train() # 학습모드on

    for batch_idx, (data, target) in enumerate(train_loader):
        # 앞에서 가중치를 GPU로 보냈었다면,
        # 학습 데이터도 같은 장치로 보내야 연산이 가능하다.
        data, target = data.to(DEVICE), target.to(DEVICE)

        optimizer.zero_grad() # 반복 때마다 기울기를 새로 계산할 수 있도록 초기화
        output = model(data) # 모델에 넣고 돌린다.

        # 3장에서는 클래스가 2개라서 BCE 를 사용했는데,
        # 이번엔 10개라 교차 엔트로피 사용해야함.
        loss = F.cross_entropy(output, target)
        loss.backward() # 기울기 계산
        optimizer.step() # 가중치 수정

# 모델 평가하기
def evaluate(model, test_loader):
    model.eval() # 평가 모드on
    test_loss = 0 # 테스트 오차 수
    correct = 0 # 예측이 맞은 수

    # 평가 과정에서는 기울기 계산 안해도 됨.(반복하는 게 아니기 때문)
    with torch.no_grad():
        for data, target in test_loader: # 똑같이 DEVICE 로 보내줌.
            data, target = data.to(DEVICE), target.to(DEVICE)
            output = model(data) # 예측값

            # 평가에서는 미니배치의 평균 대신 합을 받아야함
            # 모든 오차 더하기
            test_loss += F.cross_entropy(output, target, reduction = 'sum').item()

            # 오차 정보 말고 모델의 정확도도 함께 보자.
            # 우리가 예측한 output 에서 최댓값을 뽑아보면
            # '가장 큰 값, 그 값이 있는 자리인 인덱스' 두 개가 나옴.
            # 이 가장 큰 값의 인덱스와 label 값이 같은지 확인해야함.

            # keepdim= True : 입력된 데이터와 출력값의 차원을 갖게 해줌
            pred = output.max(1, keepdim = True)[1] # (차원 수, keepdim)

            # view_as() 로 예측값과 정답 순서 맞춰주고
            # ep()으로 같으면 1, 틀리면 0로 채우고
            # sum() 을 통해 맞은 갯수 구하기
            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(f"[{epoch}] Test Loss: {test_loss:.4f}, Accuracy: {test_accuracy:.2f}%")

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./.data',
                  train = True,
                  download = True,
                  transform = transforms.Compose([
                      transforms.RandomHorizontalFlip(), # 학습데이터 수평뒤집기 -> 학습데이터 양 2배 됨.
                      transforms.ToTensor(),
                      transforms.Normalize((0.1307,), (0.3081,))
                  ])),
    batch_size = BATCH_SIZE, shuffle = True
)

test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./.data',
                  transform = transforms.Compose([
                      transforms.ToTensor(),
                      transforms.Normalize((0.1307,), (0.3081,))
                  ])),
    batch_size = BATCH_SIZE, shuffle = True
)

class Net(nn.Module):
    def __init__(self, dropout_p = 0.2):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(784, 256)
        self.fc2 = nn.Linear(256, 128)
        self.fc3 = nn.Linear(128, 10)

        # 드롭 아웃 비율을 결정하는 파라미터 추가
        self.dropout_p = dropout_p

    def forward(self, x):
        x = x.view(-1, 784)
        x = F.relu(self.fc1(x))

        # 드롭아웃 추가
        # dropout() 함수는 모델의 모드(학습모드/평가모드)에 따라 동작이 달라짐.
        # 학습모드에서만 드롭아웃하고, 평가모드에서는 모든 노드를 사용해야하기 때문.

        # model.train() , model.eval() 할 때마다 self.training 이 True/False 자동으로 바뀜.
        x = F.dropout(x, training = self.training,
                     p = self.dropout_p)

        x = F.relu(self.fc2(x))

        # 드롭아웃 추가
        x = F.dropout(x, training = self.training,
                     p = self.dropout_p)

        x = self.fc3(x)
        return x

model = Net(dropout_p = 0.2).to(DEVICE)