From 65ddb3e7cfd8438922d21931e9293383b29f583f Mon Sep 17 00:00:00 2001 From: lpoirson <louis14.poirson@etu.ec-lyon.fr> Date: Sun, 19 Nov 2023 19:54:35 +0100 Subject: [PATCH] From ex1 to 3 --- TD2_Deep_Learning_(1).ipynb | 2073 +++++++++++++++++ hymenoptera_data/train/ants/formica.jpeg | Bin 0 -> 7858 bytes hymenoptera_data/train/ants/imageNotFound.gif | Bin 0 -> 5504 bytes 3 files changed, 2073 insertions(+) create mode 100644 TD2_Deep_Learning_(1).ipynb create mode 100644 hymenoptera_data/train/ants/formica.jpeg create mode 100644 hymenoptera_data/train/ants/imageNotFound.gif diff --git a/TD2_Deep_Learning_(1).ipynb b/TD2_Deep_Learning_(1).ipynb new file mode 100644 index 0000000..8975cd2 --- /dev/null +++ b/TD2_Deep_Learning_(1).ipynb @@ -0,0 +1,2073 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "7edf7168" + }, + "source": [ + "# TD2: Deep learning" + ], + "id": "7edf7168" + }, + { + "cell_type": "markdown", + "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 Sunday, December 1, 11:59 PM. Later commits will not be taken into account." + ], + "id": "fbb8c8df" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3d167a29" + }, + "source": [ + "Install and test PyTorch from https://pytorch.org/get-started/locally." + ], + "id": "3d167a29" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "330a42f5" + }, + "outputs": [], + "source": [ + "!pip install torch torchvision" + ], + "id": "330a42f5" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0882a636" + }, + "source": [ + "\n", + "To test run the following code" + ], + "id": "0882a636" + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "b1950f0a", + "outputId": "4bc64027-627d-4576-888b-3d6fe0cc23de" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tensor([[-0.2028, 2.0237, -1.2843, 0.0230, 1.0070, -0.8287, 2.1567, -1.0386,\n", + " 0.4017, -0.8005],\n", + " [-0.9620, 1.8215, 0.6417, -0.6226, -0.5204, 0.0484, 0.6088, 0.1195,\n", + " 0.1533, -2.0676],\n", + " [ 0.8341, -0.3921, -1.1890, 0.0912, 0.0578, 0.8995, 0.7551, -1.4050,\n", + " 0.5272, 0.8045],\n", + " [ 1.8574, -0.9345, -0.7533, 0.7402, 2.1289, 0.1758, 0.2452, -1.3896,\n", + " -0.4790, -0.1870],\n", + " [-0.8667, -0.5722, -0.2892, -0.2629, 1.2258, 0.4263, 0.5919, 1.2951,\n", + " 0.4660, 0.1756],\n", + " [ 0.2268, 2.0921, 0.4049, 0.0664, -1.1903, 0.0072, 1.5466, 1.5110,\n", + " 0.1141, 0.7788],\n", + " [-1.3739, -0.1683, -0.6034, -0.5225, -0.3639, 0.5341, -1.1496, 1.9338,\n", + " 0.0659, -0.3923],\n", + " [ 0.1114, -0.4265, 1.3247, 1.1868, 0.0215, -0.7669, -0.3272, -0.7944,\n", + " 0.0213, 0.6771],\n", + " [-0.3311, -0.0580, -1.0317, 0.2543, -0.1310, 1.5036, -0.0574, 1.6840,\n", + " -0.2404, -1.2480],\n", + " [ 1.2702, -0.9774, -0.9536, -0.7468, 1.4159, 0.9679, 0.0366, 0.1911,\n", + " 2.6050, -0.9738],\n", + " [-0.4592, -0.3593, 0.2656, 0.7353, 1.1558, -1.0067, -0.3048, 0.8037,\n", + " -0.6275, -0.4056],\n", + " [-1.5678, -0.2606, 0.3406, 1.4114, 0.4305, 0.3803, -1.0418, -0.3449,\n", + " -1.1682, 2.8705],\n", + " [-1.9394, 1.1927, -0.3441, 0.5899, 1.3980, 0.5671, 1.3139, -0.3752,\n", + " -1.0007, -0.0401],\n", + " [-1.5236, 0.3370, 0.6458, 0.0757, -0.0781, 0.0312, -2.5394, -1.1414,\n", + " -0.2234, -1.5022]])\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)" + ], + "id": "b1950f0a" + }, + { + "cell_type": "markdown", + "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" + ], + "id": "23f266da" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4ba1c82d" + }, + "source": [ + "You can test if GPU is available on your machine and thus train on it to speed up the process" + ], + "id": "4ba1c82d" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6e18f2fd", + "outputId": "3ee0a96e-a3f5-4fd7-f771-377c7ea8cbe3" + }, + "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 ...\")" + ], + "id": "6e18f2fd" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5cf214eb" + }, + "source": [ + "Next we load the CIFAR10 dataset" + ], + "id": "5cf214eb" + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "462666a2", + "outputId": "e27c0ab3-32d6-4b33-c9a0-7bf4b99750f3" + }, + "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%|██████████| 170498071/170498071 [00:03<00:00, 49485448.00it/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", + "]" + ], + "id": "462666a2" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "58ec3903" + }, + "source": [ + "CNN definition (this one is an example)" + ], + "id": "58ec3903" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "317bf070", + "outputId": "2ed6557a-ea91-4208-bee3-6c1ac6ec828f" + }, + "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()" + ], + "id": "317bf070" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "a2dc4974" + }, + "source": [ + "Loss function and training using SGD (Stochastic Gradient Descent) optimizer" + ], + "id": "a2dc4974" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4b53f229", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "f81bfda3-b6bc-4acf-b7cc-a65eef9950c2" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch: 0 \tTraining Loss: 44.307754 \tValidation Loss: 39.392413\n", + "Validation loss decreased (inf --> 39.392413). Saving model ...\n", + "Epoch: 1 \tTraining Loss: 35.753493 \tValidation Loss: 32.884607\n", + "Validation loss decreased (39.392413 --> 32.884607). Saving model ...\n", + "Epoch: 2 \tTraining Loss: 31.538194 \tValidation Loss: 30.027051\n", + "Validation loss decreased (32.884607 --> 30.027051). Saving model ...\n", + "Epoch: 3 \tTraining Loss: 28.993267 \tValidation Loss: 27.458260\n", + "Validation loss decreased (30.027051 --> 27.458260). Saving model ...\n", + "Epoch: 4 \tTraining Loss: 27.132795 \tValidation Loss: 26.931607\n", + "Validation loss decreased (27.458260 --> 26.931607). Saving model ...\n", + "Epoch: 5 \tTraining Loss: 25.574330 \tValidation Loss: 25.314186\n", + "Validation loss decreased (26.931607 --> 25.314186). Saving model ...\n", + "Epoch: 6 \tTraining Loss: 24.262112 \tValidation Loss: 24.334575\n", + "Validation loss decreased (25.314186 --> 24.334575). Saving model ...\n", + "Epoch: 7 \tTraining Loss: 23.174192 \tValidation Loss: 25.005386\n", + "Epoch: 8 \tTraining Loss: 22.125215 \tValidation Loss: 24.085739\n", + "Validation loss decreased (24.334575 --> 24.085739). Saving model ...\n", + "Epoch: 9 \tTraining Loss: 21.263283 \tValidation Loss: 22.894592\n", + "Validation loss decreased (24.085739 --> 22.894592). Saving model ...\n", + "Epoch: 10 \tTraining Loss: 20.459993 \tValidation Loss: 22.631767\n", + "Validation loss decreased (22.894592 --> 22.631767). Saving model ...\n", + "Epoch: 11 \tTraining Loss: 19.646447 \tValidation Loss: 22.054595\n", + "Validation loss decreased (22.631767 --> 22.054595). Saving model ...\n", + "Epoch: 12 \tTraining Loss: 18.954876 \tValidation Loss: 21.892770\n", + "Validation loss decreased (22.054595 --> 21.892770). Saving model ...\n", + "Epoch: 13 \tTraining Loss: 18.268278 \tValidation Loss: 22.564975\n", + "Epoch: 14 \tTraining Loss: 17.624434 \tValidation Loss: 22.852805\n", + "Epoch: 15 \tTraining Loss: 16.975349 \tValidation Loss: 22.241853\n", + "Epoch: 16 \tTraining Loss: 16.397408 \tValidation Loss: 22.040380\n", + "Epoch: 17 \tTraining Loss: 15.835682 \tValidation Loss: 22.187388\n", + "Epoch: 18 \tTraining Loss: 15.328455 \tValidation Loss: 22.427778\n", + "Epoch: 19 \tTraining Loss: 14.776516 \tValidation Loss: 22.282838\n", + "Epoch: 20 \tTraining Loss: 14.260037 \tValidation Loss: 23.586892\n", + "Epoch: 21 \tTraining Loss: 13.701756 \tValidation Loss: 23.862957\n", + "Epoch: 22 \tTraining Loss: 13.271071 \tValidation Loss: 23.934974\n", + "Epoch: 23 \tTraining Loss: 12.851553 \tValidation Loss: 24.151106\n", + "Epoch: 24 \tTraining Loss: 12.386875 \tValidation Loss: 24.450667\n", + "Epoch: 25 \tTraining Loss: 11.917942 \tValidation Loss: 25.039863\n", + "Epoch: 26 \tTraining Loss: 11.517738 \tValidation Loss: 25.714219\n", + "Epoch: 27 \tTraining Loss: 11.058535 \tValidation Loss: 26.544897\n", + "Epoch: 28 \tTraining Loss: 10.693729 \tValidation Loss: 28.075849\n", + "Epoch: 29 \tTraining Loss: 10.271838 \tValidation Loss: 28.377825\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" + ], + "id": "4b53f229" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "13e1df74" + }, + "source": [ + "Does overfit occur? If so, do an early stopping." + ], + "id": "13e1df74" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "d39df818", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "outputId": "93f890dc-7788-452c-8b3d-5daf01d13eb9" + }, + "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()" + ], + "id": "d39df818" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "11df8fd4" + }, + "source": [ + "Now loading the model with the lowest validation loss value\n" + ], + "id": "11df8fd4" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "e93efdfc", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "8ba64ea3-64f3-4672-8ba8-f0a2fec99ced" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Test Loss: 21.712322\n", + "\n", + "Test Accuracy of airplane: 57% (577/1000)\n", + "Test Accuracy of automobile: 73% (734/1000)\n", + "Test Accuracy of bird: 52% (520/1000)\n", + "Test Accuracy of cat: 48% (486/1000)\n", + "Test Accuracy of deer: 52% (523/1000)\n", + "Test Accuracy of dog: 44% (446/1000)\n", + "Test Accuracy of frog: 68% (680/1000)\n", + "Test Accuracy of horse: 72% (726/1000)\n", + "Test Accuracy of ship: 77% (771/1000)\n", + "Test Accuracy of truck: 74% (743/1000)\n", + "\n", + "Test Accuracy (Overall): 62% (6206/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", + ")" + ], + "id": "e93efdfc" + }, + { + "cell_type": "markdown", + "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." + ], + "id": "944991a2" + }, + { + "cell_type": "code", + "source": [ + "# define the CNN architecture with the new network\n", + "\n", + "\n", + "class Net(nn.Module):\n", + " def __init__(self):\n", + " super(Net, self).__init__()\n", + " self.conv1 = nn.Conv2d(3, 16, 3, padding = 1)\n", + " self.conv2 = nn.Conv2d(16, 32, 3, padding = 1)\n", + " self.conv3 = nn.Conv2d(32, 64, 3, padding = 1)\n", + " self.fc1 = nn.Linear(64*4*4 , 512)\n", + " self.fc2 = nn.Linear(512, 64)\n", + " self.fc3 = nn.Linear(64, 10)\n", + "\n", + " def forward(self, x):\n", + " x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))\n", + " x = F.max_pool2d(F.relu(self.conv2(x)), (2, 2))\n", + " x = F.max_pool2d(F.relu(self.conv3(x)), (2, 2))\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", + " 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()\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\n", + "\n", + "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", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NMNftJRRwzDe", + "outputId": "1b088533-8397-423a-e582-d6ffaeb3bd1f" + }, + "id": "NMNftJRRwzDe", + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Net(\n", + " (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\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", + ")\n", + "Epoch: 0 \tTraining Loss: 45.816719 \tValidation Loss: 43.966355\n", + "Validation loss decreased (inf --> 43.966355). Saving model ...\n", + "Epoch: 1 \tTraining Loss: 38.209464 \tValidation Loss: 35.172074\n", + "Validation loss decreased (43.966355 --> 35.172074). Saving model ...\n", + "Epoch: 2 \tTraining Loss: 31.435999 \tValidation Loss: 29.549833\n", + "Validation loss decreased (35.172074 --> 29.549833). Saving model ...\n", + "Epoch: 3 \tTraining Loss: 28.073995 \tValidation Loss: 26.215444\n", + "Validation loss decreased (29.549833 --> 26.215444). Saving model ...\n", + "Epoch: 4 \tTraining Loss: 25.583197 \tValidation Loss: 24.258325\n", + "Validation loss decreased (26.215444 --> 24.258325). Saving model ...\n", + "Epoch: 5 \tTraining Loss: 23.430590 \tValidation Loss: 22.700692\n", + "Validation loss decreased (24.258325 --> 22.700692). Saving model ...\n", + "Epoch: 6 \tTraining Loss: 21.498990 \tValidation Loss: 21.403723\n", + "Validation loss decreased (22.700692 --> 21.403723). Saving model ...\n", + "Epoch: 7 \tTraining Loss: 19.799957 \tValidation Loss: 20.328666\n", + "Validation loss decreased (21.403723 --> 20.328666). Saving model ...\n", + "Epoch: 8 \tTraining Loss: 18.312641 \tValidation Loss: 19.622646\n", + "Validation loss decreased (20.328666 --> 19.622646). Saving model ...\n", + "Epoch: 9 \tTraining Loss: 16.875187 \tValidation Loss: 18.478383\n", + "Validation loss decreased (19.622646 --> 18.478383). Saving model ...\n", + "Epoch: 10 \tTraining Loss: 15.455087 \tValidation Loss: 18.739886\n", + "Epoch: 11 \tTraining Loss: 14.161176 \tValidation Loss: 17.485207\n", + "Validation loss decreased (18.478383 --> 17.485207). Saving model ...\n", + "Epoch: 12 \tTraining Loss: 12.833713 \tValidation Loss: 18.220959\n", + "Epoch: 13 \tTraining Loss: 11.581126 \tValidation Loss: 16.867536\n", + "Validation loss decreased (17.485207 --> 16.867536). Saving model ...\n", + "Epoch: 14 \tTraining Loss: 10.281501 \tValidation Loss: 18.264160\n", + "Epoch: 15 \tTraining Loss: 9.066314 \tValidation Loss: 18.052295\n", + "Epoch: 16 \tTraining Loss: 7.870172 \tValidation Loss: 20.063252\n", + "Epoch: 17 \tTraining Loss: 6.672348 \tValidation Loss: 19.564190\n", + "Epoch: 18 \tTraining Loss: 5.619572 \tValidation Loss: 20.775727\n", + "Epoch: 19 \tTraining Loss: 4.583318 \tValidation Loss: 22.814755\n", + "Epoch: 20 \tTraining Loss: 3.865993 \tValidation Loss: 24.554825\n", + "Epoch: 21 \tTraining Loss: 3.077722 \tValidation Loss: 27.161921\n", + "Epoch: 22 \tTraining Loss: 2.617743 \tValidation Loss: 28.106431\n", + "Epoch: 23 \tTraining Loss: 2.138785 \tValidation Loss: 29.020546\n", + "Epoch: 24 \tTraining Loss: 1.815105 \tValidation Loss: 30.161924\n", + "Epoch: 25 \tTraining Loss: 1.692375 \tValidation Loss: 33.760924\n", + "Epoch: 26 \tTraining Loss: 1.241958 \tValidation Loss: 35.043594\n", + "Epoch: 27 \tTraining Loss: 1.202187 \tValidation Loss: 34.946057\n", + "Epoch: 28 \tTraining Loss: 1.373119 \tValidation Loss: 33.273757\n", + "Epoch: 29 \tTraining Loss: 1.063768 \tValidation Loss: 38.109132\n", + "Test Loss: 16.849309\n", + "\n", + "Test Accuracy of airplane: 78% (780/1000)\n", + "Test Accuracy of automobile: 78% (785/1000)\n", + "Test Accuracy of bird: 59% (591/1000)\n", + "Test Accuracy of cat: 48% (489/1000)\n", + "Test Accuracy of deer: 66% (667/1000)\n", + "Test Accuracy of dog: 68% (680/1000)\n", + "Test Accuracy of frog: 76% (761/1000)\n", + "Test Accuracy of horse: 78% (781/1000)\n", + "Test Accuracy of ship: 79% (797/1000)\n", + "Test Accuracy of truck: 83% (837/1000)\n", + "\n", + "Test Accuracy (Overall): 71% (7168/10000)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "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()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "id": "HgKA8KzG-gqB", + "outputId": "0cebe1ba-d08d-4e2c-d578-5b182e4213e9" + }, + "id": "HgKA8KzG-gqB", + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "On remarque une accuracy sur les tests meilleurs avec le deuxième réseau de neurones, passant de 63 à 71%. De manière plus détaillé, en regardant par classes, l'accuracy est partout meilleure pour le nouveau réseau.\n", + "\n", + "Concernant le tracé du loss en fcontion des epoch, on remarque que le loss est 2 fois moins faible pour les nouveau modèle, comparé au précédent." + ], + "metadata": { + "id": "iZkNRz1z9mHh" + }, + "id": "iZkNRz1z9mHh" + }, + { + "cell_type": "markdown", + "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." + ], + "id": "bc381cf4" + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "ef623c26", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "08c27105-1b6b-4010-d49a-c8f176c58365" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "model: fp32 \t Size (KB): 102523.238\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "102523238" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ], + "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\")" + ], + "id": "ef623c26" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "05c4e9ad" + }, + "source": [ + "Post training quantization example" + ], + "id": "05c4e9ad" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "c4c65d4b", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "2b1c025a-b23f-4f11-aaa2-08e4f0814713" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "model: int8 \t Size (KB): 659.742\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "659742" + ] + }, + "metadata": {}, + "execution_count": 30 + } + ], + "source": [ + "import torch.quantization\n", + "\n", + "model.cpu()\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "print_size_of_model(quantized_model, \"int8\")" + ], + "id": "c4c65d4b" + }, + { + "cell_type": "code", + "source": [ + "# track test loss for un-quantized model\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", + "\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 = 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.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", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HqDGkcZ5_rdn", + "outputId": "41447794-76fa-44ba-b8da-7192cc846608" + }, + "id": "HqDGkcZ5_rdn", + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Test Loss: 16.859613\n", + "\n", + "Test Accuracy of airplane: 78% (780/1000)\n", + "Test Accuracy of automobile: 78% (784/1000)\n", + "Test Accuracy of bird: 59% (592/1000)\n", + "Test Accuracy of cat: 50% (500/1000)\n", + "Test Accuracy of deer: 66% (660/1000)\n", + "Test Accuracy of dog: 67% (674/1000)\n", + "Test Accuracy of frog: 75% (759/1000)\n", + "Test Accuracy of horse: 78% (783/1000)\n", + "Test Accuracy of ship: 79% (797/1000)\n", + "Test Accuracy of truck: 83% (838/1000)\n", + "\n", + "Test Accuracy (Overall): 71% (7167/10000)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "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." + ], + "id": "7b108e17" + }, + { + "cell_type": "markdown", + "source": [ + "On remarque que les accuracy de test sont équivalentes pour le modèle quantifié et le modèle normal. On remarque de légères différences par classes. L'accuracy commune est de 71 %." + ], + "metadata": { + "id": "LC1sDMqfC6rJ" + }, + "id": "LC1sDMqfC6rJ" + }, + { + "cell_type": "markdown", + "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)" + ], + "id": "a0a34b90" + }, + { + "cell_type": "code", + "source": [ + "#Test another quantized model\n", + "model.cpu()\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.quint8)\n", + "print_size_of_model(quantized_model, \"int8\")\n", + "\n", + "# track test loss for un-quantized model\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", + "\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 = 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.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", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TdA7xe1iDuJW", + "outputId": "0f669a23-45fd-472b-8aa4-eb51f3a55191" + }, + "id": "TdA7xe1iDuJW", + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "model: int8 \t Size (KB): 2330.882\n", + "Test Loss: 16.849309\n", + "\n", + "Test Accuracy of airplane: 78% (780/1000)\n", + "Test Accuracy of automobile: 78% (785/1000)\n", + "Test Accuracy of bird: 59% (591/1000)\n", + "Test Accuracy of cat: 48% (489/1000)\n", + "Test Accuracy of deer: 66% (667/1000)\n", + "Test Accuracy of dog: 68% (680/1000)\n", + "Test Accuracy of frog: 76% (761/1000)\n", + "Test Accuracy of horse: 78% (781/1000)\n", + "Test Accuracy of ship: 79% (797/1000)\n", + "Test Accuracy of truck: 83% (837/1000)\n", + "\n", + "Test Accuracy (Overall): 71% (7168/10000)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "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" + ], + "id": "201470f9" + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "b4d13080", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 423 + }, + "outputId": "578776c0-2842-4033-bd8a-ffedda0f7238" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Predicted class is: llama\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", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Choose an image to pass through the model\n", + "test_image = \"Lama.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()]))" + ], + "id": "b4d13080" + }, + { + "cell_type": "markdown", + "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" + ], + "id": "184cfceb" + }, + { + "cell_type": "code", + "source": [ + "print_size_of_model(model, \"fp32\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ofs6wepVIxCo", + "outputId": "582d78de-7555-4ced-cbef-13f484377d95" + }, + "id": "ofs6wepVIxCo", + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "model: fp32 \t Size (KB): 102523.238\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "102523238" + ] + }, + "metadata": {}, + "execution_count": 12 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "La taille du modèle est de 102,5 MB." + ], + "metadata": { + "id": "lRCKkPHSIxyf" + }, + "id": "lRCKkPHSIxyf" + }, + { + "cell_type": "code", + "source": [ + "import torch.quantization\n", + "\n", + "model.cpu()\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "print_size_of_model(quantized_model, \"int8\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7W7ZK6sWJamd", + "outputId": "5cef4ca9-7018-4f71-b459-42ec0c9f89bd" + }, + "id": "7W7ZK6sWJamd", + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "model: int8 \t Size (KB): 96379.996\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "96379996" + ] + }, + "metadata": {}, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Choose an image to pass through the model\n", + "test_image = \"Lion.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", + "quantized_model.eval()\n", + "\n", + "# Get the 1000-dimensional model output\n", + "out = quantized_model(image)\n", + "# Find the predicted class\n", + "print(\"Predicted class is: {}\".format(labels[out.argmax()]))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 423 + }, + "id": "PS0bnfqTJgJA", + "outputId": "a3f2116b-245a-4149-8774-2861617f48bd" + }, + "id": "PS0bnfqTJgJA", + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Predicted class is: lion\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Même après quantification, on remarque que le modèle est toujours capable de retrouver les images qui lui sont proposées." + ], + "metadata": { + "id": "mVmSkrkfJxlk" + }, + "id": "mVmSkrkfJxlk" + }, + { + "cell_type": "code", + "source": [ + "#test with others pre-trained models\n", + "\n", + "# Choose an image to pass through the model\n", + "test_image = \"Lama.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.resnet18(pretrained=True)\n", + "\n", + "model.cpu()\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "\n", + "# Send the model to the GPU\n", + "# model.cuda()\n", + "# Set layers such as dropout and batchnorm in evaluation mode\n", + "quantized_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()]))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 547 + }, + "id": "Z-_ounggKL_r", + "outputId": "b942d30c-ffa7-4aba-fb1e-b14a7a5463f7" + }, + "id": "Z-_ounggKL_r", + "execution_count": 16, + "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=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 /root/.cache/torch/hub/checkpoints/resnet18-f37072fd.pth\n", + "100%|██████████| 44.7M/44.7M [00:00<00:00, 108MB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Predicted class is: bucket\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "En testant avec le modèle pré entrainé ResNet18 et avec une photo de lama, on remarque que le modèle donne une erreur." + ], + "metadata": { + "id": "bcaYVNjyKeqM" + }, + "id": "bcaYVNjyKeqM" + }, + { + "cell_type": "markdown", + "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." + ], + "id": "5d57da4b" + }, + { + "cell_type": "code", + "execution_count": null, + "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 = \"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" + ], + "id": "be2d31f5" + }, + { + "cell_type": "markdown", + "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." + ], + "id": "bbd48800" + }, + { + "cell_type": "code", + "execution_count": null, + "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 = \"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" + ], + "id": "572d824c" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mq4MnH6i0AKj" + }, + "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." + ], + "id": "mq4MnH6i0AKj" + }, + { + "cell_type": "markdown", + "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" + ], + "id": "04a263f0" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fe954ce4" + }, + "source": [ + "## Author\n", + "\n", + "Alberto BOSIO - Ph. D." + ], + "id": "fe954ce4" + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "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 diff --git a/hymenoptera_data/train/ants/formica.jpeg b/hymenoptera_data/train/ants/formica.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..af83327233be73099c700fce654749842aad4a9d GIT binary patch literal 7858 zcmex=<NpH&0WUXCHwH#VMg|WC4+e(+w;7xnxY*e_*x9%^I5@buxVZTw1o(J)`D8`K z1SOQ^RaKPal@!&q&GpqZO*9pi3>*zjEUoSA>{Rt!Je_Sk%x&$gL547LadY$W^2rDY z$XIJAX;_mC{vTiv<X~uGILOSX#K0uT$SlbC{|JK&0|O%~$h8bGz{bGL!phFb#PR<K zgS`L)BNHnVGYbbR3j-@F0|Nsi6Egz~tDvHgA)8~Muu@{7h?tRaP~*gf>`ogmeh^hY z_)sNj(x#89CZ^6s|Bo<8F)}bQGcv-=2GJ}`%&d%T|Bo;j3NkP;F|sf+GcmJ+j0PFb zz%0ljq-ZFt<QT}BxbWZy5oM#oi5nj}IX7PX`2Q9I4>KbJlOVGogFVBg?9z{Fua>G_ zO%HxAo}Vl({Wy8&@gF~*_hyt@#U|$a``TJ{_G~x%)OF<n1A~a?P6Y<Lz|}UNn=-Fo zy|1^{HT<T_JH@LfJ+8g%3tsMeqkLCbdCn*0XUgZVf0eemnb&i4eax{t^LkEJ=y&w8 zEerT4*J<Pww`1SrlkpYTCtT_IvgzqEDetqpn%}1A2ukc1F1T}__ll^l!CYTWFP&Xx zh060APwZ&QV|!$3(daR&c;Aix3~iBWPipM9n66o3A%6Az`PXkHuZHfe+4|eR^q%1S z2QR<9-ZEwFO_m8BVIi0N9>xYgKK-6;%g$A)MV@?9mR`FnE%;4IPeuKr$;Ih2w+Uv? zc_s6}YOV8(hnmZ^u1s0^%6RqWH_KI<&w9%9zvQ<3yU>w+;>ABbYjZwpoKG@5Qr|Y| z{K8-nA?fPb+~I|BvGyKk?@up_yt?6cR^}CHO>W<g?eR-;ubk?V<D8LtV2OT`5l7pP z>1`<%^ZX<J-MPeGc%-NQj_a@3Lb>VRrd?d4Rd&<RK(}tezuCug=Wpn|8fEiTsxqj! zw?(H~OIjzs@VAS@q}=Y$_n%9>I@soNE5_i&s|sa?p5psYc`PhlT2-R!*WHd&-og5_ zq3Xzz7`M*7k58)IzGo{}XLx>&Q0M8{4-V};xbcX+s@j_`w~Nj!0AQVZ1()iRsv z=RHL+?sTW3r@dXE&?~-6l@sqU9yHn_d`-|!O?093k>%-Zs}IjvyXu~Jzu39tZSVf= z6L9ib7Wzsg^2xd2<@2V_@R0p>HP`9EjovAGY`h1z<nC{;?^N$hJ=5xvx$^YlplMTX z>MIDCK4!Sn-MhK)LPFckZab;jMc$p6pLz71S`G#IHojZ>>*Ei@^L)V}t2zJa)!R zTdL+~F{p9QjN8&I(^4j)5#W?8QuRpPds1<x&Y1<@ZwG8@{P4?l&+etu*%s)Y;fZm0 zF1BdarKvBAdryW)?VB`b=M#ssd;UCPnJ#)|?w3llCy^ni8$|XSY`P_4r!Ysz{Nsmy zqg%mQ@7E;1NfXZ8(_F<<yYQ{oOrLduX)3F-ymMb_XQjIE9dw9$>Yi_Jaab)i+;47t zs?nw2>>jz_LhnX;-c>V|%rbfw!ymTF@4VV~9)+@;+Y3Fu?JN8FS$WQq;MXSGUamiF zbTLyb-HCyrh<Ry;z_s}yQ~KqLUYT--FPL+%PvVitwUkL=PHHz9tR{X7XgZns{_V=; z?gc%~6TkdA796=a<cHHDwOi4>+v^^`UG^f-eyYdQ%gY^4@mQ4Ynsr+Du4Y=sBq2sC znQfj<{dTG9%Ez?!`#65Od}{t7r(gDWR!>O2yk+Z$CkN*&U+T4FXVL4Lr&lVw>*6nQ zWKNb{z-Lm*`?aX6Yrfd!6=%N{tLmNE#ptuCw~<{us6$ctiN8aF;i;pVKWD0Ge)0*C z;bvHuny1;a)@72wq24tUN}ATbEwb`kt9{S;>-TBF&i9zj<>y@d(H7KhuG1XDvyf|l z`pU4V-t{HXDnCmbPX1>&91yLSC=?VzX`%zOA;r|2d>v;5R;xvTr^#b?o3zDvB$ zuJrOxJ9%Y}NYBKQzT^WD#a)_q3TrMtyJ&c8$D7Uj?|7xjXt88%ytK%xk<05?mGiOL z+6Uba{^7a0+&^iVc3z!bLeH0$t9GeDn~Pp2etGV6tmc=z;U%7w3hVYCeT~}o3a>Bq zFWqa*c|~NxmUq7Y_JwudT3Q#iS0y;`;gOl83)oIQ6TY=JUG{?T-EiCEdK=_g_8wm6 zvs>BZ@t5b9Z`!rq<oBLhtrg|?OCv_+-f_Xywreqb9N)hgnQiSes8!>&buZMMS=v6k zc4ukS<6TSp7Fyr_d$j!WQ}#XFdY9*Su)1>cdTx29U%)q4K6=Fr%}4!*CABt*T6=0t ztGjn7h)JZz;jjBWz0Yqg>}CElJX!fZq_!<3<mJ)JuXubHe4iB&=El)GZN9Z~+|q4} zrrpgw!mveyl_7V6OY&B&n5SBWL7Ug;E*C!W#yz02Ut;@1JJnFZuS+j%mk8MDRpdVX z^Bmo^mw#Tct?gS{HLK?2PHS23cdCEvIh>wrtX<Kc8T4c8+DY?oF)v;5mGfof%$bp{ zHdj{HE`H@HdnE2w$Gz+9d2L*C)?NQ`D&_LZoSBuebG&2}Sl*V4pUJ-~edEC`y)=8i zdsCObS{^DJa`W37rs$yZOG0MSd6n*(TUR=4-)?{V=ZUN3olbY|{M$V<Pq+S(80%-b zXQrBmwyJwgsXp-N_#Bfwe%r@xwpI)0)GCF_{AYM=BprQ8`ai=C7Xv-xirMZ*(_H4< zOWgmvrARn$ft7PZ{2cictKN2;dlC1e@>sk7cP9?d4GW!`gpHPdFy#t!^-7D`Yjdk> zURlz)9lQS}{%7dh^I6o!@o?|?rJk{uUgh50Gx479E(z`Fr9qpeCQV#vuBrT4<<lp_ zcZ&`MY?~vQ`lkP<zq4HB8XcR4Uo8jBBmdMr-obph*tA`XFGx-0-i*>ES#JdxcQIZP zarbHL{?xQA?6Duq4lxs%ra8@Z1!tWm-uhN7^y*9HG|yoDC8-i8Y=hi5p79u{$7pHP zF1q~qcK-9XDxW={o}bwIl`-e=ii6)LY+1W+tAyRBUrAwMTQ!!Y3ABs2b_B5K+S%DE z>&>4u^Fh_^HK)%g7QNpRHtml2g*o4+u=)0}$MiT(4esFS*;u_*c4O=%x99TJZngG- z?!sr!ojI%d{?+6@h0}_5uRS*K-Y&@T+;?40&7?%@%#!W#_x~LKl673=t7dfcWT(XA zmp(sTcIB0))FF|O*(>W<X2*P1u9)aKS(snd|4e7et+!MAE4;Qmeo>irBuVA$jytpa zf>rNa*ST~_mgC*8po2TL>}1v#SaKiXY~5?{pwLU*i%CGJpoMpm7305rsh_hRKg-?{ zHCJu5gR`+#sb(gZ!@NSPfLEQHCW#c*Zrs9gWk#aD&z@t8rs!lvr%N8HeDqYMU-_Db z=2ffRL5F&EP5v`1_R+f6b9c?^2_E9&Opl&jEO=}9tC(@--OQQu)3;9Jl5)7PN9EI% z)y&xs1oUUDyXIgxvy@M}X0qH;-*s`B+NG(E3W{5G^6Olli)}b}LohpN_H@-{5zDr4 zzirh#tG;F5BBuNgP5ycbxjQx#SoKEwuAQ*fO#Y|XhfbdG3#*!V?wsz=+!^#$t~Ru= z`!Sn^<hBRpQoE+y-|<!bV${FMp><2z?i3m)Zw}7Lb@eb;b%}_&F2Qo|UU)Cx^bo1Z z>qEC+S`bv1(0wdr*X-_`ZAY$27Ti3R*Rtw?bf!Z3`YRQ8jE`_nT)wRE%T9}T3uJ?) z=P;gG_3X)QxwP9iwO^?2>8ee>edF&kv+XaR{%5ETFX-<-&U>!l&*{yp6V7g!AmJo3 z;oH{V3dIZ)pC<Tg9NjIlFmbl1fX-SAt^W*h@~>3=?cQ8|f9}i<?spa;yMKGB{bxw* zspR<Xk-D=r^@zCG;=2($1Mk$$Kik*q-S~a(s{IlNTjuB<@mgYZrD>&yj!;NUt`}F- z#>ppcXaBp_?A0#nabfP%!Y?)}Ihz8OuPr*<Y!x!`)J+!Q^AZg={iI5kOi|D@zr(~K z%lT*7&D#@iUGKb;=v7iszr=3S-Q`hE0h>aLoEmppOLN~pe@J_?cd+b@=g;(0MQ_|Z zBKzo8%I-NSJ1fN_b*^y5re+3c>^dHJVnywPxWx9<dBOTymd(w186~0<l=O0DWZToD z7xrC?`PQMyFy;1)563lZ9@mNFcc=tLEnTTyu}y^AnO}YReE%h`Z$3;7d;QFJjc9Jz z>t~z=?!1?N%-s3YbNRI+uY_7p>j=1R5-pkg)4BMMdeFl@mC1R9Ykg);JDk6yJoKLQ z7d!U%0u@QiGUhny8f}Vp+jsUtrOJc*C!Rl*UbI|AOUB+%-|V)ZCePF@OTRY;Icf&j z=CL^33i`X`L)D)n%@HTdI3N5u<t4sPu5jVyzc+e5wZ3nklTq@Yp-gedli6G%8j4KQ z_2%95+p;t-ICZts?I-VyckJ=ZoLRXn<n(dB4LY+URK5zBD@W<|`dVE%&86zP^`>K- zZT`PSA3IOgTs_<!v#F1vcu)7O8)1LV`z@Aj%WwWrF|U?`_r!mOW@TTmGnb|b{M62k zaNa-t^dX74%MC-PbLP5kpZIRB`<5oxeMxuvlpdAt+~WBn==Q9{gSpz`o-%6|ZoI87 z+3+Ro)|9!y{2H6Qb}#v@bzZgZTgTS?;8e%sN2X3~xVa+vEz6IlsbS8ir&VrRKAWZO zlI^29wO`MtJ^FJb=z_FY_8HxGk5ac<taa#)kUjQ$#<l0Fk&h(9W>zZfy2zb+@TY%( z3%{wdm+19bt9*=Fmj!ycPT>sQB(#*b_44`Jmdux>TE{bFe0fcuPR~;-Te|Jf={`{n z(H%>Le9!s67XR{-%V_DPH&@;Tr)n-0xM$T|<ncN?SLE{-_N5czyv`i1Ib^$JzQ})u ziG@$)GVk?tPMh*%mzt#Cg6N<QZWih8Pp>O74{WW~?RZ^v{ZitRtzi=tSDJL1p50Xt zsCF~VCdU4qO6cA7A8mT(G|Sjci?}9o>zPiB(;g9zOLJr<7C+=IcyoE(n$w;;7IlA5 zy}K!7;%Tqerhi8s3;62%nq9%pG%<O?>h9-rQjBG-KkWQHdFHfl6*?y*?Nts)P3H+& zGN;B*(RRzuEAO65PgR+nb^j3i?WN~K)x3?2R@Zt+UNC6Pp0qT_>_3BK@5iL5MF+pM zDC}yvG5P1@e~V^@EnVZiP?MKuo6u~&@Z;wsb2HbZ6wkOiKPY!@%9*M;OII!zI-HuB z%KCI-l9T?_sPAS6&7M9KfAdY$QZm!lm}g~vgw3y@CEVsK6c$9fXSZ7=>Au`!?m6WV z!{I)&1<UTM&aU>=VPN~dLu!w1?k1&mE6yC}xjcXI>fm0TwKpZFsKoA`;IZ$qrk~@D z6@oKLqNaVYR_-|eHg!Y8gNYMaw1O@RZC0Irvv9ShOE%k)_=3uwo+D|o(QYSI&F}R7 zXPE8sYs$^pUZy&)^BLsA@6`5$O{|Icy!GI)hM(m-f0e%K)-8Gpv!(?Fh<MpCP276W zX2IKiY7b8xU-02??u2!BW;X4Oy%zq)jFavAN%Ny^^ESpi6o2@&)i*VG#e~IILhgSr z*%jpxU}nZ;l~dsM!8ZP3=BrxwUsqaAn|3NZh@3GwpkVn7EvCoMw?`*g=(7B3Q*~Ka z`AG8Y2cFexXQkJwhB1ip{8pFqk~icl*mP#Ka7gLS6-N86>dubcvg*74Nr%5lw!+;L z{%mx)ee(LP#<g2+@A2a*u959sJFn6(^w8C^<vU&#<;7Y_&dl}X6yNBvb?V$r`k!03 zCYPpZuk^h-@uPOd?-pj&Q+sVU_kB5>Dg9hq&bDsDd$vNs`O7T*YwPb%&pM&dxK`{x zgUr9cMY>CDZp{o}(GV=&?r~Z>#^ODHVaS|23wTf28wgF9|8K9`QOhUA8Ru6XT@dno ze)3P37aL+0?Y5ScD0TXN_?(GV{cgc|0ee4u?&X{R?ntihN;6Pjsb;=<NX)D&jzON5 z3OAZhai~~)%572AZ}Cx)7JM_i!eR3zzt^E#cqUFg9M`dB_EhsvF@dR~(SMwcr-e-` zcx>!5{qd=+DM77!bvCV8oxAg{Vf2w2Z$(q}oBM9-pIK|}G{bMYNPg2IgWTK`I~zhp z7ao{0Wo0@8Pvdj`EthV+zpEK|YKn;Q?~<<9m%<~zOxE<(%_!P*%_A(v>1JN;v#5w& zPiNOGSbyM+UCe`ReY@7QS{4;enW=jD8h@_#V()HstF78v3OSsA7brz7__FEU?{W|O ziSegv7Ch=cw&g#AyHHnw_vE@qmsd`ezF&Mk_xQw)I0-)S{w@010;z1NJg>8pWB%;V zip;s0Q6TU-j!XK_AH^+7K`YB;Hv3I{AKbj%@ce%U%Vy1KOP-&a@<Kz(<aN%Z*=axb z9<aRq=fIoe+)A-emN{N{mBaB~l)EqdPVp~S&Z3Fu*+OQuCZ1=jnmB9b;*IH(WT$Cu zC=^pvyL0TN{W&N7%ysLQ+H|(=c%F2VK{k?epTn;iZ1eK!e6OmN&VRF7-1FW1+ljJE z3T2-1UVO7xXYr=aE3ChMq;Z=(JEGIB=5@<_Wy+JYRau^2Pk-C8{6LUs!R@&=J8O?m z3B9yx|5e$di9xwO=eBW85YrK{TJrh+l!((CEw-iJO?_$F-VmIf`e;G^#v2jR4-T&n z;@RvK8o6<ag^c&h*u&ZP9z5t5{(8^YX(Nl#e}>Mv&0E?c=NB4(o?@pmWp<!uaK<kG zBNIFVe#!4Yr=xZGQfQ^WYelz4R%&ut=gWtacr1@?tz@5Y*HFXQ`0cK#+ZQlRxxcGa zZkr0@wPTFWmd){be6n=It-~#vjEag}d(Sr9i2KoNm32RAUPs^6fUTmln^Zhk23<bo zbZqL9?;SUObhIrCnS1o@sf$T*dULhUZk$uIf3{1h%IE#j-Nz<P?o0l6=hzc*otek> zn(9jyEWA~w#h7U8dQklN+_xE*pJe%bShTWd!;iYDwkuUX+}Nnnt8zQBNdLT+&05LE zM6HcxT+b|BC$B$a>hvY-Ze;d$zNK5cU&MBKdbKN83w}NlTw8tO;Nv@9xo&mF$9J^b zI38?Ey?X9qnCfz-ske;8Q+D`0WuLUO#OCdcB@e!b`p+#i*5I`XUz$-6nW^-EyXgK~ zwkf+dms)aWE?N+1(6Tz<&vJ%-CJv>a-yF_(%$c6HSm()>Q{@}^GC89>PKDU*&Xs5n zJGE@J)$4a^8dr^0uKe}-z4~dNg}JhtyQZ*xxbkO}+RF9fu2*iAc7Iknwf~l;=6at~ zKCAo+7#^2hTDa-*iT>xtEZmB}QjSj1lZaY>olRr8UBEK^2s;PWQ11Ku78hRrd*fCK z&-|~JFQ1&~)XJj9YkWB5X;wg~?@JbjX`xB_Pe1=>s1CZ4aph%XWqYk!##-K~Cd{6j z`o0BP^GnE;t$4})PcOB6=lfmjc08AP8#hDhZoP-i70;hhV(Vs$Z<}&Gczy0nS)Cn1 zVt!$!GM}v7-S))B*FW#6sN}i#vd~ZC`OOV&PB!|yZpJEiqJCXIKkwtASL|DYR#&(r zP2N&;?G{Ix&$KyZA+M)Z=B_$+R9oqOh2oNr)tmZ_)TFOn%3bYyXiH!F>(kW^Gxn5d zH0YkwuDW<k!oz4akHM_PbDTX_oqF+B$Wu)A-q-$k*#%Z>rp=h4>#bvPsgF_8hrd;) zhv)CZXV0ch;yk;7^QCC`a?x#$6IM-({4yi@kWAoT$uB3)p3yXNnQF2-enZ^%*GoRj z^i>_}n{~UmBe+=8=X92bR))^9-w{oAi>D>?1V2o-Fw~kGF?-n#W-cxV_8qHlKfUmG z(d;j&x2t6251d+encaHIgR@%#UKo3^MQ&YraZ0PSRo_CjYoTwqeiKkU8pCPv>AIzl z+>|ZLUS~+_9r$AXXYrIc(+RVAw;DWOY~yF`ocNz1?EVt*jV8OxL#u^yJU>Vui;hj@ zGuPvPXzaV~(x3icGiF`dHdohTs@WrhB{~AZ58NK9o$`|0vPS9F1^p%O+^s8anciw? zHQTNyxzbzpX-ezrU5`^fd$rx!H$l_#N4=rae}-)D88Mew&!=q=dU0HN)4s6w%W>26 z5B7(z^=9K|<M2MQ(%UO{?$Pts|2{<eKD2*T@;vqLRGUjprZTJyId$89AD`v2>GrIP zb_Y`?1>g5%(fY~7p1l9V!6S=nXL=?otTksfJ1DShaoE8FQ(onlD(J90&^+QBFjXsr zd5zWL?0=ytwO<{R^+o<OWTt!NH~(UO_~$vZv5dB<=OcZO<vyyqAt4VZt1wJ>VRcyR zWq}x@V5RTetc~io6~yl5x^9<_<Ia{|8W)=wo0>2=t0c*4*QR@}FHXMObo=3!T@%+T z2WRcCRQddY?RHMSoXDda(<+y8$8Kd=bt7QAM*h~K$i(SEj_mXG?<B}iXrEV7C4AEM z*{SMX+u82t+ZD{MvHH(ov9wZ*=U4`G#30G|6s&RHpJ|&i8`LDX3(IbgS9|5*p`P92 zzR_8s+U2&|oyB3R3bItw@4ji~Ilc1sw&f!E$s3ptJxQ;hQ<2wk!u{W?7;Qx>31ybI z^Cr&vwcNR_!)|-x!I=pQ_H4~`_F}gTWQeG@kMJw_bxXs0ortL3agY7wkL0Z%A2JO* ze2J4!WzX+cmx#tC5j^pB1<${%@>!7Uclm3UZ`YOG&u6VYch^v~x8CB!9H~F^SdPtG zw(a73A=d3GY0|EyFI!(uNqyOrJMEU1{E|G^RaGJaN7gKKnq;zmlgG~6;@wfzdR75} zOQohbFmAbZ=rQ}u{kL@2N1ZEcWL{@^OMGUdc1uO8#`V8)8EQ9F#r9Nw4cax`L~G8L z70*ru<=B1vVz|iCC}-!=?%7W*cHX=BuV#_`DxQ^h-HL;befRy(aQ>W1{*`L|*S}77 zzq5Zi<G>%wbu$Y-UDdj<L6NI`Pd<-+!>hAvmRKB~X0}VDY)@|fhgnQHouB4%n0ZC9 z=WVw>nsS``%oLUF0rNDqt~A^VnB2Smiu|)A-MrN{`a+v)AADjtw%j6YwdPdA_5T?T zo(cb@a#`hdqQl!H<%pF9cM~5xPqwvkV(@C7#kzjSPC4bLOvZPNBT{3RO`pQR9yP`6 z#vS=*O0V80*%r=P&tvQ2XtbM2#*uwtx0k;_h^DvyVxOsI=BbxLnos9NynHD4EG4Zm zX#QlW-jfHm{%1JjqP$t{jd}KyD1B=k37d|CT#wmjF1WbkRa`2g@YyP(qm2Q(Cal}} z^mEh9sOJ1lBBx&#TE8#+^Zav9=F)9TmntrrTz{gju-tEE$WE^bzb<)-v;El_Q+)oE zk*U1D<Eu4~(xVsnU3ipv-c;A@rm#<YQ^U8T=YDLIWVb)#yw+=FOIGTmB}*Py?D@}d zb^A58Ct0s_RXr-T_m!-8!f(6&&z|VhS1ztGTPh~LZ))yuiIWL0UlvX@zN@poZE|`_ zV912J(5zsqx2fi>TeeIH+W3gCE<iFk*2(v|MPF2m;>{$<wWrKCh5n3Xo)t2=VEuQt zj+wrfi-gz;44*%gEmeKBTQn`++t_E*vM>(YDVO+8mhf~-PjG!(yVH4=clOhWk9wCQ zBdv2RgmwibdF@oXy=KoO8UJtBKg_OHQ`&pmTlLr+DNj$f+pfBShYx*q(<%zm_dI!J z+ESn3skyqkYDaz6l!x$nNLVK@=~fyCPn)-N%VRCRvb|6Alk-15m9Ywo4pCQ__gvn? zb%B1|#apnf+4HNZDVF`1i6&#(k*ds{YEG?O9A3ND%u0*Wj4EZE_?*c&qb#t}>5j+K zRo8!4IR5V75)8HU@xK1<s95H!El-auJEgthX$z~U!%e9rr#jfndDqu|P;Oh*+SHyh z>2cOw)yNMDw;mi+-eWgueVWwQN_(C#lM+6sQ^zJvywLdTo>NEaaprQXpoiBSY}R)_ zU*qBP=#nGvjaOHD(ztBn{10<qee%cf^5P|P9(iurYIstpQ^wKm=B}9Hxd%fJ?r&Y> z91|U!5y7(R(BXhRQNQ-gZxdgA@<-CqrQ&P;GXz_ieC=y#e!bS|`<JqH_D}n&UIuR9 zOl)BIp;W*6<d4LvJ@ebtH+WV||Kii|T;lAGZauG9m)Wacsz`LLQ!4bj`q#|s+x?A# z#jifqNyM#Jf7ozs`3|XogI}+Cwf|?}_p&YZV*Xdd5)_gmwPJ^i(WIOSa}`XrgytU0 z;rnN2P!7}8S8>fFZ1Kve>sy?rc+A?M_N!Wle~-m|9*dhh=4l0-(8~H|TYk@!KYa3s zL!iL%&X_!NwTb1nDIP0U{M`EQ*O7<%R@0nV9_)QzboJPGi9K>4SA#vt>zjLH;w>JY ziDh*mkuT?a+`FE4?e~wPU0LhY{xjUN+;-~2rzU-vv3j?7t!1WmZ<{pDQky+))!Jv= zUej_t1I@iVxgB>X-&DHuh-b^xrl`~<+Zs0o&1QVUBGD)3`*+54T_-ONtHiFCUTp&2 zleVr&bZK^8E|RI@ShLGSfg>r*SC=tS*kMC=>SWN+u%LUZQ!9&d7SnHc9V?E21ubE+ zEZTfcA{vUK?T%cB7qoJ5xF%k3+VDcrsYx)RL|_d`imE+iLHZ8Lf{X!GCHDVs0sx)X BsEGgo literal 0 HcmV?d00001 diff --git a/hymenoptera_data/train/ants/imageNotFound.gif b/hymenoptera_data/train/ants/imageNotFound.gif new file mode 100644 index 0000000000000000000000000000000000000000..bdeaae94004e06c6a35d147ec58fb35062076b52 GIT binary patch literal 5504 zcmZ?wbhEHb)M3<Nyvo2}Z}0f#&D(F^zIAkTeEj(F?%lf$4UH#GoLIGL)y9n*FJ8R( z<jIp)uU<`@IC198S-rh|@7}$eIdkToJ$tTQyOxxcvS`tw^XJd++`04i?b|^?!AqAe z+q7v@QBm=+W5*93JoxF;r|;jtGtd$!{^ySH4N!1NEJ=*;4Y0AVC`e4sPAySLN=?tq zvsHS(d%u!GW{Ry+xT&v!Z-H}aMy5wqQEG6NUr2IQcCuxPlD(aRO@&oOZb5EpNuokU zZcbjYRfVlmVoH8es#RXG6-ZcLNdc^+B->WW5hS4iveP-gC{@8!&r~<rz{pU++)~fb z)Wp)zP)EVYz|dIV&_LhFQrFPX%Ea8t&`bdel<X92ic-?7f?V97b`_<h*(zm}loVL$ z>z9|8>y;bp<rk&v8(Lag>Khp88yV>qrKIT=SLT%@R_NvxE5l51Ni9w;$}A|!%+FH* znV6WAUs__Tqy#m#BDcWT7jAG~u^!k%ddc~@`W1-<`i6Q2`nkCve}O$*ToROua0XV@ z#UYgisro^w#rdU0$*Do9Y05}e;kO8+u)x>X$|XO!G&eP`#M8xAsUo*PFC{a@%FNWr z(!$il!qD8*z|hdu#KOSQ$<@Hf*v-w!z{SAL0H)V7uec;JFF6&aHxr@P9Isw0=c3fa zlKi5O{QMkP>;+`xm*f{`<QFJ7J1c1TCMIX*f%uxBumuO4l}l<-W?5>ATTy<l0yuE2 zGO;<p%)rUn&C$Zy+{Dn((AC({$=uAz+}zp1(b?3@%*<5@sy79j$02$xaq88#Q?Sto z#Vk@x!-Rrd+(1llq68&SI|W3_Pt8lQRVq@lw`2VO@9&@AzkdGs{_X3R&!0Yic>nJ0 zo7b;izIguZ>66Eg9zM8#@9v%3w{G6Je(ma&%a<-*IDhW!nbW6Eo;ZH&=#j&R4j$OQ zZ||PnyLRr_zHRH4&6_rESif%Vn$@dTu2{Zo>5|2Z7A}}SZ|<Dgvu4hiK5goh$&)5d z=<n<8>F(<6Xm4w6X>Mw4sIRN7sjjN5C@(85DK083$j{5o$<E5mNKZ>mNlr>kh>wen ziH?el2oDPl2@VPj@b~le@%HlcaCdWcadvWau(z|dv9_|bFgG(bF*Y(Z(AU$|(bm$` zP*+n`QC3n^ke8E{k(QE_5El~_5f%~@;OFDz;pXDxU}s}xVP;}vU{L(Y0xo-WKqRQZ zV_^I5FrmOhN2>qClA@D2R`V~cDDhewwf@GMveR#?_CMHA;iEVE{EIDBXY+R7|FEOR zZ~g7}Klap}fB*Y`Lt|5OOKV$uM`u@ePj6rUgo%?TPnkMx`iz;gX3v>BZ~lUXixw|g zx@`H1m8%LF*RET?VdJLFTefc7zGLUE-Fx=#+kfETrVPf_$Fh&6pFDmh_4K*37n9GY zT)A{T>RQsR8+SwQBs{qH*zZx?vnMY-Uc|h4_1@{-%@1F^KSh53dhciWpI_Jitz!9e zJ?DW)GfS^x&nAP!Rc-zXRwk+&J&$%S*1L6hh5urqei_@w81YH>PALDg<Is@wJkZ{J zWEqFThDoW5XPQbLo8o!-nbQ9`_sc$=dAV8O!h%z4WOS`EG|w#Ysy5<%@@3`B*3jjz zPHH_}GO;aY>ov~R!dhaRk{&K-eYCaX$kxp32YNM3PT$#)_HNqh>~O6(^Q!N&?h5_L zpMFT}XO?5mk2Uwpy2S1CY}yJR9c)(*{+IOgQ>fuwb7Ri4OLPU-FL9Ok+$(6Des<OB z4S9cOp2@km-QKOv*JRt2JG)}r8Re!|2wirbz-?$Z)zb6fg2dl$kN#BVnp|~GbKkjp z)0da0_vgQUx7Yl~hiB`ZlQ+l4SHFIJvwQg;xw@_9Ur#=L&L{i(&!hi$ug|Z4`FHF5 z+RG;j6^yw*Etjifyme(k^T(rx4>iT>T<66ICQbRju#NdtxPrHQ(~kvBvj2h?b&6iv zxJXTZ*H*;@&3(d)dla247Im2}TPVX}&$l$T-|pNBv5A-Ncr0wF);QTQS;y$6%A{is zlBrE~5t$-Wv;Igt5sl&!QtMOq+nH>VJn3eVeC908j_JOIoL;lDyf``LCZD{?HmBu5 z=cAcbA8sz6H{(a7`m|^!t*(XbedQdBGaagCO|0>VYFm0TFiLY_f5NQHzWRz+tt&oe zoKjofH6coCMfsv%D^{<WF-vt#p_Wv~g6FMG+3V)NIhC!x@82%Z4TsX4ayCwv>CRC- zrDyHA`J5Y5?v{QZ?_A|;VG|n|@02C5Y-dXdIKuS6&Y*?u!Lr%^*ReT!I54sb2{f+T z#bz_1VTaopZ~Yx_j2Io6_yZUm*w|DyI0*fhQZQis=G4%#@8zxTd_jTf)%k*a4XYW1 zZWqmNSo61MA_Id;z0VOQ6=nf_L9Qh^>jc=A=xjd2#?e@Giv6(7=Q9t*1V5iMF}~=? z=D_@*;jpWR!<TcCYu*%JRQc|6<h-jluhZ#3dB%g67@owWNyH`cI-GU!n6Qc2wI}A2 zKuEZ5%MFGZJWjVA(jR=i6Og{P<z{8EL*YG!FV?0H%J}D%KeU>>r|?#~_{mkGn&}_R zPu2;4bU4-hIJSssPWils%Q8!J%&*RipJ#Nl^Z47!=YH8|w=xQ8C^RyASKt1xcXp%q zg|gSPR-fDXvTAu;)rI`|c`XN+mH%4Ur3BQL-*#2tZ+LjwcwxhVnZdCvY)1ZT_KIXN zfA}OIU}Ip%5pC|*!aPy?{_k&hH_tWtqgmZwd2>-Y=Oz)UB{{nVj8Dt31cmLqV!Du- zdGS2K8{5s8y&4-CPRIz}5#RTjm$9O#TK?Fl=LfzPe#kl|&GgCW!M^pa%{&}A3LHDk z4Me+q3#3Ar*gB>ie82Hb>L=x!A}hY_SMhkC=e$FbL1V!IrH<ShGnqqzwks?YKj`M2 zxDhYHCSkL0CSR@-NBrwaE4I!^G;F`RJMqJg7cKt+*R_0Mc3|uku$pw!zuk=|k!Pxg zy8y@ki8&`0Ge}*3vcj;ZfP?3Vlwd2vp66%tIsgB<rr0^bX>nsAS8vE-7RlvK$}RaN z-7-$f`#p~N=3VIZe{%QJh6E`NrM0~RKW=Jznt2##J(#+oMpZzR)BSYqgshD{Pj$L4 zxG{AJu|)YC5;lxH&3(^ka?76uXU|PLZtH2t^)OmS+cCi{bJCfnlG~AN{RfVIDCO;O zy}e9OOkwYogRe7vU7BtLT=$(>xpuC_>Fej}G7ss`Xlo5PGHd6LZ-yIljb|GRt6Lps zTUS)KvHal|ahA+wHZf|6a}#`~JFZj@oGCk{CPsR;^rq6*r8B*A<&z(}zjxo;qQ$tt z=yAjEfK@)K8VnWxSzKm0U)6M<HgDq+hhWX)DQ2F>uTJK+S6=jTjix2XC8M6egqN1= zvszhou1vi0C0<BM(_(4YrBz-F7D?Sd5UAb4&vat4=1H*&ZdYuJ+822@NSan%(VcL0 z?tvUlK|M~lb8D}zDGkk*owy<VZ|^3qB=1D+vmRHsE!sNGSa*@w0j;a5N{kgZqf?U3 z-`YJ-Y~gylr;o+AWbOJG8Mw;FHb+9b^SWhP<2r>0x8zziEKg0kwn3p{t&qWQpVbo< zPS-k;e(HjUo4QJ1)#Nw1!aCC7lh*PyG4bAatoIH&)x@x4Gq0TVuB_Ir%Y++@vX>@J zo^?_^NqDB;gL@ad4n&yi8K>^4{{P5)?(4f3tOVOV59qL|wP~EKbKJ`ivC?&C=gydY zllJ}5P0M=x((At#!+{rP9GJweH^yaM-^I3hv3X)f)H=za17dyaOIi;c=$`jseW<{r zu&1iVjkl((^=wcN34U&-az>y)@QLaJuhoy9Dh2P9a@#0Sa{Dm<|1I1xyH`{R_5>`L zdTp=Mg;!PGdp0ZcGcxa(8+o~hp>cWCl<g-%K3Q+(xvu;s^a#^irqZ<y2TitpTcPV` zSfSW)MAF!iiT{KKtIUSe+Yg4+98p!CJ@<6t52=OgSG-+Z`;xIS+=-EyosH#Uht9KG zaoOC;(aJYu{$}W`=-tuFR=8CBv|ZJ_=1a4;InDk5mh)A>=fpG1_Jyttp35Gx`4<1W zy00t4bzfT@*|n1O#MX733CDK}E@0S`=D^tTA)8I+;q^WLOa)qV-zYHs=HQkv6D--A zts)|Q>yjMPrscVBa)ljl?9BTn*y8&p-T!yqgJs)x%w73XS0RDnL*Mref(;Fs{0TSM zB^m@cKIB!nGjy=-Fy~-em#?(vH-pQH0}N^bEle&9_jnz42t3lwSN>pqPx`@D0ksbw z7+q>O7|)w=ur+*`Ag*}-V_(CG_6hmi4KWX#EF75soGlPoFz1obeT}ti9g3Q-|9<*I z?+2@tK@MAv!gD7B%Y)f`OiTx?pYupKu;>+RVvIR(!)SWN`N<Cd8@NIeZg8(Sz&0tb zH12uyBQ<%a^Ow(kYBGMn#5^N)pEARj8Q<qH6o^~yeO~ZdHz$^(dVTdi^}Z5ijo4Qq z;!Uh_^NP7$_AuJ1A7YvH_q+0mm^(ZxDp~6C%9A(OK2dG2yscbcRI$6}0aL%#B|(Sp ziY#_vZ{ImRjqm@pfO{chvj3rn?RG7^2W+29-#EbZC~q_4oO>Ko&7GKq?ANslSHE4v zUi;Qtzw(i=;(h1mTTgyo`>{7#o@LAPSLaq6RG;&&|6nH1z;rG5eIk1e)46i1KgD@9 z0xk}Z#3UGgUyb{bfBink&+D~L0gNHvD=%y>da*tK|Mjv}=C$GhjIIw#j*Hj*w-T?8 zF{tKs$p5meV4HZcad~N*dV%70MmYwiKJ{7!hWcaQ8p_mJUQRO(THg4~yw+_(!@BT% zHi;^Zh=M=vwMO5wncN%e-5cM0OHMPW{$9@DHKY8cdydg{1_t$}@7pRA9#m_bXwqC! z?>nRJ!?)sB%Uir|6kIf~a@|mF>Cv2Wqxt&sd=`O1HT4!t_m<11bs+(DZ@0IqPi{<l zQTP2>3HJpCp6#WA0ZqQ)^;#9RaX0F3O{=+gyso*U?b7$k3J#{g<0ZNo#SIz-au=$c z13Jx5l$ThrmT6Sj>}adDsErFRur;p{F=t4=-k>wR!%Kj1XE;k>dCioF`gDy>vl;dO z-?Z1|{wO&7tlPz*r@_2gG@~WepeyBi<FpFKIX8NqKksUpUU%hKb*Kd6-RF#(X0ZI6 zp36F+dd>A(=?e@}-wW@R8|*pJ%;L~(dZJmwJSR7z`)x*Dk%X(*i}Ka!b+?!22evZ^ z2QZ|Ucd3<kUyWe=^P-050)uD*BkKc3W`~Y2_gp3o7UyyXrp`X@NJhq;jOWx@1Ue`7 zu{W-0pZGAXmo<S=^a8{0=?!l=ia%^;WHn&a-kJCPMffQXwlfyJp5cAW7bYm4XulN3 zDCJ({7hb{Z&{1Jt>|j~Ac1Mxn@`CT*bDf`eacE2xUr@**p3hNU92`Dz`ihE0;(c=L zO-tCT|64|8H(V&s%4E;EIj!Wwv;s}`BFpIo0n^K7_B2nMUf(diULbeZx7;gX3=Uti zn=SRUpXYjB&tct=$34NgAv15$gXwh_@&(GP%&)g5-RN>YP$)3HINhS?qC~~Cm36<5 zb56O*-gv!qf_bN-WK-nKx(xB!==7@j9Ch~MWw%ynFFe7%p1oeSgJn`i{j=%$^W0}g zsh4j5S(Uq@W7dRO`%YFemK&J;m=&7d>CV}?^=I|*8*`l>Fs{9+y>}=3`t6Ks!{;uK z=wS|+$g*N?R5`=V_SyGtb}V3+`($P#$AePK$@xYd-7DHBd<koMk=b^_v*N7gd=9PN zM>G3d4pez@%<C*K`=79*h_Re8;YAU1S2L?tt-Z%APR^<4E$3BzsJi@e*2|kSqdZvp zC1#b27s{=gmms-_$BJXi_2L(m?f=@l*-kDJGB3AxufA|%wy_q+`s)qmQRS&SW;+G+ zJ)cqhfxTJidfO}W`G=p+Ii|Fza>D$bZj+;C<X;hM4cIwR_UA+efk~PtCuGg2v;S2p z={f0b#?mPX^Od~{Wirb}%$pB;c7|$BR&SqrH@tE-d&S2v#(?Ql4m2&T$yEP3bw#tn z@}6BQCj44a+qq(rSC(_s$|<|FX6%|abJxnx1uN&RTG1r7s`|kSJtu9GB<-$*RrQZJ zRs~7TowaJhhgAnBPU}?S+|s46_?G7X6|>Y=MRBaT#kSK+b}v`gf>*0sgVtp1oZe=z z#{0n<2cgyJ3~SG?T2rODs>5OJ;>5MZ6>Ho-t=@cUt;NYTA&TpkGp*bFZ0(_}b(@>k zH7cz=d~n@DrS%i7GCLQn-Q>9bTh{7|hV_9D*X41ppUJr4q}PUHr`DgS;+Y||W>2Hq zFD}VfRhs<2wb-=l1f%8dGHCL6O9;=_lFeq7zAY{)&DAEfDdE#b|E5i`iW@>6tiQZ! zQ_jIn`x!TzJ8qumxK1o-v#Iqa4sC(wuLLraHU&P|v?*$p(QOu&)yi(w8~YA!KD$8G zse6l6HfNa7)~m0!TxU=Xo6X{x&F;5p>uSTTvlpl&M6>*loy~3@w9UC-TlB)sS=>xH zuhmK_w`6N?>vr0lD!u*ft~EEj6fS>Mj9$I{Y1dYdi<>7o?vVSmF;II)bJGsP(_3P) zw{ux<R6D&xq`SXu_WHip!t9$iPJ6v^cJykC>K(JE$shc+)0%tdWTlM@XN$d0T(v@a z-P+x|X1-?Gcw6X>*7EJ$tFL9v-)+r#m2vKVZ_aZQXC02_JmWa?xcAl-ucn`_<~-6k z{e1L>nPI!rw0HVUlrFN|o7}CHe{$~}1L+*jeRB^;)w=JSH$iH9+rIe@QX7x$D?X&U zj%~k+x9SSF{pH*nlH2w#J|L02OlZliP5K)*t&%>l#AQ1h&uZ2=2kdqq;K_+@sQrDQ zyz_w29+j_A2gS1YO8m*>+jG!d`k<W6It7_SbAPF-tXciL>d^J7gIaG6sNFfV#d?=P z&Ppkp!>!tf&3HDN&N-Y~D0=9_VF#HbPBuqeVve}&;kKD`#B0wHpF2nV{u~LAIT~bh iG$iI|Sk2LhIY*=R9F4hiH15yQ1es$=Il_(%4Aua%JEMaD literal 0 HcmV?d00001 -- GitLab