bonus.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "FV41Te_bkqdC",
        "outputId": "3da7406a-b2b2-434f-810f-632c7a8fa32c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting torch==1.12.1\n",
            "  Downloading torch-1.12.1-cp310-cp310-manylinux1_x86_64.whl (776.3 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m776.3/776.3 MB\u001b[0m \u001b[31m2.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch==1.12.1) (4.5.0)\n",
            "Installing collected packages: torch\n",
            "  Attempting uninstall: torch\n",
            "    Found existing installation: torch 2.0.0+cu118\n",
            "    Uninstalling torch-2.0.0+cu118:\n",
            "      Successfully uninstalled torch-2.0.0+cu118\n",
            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
            "torchvision 0.15.1+cu118 requires torch==2.0.0, but you have torch 1.12.1 which is incompatible.\n",
            "torchtext 0.15.1 requires torch==2.0.0, but you have torch 1.12.1 which is incompatible.\n",
            "torchdata 0.6.0 requires torch==2.0.0, but you have torch 1.12.1 which is incompatible.\n",
            "torchaudio 2.0.1+cu118 requires torch==2.0.0, but you have torch 1.12.1 which is incompatible.\u001b[0m\u001b[31m\n",
            "\u001b[0mSuccessfully installed torch-1.12.1\n",
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting torchmetrics\n",
            "  Downloading torchmetrics-0.11.4-py3-none-any.whl (519 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m519.2/519.2 kB\u001b[0m \u001b[31m38.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from torchmetrics) (23.1)\n",
            "Requirement already satisfied: torch>=1.8.1 in /usr/local/lib/python3.10/dist-packages (from torchmetrics) (1.12.1)\n",
            "Requirement already satisfied: numpy>=1.17.2 in /usr/local/lib/python3.10/dist-packages (from torchmetrics) (1.22.4)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch>=1.8.1->torchmetrics) (4.5.0)\n",
            "Installing collected packages: torchmetrics\n",
            "Successfully installed torchmetrics-0.11.4\n"
          ]
        },
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'1.12.1+cu102'"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "!pip install torch==1.12.1\n",
        "!pip install torchmetrics\n",
        "import torch\n",
        "torch.__version__"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DSKgGwzOkqdE",
        "outputId": "a22a6a90-4b8b-41ee-f21a-fc62bfc630c3"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: '/usr/local/lib/python3.10/dist-packages/torchvision/image.so: undefined symbol: _ZN3c104impl8GPUTrace13gpuTraceStateE'If you don't plan on using image functionality from `torchvision.io`, you can ignore this warning. Otherwise, there might be something wrong with your environment. Did you have `libjpeg` or `libpng` installed before building `torchvision` from source?\n",
            "  warn(\n"
          ]
        }
      ],
      "source": [
        "#Import torch dependencies\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "from torchmetrics.classification import MulticlassAccuracy\n",
        "from torchmetrics import Accuracy\n",
        "# file unpickle \n",
        "def unpickle(file):\n",
        "    import pickle\n",
        "    with open(file, 'rb') as fo:\n",
        "        dict = pickle.load(fo, encoding='bytes')\n",
        "    return dict"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "5T1cX3yvkqdE"
      },
      "outputs": [],
      "source": [
        "#Data loader: \n",
        "transform = transforms.Compose([transforms.ToTensor(),transforms.RandomHorizontalFlip(p=1)])\n",
        "batch_size = 10000"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101,
          "referenced_widgets": [
            "6809784953ae407cb3a7295e0774f402",
            "3d33fbfc535d4fd3a7d2c8529d85840a",
            "e8204d3ffda14378b68b3fbad7bf4290",
            "8411d1a6d43b4979a4d805b7e5083bdb",
            "ebdceece842444028c33f4424f453e50",
            "61eb6e1eec3946568f1a92cf4660963e",
            "0bbfcbbd710c4cb7aefbf0b8b3a372d4",
            "ece25d80cf694dce968532e07290c5dd",
            "6763b51a7dcd4e19b16fa2299812f1b6",
            "1e078230bf424f45aa8983c1e79098cf",
            "495bd4ac3255494ca5611a7ef910d2c5"
          ]
        },
        "id": "o0bK_7S-kqdF",
        "outputId": "06d906f7-6076-4587-cc95-187491bf4ae1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "6809784953ae407cb3a7295e0774f402",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/170498071 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Extracting ./data/cifar-10-python.tar.gz to ./data\n",
            "Files already downloaded and verified\n"
          ]
        }
      ],
      "source": [
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True,download=True, transform=transform)\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,shuffle=True, num_workers=2)\n",
        "testset = torchvision.datasets.CIFAR10(root='./data', train=False,download=True, transform=transform)\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,shuffle=False, num_workers=2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QUNXXgt2kqdF"
      },
      "outputs": [],
      "source": [
        "#dropout\n",
        "#batch norm\n",
        "#group norm\n",
        "#resnet\n",
        "#dla\n",
        "#vgg"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KLdEsNuYkqdF",
        "outputId": "6ab8365b-ba3d-40b7-9a4d-2f49defbe433"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "<ipython-input-5-043a4d172dbf>:26: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  encode_y = torch.tensor(encode_y, dtype=torch.float)\n",
            "<ipython-input-5-043a4d172dbf>:28: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
            "  encode_test = torch.tensor(encode_test, dtype=torch.float)\n"
          ]
        }
      ],
      "source": [
        "dict1 = unpickle(file='./data/cifar-10-batches-py/data_batch_1')\n",
        "dict2 = unpickle(file='./data/cifar-10-batches-py/data_batch_2')\n",
        "dict3 = unpickle(file='./data/cifar-10-batches-py/data_batch_3')\n",
        "dict4 = unpickle(file='./data/cifar-10-batches-py/data_batch_4')\n",
        "dict5 = unpickle(file='./data/cifar-10-batches-py/data_batch_5')\n",
        "dict_test = unpickle(file='./data/cifar-10-batches-py/test_batch')\n",
        "train_x1 = torch.tensor(dict1[b'data'])\n",
        "train_y1 = torch.tensor(dict1[b'labels'])\n",
        "train_x2 = torch.tensor(dict2[b'data'])\n",
        "train_y2 = torch.tensor(dict2[b'labels'])\n",
        "train_x3 = torch.tensor(dict3[b'data'])\n",
        "train_y3 = torch.tensor(dict3[b'labels'])\n",
        "train_x4 = torch.tensor(dict4[b'data'])\n",
        "train_y4 = torch.tensor(dict4[b'labels'])\n",
        "train_x5 = torch.tensor(dict5[b'data'])\n",
        "train_y5 = torch.tensor(dict5[b'labels'])\n",
        "test_x = torch.tensor(dict_test[b'data'])\n",
        "test_y = torch.tensor(dict_test[b'labels'])\n",
        "train_x = torch.cat((train_x1, train_x2, train_x3, train_x4, train_x5), dim=0)\n",
        "train_y = torch.cat((train_y1, train_y2, train_y3, train_y4, train_y5), dim=0)\n",
        "train_x = torch.reshape(train_x, (50000, 3, 32, 32))\n",
        "train_x = train_x/255\n",
        "test_x = torch.reshape(test_x, (10000, 3, 32, 32))\n",
        "test_x = test_x/255\n",
        "encode_y = torch.nn.functional.one_hot(train_y.clone().detach(), num_classes=10)\n",
        "encode_y = torch.tensor(encode_y, dtype=torch.float)\n",
        "encode_test = torch.nn.functional.one_hot(test_y.clone().detach(), num_classes=10)\n",
        "encode_test = torch.tensor(encode_test, dtype=torch.float)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "NzDbhXzfkqdF"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "#(For plots and losses)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "2ijTMOXpkqdG"
      },
      "outputs": [],
      "source": [
        "class CNN_Model(torch.nn.Module):\n",
        "    def __init__(self) -> None:\n",
        "        super().__init__()\n",
        "        self.conv1 = torch.nn.Conv2d(in_channels=3,out_channels=32,kernel_size=(3,3),stride=(1,1), padding=(1,1), padding_mode='zeros', bias=True)\n",
        "        self.maxpool = torch.nn.MaxPool2d((2,2), stride=(2,2), padding=0)\n",
        "        self.conv2 = torch.nn.Conv2d(32,64,(5,5),stride=(1,1), padding=(1,1), padding_mode='zeros', bias=True)\n",
        "        self.conv3 = torch.nn.Conv2d(64,64,(3,3),stride=(1,1), padding=(1,1), padding_mode='zeros', bias=True)\n",
        "        self.fc1 = torch.nn.Linear(64*7*7, 64)\n",
        "        self.fc2 = torch.nn.Linear(64, 10)\n",
        "        self.softmax = torch.nn.LogSoftmax(dim=1)\n",
        "\n",
        "    def forward(self, x, batch_size):\n",
        "        x = self.conv1(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        x = self.maxpool(x)\n",
        "        x = self.conv2(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        x = self.maxpool(x)\n",
        "        x = self.conv3(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        x = torch.reshape(x, (batch_size, -1))\n",
        "        x = self.fc1(x)\n",
        "        x = torch.nn.functional.relu(x)\n",
        "        x = self.fc2(x)\n",
        "        logits = self.softmax(x)\n",
        "        return logits\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "k0txkQmyk55Q"
      },
      "outputs": [],
      "source": [
        "class CNNModel2(torch.nn.Module):\n",
        "    def __init__(self)->None:\n",
        "        super(CNNModel2,self).__init__()\n",
        "        self.conv1 = torch.nn.Conv2d(3, 32, kernel_size=(3,3), stride=(1,1), padding=(1,1))\n",
        "        self.batchnorm1 = torch.nn.BatchNorm2d(64)\n",
        "        self.conv2 = torch.nn.Conv2d(32, 64, kernel_size=(3,3), stride=(1,1), padding=(1,1))\n",
        "        self.maxpool = torch.nn.MaxPool2d(kernel_size=2, stride=2)\n",
        "        self.conv3 = torch.nn.Conv2d(64, 128, kernel_size=(3,3), stride=(1,1), padding=(1,1))\n",
        "        self.batchnorm2 = torch.nn.BatchNorm2d(128)\n",
        "        self.conv5 = torch.nn.Conv2d(128, 256, kernel_size=(3,3), stride=(1,1), padding=(1,1))\n",
        "        self.fc1 = torch.nn.Linear(256*4*4, 1024)\n",
        "        self.batchnorm3 = torch.nn.BatchNorm2d(256)\n",
        "        self.dropout1 = torch.nn.Dropout(0.25)\n",
        "        self.dropout2 = torch.nn.Dropout(0.5)\n",
        "        self.fc2 = torch.nn.Linear(1024, 512)\n",
        "        self.fc3 = torch.nn.Linear(512, 10)\n",
        "    \n",
        "    def forward(self, x, batchsize):\n",
        "        #layer 1\n",
        "        y = self.conv1(x)\n",
        "        y = torch.nn.functional.relu(y)\n",
        "        y = self.conv2(y)\n",
        "        y = torch.nn.functional.relu(y)\n",
        "        y = self.maxpool(y)\n",
        "        y = self.batchnorm1(y)\n",
        "        y = self.conv3(y)\n",
        "        y = torch.nn.functional.relu(y)\n",
        "        y = self.maxpool(y)\n",
        "        y = self.batchnorm2(y)\n",
        "  \n",
        "        y = self.conv5(y)\n",
        "        y = torch.nn.functional.relu(y)\n",
        "        y = self.maxpool(y)\n",
        "        y = self.batchnorm3(y)\n",
        "        y = self.dropout1(y)\n",
        "        \n",
        "\n",
        "        y = torch.reshape(y, (batchsize, -1))\n",
        "        y = self.fc1(y)\n",
        "        y = torch.nn.functional.relu(y)\n",
        "        y = self.fc2(y)\n",
        "        y = torch.nn.functional.relu(y)\n",
        "        y = self.dropout2(y)\n",
        "        y = self.fc3(y)\n",
        "        return y"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UDK11VcIkqdG",
        "outputId": "5c6b4efd-5d7b-4d5a-e4d0-610a1fd28e43"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "----EPOCH 1-----\n",
            "VAL ACC EPOCH = 1: 0.6759999990463257\n",
            "TRAIN ACC EPOCH 1: 0.6754999756813049\n",
            "----EPOCH 2-----\n",
            "VAL ACC EPOCH = 2: 0.734499990940094\n",
            "TRAIN ACC EPOCH 2: 0.7450000047683716\n",
            "----EPOCH 3-----\n",
            "VAL ACC EPOCH = 3: 0.7620000243186951\n",
            "TRAIN ACC EPOCH 3: 0.7860000133514404\n",
            "----EPOCH 4-----\n",
            "VAL ACC EPOCH = 4: 0.781000018119812\n",
            "TRAIN ACC EPOCH 4: 0.8149999976158142\n",
            "----EPOCH 5-----\n",
            "VAL ACC EPOCH = 5: 0.7829999923706055\n",
            "TRAIN ACC EPOCH 5: 0.8274999856948853\n",
            "----EPOCH 6-----\n",
            "VAL ACC EPOCH = 6: 0.7919999957084656\n",
            "TRAIN ACC EPOCH 6: 0.8525000214576721\n",
            "----EPOCH 7-----\n",
            "VAL ACC EPOCH = 7: 0.7925000190734863\n",
            "TRAIN ACC EPOCH 7: 0.8560000061988831\n",
            "----EPOCH 8-----\n",
            "VAL ACC EPOCH = 8: 0.7935000061988831\n",
            "TRAIN ACC EPOCH 8: 0.8805000185966492\n",
            "----EPOCH 9-----\n",
            "VAL ACC EPOCH = 9: 0.8090000152587891\n",
            "TRAIN ACC EPOCH 9: 0.9014999866485596\n",
            "----EPOCH 10-----\n",
            "VAL ACC EPOCH = 10: 0.809499979019165\n",
            "TRAIN ACC EPOCH 10: 0.9104999899864197\n",
            "----EPOCH 11-----\n",
            "VAL ACC EPOCH = 11: 0.7935000061988831\n",
            "TRAIN ACC EPOCH 11: 0.9054999947547913\n",
            "----EPOCH 12-----\n",
            "VAL ACC EPOCH = 12: 0.8044999837875366\n",
            "TRAIN ACC EPOCH 12: 0.8970000147819519\n",
            "----EPOCH 13-----\n",
            "VAL ACC EPOCH = 13: 0.8084999918937683\n",
            "TRAIN ACC EPOCH 13: 0.9169999957084656\n",
            "----EPOCH 14-----\n",
            "VAL ACC EPOCH = 14: 0.8169999718666077\n",
            "TRAIN ACC EPOCH 14: 0.9254999756813049\n",
            "----EPOCH 15-----\n",
            "VAL ACC EPOCH = 15: 0.8075000047683716\n",
            "TRAIN ACC EPOCH 15: 0.9290000200271606\n",
            "----EPOCH 16-----\n",
            "VAL ACC EPOCH = 16: 0.809499979019165\n",
            "TRAIN ACC EPOCH 16: 0.9294999837875366\n",
            "----EPOCH 17-----\n",
            "VAL ACC EPOCH = 17: 0.8109999895095825\n",
            "TRAIN ACC EPOCH 17: 0.9294999837875366\n",
            "----EPOCH 18-----\n",
            "VAL ACC EPOCH = 18: 0.8180000185966492\n",
            "TRAIN ACC EPOCH 18: 0.9315000176429749\n",
            "tensor([2067.1909, 1355.8289, 1094.5562,  928.9739,  803.0645,  704.8461,\n",
            "         623.9920,  561.7343,  507.9993,  465.4418,  433.1402,  400.4676,\n",
            "         374.1067,  360.7436,  337.5649,  319.3326,  312.7422,  295.4007])\n",
            "tensor([0.9595, 0.7691, 0.7510, 0.6803, 0.6871, 0.6936, 0.7691, 0.7491, 0.7423,\n",
            "        0.7393, 0.7792, 0.8022, 0.7886, 0.7355, 0.7643, 0.7846, 0.7889, 0.7952])\n",
            "tensor([0.6755, 0.7450, 0.7860, 0.8150, 0.8275, 0.8525, 0.8560, 0.8805, 0.9015,\n",
            "        0.9105, 0.9055, 0.8970, 0.9170, 0.9255, 0.9290, 0.9295, 0.9295, 0.9315])\n",
            "tensor([0.6760, 0.7345, 0.7620, 0.7810, 0.7830, 0.7920, 0.7925, 0.7935, 0.8090,\n",
            "        0.8095, 0.7935, 0.8045, 0.8085, 0.8170, 0.8075, 0.8095, 0.8110, 0.8180])\n"
          ]
        }
      ],
      "source": [
        "epoch = 18\n",
        "batch_size = 32\n",
        "batches = 1562\n",
        "acc_met = Accuracy(task=\"multiclass\", num_classes=10).to('cuda:0')\n",
        "model = CNNModel2().to('cuda:0')\n",
        "criterion = torch.nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=0.0001)\n",
        "# scheduler_LR = lr_scheduler.ExponentialLR(optimizer, gamma=0.99)\n",
        "trainaccs = torch.empty(epoch)\n",
        "valaccs = torch.empty(epoch)\n",
        "train_loss = torch.empty(epoch)\n",
        "val_loss = torch.empty(epoch)\n",
        "for epochs in range(epoch):\n",
        "    print(f'----EPOCH {epochs+1}-----')\n",
        "    tloss = 0\n",
        "    for b in range(batches):\n",
        "      data = train_x[b*batch_size:(b+1)*batch_size,:,:,:].to('cuda:0')\n",
        "      target = encode_y[b*batch_size:(b+1)*batch_size,:].to('cuda:0')\n",
        "      scores = model.forward(data,32)\n",
        "      loss = criterion(scores,target)\n",
        "      # print(f'EPOCH: {epochs+1}, BATCH: {b+1}, LOSS: {loss}')\n",
        "      tloss+=loss.item()\n",
        "      optimizer.zero_grad()\n",
        "      loss.backward()\n",
        "      optimizer.step()\n",
        "    # print(f'LR BEFORE: {optimizer.param_groups[0][\"lr\"]}')\n",
        "    # scheduler_LR.step()\n",
        "    # print(f'LR AFTER: {optimizer.param_groups[0][\"lr\"]}')\n",
        "    score_val = model.forward(test_x[:2000].to('cuda:0'),2000)\n",
        "    pred_val = torch.argmax(score_val, dim=1)\n",
        "    finalacc_val = acc_met(pred_val, test_y[:2000].to('cuda:0'))\n",
        "    score_tr = model.forward(train_x[:2000].to('cuda:0'),2000)\n",
        "    pred_tr = torch.argmax(score_tr, dim=1)\n",
        "    finalacc_tr = acc_met(pred_tr, train_y[:2000].to('cuda:0'))  \n",
        "    valaccs[epochs]=finalacc_val\n",
        "    trainaccs[epochs]=finalacc_tr\n",
        "    val_loss[epochs]=criterion(score_val,encode_test[:2000].to('cuda:0')).item()\n",
        "    train_loss[epochs]=tloss\n",
        "    print(f'VAL ACC EPOCH = {epochs+1}: {finalacc_val}')\n",
        "    print(f'TRAIN ACC EPOCH {epochs+1}: {finalacc_tr}')\n",
        "print(train_loss)\n",
        "print(val_loss)\n",
        "print(trainaccs)\n",
        "print(valaccs)\n",
        "# train_loss = train_loss/499.84\n",
        "# val_loss = val_loss/10\n",
        "# print(train_loss)\n",
        "# print(val_loss)\n",
        "# loss_t = train_loss.detach().numpy()\n",
        "# loss_v = val_loss.detach().numpy()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_sqdQt6cz4hS"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 542
        },
        "id": "V5vIzclGkqdG",
        "outputId": "dd726565-902d-4246-91d2-c4345306a6ea"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#Plots of accuracy:\n",
        "plt.figure(figsize=(8,6))\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "eps = np.arange(1,19)\n",
        "# plt.ylim(90,95)\n",
        "plt.xticks(np.arange(0,19))\n",
        "plt.plot(eps,trainaccs,'purple',label=\"Train data\")\n",
        "plt.plot(eps,valaccs, 'cyan', label='Validation data')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 542
        },
        "id": "o_3cvsoKkqdH",
        "outputId": "e02dce88-8ec5-42d1-f8bf-45a022bfbd6b"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#Plots of loss:\n",
        "plt.figure(figsize=(8,6))\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Cross Entropy Loss')\n",
        "eps = np.arange(1,19)\n",
        "# plt.ylim(90,95)\n",
        "plt.xticks(np.arange(0,19))\n",
        "plt.plot(eps,train_loss,'purple',label=\"Train data\")\n",
        "plt.plot(eps,val_loss, 'green', label='Validation data')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 542
        },
        "id": "7flUK_tLJRDJ",
        "outputId": "2c6c7587-8e07-4b41-c242-57f7ee9a0123"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#Plots of loss:\n",
        "plt.figure(figsize=(8,6))\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Cross Entropy Loss')\n",
        "eps = np.arange(1,19)\n",
        "# plt.ylim(90,95)\n",
        "plt.xticks(np.arange(0,19))\n",
        "# plt.plot(eps,train_loss,'purple',label=\"Train data\")\n",
        "plt.plot(eps,val_loss, 'green', label='Validation data')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MF8GRggCkqdI",
        "outputId": "168ed403-efe2-4132-bb84-c15d9625ce68"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "tensor(0.8180, device='cuda:0')\n",
            "tensor([0.8163, 0.9040, 0.7333, 0.7136, 0.8131, 0.7243, 0.8611, 0.8549, 0.8664,\n",
            "        0.8768], device='cuda:0')\n"
          ]
        }
      ],
      "source": [
        "metric = MulticlassAccuracy(num_classes=10, average=None).to('cuda:0')\n",
        "pred_y = torch.argmax(score_val, dim=1).to('cuda:0')\n",
        "classwise = metric(score_val, test_y[:2000].to('cuda:0'))\n",
        "val_acc_met = Accuracy(task=\"multiclass\", num_classes=10).to('cuda:0')\n",
        "finalacc = val_acc_met(pred_y, test_y[:2000].to('cuda:0'))\n",
        "print(finalacc)\n",
        "print(classwise)\n",
        "###BAR GRAPH OF CLASSWISE ACCURACY\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 559
        },
        "id": "ega4RPq8Ng_b",
        "outputId": "69633f69-f89f-4a6f-dc96-935078a6cab0"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:matplotlib.legend:No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.figure(figsize=(8,6))\n",
        "classes = np.arange(0,10)\n",
        "plt.xticks(classes)\n",
        "plt.bar(classes, classwise.to('cpu'), color='purple',width=0.4)\n",
        "plt.xlabel('Classes')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TVSYu_lFkqdI"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3.9.12 ('base')",
      "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.12"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "73cba7173f8447e209b3236db8d7a4c2baa473635286a4d66150d0ea51f721be"
      }
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "0bbfcbbd710c4cb7aefbf0b8b3a372d4": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "1e078230bf424f45aa8983c1e79098cf": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "3d33fbfc535d4fd3a7d2c8529d85840a": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_61eb6e1eec3946568f1a92cf4660963e",
            "placeholder": "​",
            "style": "IPY_MODEL_0bbfcbbd710c4cb7aefbf0b8b3a372d4",
            "value": "100%"
          }
        },
        "495bd4ac3255494ca5611a7ef910d2c5": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "61eb6e1eec3946568f1a92cf4660963e": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "6763b51a7dcd4e19b16fa2299812f1b6": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ProgressStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "6809784953ae407cb3a7295e0774f402": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_3d33fbfc535d4fd3a7d2c8529d85840a",
              "IPY_MODEL_e8204d3ffda14378b68b3fbad7bf4290",
              "IPY_MODEL_8411d1a6d43b4979a4d805b7e5083bdb"
            ],
            "layout": "IPY_MODEL_ebdceece842444028c33f4424f453e50"
          }
        },
        "8411d1a6d43b4979a4d805b7e5083bdb": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_1e078230bf424f45aa8983c1e79098cf",
            "placeholder": "​",
            "style": "IPY_MODEL_495bd4ac3255494ca5611a7ef910d2c5",
            "value": " 170498071/170498071 [00:13&lt;00:00, 13398639.58it/s]"
          }
        },
        "e8204d3ffda14378b68b3fbad7bf4290": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "FloatProgressModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_ece25d80cf694dce968532e07290c5dd",
            "max": 170498071,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_6763b51a7dcd4e19b16fa2299812f1b6",
            "value": 170498071
          }
        },
        "ebdceece842444028c33f4424f453e50": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "ece25d80cf694dce968532e07290c5dd": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}