Add Project 3

Author: Qiong-Hu

Project3/Classification.py

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*-
+"""
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/1N1S8ROzSKeUhb1tI_8LKG2r2CWjMz0sT
+"""
+
+import torch
+import torchvision
+import torchvision.transforms as transforms
+
+transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
+
+trainset = torchvision.datasets.CIFAR10(root='.', train = True, download = True, transform = transform)
+trainloader = torch.utils.data.DataLoader(trainset, batch_size = 4, shuffle = True, num_workers = 8)
+testset = torchvision.datasets.CIFAR10(root='.', train = False, download = True, transform = transform)
+testloader = torch.utils.data.DataLoader(testset, batch_size = 4, shuffle = False, num_workers = 8)
+
+classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+def imshow(img):
+    img = img/2+0.5   # Denormalize
+    npimg = img.numpy()
+    plt.imshow(np.transpose(npimg, (1, 2, 0)))
+    plt.show()
+
+# Get some random training images
+dataiter = iter(trainloader)
+images, labels = dataiter.next()
+
+# Show images
+imshow(torchvision.utils.make_grid(images))
+print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
+
+# Define a CNN
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Net(nn.Module):
+    def __init__(self):
+        super(Net, self).__init__()
+        self.pool = nn.MaxPool2d(2, 2)
+        self.conv1 = nn.Conv2d(3, 8, 3)
+        self.conv2 = nn.Conv2d(8, 32, 2)
+        self.conv3 = nn.Conv2d(32, 64, 2)
+        self.fc1 = nn.Linear(64*3*3, 256)
+        self.fc2 = nn.Linear(256, 84)
+        self.fc3 = nn.Linear(84, 10)
+        self.drop = nn.Dropout2d(p=0.5)
+    
+    def forward(self, x):
+        x = self.pool(F.relu(self.conv1(x)))
+        x = self.pool(F.relu(self.conv2(x)))
+        x = self.pool(F.relu(self.conv3(x)))
+        x = x.view(-1, 64*3*3)
+        x = self.drop(x)
+        x = F.relu(self.fc1(x))
+        x = self.drop(x)
+        x = F.relu(self.fc2(x))
+        x = self.drop(x)
+        x = self.fc3(x)
+        return x
+
+net = Net()
+
+# Define the loss function: classification cross-entropy loss
+# Define the SGD with momentum as optimizer
+import torch.optim as optim
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.SGD(net.parameters(), lr = 0.001, momentum = 0.9)
+
+# Train the network
+for epoch in range(50):
+    running_loss = 0.0
+    for i, data in enumerate(trainloader, 0):
+        # Get the inputs; data is a list of [inputs, labels]
+        inputs, labels = data
+
+        # Zero the parameter gradients
+        optimizer.zero_grad()
+
+        # Forward + backward + optimize
+        outputs = net(inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        if epoch==5:
+            optimizer = optim.SGD(net.parameters(), lr = 0.0001, momentum = 0.9)
+        elif epoch==20:
+            optimizer = optim.SGD(net.parameters(), lr = 0.00001, momentum = 0.9)
+        optimizer.step()
+
+        # Print statistics
+        running_loss += loss.item()
+        if i%2000 == 1999:    # Print every 2000 mini-patches
+            print('[%d, %5d] loss: %0.3f' %(epoch+1, i+1, running_loss/2000))
+            running_loss = 0.0
+
+print('Finished Training.')
+
+# Save the network
+## Don't forget to change the name of the PATH!!!
+# PATH = './cifar_net.pth'                          # default CNN structure
+# PATH = './cifar_net_epoch20.pth'                  # default CNN structure, epoch=20
+# PATH = './cifar_net_dropout_epoch20.pth'          # add dropout, epoch=20
+# PATH = './cifar_net_dropout2_epoch20.pth'         # less dropout, epoch=20
+# PATH = './cifar_net_dropout_6layer_epoch30.pth'   # 6 layers, epoch=30
+# PATH = './cifar_net_dropout_5layer_epoch20.pth'   # 5 layers, epoch=20, feature=32*5*5
+# PATH = './cifar_net_changed_rl.pth'               # rl=0.001 when epoch<5, =0.0001 when epoch>=5, no dropout, epoch=20
+PATH = './cifar_net_changed_rl_epoch50.pth'         # rl=0.001 (<5), 0.0001 (5-20), 0.00001 (>20), epoch=50 
+torch.save(net.state_dict(), PATH)
+
+# Reload the network
+net = Net()
+net.load_state_dict(torch.load(PATH))
+
+# Test the network on the test data
+dataiter = iter(testloader)
+images, labels = dataiter.next()
+
+# Show the test images
+imshow(torchvision.utils.make_grid(images))
+print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
+
+# Predicted results
+outputs = net(images)
+_, predicted = torch.max(outputs, 1)
+print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))
+
+# To see the performance of the network on the whole training dataset
+correct = 0
+total = 0
+with torch.no_grad():
+    for data in trainloader:
+        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 %d training images is: %0.2f %%' % (total, 100*correct/total))
+
+# To see the performance of the network on the whole test dataset
+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 %d test images is: %0.2f %%' % (total, 100*correct/total))
+
+# Performace of the network on each class
+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).squeeze()
+        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]))

