diff --git a/TD2_Deep_Learning.ipynb b/TD2_Deep_Learning.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..43d83e9c5b6edcb3d1e6e930dec2fd6aea2492a2 --- /dev/null +++ b/TD2_Deep_Learning.ipynb @@ -0,0 +1,2364 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7edf7168", + "metadata": {}, + "source": [ + "# TD2: Deep learning" + ] + }, + { + "cell_type": "markdown", + "id": "fbb8c8df", + "metadata": {}, + "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 Sunday, December 1, 11:59 PM. Later commits will not be taken into account." + ] + }, + { + "cell_type": "markdown", + "id": "3d167a29", + "metadata": {}, + "source": [ + "Install and test PyTorch from https://pytorch.org/get-started/locally." + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "330a42f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n", + "Requirement already satisfied: torch in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (2.1.1)\n", + "Requirement already satisfied: torchvision in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (0.16.1)\n", + "Requirement already satisfied: filelock in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from torch) (3.13.1)\n", + "Requirement already satisfied: typing-extensions in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from torch) (4.8.0)\n", + "Requirement already satisfied: sympy in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from torch) (1.12)\n", + "Requirement already satisfied: networkx in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from torch) (3.2.1)\n", + "Requirement already satisfied: jinja2 in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from torch) (3.1.2)\n", + "Requirement already satisfied: fsspec in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from torch) (2023.10.0)\n", + "Requirement already satisfied: numpy in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from torchvision) (1.24.1)\n", + "Requirement already satisfied: requests in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from torchvision) (2.28.2)\n", + "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from torchvision) (9.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from jinja2->torch) (2.1.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from requests->torchvision) (2.1.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from requests->torchvision) (3.4)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from requests->torchvision) (1.26.14)\n", + "Requirement already satisfied: certifi>=2017.4.17 in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from requests->torchvision) (2022.12.7)\n", + "Requirement already satisfied: mpmath>=0.19 in c:\\users\\doha\\appdata\\local\\programs\\python\\python311\\lib\\site-packages (from sympy->torch) (1.3.0)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "[notice] A new release of pip is available: 23.3 -> 23.3.1\n", + "[notice] To update, run: python.exe -m pip install --upgrade pip\n" + ] + } + ], + "source": [ + "%pip install torch torchvision" + ] + }, + { + "cell_type": "markdown", + "id": "0882a636", + "metadata": {}, + "source": [ + "\n", + "To test run the following code" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "b1950f0a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[-0.7389, 0.7885, 1.8504, -1.8347, 0.0515, 2.1204, -0.8793, 0.0580,\n", + " -0.2390, -0.0843],\n", + " [-0.1486, -0.4881, 0.7030, -0.8952, 0.3478, 1.7086, 0.3329, 0.4372,\n", + " -0.8096, 0.5709],\n", + " [ 1.8788, 1.3843, -0.5696, -0.0188, -1.3012, 0.1746, 0.8784, 0.0155,\n", + " -0.0771, -0.9417],\n", + " [ 0.2465, -0.1813, -2.3470, -1.3867, -0.7287, -1.3100, 0.2620, -0.2575,\n", + " 0.5564, 2.7016],\n", + " [-0.4815, -2.0081, 0.9647, -1.0703, -1.2811, 0.2649, -0.2473, -0.3607,\n", + " -0.3860, -0.9729],\n", + " [-1.5436, -0.3369, 0.8532, 1.8994, -0.3204, -2.6883, 0.6587, 0.9593,\n", + " 0.0236, 0.5737],\n", + " [-0.2410, -0.0543, 0.1070, -2.0459, -0.3437, -0.1986, -0.8142, 0.0413,\n", + " 0.0535, -1.8599],\n", + " [ 2.0889, 0.8851, -0.7093, -0.0486, 1.9867, 0.8712, -1.2285, 0.3417,\n", + " -0.0881, -0.8200],\n", + " [ 0.5620, 0.1835, -0.3233, 0.5504, 0.6176, -1.9067, -1.0294, -0.1108,\n", + " 0.9401, 0.0073],\n", + " [ 1.1959, 0.4060, 0.3481, -0.7020, 1.9528, 0.9577, 2.1714, -1.5264,\n", + " -1.8736, -1.0982],\n", + " [-0.1024, -0.6245, -0.5537, -1.3826, 1.2962, -1.2738, -0.3666, -0.0186,\n", + " 0.8719, 0.2653],\n", + " [ 0.3359, 0.1678, 1.1025, -0.1236, 0.4400, 0.1040, 0.6082, -0.7197,\n", + " -0.2086, 0.2659],\n", + " [-2.0035, 1.0286, 0.0625, 0.7358, -0.9408, 0.3707, 1.2950, -1.8920,\n", + " -0.1246, -0.6542],\n", + " [-2.4152, -0.5704, -0.3693, 1.8454, -0.1433, -0.1888, 1.5017, 1.6391,\n", + " -1.6019, -1.6772]])\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": {}, + "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": {}, + "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": 70, + "id": "6e18f2fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CUDA is not available. Training on CPU ...\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": {}, + "source": [ + "Next we load the CIFAR10 dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "462666a2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files already downloaded and verified\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": {}, + "source": [ + "CNN definition (this one is an example)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "317bf070", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "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", + "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": {}, + "source": [ + "Loss function and training using SGD (Stochastic Gradient Descent) optimizer" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "4b53f229", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0 \tTraining Loss: 45.021260 \tValidation Loss: 40.522292\n", + "Validation loss decreased (inf --> 40.522292). Saving model ...\n", + "Epoch: 1 \tTraining Loss: 36.454532 \tValidation Loss: 32.328398\n", + "Validation loss decreased (40.522292 --> 32.328398). Saving model ...\n", + "Epoch: 2 \tTraining Loss: 30.949551 \tValidation Loss: 30.173495\n", + "Validation loss decreased (32.328398 --> 30.173495). Saving model ...\n", + "Epoch: 3 \tTraining Loss: 28.695976 \tValidation Loss: 27.666056\n", + "Validation loss decreased (30.173495 --> 27.666056). Saving model ...\n", + "Epoch: 4 \tTraining Loss: 26.969767 \tValidation Loss: 26.234066\n", + "Validation loss decreased (27.666056 --> 26.234066). Saving model ...\n", + "Epoch: 5 \tTraining Loss: 25.542438 \tValidation Loss: 25.832758\n", + "Validation loss decreased (26.234066 --> 25.832758). Saving model ...\n", + "Epoch: 6 \tTraining Loss: 24.313492 \tValidation Loss: 24.163737\n", + "Validation loss decreased (25.832758 --> 24.163737). Saving model ...\n", + "Epoch: 7 \tTraining Loss: 23.123524 \tValidation Loss: 24.267641\n", + "Epoch: 8 \tTraining Loss: 22.089343 \tValidation Loss: 24.175819\n", + "Epoch: 9 \tTraining Loss: 21.132213 \tValidation Loss: 24.701078\n", + "Epoch: 10 \tTraining Loss: 20.245910 \tValidation Loss: 22.396485\n", + "Validation loss decreased (24.163737 --> 22.396485). Saving model ...\n", + "Epoch: 11 \tTraining Loss: 19.471691 \tValidation Loss: 21.707046\n", + "Validation loss decreased (22.396485 --> 21.707046). Saving model ...\n", + "Epoch: 12 \tTraining Loss: 18.733107 \tValidation Loss: 21.993602\n", + "Epoch: 13 \tTraining Loss: 18.006454 \tValidation Loss: 22.096681\n", + "Epoch: 14 \tTraining Loss: 17.369621 \tValidation Loss: 22.083588\n", + "Epoch: 15 \tTraining Loss: 16.809330 \tValidation Loss: 22.407409\n", + "Epoch: 16 \tTraining Loss: 16.225887 \tValidation Loss: 21.790938\n", + "Epoch: 17 \tTraining Loss: 15.655550 \tValidation Loss: 22.603928\n", + "Epoch: 18 \tTraining Loss: 15.065336 \tValidation Loss: 21.671956\n", + "Validation loss decreased (21.707046 --> 21.671956). Saving model ...\n", + "Epoch: 19 \tTraining Loss: 14.558645 \tValidation Loss: 21.994533\n", + "Epoch: 20 \tTraining Loss: 14.046592 \tValidation Loss: 22.487718\n", + "Epoch: 21 \tTraining Loss: 13.516859 \tValidation Loss: 23.430379\n", + "Epoch: 22 \tTraining Loss: 13.095497 \tValidation Loss: 24.477961\n", + "Epoch: 23 \tTraining Loss: 12.603915 \tValidation Loss: 22.942599\n", + "Epoch: 24 \tTraining Loss: 12.050708 \tValidation Loss: 23.745723\n", + "Epoch: 25 \tTraining Loss: 11.685706 \tValidation Loss: 24.577321\n", + "Epoch: 26 \tTraining Loss: 11.259907 \tValidation Loss: 25.139730\n", + "Epoch: 27 \tTraining Loss: 10.902550 \tValidation Loss: 25.911864\n", + "Epoch: 28 \tTraining Loss: 10.473128 \tValidation Loss: 26.282745\n", + "Epoch: 29 \tTraining Loss: 10.109592 \tValidation Loss: 26.700022\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(), \"model_cifar.pt\")\n", + " valid_loss_min = valid_loss" + ] + }, + { + "cell_type": "markdown", + "id": "13e1df74", + "metadata": {}, + "source": [ + "Does overfit occur? If so, do an early stopping.\n", + "\n", + "=> YES, an overfit occurs at epoch 19; Validation Loss increased while the Training Loss decresed" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "d39df818", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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": {}, + "source": [ + "Now loading the model with the lowest validation loss value\n" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "e93efdfc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss: 21.174222\n", + "\n", + "Test Accuracy of airplane: 64% (648/1000)\n", + "Test Accuracy of automobile: 77% (774/1000)\n", + "Test Accuracy of bird: 56% (561/1000)\n", + "Test Accuracy of cat: 46% (465/1000)\n", + "Test Accuracy of deer: 58% (588/1000)\n", + "Test Accuracy of dog: 49% (490/1000)\n", + "Test Accuracy of frog: 74% (748/1000)\n", + "Test Accuracy of horse: 68% (681/1000)\n", + "Test Accuracy of ship: 75% (755/1000)\n", + "Test Accuracy of truck: 74% (741/1000)\n", + "\n", + "Test Accuracy (Overall): 64% (6451/10000)\n" + ] + } + ], + "source": [ + "model.load_state_dict(torch.load(\"./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": {}, + "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": 63, + "id": "a97bb9f1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NewCNN(\n", + " (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (relu1): ReLU()\n", + " (pool1): 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", + " (relu2): ReLU()\n", + " (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (relu3): ReLU()\n", + " (pool3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (fc1): Linear(in_features=1024, out_features=512, bias=True)\n", + " (relu4): ReLU()\n", + " (dropout1): Dropout(p=0.5, inplace=False)\n", + " (fc2): Linear(in_features=512, out_features=64, bias=True)\n", + " (relu5): ReLU()\n", + " (dropout2): Dropout(p=0.5, inplace=False)\n", + " (fc3): Linear(in_features=64, out_features=10, bias=True)\n", + ")\n", + "\n", + "Epoch: 0 \tTraining Loss: 45.699048 \tValidation Loss: 43.815921\n", + "Validation loss decreased (inf --> 43.815921). Saving model ...\n", + "Epoch: 1 \tTraining Loss: 41.656124 \tValidation Loss: 38.794752\n", + "Validation loss decreased (43.815921 --> 38.794752). Saving model ...\n", + "Epoch: 2 \tTraining Loss: 37.959708 \tValidation Loss: 34.560239\n", + "Validation loss decreased (38.794752 --> 34.560239). Saving model ...\n", + "Epoch: 3 \tTraining Loss: 34.497164 \tValidation Loss: 31.356168\n", + "Validation loss decreased (34.560239 --> 31.356168). Saving model ...\n", + "Epoch: 4 \tTraining Loss: 32.128342 \tValidation Loss: 29.376391\n", + "Validation loss decreased (31.356168 --> 29.376391). Saving model ...\n", + "Epoch: 5 \tTraining Loss: 30.274867 \tValidation Loss: 27.456289\n", + "Validation loss decreased (29.376391 --> 27.456289). Saving model ...\n", + "Epoch: 6 \tTraining Loss: 28.848854 \tValidation Loss: 26.413416\n", + "Validation loss decreased (27.456289 --> 26.413416). Saving model ...\n", + "Epoch: 7 \tTraining Loss: 27.273288 \tValidation Loss: 24.634868\n", + "Validation loss decreased (26.413416 --> 24.634868). Saving model ...\n", + "Epoch: 8 \tTraining Loss: 25.993049 \tValidation Loss: 23.469470\n", + "Validation loss decreased (24.634868 --> 23.469470). Saving model ...\n", + "Epoch: 9 \tTraining Loss: 24.621966 \tValidation Loss: 22.649529\n", + "Validation loss decreased (23.469470 --> 22.649529). Saving model ...\n", + "Epoch: 10 \tTraining Loss: 23.493129 \tValidation Loss: 21.448941\n", + "Validation loss decreased (22.649529 --> 21.448941). Saving model ...\n", + "Epoch: 11 \tTraining Loss: 22.459077 \tValidation Loss: 20.434714\n", + "Validation loss decreased (21.448941 --> 20.434714). Saving model ...\n", + "Epoch: 12 \tTraining Loss: 21.366676 \tValidation Loss: 20.357604\n", + "Validation loss decreased (20.434714 --> 20.357604). Saving model ...\n", + "Epoch: 13 \tTraining Loss: 20.557976 \tValidation Loss: 18.848052\n", + "Validation loss decreased (20.357604 --> 18.848052). Saving model ...\n", + "Epoch: 14 \tTraining Loss: 19.659216 \tValidation Loss: 18.160238\n", + "Validation loss decreased (18.848052 --> 18.160238). Saving model ...\n", + "Epoch: 15 \tTraining Loss: 18.923040 \tValidation Loss: 18.249711\n", + "Epoch: 16 \tTraining Loss: 18.149580 \tValidation Loss: 18.043765\n", + "Validation loss decreased (18.160238 --> 18.043765). Saving model ...\n", + "Epoch: 17 \tTraining Loss: 17.350466 \tValidation Loss: 17.022735\n", + "Validation loss decreased (18.043765 --> 17.022735). Saving model ...\n", + "Epoch: 18 \tTraining Loss: 16.683850 \tValidation Loss: 16.652761\n", + "Validation loss decreased (17.022735 --> 16.652761). Saving model ...\n", + "Epoch: 19 \tTraining Loss: 16.118304 \tValidation Loss: 16.488385\n", + "Validation loss decreased (16.652761 --> 16.488385). Saving model ...\n", + "Epoch: 20 \tTraining Loss: 15.440867 \tValidation Loss: 16.136372\n", + "Validation loss decreased (16.488385 --> 16.136372). Saving model ...\n", + "Epoch: 21 \tTraining Loss: 14.862580 \tValidation Loss: 16.491368\n", + "Epoch: 22 \tTraining Loss: 14.223582 \tValidation Loss: 16.225098\n", + "Epoch: 23 \tTraining Loss: 13.654685 \tValidation Loss: 16.037052\n", + "Validation loss decreased (16.136372 --> 16.037052). Saving model ...\n", + "Epoch: 24 \tTraining Loss: 13.217083 \tValidation Loss: 15.995316\n", + "Validation loss decreased (16.037052 --> 15.995316). Saving model ...\n", + "Epoch: 25 \tTraining Loss: 12.775729 \tValidation Loss: 16.247011\n", + "Epoch: 26 \tTraining Loss: 12.117861 \tValidation Loss: 15.865452\n", + "Validation loss decreased (15.995316 --> 15.865452). Saving model ...\n", + "Epoch: 27 \tTraining Loss: 11.652771 \tValidation Loss: 15.806456\n", + "Validation loss decreased (15.865452 --> 15.806456). Saving model ...\n", + "Epoch: 28 \tTraining Loss: 11.152563 \tValidation Loss: 16.118254\n", + "Epoch: 29 \tTraining Loss: 10.774879 \tValidation Loss: 16.564750\n", + "\n", + "Test Loss: 15.909433\n", + "\n", + "Test Accuracy of airplane: 83% (833/1000)\n", + "Test Accuracy of automobile: 85% (855/1000)\n", + "Test Accuracy of bird: 64% (646/1000)\n", + "Test Accuracy of cat: 58% (586/1000)\n", + "Test Accuracy of deer: 71% (718/1000)\n", + "Test Accuracy of dog: 49% (495/1000)\n", + "Test Accuracy of frog: 82% (823/1000)\n", + "Test Accuracy of horse: 76% (760/1000)\n", + "Test Accuracy of ship: 84% (848/1000)\n", + "Test Accuracy of truck: 83% (838/1000)\n", + "\n", + "Test Accuracy (Overall): 74% (7402/10000)\n" + ] + } + ], + "source": [ + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "\n", + "# define the CNN architecture\n", + "\n", + "class NewCNN(nn.Module):\n", + " def __init__(self):\n", + " super(NewCNN, self).__init__()\n", + " self.conv1 = nn.Conv2d(3, 16, kernel_size = 3, padding = 1)\n", + " self.relu1 = nn.ReLU()\n", + " self.pool1 = nn.MaxPool2d(kernel_size = 2)\n", + " \n", + " self.conv2 = nn.Conv2d(16, 32, kernel_size = 3, padding = 1)\n", + " self.relu2 = nn.ReLU()\n", + " self.pool2 = nn.MaxPool2d(kernel_size = 2)\n", + " \n", + " self.conv3 = nn.Conv2d(32, 64, kernel_size = 3, padding = 1)\n", + " self.relu3 = nn.ReLU()\n", + " self.pool3 = nn.MaxPool2d(kernel_size = 2)\n", + " \n", + " \n", + " self.fc1 = nn.Linear(16 * 8 * 8, 512)\n", + " self.relu4 = nn.ReLU()\n", + " self.dropout1 = nn.Dropout(0.5)\n", + "\n", + " self.fc2 = nn.Linear(512, 64)\n", + " self.relu5 = nn.ReLU()\n", + " self.dropout2 = nn.Dropout(0.5)\n", + " \n", + " self.fc3 = nn.Linear(64, 10)\n", + "\n", + " def forward(self, x):\n", + " # Convolutional layers\n", + " x = self.pool1(self.relu1(self.conv1(x)))\n", + " x = self.pool2(self.relu2(self.conv2(x)))\n", + " x = self.pool3(self.relu3(self.conv3(x)))\n", + " \n", + " # Flatten the output for fully connected layers\n", + " x = x.view(x.size(0), -1)\n", + " \n", + " # Fully connected layers\n", + " x = self.dropout1(self.relu4(self.fc1(x)))\n", + " x = self.dropout2(self.relu5(self.fc2(x)))\n", + " x = self.fc3(x)\n", + " \n", + " return x\n", + "\n", + "\n", + "# create a complete CNN\n", + "model = NewCNN()\n", + "print(model)\n", + "# move tensors to GPU if CUDA is available\n", + "if train_on_gpu:\n", + " model.cuda()\n", + " \n", + "print('')\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(), \"model_cifar_NewCNN.pt\")\n", + " valid_loss_min = valid_loss\n", + " \n", + "\n", + "print('')\n", + "model.load_state_dict(torch.load(\"./model_cifar_NewCNN.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", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "d21fc0d9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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 : NewCNN\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4cf3d90f", + "metadata": {}, + "source": [ + "# Comparison\n", + "The result we have obtained with the second CNN architecture is much better than the first one,the validation_loss and the training_loss decrease extremely better then the first architecture and that's due to adding more layer in our CNN architecture that's the reason over getting better performance in the second architecture \n", + "\n", + "For the \"NewCNN\" we have test_accuracy = 74%; and for \"Net\" test_accuracy = 64%\n", + "The accuracy of the second model is better than the first model \n", + "The \"NewCNN\" architecture is more effective" + ] + }, + { + "cell_type": "markdown", + "id": "bc381cf4", + "metadata": {}, + "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": 76, + "id": "ef623c26", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: fp32 \t Size (KB): 251.278\n" + ] + }, + { + "data": { + "text/plain": [ + "251278" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "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": {}, + "source": [ + "Post training quantization example" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "c4c65d4b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: int8 \t Size (KB): 76.522\n" + ] + }, + { + "data": { + "text/plain": [ + "76522" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch.quantization\n", + "\n", + "\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "print_size_of_model(quantized_model, \"int8\")" + ] + }, + { + "cell_type": "markdown", + "id": "023971b6", + "metadata": {}, + "source": [ + "The quantize model has 2331138 /659998 = 3.53 time less parameter than the original model and is 3.53 time lighter than the original model" + ] + }, + { + "cell_type": "markdown", + "id": "7b108e17", + "metadata": {}, + "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": "markdown", + "id": "a0a34b90", + "metadata": {}, + "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", + "execution_count": 89, + "id": "7665e54b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Initial Model Accuracy per Class:\n", + "Class 0: 83.30%\n", + "Class 1: 85.50%\n", + "Class 2: 64.60%\n", + "Class 3: 58.60%\n", + "Class 4: 71.80%\n", + "Class 5: 49.50%\n", + "Class 6: 82.30%\n", + "Class 7: 76.00%\n", + "Class 8: 84.80%\n", + "Class 9: 83.80%\n", + "Initial Model Accuracy: 74.02%\n", + "\n", + "Quantized Model Accuracy per Class:\n", + "Class 0: 83.40%\n", + "Class 1: 85.30%\n", + "Class 2: 64.70%\n", + "Class 3: 58.40%\n", + "Class 4: 71.00%\n", + "Class 5: 49.50%\n", + "Class 6: 82.40%\n", + "Class 7: 76.00%\n", + "Class 8: 84.70%\n", + "Class 9: 83.70%\n", + "Quantized Model Accuracy: 73.91%\n", + "Model Type: Original Model (FP32)\tSize (KB): 2331.14\n", + "Model Type: Quantized Model (INT8)\tSize (KB): 660.00\n", + "\n", + "Size Reduction: 71.69%\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torchvision.transforms as transforms\n", + "import os\n", + "\n", + "# Function to print the size of the model\n", + "def display_model_size(model, label=\"\"):\n", + " torch.save(model.state_dict(), \"temp.p\")\n", + " size = os.path.getsize(\"temp.p\")\n", + " print(\"Model Type: {}\\tSize (KB): {:.2f}\".format(label, size / 1e3))\n", + " os.remove(\"temp.p\")\n", + " return size\n", + "\n", + "# Function to evaluate class-wise accuracy\n", + "def calculate_classwise_accuracy(model, data_loader, num_classes):\n", + " model.eval()\n", + " correct_per_class = [0] * num_classes\n", + " total_per_class = [0] * num_classes\n", + "\n", + " with torch.no_grad():\n", + " for images, labels in data_loader:\n", + " outputs = model(images)\n", + " _, predicted = torch.max(outputs, 1)\n", + " \n", + " for c in range(num_classes):\n", + " total_per_class[c] += (labels == c).sum().item()\n", + " correct_per_class[c] += ((predicted == labels) & (labels == c)).sum().item()\n", + "\n", + " accuracy_per_class = [correct / total if total > 0 else 0 for correct, total in zip(correct_per_class, total_per_class)]\n", + " return accuracy_per_class\n", + "\n", + "# Load the pre-trained model\n", + "my_model = NewCNN()\n", + "my_model.load_state_dict(torch.load('model_cifar_NewCNN.pt', map_location=torch.device('cpu')))\n", + "my_model.eval()\n", + "\n", + "# Evaluate the accuracy of the initial model\n", + "initial_acc_per_class = calculate_classwise_accuracy(my_model, test_loader, num_classes=10)\n", + "print(\"\\nInitial Model Accuracy per Class:\")\n", + "for i, acc in enumerate(initial_acc_per_class):\n", + " print(\"Class {}: {:.2%}\".format(i, acc))\n", + "print(\"Initial Model Accuracy: {:.2%}\".format(sum(initial_acc_per_class) / 10))\n", + "\n", + "# Quantize the model\n", + "quantized_my_model = torch.quantization.quantize_dynamic(my_model, dtype=torch.qint8)\n", + "\n", + "# Evaluate the accuracy of the quantized model\n", + "quantized_acc_per_class = calculate_classwise_accuracy(quantized_my_model, test_loader, num_classes=10)\n", + "print(\"\\nQuantized Model Accuracy per Class:\")\n", + "for i, acc in enumerate(quantized_acc_per_class):\n", + " print(\"Class {}: {:.2%}\".format(i, acc))\n", + "print(\"Quantized Model Accuracy: {:.2%}\".format(sum(quantized_acc_per_class) / 10))\n", + "\n", + "# Print the size reduction\n", + "original_size = display_model_size(my_model, \"Original Model (FP32)\")\n", + "quantized_size = display_model_size(quantized_my_model, \"Quantized Model (INT8)\")\n", + "reduction_percentage = (original_size - quantized_size) / original_size * 100\n", + "print(\"\\nSize Reduction: {:.2f}%\".format(reduction_percentage))\n" + ] + }, + { + "cell_type": "markdown", + "id": "1e584293", + "metadata": {}, + "source": [ + "The test accuracy for the quantified model and the normal model is the same. We note slight differences by class. The common accuracy is 71%. The quantized model is as good as the initial model on all classes." + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "1827fb0b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial Model Accuracy per Class:\n", + "Class 0: 83.30%\n", + "Class 1: 85.50%\n", + "Class 2: 64.60%\n", + "Class 3: 58.60%\n", + "Class 4: 71.80%\n", + "Class 5: 49.50%\n", + "Class 6: 82.30%\n", + "Class 7: 76.00%\n", + "Class 8: 84.80%\n", + "Class 9: 83.80%\n", + "Initial Model Accuracy: 74.02%\n", + "\n", + "Quantized Model Accuracy per Class:\n", + "Class 0: 83.40%\n", + "Class 1: 85.30%\n", + "Class 2: 64.70%\n", + "Class 3: 58.40%\n", + "Class 4: 71.00%\n", + "Class 5: 49.50%\n", + "Class 6: 82.40%\n", + "Class 7: 76.00%\n", + "Class 8: 84.70%\n", + "Class 9: 83.70%\n", + "Quantized Model Accuracy: 73.91%\n", + "Model: FP32\tSize (KB): 2331.14\n", + "Model: INT8\tSize (KB): 660.00\n", + "\n", + "Size Reduction: 71.69%\n" + ] + } + ], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torchvision.transforms as transforms\n", + "import os\n", + "\n", + "# Define the function to print the size of the model\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: {}\\tSize (KB): {:.2f}\".format(label, size / 1e3))\n", + " os.remove(\"temp.p\")\n", + " return size\n", + "\n", + "# Define the evaluation function to get class-wise accuracy\n", + "def evaluate_model_classwise(model, data_loader, num_classes):\n", + " model.eval()\n", + " correct_per_class = [0] * num_classes\n", + " total_per_class = [0] * num_classes\n", + "\n", + " with torch.no_grad():\n", + " for images, labels in data_loader:\n", + " outputs = model(images)\n", + " _, predicted = torch.max(outputs, 1)\n", + " \n", + " for c in range(num_classes):\n", + " total_per_class[c] += (labels == c).sum().item()\n", + " correct_per_class[c] += ((predicted == labels) & (labels == c)).sum().item()\n", + "\n", + " accuracy_per_class = [correct / total if total > 0 else 0 for correct, total in zip(correct_per_class, total_per_class)]\n", + " return accuracy_per_class\n", + "\n", + "# Load the pre-trained model\n", + "model = NewCNN()\n", + "model.load_state_dict(torch.load('model_cifar_NewCNN.pt', map_location=torch.device('cpu')))\n", + "model.eval()\n", + "\n", + "# Evaluate the accuracy of the initial model\n", + "initial_accuracy_per_class = evaluate_model_classwise(model, test_loader, num_classes=10)\n", + "print(\"Initial Model Accuracy per Class:\")\n", + "for i, acc in enumerate(initial_accuracy_per_class):\n", + " print(\"Class {}: {:.2%}\".format(i, acc))\n", + "print(\"Initial Model Accuracy: {:.2%}\".format(sum(initial_accuracy_per_class) / 10))\n", + "\n", + "# Quantize the model\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "\n", + "# Evaluate the accuracy of the quantized model\n", + "quantized_accuracy_per_class = evaluate_model_classwise(quantized_model, test_loader, num_classes=10)\n", + "print(\"\\nQuantized Model Accuracy per Class:\")\n", + "for i, acc in enumerate(quantized_accuracy_per_class):\n", + " print(\"Class {}: {:.2%}\".format(i, acc))\n", + "print(\"Quantized Model Accuracy: {:.2%}\".format(sum(quantized_accuracy_per_class) / 10))\n", + "\n", + "# Print the size reduction\n", + "initial_size = print_size_of_model(model, \"FP32\")\n", + "quantized_size = print_size_of_model(quantized_model, \"INT8\")\n", + "size_reduction = (initial_size - quantized_size) / initial_size * 100\n", + "print(\"\\nSize Reduction: {:.2f}%\".format(size_reduction))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "3cd0b4f2", + "metadata": {}, + "outputs": [], + "source": [ + " import copy\n", + "\n", + "# Load the model to quantize first:\n", + "model_to_quantize = copy.deepcopy(model)" + ] + }, + { + "cell_type": "markdown", + "id": "201470f9", + "metadata": {}, + "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": 86, + "id": "b4d13080", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Doha\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-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", + "C:\\Users\\Doha\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-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 C:\\Users\\Doha/.cache\\torch\\hub\\checkpoints\\resnet50-0676ba61.pth\n", + "100%|█████████████████████████████████████████████████████████████████████████████| 97.8M/97.8M [00:45<00:00, 2.23MB/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: Golden Retriever\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import json\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", + "model = 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", + "model.eval()\n", + "\n", + "# Get the 1000-dimensional model output\n", + "out = model(image)\n", + "# Find the predicted class\n", + "print(\"Predicted class is: {}\".format(labels[out.argmax()]))" + ] + }, + { + "cell_type": "markdown", + "id": "184cfceb", + "metadata": {}, + "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": 93, + "id": "9648f750", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: airliner\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import json\n", + "from PIL import Image\n", + "\n", + "# Choose an image to pass through the model\n", + "test_image = \"airplane.jpeg\"\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", + "model = 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", + "model.eval()\n", + "\n", + "# Get the 1000-dimensional model output\n", + "out = model(image)\n", + "# Find the predicted class\n", + "print(\"Predicted class is: {}\".format(labels[out.argmax()]))" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "bdb6dbdd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: fp32 \t Size (KB): 102523.238\n" + ] + }, + { + "data": { + "text/plain": [ + "102523238" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os\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": "code", + "execution_count": 101, + "id": "15527c02", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: int8 \t Size (KB): 96379.996\n" + ] + }, + { + "data": { + "text/plain": [ + "96379996" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch.quantization\n", + "\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "print_size_of_model(quantized_model, \"int8\")" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "bf835c24", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: tabby cat\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import json\n", + "from PIL import Image\n", + "\n", + "# Choose an image to pass through the model\n", + "test_image = \"cat.jpg\"\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", + "model = 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", + "model.eval()\n", + "\n", + "# Get the 1000-dimensional model output\n", + "out = model(image)\n", + "# Find the predicted class\n", + "print(\"Predicted class is: {}\".format(labels[out.argmax()]))" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "f811bfd7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: fp32 \t Size (KB): 102523.238\n" + ] + }, + { + "data": { + "text/plain": [ + "102523238" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os\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": "code", + "execution_count": 103, + "id": "a107e578", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: int8 \t Size (KB): 96379.996\n" + ] + }, + { + "data": { + "text/plain": [ + "96379996" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch.quantization\n", + "\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "print_size_of_model(quantized_model, \"int8\")" + ] + }, + { + "cell_type": "markdown", + "id": "5d57da4b", + "metadata": {}, + "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": 107, + "id": "be2d31f5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "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 = \"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": {}, + "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": 108, + "id": "572d824c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Doha\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-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=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.\n", + " warnings.warn(msg)\n", + "Downloading: \"https://download.pytorch.org/models/resnet18-f37072fd.pth\" to C:\\Users\\Doha/.cache\\torch\\hub\\checkpoints\\resnet18-f37072fd.pth\n", + "100%|█████████████████████████████████████████████████████████████████████████████| 44.7M/44.7M [00:25<00:00, 1.86MB/s]\n", + "C:\\Users\\Doha\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\optim\\lr_scheduler.py:136: UserWarning: Detected call of `lr_scheduler.step()` before `optimizer.step()`. In PyTorch 1.1.0 and later, you should call them in the opposite order: `optimizer.step()` before `lr_scheduler.step()`. Failure to do this will result in PyTorch skipping the first value of the learning rate schedule. See more details at https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate\n", + " warnings.warn(\"Detected call of `lr_scheduler.step()` before `optimizer.step()`. \"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "----------\n", + "train Loss: 0.7073 Acc: 0.5779\n", + "val Loss: 0.2944 Acc: 0.8562\n", + "\n", + "Epoch 2/10\n", + "----------\n", + "train Loss: 0.4356 Acc: 0.7951\n", + "val Loss: 0.2135 Acc: 0.9216\n", + "\n", + "Epoch 3/10\n", + "----------\n", + "train Loss: 0.4062 Acc: 0.7869\n", + "val Loss: 0.2360 Acc: 0.9150\n", + "\n", + "Epoch 4/10\n", + "----------\n", + "train Loss: 0.4777 Acc: 0.7992\n", + "val Loss: 0.1972 Acc: 0.9281\n", + "\n", + "Epoch 5/10\n", + "----------\n", + "train Loss: 0.4712 Acc: 0.8115\n", + "val Loss: 0.1691 Acc: 0.9412\n", + "\n", + "Epoch 6/10\n", + "----------\n", + "train Loss: 0.5008 Acc: 0.7664\n", + "val Loss: 0.1751 Acc: 0.9542\n", + "\n", + "Epoch 7/10\n", + "----------\n", + "train Loss: 0.3635 Acc: 0.8320\n", + "val Loss: 0.1944 Acc: 0.9412\n", + "\n", + "Epoch 8/10\n", + "----------\n", + "train Loss: 0.3400 Acc: 0.8484\n", + "val Loss: 0.1776 Acc: 0.9477\n", + "\n", + "Epoch 9/10\n", + "----------\n", + "train Loss: 0.4246 Acc: 0.8197\n", + "val Loss: 0.1724 Acc: 0.9477\n", + "\n", + "Epoch 10/10\n", + "----------\n", + "train Loss: 0.4214 Acc: 0.8156\n", + "val Loss: 0.1954 Acc: 0.9412\n", + "\n", + "Training complete in 3m 38s\n", + "Best val Acc: 0.954248\n" + ] + } + ], + "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 = \"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": "8cda96af", + "metadata": {}, + "source": [ + "The code allows using already trained models. Parameters cannot be learned.\n", + "The last layer is then replaced with a fully connected layer and trained to better identify ants and bees." + ] + }, + { + "cell_type": "markdown", + "id": "c73d095e", + "metadata": {}, + "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": "markdown", + "id": "948d741d", + "metadata": {}, + "source": [ + "#### Modify the code and add an \"eval_model\" function to allow 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." + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "444ac048", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluation Loss: 0.1626 Accuracy: 0.9608\n" + ] + } + ], + "source": [ + "def eval_model(model, dataloader, criterion):\n", + " model.eval()\n", + " running_loss = 0.0\n", + " running_corrects = 0\n", + "\n", + " with torch.no_grad():\n", + " for inputs, labels in dataloader:\n", + " inputs = inputs.to(device)\n", + " labels = labels.to(device)\n", + "\n", + " outputs = model(inputs)\n", + " loss = criterion(outputs, labels)\n", + " _, preds = torch.max(outputs, 1)\n", + "\n", + " running_loss += loss.item() * inputs.size(0)\n", + " running_corrects += torch.sum(preds == labels.data)\n", + "\n", + " total_loss = running_loss / len(dataloader.dataset)\n", + " total_acc = running_corrects.double() / len(dataloader.dataset)\n", + "\n", + " print(\"Evaluation Loss: {:.4f} Accuracy: {:.4f}\".format(total_loss, total_acc))\n", + "\n", + "# Usage:\n", + "eval_model(model, dataloaders[\"val\"], criterion)\n" + ] + }, + { + "cell_type": "markdown", + "id": "f71263e3", + "metadata": {}, + "source": [ + "#### 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." + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "9cbfbaa1", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "----------\n", + "train Loss: 0.6326 Acc: 0.5861\n", + "val Loss: 0.4421 Acc: 0.7516\n", + "\n", + "Epoch 2/10\n", + "----------\n", + "train Loss: 0.4801 Acc: 0.7828\n", + "val Loss: 0.2792 Acc: 0.9150\n", + "\n", + "Epoch 3/10\n", + "----------\n", + "train Loss: 0.5157 Acc: 0.7418\n", + "val Loss: 0.2238 Acc: 0.9477\n", + "\n", + "Epoch 4/10\n", + "----------\n", + "train Loss: 0.5209 Acc: 0.7541\n", + "val Loss: 0.3383 Acc: 0.8497\n", + "\n", + "Epoch 5/10\n", + "----------\n", + "train Loss: 0.4872 Acc: 0.7705\n", + "val Loss: 0.2243 Acc: 0.9281\n", + "\n", + "Epoch 6/10\n", + "----------\n", + "train Loss: 0.4045 Acc: 0.8033\n", + "val Loss: 0.2575 Acc: 0.8954\n", + "\n", + "Epoch 7/10\n", + "----------\n", + "train Loss: 0.3754 Acc: 0.8443\n", + "val Loss: 0.1900 Acc: 0.9477\n", + "\n", + "Epoch 8/10\n", + "----------\n", + "train Loss: 0.4161 Acc: 0.8156\n", + "val Loss: 0.2161 Acc: 0.9281\n", + "\n", + "Epoch 9/10\n", + "----------\n", + "train Loss: 0.3834 Acc: 0.8197\n", + "val Loss: 0.1876 Acc: 0.9608\n", + "\n", + "Epoch 10/10\n", + "----------\n", + "train Loss: 0.4078 Acc: 0.8156\n", + "val Loss: 0.2228 Acc: 0.9346\n", + "\n", + "Training complete in 3m 37s\n", + "Best val Acc: 0.960784\n", + "Evaluation Loss: 0.1876 Accuracy: 0.9608\n" + ] + } + ], + "source": [ + "class ModifiedResNet18(nn.Module):\n", + " def __init__(self):\n", + " super(ModifiedResNet18, self).__init__()\n", + " resnet18 = torchvision.models.resnet18(pretrained=True)\n", + " for param in resnet18.parameters():\n", + " param.requires_grad = False\n", + "\n", + " self.features = nn.Sequential(*list(resnet18.children())[:-1])\n", + " self.classifier = nn.Sequential(\n", + " nn.Linear(resnet18.fc.in_features, 256),\n", + " nn.ReLU(),\n", + " nn.Dropout(0.5),\n", + " nn.Linear(256, 2)\n", + " )\n", + "\n", + " def forward(self, x):\n", + " x = self.features(x)\n", + " x = x.view(x.size(0), -1)\n", + " x = self.classifier(x)\n", + " return x\n", + "\n", + "# Create an instance of the modified model and move it to GPU if available\n", + "modified_model = ModifiedResNet18().to(device)\n", + "\n", + "# Set the loss function and optimizer\n", + "criterion_modified = nn.CrossEntropyLoss()\n", + "optimizer_modified = optim.SGD(modified_model.parameters(), lr=0.001, momentum=0.9)\n", + "exp_lr_scheduler_modified = lr_scheduler.StepLR(optimizer_modified, step_size=7, gamma=0.1)\n", + "\n", + "# Train the modified model\n", + "modified_model, epoch_time_modified = train_model(\n", + " modified_model, criterion_modified, optimizer_modified, exp_lr_scheduler_modified, num_epochs=10\n", + ")\n", + "\n", + "# Evaluate the modified model\n", + "eval_model(modified_model, dataloaders[\"val\"], criterion_modified)\n" + ] + }, + { + "cell_type": "markdown", + "id": "5c33720b", + "metadata": {}, + "source": [ + "#### Apply ther quantization (post and quantization aware) and evaluate impact on model size and accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "id": "067d5049", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluation Loss: 0.1623 Accuracy: 0.9608\n", + "Evaluation Loss: 0.1876 Accuracy: 0.9608\n" + ] + } + ], + "source": [ + "# Quantize the original model\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "# Evaluate the quantized model\n", + "eval_model(quantized_model, dataloaders[\"val\"], criterion)\n", + "\n", + "# Quantize the modified model\n", + "quantized_modified_model = torch.quantization.quantize_dynamic(modified_model, dtype=torch.qint8)\n", + "# Evaluate the quantized modified model\n", + "eval_model(quantized_modified_model, dataloaders[\"val\"], criterion_modified)" + ] + }, + { + "cell_type": "markdown", + "id": "04a263f0", + "metadata": {}, + "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": {}, + "source": [ + "## Author\n", + "\n", + "Alberto BOSIO - Ph. D." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.1" + }, + "vscode": { + "interpreter": { + "hash": "9e3efbebb05da2d4a1968abe9a0645745f54b63feb7a85a514e4da0495be97eb" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}