ConvNet.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ConvNet",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNwSkbyhjPTMFhADP7RuzmM",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Kshitij-Ambilduke/Memes-vs-Notes/blob/master/ConvNet.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pWyFPNLexHq9",
        "colab_type": "text"
      },
      "source": [
        "# **Memes vs Notes Classifier**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "azRaSb0LRm3f",
        "colab_type": "text"
      },
      "source": [
        "First we mount the drive containing the dataset so that we can read data from the drive and transform it as we want to.\n",
        "To do this we run the below code block and copy the password generated for us in the link provided by logging in and pasting it here.\n",
        "\n",
        "\n",
        "```python\n",
        "drive.mount('/content/drive') can be replaced by drive.mount('/content/gdrive)\n",
        "``` \n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nWmifWm76Vx5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 128
        },
        "outputId": "cea036cd-6868-4bc6-c677-c1931b0fef4e"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&response_type=code&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly\n",
            "\n",
            "Enter your authorization code:\n",
            "··········\n",
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QCHt-VdmTDWU",
        "colab_type": "text"
      },
      "source": [
        "After having access to all the images in the dataset, we go ahead and import some important packages that will help us in reading the dataset, preprocessing and using the preprocessed data to build our model that differenciates between memes and notes.\n",
        "```python\n",
        "import os # To loacte the data and making list of all the data in a particular folder\n",
        "import cv2 # For reading the images, resizing them and converting them to a desired colour space\n",
        "import random # For Shuffling the data\n",
        "import torch # For Neural Networks\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DADlo3x96Hed",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import os\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import cv2\n",
        "import random\n",
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OOTnm3noVhJ1",
        "colab_type": "text"
      },
      "source": [
        "Defining path for memes as ```meme_path``` and the path for notes as ```note_path```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8jd30GthEV9x",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "meme_path = \"/content/drive/My Drive/dataset stage 0 /meme\"\n",
        "note_path = \"/content/drive/My Drive/dataset stage 0 /note\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MT6Jt-3iV4tc",
        "colab_type": "text"
      },
      "source": [
        "Defining a pseudo-dataloader as ```dataloader``` so as to load the data from the path that is passed as an argument ```folder``` and the label to be given to this  folder is passed through the argument ```label```.\n",
        "This function can be fine tuned so as to the desired form of the images from the folder.\n",
        "Note that all the images from the same folder are labeled with the 2nd argument passed in the function. \n",
        "Here we are using the size ```(100 x 100)``` and the grayscale colour.\n",
        "The function returns 2 lists, 1st the resized images and 2nd the labels for these images."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kQFkaKQJFGhg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def dataloader(folder,label):\n",
        "    images=[]\n",
        "    labels=[]\n",
        "    for file in os.listdir(folder):\n",
        "        img = cv2.imread(os.path.join(folder,file),0)\n",
        "        #img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
        "        img = cv2.resize(img, (100,100))\n",
        "        images.append(img)\n",
        "        labels.append(label)\n",
        "    return images, labels"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4AwDnqrBYfrT",
        "colab_type": "text"
      },
      "source": [
        "Defining variables for containing the memes and the labels for meme as ```meme``` and ```memelabel``` respectively. Similarly defining variables for notes and label for notes as ```note``` and ```notelabel``` respectively."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rn91UjU3FIu9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "meme, memelabel = dataloader(meme_path, 1)\n",
        "note, notelabel = dataloader(note_path, 0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qPiH6eSIZD1r",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "\n",
        "Converting all the lists into numpy arrays and reshaping them in the format ```(number of images x channels in the image x height of the image x width of the image)```. For a RGB image the number of channels will be 3 and for a RGB image, the number of channel will be 1.\n",
        "The target vector should be of the shape ```(m,)``` or ```(m)``` and not of the shape ```(m,1)``` or ```(1,m)```. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PHo4M31CFLVE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "meme = np.array(meme)\n",
        "memelabel = np.array(memelabel)\n",
        "#print(meme.__len__())\n",
        "meme = meme.reshape(800,1,100,100)\n",
        "note = np.array(note)\n",
        "note = note.reshape(800,1,100,100)\n",
        "notelabel = np.array(notelabel)\n",
        "#print(len(notelabel))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4a40s32GbOHi",
        "colab_type": "text"
      },
      "source": [
        "Zipping together the images and labels so as to Shuffle them."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NjDqJlebFXFE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "memezip = list(zip(meme, memelabel))\n",
        "notezip = list(zip(note, notelabel))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N_rvUCfnbaAv",
        "colab_type": "text"
      },
      "source": [
        "Concatenating the two lists in the variable ```toshuffle``` then shuffling the list containing the zips of both the labels using  ```random.shuffle()``` then unzipping the shuffled list of zips into two variables ```xtest``` and ```ytest``` where ```xtest``` is the list containing the shuffled images and ```ytest``` is the list containing the labels for these images.\n",
        "In the same way ```xtrain```,```ytrain```,```xval```,```yval``` is created.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6_Q377WQFYOT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "toshuffle = []\n",
        "toshuffle = memezip[0:750] + notezip[0:750]\n",
        "random.shuffle(toshuffle)\n",
        "xtrain, ytrain = list(zip(*toshuffle))\n",
        "\n",
        "toshuffle = []\n",
        "toshuffle = memezip[750:775] + notezip[750:775]\n",
        "random.shuffle(toshuffle)\n",
        "xtest, ytest = list(zip(*toshuffle))\n",
        "\n",
        "toshuffle = []\n",
        "toshuffle = memezip[775:] + notezip[775:]\n",
        "random.shuffle(toshuffle)\n",
        "xval, yval = list(zip(*toshuffle))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kbhCyoBig-VF",
        "colab_type": "text"
      },
      "source": [
        "Now that we have our data all sorted out, its time to convert our data into tensor so as to use it with pytorch module.\n",
        "While calculating the loss, the labels of the data are expected to be of ```Long``` datatype so we convert the labels into ```long``` datatype."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_nfSBtKijoKl",
        "colab_type": "text"
      },
      "source": [
        "We have also segregated the data into training, validation and testing data.\n",
        "Out of the **1600** images available to us in the dataset, we chose **1500** images for training, 50 for validation and **50** for testing. This gives us a training set of **93.75%** of the dataset and the validation and testing set bith **3.125%** of the total dataset. Here we have adopted a very primitive technique of normalization that being dividing all the pixels of the image by 255 thereby bringing each of the pixels' value between 0 and 1."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EtsW8-IZFkoy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "xtrain = torch.Tensor(xtrain)\n",
        "xtest = torch.Tensor(xtest)\n",
        "xval = torch.Tensor(xval)\n",
        "ytrain = torch.Tensor(ytrain).long()\n",
        "ytest = torch.Tensor(ytest).long()\n",
        "yval = torch.Tensor(yval).long()\n",
        "xtrain/=255.0\n",
        "xtest/=255.0\n",
        "xval /=255.0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "34Yr46EslqfS",
        "colab_type": "text"
      },
      "source": [
        "Now we start to define our neural network. We start by creating a class ```ConvNet``` which inherit from the parent class of pytorch ```nn.Module```. The attributes of this class are the layers of the neural network are the layers of our convolutional neural network. We use ```nn.Sequntial``` for bunching a couple of layes together.\n",
        "The Architechture of the neural network is as follows:\n",
        "\n",
        "\n",
        "1.   Convolutional layer taking 1 channel and giving 16 channels with a kernel size of ```5x5``` followed by a ReLU activation and then a Max Pool layer with a ```kernel_size = 2``` and ```stride = 2```\n",
        "2.   Convolutional layer taking 16 channel and giving 32 channels with a kernel size of ```5x5``` followed by a ReLU activation and then a Max Pool layer with a ```kernel_size = 2``` and ```stride = 2```\n",
        "3.   Convolutional layer taking 32 channel and giving 48 channels with a kernel size of ```5x5``` followed by a ReLU activation and then a Max Pool layer with a ```kernel_size = 2``` and ```stride = 2```\n",
        "4.    Couple of Linear layer with ```input_features = 2888``` i.e. the flattened output of the convolutional layers, then hidden layer containing ```500``` neurons and the output layer containing ```2``` neurons which depict the binary nature of our classification.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p3BFTLic6iBL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class ConvNet(nn.Module):\n",
        "  \n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    \n",
        "    self.l1 = nn.Sequential(nn.Conv2d(1,16,5),\n",
        "                       nn.ReLU(),\n",
        "                       nn.MaxPool2d(2,2))\n",
        "    \n",
        "    self.l2 = nn.Sequential(nn.Conv2d(16,32,3),\n",
        "                       nn.ReLU(),\n",
        "                       nn.MaxPool2d(2,2))\n",
        "    \n",
        "    self.l3 = nn.Sequential(nn.Conv2d(32,48,5),\n",
        "                       nn.ReLU(),\n",
        "                       nn.MaxPool2d(2,2))\n",
        "\n",
        "    self.l4 = nn.Sequential(nn.Linear(48*9*9,500),\n",
        "                       nn.Linear(500,2))\n",
        "    \n",
        "  def forward(self,x):\n",
        "\n",
        "    x = self.l1(x)\n",
        "    x = self.l2(x)\n",
        "    x = self.l3(x)\n",
        "    x = x.flatten(1)\n",
        "    x = self.l4(x)\n",
        "    return x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fhtva7JbuRGF",
        "colab_type": "text"
      },
      "source": [
        "Now we create an instance of the class we just created and print out that instance just to make sure everything is just as we wanted."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mg5XBNHsESoq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 399
        },
        "outputId": "5ab642af-8450-4b1f-fcc5-9a6cd3554e43"
      },
      "source": [
        "net = ConvNet()\n",
        "print(net)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ConvNet(\n",
            "  (l1): Sequential(\n",
            "    (0): Conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1))\n",
            "    (1): ReLU()\n",
            "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "  )\n",
            "  (l2): Sequential(\n",
            "    (0): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))\n",
            "    (1): ReLU()\n",
            "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "  )\n",
            "  (l3): Sequential(\n",
            "    (0): Conv2d(32, 48, kernel_size=(5, 5), stride=(1, 1))\n",
            "    (1): ReLU()\n",
            "    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "  )\n",
            "  (l4): Sequential(\n",
            "    (0): Linear(in_features=3888, out_features=500, bias=True)\n",
            "    (1): Linear(in_features=500, out_features=2, bias=True)\n",
            "  )\n",
            ")\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "waJhL1F3uqPC",
        "colab_type": "text"
      },
      "source": [
        "Now it's time we define our optimizer and loss function. Pytorch provied optimizer in the ```torch.optim``` package so we define our optimizer as ```torch.optim.Adam``` optimizer and the loss function as ```nn.CrossEntropyLoss```. This loss function combines the ```softmax``` and the ```NLLloss``` so we need not define the softmax layer at the end of our network. The optimizer requires 2 arguments, 1st the parameters on which the optimization should be performed and 2nd the learning rate. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P1LdVFYLNpUU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "optimizer = torch.optim.Adam(net.parameters(),lr=0.0001)\n",
        "lossfn = nn.CrossEntropyLoss()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "34Zn4WXTv_7u",
        "colab_type": "text"
      },
      "source": [
        "Finally with all the data ready and the loss and optimiser defined, we can now build our accuracy function so as to track the training, testing and validation accuracy.\n",
        "This function takes 2 arguments ```label``` and ```pred```.\n",
        "The argument ```label``` is the actual label matrix that we made while we made the dataset and ```pred``` is a matrix output by the network with contains the confidence score of what the network thinks should be the prediction of the data. We use ```torch.argmax``` to get the index of the highest prediction. The argument ```dim=1``` specifies that for a particular example, the confidence score is distributed along the horizontal. Then by comparing the values in the 2 matrices, we can get the accuracy easily. \n",
        "> While calculating the accuracy, we need to apply the softmax layer so as to get the probability distribution of of the confidence score of the model. This is done because we haven't applied Softmax layer to the output but while loss calculation, due to usage of ```nn.CrossEntropyLoss``` we dont need to separately use Softmax .\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pM5whC3fOErr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def accuracy(label, pred):\n",
        "  pred = F.softmax(pred, dim=1)\n",
        "  count =0\n",
        "  pred = torch.argmax(pred, dim=1, keepdims=True)\n",
        "  pred = pred.reshape(pred.shape[0])\n",
        "  for i in range(len(label)):\n",
        "    if label[i]==pred[i]:\n",
        "      count+=1\n",
        "  return 100*count/label.shape[0]\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "acvDaAv-T2VJ",
        "colab_type": "text"
      },
      "source": [
        "Now we define our main loop which will contain everything and it will do all the calculations necessary for our network to learn. I have chosen a mini-batch of size 50 and 3 epochs. The training accuracy, testing accuracy and validation accuracy is stored in the lists ```trainacc```,```testacc``` and ```valacc``` respectively. Similarly, the training and validation loss is stored in ```trainloss``` and ```valloss``` respectively."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2OsVixXBLidy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "7d3ac52b-e448-41a4-9000-e6ba8d1e539d"
      },
      "source": [
        "trainacc = []\n",
        "testacc = []\n",
        "trainloss = []\n",
        "testloss = []\n",
        "valacc = []\n",
        "valloss = []\n",
        "\n",
        "for i in range(10):\n",
        "    k=0\n",
        "    for j in range(30): \n",
        "      \n",
        "      output = net.forward(xtrain[k:k+50])\n",
        "      loss = lossfn(output, ytrain[k:k+50])\n",
        "        \n",
        "      k+=50\n",
        "      optimizer.zero_grad()\n",
        "      loss.backward()\n",
        "      optimizer.step()\n",
        "    \n",
        "    with torch.no_grad():\n",
        "\n",
        "      accu = accuracy(ytrain, net.forward(xtrain))\n",
        "      vloss = lossfn(net.forward(xval),yval)\n",
        "      tacc = accuracy(ytest, net.forward(xtest))\n",
        "      vacc = accuracy(yval,net.forward(xval))\n",
        "\n",
        "    \n",
        "    print(f\"training loss:{loss}\")\n",
        "    trainloss.append(loss)\n",
        "    print(f\"validation loss:{vloss}\")\n",
        "    valloss.append(vloss.item())\n",
        "    print(f\"training accuracy:{accu}\")\n",
        "    trainacc.append(accu)\n",
        "    print(f\"validation accuracy:{vacc}\")\n",
        "    valacc.append(vacc)\n",
        "    print(f\"testing accuracy:{tacc}\")\n",
        "    testacc.append(tacc)\n",
        "    print()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "training loss:0.30980977416038513\n",
            "validation loss:0.26092788577079773\n",
            "training accuracy:95.46666666666667\n",
            "validation accuracy:94.0\n",
            "testing accuracy:92.0\n",
            "\n",
            "training loss:0.3026829659938812\n",
            "validation loss:0.22151347994804382\n",
            "training accuracy:94.33333333333333\n",
            "validation accuracy:88.0\n",
            "testing accuracy:90.0\n",
            "\n",
            "training loss:0.2543073892593384\n",
            "validation loss:0.1973298192024231\n",
            "training accuracy:95.86666666666666\n",
            "validation accuracy:90.0\n",
            "testing accuracy:90.0\n",
            "\n",
            "training loss:0.25176501274108887\n",
            "validation loss:0.19942444562911987\n",
            "training accuracy:95.93333333333334\n",
            "validation accuracy:90.0\n",
            "testing accuracy:92.0\n",
            "\n",
            "training loss:0.21988777816295624\n",
            "validation loss:0.1735534518957138\n",
            "training accuracy:96.46666666666667\n",
            "validation accuracy:90.0\n",
            "testing accuracy:94.0\n",
            "\n",
            "training loss:0.19349569082260132\n",
            "validation loss:0.14633622765541077\n",
            "training accuracy:97.2\n",
            "validation accuracy:94.0\n",
            "testing accuracy:96.0\n",
            "\n",
            "training loss:0.17796549201011658\n",
            "validation loss:0.13277286291122437\n",
            "training accuracy:97.66666666666667\n",
            "validation accuracy:94.0\n",
            "testing accuracy:96.0\n",
            "\n",
            "training loss:0.16344648599624634\n",
            "validation loss:0.12619416415691376\n",
            "training accuracy:97.86666666666666\n",
            "validation accuracy:94.0\n",
            "testing accuracy:96.0\n",
            "\n",
            "training loss:0.15217959880828857\n",
            "validation loss:0.12443678826093674\n",
            "training accuracy:98.0\n",
            "validation accuracy:94.0\n",
            "testing accuracy:96.0\n",
            "\n",
            "training loss:0.14310984313488007\n",
            "validation loss:0.1258121132850647\n",
            "training accuracy:98.0\n",
            "validation accuracy:96.0\n",
            "testing accuracy:98.0\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dIS8GNjktbgo",
        "colab_type": "text"
      },
      "source": [
        "## **Note:**\n",
        "> If you are re-running the program start from the point where we made ```xtrain```,```ytrain``` ....\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KgotRT7bqC6i",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "dd34bcc5-27dc-4b28-cfaf-ca8b8c4e316c"
      },
      "source": [
        "print(xtrain.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([1500, 1, 100, 100])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6hyuuGRONm8J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from matplotlib import pyplot as plt\n",
        "def plot(data):\n",
        "  plt.plot(data)\n",
        "  plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rQKUaeCdTVSr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "17710998-76c5-4cd2-ad0b-85524bb26a49"
      },
      "source": [
        "plot(testacc)"
      ],
      "execution_count": null,
      "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": "AbrEL5EK74fU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "14abe015-129c-40aa-8ee4-c8bc0af1ffcf"
      },
      "source": [
        "plot(trainacc)"
      ],
      "execution_count": null,
      "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": "fmR6LNAJOwCI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "1c445ac4-aa7c-4309-982c-520100b2b6e6"
      },
      "source": [
        "plot(valacc)"
      ],
      "execution_count": null,
      "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": "MLvvfWpCOXIN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "a5d9721e-8dc2-4ee5-ad69-66db3b5dec99"
      },
      "source": [
        "plot(trainloss)"
      ],
      "execution_count": null,
      "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": "gaPEb4UzOpMi",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "c8d51059-0908-40a0-94e8-408f643cb540"
      },
      "source": [
        "plot(valloss)"
      ],
      "execution_count": null,
      "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": "3BcN4_xwQk5I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}