res34_imageClassification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "from __future__ import division\n",
    "\n",
    "import math\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "from torch.utils.data import random_split, DataLoader\n",
    "from torchvision import transforms\n",
    "from torchvision.datasets import CIFAR10\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "import requests\n",
    "from io import BytesIO\n",
    "from PIL import Image\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0)\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert torch.cuda.is_available(), 'GPU unavailable'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data_loaders():\n",
    "  loader_kwargs = {\n",
    "    'batch_size': 100,\n",
    "    'shuffle': True,\n",
    "    'num_workers': 4,\n",
    "    'pin_memory': True,\n",
    "    'drop_last': True,\n",
    "  }\n",
    "  \n",
    "  transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2470, 0.2435, 0.2616]),\n",
    "  ])\n",
    "  \n",
    "  CIFAR10_train = CIFAR10(root='.', train=True, transform=transform, download=True)\n",
    "  CIFAR10_test = CIFAR10(root='.', train=False, transform=transform, download=True)\n",
    "  \n",
    "  train_set, val_set = random_split(CIFAR10_train, [40000, 10000],\n",
    "                                    generator=torch.Generator().manual_seed(0))\n",
    "  \n",
    "  train_loader = DataLoader(train_set, **loader_kwargs)\n",
    "  val_loader = DataLoader(val_set, **loader_kwargs)\n",
    "  test_loader = DataLoader(CIFAR10_test, **loader_kwargs)\n",
    "  \n",
    "  return train_loader, val_loader, test_loader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Resnet34 Model**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#In this Part, resnet_block is a basic resnet block, we choose resnet, because we believe deeper layer may potentially maintain more features of the image and cause less overfitting than we thought.\n",
    "# RELU, ELU, and GELU are tested before final decision. The ELU function works much better than the other two.\n",
    "# p=0.2 is used in dropout layer because we have tested that p=0.1 gives the best result.\n",
    "\n",
    "class resnet_block(nn.Module):\n",
    "  def __init__(self, in_channels, out_channels, stride=1, downsample=None):\n",
    "    super(resnet_block, self).__init__()\n",
    "    self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)\n",
    "    self.bn1 = nn.BatchNorm2d(out_channels)\n",
    "    self.act = nn.ELU(inplace=True)\n",
    "    self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)\n",
    "    self.bn2 = nn.BatchNorm2d(out_channels)\n",
    "    self.downsample = downsample\n",
    "    self.dropout = nn.Dropout(p=0.1)\n",
    "\n",
    "  def forward(self, ipt):\n",
    "    residual = ipt\n",
    "    out = self.conv1(ipt)\n",
    "    out = self.bn1(out)\n",
    "    out = self.act(out)\n",
    "    out = self.dropout(out)\n",
    "        \n",
    "    out = self.conv2(out)\n",
    "    out = self.bn2(out)\n",
    "    if self.downsample is not None:\n",
    "      residual = self.downsample(ipt)\n",
    "    out += residual\n",
    "    out = self.act(out)\n",
    "    out = self.dropout(out)\n",
    "    return out\n",
    "\n",
    "\n",
    "class Net(nn.Module):\n",
    "  \n",
    "  def __init__(self):\n",
    "    super().__init__()\n",
    "    # Before implement resnet block\n",
    "    self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)\n",
    "    self.bn1 = nn.BatchNorm2d(64)\n",
    "    self.act = nn.ELU(inplace=True)\n",
    "    \n",
    "    # ResNet layers\n",
    "    downsample = None\n",
    "    # Perform 34-layer resnet, using number of resblock in each layer is [3,4,6,3]\n",
    "    # number of output channels in year layer should follow 64,128,256,512\n",
    "    # List of each type of resnet can be found in https://datagen.tech/guides/computer-vision/resnet-50/#:~:text=ResNet%2D50%20is%20a%2050,networks%20by%20stacking%20residual%20blocks.\n",
    "    self.layer1 = nn.Sequential(resnet_block(64, 64, stride=1, downsample=downsample),*[resnet_block(64, 64) for _ in range(1, 3)])\n",
    "    downsample = nn.Sequential(nn.Conv2d(64, 128, kernel_size=1, stride=2, bias=False),nn.BatchNorm2d(128))\n",
    "    self.layer2 = nn.Sequential(resnet_block(64, 128, stride=2, downsample=downsample),*[resnet_block(128, 128) for _ in range(1, 4)])\n",
    "    downsample = nn.Sequential(nn.Conv2d(128, 256, kernel_size=1, stride=2, bias=False),nn.BatchNorm2d(256))\n",
    "    self.layer3 = nn.Sequential(resnet_block(128, 256, stride=2, downsample=downsample),*[resnet_block(256, 256) for _ in range(1, 6)])\n",
    "    downsample = nn.Sequential(nn.Conv2d(256, 512, kernel_size=1, stride=2, bias=False),nn.BatchNorm2d(512))\n",
    "    self.layer4 = nn.Sequential(resnet_block(256, 512, stride=2, downsample=downsample),*[resnet_block(512, 512) for _ in range(1, 3)])\n",
    "    self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) # Global Average Pooling, typically use (1,1)\n",
    "    \n",
    "    self.fc = nn.Linear(512, 10)\n",
    "    self.dropout = nn.Dropout(p=0.1)\n",
    "  \n",
    "  \n",
    "  def forward(self, images, labels):\n",
    "    loss = None\n",
    "    y = self.conv1(images)\n",
    "    y = self.bn1(y)\n",
    "    y = self.act(y)\n",
    "    y = self.dropout(y)\n",
    "    y = self.layer1(y)\n",
    "    y = self.layer2(y)\n",
    "    y = self.layer3(y)\n",
    "    y = self.layer4(y)\n",
    "    y = self.avgpool(y)\n",
    "    y = y.view(y.size(0), -1)\n",
    "    y = self.fc(y)\n",
    "    loss = F.cross_entropy(y, labels)\n",
    "    return loss\n",
    "  \n",
    "  \n",
    "  def predict(self, images):\n",
    "    labels_pred = None\n",
    "    outp = self.conv1(images)\n",
    "    outp = self.bn1(outp)\n",
    "    outp = self.act(outp)\n",
    "    outp = self.dropout(outp)\n",
    "    outp = self.layer1(outp)\n",
    "    outp = self.layer2(outp)\n",
    "    outp = self.layer3(outp)\n",
    "    outp = self.layer4(outp)\n",
    "    outp = self.avgpool(outp)\n",
    "    outp = outp.view(outp.size(0), -1)\n",
    "    outp = self.fc(outp)\n",
    "    _, labels_pred = torch.max(outp, 1)\n",
    "    # END OF YOUR CODE\n",
    "    return labels_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Evaluation**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_acc(model, data_loader):\n",
    "  \n",
    "  with torch.no_grad():\n",
    "    model.eval()\n",
    "    \n",
    "    total = 0\n",
    "    correct = 0\n",
    "    \n",
    "    for (images, labels) in data_loader:\n",
    "      images = images.cuda()\n",
    "      labels = labels.cuda()\n",
    "      \n",
    "      labels_pred = model.predict(images)\n",
    "      \n",
    "      total += labels.shape[0]\n",
    "      correct += (labels_pred == labels).sum().item()\n",
    "    \n",
    "    acc = 100 * correct / total\n",
    "  \n",
    "  return acc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Training**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "Train Epoch:   0 \t Loss: 2.357387 \t Val Acc: 10.820000\n",
      "Train Epoch:   1 \t Loss: 1.282456 \t Val Acc: 57.290000\n",
      "Train Epoch:   2 \t Loss: 1.129779 \t Val Acc: 65.310000\n",
      "Train Epoch:   3 \t Loss: 0.896304 \t Val Acc: 70.440000\n",
      "Train Epoch:   4 \t Loss: 0.690156 \t Val Acc: 75.390000\n",
      "Train Epoch:   5 \t Loss: 0.620792 \t Val Acc: 75.410000\n",
      "Train Epoch:   6 \t Loss: 0.440290 \t Val Acc: 78.330000\n",
      "Train Epoch:   7 \t Loss: 0.535518 \t Val Acc: 79.360000\n",
      "Train Epoch:   8 \t Loss: 0.258452 \t Val Acc: 79.810000\n",
      "Train Epoch:   9 \t Loss: 0.413869 \t Val Acc: 81.110000\n",
      "Train Epoch:  10 \t Loss: 0.312262 \t Val Acc: 81.240000\n",
      "Train Epoch:  11 \t Loss: 0.362607 \t Val Acc: 82.250000\n",
      "Train Epoch:  12 \t Loss: 0.382700 \t Val Acc: 82.270000\n",
      "Train Epoch:  13 \t Loss: 0.311038 \t Val Acc: 83.340000\n",
      "Train Epoch:  14 \t Loss: 0.216858 \t Val Acc: 83.730000\n",
      "Train Epoch:  15 \t Loss: 0.283425 \t Val Acc: 84.290000\n",
      "Train Epoch:  16 \t Loss: 0.221569 \t Val Acc: 84.240000\n",
      "Train Epoch:  17 \t Loss: 0.192640 \t Val Acc: 84.770000\n",
      "Train Epoch:  18 \t Loss: 0.222225 \t Val Acc: 84.550000\n",
      "Train Epoch:  19 \t Loss: 0.334843 \t Val Acc: 85.080000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_loader, val_loader, test_loader = get_data_loaders()\n",
    "\n",
    "torch.manual_seed(0)\n",
    "model = Net()\n",
    "model = model.cuda()\n",
    "\n",
    "num_epochs = 20\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.0001)  # TODO: choose an optimizer\n",
    "\n",
    "loss_history = []\n",
    "for epoch in range(num_epochs):\n",
    "  val_acc = eval_acc(model, val_loader)\n",
    "  \n",
    "  model.train()\n",
    "  \n",
    "  for batch, (images, labels) in enumerate(train_loader):\n",
    "    images = images.cuda()\n",
    "    labels = labels.cuda()\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    loss = model(images, labels)\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    with torch.no_grad():\n",
    "      loss_history.append(loss.item())\n",
    "      if batch == 0:\n",
    "        print('Train Epoch: {:3} \\t Loss: {:F} \\t Val Acc: {:F}'.format(\n",
    "          epoch, loss.item(), val_acc))\n",
    "\n",
    "with torch.no_grad():\n",
    "  plt.plot(loss_history, 'o')\n",
    "  plt.xlabel('Iteration number')\n",
    "  plt.ylabel('Loss value')\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**result in 20 iteration**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy: 96.7525\n",
      "Validation Accuracy: 84.96\n",
      "Test Accuracy: 85.03\n"
     ]
    }
   ],
   "source": [
    "train_acc = eval_acc(model, train_loader)\n",
    "print('Training Accuracy:', train_acc)\n",
    "val_acc = eval_acc(model, val_loader)\n",
    "print('Validation Accuracy:', val_acc)\n",
    "test_acc = eval_acc(model, test_loader)\n",
    "print('Test Accuracy:', test_acc)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}