HW0Phase1AndPhase2Notebook.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zoAmRych4zjz"
      },
      "source": [
        "# RBE/CS549 Fall 2022: Computer Vision\n",
        "## Homework 0: Alohomora\n",
        "\n",
        "Author(s): \n",
        "Prof. Nitin J. Sanket (nsanket@wpi.edu), Lening Li (lli4@wpi.edu), Gejji, Vaishnavi Vivek (vgejji@wpi.edu)\n",
        "\n",
        "Robotics Engineering Department,\n",
        "\n",
        "Worcester Polytechnic Institute\n",
        "\n",
        "Code adapted from CMSC733 at the University of Maryland, College Park."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "## Phase 1\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "_OTbKmZc84z9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Get the BSDS500 dataset"
      ],
      "metadata": {
        "id": "tShNtcK9syo_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!wget https://raw.githubusercontent.com/leelening/rbe549/main/hw0/BSDS500.tar.xz\n",
        "!tar -xvf BSDS500.tar.xz\n",
        "!mv BSDS500/ /content/data/"
      ],
      "metadata": {
        "id": "6poCzkgco7sv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!wget https://raw.githubusercontent.com/leelening/rbe549/main/hw0/TxtFiles.tar.xz\n",
        "!tar -xvf TxtFiles.tar.xz\n",
        "!mv TxtFiles/ /content/data/"
      ],
      "metadata": {
        "id": "6FH307bN0MDt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lak3Alk44zj1"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import cv2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mN-AX2a04zj2"
      },
      "source": [
        "1. Generate Difference of Gaussian Filter Bank: (DoG)\n",
        "2. Display all the filters in this filter bank and save image as DoG.png,\n",
        "3. use command \"cv2.imwrite(...)\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UEpnMgO64zj3"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W9sMEggi4zj3"
      },
      "source": [
        "\n",
        "1. Generate Leung-Malik Filter Bank: (LM)\n",
        "2. Display all the filters in this filter bank and save image as LM.png,\n",
        "3. use command \"cv2.imwrite(...)\"\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K_ihdTUc4zj3"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iWPCb37t4zj3"
      },
      "source": [
        "1. Generate Gabor Filter Bank: (Gabor)\n",
        "2. Display all the filters in this filter bank and save image as Gabor.png,\n",
        "3. use command \"cv2.imwrite(...)\"\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "N3RUEhBJ4zj4"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VhZSwN8W4zj4"
      },
      "source": [
        "1. Generate Half-disk masks\n",
        "2. Display all the Half-disk masks and save image as HDMasks.png,\n",
        "3. use command \"cv2.imwrite(...)\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H43aTHdD4zj4"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VsO2z2ub4zj5"
      },
      "source": [
        "1. Generate Texton Map\n",
        "2. Filter image using oriented gaussian filter bank\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "C-jtngqU4zj5"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ifGTkHv84zj5"
      },
      "source": [
        "1. Generate texture ID's using K-means clustering\n",
        "2. Display texton map and save image as TextonMap_ImageName.png,\n",
        "3. use command \"cv2.imwrite('...)\"\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Uhd-eznB4zj5"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KhkWsyiV4zj6"
      },
      "source": [
        "1. Generate Texton Gradient (Tg)\n",
        "2. Perform Chi-square calculation on Texton Map\n",
        "3. Display Tg and save image as Tg_ImageName.png,\n",
        "4. use command \"cv2.imwrite(...)\"\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mXPbc8FE4zj6"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8vrXv0ff4zj6"
      },
      "source": [
        "1. Generate Brightness Map\n",
        "2. Perform brightness binning\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1_ND-sVC4zj6"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SKOitvW34zj6"
      },
      "source": [
        "1. Generate Brightness Gradient (Bg)\n",
        "2. Perform Chi-square calculation on Brightness Map\n",
        "3. Display Bg and save image as Bg_ImageName.png,\n",
        "4. use command \"cv2.imwrite(...)\"\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hCOD81PA4zj7"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NHJXA-HM4zj7"
      },
      "source": [
        "1. Generate Color Map\n",
        "2. Perform color binning or clustering\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0m2LGULC4zj7"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SO27XPii4zj7"
      },
      "source": [
        "\n",
        "\n",
        "\n",
        "1. Generate Color Gradient (Cg)\n",
        "2. Perform Chi-square calculation on Color Map\n",
        "3. Display Cg and save image as Cg_ImageName.png,\n",
        "4. use command \"cv2.imwrite(...)\"\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t_BnNy7s4zj7"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nmy__th24zj7"
      },
      "source": [
        "\n",
        "1. Read Sobel Baseline\n",
        "2. use command \"cv2.imread(...)\"\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vapObHsb4zj7"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nMm0qhf-4zj8"
      },
      "source": [
        "\n",
        "\n",
        "\n",
        "1. Read Canny Baseline\n",
        "2. use command \"cv2.imread(...)\"\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9ZcgUAqK4zj8"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y1Ut3_c74zj8"
      },
      "source": [
        "\n",
        "\n",
        "1. Combine responses to get pb-lite output\n",
        "2. Display PbLite and save image as PbLite_ImageName.png\n",
        "3. use command \"cv2.imwrite(...)\"\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TpC2Z26r4zj8"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Phase 2"
      ],
      "metadata": {
        "id": "e2aeH7uq8qR7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Neural Network Construction"
      ],
      "metadata": {
        "id": "-4iWkcHsItB0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import numpy as np\n",
        "\n",
        "def accuracy(outputs, labels):\n",
        "    _, preds = torch.max(outputs, dim=1)\n",
        "    return torch.tensor(torch.sum(preds == labels).item() / len(preds))\n",
        "\n",
        "def loss_fn(out, labels):\n",
        "    ###############################################\n",
        "    # Fill your loss function of choice here!\n",
        "    ###############################################\n",
        "    loss = ...\n",
        "    return loss\n",
        "\n",
        "class ImageClassificationBase(nn.Module):\n",
        "    def training_step(self, batch):\n",
        "        images, labels = batch \n",
        "        out = self(images)                  # Generate predictions\n",
        "        loss = loss_fn(out, labels) # Calculate loss\n",
        "        return loss\n",
        "    \n",
        "    def validation_step(self, batch):\n",
        "        images, labels = batch \n",
        "        out = self(images)                    # Generate predictions\n",
        "        loss = loss_fn(out, labels)   # Calculate loss\n",
        "        acc = accuracy(out, labels)           # Calculate accuracy\n",
        "        return {'loss': loss.detach(), 'acc': acc}\n",
        "        \n",
        "    def validation_epoch_end(self, outputs):\n",
        "        batch_losses = [x['loss'] for x in outputs]\n",
        "        epoch_loss = torch.stack(batch_losses).mean()   # Combine losses\n",
        "        batch_accs = [x['acc'] for x in outputs]\n",
        "        epoch_acc = torch.stack(batch_accs).mean()      # Combine accuracies\n",
        "        return {'loss': epoch_loss.item(), 'acc': epoch_acc.item()}\n",
        "    \n",
        "    def epoch_end(self, epoch, result):\n",
        "        print(\"Epoch [{}], loss: {:.4f}, acc: {:.4f}\".format(epoch, result['loss'], result['acc']))\n",
        "\n",
        "\n",
        "\n",
        "class CIFAR10Model(ImageClassificationBase):\n",
        "  def __init__(self, InputSize, OutputSize):\n",
        "      \"\"\"\n",
        "      Inputs: \n",
        "      InputSize - Size of the Input\n",
        "      OutputSize - Size of the Output\n",
        "      \"\"\"\n",
        "      #############################\n",
        "      # Fill your network initialization of choice here!\n",
        "      #############################\n",
        "\n",
        "      \n",
        "  def forward(self, xb):\n",
        "      \"\"\"\n",
        "      Input:\n",
        "      xb is a MiniBatch of the current image\n",
        "      Outputs:\n",
        "      out - output of the network\n",
        "      \"\"\"\n",
        "      #############################\n",
        "      # Fill your network structure of choice here!\n",
        "      #############################\n",
        "     \n",
        "      return out\n",
        "      "
      ],
      "metadata": {
        "id": "jGCHa0pfIss-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import time\n",
        "import glob\n",
        "import os\n",
        "import sys\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "def tic():\n",
        "    \"\"\"\n",
        "    Function to start timer\n",
        "    Tries to mimic tic() toc() in MATLAB\n",
        "    \"\"\"\n",
        "    StartTime = time.time()\n",
        "    return StartTime\n",
        "\n",
        "def toc(StartTime):\n",
        "    \"\"\"\n",
        "    Function to stop timer\n",
        "    Tries to mimic tic() toc() in MATLAB\n",
        "    \"\"\"\n",
        "    return time.time() - StartTime\n",
        "\n",
        "def FindLatestModel(CheckPointPath):\n",
        "    \"\"\"\n",
        "    Finds Latest Model in CheckPointPath\n",
        "    Inputs:\n",
        "    CheckPointPath - Path where you have stored checkpoints\n",
        "    Outputs:\n",
        "    LatestFile - File Name of the latest checkpoint\n",
        "    \"\"\"\n",
        "    FileList = glob.glob(CheckPointPath + '*.ckpt.index') # * means all if need specific format then *.csv\n",
        "    LatestFile = max(FileList, key=os.path.getctime)\n",
        "    # Strip everything else except needed information\n",
        "    LatestFile = LatestFile.replace(CheckPointPath, '')\n",
        "    LatestFile = LatestFile.replace('.ckpt.index', '')\n",
        "    return LatestFile\n",
        "\n",
        "\n",
        "def convertToOneHot(vector, NumClasses):\n",
        "    \"\"\"\n",
        "    Inputs:\n",
        "    vector - vector of argmax indexes\n",
        "    NumClasses - Number of classes\n",
        "    \"\"\"\n",
        "    return np.equal.outer(vector, np.arange(NumClasses)).astype(np.float)"
      ],
      "metadata": {
        "id": "2SPck2oRdL5j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Train your neural network"
      ],
      "metadata": {
        "id": "A04kYJ_rJxEP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torchvision\n",
        "from torch.utils.tensorboard import SummaryWriter\n",
        "from torchvision import datasets, transforms\n",
        "from torch.optim import AdamW\n",
        "from torchvision.datasets import CIFAR10\n",
        "import cv2\n",
        "import sys\n",
        "import os\n",
        "import numpy as np\n",
        "import random\n",
        "import skimage\n",
        "import PIL\n",
        "import os\n",
        "import glob\n",
        "import random\n",
        "from skimage import data, exposure, img_as_float\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import time\n",
        "from torchvision.transforms import ToTensor\n",
        "import argparse\n",
        "import shutil\n",
        "import string\n",
        "from termcolor import colored, cprint\n",
        "import math as m\n",
        "from tqdm.notebook import tqdm\n",
        "\n",
        "def SetupAll(CheckPointPath):\n",
        "    \"\"\"\n",
        "    Inputs: \n",
        "    CheckPointPath - Path to save checkpoints/model\n",
        "    Outputs:\n",
        "    SaveCheckPoint - Save checkpoint every SaveCheckPoint iteration in every epoch, checkpoint saved automatically after every epoch\n",
        "    ImageSize - Size of the image\n",
        "    NumTrainSamples - length(Train)\n",
        "    TrainLabels - Labels corresponding to Train\n",
        "    NumClasses - Number of classes\n",
        "    \"\"\"\n",
        "    # Read and Setup Labels\n",
        "    LabelsPathTrain = '/content/data/TxtFiles/LabelsTrain.txt'\n",
        "    TrainLabels = ReadLabels(LabelsPathTrain)\n",
        "\n",
        "    # If CheckPointPath doesn't exist make the path\n",
        "    if(not (os.path.isdir(CheckPointPath))):\n",
        "       os.makedirs(CheckPointPath)\n",
        "        \n",
        "    # Save checkpoint every SaveCheckPoint iteration in every epoch, checkpoint saved automatically after every epoch\n",
        "    SaveCheckPoint = 100 \n",
        "    \n",
        "    # Image Input Shape\n",
        "    ImageSize = [32, 32, 3]\n",
        "    NumTrainSamples = len(TrainSet)\n",
        "\n",
        "    # Number of classes\n",
        "    NumClasses = 10\n",
        "\n",
        "    return SaveCheckPoint, ImageSize, NumTrainSamples, TrainLabels, NumClasses\n",
        "\n",
        "\n",
        "def ReadLabels(LabelsPathTrain):\n",
        "    if(not (os.path.isfile(LabelsPathTrain))):\n",
        "        print('ERROR: Train Labels do not exist in '+LabelsPathTrain)\n",
        "        sys.exit()\n",
        "    else:\n",
        "        TrainLabels = open(LabelsPathTrain, 'r')\n",
        "        TrainLabels = TrainLabels.read()\n",
        "        TrainLabels = map(float, TrainLabels.split())\n",
        "\n",
        "    return TrainLabels\n",
        "    \n",
        "\n",
        "def ReadDirNames(ReadPath):\n",
        "    \"\"\"\n",
        "    Inputs: \n",
        "    ReadPath is the path of the file you want to read\n",
        "    Outputs:\n",
        "    DirNames is the data loaded from /content/data/TxtFiles/DirNames.txt which has full path to all image files without extension\n",
        "    \"\"\"\n",
        "    # Read text files\n",
        "    DirNames = open(ReadPath, 'r')\n",
        "    DirNames = DirNames.read()\n",
        "    DirNames = DirNames.split()\n",
        "    return DirNames\n",
        "\n",
        "    \n",
        "def GenerateBatch(TrainSet, TrainLabels, ImageSize, MiniBatchSize):\n",
        "    \"\"\"\n",
        "    Inputs: \n",
        "    TrainSet - Variable with Subfolder paths to train files\n",
        "    NOTE that Train can be replaced by Val/Test for generating batch corresponding to validation (held-out testing in this case)/testing\n",
        "    TrainLabels - Labels corresponding to Train\n",
        "    NOTE that TrainLabels can be replaced by Val/TestLabels for generating batch corresponding to validation (held-out testing in this case)/testing\n",
        "    ImageSize is the Size of the Image\n",
        "    MiniBatchSize is the size of the MiniBatch\n",
        "   \n",
        "    Outputs:\n",
        "    I1Batch - Batch of images\n",
        "    LabelBatch - Batch of one-hot encoded labels \n",
        "    \"\"\"\n",
        "    I1Batch = []\n",
        "    LabelBatch = []\n",
        "    \n",
        "    ImageNum = 0\n",
        "    while ImageNum < MiniBatchSize:\n",
        "        # Generate random image\n",
        "        RandIdx = random.randint(0, len(TrainSet)-1)\n",
        "        \n",
        "        ImageNum += 1\n",
        "    \t\n",
        "    \t  ##########################################################\n",
        "    \t  # Add any standardization or data augmentation here!\n",
        "    \t  ##########################################################\n",
        "\n",
        "        I1, Label = TrainSet[RandIdx]\n",
        "\n",
        "        # Append All Images and Mask\n",
        "        I1Batch.append(I1)\n",
        "        LabelBatch.append(torch.tensor(Label))\n",
        "        \n",
        "    return torch.stack(I1Batch), torch.stack(LabelBatch)\n",
        "\n",
        "\n",
        "def PrettyPrint(NumEpochs, DivTrain, MiniBatchSize, NumTrainSamples, LatestFile):\n",
        "    \"\"\"\n",
        "    Prints all stats with all arguments\n",
        "    \"\"\"\n",
        "    print('Number of Epochs Training will run for ' + str(NumEpochs))\n",
        "    print('Factor of reduction in training data is ' + str(DivTrain))\n",
        "    print('Mini Batch Size ' + str(MiniBatchSize))\n",
        "    print('Number of Training Images ' + str(NumTrainSamples))\n",
        "    if LatestFile is not None:\n",
        "        print('Loading latest checkpoint with the name ' + LatestFile)              \n",
        "\n",
        "def TrainOperation(TrainLabels, NumTrainSamples, ImageSize,\n",
        "                   NumEpochs, MiniBatchSize, SaveCheckPoint, CheckPointPath,\n",
        "                   DivTrain, LatestFile, TrainSet, LogsPath):\n",
        "    \"\"\"\n",
        "    Inputs: \n",
        "    TrainLabels - Labels corresponding to Train/Test\n",
        "    NumTrainSamples - length(Train)\n",
        "    ImageSize - Size of the image\n",
        "    NumEpochs - Number of passes through the Train data\n",
        "    MiniBatchSize is the size of the MiniBatch\n",
        "    SaveCheckPoint - Save checkpoint every SaveCheckPoint iteration in every epoch, checkpoint saved automatically after every epoch\n",
        "    CheckPointPath - Path to save checkpoints/model\n",
        "    DivTrain - Divide the data by this number for Epoch calculation, use if you have a lot of dataor for debugging code\n",
        "    LatestFile - Latest checkpointfile to continue training\n",
        "    TrainSet - The training dataset\n",
        "    LogsPath - Path to save Tensorboard Logs\n",
        "    Outputs:\n",
        "    Saves Trained network in CheckPointPath and Logs to LogsPath\n",
        "    \"\"\"\n",
        "    # Initialize the model\n",
        "    model = CIFAR10Model(InputSize=3*32*32,OutputSize=10) \n",
        "    ###############################################\n",
        "    # Fill your optimizer of choice here!\n",
        "    ###############################################\n",
        "    Optimizer = ...\n",
        "\n",
        "    # Tensorboard\n",
        "    # Create a summary to monitor loss tensor\n",
        "    Writer = SummaryWriter(LogsPath)\n",
        "\n",
        "    if LatestFile is not None:\n",
        "        CheckPoint = torch.load(CheckPointPath + LatestFile + '.ckpt')\n",
        "        # Extract only numbers from the name\n",
        "        StartEpoch = int(''.join(c for c in LatestFile.split('a')[0] if c.isdigit()))\n",
        "        model.load_state_dict(CheckPoint['model_state_dict'])\n",
        "        print('Loaded latest checkpoint with the name ' + LatestFile + '....')\n",
        "    else:\n",
        "        StartEpoch = 0\n",
        "        print('New model initialized....')\n",
        "        \n",
        "    for Epochs in tqdm(range(StartEpoch, NumEpochs)):\n",
        "        NumIterationsPerEpoch = int(NumTrainSamples/MiniBatchSize/DivTrain)\n",
        "        for PerEpochCounter in tqdm(range(NumIterationsPerEpoch)):\n",
        "            Batch = GenerateBatch(TrainSet, TrainLabels, ImageSize, MiniBatchSize)\n",
        "            \n",
        "            # Predict output with forward pass\n",
        "            LossThisBatch = model.training_step(Batch)\n",
        "\n",
        "            Optimizer.zero_grad()\n",
        "            LossThisBatch.backward()\n",
        "            Optimizer.step()\n",
        "            \n",
        "            # Save checkpoint every some SaveCheckPoint's iterations\n",
        "            if PerEpochCounter % SaveCheckPoint == 0:\n",
        "                # Save the Model learnt in this epoch\n",
        "                SaveName =  CheckPointPath + str(Epochs) + 'a' + str(PerEpochCounter) + 'model.ckpt'\n",
        "                \n",
        "                torch.save({'epoch': Epochs,'model_state_dict': model.state_dict(),'optimizer_state_dict': Optimizer.state_dict(),'loss': LossThisBatch}, SaveName)\n",
        "                print('\\n' + SaveName + ' Model Saved...')\n",
        "\n",
        "            result = model.validation_step(Batch)\n",
        "            model.epoch_end(Epochs*NumIterationsPerEpoch + PerEpochCounter, result)\n",
        "            # Tensorboard\n",
        "            Writer.add_scalar('LossEveryIter', result[\"loss\"], Epochs*NumIterationsPerEpoch + PerEpochCounter)\n",
        "            Writer.add_scalar('Accuracy', result[\"acc\"], Epochs*NumIterationsPerEpoch + PerEpochCounter)\n",
        "            # If you don't flush the tensorboard doesn't update until a lot of iterations!\n",
        "            Writer.flush()\n",
        "\n",
        "        # Save model every epoch\n",
        "        SaveName = CheckPointPath + str(Epochs) + 'model.ckpt'\n",
        "        torch.save({'epoch': Epochs,'model_state_dict': model.state_dict(),'optimizer_state_dict': Optimizer.state_dict(),'loss': LossThisBatch}, SaveName)\n",
        "        print('\\n' + SaveName + ' Model Saved...')\n",
        "        \n",
        "\n",
        "\n",
        "# Default Hyperparameters\n",
        "NumEpochs = 50\n",
        "TrainSet = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
        "                                        download=True, transform=ToTensor())\n",
        "DivTrain = 1.0\n",
        "MiniBatchSize = 1\n",
        "LoadCheckPoint = 0\n",
        "CheckPointPath = \"/content/Checkpoints/\"\n",
        "LogsPath = \"/content/Logs\"\n",
        "\n",
        "# Setup all needed parameters including file reading\n",
        "SaveCheckPoint, ImageSize, NumTrainSamples, TrainLabels, NumClasses = SetupAll(CheckPointPath)\n",
        "\n",
        "# Find Latest Checkpoint File\n",
        "if LoadCheckPoint==1:\n",
        "    LatestFile = FindLatestModel(CheckPointPath)\n",
        "else:\n",
        "    LatestFile = None\n",
        "\n",
        "# Pretty print stats\n",
        "PrettyPrint(NumEpochs, DivTrain, MiniBatchSize, NumTrainSamples, LatestFile)\n",
        "\n",
        "TrainOperation(TrainLabels, NumTrainSamples, ImageSize,\n",
        "                NumEpochs, MiniBatchSize, SaveCheckPoint, CheckPointPath,\n",
        "                DivTrain, LatestFile, TrainSet, LogsPath)"
      ],
      "metadata": {
        "id": "hcGOFRE2JueB",
        "collapsed": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Test your neural network"
      ],
      "metadata": {
        "id": "HKVVLygOJ1kd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import cv2\n",
        "import os\n",
        "import sys\n",
        "import glob\n",
        "import random\n",
        "from skimage import data, exposure, img_as_float\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import time\n",
        "from torchvision.transforms import ToTensor\n",
        "import argparse\n",
        "import shutil\n",
        "import string\n",
        "import math as m\n",
        "from sklearn.metrics import confusion_matrix\n",
        "from tqdm.notebook import tqdm\n",
        "import torch\n",
        "\n",
        "def SetupAll():\n",
        "    \"\"\"\n",
        "    Outputs:\n",
        "    ImageSize - Size of the Image\n",
        "    \"\"\"   \n",
        "    # Image Input Shape\n",
        "    ImageSize = [32, 32, 3]\n",
        "\n",
        "    return ImageSize\n",
        "\n",
        "def StandardizeInputs(Img):\n",
        "    ##########################################################################\n",
        "    # Add any standardization or cropping/resizing if used in Training here!\n",
        "    ##########################################################################\n",
        "    return Img\n",
        "    \n",
        "def ReadImages(Img):\n",
        "    \"\"\"\n",
        "    Outputs:\n",
        "    I1Combined - I1 image after any standardization and/or cropping/resizing to ImageSize\n",
        "    I1 - Original I1 image for visualization purposes only\n",
        "    \"\"\"    \n",
        "    I1 = Img\n",
        "    \n",
        "    if(I1 is None):\n",
        "        # OpenCV returns empty list if image is not read! \n",
        "        print('ERROR: Image I1 cannot be read')\n",
        "        sys.exit()\n",
        "        \n",
        "    I1S = StandardizeInputs(np.float32(I1))\n",
        "\n",
        "    I1Combined = np.expand_dims(I1S, axis=0)\n",
        "\n",
        "    return I1Combined, I1\n",
        "                \n",
        "\n",
        "def TestOperation(ImageSize, ModelPath, TestSet, LabelsPathPred):\n",
        "    \"\"\"\n",
        "    Inputs: \n",
        "    ImageSize is the size of the image\n",
        "    ModelPath - Path to load trained model from\n",
        "    TestSet - The test dataset\n",
        "    LabelsPathPred - Path to save predictions\n",
        "    Outputs:\n",
        "    Predictions written to /content/data/TxtFiles/PredOut.txt\n",
        "    \"\"\"\n",
        "    # Predict output with forward pass, MiniBatchSize for Test is 1\n",
        "    model = CIFAR10Model(InputSize=3*32*32,OutputSize=10) \n",
        "    \n",
        "    CheckPoint = torch.load(ModelPath)\n",
        "    model.load_state_dict(CheckPoint['model_state_dict'])\n",
        "    print('Number of parameters in this model are %d ' % len(model.state_dict().items()))\n",
        "    \n",
        "    OutSaveT = open(LabelsPathPred, 'w')\n",
        "\n",
        "    for count in tqdm(range(len(TestSet))): \n",
        "        Img, Label = TestSet[count]\n",
        "        Img, ImgOrg = ReadImages(Img)\n",
        "        PredT = torch.argmax(model(Img)).item()\n",
        "\n",
        "        OutSaveT.write(str(PredT)+'\\n')\n",
        "    OutSaveT.close()\n",
        "\n",
        "def Accuracy(Pred, GT):\n",
        "    \"\"\"\n",
        "    Inputs: \n",
        "    Pred are the predicted labels\n",
        "    GT are the ground truth labels\n",
        "    Outputs:\n",
        "    Accuracy in percentage\n",
        "    \"\"\"\n",
        "    return (np.sum(np.array(Pred)==np.array(GT))*100.0/len(Pred))\n",
        "\n",
        "def ReadLabels(LabelsPathTest, LabelsPathPred):\n",
        "    if(not (os.path.isfile(LabelsPathTest))):\n",
        "        print('ERROR: Test Labels do not exist in '+LabelsPathTest)\n",
        "        sys.exit()\n",
        "    else:\n",
        "        LabelTest = open(LabelsPathTest, 'r')\n",
        "        LabelTest = LabelTest.read()\n",
        "        LabelTest = map(float, LabelTest.split())\n",
        "\n",
        "    if(not (os.path.isfile(LabelsPathPred))):\n",
        "        print('ERROR: Pred Labels do not exist in '+LabelsPathPred)\n",
        "        sys.exit()\n",
        "    else:\n",
        "        LabelPred = open(LabelsPathPred, 'r')\n",
        "        LabelPred = LabelPred.read()\n",
        "        LabelPred = map(float, LabelPred.split())\n",
        "        \n",
        "    return LabelTest, LabelPred\n",
        "\n",
        "def ConfusionMatrix(LabelsTrue, LabelsPred):\n",
        "    \"\"\"\n",
        "    LabelsTrue - True labels\n",
        "    LabelsPred - Predicted labels\n",
        "    \"\"\"\n",
        "\n",
        "    # Get the confusion matrix using sklearn.\n",
        "    LabelsTrue, LabelsPred = list(LabelsTrue), list(LabelsPred)\n",
        "    cm = confusion_matrix(y_true=LabelsTrue,  # True class for test-set.\n",
        "                          y_pred=LabelsPred)  # Predicted class.\n",
        "\n",
        "    # Print the confusion matrix as text.\n",
        "    for i in range(10):\n",
        "        print(str(cm[i, :]) + ' ({0})'.format(i))\n",
        "\n",
        "    # Print the class-numbers for easy reference.\n",
        "    class_numbers = [\" ({0})\".format(i) for i in range(10)]\n",
        "    print(\"\".join(class_numbers))\n",
        "\n",
        "    print('Accuracy: '+ str(Accuracy(LabelsPred, LabelsTrue)), '%')\n",
        "\n",
        "\n",
        "ModelPath = \"/content/Checkpoints/0a100model.ckpt\"\n",
        "LabelsPath = \"/content/data/TxtFiles/LabelsTest.txt\"\n",
        "TestSet = CIFAR10(root='data/', train=False)\n",
        "\n",
        "\n",
        "# Setup all needed parameters including file reading\n",
        "ImageSize = SetupAll()\n",
        "\n",
        "# Define PlaceHolder variables for Input and Predicted output\n",
        "LabelsPathPred = '/content/data/TxtFiles/PredOut.txt' # Path to save predicted labels\n",
        "\n",
        "TestOperation(ImageSize, ModelPath, TestSet, LabelsPathPred)\n",
        "\n",
        "# Plot Confusion Matrix\n",
        "LabelsTrue, LabelsPred = ReadLabels(LabelsPath, LabelsPathPred)\n",
        "ConfusionMatrix(LabelsTrue, LabelsPred) "
      ],
      "metadata": {
        "id": "lY-9nSVBJ282"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3.9.10 ('py39')",
      "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.9.10"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "2762af0fb94193cc770e2dbb99b50503f4c838317f9fa63bb8a7461c3d6fd280"
      }
    },
    "colab": {
      "name": "hw0_to_be_filled.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}