2_ALL-IDB classification using Autoencoder.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ALL-IDB Classification using Autoencoder\n",
    "\n",
    "### Dataset used:- [ALL-IDB:Acute Lymphoblastic Leukemia Image Database for Image Processing](https://homes.di.unimi.it/scotti/all/)\n",
    "Follow the instructions provided in the linked website to download the dataset. After downloading, extract the files to the current directory (same folder as your codes). Note that ALL_IDB2 is used in this  tutorial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import os\n",
    "import struct\n",
    "import torch\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torchvision\n",
    "from torch.autograd import Variable\n",
    "from torch.utils.data import TensorDataset,DataLoader\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import copy\n",
    "import time\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load Data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "Datapath = 'C:/Users/USER/Desktop/ALL_IDB2/ALL_IDB2/img/'\n",
    "listing = os.listdir(Datapath) \n",
    "random.shuffle(listing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ALL_IDB2 dataset has 260 images in total\n",
    "TrainImages = torch.FloatTensor(200,3072)\n",
    "TrainLabels = torch.LongTensor(200)\n",
    "TestImages = torch.FloatTensor(60,3072)\n",
    "TestLabels = torch.LongTensor(60)\n",
    "\n",
    "# First 200 images are used for training and the remaining 60 for testing\n",
    "img_no = 0\n",
    "for file in listing:\n",
    "    im=Image.open(Datapath + file)\n",
    "    im = im.resize((32,32))\n",
    "    im = np.array(im)\n",
    "    im = np.reshape(im, 32*32*3)\n",
    "    if img_no < 200:\n",
    "        TrainImages[img_no] = torch.from_numpy(im)\n",
    "        TrainLabels[img_no] = int(listing[img_no][6:7])\n",
    "    else:\n",
    "        TestImages[img_no - 200] = torch.from_numpy(im)\n",
    "        TestLabels[img_no - 200] = int(listing[img_no][6:7])\n",
    "    img_no = img_no + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([200, 3072])\n",
      "torch.Size([200])\n",
      "torch.Size([60, 3072])\n",
      "torch.Size([60])\n"
     ]
    }
   ],
   "source": [
    "print(TrainImages.size())\n",
    "print(TrainLabels.size())\n",
    "print(TestImages.size())\n",
    "print(TestLabels.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating pytorch dataset from the feature matices\n",
    "trainDataset = TensorDataset(TrainImages, TrainLabels)\n",
    "testDataset = TensorDataset(TestImages, TestLabels)\n",
    "# Creating dataloader\n",
    "BatchSize = 16\n",
    "trainLoader = DataLoader(trainDataset, batch_size=BatchSize, shuffle=True,num_workers=4, pin_memory=True)\n",
    "testLoader = DataLoader(testDataset, batch_size=BatchSize, shuffle=True,num_workers=4, pin_memory=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check availability of GPU\n",
    "use_gpu = torch.cuda.is_available()\n",
    "if use_gpu:\n",
    "    print('GPU is available!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the Autoencoder class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class autoencoder(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(autoencoder, self).__init__()\n",
    "        self.encoder = nn.Sequential(\n",
    "            nn.Linear(32*32*3, 1000),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(1000, 500),\n",
    "            nn.ReLU())\n",
    "#             nn.Linear(500, 100),\n",
    "#             nn.ReLU())\n",
    "        self.decoder = nn.Sequential(\n",
    "#             nn.Linear(100, 500),\n",
    "#             nn.ReLU(),\n",
    "            nn.Linear(500, 1000),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(1000, 32*32*3),\n",
    "            nn.ReLU())\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.encoder(x)\n",
    "        x = self.decoder(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "autoencoder(\n",
      "  (encoder): Sequential(\n",
      "    (0): Linear(in_features=3072, out_features=1000, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=1000, out_features=500, bias=True)\n",
      "    (3): ReLU()\n",
      "  )\n",
      "  (decoder): Sequential(\n",
      "    (0): Linear(in_features=500, out_features=1000, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=1000, out_features=3072, bias=True)\n",
      "    (3): ReLU()\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "net = autoencoder()\n",
    "print(net)\n",
    "\n",
    "if use_gpu:\n",
    "    net = net.cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define optimization technique:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.MSELoss() # Mean Squared Error \n",
    "optimizer = optim.Adam(net.parameters(), lr=1e-3)#, momentum=0.9) # Stochastic Gradient Descent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training the autoencoder for representaion learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At Iteration : 1 / 20  ;  Mean-Squared Error : 0.136298\n",
      "At Iteration : 2 / 20  ;  Mean-Squared Error : 0.078614\n",
      "At Iteration : 3 / 20  ;  Mean-Squared Error : 0.071790\n",
      "At Iteration : 4 / 20  ;  Mean-Squared Error : 0.070829\n",
      "At Iteration : 5 / 20  ;  Mean-Squared Error : 0.070107\n",
      "At Iteration : 6 / 20  ;  Mean-Squared Error : 0.070178\n",
      "At Iteration : 7 / 20  ;  Mean-Squared Error : 0.070239\n",
      "At Iteration : 8 / 20  ;  Mean-Squared Error : 0.070459\n",
      "At Iteration : 9 / 20  ;  Mean-Squared Error : 0.070559\n",
      "At Iteration : 10 / 20  ;  Mean-Squared Error : 0.070628\n",
      "At Iteration : 11 / 20  ;  Mean-Squared Error : 0.069923\n",
      "At Iteration : 12 / 20  ;  Mean-Squared Error : 0.070213\n",
      "At Iteration : 13 / 20  ;  Mean-Squared Error : 0.070274\n",
      "At Iteration : 14 / 20  ;  Mean-Squared Error : 0.070332\n",
      "At Iteration : 15 / 20  ;  Mean-Squared Error : 0.069774\n",
      "At Iteration : 16 / 20  ;  Mean-Squared Error : 0.069665\n",
      "At Iteration : 17 / 20  ;  Mean-Squared Error : 0.069080\n",
      "At Iteration : 18 / 20  ;  Mean-Squared Error : 0.068165\n",
      "At Iteration : 19 / 20  ;  Mean-Squared Error : 0.067816\n",
      "At Iteration : 20 / 20  ;  Mean-Squared Error : 0.067442\n"
     ]
    }
   ],
   "source": [
    "iterations = 20\n",
    "for epoch in range(iterations):   \n",
    "    net.train(True) # For training\n",
    "    runningLoss = 0\n",
    "    for batch_num,data in enumerate(trainLoader):\n",
    "        inputs,_  = data # Labels are not required \n",
    "        inputs = inputs/255\n",
    "        if use_gpu:\n",
    "            inputs = Variable(inputs).cuda()\n",
    "        else:\n",
    "            inputs = Variable(inputs)\n",
    "        # Initialize the gradients to zero\n",
    "        optimizer.zero_grad()\n",
    "        # Feed forward the input data through the network\n",
    "        outputs = net(inputs)\n",
    "        # Compute the error/loss\n",
    "        loss = criterion(outputs, inputs)\n",
    "        # Backpropagate the loss to compute gradients\n",
    "        loss.backward()\n",
    "        # Update model parameters\n",
    "        optimizer.step()\n",
    "        # Accumulate loss per batch\n",
    "        runningLoss += loss.data\n",
    "    # Printing average loss per epoch\n",
    "    print('At Iteration : %d / %d  ;  Mean-Squared Error : %f'%(epoch + 1,iterations,runningLoss/\n",
    "                                                                (TrainImages.size()[0]/BatchSize)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifying the autoencoder for classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential(\n",
      "  (0): Sequential(\n",
      "    (0): Linear(in_features=3072, out_features=1000, bias=True)\n",
      "    (1): ReLU()\n",
      "    (2): Linear(in_features=1000, out_features=500, bias=True)\n",
      "    (3): ReLU()\n",
      "  )\n",
      "  (classifier): Sequential(\n",
      "    (0): Linear(in_features=500, out_features=2, bias=True)\n",
      "    (1): LogSoftmax()\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# Removing the decoder module from the autoencoder\n",
    "new_classifier = nn.Sequential(*list(net.children())[:-1])\n",
    "net = new_classifier\n",
    "# Adding linear layer for 2-class classification problem\n",
    "net.add_module('classifier', nn.Sequential(nn.Linear(500, 2),nn.LogSoftmax()))\n",
    "print(net)\n",
    "if use_gpu:\n",
    "    net = net.cuda()\n",
    "# # Copying initial weights  for visualization\n",
    "# cll_weights = copy.deepcopy(net[0][0].weight.data)\n",
    "# init_classifier_weights = copy.deepcopy(net.classifier[0].weight.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define loss function and optimizer: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.NLLLoss() # Negative Log-Likelihood\n",
    "optimizer = optim.Adam(net.parameters(), lr=1e-4) # Adam optimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\USER\\Anaconda3\\lib\\site-packages\\torch\\nn\\modules\\container.py:92: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "  input = module(input)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At Iteration: 1 /50  ;  Training Loss: 0.765977 ; Training Acc: 48.500 ; Testing Acc: 50.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 2 /50  ;  Training Loss: 0.729060 ; Training Acc: 60.000 ; Testing Acc: 71.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 3 /50  ;  Training Loss: 0.716171 ; Training Acc: 58.500 ; Testing Acc: 68.333 ; Time consumed: 0m 2s \n",
      "At Iteration: 4 /50  ;  Training Loss: 0.702446 ; Training Acc: 64.500 ; Testing Acc: 75.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 5 /50  ;  Training Loss: 0.686622 ; Training Acc: 63.000 ; Testing Acc: 65.000 ; Time consumed: 0m 1s \n",
      "At Iteration: 6 /50  ;  Training Loss: 0.677546 ; Training Acc: 65.500 ; Testing Acc: 61.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 7 /50  ;  Training Loss: 0.656341 ; Training Acc: 63.500 ; Testing Acc: 71.667 ; Time consumed: 0m 1s \n",
      "At Iteration: 8 /50  ;  Training Loss: 0.653022 ; Training Acc: 70.000 ; Testing Acc: 63.333 ; Time consumed: 0m 1s \n",
      "At Iteration: 9 /50  ;  Training Loss: 0.645000 ; Training Acc: 70.500 ; Testing Acc: 65.000 ; Time consumed: 0m 1s \n",
      "At Iteration: 10 /50  ;  Training Loss: 0.631661 ; Training Acc: 64.500 ; Testing Acc: 70.000 ; Time consumed: 0m 1s \n",
      "At Iteration: 11 /50  ;  Training Loss: 0.626631 ; Training Acc: 65.000 ; Testing Acc: 65.000 ; Time consumed: 0m 1s \n",
      "At Iteration: 12 /50  ;  Training Loss: 0.597703 ; Training Acc: 62.500 ; Testing Acc: 66.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 13 /50  ;  Training Loss: 0.602054 ; Training Acc: 67.000 ; Testing Acc: 71.667 ; Time consumed: 0m 1s \n",
      "At Iteration: 14 /50  ;  Training Loss: 0.583311 ; Training Acc: 67.500 ; Testing Acc: 65.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 15 /50  ;  Training Loss: 0.571232 ; Training Acc: 62.500 ; Testing Acc: 71.667 ; Time consumed: 0m 1s \n",
      "At Iteration: 16 /50  ;  Training Loss: 0.599541 ; Training Acc: 70.500 ; Testing Acc: 70.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 17 /50  ;  Training Loss: 0.572787 ; Training Acc: 71.500 ; Testing Acc: 66.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 18 /50  ;  Training Loss: 0.551782 ; Training Acc: 67.000 ; Testing Acc: 71.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 19 /50  ;  Training Loss: 0.571700 ; Training Acc: 71.000 ; Testing Acc: 68.333 ; Time consumed: 0m 1s \n",
      "At Iteration: 20 /50  ;  Training Loss: 0.579663 ; Training Acc: 70.000 ; Testing Acc: 70.000 ; Time consumed: 0m 1s \n",
      "At Iteration: 21 /50  ;  Training Loss: 0.551588 ; Training Acc: 74.500 ; Testing Acc: 68.333 ; Time consumed: 0m 2s \n",
      "At Iteration: 22 /50  ;  Training Loss: 0.538589 ; Training Acc: 72.000 ; Testing Acc: 68.333 ; Time consumed: 0m 2s \n",
      "At Iteration: 23 /50  ;  Training Loss: 0.536029 ; Training Acc: 69.000 ; Testing Acc: 70.000 ; Time consumed: 0m 1s \n",
      "At Iteration: 24 /50  ;  Training Loss: 0.555569 ; Training Acc: 73.000 ; Testing Acc: 65.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 25 /50  ;  Training Loss: 0.540902 ; Training Acc: 75.500 ; Testing Acc: 61.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 26 /50  ;  Training Loss: 0.521214 ; Training Acc: 74.000 ; Testing Acc: 70.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 27 /50  ;  Training Loss: 0.525547 ; Training Acc: 76.000 ; Testing Acc: 70.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 28 /50  ;  Training Loss: 0.515365 ; Training Acc: 72.500 ; Testing Acc: 68.333 ; Time consumed: 0m 2s \n",
      "At Iteration: 29 /50  ;  Training Loss: 0.506639 ; Training Acc: 73.500 ; Testing Acc: 66.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 30 /50  ;  Training Loss: 0.544614 ; Training Acc: 74.500 ; Testing Acc: 61.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 31 /50  ;  Training Loss: 0.503558 ; Training Acc: 75.000 ; Testing Acc: 71.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 32 /50  ;  Training Loss: 0.562871 ; Training Acc: 74.500 ; Testing Acc: 66.667 ; Time consumed: 0m 1s \n",
      "At Iteration: 33 /50  ;  Training Loss: 0.516434 ; Training Acc: 76.500 ; Testing Acc: 65.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 34 /50  ;  Training Loss: 0.500856 ; Training Acc: 79.000 ; Testing Acc: 71.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 35 /50  ;  Training Loss: 0.520777 ; Training Acc: 72.500 ; Testing Acc: 66.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 36 /50  ;  Training Loss: 0.496316 ; Training Acc: 78.500 ; Testing Acc: 66.667 ; Time consumed: 0m 1s \n",
      "At Iteration: 37 /50  ;  Training Loss: 0.500213 ; Training Acc: 77.000 ; Testing Acc: 65.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 38 /50  ;  Training Loss: 0.528455 ; Training Acc: 74.500 ; Testing Acc: 65.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 39 /50  ;  Training Loss: 0.517247 ; Training Acc: 75.500 ; Testing Acc: 66.667 ; Time consumed: 0m 1s \n",
      "At Iteration: 40 /50  ;  Training Loss: 0.486425 ; Training Acc: 78.000 ; Testing Acc: 65.000 ; Time consumed: 0m 1s \n",
      "At Iteration: 41 /50  ;  Training Loss: 0.493493 ; Training Acc: 76.000 ; Testing Acc: 66.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 42 /50  ;  Training Loss: 0.503915 ; Training Acc: 77.000 ; Testing Acc: 66.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 43 /50  ;  Training Loss: 0.501909 ; Training Acc: 77.500 ; Testing Acc: 65.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 44 /50  ;  Training Loss: 0.461221 ; Training Acc: 79.000 ; Testing Acc: 65.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 45 /50  ;  Training Loss: 0.453471 ; Training Acc: 80.500 ; Testing Acc: 61.667 ; Time consumed: 0m 1s \n",
      "At Iteration: 46 /50  ;  Training Loss: 0.454791 ; Training Acc: 80.500 ; Testing Acc: 66.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 47 /50  ;  Training Loss: 0.458429 ; Training Acc: 77.500 ; Testing Acc: 66.667 ; Time consumed: 0m 2s \n",
      "At Iteration: 48 /50  ;  Training Loss: 0.453708 ; Training Acc: 78.000 ; Testing Acc: 65.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 49 /50  ;  Training Loss: 0.446797 ; Training Acc: 80.500 ; Testing Acc: 65.000 ; Time consumed: 0m 2s \n",
      "At Iteration: 50 /50  ;  Training Loss: 0.439567 ; Training Acc: 82.000 ; Testing Acc: 66.667 ; Time consumed: 0m 2s \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "iterations = 50\n",
    "trainLoss = []\n",
    "trainAcc = []\n",
    "testAcc = []\n",
    "start = time.time()\n",
    "for epoch in range(iterations):\n",
    "    epochStart = time.time()\n",
    "    runningLoss = 0\n",
    "    runningCorrect = 0\n",
    "    avgTrainAcc = 0\n",
    "    for batch_num,data in enumerate(trainLoader):\n",
    "        inputs,labels = data\n",
    "        inputs = inputs/255.0\n",
    "        # Initialize gradients to zero\n",
    "        optimizer.zero_grad()\n",
    "        if use_gpu:\n",
    "            inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())\n",
    "            # Feed-forward input data through the network\n",
    "            outputs = net(inputs)\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "            predicted = predicted.cpu()\n",
    "        else:\n",
    "            inputs, labels = Variable(inputs), Variable(labels)  \n",
    "            outputs = net(inputs)\n",
    "            _, predicted = torch.max(outputs.data, 1)\n",
    "        \n",
    "        \n",
    "        # Compute loss/error\n",
    "        loss = criterion(outputs, labels)\n",
    "        # Backpropagate loss and compute gradients\n",
    "        loss.backward()\n",
    "        # Update the network parameters\n",
    "        optimizer.step()\n",
    "        # Accumulate loss per batch\n",
    "        runningLoss += loss.data\n",
    "        runningCorrect += (predicted == labels).sum()\n",
    "    avgTrainLoss = runningLoss/batch_num\n",
    "    trainLoss.append(avgTrainLoss)\n",
    "    avgTrainAcc = runningCorrect.item()/200.0    \n",
    "    trainAcc.append(avgTrainAcc)\n",
    "    \n",
    "    # Evaluating performance on test set for each epoch\n",
    "    net.train(False) # For testing\n",
    "    inputs = TestImages/255\n",
    "    if use_gpu:\n",
    "        inputs = Variable(inputs.cuda())\n",
    "        outputs = net(inputs)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        predicted = predicted.cpu()\n",
    "    else:\n",
    "        inputs = Variable(inputs)\n",
    "        outputs = net(inputs)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "    correct = 0\n",
    "#     total = 0\n",
    "#     total += TestLabels.size(0)\n",
    "    correct += (predicted == TestLabels).sum()\n",
    "    avgTestAcc = correct.item()/60.0\n",
    "    testAcc.append(avgTestAcc)\n",
    "    \n",
    "    # Plotting training loss vs Epochs\n",
    "    fig1 = plt.figure(1)        \n",
    "    plt.plot(range(epoch+1),trainLoss,'r-',label='train')        \n",
    "    if epoch==0:\n",
    "        plt.legend(loc='upper left')\n",
    "        plt.xlabel('Epochs')\n",
    "        plt.ylabel('Training loss')   \n",
    "    # Plotting testing accuracy vs Epochs\n",
    "    fig2 = plt.figure(2)        \n",
    "    plt.plot(range(epoch+1),trainAcc,'r-',label='train') \n",
    "    plt.plot(range(epoch+1),testAcc,'g-',label='test')        \n",
    "    if epoch==0:\n",
    "        plt.legend(loc='upper left')\n",
    "        plt.xlabel('Epochs')\n",
    "        plt.ylabel('Accuracy plots')    \n",
    "    \n",
    "    epochEnd = time.time()-epochStart\n",
    "    print('At Iteration: {:.0f} /{:.0f}  ;  Training Loss: {:.6f} ; Training Acc: {:.3f} ; Testing Acc: {:.3f} ; Time consumed: {:.0f}m {:.0f}s '\\\n",
    "          .format(epoch + 1,iterations,avgTrainLoss,avgTrainAcc*100,avgTestAcc*100,epochEnd//60,epochEnd%60))\n",
    "# end = time.time()-start\n",
    "# print('Training completed in {:.0f}m {:.0f}s'.format(end//60,end%60))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}