Data_Augmentation

• Scale
• Crop
• Flip
• Rotate (using PIL Transform )

!pip install torch torchvision

Requirement already satisfied: torch in /usr/local/lib/python3.6/dist-packages (1.1.0)
Requirement already satisfied: torchvision in /usr/local/lib/python3.6/dist-packages (0.3.0)
Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from torch) (1.16.4)
Requirement already satisfied: pillow>=4.1.1 in /usr/local/lib/python3.6/dist-packages (from torchvision) (4.3.0)
Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from torchvision) (1.12.0)
Requirement already satisfied: olefile in /usr/local/lib/python3.6/dist-packages (from pillow>=4.1.1->torchvision) (0.46)

1. Settings

1) Import required libraries

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.init as init
import torchvision.datasets as dset
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

from PIL import Image
import matplotlib.pyplot as plt
%matplotlib inline

2) Set hyperparameters

batch_size = 256
learning_rate = 0.0002
num_epoch = 10

2. Data

1) Download Data

mnist_train = dset.MNIST("./", train=True, 
                         transform = transforms.Compose([
                             transforms.Resize(34),                             # ¿ø·¡ 28x28ÀÎ À̹ÌÁö¸¦ 34x34·Î ´Ã¸³´Ï´Ù.
                             transforms.CenterCrop(28),                         # Áß¾Ó 28x28¸¦ »Ì¾Æ³À´Ï´Ù.
                             transforms.RandomHorizontalFlip(),                 # ·£´ýÇÏ°Ô Á¿ì¹ÝÀü ÇÕ´Ï´Ù.
                             transforms.Lambda(lambda x: x.rotate(90)),         # ¶÷´ÙÇÔ¼ö¸¦ ÀÌ¿ëÇØ 90µµ ȸÀüÇØÁÝ´Ï´Ù.
                             transforms.ToTensor(),                             # À̹ÌÁö¸¦ ÅÙ¼­·Î º¯ÇüÇÕ´Ï´Ù.
                         ]),
                         target_transform=None,
                         download=True)


mnist_test = dset.MNIST("./", train=False, transform=transforms.ToTensor(), target_transform=None, download=True)

2) Check Dataset

print(mnist_train.__getitem__(0)[0].size(), mnist_train.__len__())
mnist_test.__getitem__(0)[0].size(), mnist_test.__len__()

torch.Size([1, 28, 28]) 60000

(torch.Size([1, 28, 28]), 10000)

3) Set DataLoader

train_loader = torch.utils.data.DataLoader(mnist_train,batch_size=batch_size, shuffle=True,num_workers=2,drop_last=True)
test_loader = torch.utils.data.DataLoader(mnist_test,batch_size=batch_size, shuffle=False,num_workers=2,drop_last=True)

# À̹ÌÁö¸¦ º¸¸é ¾Ë¼ö ÀÖµíÀÌ augmentationÀ» µ¥ÀÌÅÍ¿¡ ¸Â°Ô ÇÏÁö ¾ÊÀ¸¸é ¸»µµ ¾ÈµÇ´Â°É ÇнÀÇÏ°Ô µË´Ï´Ù.
# 90µµ µ¹¸®°Å³ª Á¿ì¹ÝÀüÀ» ÇÔÀ¸·Î½á Àǹ̸¦ ÀÒ¾î¹ö¸®´Â °æ¿ìµµ Àֱ⠶§¹®¿¡ µ¥ÀÌÅÍ¿¡ ¸Â´Â augmentationÀ» ÇؾßÇÕ´Ï´Ù.

for idx,(img,label) in enumerate(train_loader):
  plt.imshow(img[0,0,...],cmap="gray")
  plt.show()
  if idx > 5:
    break

3. Model & Optimizer

1) CNN Model

class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()
        self.layer = nn.Sequential(
            nn.Conv2d(1,16,3,padding=1),  # 28 x 28
            nn.ReLU(),
            nn.Conv2d(16,32,3,padding=1), # 28 x 28
            nn.ReLU(),
            nn.MaxPool2d(2,2),            # 14 x 14
            nn.Conv2d(32,64,3,padding=1), # 14 x 14
            nn.ReLU(),
            nn.MaxPool2d(2,2)             #  7 x 7
        )
        self.fc_layer = nn.Sequential(
            nn.Linear(64*7*7,100),
            nn.ReLU(),
            nn.Linear(100,10)
        )       
        
    def forward(self,x):
        out = self.layer(x)
        out = out.view(batch_size,-1)
        out = self.fc_layer(out)
        return out

2) Loss func & Optimizer

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)

model = CNN().to(device)
loss_func = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

cuda:0

4. Train

for i in range(num_epoch):
    for j,[image,label] in enumerate(train_loader):
        x = image.to(device)
        y_= label.to(device)
        
        optimizer.zero_grad()
        output = model.forward(x)
        loss = loss_func(output,y_)
        loss.backward()
        optimizer.step()
        
    if i % 10 == 0:
        print(loss)          

tensor(2.3065, device='cuda:0', grad_fn=<NllLossBackward>)

#param_list = list(model.parameters())
#print(param_list)

5. Test

correct = 0
total = 0

with torch.no_grad():
  for image,label in test_loader:
      x = image.to(device)
      y_= label.to(device)

      output = model.forward(x)
      _,output_index = torch.max(output,1)

      total += label.size(0)
      correct += (output_index == y_).sum().float()

  print("Accuracy of Test Data: {}".format(100*correct/total))

Accuracy of Test Data: 10.927484512329102