CNN_approach.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import torch \n",
    "import torch.nn.functional as F\n",
    "import torch.nn as nn\n",
    "from PIL import Image\n",
    "from sklearn.preprocessing import LabelEncoder, OneHotEncoder\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader, random_split\n",
    "from sklearn.metrics import ConfusionMatrixDisplay, confusion_matrix\n",
    "\n",
    "import seaborn as sns\n",
    "sns.set_theme(style='whitegrid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = torch.load('datasets/gds_as_tensors/X_train.pt')\n",
    "y_train = torch.load('datasets/gds_as_tensors/y_train.pt')\n",
    "X_test = torch.load('datasets/gds_as_tensors/X_test.pt')\n",
    "y_test = torch.load('datasets/gds_as_tensors/y_test.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = X_train / 255.0\n",
    "X_test = X_test / 255.0\n",
    "y_train = y_train.squeeze(1).type(torch.LongTensor)\n",
    "y_test = y_test.squeeze(1).type(torch.LongTensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        # 1 input image channel, 6 output channels, 5x5 square convolution\n",
    "        # kernel\n",
    "        self.conv1 = nn.Conv2d(1, 6, 5)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
    "        # an affine operation: y = Wx + b\n",
    "        self.fc1 = nn.Linear(16 * 4 * 4, 120)  # 5*5 from image dimension\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 16)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Max pooling over a (2, 2) window\n",
    "        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))\n",
    "        # If the size is a square, you can specify with a single number\n",
    "        x = F.max_pool2d(F.relu(self.conv2(x)), 2)\n",
    "        x = torch.flatten(x, 1) # flatten all dimensions except the batch dimension\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(X, y, model, device, optimizer, criterion, i):\n",
    "    '''\n",
    "    Trains the model for an epoch and optimizes it.\n",
    "    model: The model to train. Should already be in correct device.\n",
    "    device: 'cuda' or 'cpu'.\n",
    "    train_loader: dataloader for training samples.\n",
    "    optimizer: optimizer to use for model parameter updates.\n",
    "    criterion: used to compute loss for prediction and target \n",
    "    epoch: Current epoch to train for.\n",
    "    batch_size: Batch size to be used.\n",
    "    '''\n",
    "    \n",
    "    # Set model to train mode before each epoch\n",
    "    model.train()\n",
    "    \n",
    "    # Empty list to store losses \n",
    "    \n",
    "    predictions = []\n",
    "    correct = 0\n",
    "    \n",
    "    \n",
    "    \n",
    "        \n",
    "    optimizer.zero_grad()    \n",
    "    # Do forward pass for current set of data\n",
    "    output = model(X)\n",
    "        \n",
    "    pred = output.argmax(dim=1, keepdim=True)\n",
    "    \n",
    "    \n",
    "    loss = criterion(output, y)\n",
    "        \n",
    "    # Computes gradient based on final loss\n",
    "    loss.backward()\n",
    "        \n",
    "    \n",
    "        \n",
    "    # Optimize model parameters based on learning rate and gradient \n",
    "    optimizer.step()\n",
    "        \n",
    "    # Get predicted index by selecting maximum log-probability\n",
    "    correct = pred.eq(y.data.view_as(pred)).sum()\n",
    "    predictions.append(pred)\n",
    "    train_loss = loss.item()\n",
    "    train_acc = correct / len(y)\n",
    "    \n",
    "    if i % 50 == 0:\n",
    "        print('Train set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
    "            loss.item(), correct, len(y),\n",
    "            100. * correct / len(y)))\n",
    "    \n",
    "    return train_loss, train_acc, predictions\n",
    "    \n",
    "\n",
    "\n",
    "def test(X, y, model, device, criterion, i):\n",
    "    '''\n",
    "    Tests the model.\n",
    "    model: The model to train. Should already be in correct device.\n",
    "    device: 'cuda' or 'cpu'.\n",
    "    test_loader: dataloader for test samples.\n",
    "    '''\n",
    "    \n",
    "    # Set model to eval mode to notify all layers.\n",
    "    model.eval()\n",
    "    \n",
    "    losses = []\n",
    "    correct = 0\n",
    "    predictions = []\n",
    "    \n",
    "    # Set torch.no_grad() to disable gradient computation and backpropagation\n",
    "    with torch.no_grad():\n",
    "        \n",
    "            \n",
    "\n",
    "        # Predict for data by doing forward pass\n",
    "        output = model(X)\n",
    "        # Compute loss based on same criterion as training \n",
    "        loss = criterion(output, y)\n",
    "            \n",
    "        # Append loss to overall test loss\n",
    "        losses.append(loss.item())\n",
    "        \n",
    "          \n",
    "        # Get predicted index by selecting maximum log-probability\n",
    "        pred = output.argmax(dim=1, keepdim=True)\n",
    "           \n",
    "        # =======================   ===============================================\n",
    "        # Count correct predictions overall#\n",
    "        predictions.append(pred)\n",
    "        \n",
    "        correct = pred.eq(y.data.view_as(pred)).sum()\n",
    "\n",
    "    test_loss = float(np.mean(losses))\n",
    "    accuracy = 100. * correct / len(y)\n",
    "    if i % 50 == 0:\n",
    "        print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
    "            test_loss, correct, len(y), accuracy))\n",
    "        \n",
    "    return test_loss, accuracy, predictions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_all_losses(train_l=None, test_l=None, train_ac=None, test_ac=None, title=None):\n",
    "    fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(8, 6), dpi=100)\n",
    "    \n",
    "    if title:\n",
    "        fig.suptitle(title)\n",
    "    if train_l:\n",
    "        axes[0][0].plot(train_l)\n",
    "        axes[0][0].set_title(\"Training Loss\")\n",
    "    if test_l:\n",
    "        axes[0][1].plot(test_l)\n",
    "        axes[0][1].set_title(\"Test Loss\")\n",
    "    if train_ac:\n",
    "        axes[1][0].plot(train_ac)\n",
    "        axes[1][0].set_title(\"Training Accuracy\")\n",
    "    if test_ac:\n",
    "        axes[1][1].plot(test_ac)\n",
    "        axes[1][1].set_title(\"Test Accuracy\")\n",
    "\n",
    "    plt.tight_layout()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_main():\n",
    "    # Check if cuda is available\n",
    "    use_cuda = torch.cuda.is_available()\n",
    "    \n",
    "    # Set proper device based onr cuda availability \n",
    "    device = torch.device(\"cpu\") #torch.device(\"cuda\" if use_cuda else \"cpu\") \n",
    "    print(\"Torch device selected: \", device)\n",
    "    \n",
    "    # Initialize the model and send to device \n",
    "    model = Net().to(device)\n",
    "\n",
    "    \n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    \n",
    "    # ======================================================================\n",
    "    # Define optimizer function.\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n",
    "        \n",
    "    \n",
    "    training_losses = []\n",
    "    test_losses = []\n",
    "    training_accuracies = []\n",
    "    testing_accuracies = []\n",
    "    y_pred_train = []\n",
    "    y_pred_test = []\n",
    "    \n",
    "    best_train_accuracy = 0.0\n",
    "    best_test_accuracy = 0.0\n",
    "    \n",
    "    # Run training for n_epochs specified in config \n",
    "    for epoch in range(1, 500):\n",
    "        train_loss, train_accuracy, y_pred_train = train(X_train, y_train, model, device,\n",
    "                                            optimizer, criterion, epoch)\n",
    "        test_loss, test_accuracy, y_pred_test = test(X_test, y_test, model, device, criterion, epoch)\n",
    "        \n",
    "        \n",
    "        training_losses.append(train_loss)\n",
    "        test_losses.append(test_loss)\n",
    "        training_accuracies.append(train_accuracy)\n",
    "        testing_accuracies.append(test_accuracy)\n",
    "        \n",
    "        if train_accuracy > best_train_accuracy:\n",
    "            best_train_accuracy = train_accuracy\n",
    "        if test_accuracy > best_test_accuracy:\n",
    "            best_test_accuracy = test_accuracy\n",
    "    \n",
    "    \n",
    "    print(\"best train accuracy is {:2.2f}\".format(best_train_accuracy))\n",
    "    print(\"best test accuracy is {:2.2f}\".format(best_test_accuracy))\n",
    "    \n",
    "    print(\"Training loss after training: {:2.2f}\".format(train_loss))\n",
    "    print(\"Test loss after training: {:2.2f}\".format(test_loss))\n",
    "\n",
    "\n",
    "    print(\"Training and evaluation finished\")\n",
    "    \n",
    "    plot_all_losses(training_losses, test_losses, training_accuracies, testing_accuracies)\n",
    "    \n",
    "    return y_pred_test, y_pred_train\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Torch device selected:  cpu\n",
      "Train set: Average loss: 0.1252, Accuracy: 3705/3840 (96%)\n",
      "\n",
      "\n",
      "Test set: Average loss: 0.1571, Accuracy: 919/960 (96%)\n",
      "\n",
      "Train set: Average loss: 0.0097, Accuracy: 3834/3840 (100%)\n",
      "\n",
      "\n",
      "Test set: Average loss: 0.0693, Accuracy: 945/960 (98%)\n",
      "\n",
      "Train set: Average loss: 0.0020, Accuracy: 3840/3840 (100%)\n",
      "\n",
      "\n",
      "Test set: Average loss: 0.0818, Accuracy: 944/960 (98%)\n",
      "\n",
      "Train set: Average loss: 0.0008, Accuracy: 3840/3840 (100%)\n",
      "\n",
      "\n",
      "Test set: Average loss: 0.0905, Accuracy: 944/960 (98%)\n",
      "\n",
      "Train set: Average loss: 0.0004, Accuracy: 3840/3840 (100%)\n",
      "\n",
      "\n",
      "Test set: Average loss: 0.0956, Accuracy: 946/960 (99%)\n",
      "\n",
      "Train set: Average loss: 0.0003, Accuracy: 3840/3840 (100%)\n",
      "\n",
      "\n",
      "Test set: Average loss: 0.1015, Accuracy: 944/960 (98%)\n",
      "\n",
      "Train set: Average loss: 0.0002, Accuracy: 3840/3840 (100%)\n",
      "\n",
      "\n",
      "Test set: Average loss: 0.1048, Accuracy: 943/960 (98%)\n",
      "\n",
      "Train set: Average loss: 0.0001, Accuracy: 3840/3840 (100%)\n",
      "\n",
      "\n",
      "Test set: Average loss: 0.1080, Accuracy: 943/960 (98%)\n",
      "\n",
      "Train set: Average loss: 0.0001, Accuracy: 3840/3840 (100%)\n",
      "\n",
      "\n",
      "Test set: Average loss: 0.1112, Accuracy: 943/960 (98%)\n",
      "\n",
      "best train accuracy is 1.00\n",
      "best test accuracy is 98.54\n",
      "Training loss after training: 0.00\n",
      "Test loss after training: 0.11\n",
      "Training and evaluation finished\n",
      "156.79699670000002\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import time\n",
    "time_start = time.perf_counter()\n",
    "y_pred_test, y_pred_train = run_main()\n",
    "time_end = time.perf_counter()\n",
    "time_difference = time_end - time_start\n",
    "print(time_difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = y_pred_test[0].numpy()\n",
    "y_test = y_test.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-0.5, 15.5, 15.5, -0.5)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm = confusion_matrix(y_test, y_pred)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm)\n",
    "fig, ax = plt.subplots(figsize=(10,10), dpi=100)\n",
    "disp.plot(ax=ax)\n",
    "plt.axis('off')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "115b0fe3c69e1b3e92d19ec07fb6c0c7f63d0deec3bf9831f92d60b7c8ef1267"
  },
  "kernelspec": {
   "display_name": "Python 3.9.7 64-bit (windows store)",
   "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.9.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}