diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb
deleted file mode 100644
index 7a145b44a1dc51e7a7429942a29c2106fcf664dc..0000000000000000000000000000000000000000
--- a/TD2 Deep Learning.ipynb	
+++ /dev/null
@@ -1,2139 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "id": "7edf7168",
-      "metadata": {
-        "id": "7edf7168"
-      },
-      "source": [
-        "# TD2: Deep learning"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "fbb8c8df",
-      "metadata": {
-        "id": "fbb8c8df"
-      },
-      "source": [
-        "In this TD, you must modify this notebook to answer the questions. To do this,\n",
-        "\n",
-        "1. Fork this repository\n",
-        "2. Clone your forked repository on your local computer\n",
-        "3. Answer the questions\n",
-        "4. Commit and push regularly\n",
-        "\n",
-        "The last commit is due on Wednesday, December 4, 11:59 PM. Later commits will not be taken into account."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "3d167a29",
-      "metadata": {
-        "id": "3d167a29"
-      },
-      "source": [
-        "Install and test PyTorch from  https://pytorch.org/get-started/locally."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "330a42f5",
-      "metadata": {
-        "id": "330a42f5"
-      },
-      "outputs": [],
-      "source": [
-        "#pip install torch torchvision"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "0882a636",
-      "metadata": {
-        "id": "0882a636"
-      },
-      "source": [
-        "\n",
-        "To test run the following code"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 2,
-      "id": "b1950f0a",
-      "metadata": {
-        "id": "b1950f0a",
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "outputId": "1bf1ebe9-4993-4a9e-b19d-c76ddec453f0"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "tensor([[ 0.3641,  0.5224, -0.9584, -0.0321, -0.3416, -0.0876, -0.4329,  0.6723,\n",
-            "          0.9673,  0.4275],\n",
-            "        [ 0.4267,  0.8826, -0.2041,  1.1179, -0.2092,  0.0574,  1.0224, -0.0039,\n",
-            "         -1.2900,  1.9125],\n",
-            "        [-0.5982,  0.6839, -0.5857,  0.4444, -0.8312,  0.6723,  0.8040, -0.3553,\n",
-            "          0.2014, -0.5665],\n",
-            "        [-1.0921, -0.3161, -1.3390, -1.2649, -1.1278, -1.0613,  2.6058,  0.9691,\n",
-            "         -1.4536, -0.2266],\n",
-            "        [-0.9305,  0.6932, -1.3937, -2.1207,  0.2663,  0.0777,  0.3180,  0.6638,\n",
-            "         -0.7620, -1.5287],\n",
-            "        [ 0.5687, -0.0679, -0.8615,  1.9719, -0.1483, -0.8494, -0.3631,  0.5198,\n",
-            "          0.1581, -0.8487],\n",
-            "        [ 0.0446, -0.2545, -1.3286, -0.0456,  1.1024,  0.9406, -1.2425, -1.3619,\n",
-            "         -1.6396, -0.7690],\n",
-            "        [-0.1343,  0.2762,  1.4480, -0.0950,  1.3161, -1.0571, -0.0906, -0.3761,\n",
-            "          2.0049, -0.2862],\n",
-            "        [-1.2537, -0.8561, -1.5358,  0.9651,  0.5420, -0.9729, -0.0779,  0.7266,\n",
-            "          1.9224, -0.7308],\n",
-            "        [-0.2513, -0.2896, -1.0405, -0.3181,  1.3613, -0.6266,  0.2374, -1.0980,\n",
-            "         -0.5177, -0.1567],\n",
-            "        [-0.6940,  1.0261,  0.0406, -0.1215, -0.6148, -0.3655, -0.4999,  0.0449,\n",
-            "         -0.5944,  2.1691],\n",
-            "        [ 0.2888,  0.1127, -0.5346,  0.0867, -2.2361, -1.0839, -0.8207, -0.9238,\n",
-            "          0.4651, -0.1594],\n",
-            "        [-1.1425,  1.4220,  0.6096,  0.2622,  0.2159, -0.7445, -1.1781, -0.2175,\n",
-            "         -0.3940, -0.4477],\n",
-            "        [-1.1419,  1.6006,  0.1688, -0.3927,  0.6745, -0.3867,  0.4292,  0.0043,\n",
-            "         -0.2200, -0.0212]])\n",
-            "AlexNet(\n",
-            "  (features): Sequential(\n",
-            "    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))\n",
-            "    (1): ReLU(inplace=True)\n",
-            "    (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
-            "    (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
-            "    (4): ReLU(inplace=True)\n",
-            "    (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
-            "    (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-            "    (7): ReLU(inplace=True)\n",
-            "    (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-            "    (9): ReLU(inplace=True)\n",
-            "    (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-            "    (11): ReLU(inplace=True)\n",
-            "    (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
-            "  )\n",
-            "  (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))\n",
-            "  (classifier): Sequential(\n",
-            "    (0): Dropout(p=0.5, inplace=False)\n",
-            "    (1): Linear(in_features=9216, out_features=4096, bias=True)\n",
-            "    (2): ReLU(inplace=True)\n",
-            "    (3): Dropout(p=0.5, inplace=False)\n",
-            "    (4): Linear(in_features=4096, out_features=4096, bias=True)\n",
-            "    (5): ReLU(inplace=True)\n",
-            "    (6): Linear(in_features=4096, out_features=1000, bias=True)\n",
-            "  )\n",
-            ")\n"
-          ]
-        }
-      ],
-      "source": [
-        "import torch\n",
-        "\n",
-        "N, D = 14, 10\n",
-        "x = torch.randn(N, D).type(torch.FloatTensor)\n",
-        "print(x)\n",
-        "\n",
-        "from torchvision import models\n",
-        "\n",
-        "alexnet = models.alexnet()\n",
-        "print(alexnet)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "23f266da",
-      "metadata": {
-        "id": "23f266da"
-      },
-      "source": [
-        "## Exercise 1: CNN on CIFAR10\n",
-        "\n",
-        "The goal is to apply a Convolutional Neural Net (CNN) model on the CIFAR10 image dataset and test the accuracy of the model on the basis of image classification. Compare the Accuracy VS the neural network implemented during TD1.\n",
-        "\n",
-        "Have a look at the following documentation to be familiar with PyTorch.\n",
-        "\n",
-        "https://pytorch.org/tutorials/beginner/pytorch_with_examples.html\n",
-        "\n",
-        "https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "4ba1c82d",
-      "metadata": {
-        "id": "4ba1c82d"
-      },
-      "source": [
-        "You can test if GPU is available on your machine and thus train on it to speed up the process"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 3,
-      "id": "6e18f2fd",
-      "metadata": {
-        "id": "6e18f2fd",
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "outputId": "a666e7ad-55dc-4d88-c5d9-e13b8a51d0f3"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "CUDA is available!  Training on GPU ...\n"
-          ]
-        }
-      ],
-      "source": [
-        "import torch\n",
-        "\n",
-        "# check if CUDA is available\n",
-        "train_on_gpu = torch.cuda.is_available()\n",
-        "\n",
-        "if not train_on_gpu:\n",
-        "    print(\"CUDA is not available.  Training on CPU ...\")\n",
-        "else:\n",
-        "    print(\"CUDA is available!  Training on GPU ...\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "5cf214eb",
-      "metadata": {
-        "id": "5cf214eb"
-      },
-      "source": [
-        "Next we load the CIFAR10 dataset"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 8,
-      "id": "462666a2",
-      "metadata": {
-        "id": "462666a2",
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "outputId": "4eca06d5-0aac-4650-8c93-8f9c747d4f69"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to data/cifar-10-python.tar.gz\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "100%|██████████| 170M/170M [00:04<00:00, 35.0MB/s]\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Extracting data/cifar-10-python.tar.gz to data\n",
-            "Files already downloaded and verified\n"
-          ]
-        }
-      ],
-      "source": [
-        "import numpy as np\n",
-        "from torchvision import datasets, transforms\n",
-        "from torch.utils.data.sampler import SubsetRandomSampler\n",
-        "\n",
-        "# number of subprocesses to use for data loading\n",
-        "num_workers = 0\n",
-        "# how many samples per batch to load\n",
-        "batch_size = 20\n",
-        "# percentage of training set to use as validation\n",
-        "valid_size = 0.2\n",
-        "\n",
-        "# convert data to a normalized torch.FloatTensor\n",
-        "transform = transforms.Compose(\n",
-        "    [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]\n",
-        ")\n",
-        "\n",
-        "# choose the training and test datasets\n",
-        "train_data = datasets.CIFAR10(\"data\", train=True, download=True, transform=transform)\n",
-        "test_data = datasets.CIFAR10(\"data\", train=False, download=True, transform=transform)\n",
-        "\n",
-        "# obtain training indices that will be used for validation\n",
-        "num_train = len(train_data)\n",
-        "indices = list(range(num_train))\n",
-        "np.random.shuffle(indices)\n",
-        "split = int(np.floor(valid_size * num_train))\n",
-        "train_idx, valid_idx = indices[split:], indices[:split]\n",
-        "\n",
-        "# define samplers for obtaining training and validation batches\n",
-        "train_sampler = SubsetRandomSampler(train_idx)\n",
-        "valid_sampler = SubsetRandomSampler(valid_idx)\n",
-        "\n",
-        "# prepare data loaders (combine dataset and sampler)\n",
-        "train_loader = torch.utils.data.DataLoader(\n",
-        "    train_data, batch_size=batch_size, sampler=train_sampler, num_workers=num_workers\n",
-        ")\n",
-        "valid_loader = torch.utils.data.DataLoader(\n",
-        "    train_data, batch_size=batch_size, sampler=valid_sampler, num_workers=num_workers\n",
-        ")\n",
-        "test_loader = torch.utils.data.DataLoader(\n",
-        "    test_data, batch_size=batch_size, num_workers=num_workers\n",
-        ")\n",
-        "\n",
-        "# specify the image classes\n",
-        "classes = [\n",
-        "    \"airplane\",\n",
-        "    \"automobile\",\n",
-        "    \"bird\",\n",
-        "    \"cat\",\n",
-        "    \"deer\",\n",
-        "    \"dog\",\n",
-        "    \"frog\",\n",
-        "    \"horse\",\n",
-        "    \"ship\",\n",
-        "    \"truck\",\n",
-        "]"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "58ec3903",
-      "metadata": {
-        "id": "58ec3903"
-      },
-      "source": [
-        "CNN definition (this one is an example)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 9,
-      "id": "317bf070",
-      "metadata": {
-        "id": "317bf070",
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "outputId": "56912add-0577-4c19-8013-68adcac49132"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Net(\n",
-            "  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))\n",
-            "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
-            "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
-            "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
-            "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
-            "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
-            ")\n"
-          ]
-        }
-      ],
-      "source": [
-        "import torch.nn as nn\n",
-        "import torch.nn.functional as F\n",
-        "\n",
-        "# define the CNN architecture\n",
-        "\n",
-        "\n",
-        "class Net(nn.Module):\n",
-        "    def __init__(self):\n",
-        "        super(Net, self).__init__()\n",
-        "        self.conv1 = nn.Conv2d(3, 6, 5)\n",
-        "        self.pool = nn.MaxPool2d(2, 2)\n",
-        "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
-        "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
-        "        self.fc2 = nn.Linear(120, 84)\n",
-        "        self.fc3 = nn.Linear(84, 10)\n",
-        "\n",
-        "    def forward(self, x):\n",
-        "        x = self.pool(F.relu(self.conv1(x)))\n",
-        "        x = self.pool(F.relu(self.conv2(x)))\n",
-        "        x = x.view(-1, 16 * 5 * 5)\n",
-        "        x = F.relu(self.fc1(x))\n",
-        "        x = F.relu(self.fc2(x))\n",
-        "        x = self.fc3(x)\n",
-        "        return x\n",
-        "\n",
-        "\n",
-        "# create a complete CNN\n",
-        "model = Net()\n",
-        "print(model)\n",
-        "# move tensors to GPU if CUDA is available\n",
-        "if train_on_gpu:\n",
-        "    model.cuda()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "a2dc4974",
-      "metadata": {
-        "id": "a2dc4974"
-      },
-      "source": [
-        "Loss function and training using SGD (Stochastic Gradient Descent) optimizer"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 10,
-      "id": "4b53f229",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "4b53f229",
-        "outputId": "b635846d-cfa6-4864-a32a-0e2c61a7bbaf"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Epoch: 0 \tTraining Loss: 44.038691 \tValidation Loss: 39.899024\n",
-            "Validation loss decreased (inf --> 39.899024).  Saving model ...\n",
-            "Epoch: 1 \tTraining Loss: 35.893642 \tValidation Loss: 33.235785\n",
-            "Validation loss decreased (39.899024 --> 33.235785).  Saving model ...\n",
-            "Epoch: 2 \tTraining Loss: 31.461009 \tValidation Loss: 29.621095\n",
-            "Validation loss decreased (33.235785 --> 29.621095).  Saving model ...\n",
-            "Epoch: 3 \tTraining Loss: 28.733553 \tValidation Loss: 28.297773\n",
-            "Validation loss decreased (29.621095 --> 28.297773).  Saving model ...\n",
-            "Epoch: 4 \tTraining Loss: 26.963451 \tValidation Loss: 26.412986\n",
-            "Validation loss decreased (28.297773 --> 26.412986).  Saving model ...\n",
-            "Epoch: 5 \tTraining Loss: 25.590625 \tValidation Loss: 25.926439\n",
-            "Validation loss decreased (26.412986 --> 25.926439).  Saving model ...\n",
-            "Epoch: 6 \tTraining Loss: 24.364280 \tValidation Loss: 25.367648\n",
-            "Validation loss decreased (25.926439 --> 25.367648).  Saving model ...\n",
-            "Epoch: 7 \tTraining Loss: 23.346202 \tValidation Loss: 24.768607\n",
-            "Validation loss decreased (25.367648 --> 24.768607).  Saving model ...\n",
-            "Epoch: 8 \tTraining Loss: 22.379130 \tValidation Loss: 23.399870\n",
-            "Validation loss decreased (24.768607 --> 23.399870).  Saving model ...\n",
-            "Epoch: 9 \tTraining Loss: 21.528287 \tValidation Loss: 23.929243\n",
-            "Epoch: 10 \tTraining Loss: 20.749060 \tValidation Loss: 22.869238\n",
-            "Validation loss decreased (23.399870 --> 22.869238).  Saving model ...\n",
-            "Epoch: 11 \tTraining Loss: 20.020419 \tValidation Loss: 23.134749\n",
-            "Epoch: 12 \tTraining Loss: 19.335370 \tValidation Loss: 22.266936\n",
-            "Validation loss decreased (22.869238 --> 22.266936).  Saving model ...\n",
-            "Epoch: 13 \tTraining Loss: 18.723556 \tValidation Loss: 22.868227\n",
-            "Epoch: 14 \tTraining Loss: 18.106807 \tValidation Loss: 22.656285\n",
-            "Epoch: 15 \tTraining Loss: 17.507755 \tValidation Loss: 22.731841\n",
-            "Epoch: 16 \tTraining Loss: 16.910457 \tValidation Loss: 22.978564\n",
-            "Epoch: 17 \tTraining Loss: 16.362614 \tValidation Loss: 22.398967\n",
-            "Epoch: 18 \tTraining Loss: 15.794768 \tValidation Loss: 23.340474\n",
-            "Epoch: 19 \tTraining Loss: 15.321738 \tValidation Loss: 24.281617\n",
-            "Epoch: 20 \tTraining Loss: 14.806355 \tValidation Loss: 23.759720\n",
-            "Epoch: 21 \tTraining Loss: 14.317786 \tValidation Loss: 23.553277\n",
-            "Epoch: 22 \tTraining Loss: 13.832166 \tValidation Loss: 23.480105\n",
-            "Epoch: 23 \tTraining Loss: 13.343578 \tValidation Loss: 24.185503\n",
-            "Epoch: 24 \tTraining Loss: 12.897845 \tValidation Loss: 24.910838\n",
-            "Epoch: 25 \tTraining Loss: 12.507436 \tValidation Loss: 24.985278\n",
-            "Epoch: 26 \tTraining Loss: 12.090102 \tValidation Loss: 25.659139\n",
-            "Epoch: 27 \tTraining Loss: 11.729638 \tValidation Loss: 27.197954\n",
-            "Epoch: 28 \tTraining Loss: 11.274616 \tValidation Loss: 28.539263\n",
-            "Epoch: 29 \tTraining Loss: 10.903824 \tValidation Loss: 27.740380\n"
-          ]
-        }
-      ],
-      "source": [
-        "import torch.optim as optim\n",
-        "\n",
-        "criterion = nn.CrossEntropyLoss()  # specify loss function\n",
-        "optimizer = optim.SGD(model.parameters(), lr=0.01)  # specify optimizer\n",
-        "\n",
-        "n_epochs = 30  # number of epochs to train the model\n",
-        "train_loss_list = []  # list to store loss to visualize\n",
-        "valid_loss_min = np.Inf  # track change in validation loss\n",
-        "\n",
-        "for epoch in range(n_epochs):\n",
-        "    # Keep track of training and validation loss\n",
-        "    train_loss = 0.0\n",
-        "    valid_loss = 0.0\n",
-        "\n",
-        "    # Train the model\n",
-        "    model.train()\n",
-        "    for data, target in train_loader:\n",
-        "        # Move tensors to GPU if CUDA is available\n",
-        "        if train_on_gpu:\n",
-        "            data, target = data.cuda(), target.cuda()\n",
-        "        # Clear the gradients of all optimized variables\n",
-        "        optimizer.zero_grad()\n",
-        "        # Forward pass: compute predicted outputs by passing inputs to the model\n",
-        "        output = model(data)\n",
-        "        # Calculate the batch loss\n",
-        "        loss = criterion(output, target)\n",
-        "        # Backward pass: compute gradient of the loss with respect to model parameters\n",
-        "        loss.backward()\n",
-        "        # Perform a single optimization step (parameter update)\n",
-        "        optimizer.step()\n",
-        "        # Update training loss\n",
-        "        train_loss += loss.item() * data.size(0)\n",
-        "\n",
-        "    # Validate the model\n",
-        "    model.eval()\n",
-        "    for data, target in valid_loader:\n",
-        "        # Move tensors to GPU if CUDA is available\n",
-        "        if train_on_gpu:\n",
-        "            data, target = data.cuda(), target.cuda()\n",
-        "        # Forward pass: compute predicted outputs by passing inputs to the model\n",
-        "        output = model(data)\n",
-        "        # Calculate the batch loss\n",
-        "        loss = criterion(output, target)\n",
-        "        # Update average validation loss\n",
-        "        valid_loss += loss.item() * data.size(0)\n",
-        "\n",
-        "    # Calculate average losses\n",
-        "    train_loss = train_loss / len(train_loader)\n",
-        "    valid_loss = valid_loss / len(valid_loader)\n",
-        "    train_loss_list.append(train_loss)\n",
-        "\n",
-        "    # Print training/validation statistics\n",
-        "    print(\n",
-        "        \"Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}\".format(\n",
-        "            epoch, train_loss, valid_loss\n",
-        "        )\n",
-        "    )\n",
-        "\n",
-        "    # Save model if validation loss has decreased\n",
-        "    if valid_loss <= valid_loss_min:\n",
-        "        print(\n",
-        "            \"Validation loss decreased ({:.6f} --> {:.6f}).  Saving model ...\".format(\n",
-        "                valid_loss_min, valid_loss\n",
-        "            )\n",
-        "        )\n",
-        "        torch.save(model.state_dict(), \"/content/save_data/model_cifar.pt\")\n",
-        "        valid_loss_min = valid_loss"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "13e1df74",
-      "metadata": {
-        "id": "13e1df74"
-      },
-      "source": [
-        "Does overfit occur? If so, do an early stopping."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 11,
-      "id": "d39df818",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 472
-        },
-        "id": "d39df818",
-        "outputId": "cd9d0021-66ad-4c92-8a66-8db8214837ee"
-      },
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "import matplotlib.pyplot as plt\n",
-        "\n",
-        "plt.plot(range(n_epochs), train_loss_list)\n",
-        "plt.xlabel(\"Epoch\")\n",
-        "plt.ylabel(\"Loss\")\n",
-        "plt.title(\"Performance of Model 1\")\n",
-        "plt.show()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "11df8fd4",
-      "metadata": {
-        "id": "11df8fd4"
-      },
-      "source": [
-        "Now loading the model with the lowest validation loss value\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 12,
-      "id": "e93efdfc",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "e93efdfc",
-        "outputId": "528eddc6-7bb8-421d-94aa-e43340b8c3c4"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "<ipython-input-12-022d8c474780>:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
-            "  model.load_state_dict(torch.load(\"/content/save_data/model_cifar.pt\"))\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Test Loss: 22.373568\n",
-            "\n",
-            "Test Accuracy of airplane: 70% (709/1000)\n",
-            "Test Accuracy of automobile: 67% (676/1000)\n",
-            "Test Accuracy of  bird: 49% (493/1000)\n",
-            "Test Accuracy of   cat: 31% (319/1000)\n",
-            "Test Accuracy of  deer: 40% (400/1000)\n",
-            "Test Accuracy of   dog: 59% (590/1000)\n",
-            "Test Accuracy of  frog: 79% (792/1000)\n",
-            "Test Accuracy of horse: 70% (700/1000)\n",
-            "Test Accuracy of  ship: 77% (779/1000)\n",
-            "Test Accuracy of truck: 64% (647/1000)\n",
-            "\n",
-            "Test Accuracy (Overall): 61% (6105/10000)\n"
-          ]
-        }
-      ],
-      "source": [
-        "model.load_state_dict(torch.load(\"/content/save_data/model_cifar.pt\"))\n",
-        "\n",
-        "# track test loss\n",
-        "test_loss = 0.0\n",
-        "class_correct = list(0.0 for i in range(10))\n",
-        "class_total = list(0.0 for i in range(10))\n",
-        "\n",
-        "model.eval()\n",
-        "# iterate over test data\n",
-        "for data, target in test_loader:\n",
-        "    # move tensors to GPU if CUDA is available\n",
-        "    if train_on_gpu:\n",
-        "        data, target = data.cuda(), target.cuda()\n",
-        "    # forward pass: compute predicted outputs by passing inputs to the model\n",
-        "    output = model(data)\n",
-        "    # calculate the batch loss\n",
-        "    loss = criterion(output, target)\n",
-        "    # update test loss\n",
-        "    test_loss += loss.item() * data.size(0)\n",
-        "    # convert output probabilities to predicted class\n",
-        "    _, pred = torch.max(output, 1)\n",
-        "    # compare predictions to true label\n",
-        "    correct_tensor = pred.eq(target.data.view_as(pred))\n",
-        "    correct = (\n",
-        "        np.squeeze(correct_tensor.numpy())\n",
-        "        if not train_on_gpu\n",
-        "        else np.squeeze(correct_tensor.cpu().numpy())\n",
-        "    )\n",
-        "    # calculate test accuracy for each object class\n",
-        "    for i in range(batch_size):\n",
-        "        label = target.data[i]\n",
-        "        class_correct[label] += correct[i].item()\n",
-        "        class_total[label] += 1\n",
-        "\n",
-        "# average test loss\n",
-        "test_loss = test_loss / len(test_loader)\n",
-        "print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n",
-        "\n",
-        "for i in range(10):\n",
-        "    if class_total[i] > 0:\n",
-        "        print(\n",
-        "            \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
-        "            % (\n",
-        "                classes[i],\n",
-        "                100 * class_correct[i] / class_total[i],\n",
-        "                np.sum(class_correct[i]),\n",
-        "                np.sum(class_total[i]),\n",
-        "            )\n",
-        "        )\n",
-        "    else:\n",
-        "        print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n",
-        "\n",
-        "print(\n",
-        "    \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n",
-        "    % (\n",
-        "        100.0 * np.sum(class_correct) / np.sum(class_total),\n",
-        "        np.sum(class_correct),\n",
-        "        np.sum(class_total),\n",
-        "    )\n",
-        ")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "944991a2",
-      "metadata": {
-        "id": "944991a2"
-      },
-      "source": [
-        "Build a new network with the following structure.\n",
-        "\n",
-        "- It has 3 convolutional layers of kernel size 3 and padding of 1.\n",
-        "- The first convolutional layer must output 16 channels, the second 32 and the third 64.\n",
-        "- At each convolutional layer output, we apply a ReLU activation then a MaxPool with kernel size of 2.\n",
-        "- Then, three fully connected layers, the first two being followed by a ReLU activation and a dropout whose value you will suggest.\n",
-        "- The first fully connected layer will have an output size of 512.\n",
-        "- The second fully connected layer will have an output size of 64.\n",
-        "\n",
-        "Compare the results obtained with this new network to those obtained previously."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 13,
-      "id": "2DvrdR_nsGqq",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "2DvrdR_nsGqq",
-        "outputId": "cc887236-ba43-4550-8bcb-baca5e48cb1a"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Net2(\n",
-            "  (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-            "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
-            "  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-            "  (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-            "  (fc1): Linear(in_features=1024, out_features=512, bias=True)\n",
-            "  (fc2): Linear(in_features=512, out_features=64, bias=True)\n",
-            "  (fc3): Linear(in_features=64, out_features=10, bias=True)\n",
-            "  (dropout): Dropout(p=0.5, inplace=False)\n",
-            ")\n"
-          ]
-        }
-      ],
-      "source": [
-        "import torch.nn as nn\n",
-        "import torch.nn.functional as F\n",
-        "\n",
-        "class Net2(nn.Module):  # Ensure it inherits from nn.Module\n",
-        "    def __init__(self, dropout_prob):\n",
-        "        super(Net2, self).__init__()\n",
-        "        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)  # (input channels, output channels, kernel size 3x3)\n",
-        "        self.pool = nn.MaxPool2d(2, 2)  # (kernel size, stride)\n",
-        "        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)  # (input channels, output channels, kernel size 3x3)\n",
-        "        self.conv3 = nn.Conv2d(32, 64, 3, padding=1)  # (input channels, output channels, kernel size 3x3)\n",
-        "        self.fc1 = nn.Linear(64 * 4 * 4, 512)  # (input, output)\n",
-        "        self.fc2 = nn.Linear(512, 64)  # (input, output)\n",
-        "        self.fc3 = nn.Linear(64, 10)  # (input, output = number of classes)\n",
-        "\n",
-        "        # Dropout layer\n",
-        "        self.dropout = nn.Dropout(p=dropout_prob)\n",
-        "\n",
-        "    def forward(self, x):\n",
-        "        x = self.pool(F.relu(self.conv1(x)))\n",
-        "        x = self.pool(F.relu(self.conv2(x)))\n",
-        "        x = self.pool(F.relu(self.conv3(x)))\n",
-        "        x = x.view(-1, 64 * 4 * 4)\n",
-        "        x = F.relu(self.fc1(x))\n",
-        "        x = F.relu(self.fc2(x))\n",
-        "        x = self.fc3(x)\n",
-        "        x = self.dropout(x)  # Apply dropout\n",
-        "        return x\n",
-        "\n",
-        "# Create a complete CNN\n",
-        "model2 = Net2(dropout_prob=0.5)  # Pass dropout probability when creating the model\n",
-        "print(model2)\n",
-        "\n",
-        "# Move tensors to GPU if CUDA is available\n",
-        "train_on_gpu = torch.cuda.is_available()\n",
-        "if train_on_gpu:\n",
-        "    model2.cuda()\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 15,
-      "id": "IJz2Q9T25Qc3",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "IJz2Q9T25Qc3",
-        "outputId": "d7a1f11c-6ffd-49f7-e4d6-4a2bf90016cf"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Epoch: 0 \tTraining Loss: 44.900920 \tValidation Loss: 40.766211\n",
-            "Validation loss decreased (inf --> 40.766211).  Saving model ...\n",
-            "Epoch: 1 \tTraining Loss: 40.962535 \tValidation Loss: 36.220546\n",
-            "Validation loss decreased (40.766211 --> 36.220546).  Saving model ...\n",
-            "Epoch: 2 \tTraining Loss: 38.644727 \tValidation Loss: 33.266595\n",
-            "Validation loss decreased (36.220546 --> 33.266595).  Saving model ...\n",
-            "Epoch: 3 \tTraining Loss: 37.229567 \tValidation Loss: 32.241205\n",
-            "Validation loss decreased (33.266595 --> 32.241205).  Saving model ...\n",
-            "Epoch: 4 \tTraining Loss: 36.195308 \tValidation Loss: 29.560483\n",
-            "Validation loss decreased (32.241205 --> 29.560483).  Saving model ...\n",
-            "Epoch: 5 \tTraining Loss: 35.120303 \tValidation Loss: 27.983202\n",
-            "Validation loss decreased (29.560483 --> 27.983202).  Saving model ...\n",
-            "Epoch: 6 \tTraining Loss: 34.259414 \tValidation Loss: 26.992002\n",
-            "Validation loss decreased (27.983202 --> 26.992002).  Saving model ...\n",
-            "Epoch: 7 \tTraining Loss: 33.302069 \tValidation Loss: 25.630227\n",
-            "Validation loss decreased (26.992002 --> 25.630227).  Saving model ...\n",
-            "Epoch: 8 \tTraining Loss: 32.202420 \tValidation Loss: 24.588620\n",
-            "Validation loss decreased (25.630227 --> 24.588620).  Saving model ...\n",
-            "Epoch: 9 \tTraining Loss: 31.568073 \tValidation Loss: 23.482576\n",
-            "Validation loss decreased (24.588620 --> 23.482576).  Saving model ...\n"
-          ]
-        }
-      ],
-      "source": [
-        "import torch.optim as optim\n",
-        "\n",
-        "criterion = nn.CrossEntropyLoss()  # specify loss function\n",
-        "optimizer = optim.SGD(model2.parameters(), lr=0.01)  # specify optimizer\n",
-        "\n",
-        "n_epochs = 10  # number of epochs to train the model\n",
-        "train_loss_list = []  # list to store loss to visualize\n",
-        "valid_loss_min = np.Inf  # track change in validation loss\n",
-        "\n",
-        "for epoch in range(n_epochs):\n",
-        "    # Keep track of training and validation loss\n",
-        "    train_loss = 0.0\n",
-        "    valid_loss = 0.0\n",
-        "\n",
-        "    # Train the model\n",
-        "    model2.train()\n",
-        "    for data, target in train_loader:\n",
-        "        # Move tensors to GPU if CUDA is available\n",
-        "        if train_on_gpu:\n",
-        "            data, target = data.cuda(), target.cuda()\n",
-        "        # Clear the gradients of all optimized variables\n",
-        "        optimizer.zero_grad()\n",
-        "        # Forward pass: compute predicted outputs by passing inputs to the model\n",
-        "        output = model2(data)\n",
-        "        # Calculate the batch loss\n",
-        "        loss = criterion(output, target)\n",
-        "        # Backward pass: compute gradient of the loss with respect to model parameters\n",
-        "        loss.backward()\n",
-        "        # Perform a single optimization step (parameter update)\n",
-        "        optimizer.step()\n",
-        "        # Update training loss\n",
-        "        train_loss += loss.item() * data.size(0)\n",
-        "\n",
-        "    # Validate the model\n",
-        "    model2.eval()\n",
-        "    for data, target in valid_loader:\n",
-        "        # Move tensors to GPU if CUDA is available\n",
-        "        if train_on_gpu:\n",
-        "            data, target = data.cuda(), target.cuda()\n",
-        "        # Forward pass: compute predicted outputs by passing inputs to the model\n",
-        "        output = model2(data)\n",
-        "        # Calculate the batch loss\n",
-        "        loss = criterion(output, target)\n",
-        "        # Update average validation loss\n",
-        "        valid_loss += loss.item() * data.size(0)\n",
-        "\n",
-        "    # Calculate average losses\n",
-        "    train_loss = train_loss / len(train_loader)\n",
-        "    valid_loss = valid_loss / len(valid_loader)\n",
-        "    train_loss_list.append(train_loss)\n",
-        "\n",
-        "    # Print training/validation statistics\n",
-        "    print(\n",
-        "        \"Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}\".format(\n",
-        "            epoch, train_loss, valid_loss\n",
-        "        )\n",
-        "    )\n",
-        "\n",
-        "    # Save model if validation loss has decreased\n",
-        "    if valid_loss <= valid_loss_min:\n",
-        "        print(\n",
-        "            \"Validation loss decreased ({:.6f} --> {:.6f}).  Saving model ...\".format(\n",
-        "                valid_loss_min, valid_loss\n",
-        "            )\n",
-        "        )\n",
-        "        torch.save(model2.state_dict(), \"/content/save_data/model2_cifar.pt\")\n",
-        "        valid_loss_min = valid_loss"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "hNYf38f_sSfo",
-      "metadata": {
-        "id": "hNYf38f_sSfo"
-      },
-      "source": []
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "aQVARMhv7y1b",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 472
-        },
-        "id": "aQVARMhv7y1b",
-        "outputId": "a960fab4-f083-49f5-e54a-21fdb674cb03"
-      },
-      "outputs": [
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "import matplotlib.pyplot as plt\n",
-        "\n",
-        "plt.plot(range(n_epochs), train_loss_list)\n",
-        "plt.xlabel(\"Epoch\")\n",
-        "plt.ylabel(\"Loss\")\n",
-        "plt.title(\"Performance of Model 2\")\n",
-        "plt.show()"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 16,
-      "id": "06j_Dr6475Kb",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "06j_Dr6475Kb",
-        "outputId": "7e5745d9-7737-41c1-bd0d-c22f446e2aa8"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "<ipython-input-16-ee85c886ffd9>:1: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
-            "  model2.load_state_dict(torch.load(\"/content/save_data/model2_cifar.pt\"))\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Test Loss: 23.372290\n",
-            "\n",
-            "Test Accuracy of airplane: 72% (725/1000)\n",
-            "Test Accuracy of automobile: 84% (842/1000)\n",
-            "Test Accuracy of  bird: 33% (339/1000)\n",
-            "Test Accuracy of   cat: 21% (216/1000)\n",
-            "Test Accuracy of  deer: 65% (659/1000)\n",
-            "Test Accuracy of   dog: 72% (720/1000)\n",
-            "Test Accuracy of  frog: 64% (648/1000)\n",
-            "Test Accuracy of horse: 75% (758/1000)\n",
-            "Test Accuracy of  ship: 66% (668/1000)\n",
-            "Test Accuracy of truck: 70% (702/1000)\n",
-            "\n",
-            "Test Accuracy (Overall): 62% (6277/10000)\n"
-          ]
-        }
-      ],
-      "source": [
-        "model2.load_state_dict(torch.load(\"/content/save_data/model2_cifar.pt\"))\n",
-        "\n",
-        "# track test loss\n",
-        "test_loss = 0.0\n",
-        "class_correct = list(0.0 for i in range(10))\n",
-        "class_total = list(0.0 for i in range(10))\n",
-        "\n",
-        "model2.eval()\n",
-        "# iterate over test data\n",
-        "for data, target in test_loader:\n",
-        "    # move tensors to GPU if CUDA is available\n",
-        "    if train_on_gpu:\n",
-        "        data, target = data.cuda(), target.cuda()\n",
-        "    # forward pass: compute predicted outputs by passing inputs to the model\n",
-        "    output = model2(data)\n",
-        "    # calculate the batch loss\n",
-        "    loss = criterion(output, target)\n",
-        "    # update test loss\n",
-        "    test_loss += loss.item() * data.size(0)\n",
-        "    # convert output probabilities to predicted class\n",
-        "    _, pred = torch.max(output, 1)\n",
-        "    # compare predictions to true label\n",
-        "    correct_tensor = pred.eq(target.data.view_as(pred))\n",
-        "    correct = (\n",
-        "        np.squeeze(correct_tensor.numpy())\n",
-        "        if not train_on_gpu\n",
-        "        else np.squeeze(correct_tensor.cpu().numpy())\n",
-        "    )\n",
-        "    # calculate test accuracy for each object class\n",
-        "    for i in range(batch_size):\n",
-        "        label = target.data[i]\n",
-        "        class_correct[label] += correct[i].item()\n",
-        "        class_total[label] += 1\n",
-        "\n",
-        "# average test loss\n",
-        "test_loss = test_loss / len(test_loader)\n",
-        "print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n",
-        "\n",
-        "for i in range(10):\n",
-        "    if class_total[i] > 0:\n",
-        "        print(\n",
-        "            \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
-        "            % (\n",
-        "                classes[i],\n",
-        "                100 * class_correct[i] / class_total[i],\n",
-        "                np.sum(class_correct[i]),\n",
-        "                np.sum(class_total[i]),\n",
-        "            )\n",
-        "        )\n",
-        "    else:\n",
-        "        print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n",
-        "\n",
-        "print(\n",
-        "    \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n",
-        "    % (\n",
-        "        100.0 * np.sum(class_correct) / np.sum(class_total),\n",
-        "        np.sum(class_correct),\n",
-        "        np.sum(class_total),\n",
-        "    )\n",
-        ")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "bc381cf4",
-      "metadata": {
-        "id": "bc381cf4"
-      },
-      "source": [
-        "## Exercise 2: Quantization: try to compress the CNN to save space\n",
-        "\n",
-        "Quantization doc is available from https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic\n",
-        "        \n",
-        "The Exercise is to quantize post training the above CNN model. Compare the size reduction and the impact on the classification accuracy\n",
-        "\n",
-        "\n",
-        "The size of the model is simply the size of the file."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 17,
-      "id": "ef623c26",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "ef623c26",
-        "outputId": "904dfb78-95a4-48b6-ff7e-f827a14a2d65"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "model:  fp32  \t Size (KB): 251.342\n"
-          ]
-        },
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "251342"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 17
-        }
-      ],
-      "source": [
-        "import os\n",
-        "\n",
-        "\n",
-        "def print_size_of_model(model, label=\"\"):\n",
-        "    torch.save(model.state_dict(), \"temp.p\")\n",
-        "    size = os.path.getsize(\"temp.p\")\n",
-        "    print(\"model: \", label, \" \\t\", \"Size (KB):\", size / 1e3)\n",
-        "    os.remove(\"temp.p\")\n",
-        "    return size\n",
-        "\n",
-        "\n",
-        "print_size_of_model(model, \"fp32\")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "05c4e9ad",
-      "metadata": {
-        "id": "05c4e9ad"
-      },
-      "source": [
-        "Post training quantization example"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        " import torch.quantization\n",
-        "\n",
-        "model2.to(\"cpu\")\n",
-        "quantized_model = torch.quantization.quantize_dynamic(model2, dtype=torch.qint8)\n",
-        "print_size_of_model(model2, \"fp32\")\n",
-        "print_size_of_model(quantized_model, \"int8\")"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "38_XJKcrX5Lq",
-        "outputId": "ebef688d-5025-410d-a939-7bd8aeb6b670"
-      },
-      "id": "38_XJKcrX5Lq",
-      "execution_count": 18,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "model:  fp32  \t Size (KB): 2330.946\n",
-            "model:  int8  \t Size (KB): 659.806\n"
-          ]
-        },
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "659806"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 18
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "source": [
-        "The size of the model reduces by more than 3 thanks to the dynamic quantization."
-      ],
-      "metadata": {
-        "id": "mCL0R6GGatxw"
-      },
-      "id": "mCL0R6GGatxw"
-    },
-    {
-      "cell_type": "markdown",
-      "id": "7b108e17",
-      "metadata": {
-        "id": "7b108e17"
-      },
-      "source": [
-        "For each class, compare the classification test accuracy of the initial model and the quantized model. Also give the overall test accuracy for both models."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "ZXeLJC39QjOP",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "ZXeLJC39QjOP",
-        "outputId": "4bc24c61-e094-4f60-f8fa-4c6a73faf7e9"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Net2(\n",
-            "  (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-            "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
-            "  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-            "  (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
-            "  (fc1): DynamicQuantizedLinear(in_features=1024, out_features=512, dtype=torch.qint8, qscheme=torch.per_tensor_affine)\n",
-            "  (fc2): DynamicQuantizedLinear(in_features=512, out_features=64, dtype=torch.qint8, qscheme=torch.per_tensor_affine)\n",
-            "  (fc3): DynamicQuantizedLinear(in_features=64, out_features=10, dtype=torch.qint8, qscheme=torch.per_tensor_affine)\n",
-            "  (dropout): Dropout(p=0.5, inplace=False)\n",
-            ")\n",
-            "Test Loss: 24.060782\n",
-            "\n",
-            "Test Accuracy of airplane: 61% (613/1000)\n",
-            "Test Accuracy of automobile: 69% (694/1000)\n",
-            "Test Accuracy of  bird: 44% (445/1000)\n",
-            "Test Accuracy of   cat: 33% (335/1000)\n",
-            "Test Accuracy of  deer: 55% (551/1000)\n",
-            "Test Accuracy of   dog: 63% (637/1000)\n",
-            "Test Accuracy of  frog: 70% (704/1000)\n",
-            "Test Accuracy of horse: 69% (696/1000)\n",
-            "Test Accuracy of  ship: 78% (788/1000)\n",
-            "Test Accuracy of truck: 70% (709/1000)\n",
-            "\n",
-            "Test Accuracy (Overall): 61% (6172/10000)\n"
-          ]
-        }
-      ],
-      "source": [
-        "#try with CPU dynamic quantization --> need to convert GPU to CPU device\n",
-        "\n",
-        "# track test loss\n",
-        "test_loss = 0.0\n",
-        "class_correct = list(0.0 for i in range(10))\n",
-        "class_total = list(0.0 for i in range(10))\n",
-        "\n",
-        "quantized_model.eval()\n",
-        "print(quantized_model)\n",
-        "\n",
-        "# iterate over test data\n",
-        "for data, target in test_loader:\n",
-        "    # move tensors to GPU if CUDA is available\n",
-        "    data, target = data.cpu(), target.cpu()\n",
-        "\n",
-        "    #print(data.device, target.device, next(quantized_model.parameters()).device)\n",
-        "    # forward pass: compute predicted outputs by passing inputs to the model\n",
-        "    with torch.no_grad() :\n",
-        "      output = quantized_model(data)\n",
-        "    # calculate the batch loss\n",
-        "    loss = criterion(output, target)\n",
-        "    # update test loss\n",
-        "    test_loss += loss.item() * data.size(0)\n",
-        "    # convert output probabilities to predicted class\n",
-        "    _, pred = torch.max(output, 1)\n",
-        "    # compare predictions to true label\n",
-        "    correct_tensor = pred.eq(target.data.view_as(pred))\n",
-        "    correct = (\n",
-        "        np.squeeze(correct_tensor.cpu().numpy())\n",
-        "\n",
-        "    )\n",
-        "    # calculate test accuracy for each object class\n",
-        "    for i in range(batch_size):\n",
-        "        label = target.data[i]\n",
-        "        class_correct[label] += correct[i].item()\n",
-        "        class_total[label] += 1\n",
-        "\n",
-        "# average test loss\n",
-        "test_loss = test_loss / len(test_loader)\n",
-        "print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n",
-        "\n",
-        "for i in range(10):\n",
-        "    if class_total[i] > 0:\n",
-        "        print(\n",
-        "            \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
-        "            % (\n",
-        "                classes[i],\n",
-        "                100 * class_correct[i] / class_total[i],\n",
-        "                np.sum(class_correct[i]),\n",
-        "                np.sum(class_total[i]),\n",
-        "            )\n",
-        "        )\n",
-        "    else:\n",
-        "        print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n",
-        "\n",
-        "print(\n",
-        "    \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n",
-        "    % (\n",
-        "        100.0 * np.sum(class_correct) / np.sum(class_total),\n",
-        "        np.sum(class_correct),\n",
-        "        np.sum(class_total),\n",
-        "    )\n",
-        ")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "source": [
-        "**Answer** -->The overall test accuracies for the dense model and the quantized model are very close (respectfully 63% and 62%). The class accuracies are  equal for both models, except for dog and ship, where the quantized model has a reduced accuracy of 1%. Looking at the gain by reducing the size of the model, we can consider than it is more interesting to use the quaantized model in this case."
-      ],
-      "metadata": {
-        "id": "NIb1ZktXa6LL"
-      },
-      "id": "NIb1ZktXa6LL"
-    },
-    {
-      "cell_type": "markdown",
-      "id": "a0a34b90",
-      "metadata": {
-        "id": "a0a34b90"
-      },
-      "source": [
-        "Try training aware quantization to mitigate the impact on the accuracy (doc available here https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic)"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "#Training aware quantization\n",
-        "model2.qconfig = torch.quantization.get_default_qconfig(\"fbgemm\")\n",
-        "model2.to(\"cpu\")\n",
-        "\n",
-        "static_quantized_model = torch.quantization.prepare(model2)\n",
-        "static_quantized_model = torch.quantization.convert(static_quantized_model)\n",
-        "print_size_of_model(static_quantized_model)"
-      ],
-      "metadata": {
-        "id": "Sb_TEK6hbwp1",
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "outputId": "51cecc36-99d0-460f-8d90-e4d4d3c9ad64"
-      },
-      "id": "Sb_TEK6hbwp1",
-      "execution_count": 33,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "model:    \t Size (KB): 604.53\n"
-          ]
-        },
-        {
-          "output_type": "execute_result",
-          "data": {
-            "text/plain": [
-              "604530"
-            ]
-          },
-          "metadata": {},
-          "execution_count": 33
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "#try with CPU static quantization --> need to convert GPU to CPU device\n",
-        "\n",
-        "# track test loss\n",
-        "test_loss = 0.0\n",
-        "class_correct = list(0.0 for i in range(10))\n",
-        "class_total = list(0.0 for i in range(10))\n",
-        "\n",
-        "static_quantized_model.eval()\n",
-        "print(static_quantized_model)\n",
-        "\n",
-        "# iterate over test data\n",
-        "for data, target in test_loader:\n",
-        "    # move tensors to CPU\n",
-        "    data, target = data.cpu(), target.cpu()\n",
-        "\n",
-        "    # forward pass: compute predicted outputs by passing inputs to the model\n",
-        "    with torch.no_grad() :\n",
-        "      output = static_quantized_model(data)\n",
-        "    # calculate the batch loss\n",
-        "    loss = criterion(output, target)\n",
-        "    # update test loss\n",
-        "    test_loss += loss.item() * data.size(0)\n",
-        "    # convert output probabilities to predicted class\n",
-        "    _, pred = torch.max(output, 1)\n",
-        "    # compare predictions to true label\n",
-        "    correct_tensor = pred.eq(target.data.view_as(pred))\n",
-        "    correct = (\n",
-        "        np.squeeze(correct_tensor.cpu().numpy())\n",
-        "\n",
-        "    )\n",
-        "    # calculate test accuracy for each object class\n",
-        "    for i in range(batch_size):\n",
-        "        label = target.data[i]\n",
-        "        class_correct[label] += correct[i].item()\n",
-        "        class_total[label] += 1\n",
-        "\n",
-        "# average test loss\n",
-        "test_loss = test_loss / len(test_loader)\n",
-        "print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n",
-        "\n",
-        "for i in range(10):\n",
-        "    if class_total[i] > 0:\n",
-        "        print(\n",
-        "            \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
-        "            % (\n",
-        "                classes[i],\n",
-        "                100 * class_correct[i] / class_total[i],\n",
-        "                np.sum(class_correct[i]),\n",
-        "                np.sum(class_total[i]),\n",
-        "            )\n",
-        "        )\n",
-        "    else:\n",
-        "        print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n",
-        "\n",
-        "print(\n",
-        "    \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n",
-        "    % (\n",
-        "        100.0 * np.sum(class_correct) / np.sum(class_total),\n",
-        "        np.sum(class_correct),\n",
-        "        np.sum(class_total),\n",
-        "    )\n",
-        ")"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 1000
-        },
-        "id": "ylrc7tZaKWd4",
-        "outputId": "5bdfa57b-50cb-4865-c397-2bc5fe0e6e26"
-      },
-      "id": "ylrc7tZaKWd4",
-      "execution_count": 32,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Net2(\n",
-            "  (conv1): QuantizedConv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), scale=1.0, zero_point=0, padding=(1, 1))\n",
-            "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
-            "  (conv2): QuantizedConv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), scale=1.0, zero_point=0, padding=(1, 1))\n",
-            "  (conv3): QuantizedConv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), scale=1.0, zero_point=0, padding=(1, 1))\n",
-            "  (fc1): QuantizedLinear(in_features=1024, out_features=512, scale=1.0, zero_point=0, qscheme=torch.per_channel_affine)\n",
-            "  (fc2): QuantizedLinear(in_features=512, out_features=64, scale=1.0, zero_point=0, qscheme=torch.per_channel_affine)\n",
-            "  (fc3): QuantizedLinear(in_features=64, out_features=10, scale=1.0, zero_point=0, qscheme=torch.per_channel_affine)\n",
-            "  (dropout): QuantizedDropout(p=0.5, inplace=False)\n",
-            ")\n"
-          ]
-        },
-        {
-          "output_type": "error",
-          "ename": "NotImplementedError",
-          "evalue": "Could not run 'quantized::conv2d.new' with arguments from the 'CPU' backend. This could be because the operator doesn't exist for this backend, or was omitted during the selective/custom build process (if using custom build). If you are a Facebook employee using PyTorch on mobile, please visit https://fburl.com/ptmfixes for possible resolutions. 'quantized::conv2d.new' is only available for these backends: [Meta, QuantizedCPU, QuantizedCUDA, BackendSelect, Python, FuncTorchDynamicLayerBackMode, Functionalize, Named, Conjugate, Negative, ZeroTensor, ADInplaceOrView, AutogradOther, AutogradCPU, AutogradCUDA, AutogradXLA, AutogradMPS, AutogradXPU, AutogradHPU, AutogradLazy, AutogradMeta, Tracer, AutocastCPU, AutocastXPU, AutocastMPS, AutocastCUDA, FuncTorchBatched, BatchedNestedTensor, FuncTorchVmapMode, Batched, VmapMode, FuncTorchGradWrapper, PythonTLSSnapshot, FuncTorchDynamicLayerFrontMode, PreDispatch, PythonDispatcher].\n\nMeta: registered at ../aten/src/ATen/core/MetaFallbackKernel.cpp:23 [backend fallback]\nQuantizedCPU: registered at ../aten/src/ATen/native/quantized/cpu/qconv.cpp:1972 [kernel]\nQuantizedCUDA: registered at ../aten/src/ATen/native/quantized/cudnn/Conv.cpp:391 [kernel]\nBackendSelect: fallthrough registered at ../aten/src/ATen/core/BackendSelectFallbackKernel.cpp:3 [backend fallback]\nPython: registered at ../aten/src/ATen/core/PythonFallbackKernel.cpp:153 [backend fallback]\nFuncTorchDynamicLayerBackMode: registered at ../aten/src/ATen/functorch/DynamicLayer.cpp:497 [backend fallback]\nFunctionalize: registered at ../aten/src/ATen/FunctionalizeFallbackKernel.cpp:349 [backend fallback]\nNamed: registered at ../aten/src/ATen/core/NamedRegistrations.cpp:7 [backend fallback]\nConjugate: registered at ../aten/src/ATen/ConjugateFallback.cpp:17 [backend fallback]\nNegative: registered at ../aten/src/ATen/native/NegateFallback.cpp:18 [backend fallback]\nZeroTensor: registered at ../aten/src/ATen/ZeroTensorFallback.cpp:86 [backend fallback]\nADInplaceOrView: fallthrough registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:96 [backend fallback]\nAutogradOther: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:63 [backend fallback]\nAutogradCPU: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:67 [backend fallback]\nAutogradCUDA: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:75 [backend fallback]\nAutogradXLA: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:79 [backend fallback]\nAutogradMPS: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:87 [backend fallback]\nAutogradXPU: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:71 [backend fallback]\nAutogradHPU: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:100 [backend fallback]\nAutogradLazy: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:83 [backend fallback]\nAutogradMeta: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:91 [backend fallback]\nTracer: registered at ../torch/csrc/autograd/TraceTypeManual.cpp:294 [backend fallback]\nAutocastCPU: fallthrough registered at ../aten/src/ATen/autocast_mode.cpp:321 [backend fallback]\nAutocastXPU: fallthrough registered at ../aten/src/ATen/autocast_mode.cpp:463 [backend fallback]\nAutocastMPS: fallthrough registered at ../aten/src/ATen/autocast_mode.cpp:209 [backend fallback]\nAutocastCUDA: fallthrough registered at ../aten/src/ATen/autocast_mode.cpp:165 [backend fallback]\nFuncTorchBatched: registered at ../aten/src/ATen/functorch/LegacyBatchingRegistrations.cpp:731 [backend fallback]\nBatchedNestedTensor: registered at ../aten/src/ATen/functorch/LegacyBatchingRegistrations.cpp:758 [backend fallback]\nFuncTorchVmapMode: fallthrough registered at ../aten/src/ATen/functorch/VmapModeRegistrations.cpp:27 [backend fallback]\nBatched: registered at ../aten/src/ATen/LegacyBatchingRegistrations.cpp:1075 [backend fallback]\nVmapMode: fallthrough registered at ../aten/src/ATen/VmapModeRegistrations.cpp:33 [backend fallback]\nFuncTorchGradWrapper: registered at ../aten/src/ATen/functorch/TensorWrapper.cpp:207 [backend fallback]\nPythonTLSSnapshot: registered at ../aten/src/ATen/core/PythonFallbackKernel.cpp:161 [backend fallback]\nFuncTorchDynamicLayerFrontMode: registered at ../aten/src/ATen/functorch/DynamicLayer.cpp:493 [backend fallback]\nPreDispatch: registered at ../aten/src/ATen/core/PythonFallbackKernel.cpp:165 [backend fallback]\nPythonDispatcher: registered at ../aten/src/ATen/core/PythonFallbackKernel.cpp:157 [backend fallback]\n",
-          "traceback": [
-            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-            "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
-            "\u001b[0;32m<ipython-input-32-c4c1bd69ab25>\u001b[0m in \u001b[0;36m<cell line: 12>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     16\u001b[0m     \u001b[0;31m# forward pass: compute predicted outputs by passing inputs to the model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mno_grad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m       \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstatic_quantized_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     19\u001b[0m     \u001b[0;31m# calculate the batch loss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m     \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1735\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1736\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1737\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1738\u001b[0m     \u001b[0;31m# torchrec tests the code consistency with the following code\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1745\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1746\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1748\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1749\u001b[0m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m<ipython-input-13-fc26374c7ea5>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrelu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     20\u001b[0m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrelu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrelu\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconv3\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1734\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiled_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[misc]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1735\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1736\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1737\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1738\u001b[0m     \u001b[0;31m# torchrec tests the code consistency with the following code\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1745\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1746\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1747\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1748\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1749\u001b[0m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/ao/nn/quantized/modules/conv.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    593\u001b[0m                 \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_reversed_padding_repeated_twice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpadding_mode\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    594\u001b[0m             )\n\u001b[0;32m--> 595\u001b[0;31m         return ops.quantized.conv2d(\n\u001b[0m\u001b[1;32m    596\u001b[0m             \u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_packed_params\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscale\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzero_point\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    597\u001b[0m         )\n",
-            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/_ops.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1114\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_has_torchbind_op_overload\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0m_must_dispatch_in_python\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1115\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0m_call_overload_packet_from_python\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1116\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_op\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkwargs\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1117\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1118\u001b[0m     \u001b[0;31m# TODO: use this to make a __dir__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-            "\u001b[0;31mNotImplementedError\u001b[0m: Could not run 'quantized::conv2d.new' with arguments from the 'CPU' backend. This could be because the operator doesn't exist for this backend, or was omitted during the selective/custom build process (if using custom build). If you are a Facebook employee using PyTorch on mobile, please visit https://fburl.com/ptmfixes for possible resolutions. 'quantized::conv2d.new' is only available for these backends: [Meta, QuantizedCPU, QuantizedCUDA, BackendSelect, Python, FuncTorchDynamicLayerBackMode, Functionalize, Named, Conjugate, Negative, ZeroTensor, ADInplaceOrView, AutogradOther, AutogradCPU, AutogradCUDA, AutogradXLA, AutogradMPS, AutogradXPU, AutogradHPU, AutogradLazy, AutogradMeta, Tracer, AutocastCPU, AutocastXPU, AutocastMPS, AutocastCUDA, FuncTorchBatched, BatchedNestedTensor, FuncTorchVmapMode, Batched, VmapMode, FuncTorchGradWrapper, PythonTLSSnapshot, FuncTorchDynamicLayerFrontMode, PreDispatch, PythonDispatcher].\n\nMeta: registered at ../aten/src/ATen/core/MetaFallbackKernel.cpp:23 [backend fallback]\nQuantizedCPU: registered at ../aten/src/ATen/native/quantized/cpu/qconv.cpp:1972 [kernel]\nQuantizedCUDA: registered at ../aten/src/ATen/native/quantized/cudnn/Conv.cpp:391 [kernel]\nBackendSelect: fallthrough registered at ../aten/src/ATen/core/BackendSelectFallbackKernel.cpp:3 [backend fallback]\nPython: registered at ../aten/src/ATen/core/PythonFallbackKernel.cpp:153 [backend fallback]\nFuncTorchDynamicLayerBackMode: registered at ../aten/src/ATen/functorch/DynamicLayer.cpp:497 [backend fallback]\nFunctionalize: registered at ../aten/src/ATen/FunctionalizeFallbackKernel.cpp:349 [backend fallback]\nNamed: registered at ../aten/src/ATen/core/NamedRegistrations.cpp:7 [backend fallback]\nConjugate: registered at ../aten/src/ATen/ConjugateFallback.cpp:17 [backend fallback]\nNegative: registered at ../aten/src/ATen/native/NegateFallback.cpp:18 [backend fallback]\nZeroTensor: registered at ../aten/src/ATen/ZeroTensorFallback.cpp:86 [backend fallback]\nADInplaceOrView: fallthrough registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:96 [backend fallback]\nAutogradOther: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:63 [backend fallback]\nAutogradCPU: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:67 [backend fallback]\nAutogradCUDA: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:75 [backend fallback]\nAutogradXLA: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:79 [backend fallback]\nAutogradMPS: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:87 [backend fallback]\nAutogradXPU: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:71 [backend fallback]\nAutogradHPU: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:100 [backend fallback]\nAutogradLazy: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:83 [backend fallback]\nAutogradMeta: registered at ../aten/src/ATen/core/VariableFallbackKernel.cpp:91 [backend fallback]\nTracer: registered at ../torch/csrc/autograd/TraceTypeManual.cpp:294 [backend fallback]\nAutocastCPU: fallthrough registered at ../aten/src/ATen/autocast_mode.cpp:321 [backend fallback]\nAutocastXPU: fallthrough registered at ../aten/src/ATen/autocast_mode.cpp:463 [backend fallback]\nAutocastMPS: fallthrough registered at ../aten/src/ATen/autocast_mode.cpp:209 [backend fallback]\nAutocastCUDA: fallthrough registered at ../aten/src/ATen/autocast_mode.cpp:165 [backend fallback]\nFuncTorchBatched: registered at ../aten/src/ATen/functorch/LegacyBatchingRegistrations.cpp:731 [backend fallback]\nBatchedNestedTensor: registered at ../aten/src/ATen/functorch/LegacyBatchingRegistrations.cpp:758 [backend fallback]\nFuncTorchVmapMode: fallthrough registered at ../aten/src/ATen/functorch/VmapModeRegistrations.cpp:27 [backend fallback]\nBatched: registered at ../aten/src/ATen/LegacyBatchingRegistrations.cpp:1075 [backend fallback]\nVmapMode: fallthrough registered at ../aten/src/ATen/VmapModeRegistrations.cpp:33 [backend fallback]\nFuncTorchGradWrapper: registered at ../aten/src/ATen/functorch/TensorWrapper.cpp:207 [backend fallback]\nPythonTLSSnapshot: registered at ../aten/src/ATen/core/PythonFallbackKernel.cpp:161 [backend fallback]\nFuncTorchDynamicLayerFrontMode: registered at ../aten/src/ATen/functorch/DynamicLayer.cpp:493 [backend fallback]\nPreDispatch: registered at ../aten/src/ATen/core/PythonFallbackKernel.cpp:165 [backend fallback]\nPythonDispatcher: registered at ../aten/src/ATen/core/PythonFallbackKernel.cpp:157 [backend fallback]\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "201470f9",
-      "metadata": {
-        "id": "201470f9"
-      },
-      "source": [
-        "## Exercise 3: working with pre-trained models.\n",
-        "\n",
-        "PyTorch offers several pre-trained models https://pytorch.org/vision/0.8/models.html        \n",
-        "We will use ResNet50 trained on ImageNet dataset (https://www.image-net.org/index.php). Use the following code with the files `imagenet-simple-labels.json` that contains the imagenet labels and the image dog.png that we will use as test.\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "b4d13080",
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 545
-        },
-        "id": "b4d13080",
-        "outputId": "b2316966-6cfb-4e0f-9914-f0cef4d8e031"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
-            "  warnings.warn(\n",
-            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
-            "  warnings.warn(msg)\n",
-            "Downloading: \"https://download.pytorch.org/models/resnet50-0676ba61.pth\" to /root/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth\n",
-            "100%|██████████| 97.8M/97.8M [00:00<00:00, 177MB/s]\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Predicted class is: Golden Retriever\n"
-          ]
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 640x480 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "import json\n",
-        "import matplotlib.pyplot as plt\n",
-        "from torchvision import models\n",
-        "from PIL import Image\n",
-        "\n",
-        "# Choose an image to pass through the model\n",
-        "test_image = \"dog.png\"\n",
-        "\n",
-        "# Configure matplotlib for pretty inline plots\n",
-        "#%matplotlib inline\n",
-        "#%config InlineBackend.figure_format = 'retina'\n",
-        "\n",
-        "# Prepare the labels\n",
-        "with open(\"imagenet-simple-labels.json\") as f:\n",
-        "    labels = json.load(f)\n",
-        "\n",
-        "# First prepare the transformations: resize the image to what the model was trained on and convert it to a tensor\n",
-        "data_transform = transforms.Compose(\n",
-        "    [\n",
-        "        transforms.Resize((224, 224)),\n",
-        "        transforms.ToTensor(),\n",
-        "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
-        "    ]\n",
-        ")\n",
-        "# Load the image\n",
-        "\n",
-        "image = Image.open(test_image)\n",
-        "plt.imshow(image), plt.xticks([]), plt.yticks([])\n",
-        "\n",
-        "# Now apply the transformation, expand the batch dimension, and send the image to the GPU\n",
-        "# image = data_transform(image).unsqueeze(0).cuda()\n",
-        "image = data_transform(image).unsqueeze(0)\n",
-        "\n",
-        "# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\n",
-        "model3 = models.resnet50(pretrained=True)\n",
-        "# Send the model to the GPU\n",
-        "# model.cuda()\n",
-        "# Set layers such as dropout and batchnorm in evaluation mode\n",
-        "model3.eval()\n",
-        "\n",
-        "# Get the 1000-dimensional model output\n",
-        "out = model3(image)\n",
-        "# Find the predicted class\n",
-        "print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "184cfceb",
-      "metadata": {
-        "id": "184cfceb"
-      },
-      "source": [
-        "Experiments:\n",
-        "\n",
-        "Study the code and the results obtained. Possibly add other images downloaded from the internet.\n",
-        "\n",
-        "What is the size of the model? Quantize it and then check if the model is still able to correctly classify the other images.\n",
-        "\n",
-        "Experiment with other pre-trained CNN models.\n",
-        "\n",
-        "    \n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "l6AkxJIEj1BS",
-      "metadata": {
-        "id": "l6AkxJIEj1BS"
-      },
-      "outputs": [],
-      "source": [
-        "test_image_2 = 'cat.jpg'\n",
-        "# Load the image\n",
-        "image_cat = Image.open(test_image_2)\n",
-        "plt.imshow(image_cat), plt.xticks([]), plt.yticks([])\n",
-        "\n",
-        "image_cat = data_transform(image_cat).unsqueeze(0)\n",
-        "out = model3(image_cat)\n",
-        "# Find the predicted class\n",
-        "print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "9u8okHN2lSoX",
-      "metadata": {
-        "id": "9u8okHN2lSoX"
-      },
-      "outputs": [],
-      "source": [
-        "test_image_3 = 'apple.jpg'\n",
-        "# Load the image\n",
-        "image_apple = Image.open(test_image_3)\n",
-        "plt.imshow(image_apple), plt.xticks([]), plt.yticks([])\n",
-        "\n",
-        "image_apple = data_transform(image_apple).unsqueeze(0)\n",
-        "out = model3(image_apple)\n",
-        "# Find the predicted class\n",
-        "print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "FrctIZuFmB8y",
-      "metadata": {
-        "id": "FrctIZuFmB8y"
-      },
-      "source": [
-        "The model recognizes the cat (with description of its coat pattern) and the apple (with its species). We will now quantize the two images and check wether the model can predict the image class again or not."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "fRTBC2nySCRx",
-      "metadata": {
-        "id": "fRTBC2nySCRx"
-      },
-      "outputs": [],
-      "source": [
-        "print_size_of_model(model3, \"fp32\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "-IcU6LXlSOHr",
-      "metadata": {
-        "id": "-IcU6LXlSOHr"
-      },
-      "outputs": [],
-      "source": [
-        "quantized_model3 = torch.quantization.quantize_dynamic(model3, dtype=torch.qint8)\n",
-        "print_size_of_model(quantized_model3, \"int8\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "e-6cS1K3USbn",
-      "metadata": {
-        "id": "e-6cS1K3USbn"
-      },
-      "outputs": [],
-      "source": [
-        "# Get the 1000-dimensional model output\n",
-        "out = quantized_model3(image)\n",
-        "# Find the predicted class\n",
-        "print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "0p2dJTkdpBaG",
-      "metadata": {
-        "id": "0p2dJTkdpBaG"
-      },
-      "outputs": [],
-      "source": [
-        "# Get the 1000-dimensional model output\n",
-        "out = quantized_model3(image_cat)\n",
-        "# Find the predicted class\n",
-        "print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "# Get the 1000-dimensional model output\n",
-        "out = quantized_model3(image_apple)\n",
-        "# Find the predicted class\n",
-        "print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
-      ],
-      "metadata": {
-        "id": "jc2Az0yiMO2e"
-      },
-      "id": "jc2Az0yiMO2e",
-      "execution_count": null,
-      "outputs": []
-    },
-    {
-      "cell_type": "markdown",
-      "id": "5d57da4b",
-      "metadata": {
-        "id": "5d57da4b"
-      },
-      "source": [
-        "## Exercise 4: Transfer Learning\n",
-        "    \n",
-        "    \n",
-        "For this work, we will use a pre-trained model (ResNet18) as a descriptor extractor and will refine the classification by training only the last fully connected layer of the network. Thus, the output layer of the pre-trained network will be replaced by a layer adapted to the new classes to be recognized which will be in our case ants and bees.\n",
-        "Download and unzip in your working directory the dataset available at the address :\n",
-        "    \n",
-        "https://download.pytorch.org/tutorial/hymenoptera_data.zip\n",
-        "    \n",
-        "Execute the following code in order to display some images of the dataset."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "2Dzaxe-EFTx9",
-      "metadata": {
-        "id": "2Dzaxe-EFTx9"
-      },
-      "outputs": [],
-      "source": [
-        "from google.colab import drive\n",
-        "drive.mount('/content/drive')"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "be2d31f5",
-      "metadata": {
-        "id": "be2d31f5"
-      },
-      "outputs": [],
-      "source": [
-        "import os\n",
-        "\n",
-        "import matplotlib.pyplot as plt\n",
-        "import numpy as np\n",
-        "import torch\n",
-        "import torchvision\n",
-        "from torchvision import datasets, transforms\n",
-        "\n",
-        "# Data augmentation and normalization for training\n",
-        "# Just normalization for validation\n",
-        "data_transforms = {\n",
-        "    \"train\": transforms.Compose(\n",
-        "        [\n",
-        "            transforms.RandomResizedCrop(\n",
-        "                224\n",
-        "            ),  # ImageNet models were trained on 224x224 images\n",
-        "            transforms.RandomHorizontalFlip(),  # flip horizontally 50% of the time - increases train set variability\n",
-        "            transforms.ToTensor(),  # convert it to a PyTorch tensor\n",
-        "            transforms.Normalize(\n",
-        "                [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n",
-        "            ),  # ImageNet models expect this norm\n",
-        "        ]\n",
-        "    ),\n",
-        "    \"val\": transforms.Compose(\n",
-        "        [\n",
-        "            transforms.Resize(256),\n",
-        "            transforms.CenterCrop(224),\n",
-        "            transforms.ToTensor(),\n",
-        "            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
-        "        ]\n",
-        "    ),\n",
-        "}\n",
-        "\n",
-        "data_dir = \"/content/drive/MyDrive/hymenoptera_data\"\n",
-        "# Create train and validation datasets and loaders\n",
-        "image_datasets = {\n",
-        "    x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n",
-        "    for x in [\"train\", \"val\"]\n",
-        "}\n",
-        "dataloaders = {\n",
-        "    x: torch.utils.data.DataLoader(\n",
-        "        image_datasets[x], batch_size=4, shuffle=True, num_workers=0\n",
-        "    )\n",
-        "    for x in [\"train\", \"val\"]\n",
-        "}\n",
-        "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n",
-        "class_names = image_datasets[\"train\"].classes\n",
-        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
-        "\n",
-        "# Helper function for displaying images\n",
-        "def imshow(inp, title=None):\n",
-        "    \"\"\"Imshow for Tensor.\"\"\"\n",
-        "    inp = inp.numpy().transpose((1, 2, 0))\n",
-        "    mean = np.array([0.485, 0.456, 0.406])\n",
-        "    std = np.array([0.229, 0.224, 0.225])\n",
-        "\n",
-        "    # Un-normalize the images\n",
-        "    inp = std * inp + mean\n",
-        "    # Clip just in case\n",
-        "    inp = np.clip(inp, 0, 1)\n",
-        "    plt.imshow(inp)\n",
-        "    if title is not None:\n",
-        "        plt.title(title)\n",
-        "    plt.pause(0.001)  # pause a bit so that plots are updated\n",
-        "    plt.show()\n",
-        "\n",
-        "\n",
-        "# Get a batch of training data\n",
-        "inputs, classes = next(iter(dataloaders[\"train\"]))\n",
-        "\n",
-        "# Make a grid from batch\n",
-        "out = torchvision.utils.make_grid(inputs)\n",
-        "\n",
-        "imshow(out, title=[class_names[x] for x in classes])\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "bbd48800",
-      "metadata": {
-        "id": "bbd48800"
-      },
-      "source": [
-        "Now, execute the following code which uses a pre-trained model ResNet18 having replaced the output layer for the ants/bees classification and performs the model training by only changing the weights of this output layer."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "572d824c",
-      "metadata": {
-        "id": "572d824c"
-      },
-      "outputs": [],
-      "source": [
-        "import copy\n",
-        "import os\n",
-        "import time\n",
-        "\n",
-        "import matplotlib.pyplot as plt\n",
-        "import numpy as np\n",
-        "import torch\n",
-        "import torch.nn as nn\n",
-        "import torch.optim as optim\n",
-        "import torchvision\n",
-        "from torch.optim import lr_scheduler\n",
-        "from torchvision import datasets, transforms\n",
-        "\n",
-        "# Data augmentation and normalization for training\n",
-        "# Just normalization for validation\n",
-        "data_transforms = {\n",
-        "    \"train\": transforms.Compose(\n",
-        "        [\n",
-        "            transforms.RandomResizedCrop(\n",
-        "                224\n",
-        "            ),  # ImageNet models were trained on 224x224 images\n",
-        "            transforms.RandomHorizontalFlip(),  # flip horizontally 50% of the time - increases train set variability\n",
-        "            transforms.ToTensor(),  # convert it to a PyTorch tensor\n",
-        "            transforms.Normalize(\n",
-        "                [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n",
-        "            ),  # ImageNet models expect this norm\n",
-        "        ]\n",
-        "    ),\n",
-        "    \"val\": transforms.Compose(\n",
-        "        [\n",
-        "            transforms.Resize(256),\n",
-        "            transforms.CenterCrop(224),\n",
-        "            transforms.ToTensor(),\n",
-        "            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
-        "        ]\n",
-        "    ),\n",
-        "}\n",
-        "\n",
-        "data_dir = \"/content/drive/MyDrive/hymenoptera_data\"\n",
-        "# Create train and validation datasets and loaders\n",
-        "image_datasets = {\n",
-        "    x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n",
-        "    for x in [\"train\", \"val\"]\n",
-        "}\n",
-        "dataloaders = {\n",
-        "    x: torch.utils.data.DataLoader(\n",
-        "        image_datasets[x], batch_size=4, shuffle=True, num_workers=4\n",
-        "    )\n",
-        "    for x in [\"train\", \"val\"]\n",
-        "}\n",
-        "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n",
-        "class_names = image_datasets[\"train\"].classes\n",
-        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
-        "\n",
-        "# Helper function for displaying images\n",
-        "def imshow(inp, title=None):\n",
-        "    \"\"\"Imshow for Tensor.\"\"\"\n",
-        "    inp = inp.numpy().transpose((1, 2, 0))\n",
-        "    mean = np.array([0.485, 0.456, 0.406])\n",
-        "    std = np.array([0.229, 0.224, 0.225])\n",
-        "\n",
-        "    # Un-normalize the images\n",
-        "    inp = std * inp + mean\n",
-        "    # Clip just in case\n",
-        "    inp = np.clip(inp, 0, 1)\n",
-        "    plt.imshow(inp)\n",
-        "    if title is not None:\n",
-        "        plt.title(title)\n",
-        "    plt.pause(0.001)  # pause a bit so that plots are updated\n",
-        "    plt.show()\n",
-        "\n",
-        "\n",
-        "# Get a batch of training data\n",
-        "# inputs, classes = next(iter(dataloaders['train']))\n",
-        "\n",
-        "# Make a grid from batch\n",
-        "# out = torchvision.utils.make_grid(inputs)\n",
-        "\n",
-        "# imshow(out, title=[class_names[x] for x in classes])\n",
-        "# training\n",
-        "\n",
-        "\n",
-        "def train_model(model, criterion, optimizer, scheduler, num_epochs=25):\n",
-        "    since = time.time()\n",
-        "\n",
-        "    best_model_wts = copy.deepcopy(model.state_dict())\n",
-        "    best_acc = 0.0\n",
-        "\n",
-        "    epoch_time = []  # we'll keep track of the time needed for each epoch\n",
-        "\n",
-        "    for epoch in range(num_epochs):\n",
-        "        epoch_start = time.time()\n",
-        "        print(\"Epoch {}/{}\".format(epoch + 1, num_epochs))\n",
-        "        print(\"-\" * 10)\n",
-        "\n",
-        "        # Each epoch has a training and validation phase\n",
-        "        for phase in [\"train\", \"val\"]:\n",
-        "            if phase == \"train\":\n",
-        "                scheduler.step()\n",
-        "                model.train()  # Set model to training mode\n",
-        "            else:\n",
-        "                model.eval()  # Set model to evaluate mode\n",
-        "\n",
-        "            running_loss = 0.0\n",
-        "            running_corrects = 0\n",
-        "\n",
-        "            # Iterate over data.\n",
-        "            for inputs, labels in dataloaders[phase]:\n",
-        "                inputs = inputs.to(device)\n",
-        "                labels = labels.to(device)\n",
-        "\n",
-        "                # zero the parameter gradients\n",
-        "                optimizer.zero_grad()\n",
-        "\n",
-        "                # Forward\n",
-        "                # Track history if only in training phase\n",
-        "                with torch.set_grad_enabled(phase == \"train\"):\n",
-        "                    outputs = model(inputs)\n",
-        "                    _, preds = torch.max(outputs, 1)\n",
-        "                    loss = criterion(outputs, labels)\n",
-        "\n",
-        "                    # backward + optimize only if in training phase\n",
-        "                    if phase == \"train\":\n",
-        "                        loss.backward()\n",
-        "                        optimizer.step()\n",
-        "\n",
-        "                # Statistics\n",
-        "                running_loss += loss.item() * inputs.size(0)\n",
-        "                running_corrects += torch.sum(preds == labels.data)\n",
-        "\n",
-        "            epoch_loss = running_loss / dataset_sizes[phase]\n",
-        "            epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
-        "\n",
-        "            print(\"{} Loss: {:.4f} Acc: {:.4f}\".format(phase, epoch_loss, epoch_acc))\n",
-        "\n",
-        "            # Deep copy the model\n",
-        "            if phase == \"val\" and epoch_acc > best_acc:\n",
-        "                best_acc = epoch_acc\n",
-        "                best_model_wts = copy.deepcopy(model.state_dict())\n",
-        "\n",
-        "        # Add the epoch time\n",
-        "        t_epoch = time.time() - epoch_start\n",
-        "        epoch_time.append(t_epoch)\n",
-        "        print()\n",
-        "\n",
-        "    time_elapsed = time.time() - since\n",
-        "    print(\n",
-        "        \"Training complete in {:.0f}m {:.0f}s\".format(\n",
-        "            time_elapsed // 60, time_elapsed % 60\n",
-        "        )\n",
-        "    )\n",
-        "    print(\"Best val Acc: {:4f}\".format(best_acc))\n",
-        "\n",
-        "    # Load best model weights\n",
-        "    model.load_state_dict(best_model_wts)\n",
-        "    return model, epoch_time\n",
-        "\n",
-        "\n",
-        "# Download a pre-trained ResNet18 model and freeze its weights\n",
-        "model = torchvision.models.resnet18(pretrained=True)\n",
-        "for param in model.parameters():\n",
-        "    param.requires_grad = False\n",
-        "\n",
-        "# Replace the final fully connected layer\n",
-        "# Parameters of newly constructed modules have requires_grad=True by default\n",
-        "num_ftrs = model.fc.in_features\n",
-        "model.fc = nn.Linear(num_ftrs, 2)\n",
-        "# Send the model to the GPU\n",
-        "model = model.to(device)\n",
-        "# Set the loss function\n",
-        "criterion = nn.CrossEntropyLoss()\n",
-        "\n",
-        "# Observe that only the parameters of the final layer are being optimized\n",
-        "optimizer_conv = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)\n",
-        "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)\n",
-        "model, epoch_time = train_model(\n",
-        "    model, criterion, optimizer_conv, exp_lr_scheduler, num_epochs=10\n",
-        ")\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "sN7V8_EAn0OO",
-      "metadata": {
-        "id": "sN7V8_EAn0OO"
-      },
-      "source": [
-        "Experiments:\n",
-        "Study the code and the results obtained.\n",
-        "\n",
-        "Modify the code and add an \"eval_model\" function to allow\n",
-        "the evaluation of the model on a test set (different from the learning and validation sets used during the learning phase). Study the results obtained.\n",
-        "\n",
-        "Now modify the code to replace the current classification layer with a set of two layers using a \"relu\" activation function for the middle layer, and the \"dropout\" mechanism for both layers. Renew the experiments and study the results obtained.\n",
-        "\n",
-        "Apply ther quantization (post and quantization aware) and evaluate impact on model size and accuracy."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "id": "PnI7tSTqXRZ8",
-      "metadata": {
-        "id": "PnI7tSTqXRZ8"
-      },
-      "outputs": [],
-      "source": [
-        "# Data augmentation and normalization for training\n",
-        "# Just normalization for validation\n",
-        "data_transforms = {\n",
-        "    \"test\": transforms.Compose(\n",
-        "        [\n",
-        "            transforms.Resize(256),\n",
-        "            transforms.CenterCrop(224),\n",
-        "            transforms.ToTensor(),\n",
-        "            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
-        "        ]\n",
-        "    ),\n",
-        "}\n",
-        "\n",
-        "image_datasets = {\n",
-        "    x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n",
-        "    for x in [\"test\"]\n",
-        "}\n",
-        "\n",
-        "dataloader = {\n",
-        "    x: torch.utils.data.DataLoader(\n",
-        "        image_datasets[x], batch_size=4, shuffle=True, num_workers=4\n",
-        "    )\n",
-        "    for x in [\"test\"]\n",
-        "}\n",
-        "\n",
-        "dataset_sizes = {x: len(image_datasets[x]) for x in [\"test\"]}\n",
-        "class_names = image_datasets[\"test\"].classes\n",
-        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
-        "\n",
-        "def eval_model(model, dataloader, criterion):\n",
-        "    model.eval()\n",
-        "\n",
-        "    running_loss = 0.0\n",
-        "    running_corrects = 0\n",
-        "\n",
-        "    for inputs, labels in dataloaders[\"test\"]:\n",
-        "        inputs = inputs.to(device)\n",
-        "        labels = labels.to(device)\n",
-        "\n",
-        "        outputs = model(inputs)\n",
-        "        _, preds = torch.max(outputs, 1)\n",
-        "        loss = criterion(outputs, labels)\n",
-        "\n",
-        "        running_loss += loss.item() * inputs.size(0)\n",
-        "        running_corrects += torch.sum(preds == labels.data)\n",
-        "\n",
-        "    total_loss = running_loss / dataset_sizes[\"test\"]\n",
-        "    total_accuracy = running_corrects.double() / dataset_sizes[\"test\"]\n",
-        "\n",
-        "    print(\"Validation Loss: {:.4f} Accuracy: {:.4f}\".format(total_loss, total_accuracy))\n",
-        "    return total_loss, total_accuracy\n",
-        "\n",
-        "eval_model(model, dataloader, criterion)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "04a263f0",
-      "metadata": {
-        "id": "04a263f0"
-      },
-      "source": [
-        "## Optional\n",
-        "    \n",
-        "Try this at home!!\n",
-        "\n",
-        "\n",
-        "Pytorch offers a framework to export a given CNN to your selfphone (either android or iOS). Have a look at the tutorial https://pytorch.org/mobile/home/\n",
-        "\n",
-        "The Exercise consists in deploying the CNN of Exercise 4 in your phone and then test it on live.\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "id": "fe954ce4",
-      "metadata": {
-        "id": "fe954ce4"
-      },
-      "source": [
-        "## Author\n",
-        "\n",
-        "Alberto BOSIO - Ph. D."
-      ]
-    }
-  ],
-  "metadata": {
-    "accelerator": "GPU",
-    "colab": {
-      "gpuType": "T4",
-      "provenance": []
-    },
-    "kernelspec": {
-      "display_name": "Python 3",
-      "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.8.5"
-    },
-    "vscode": {
-      "interpreter": {
-        "hash": "9e3efbebb05da2d4a1968abe9a0645745f54b63feb7a85a514e4da0495be97eb"
-      }
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 5
-}
\ No newline at end of file