From a85a60a49a1c627de7083dfb146e33ea004546b3 Mon Sep 17 00:00:00 2001 From: mkhatib254 <mohamed.khatib@ecl21.ec-lyon.fr> Date: Fri, 1 Dec 2023 23:43:34 +0100 Subject: [PATCH] Exercice 1, 2, 3 and the first q of 4 Quantize doesn't work --- TD2 Deep Learning.ipynb | 1434 +++++++++++++++-- hymenoptera_data/train/ants/formica.jpeg | Bin 0 -> 7858 bytes hymenoptera_data/train/ants/imageNotFound.gif | Bin 0 -> 5504 bytes 3 files changed, 1341 insertions(+), 93 deletions(-) create mode 100644 hymenoptera_data/train/ants/formica.jpeg create mode 100644 hymenoptera_data/train/ants/imageNotFound.gif diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb index 2ecfce9..48543b6 100644 --- a/TD2 Deep Learning.ipynb +++ b/TD2 Deep Learning.ipynb @@ -31,44 +31,6 @@ "Install and test PyTorch from https://pytorch.org/get-started/locally." ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "330a42f5", - "metadata": {}, - "outputs": [], - "source": [ - "%pip install torch torchvision" - ] - }, - { - "cell_type": "markdown", - "id": "0882a636", - "metadata": {}, - "source": [ - "\n", - "To test run the following code" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b1950f0a", - "metadata": {}, - "outputs": [], - "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", @@ -95,10 +57,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "6e18f2fd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CUDA is not available. Training on CPU ...\n" + ] + } + ], "source": [ "import torch\n", "\n", @@ -121,10 +91,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "462666a2", "metadata": {}, - "outputs": [], + "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", @@ -193,10 +172,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "id": "317bf070", "metadata": {}, - "outputs": [], + "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", @@ -242,10 +236,60 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "id": "4b53f229", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0 \tTraining Loss: 43.063014 \tValidation Loss: 37.339008\n", + "Validation loss decreased (inf --> 37.339008). Saving model ...\n", + "Epoch: 1 \tTraining Loss: 34.015359 \tValidation Loss: 32.207648\n", + "Validation loss decreased (37.339008 --> 32.207648). Saving model ...\n", + "Epoch: 2 \tTraining Loss: 30.306687 \tValidation Loss: 28.983380\n", + "Validation loss decreased (32.207648 --> 28.983380). Saving model ...\n", + "Epoch: 3 \tTraining Loss: 27.843216 \tValidation Loss: 27.239942\n", + "Validation loss decreased (28.983380 --> 27.239942). Saving model ...\n", + "Epoch: 4 \tTraining Loss: 26.006147 \tValidation Loss: 26.169565\n", + "Validation loss decreased (27.239942 --> 26.169565). Saving model ...\n", + "Epoch: 5 \tTraining Loss: 24.580938 \tValidation Loss: 24.793491\n", + "Validation loss decreased (26.169565 --> 24.793491). Saving model ...\n", + "Epoch: 6 \tTraining Loss: 23.410021 \tValidation Loss: 23.862509\n", + "Validation loss decreased (24.793491 --> 23.862509). Saving model ...\n", + "Epoch: 7 \tTraining Loss: 22.391496 \tValidation Loss: 23.574860\n", + "Validation loss decreased (23.862509 --> 23.574860). Saving model ...\n", + "Epoch: 8 \tTraining Loss: 21.458246 \tValidation Loss: 22.893507\n", + "Validation loss decreased (23.574860 --> 22.893507). Saving model ...\n", + "Epoch: 9 \tTraining Loss: 20.667557 \tValidation Loss: 23.230095\n", + "Epoch: 10 \tTraining Loss: 19.821100 \tValidation Loss: 22.576859\n", + "Validation loss decreased (22.893507 --> 22.576859). Saving model ...\n", + "Epoch: 11 \tTraining Loss: 19.138384 \tValidation Loss: 22.086590\n", + "Validation loss decreased (22.576859 --> 22.086590). Saving model ...\n", + "Epoch: 12 \tTraining Loss: 18.385147 \tValidation Loss: 21.860625\n", + "Validation loss decreased (22.086590 --> 21.860625). Saving model ...\n", + "Epoch: 13 \tTraining Loss: 17.742886 \tValidation Loss: 22.540151\n", + "Epoch: 14 \tTraining Loss: 17.085082 \tValidation Loss: 22.178268\n", + "Epoch: 15 \tTraining Loss: 16.456965 \tValidation Loss: 21.667622\n", + "Validation loss decreased (21.860625 --> 21.667622). Saving model ...\n", + "Epoch: 16 \tTraining Loss: 15.864612 \tValidation Loss: 22.554405\n", + "Epoch: 17 \tTraining Loss: 15.292559 \tValidation Loss: 22.479476\n", + "Epoch: 18 \tTraining Loss: 14.758371 \tValidation Loss: 21.797776\n", + "Epoch: 19 \tTraining Loss: 14.238460 \tValidation Loss: 22.749340\n", + "Epoch: 20 \tTraining Loss: 13.736323 \tValidation Loss: 23.074472\n", + "Epoch: 21 \tTraining Loss: 13.319694 \tValidation Loss: 24.253480\n", + "Epoch: 22 \tTraining Loss: 12.786041 \tValidation Loss: 23.767697\n", + "Epoch: 23 \tTraining Loss: 12.355924 \tValidation Loss: 24.340125\n", + "Epoch: 24 \tTraining Loss: 11.883646 \tValidation Loss: 24.489632\n", + "Epoch: 25 \tTraining Loss: 11.472686 \tValidation Loss: 24.542421\n", + "Epoch: 26 \tTraining Loss: 11.092597 \tValidation Loss: 25.499948\n", + "Epoch: 27 \tTraining Loss: 10.677345 \tValidation Loss: 26.615149\n", + "Epoch: 28 \tTraining Loss: 10.314805 \tValidation Loss: 27.345627\n", + "Epoch: 29 \tTraining Loss: 9.850338 \tValidation Loss: 27.497487\n" + ] + } + ], "source": [ "import torch.optim as optim\n", "\n", @@ -255,6 +299,7 @@ "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", + "valid_loss_list = []\n", "\n", "for epoch in range(n_epochs):\n", " # Keep track of training and validation loss\n", @@ -297,6 +342,7 @@ " train_loss = train_loss / len(train_loader)\n", " valid_loss = valid_loss / len(valid_loader)\n", " train_loss_list.append(train_loss)\n", + " valid_loss_list.append(valid_loss)\n", "\n", " # Print training/validation statistics\n", " print(\n", @@ -326,20 +372,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "id": "d39df818", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "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.plot(range(n_epochs), train_loss_list, label = 'Training Loss')\n", + "plt.plot(range(n_epochs), valid_loss_list, label = 'Validation Loss')\n", "plt.xlabel(\"Epoch\")\n", "plt.ylabel(\"Loss\")\n", "plt.title(\"Performance of Model 1\")\n", "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Certainly, overfitting is evident. The validation loss steadily decreases until the 11th epoch, after which it begins to rise. From epoch 11 onward, the training loss continues to decrease, while the validation loss shows an upward trend, indicating the onset of overfitting." + ] + }, { "cell_type": "markdown", "id": "11df8fd4", @@ -350,10 +415,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "id": "e93efdfc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss: 21.400496\n", + "\n", + "Test Accuracy of airplane: 70% (705/1000)\n", + "Test Accuracy of automobile: 77% (773/1000)\n", + "Test Accuracy of bird: 47% (476/1000)\n", + "Test Accuracy of cat: 47% (471/1000)\n", + "Test Accuracy of deer: 55% (557/1000)\n", + "Test Accuracy of dog: 52% (527/1000)\n", + "Test Accuracy of frog: 77% (774/1000)\n", + "Test Accuracy of horse: 64% (643/1000)\n", + "Test Accuracy of ship: 76% (762/1000)\n", + "Test Accuracy of truck: 62% (625/1000)\n", + "\n", + "Test Accuracy (Overall): 63% (6313/10000)\n" + ] + } + ], "source": [ "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n", "\n", @@ -434,6 +520,298 @@ "Compare the results obtained with this new network to those obtained previously." ] }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "my_Net(\n", + " (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1))\n", + " (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))\n", + " (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))\n", + " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (fc1): Linear(in_features=256, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=64, bias=True)\n", + " (fc3): Linear(in_features=64, out_features=10, bias=True)\n", + " (dropout): Dropout(p=0.25, inplace=False)\n", + ")\n" + ] + } + ], + "source": [ + "# Define the new Network\n", + "\n", + "\n", + "class my_Net(nn.Module):\n", + " def __init__(self):\n", + " super(my_Net, self).__init__()\n", + "\n", + " self.conv1 = nn.Conv2d(3, 16, 3)\n", + " self.conv2 = nn.Conv2d(16, 32, 3)\n", + " self.conv3 = nn.Conv2d(32, 64, 3)\n", + "\n", + " self.pool = nn.MaxPool2d(2, 2)\n", + "\n", + " self.fc1 = nn.Linear(64 * 2 * 2, 512)\n", + " self.fc2 = nn.Linear(512, 64)\n", + " self.fc3 = nn.Linear(64, 10)\n", + " \n", + " self.dropout = nn.Dropout(0.25) # Define a proportion to dropout\n", + "\n", + " def forward(self, x):\n", + " x = self.pool(F.relu(self.conv1(x)))\n", + " x = self.pool(F.relu(self.conv2(x)))\n", + " x = self.pool(F.relu(self.conv3(x)))\n", + "\n", + " x = x.view(-1, 64 * 2 * 2)\n", + " \n", + " x = F.relu(self.fc1(x))\n", + " x = self.dropout(x)\n", + "\n", + " x = F.relu(self.fc2(x))\n", + " x = self.dropout(x)\n", + "\n", + " x = self.fc3(x)\n", + "\n", + " return x\n", + "# create a complete CNN\n", + "my_model = my_Net()\n", + "print(my_model)\n", + "# move tensors to GPU if CUDA is available\n", + "if train_on_gpu:\n", + " my_model.cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0 \tTraining Loss: 45.134068 \tValidation Loss: 41.054394\n", + "Validation loss decreased (inf --> 41.054394). Saving model ...\n", + "Epoch: 1 \tTraining Loss: 38.187044 \tValidation Loss: 37.420758\n", + "Validation loss decreased (41.054394 --> 37.420758). Saving model ...\n", + "Epoch: 2 \tTraining Loss: 34.026367 \tValidation Loss: 32.033726\n", + "Validation loss decreased (37.420758 --> 32.033726). Saving model ...\n", + "Epoch: 3 \tTraining Loss: 31.616009 \tValidation Loss: 30.048698\n", + "Validation loss decreased (32.033726 --> 30.048698). Saving model ...\n", + "Epoch: 4 \tTraining Loss: 29.538672 \tValidation Loss: 27.864547\n", + "Validation loss decreased (30.048698 --> 27.864547). Saving model ...\n", + "Epoch: 5 \tTraining Loss: 27.807588 \tValidation Loss: 26.319093\n", + "Validation loss decreased (27.864547 --> 26.319093). Saving model ...\n", + "Epoch: 6 \tTraining Loss: 26.402330 \tValidation Loss: 25.810634\n", + "Validation loss decreased (26.319093 --> 25.810634). Saving model ...\n", + "Epoch: 7 \tTraining Loss: 25.084352 \tValidation Loss: 23.900651\n", + "Validation loss decreased (25.810634 --> 23.900651). Saving model ...\n", + "Epoch: 8 \tTraining Loss: 23.898927 \tValidation Loss: 23.091500\n", + "Validation loss decreased (23.900651 --> 23.091500). Saving model ...\n", + "Epoch: 9 \tTraining Loss: 22.803171 \tValidation Loss: 22.533158\n", + "Validation loss decreased (23.091500 --> 22.533158). Saving model ...\n", + "Epoch: 10 \tTraining Loss: 21.863548 \tValidation Loss: 21.222150\n", + "Validation loss decreased (22.533158 --> 21.222150). Saving model ...\n", + "Epoch: 11 \tTraining Loss: 20.979512 \tValidation Loss: 21.230974\n", + "Epoch: 12 \tTraining Loss: 20.109624 \tValidation Loss: 21.620998\n", + "Epoch: 13 \tTraining Loss: 19.313069 \tValidation Loss: 20.326536\n", + "Validation loss decreased (21.222150 --> 20.326536). Saving model ...\n", + "Epoch: 14 \tTraining Loss: 18.571943 \tValidation Loss: 20.331564\n", + "Epoch: 15 \tTraining Loss: 17.817714 \tValidation Loss: 20.720748\n", + "Epoch: 16 \tTraining Loss: 17.193074 \tValidation Loss: 18.592126\n", + "Validation loss decreased (20.326536 --> 18.592126). Saving model ...\n", + "Epoch: 17 \tTraining Loss: 16.542523 \tValidation Loss: 18.835720\n", + "Epoch: 18 \tTraining Loss: 15.961326 \tValidation Loss: 18.070037\n", + "Validation loss decreased (18.592126 --> 18.070037). Saving model ...\n", + "Epoch: 19 \tTraining Loss: 15.414899 \tValidation Loss: 18.461803\n", + "Epoch: 20 \tTraining Loss: 14.821671 \tValidation Loss: 18.260921\n", + "Epoch: 21 \tTraining Loss: 14.339739 \tValidation Loss: 17.989368\n", + "Validation loss decreased (18.070037 --> 17.989368). Saving model ...\n", + "Epoch: 22 \tTraining Loss: 13.744303 \tValidation Loss: 17.458426\n", + "Validation loss decreased (17.989368 --> 17.458426). Saving model ...\n", + "Epoch: 23 \tTraining Loss: 13.351121 \tValidation Loss: 17.790878\n", + "Epoch: 24 \tTraining Loss: 12.813877 \tValidation Loss: 17.712053\n", + "Epoch: 25 \tTraining Loss: 12.359643 \tValidation Loss: 17.466232\n", + "Epoch: 26 \tTraining Loss: 12.005489 \tValidation Loss: 17.476017\n", + "Epoch: 27 \tTraining Loss: 11.555814 \tValidation Loss: 17.978988\n", + "Epoch: 28 \tTraining Loss: 11.146048 \tValidation Loss: 18.297485\n", + "Epoch: 29 \tTraining Loss: 10.791841 \tValidation Loss: 18.457107\n" + ] + } + ], + "source": [ + "import torch.optim as optim\n", + "\n", + "criterion = nn.CrossEntropyLoss() # specify loss function\n", + "optimizer = optim.SGD(my_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", + "valid_loss_list = []\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", + " my_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 = my_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", + " my_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 = my_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", + " valid_loss_list.append(valid_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(my_model.state_dict(), \"my_model_cifar.pt\")\n", + " valid_loss_min = valid_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss: 17.242800\n", + "\n", + "Test Accuracy of airplane: 74% (746/1000)\n", + "Test Accuracy of automobile: 84% (842/1000)\n", + "Test Accuracy of bird: 64% (640/1000)\n", + "Test Accuracy of cat: 54% (541/1000)\n", + "Test Accuracy of deer: 64% (646/1000)\n", + "Test Accuracy of dog: 50% (508/1000)\n", + "Test Accuracy of frog: 77% (776/1000)\n", + "Test Accuracy of horse: 73% (738/1000)\n", + "Test Accuracy of ship: 84% (842/1000)\n", + "Test Accuracy of truck: 73% (734/1000)\n", + "\n", + "Test Accuracy (Overall): 70% (7013/10000)\n" + ] + } + ], + "source": [ + "my_model.load_state_dict(torch.load(\"./my_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", + "my_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 = my_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", + "metadata": {}, + "source": [ + "We observe an improvement in the overall accuracy of the new model compared to the old one, and this superiority extends to every individual class. The increased performance can be attributed to the inclusion of more convolutional layers and a greater number of channels in each layer. Additionally, it's noteworthy that overfitting did not manifest during the 30 epochs. This absence of overfitting can be attributed to the higher number of hyperparameters, which facilitated a more robust learning process over the 30 epochs." + ] + }, { "cell_type": "markdown", "id": "bc381cf4", @@ -451,10 +829,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "id": "ef623c26", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: fp32 \t Size (KB): 251.278\n" + ] + }, + { + "data": { + "text/plain": [ + "251278" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import os\n", "\n", @@ -480,10 +876,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "c4c65d4b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Didn't find engine for operation quantized::linear_prepack NoQEngine", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/k.mohamed/Documents/Ecole centrale de Lyon/S9/Deep Learning/mod_4_6-td2/TD2 Deep Learning.ipynb Cell 26\u001b[0m line \u001b[0;36m4\n\u001b[1;32m <a href='vscode-notebook-cell:/Users/k.mohamed/Documents/Ecole%20centrale%20de%20Lyon/S9/Deep%20Learning/mod_4_6-td2/TD2%20Deep%20Learning.ipynb#X34sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mtorch\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mquantization\u001b[39;00m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/k.mohamed/Documents/Ecole%20centrale%20de%20Lyon/S9/Deep%20Learning/mod_4_6-td2/TD2%20Deep%20Learning.ipynb#X34sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m quantized_model \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39;49mquantization\u001b[39m.\u001b[39;49mquantize_dynamic(model, dtype\u001b[39m=\u001b[39;49mtorch\u001b[39m.\u001b[39;49mqint8)\n\u001b[1;32m <a href='vscode-notebook-cell:/Users/k.mohamed/Documents/Ecole%20centrale%20de%20Lyon/S9/Deep%20Learning/mod_4_6-td2/TD2%20Deep%20Learning.ipynb#X34sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m print_size_of_model(quantized_model, \u001b[39m\"\u001b[39m\u001b[39mint8\u001b[39m\u001b[39m\"\u001b[39m)\n", + "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/ao/quantization/quantize.py:465\u001b[0m, in \u001b[0;36mquantize_dynamic\u001b[0;34m(model, qconfig_spec, dtype, mapping, inplace)\u001b[0m\n\u001b[1;32m 463\u001b[0m model\u001b[39m.\u001b[39meval()\n\u001b[1;32m 464\u001b[0m propagate_qconfig_(model, qconfig_spec)\n\u001b[0;32m--> 465\u001b[0m convert(model, mapping, inplace\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n\u001b[1;32m 466\u001b[0m \u001b[39mreturn\u001b[39;00m model\n", + "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/ao/quantization/quantize.py:550\u001b[0m, in \u001b[0;36mconvert\u001b[0;34m(module, mapping, inplace, remove_qconfig, is_reference, convert_custom_config_dict)\u001b[0m\n\u001b[1;32m 548\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m inplace:\n\u001b[1;32m 549\u001b[0m module \u001b[39m=\u001b[39m copy\u001b[39m.\u001b[39mdeepcopy(module)\n\u001b[0;32m--> 550\u001b[0m _convert(\n\u001b[1;32m 551\u001b[0m module, mapping, inplace\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m, is_reference\u001b[39m=\u001b[39;49mis_reference,\n\u001b[1;32m 552\u001b[0m convert_custom_config_dict\u001b[39m=\u001b[39;49mconvert_custom_config_dict)\n\u001b[1;32m 553\u001b[0m \u001b[39mif\u001b[39;00m remove_qconfig:\n\u001b[1;32m 554\u001b[0m _remove_qconfig(module)\n", + "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/ao/quantization/quantize.py:590\u001b[0m, in \u001b[0;36m_convert\u001b[0;34m(module, mapping, inplace, is_reference, convert_custom_config_dict)\u001b[0m\n\u001b[1;32m 586\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39misinstance\u001b[39m(mod, _FusedModule) \u001b[39mand\u001b[39;00m \\\n\u001b[1;32m 587\u001b[0m type_before_parametrizations(mod) \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m custom_module_class_mapping:\n\u001b[1;32m 588\u001b[0m _convert(mod, mapping, \u001b[39mTrue\u001b[39;00m, \u001b[39m# inplace\u001b[39;00m\n\u001b[1;32m 589\u001b[0m is_reference, convert_custom_config_dict)\n\u001b[0;32m--> 590\u001b[0m reassign[name] \u001b[39m=\u001b[39m swap_module(mod, mapping, custom_module_class_mapping)\n\u001b[1;32m 592\u001b[0m \u001b[39mfor\u001b[39;00m key, value \u001b[39min\u001b[39;00m reassign\u001b[39m.\u001b[39mitems():\n\u001b[1;32m 593\u001b[0m module\u001b[39m.\u001b[39m_modules[key] \u001b[39m=\u001b[39m value\n", + "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/ao/quantization/quantize.py:623\u001b[0m, in \u001b[0;36mswap_module\u001b[0;34m(mod, mapping, custom_module_class_mapping)\u001b[0m\n\u001b[1;32m 621\u001b[0m new_mod \u001b[39m=\u001b[39m qmod\u001b[39m.\u001b[39mfrom_float(mod, weight_qparams)\n\u001b[1;32m 622\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 623\u001b[0m new_mod \u001b[39m=\u001b[39m qmod\u001b[39m.\u001b[39;49mfrom_float(mod)\n\u001b[1;32m 624\u001b[0m swapped \u001b[39m=\u001b[39m \u001b[39mTrue\u001b[39;00m\n\u001b[1;32m 626\u001b[0m \u001b[39mif\u001b[39;00m swapped:\n\u001b[1;32m 627\u001b[0m \u001b[39m# Preserve module's pre forward hooks. They'll be called on quantized input\u001b[39;00m\n", + "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/ao/nn/quantized/dynamic/modules/linear.py:116\u001b[0m, in \u001b[0;36mLinear.from_float\u001b[0;34m(cls, mod)\u001b[0m\n\u001b[1;32m 114\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 115\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\u001b[39m'\u001b[39m\u001b[39mUnsupported dtype specified for dynamic quantized Linear!\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m--> 116\u001b[0m qlinear \u001b[39m=\u001b[39m \u001b[39mcls\u001b[39;49m(mod\u001b[39m.\u001b[39;49min_features, mod\u001b[39m.\u001b[39;49mout_features, dtype\u001b[39m=\u001b[39;49mdtype)\n\u001b[1;32m 117\u001b[0m qlinear\u001b[39m.\u001b[39mset_weight_bias(qweight, mod\u001b[39m.\u001b[39mbias)\n\u001b[1;32m 118\u001b[0m \u001b[39mreturn\u001b[39;00m qlinear\n", + "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/ao/nn/quantized/dynamic/modules/linear.py:40\u001b[0m, in \u001b[0;36mLinear.__init__\u001b[0;34m(self, in_features, out_features, bias_, dtype)\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__init__\u001b[39m(\u001b[39mself\u001b[39m, in_features, out_features, bias_\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m, dtype\u001b[39m=\u001b[39mtorch\u001b[39m.\u001b[39mqint8):\n\u001b[0;32m---> 40\u001b[0m \u001b[39msuper\u001b[39;49m()\u001b[39m.\u001b[39;49m\u001b[39m__init__\u001b[39;49m(in_features, out_features, bias_, dtype\u001b[39m=\u001b[39;49mdtype)\n\u001b[1;32m 41\u001b[0m \u001b[39m# We don't muck around with buffers or attributes or anything here\u001b[39;00m\n\u001b[1;32m 42\u001b[0m \u001b[39m# to keep the module simple. *everything* is simply a Python attribute.\u001b[39;00m\n\u001b[1;32m 43\u001b[0m \u001b[39m# Serialization logic is explicitly handled in the below serialization and\u001b[39;00m\n\u001b[1;32m 44\u001b[0m \u001b[39m# deserialization modules\u001b[39;00m\n\u001b[1;32m 45\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mversion \u001b[39m=\u001b[39m \u001b[39m4\u001b[39m\n", + "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/ao/nn/quantized/modules/linear.py:151\u001b[0m, in \u001b[0;36mLinear.__init__\u001b[0;34m(self, in_features, out_features, bias_, dtype)\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 149\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\u001b[39m'\u001b[39m\u001b[39mUnsupported dtype specified for quantized Linear!\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m--> 151\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_packed_params \u001b[39m=\u001b[39m LinearPackedParams(dtype)\n\u001b[1;32m 152\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_packed_params\u001b[39m.\u001b[39mset_weight_bias(qweight, bias)\n\u001b[1;32m 153\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mscale \u001b[39m=\u001b[39m \u001b[39m1.0\u001b[39m\n", + "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/ao/nn/quantized/modules/linear.py:27\u001b[0m, in \u001b[0;36mLinearPackedParams.__init__\u001b[0;34m(self, dtype)\u001b[0m\n\u001b[1;32m 25\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdtype \u001b[39m==\u001b[39m torch\u001b[39m.\u001b[39mfloat16:\n\u001b[1;32m 26\u001b[0m wq \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mzeros([\u001b[39m1\u001b[39m, \u001b[39m1\u001b[39m], dtype\u001b[39m=\u001b[39mtorch\u001b[39m.\u001b[39mfloat)\n\u001b[0;32m---> 27\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mset_weight_bias(wq, \u001b[39mNone\u001b[39;49;00m)\n", + "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/ao/nn/quantized/modules/linear.py:32\u001b[0m, in \u001b[0;36mLinearPackedParams.set_weight_bias\u001b[0;34m(self, weight, bias)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[39m@torch\u001b[39m\u001b[39m.\u001b[39mjit\u001b[39m.\u001b[39mexport\n\u001b[1;32m 30\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mset_weight_bias\u001b[39m(\u001b[39mself\u001b[39m, weight: torch\u001b[39m.\u001b[39mTensor, bias: Optional[torch\u001b[39m.\u001b[39mTensor]) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 31\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdtype \u001b[39m==\u001b[39m torch\u001b[39m.\u001b[39mqint8:\n\u001b[0;32m---> 32\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_packed_params \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39;49mops\u001b[39m.\u001b[39;49mquantized\u001b[39m.\u001b[39;49mlinear_prepack(weight, bias)\n\u001b[1;32m 33\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mdtype \u001b[39m==\u001b[39m torch\u001b[39m.\u001b[39mfloat16:\n\u001b[1;32m 34\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_packed_params \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mops\u001b[39m.\u001b[39mquantized\u001b[39m.\u001b[39mlinear_prepack_fp16(weight, bias)\n", + "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/_ops.py:692\u001b[0m, in \u001b[0;36mOpOverloadPacket.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 687\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__call__\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m 688\u001b[0m \u001b[39m# overloading __call__ to ensure torch.ops.foo.bar()\u001b[39;00m\n\u001b[1;32m 689\u001b[0m \u001b[39m# is still callable from JIT\u001b[39;00m\n\u001b[1;32m 690\u001b[0m \u001b[39m# We save the function ptr as the `op` attribute on\u001b[39;00m\n\u001b[1;32m 691\u001b[0m \u001b[39m# OpOverloadPacket to access it here.\u001b[39;00m\n\u001b[0;32m--> 692\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_op(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs \u001b[39mor\u001b[39;49;00m {})\n", + "\u001b[0;31mRuntimeError\u001b[0m: Didn't find engine for operation quantized::linear_prepack NoQEngine" + ] + } + ], "source": [ "import torch.quantization\n", "\n", @@ -492,6 +910,13 @@ "print_size_of_model(quantized_model, \"int8\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## I couldn't fix the error. In all the code below, i didn't execute anything for the quantized models but I did write the code when it was necessary. I will use someone else's computer to try to execute it and send the code by mail." + ] + }, { "cell_type": "markdown", "id": "7b108e17", @@ -508,6 +933,94 @@ "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": "markdown", + "metadata": {}, + "source": [ + "In the code below, we will try the aware quantization" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "my_model.qconfig = torch.ao.quantization.get_default_qat_qconfig('fbgemm')\n", + "my_model = torch.ao.quantization.prepare_qat(my_model)\n", + "epochquantized_model=torch.quantization.convert(my_model.eval(), inplace=False)\n", + "\n", + "import torch.optim as optim\n", + "\n", + "criterion = nn.CrossEntropyLoss() # specify loss function\n", + "optimizer = optim.SGD(my_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", + "valid_loss_list = []\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", + " my_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 = my_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", + " my_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 = my_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", + " valid_loss_list.append(valid_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(my_model.state_dict(), \"my_model_cifar.pt\")\n", + " valid_loss_min = valid_loss" + ] + }, { "cell_type": "markdown", "id": "201470f9", @@ -521,53 +1034,65 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "id": "b4d13080", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/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" + ] + } + ], "source": [ "import json\n", "from PIL import Image\n", - "\n", + "from torchvision import models\n", + "from torchvision import transforms\n", + "import matplotlib.pyplot as plt\n", "# Choose an image to pass through the model\n", - "test_image = \"dog.png\"\n", + "\n", "\n", "# Configure matplotlib for pretty inline plots\n", "#%matplotlib inline\n", "#%config InlineBackend.figure_format = 'retina'\n", + "def test_data(test_image, model = models.resnet50(pretrained = True)):\n", + " # Prepare the labels\n", + " with open(\"imagenet-simple-labels.json\") as f:\n", + " labels = json.load(f)\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", + " # 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", + " 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", + " # 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", + " # Download the model if it's not there already. It will take a bit on the first run, after that it's fast\n", + " \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()]))" + " # Get the 1000-dimensional model output\n", + " out = model(image)\n", + " # Find the predicted class\n", + " print(\"Predicted class is: {}\".format(labels[out.argmax()]))\n", + " return labels[out.argmax()]" ] }, { @@ -586,6 +1111,233 @@ " \n" ] }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: Golden Retriever\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dog = test_data('dog.png')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model did recognize that the image is of a golden retriever dog." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: minibus\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Adding other images \n", + "minibus = test_data('minibus.jpg')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: broom\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "broom = test_data('broom.jpg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We notice that in each picture, the model did well predicting on which category it belongs" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: fp32 \t Size (KB): 251.278\n" + ] + }, + { + "data": { + "text/plain": [ + "251278" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Size of the model\n", + "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": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Quantizing the model\n", + "\n", + "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": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'quantized_model' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/k.mohamed/Documents/Ecole centrale de Lyon/S9/Deep Learning/mod_4_6-td2/TD2 Deep Learning.ipynb Cell 40\u001b[0m line \u001b[0;36m3\n\u001b[1;32m <a href='vscode-notebook-cell:/Users/k.mohamed/Documents/Ecole%20centrale%20de%20Lyon/S9/Deep%20Learning/mod_4_6-td2/TD2%20Deep%20Learning.ipynb#X63sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m# testing the quantized model \u001b[39;00m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/k.mohamed/Documents/Ecole%20centrale%20de%20Lyon/S9/Deep%20Learning/mod_4_6-td2/TD2%20Deep%20Learning.ipynb#X63sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m outputs \u001b[39m=\u001b[39m [test_data(\u001b[39m'\u001b[39m\u001b[39mdog.png\u001b[39m\u001b[39m'\u001b[39m, model \u001b[39m=\u001b[39m quantized_model), test_data(\u001b[39m'\u001b[39m\u001b[39mbroom.jpg\u001b[39m\u001b[39m'\u001b[39m, model \u001b[39m=\u001b[39m quantized_model), test_data(\u001b[39m'\u001b[39m\u001b[39mminibus.jpg\u001b[39m\u001b[39m'\u001b[39m, model \u001b[39m=\u001b[39m quantized_model)]\n\u001b[1;32m <a href='vscode-notebook-cell:/Users/k.mohamed/Documents/Ecole%20centrale%20de%20Lyon/S9/Deep%20Learning/mod_4_6-td2/TD2%20Deep%20Learning.ipynb#X63sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39mprint\u001b[39m(outputs)\n", + "\u001b[0;31mNameError\u001b[0m: name 'quantized_model' is not defined" + ] + } + ], + "source": [ + "# testing the quantized model \n", + "\n", + "outputs = [test_data('dog.png', model = quantized_model), test_data('broom.jpg', model = quantized_model), test_data('minibus.jpg', model = quantized_model)]\n", + "print(outputs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We notice that the quantized model has got the 3 predictions right" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# We will now use VGG16\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: Golden Retriever\n", + "Predicted class is: broom\n", + "Predicted class is: minibus\n", + "['Golden Retriever', 'broom', 'minibus']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model = models.vgg16(pretrained = True)\n", + "outputs = [test_data('dog.png', model = model), test_data('broom.jpg', model = model), test_data('minibus.jpg', model = model)]\n", + "print(outputs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We notice that the pretrained model VGG16 has also predicted the classes of the images very well." + ] + }, { "cell_type": "markdown", "id": "5d57da4b", @@ -604,10 +1356,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "id": "be2d31f5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import os\n", "\n", @@ -696,10 +1459,481 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "572d824c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/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 /Users/k.mohamed/.cache/torch/hub/checkpoints/resnet18-f37072fd.pth\n", + "100.0%\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/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" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.6120 Acc: 0.6639\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.2199 Acc: 0.9346\n", + "\n", + "Epoch 2/10\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.4207 Acc: 0.8074\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.1664 Acc: 0.9542\n", + "\n", + "Epoch 3/10\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.4194 Acc: 0.7828\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.1600 Acc: 0.9477\n", + "\n", + "Epoch 4/10\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.4631 Acc: 0.8238\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.1602 Acc: 0.9542\n", + "\n", + "Epoch 5/10\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.4219 Acc: 0.8197\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.1849 Acc: 0.9412\n", + "\n", + "Epoch 6/10\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.4087 Acc: 0.8320\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.1803 Acc: 0.9346\n", + "\n", + "Epoch 7/10\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.4611 Acc: 0.7746\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.1584 Acc: 0.9542\n", + "\n", + "Epoch 8/10\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.3381 Acc: 0.8361\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.1646 Acc: 0.9477\n", + "\n", + "Epoch 9/10\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.3162 Acc: 0.8648\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.1588 Acc: 0.9477\n", + "\n", + "Epoch 10/10\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Loss: 0.3295 Acc: 0.8443\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n", + "/Users/k.mohamed/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:34: NotOpenSSLWarning: urllib3 v2.0 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "val Loss: 0.1693 Acc: 0.9477\n", + "\n", + "Training complete in 8m 27s\n", + "Best val Acc: 0.954248\n" + ] + } + ], "source": [ "import copy\n", "import os\n", @@ -866,7 +2100,7 @@ "\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", + "num_ftrs = my_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", @@ -881,6 +2115,20 @@ ")\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Analyzing the results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We notice that by changing the number of epochs from 8 epochs, the results do not change. We can conclude that 95% accuracy obtained at 8 epochs is the highest accuracy that we can obtain. The increase of the number of epochs is thus unnecessary. " + ] + }, { "cell_type": "markdown", "id": "bbd48800", @@ -940,7 +2188,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.9.6" }, "vscode": { "interpreter": { 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