Project3/HW3_report.pdf

@@ -0,0 +1,65 @@
+# Project 3: Image Classification using Convolutional Neural Networks (CNN)
+
+Main code: [Classification.py](Classification.py)
+
+Full report: [report.pdf](HW3_report.pdf)
+
+Python package used in implementation: PyTorch
+
+Image source: CIFAR-10 dataset
+
+<br>
+
+## Objectives
+
+To build a CNN to conduct a multi-class image classification task on the CIFAR-10 dataset using PyTorch.
+
+## Instructions
+
+1. Design a CNN such that
+    1. ReLU is the activation function
+    2. cross entropy loss is the loss function
+    3. only consists of convolutional layers and fully-connected layers
+    4. only contains 6 layers
+
+2. Evaluate the classification performance using model accuracy on training and testing set.
+
+## Results
+
+### CNN pipeline
+
+   Convolutional layer (in_channels = 3, out_channels = 8, kernel_size = 3)
+
+=> ReLu => Maxpool
+
+=> Convolutional layer (in_channels = 8, out_channels = 32, kernel_size = 2)
+
+=> ReLu => Maxpool
+
+=> Convolutional layer (in_channels = 32, out_channels = 64, kernel_size = 2)
+
+=> ReLu => Maxpool
+
+=> Fully-connected layer (in_channels = 64\*3\*3, out_channels = 256)
+
+=> ReLU
+
+=> Fully-connected layer (in_channels = 256, out_channels = 84)
+
+=> ReLU
+
+=> Fully-connected layer (in_channels = 84, out_channels = 10)
+
+### Evaluation
+
+Training loss history:
+
+<img src="img/training_loss_nodropout.jpg">
+
+Average model accuracy on the training set is: 98.38%
+
+Average model accuracy on the testing set is: 72.04%
+
+<br>
+
+Full report see: [report.pdf](HW3_report.pdf)

Project3/README.md

@@ -18,3 +18,11 @@
 - Implement these two algorithms for an image inpainting task, which aims to remove extra text content on an image
 - Evaluate quantitatively the reconstruction performance
 
+## [Project 3: Image Classification using Convolutional Neural Networks (CNN)](https://github.com/Qiong-Hu/Digital_Image_Processing/blob/master/Project3)
+
+### Content
+
+- Implement data augmentation methods when training a convolutional neural networks (CNN) on images
+- Design a CNN pipeline for multi-class image classification task with 6 layers, which is only consisted of convolutional layers and fully-connected layers
+- User rectified linear unit (ReLU) as the activation function and cross entropy loss as the loss function
+- Evaluate the classification performance