CNN_classifier.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "CNN_classifier.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6BLQnn8gAKxH",
        "colab_type": "text"
      },
      "source": [
        "# Necessary Imports"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vssFyWDNQz-_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import numpy as np\n",
        "use_cuda=True\n",
        "from sklearn.model_selection import train_test_split\n",
        "import matplotlib.pyplot as plt\n",
        "torch.manual_seed(2)\n",
        "np.random.seed(2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IDL9AihfAQMj",
        "colab_type": "text"
      },
      "source": [
        "# Data Loading and Processing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jCw9RnLbdznU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "real_train=np.load(\"/content/drive/My Drive/CelebA/image_array_10000.npy\")\n",
        "fake_train=np.load(\"/content/drive/My Drive/CelebA/image_array_10000_fakes.npy\")\n",
        "\n",
        "if real_train.shape[1:]==(64, 64, 3):\n",
        "  array_real = np.transpose(real_train, (0, 1, 3, 2))\n",
        "  array_real = np.transpose(array_real, (0, 2, 1, 3))\n",
        "else:\n",
        "  array_real=real_train\n",
        "\n",
        "if fake_train.shape[1:]==(64, 64, 3):\n",
        "\n",
        "  array_fake = np.transpose(fake_train, (0, 1, 3, 2))\n",
        "  array_fake = np.transpose(array_fake, (0, 2, 1, 3))\n",
        "else:\n",
        "  array_fake=fake_train"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_-LnN1u4nUHS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train_x=np.concatenate([array_real, array_fake])\n",
        "train_y=np.concatenate([np.zeros(len(array_real)), np.ones(len(array_fake))])\n",
        "\n",
        "x_train, x_test, y_train, y_test = train_test_split(train_x, train_y, stratify=train_y, test_size=0.2, shuffle=True)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LnyXwBrfktwu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from torch.utils.data import Dataset, DataLoader\n",
        "from PIL import Image\n",
        "\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "\n",
        "class MyDataset(Dataset):\n",
        "    def __init__(self, data, targets, transform=None):\n",
        "        self.data = data\n",
        "        self.targets = torch.LongTensor(targets)\n",
        "        self.transform = transform\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        x = self.data[index]\n",
        "        y = self.targets[index]\n",
        "\n",
        "        if self.transform:\n",
        "            x = Image.fromarray(self.data[index].astype(np.uint8).transpose(1,2,0))\n",
        "            x = self.transform(x)\n",
        "\n",
        "        return x, y\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data)\n",
        "\n",
        "transform = transforms.Compose(\n",
        "    [transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(),  transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.25, 0.25, 0.25))])\n",
        "\n",
        "transform_norm = transforms.Compose(\n",
        "    [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.25, 0.25, 0.25))])\n",
        "\n",
        "dataset = MyDataset(x_train, y_train, transform=transform)\n",
        "dataloader = DataLoader(dataset, 50, shuffle=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ivgJBscEAXa2",
        "colab_type": "text"
      },
      "source": [
        "# Training and Validation Functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "txZewbdEeAlJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Main Training code\n",
        "\n",
        "#Train function returns the training data accuracy, dev data accuracy, and loss for each epoch. This was needed for plotting the graphs.\n",
        "\n",
        "def train(model ,optimiser, criterion, num_epochs, scheduler_present=False, load=False, save=False):\n",
        "  train_acc=[]\n",
        "  val_acc=[]\n",
        "  loss_data=[]\n",
        "  \n",
        "  start=0\n",
        "  \n",
        "  if load:\n",
        "    checkpoint = torch.load(PATH) #set Path here for loading data\n",
        "    model.load_state_dict(checkpoint['model_state_dict'])\n",
        "    optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
        "    start = checkpoint['epoch']\n",
        "    loss = checkpoint['loss']\n",
        "    model.train()\n",
        "\n",
        "  for epoch in range(start, num_epochs):\n",
        "\n",
        "    for local_X, local_Y in dataloader:\n",
        "      local_X, local_Y= local_X.cuda(), local_Y.cuda()\n",
        "      optimizer.zero_grad()\n",
        "\n",
        "      outputs=model(local_X)\n",
        "      loss=criterion(outputs, local_Y)\n",
        "      loss.backward()\n",
        "\n",
        "      optimizer.step()\n",
        "    \n",
        "    if scheduler_present:\n",
        "      scheduler.step()\n",
        "    \n",
        "    tr=model_accuracy(model, x_train, y_train, 50)\n",
        "    val=model_accuracy(model, x_test, y_test, 50)\n",
        "    \n",
        "    train_acc.append(tr)\n",
        "    val_acc.append(val)\n",
        "    loss_data.append(loss.item())\n",
        "\n",
        "    if epoch%10==0:\n",
        "      print(\"Epoch:\", epoch, loss.item(), \"Train Acc:\", tr, \"Val Acc:\", val)\n",
        "    \n",
        "\n",
        "    #Saving the Model (Current path in Google Drive)\n",
        "    \n",
        "    if save and epoch%50==0:\n",
        "      torch.save({'epoch': epoch,\n",
        "                  'model_state_dict': model.state_dict(),\n",
        "                  'optimizer_state_dict': optimizer.state_dict(),\n",
        "                  'loss': loss,}, \"/content/drive/My Drive/DL_CIFAR_\"+str(epoch)) #set path here for saving data to desired location\n",
        "  \n",
        "  return train_acc, val_acc, loss_data\n",
        "\n",
        "\n",
        "#Model Accuracy Calculator\n",
        "#Reference: https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html\n",
        "\n",
        "def model_accuracy(model, data_x, data_y, batch_size):\n",
        "\n",
        "  correct = 0\n",
        "  total = 0\n",
        "\n",
        "  dataset_check = MyDataset(data_x, data_y, transform=transform_norm)\n",
        "  dataloader_check = DataLoader(dataset_check, 50, shuffle=False)\n",
        "  with torch.no_grad():\n",
        "      for local_X, local_Y in dataloader_check:\n",
        "          local_X, local_Y= local_X.cuda(), local_Y.cuda()\n",
        "          outputs = model(local_X)\n",
        "          _, predicted = torch.max(outputs.data, 1)\n",
        "          total += local_Y.size(0)\n",
        "          correct += (predicted == local_Y).sum().item()\n",
        "\n",
        "  return 100 * correct / total\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eeyRDTZWAbJ6",
        "colab_type": "text"
      },
      "source": [
        "# Convolution Neural Network Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hm5jb4HJd7Dl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "class CNN_Model_2(torch.nn.Module):\n",
        "\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.conv1= torch.nn.Conv2d(3, 16, 7)\n",
        "    self.conv2= torch.nn.Conv2d(16, 16, 3)\n",
        "    self.pool= torch.nn.MaxPool2d(2,2)\n",
        "    self.drop= torch.nn.Dropout(p=0.25)\n",
        "    self.conv_batchnorm=torch.nn.BatchNorm2d(16)\n",
        "    self.linear1=nn.Linear(11664, 2)\n",
        "    \n",
        "\n",
        "  def forward(self, x):\n",
        "    x=self.pool(F.relu(self.conv_batchnorm(self.conv1(x))))\n",
        "    x=F.relu(self.conv_batchnorm(self.conv2(x)))\n",
        "    x=x.view(-1, 11664)\n",
        "\n",
        "    \n",
        "    x=self.drop(x)\n",
        "    x=(self.linear1(x))\n",
        "\n",
        "    return x"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zWoR8AjbAhR7",
        "colab_type": "text"
      },
      "source": [
        "# Training "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K1iKY6MGkL7v",
        "colab_type": "code",
        "outputId": "12bc38e8-fdc4-4a14-d68d-075504aaffd0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 104
        }
      },
      "source": [
        "\n",
        "#Run Model 2\n",
        "\n",
        "model=CNN_Model_2()\n",
        "model.cuda()\n",
        "\n",
        "criterion=nn.CrossEntropyLoss()\n",
        "optimizer=optim.SGD(model.parameters(), lr=0.1, weight_decay=0.0005) #regularisation l2\n",
        "scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)\n",
        "\n",
        "num_epochs=50\n",
        "\n",
        "scheduler_present=True\n",
        "\n",
        "#Loading and Saving Data (Needs drive Mounting)\n",
        "load_data=False\n",
        "save_data=False\n",
        "\n",
        "train_acc, val_acc, loss_data=train(model, optimizer, criterion, num_epochs, scheduler_present, load_data, save_data)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch: 0 0.0 Train Acc: 99.9375 Val Acc: 99.925\n",
            "Epoch: 10 0.0 Train Acc: 99.975 Val Acc: 99.95\n",
            "Epoch: 20 0.05615462362766266 Train Acc: 99.95 Val Acc: 99.975\n",
            "Epoch: 30 0.0 Train Acc: 99.9875 Val Acc: 100.0\n",
            "Epoch: 40 0.0 Train Acc: 99.9875 Val Acc: 99.975\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UFYRZJEWkccD",
        "colab_type": "text"
      },
      "source": [
        "# Evaluation on New Test Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O9cj1UzPNYOo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Load Data\n",
        "nvidia_fakes = np.load('/content/drive/My Drive/CelebA/image_fake_array_10000.npy')\n",
        "real_images = np.load('/content/drive/My Drive/CelebA/image_array_20000.npy')[:10000]\n",
        "\n",
        "if nvidia_fakes.shape[1:]==(64, 64, 3):\n",
        "  nvidia_fake_array = np.transpose(nvidia_fakes, (0, 1, 3, 2))\n",
        "  nvidia_fake_array = np.transpose(nvidia_fake_array, (0, 2, 1, 3))\n",
        "else:\n",
        "  nvidia_fake_array=nvidia_fakes\n",
        "\n",
        "if real_images.shape[1:]==(64, 64, 3):\n",
        "  real_images_array = np.transpose(real_images, (0, 1, 3, 2))\n",
        "  real_images_array = np.transpose(real_images_array, (0, 2, 1, 3))\n",
        "else:\n",
        "  real_images_array=real_images\n",
        "\n",
        "#Create a mixture of real and Nvidia Fakes\n",
        "\n",
        "test_x=np.concatenate([nvidia_fake_array, real_images_array])\n",
        "test_y=np.concatenate([np.ones(len(nvidia_fake_array)), np.zeros(len(real_images_array))])\n",
        "\n",
        "#Create a dataloader\n",
        "dataset_test=MyDataset(x_test, y_test, transform=transform_norm)\n",
        "dataloader_test=torch.utils.data.DataLoader(dataset_test, 50, shuffle=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X5Zj_oFANUjS",
        "colab_type": "code",
        "outputId": "1ef34017-fe4e-4a91-de5d-9327d4da0f5e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "#Check Accuracy\n",
        "model_accuracy(model, x_test, y_test, 50)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "45.3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U8d7c_HsAml4",
        "colab_type": "text"
      },
      "source": [
        "# Generate Plots"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RpraNuNHAfgL",
        "colab_type": "code",
        "outputId": "2426567c-391a-4a86-bd59-bf20f870f9c4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        }
      },
      "source": [
        "plt.title(\"Train vs Val Accuracy over CNN\")\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.ylabel(\"Accuracy\")\n",
        "plt.plot(range(len(tr_acc)), tr_acc, label=\"Training\")\n",
        "plt.plot(range(len(val_acc)), val_acc, label=\"Validation\")\n",
        "plt.legend();"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r53dpn3bL8EP",
        "colab_type": "code",
        "outputId": "caf78b3a-093a-4b82-bbe9-8d1430eabc6c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        }
      },
      "source": [
        "plt.title(\"Loss plot of Network\")\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.plot(range(len(loss)), loss, label='Loss');\n",
        "plt.legend();"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}