From dbeae6b7572c5ac20a6f20210f75a671f4c10ce0 Mon Sep 17 00:00:00 2001 From: Maha Kosksi <78474190+Mahakosksi@users.noreply.github.com> Date: Mon, 27 Nov 2023 21:26:48 +0100 Subject: [PATCH] sauvgarde des fichiers --- TD2 Deep Learning.ipynb | 2591 ++++++++++++++++- hymenoptera_data/train/ants/formica.jpeg | Bin 0 -> 7858 bytes hymenoptera_data/train/ants/imageNotFound.gif | Bin 0 -> 5504 bytes tench.png | Bin 0 -> 152194 bytes 4 files changed, 2439 insertions(+), 152 deletions(-) create mode 100644 hymenoptera_data/train/ants/formica.jpeg create mode 100644 hymenoptera_data/train/ants/imageNotFound.gif create mode 100644 tench.png diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb index 2ecfce9..e54b6ce 100644 --- a/TD2 Deep Learning.ipynb +++ b/TD2 Deep Learning.ipynb @@ -52,10 +52,72 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "b1950f0a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[-0.9423, 0.9708, -1.1173, 0.7517, 0.1651, 0.1440, 0.3395, -1.5821,\n", + " -1.2083, -0.1834],\n", + " [-0.1060, -1.2338, 0.3896, -0.6367, -2.6377, 0.0821, -0.6745, -0.2476,\n", + " -1.6165, -0.2387],\n", + " [ 0.6264, -1.4330, -0.4977, -0.4685, -0.5423, -0.3698, -0.0252, 1.0910,\n", + " 1.0854, 0.2728],\n", + " [-0.2262, -0.9628, 0.2071, -0.3877, 0.7292, 0.0707, 0.6892, -0.2527,\n", + " 0.6129, -2.5222],\n", + " [-0.7208, -0.1664, 0.1882, 0.3032, -0.3780, -0.2051, 0.6495, 0.1030,\n", + " -0.3246, 2.1220],\n", + " [-2.2701, 0.0399, 0.7866, 1.0246, -0.9594, 1.1121, 0.2151, 0.3468,\n", + " -1.3409, -0.5332],\n", + " [ 0.9423, -1.1214, 2.2758, -0.6316, -1.4389, 0.6033, -0.6149, -0.4695,\n", + " -0.5999, -0.0356],\n", + " [ 0.3975, -1.3820, -0.2830, -0.1399, 0.3447, -1.4293, -0.1438, -0.0358,\n", + " 0.8166, -1.3432],\n", + " [-0.4973, -0.7376, 0.1388, -0.5577, -0.1812, 0.7578, -1.0928, -0.1980,\n", + " 0.4528, 0.1032],\n", + " [ 0.3483, 0.1561, -0.6872, 1.2322, -0.9672, 2.4793, 0.1647, 1.8180,\n", + " 1.7788, 0.2212],\n", + " [ 1.0694, 0.1998, -0.2160, 0.1633, -1.1462, 0.9828, 2.9743, 0.2247,\n", + " 0.8128, 0.5803],\n", + " [-1.9120, 1.5484, 0.8139, -0.1669, -0.6376, 0.1648, -0.1058, -1.0445,\n", + " -1.0512, 0.7069],\n", + " [-0.9353, 1.9754, 0.0052, -0.3826, 2.2824, -0.9010, 1.4606, -1.7802,\n", + " 1.6978, -0.4301],\n", + " [ 0.7528, -0.9648, 0.8284, -1.0311, 0.3247, -2.3639, 1.5370, 1.5331,\n", + " -0.7809, 0.0950]])\n", + "AlexNet(\n", + " (features): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))\n", + " (1): ReLU(inplace=True)\n", + " (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", + " (4): ReLU(inplace=True)\n", + " (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (7): ReLU(inplace=True)\n", + " (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (9): ReLU(inplace=True)\n", + " (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))\n", + " (classifier): Sequential(\n", + " (0): Dropout(p=0.5, inplace=False)\n", + " (1): Linear(in_features=9216, out_features=4096, bias=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Dropout(p=0.5, inplace=False)\n", + " (4): Linear(in_features=4096, out_features=4096, bias=True)\n", + " (5): ReLU(inplace=True)\n", + " (6): Linear(in_features=4096, out_features=1000, bias=True)\n", + " )\n", + ")\n" + ] + } + ], "source": [ "import torch\n", "\n", @@ -95,10 +157,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "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 +191,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "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 +272,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "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 +336,59 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "4b53f229", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0 \tTraining Loss: 44.726907 \tValidation Loss: 39.071647\n", + "Validation loss decreased (inf --> 39.071647). Saving model ...\n", + "Epoch: 1 \tTraining Loss: 35.054405 \tValidation Loss: 32.110584\n", + "Validation loss decreased (39.071647 --> 32.110584). Saving model ...\n", + "Epoch: 2 \tTraining Loss: 30.749012 \tValidation Loss: 29.360720\n", + "Validation loss decreased (32.110584 --> 29.360720). Saving model ...\n", + "Epoch: 3 \tTraining Loss: 28.391951 \tValidation Loss: 27.967922\n", + "Validation loss decreased (29.360720 --> 27.967922). Saving model ...\n", + "Epoch: 4 \tTraining Loss: 26.568487 \tValidation Loss: 26.119769\n", + "Validation loss decreased (27.967922 --> 26.119769). Saving model ...\n", + "Epoch: 5 \tTraining Loss: 25.169793 \tValidation Loss: 25.031413\n", + "Validation loss decreased (26.119769 --> 25.031413). Saving model ...\n", + "Epoch: 6 \tTraining Loss: 23.912804 \tValidation Loss: 24.453721\n", + "Validation loss decreased (25.031413 --> 24.453721). Saving model ...\n", + "Epoch: 7 \tTraining Loss: 22.897765 \tValidation Loss: 24.236649\n", + "Validation loss decreased (24.453721 --> 24.236649). Saving model ...\n", + "Epoch: 8 \tTraining Loss: 21.957622 \tValidation Loss: 23.964489\n", + "Validation loss decreased (24.236649 --> 23.964489). Saving model ...\n", + "Epoch: 9 \tTraining Loss: 21.138539 \tValidation Loss: 22.705581\n", + "Validation loss decreased (23.964489 --> 22.705581). Saving model ...\n", + "Epoch: 10 \tTraining Loss: 20.329734 \tValidation Loss: 22.290488\n", + "Validation loss decreased (22.705581 --> 22.290488). Saving model ...\n", + "Epoch: 11 \tTraining Loss: 19.645637 \tValidation Loss: 23.373632\n", + "Epoch: 12 \tTraining Loss: 18.901699 \tValidation Loss: 21.661441\n", + "Validation loss decreased (22.290488 --> 21.661441). Saving model ...\n", + "Epoch: 13 \tTraining Loss: 18.234404 \tValidation Loss: 21.704771\n", + "Epoch: 14 \tTraining Loss: 17.646186 \tValidation Loss: 22.160250\n", + "Epoch: 15 \tTraining Loss: 17.069965 \tValidation Loss: 22.348481\n", + "Epoch: 16 \tTraining Loss: 16.463965 \tValidation Loss: 21.731248\n", + "Epoch: 17 \tTraining Loss: 15.982605 \tValidation Loss: 21.859619\n", + "Epoch: 18 \tTraining Loss: 15.390740 \tValidation Loss: 22.549561\n", + "Epoch: 19 \tTraining Loss: 14.906437 \tValidation Loss: 22.900866\n", + "Epoch: 20 \tTraining Loss: 14.399535 \tValidation Loss: 22.831292\n", + "Epoch: 21 \tTraining Loss: 13.890568 \tValidation Loss: 23.340409\n", + "Epoch: 22 \tTraining Loss: 13.447925 \tValidation Loss: 23.446479\n", + "Epoch: 23 \tTraining Loss: 12.976771 \tValidation Loss: 23.933286\n", + "Epoch: 24 \tTraining Loss: 12.543276 \tValidation Loss: 24.310838\n", + "Epoch: 25 \tTraining Loss: 12.146771 \tValidation Loss: 25.697770\n", + "Epoch: 26 \tTraining Loss: 11.725751 \tValidation Loss: 25.141558\n", + "Epoch: 27 \tTraining Loss: 11.372244 \tValidation Loss: 26.506025\n", + "Epoch: 28 \tTraining Loss: 10.863760 \tValidation Loss: 26.072285\n", + "Epoch: 29 \tTraining Loss: 10.430784 \tValidation Loss: 26.664543\n" + ] + } + ], "source": [ "import torch.optim as optim\n", "\n", @@ -326,10 +469,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "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", @@ -350,10 +504,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "e93efdfc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss: 21.163006\n", + "\n", + "Test Accuracy of airplane: 66% (661/1000)\n", + "Test Accuracy of automobile: 75% (754/1000)\n", + "Test Accuracy of bird: 45% (457/1000)\n", + "Test Accuracy of cat: 41% (414/1000)\n", + "Test Accuracy of deer: 55% (556/1000)\n", + "Test Accuracy of dog: 56% (564/1000)\n", + "Test Accuracy of frog: 67% (678/1000)\n", + "Test Accuracy of horse: 72% (726/1000)\n", + "Test Accuracy of ship: 74% (746/1000)\n", + "Test Accuracy of truck: 74% (741/1000)\n", + "\n", + "Test Accuracy (Overall): 62% (6297/10000)\n" + ] + } + ], "source": [ "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n", "\n", @@ -434,6 +609,310 @@ "Compare the results obtained with this new network to those obtained previously." ] }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "second_Net(\n", + " (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (fc1): Linear(in_features=1024, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=64, bias=True)\n", + " (fc3): Linear(in_features=64, out_features=10, bias=True)\n", + " (dropout): Dropout(p=0.2, inplace=False)\n", + ")\n" + ] + } + ], + "source": [ + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "\n", + "# define the CNN architecture\n", + "\n", + "\n", + "class second_Net(nn.Module):\n", + " def __init__(self):\n", + " super(second_Net, self).__init__()\n", + " self.conv1 = nn.Conv2d(3, 16, 3, padding=1)\n", + " self.pool = nn.MaxPool2d(2, 2)\n", + " self.conv2 = nn.Conv2d(16, 32, 3, padding=1)\n", + " self.conv3 = nn.Conv2d(32, 64, 3, padding=1)\n", + " #fc1, fc2 and fc3 are the fully connected layers\n", + " self.fc1 = nn.Linear(64 * 4 * 4, 512)\n", + " self.fc2 = nn.Linear(512, 64)\n", + " self.fc3 = nn.Linear(64, 10)\n", + " self.dropout = nn.Dropout(0.2)\n", + "\n", + " def forward(self, x):\n", + " x = self.pool(F.relu(self.conv1(x)))\n", + " x = self.pool(F.relu(self.conv2(x)))\n", + " x = self.pool(F.relu(self.conv3(x)))\n", + " x = x.view(-1, 64 * 4 * 4)#to reshape the outpout tensor x into a shape that can be fed into a subsequent fully connected layer\n", + " x = self.dropout(F.relu(self.fc1(x)))\n", + " x = self.dropout(F.relu(self.fc2(x)))\n", + " x = self.fc3(x)#we apply only the fully connected layer\n", + " return x\n", + "\n", + "\n", + "# create a complete CNN\n", + "model = second_Net()\n", + "print(model)\n", + "# move tensors to GPU if CUDA is available\n", + "if train_on_gpu:\n", + " model.cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0 \tTraining Loss: 45.290243 \tValidation Loss: 41.165060\n", + "Validation loss decreased (inf --> 41.165060). Saving model ...\n", + "Epoch: 1 \tTraining Loss: 37.510178 \tValidation Loss: 32.934895\n", + "Validation loss decreased (41.165060 --> 32.934895). Saving model ...\n", + "Epoch: 2 \tTraining Loss: 32.064958 \tValidation Loss: 29.373906\n", + "Validation loss decreased (32.934895 --> 29.373906). Saving model ...\n", + "Epoch: 3 \tTraining Loss: 29.183704 \tValidation Loss: 27.515824\n", + "Validation loss decreased (29.373906 --> 27.515824). Saving model ...\n", + "Epoch: 4 \tTraining Loss: 26.968789 \tValidation Loss: 25.998306\n", + "Validation loss decreased (27.515824 --> 25.998306). Saving model ...\n", + "Epoch: 5 \tTraining Loss: 25.027486 \tValidation Loss: 23.763529\n", + "Validation loss decreased (25.998306 --> 23.763529). Saving model ...\n", + "Epoch: 6 \tTraining Loss: 23.155620 \tValidation Loss: 22.014464\n", + "Validation loss decreased (23.763529 --> 22.014464). Saving model ...\n", + "Epoch: 7 \tTraining Loss: 21.475198 \tValidation Loss: 20.990993\n", + "Validation loss decreased (22.014464 --> 20.990993). Saving model ...\n", + "Epoch: 8 \tTraining Loss: 19.979418 \tValidation Loss: 19.800872\n", + "Validation loss decreased (20.990993 --> 19.800872). Saving model ...\n", + "Epoch: 9 \tTraining Loss: 18.691629 \tValidation Loss: 19.004915\n", + "Validation loss decreased (19.800872 --> 19.004915). Saving model ...\n", + "Epoch: 10 \tTraining Loss: 17.424382 \tValidation Loss: 18.288136\n", + "Validation loss decreased (19.004915 --> 18.288136). Saving model ...\n", + "Epoch: 11 \tTraining Loss: 16.307390 \tValidation Loss: 18.244697\n", + "Validation loss decreased (18.288136 --> 18.244697). Saving model ...\n", + "Epoch: 12 \tTraining Loss: 15.167211 \tValidation Loss: 18.015783\n", + "Validation loss decreased (18.244697 --> 18.015783). Saving model ...\n", + "Epoch: 13 \tTraining Loss: 14.113395 \tValidation Loss: 16.667591\n", + "Validation loss decreased (18.015783 --> 16.667591). Saving model ...\n", + "Epoch: 14 \tTraining Loss: 13.236849 \tValidation Loss: 16.125387\n", + "Validation loss decreased (16.667591 --> 16.125387). Saving model ...\n", + "Epoch: 15 \tTraining Loss: 12.238603 \tValidation Loss: 17.085894\n", + "Epoch: 16 \tTraining Loss: 11.353403 \tValidation Loss: 16.390383\n", + "Epoch: 17 \tTraining Loss: 10.481450 \tValidation Loss: 16.541884\n", + "Epoch: 18 \tTraining Loss: 9.706518 \tValidation Loss: 15.796362\n", + "Validation loss decreased (16.125387 --> 15.796362). Saving model ...\n", + "Epoch: 19 \tTraining Loss: 8.832767 \tValidation Loss: 16.756571\n", + "Epoch: 20 \tTraining Loss: 8.153805 \tValidation Loss: 16.796708\n", + "Epoch: 21 \tTraining Loss: 7.322154 \tValidation Loss: 17.710617\n", + "Epoch: 22 \tTraining Loss: 6.726637 \tValidation Loss: 18.109654\n", + "Epoch: 23 \tTraining Loss: 6.115624 \tValidation Loss: 18.905652\n", + "Epoch: 24 \tTraining Loss: 5.584887 \tValidation Loss: 19.411039\n", + "Epoch: 25 \tTraining Loss: 5.083100 \tValidation Loss: 19.586951\n", + "Epoch: 26 \tTraining Loss: 4.624071 \tValidation Loss: 19.442007\n", + "Epoch: 27 \tTraining Loss: 4.313399 \tValidation Loss: 21.781538\n", + "Epoch: 28 \tTraining Loss: 4.065315 \tValidation Loss: 21.534176\n", + "Epoch: 29 \tTraining Loss: 3.495624 \tValidation Loss: 21.116070\n" + ] + } + ], + "source": [ + "import torch.optim as optim\n", + "\n", + "criterion = nn.CrossEntropyLoss() # specify loss function\n", + "optimizer = optim.SGD(model.parameters(), lr=0.01) # specify optimizer\n", + "\n", + "n_epochs = 30 # number of epochs to train the model\n", + "train_loss_list = [] # list to store loss to visualize\n", + "valid_loss_min = np.Inf # track change in validation loss\n", + "\n", + "for epoch in range(n_epochs):\n", + " # Keep track of training and validation loss\n", + " train_loss = 0.0\n", + " valid_loss = 0.0\n", + "\n", + " # Train the model\n", + " model.train()\n", + " for data, target in train_loader:\n", + " # Move tensors to GPU if CUDA is available\n", + " if train_on_gpu:\n", + " data, target = data.cuda(), target.cuda()\n", + " # Clear the gradients of all optimized variables\n", + " optimizer.zero_grad()\n", + " # Forward pass: compute predicted outputs by passing inputs to the model\n", + " output = model(data)\n", + " # Calculate the batch loss\n", + " loss = criterion(output, target)\n", + " # Backward pass: compute gradient of the loss with respect to model parameters\n", + " loss.backward()\n", + " # Perform a single optimization step (parameter update)\n", + " optimizer.step()\n", + " # Update training loss\n", + " train_loss += loss.item() * data.size(0)\n", + "\n", + " # Validate the model\n", + " model.eval()\n", + " for data, target in valid_loader:\n", + " # Move tensors to GPU if CUDA is available\n", + " if train_on_gpu:\n", + " data, target = data.cuda(), target.cuda()\n", + " # Forward pass: compute predicted outputs by passing inputs to the model\n", + " output = model(data)\n", + " # Calculate the batch loss\n", + " loss = criterion(output, target)\n", + " # Update average validation loss\n", + " valid_loss += loss.item() * data.size(0)\n", + "\n", + " # Calculate average losses\n", + " train_loss = train_loss / len(train_loader)\n", + " valid_loss = valid_loss / len(valid_loader)\n", + " train_loss_list.append(train_loss)\n", + "\n", + " # Print training/validation statistics\n", + " print(\n", + " \"Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}\".format(\n", + " epoch, train_loss, valid_loss\n", + " )\n", + " )\n", + "\n", + " # Save model if validation loss has decreased\n", + " if valid_loss <= valid_loss_min:\n", + " print(\n", + " \"Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...\".format(\n", + " valid_loss_min, valid_loss\n", + " )\n", + " )\n", + " torch.save(model.state_dict(), \"model_cifar.pt\")\n", + " valid_loss_min = valid_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "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.xlabel(\"Epoch\")\n", + "plt.ylabel(\"Loss\")\n", + "plt.title(\"Performance of Model 2\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss: 15.936195\n", + "\n", + "Test Accuracy of airplane: 78% (789/1000)\n", + "Test Accuracy of automobile: 89% (898/1000)\n", + "Test Accuracy of bird: 57% (572/1000)\n", + "Test Accuracy of cat: 60% (605/1000)\n", + "Test Accuracy of deer: 73% (733/1000)\n", + "Test Accuracy of dog: 63% (635/1000)\n", + "Test Accuracy of frog: 76% (767/1000)\n", + "Test Accuracy of horse: 75% (751/1000)\n", + "Test Accuracy of ship: 83% (831/1000)\n", + "Test Accuracy of truck: 76% (762/1000)\n", + "\n", + "Test Accuracy (Overall): 73% (7343/10000)\n" + ] + } + ], + "source": [ + "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n", + "\n", + "# track test loss\n", + "test_loss = 0.0\n", + "class_correct = list(0.0 for i in range(10))\n", + "class_total = list(0.0 for i in range(10))\n", + "\n", + "model.eval()\n", + "# iterate over test data\n", + "for data, target in test_loader:\n", + " # move tensors to GPU if CUDA is available\n", + " if train_on_gpu:\n", + " data, target = data.cuda(), target.cuda()\n", + " # forward pass: compute predicted outputs by passing inputs to the model\n", + " output = model(data)\n", + " # calculate the batch loss\n", + " loss = criterion(output, target)\n", + " # update test loss\n", + " test_loss += loss.item() * data.size(0)\n", + " # convert output probabilities to predicted class\n", + " _, pred = torch.max(output, 1)\n", + " # compare predictions to true label\n", + " correct_tensor = pred.eq(target.data.view_as(pred))\n", + " correct = (\n", + " np.squeeze(correct_tensor.numpy())\n", + " if not train_on_gpu\n", + " else np.squeeze(correct_tensor.cpu().numpy())\n", + " )\n", + " # calculate test accuracy for each object class\n", + " for i in range(batch_size):\n", + " label = target.data[i]\n", + " class_correct[label] += correct[i].item()\n", + " class_total[label] += 1\n", + "\n", + "# average test loss\n", + "test_loss = test_loss / len(test_loader)\n", + "print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n", + "\n", + "for i in range(10):\n", + " if class_total[i] > 0:\n", + " print(\n", + " \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n", + " % (\n", + " classes[i],\n", + " 100 * class_correct[i] / class_total[i],\n", + " np.sum(class_correct[i]),\n", + " np.sum(class_total[i]),\n", + " )\n", + " )\n", + " else:\n", + " print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n", + "\n", + "print(\n", + " \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n", + " % (\n", + " 100.0 * np.sum(class_correct) / np.sum(class_total),\n", + " np.sum(class_correct),\n", + " np.sum(class_total),\n", + " )\n", + ")" + ] + }, { "cell_type": "markdown", "id": "bc381cf4", @@ -451,10 +930,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "id": "ef623c26", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: fp32 \t Size (KB): 2330.946\n" + ] + }, + { + "data": { + "text/plain": [ + "2330946" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import os\n", "\n", @@ -480,10 +977,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "id": "c4c65d4b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: int8 \t Size (KB): 659.806\n" + ] + }, + { + "data": { + "text/plain": [ + "659806" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import torch.quantization\n", "\n", @@ -492,6 +1007,13 @@ "print_size_of_model(quantized_model, \"int8\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " We observe a significant decline in model size from 2330.946KB to 659.806KB which proves the effectivness of quantization in reducing the model's size" + ] + }, { "cell_type": "markdown", "id": "7b108e17", @@ -500,41 +1022,586 @@ "For each class, compare the classification test accuracy of the initial model and the quantized model. Also give the overall test accuracy for both models." ] }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def compare():\n", + " # track test loss\n", + " test_loss = 0.0\n", + " test_loss_quantized= 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", + " class_correct_quantized = list(0.0 for i in range(10))\n", + " class_total_quantized = list(0.0 for i in range(10))\n", + "\n", + " model.eval()\n", + " quantized_model.eval()\n", + " # iterate over test data\n", + " for data, target in test_loader:\n", + " # move tensors to GPU if CUDA is available\n", + " if train_on_gpu:\n", + " data, target = data.cuda(), target.cuda()\n", + " # forward pass: compute predicted outputs by passing inputs to the model\n", + " output = model(data)\n", + " quantized_output=quantized_model(data)\n", + " # calculate the batch loss\n", + " loss = criterion(output, target)\n", + " quantized_loss=criterion(quantized_output, target)\n", + " # update test loss\n", + " test_loss += loss.item() * data.size(0)\n", + " test_loss_quantized+= quantized_loss.item() * data.size(0)\n", + " # convert output probabilities to predicted class\n", + " _, pred = torch.max(output, 1)\n", + " _, quantized_pred = torch.max(quantized_output, 1)\n", + " # compare predictions to true label\n", + " correct_tensor = pred.eq(target.data.view_as(pred))\n", + " quantized_correct_tensor = quantized_pred.eq(target.data.view_as(quantized_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", + " quantized_correct = (\n", + " np.squeeze(quantized_correct_tensor.numpy())\n", + " if not train_on_gpu\n", + " else np.squeeze(quantized_correct_tensor.cpu().numpy())\n", + " )\n", + " # calculate test accuracy for each object class for the non quantized model\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", + " # calculate test accuracy for each object class for the quantized model\n", + " for i in range(batch_size):\n", + " label = target.data[i]\n", + " class_correct_quantized[label] += quantized_correct[i].item()\n", + " class_total_quantized[label] += 1 \n", + " # average test loss for the non quantized model \n", + " test_loss = test_loss / len(test_loader)\n", + " print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n", + " # average test loss for the quantized model \n", + " test_loss_quantized = test_loss_quantized / len(test_loader)\n", + " print(\"Test Loss quantized: {:.6f}\\n\".format(test_loss_quantized))\n", + " for i in range(10):\n", + " if class_total[i] > 0:\n", + " print(\n", + " \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n", + " % (\n", + " classes[i],\n", + " 100 * class_correct[i] / class_total[i],\n", + " np.sum(class_correct[i]),\n", + " np.sum(class_total[i]),\n", + " )\n", + " )\n", + " else:\n", + " print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n", + "\n", + " print(\n", + " \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n", + " % (\n", + " 100.0 * np.sum(class_correct) / np.sum(class_total),\n", + " np.sum(class_correct),\n", + " np.sum(class_total),\n", + " )\n", + " )\n", + "\n", + " # average test loss for the quantized model \n", + " test_loss_quantized = test_loss_quantized / len(test_loader)\n", + " print(\"Test Loss: {:.6f}\\n\".format(test_loss_quantized))\n", + "\n", + " for i in range(10):\n", + " if class_total_quantized[i] > 0:\n", + " print(\n", + " \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n", + " % (\n", + " classes[i],\n", + " 100 * class_correct_quantized[i] / class_total_quantized[i],\n", + " np.sum(class_correct_quantized[i]),\n", + " np.sum(class_total_quantized[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_quantized) / np.sum(class_total_quantized),\n", + " np.sum(class_correct_quantized),\n", + " np.sum(class_total_quantized),\n", + " )\n", + " )\n", + " # the comparision between the two models\n", + " print('\\n \\n')\n", + " quant_class_model=0\n", + " class_model=0\n", + " for i in range(10):\n", + " quant_class_model=100 * class_correct_quantized[i] / class_total_quantized[i]\n", + " class_model=100 * class_correct[i] / class_total[i]\n", + " if quant_class_model>class_model:\n", + " print('the quantized model performed better for the class',classes[i],'with accuracy equal to',quant_class_model)\n", + " elif quant_class_model<class_model:\n", + " print('the non quantized model performed better for the class',classes[i],'with accuracy equal to',quant_class_model)\n", + " elif quant_class_model==class_model:\n", + " print('the models performed the same for the class',classes[i])" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss: 15.936195\n", + "\n", + "Test Loss quantized: 15.949273\n", + "\n", + "Test Accuracy of airplane: 78% (789/1000)\n", + "Test Accuracy of automobile: 89% (898/1000)\n", + "Test Accuracy of bird: 57% (572/1000)\n", + "Test Accuracy of cat: 60% (605/1000)\n", + "Test Accuracy of deer: 73% (733/1000)\n", + "Test Accuracy of dog: 63% (635/1000)\n", + "Test Accuracy of frog: 76% (767/1000)\n", + "Test Accuracy of horse: 75% (751/1000)\n", + "Test Accuracy of ship: 83% (831/1000)\n", + "Test Accuracy of truck: 76% (762/1000)\n", + "\n", + "Test Accuracy (Overall): 73% (7343/10000)\n", + "Test Loss: 0.031899\n", + "\n", + "Test Accuracy of airplane: 78% (789/1000)\n", + "Test Accuracy of automobile: 89% (898/1000)\n", + "Test Accuracy of bird: 57% (574/1000)\n", + "Test Accuracy of cat: 60% (600/1000)\n", + "Test Accuracy of deer: 73% (733/1000)\n", + "Test Accuracy of dog: 63% (632/1000)\n", + "Test Accuracy of frog: 76% (765/1000)\n", + "Test Accuracy of horse: 75% (752/1000)\n", + "Test Accuracy of ship: 83% (835/1000)\n", + "Test Accuracy of truck: 76% (761/1000)\n", + "\n", + "Test Accuracy (Overall): 73% (7339/10000)\n", + "\n", + " \n", + "\n", + "the models performed the same for the class airplane\n", + "the models performed the same for the class automobile\n", + "the quantized model performed better for the class bird with accuracy equal to 57.4\n", + "the non quantized model performed better for the class cat with accuracy equal to 60.0\n", + "the models performed the same for the class deer\n", + "the non quantized model performed better for the class dog with accuracy equal to 63.2\n", + "the non quantized model performed better for the class frog with accuracy equal to 76.5\n", + "the quantized model performed better for the class horse with accuracy equal to 75.2\n", + "the quantized model performed better for the class ship with accuracy equal to 83.5\n", + "the non quantized model performed better for the class truck with accuracy equal to 76.1\n" + ] + } + ], + "source": [ + "compare()" + ] + }, { "cell_type": "markdown", - "id": "a0a34b90", "metadata": {}, "source": [ - "Try training aware quantization to mitigate the impact on the accuracy (doc available here https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic)" + "We can observe that the non quantized model performed better than the quantized model for several classes. There seems to be a noticeable accuracy reduction in the quantized model for certain classes. Still, the quantized model performed better for other classes.Yet, the negative effect is more abundent than the positive one (6 classes out of 9).\n", + "Thus, we can assume that quantization effect negatively the accuracy." ] }, { "cell_type": "markdown", - "id": "201470f9", + "id": "a0a34b90", "metadata": {}, "source": [ - "## Exercise 3: working with pre-trained models.\n", - "\n", - "PyTorch offers several pre-trained models https://pytorch.org/vision/0.8/models.html \n", - "We will use ResNet50 trained on ImageNet dataset (https://www.image-net.org/index.php). Use the following code with the files `imagenet-simple-labels.json` that contains the imagenet labels and the image dog.png that we will use as test.\n" + "Try training aware quantization to mitigate the impact on the accuracy (doc available here https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic)" ] }, { "cell_type": "code", - "execution_count": null, - "id": "b4d13080", + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ - "import json\n", - "from PIL import Image\n", - "\n", - "# Choose an image to pass through the model\n", - "test_image = \"dog.png\"\n", - "\n", - "# Configure matplotlib for pretty inline plots\n", - "#%matplotlib inline\n", - "#%config InlineBackend.figure_format = 'retina'\n", + "class Second_Net(nn.Module):\n", + " def __init__(self):\n", + " super(Second_Net, self).__init__()\n", + " self.conv1 = nn.Conv2d(3, 16, 3, padding=1)\n", + " self.pool = nn.MaxPool2d(2, 2)\n", + " self.conv2 = nn.Conv2d(16, 32, 3, padding=1)\n", + " self.conv3 = nn.Conv2d(32, 64, 3, padding=1)\n", + " self.fc1 = nn.Linear(64 * 4 * 4, 512)\n", + " self.fc2 = nn.Linear(512, 64)\n", + " self.fc3 = nn.Linear(64, 10)\n", + " self.dropout = nn.Dropout(0.2)\n", + " self.quant = torch.quantization.QuantStub()\n", + " self.dequant = torch.quantization.DeQuantStub()\n", + "\n", + " def forward(self, x):\n", + " x = self.quant(x)\n", + " x = self.pool(F.relu(self.conv1(x)))\n", + " x = self.pool(F.relu(self.conv2(x)))\n", + " x = self.pool(F.relu(self.conv3(x)))\n", + " x = x.view(-1, 64 * 4 * 4)\n", + " x = self.dropout(F.relu(self.fc1(x)))\n", + " x = self.dropout(F.relu(self.fc2(x)))\n", + " x = self.fc3(x)\n", + " x = self.dequant(x)\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Maha Kosksi\\AppData\\Roaming\\Python\\Python311\\site-packages\\torch\\ao\\quantization\\quantize.py:309: UserWarning: None of the submodule got qconfig applied. Make sure you passed correct configuration through `qconfig_dict` or by assigning the `.qconfig` attribute directly on submodules\n", + " warnings.warn(\"None of the submodule got qconfig applied. Make sure you \"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0 \tTraining Loss: 45.423676 \tValidation Loss: 42.686249\n", + "Epoch: 1 \tTraining Loss: 39.450979 \tValidation Loss: 34.980716\n", + "Epoch: 2 \tTraining Loss: 33.441739 \tValidation Loss: 30.549556\n", + "Epoch: 3 \tTraining Loss: 30.410467 \tValidation Loss: 28.980548\n", + "Epoch: 4 \tTraining Loss: 28.103745 \tValidation Loss: 26.466495\n", + "Epoch: 5 \tTraining Loss: 26.096422 \tValidation Loss: 25.030080\n", + "Epoch: 6 \tTraining Loss: 24.164691 \tValidation Loss: 24.016260\n", + "Epoch: 7 \tTraining Loss: 22.486316 \tValidation Loss: 21.297213\n", + "Epoch: 8 \tTraining Loss: 21.019347 \tValidation Loss: 20.847245\n", + "Epoch: 9 \tTraining Loss: 19.674915 \tValidation Loss: 19.561787\n", + "Epoch: 10 \tTraining Loss: 18.569554 \tValidation Loss: 19.161279\n", + "Epoch: 11 \tTraining Loss: 17.338444 \tValidation Loss: 18.754486\n", + "Epoch: 12 \tTraining Loss: 16.313604 \tValidation Loss: 17.663940\n", + "Epoch: 13 \tTraining Loss: 15.244958 \tValidation Loss: 17.191757\n", + "Epoch: 14 \tTraining Loss: 14.236570 \tValidation Loss: 17.347870\n", + "Epoch: 15 \tTraining Loss: 13.233929 \tValidation Loss: 17.197369\n", + "Epoch: 16 \tTraining Loss: 12.332780 \tValidation Loss: 17.899901\n", + "Epoch: 17 \tTraining Loss: 11.477178 \tValidation Loss: 16.836718\n", + "Epoch: 18 \tTraining Loss: 10.524045 \tValidation Loss: 16.791954\n", + "Epoch: 19 \tTraining Loss: 9.667919 \tValidation Loss: 17.603604\n", + "Epoch: 20 \tTraining Loss: 8.968887 \tValidation Loss: 18.133368\n", + "Epoch: 21 \tTraining Loss: 8.172313 \tValidation Loss: 18.145785\n", + "Epoch: 22 \tTraining Loss: 7.446161 \tValidation Loss: 18.876433\n", + "Epoch: 23 \tTraining Loss: 6.840206 \tValidation Loss: 18.421874\n", + "Epoch: 24 \tTraining Loss: 6.165971 \tValidation Loss: 18.937731\n", + "Epoch: 25 \tTraining Loss: 5.730384 \tValidation Loss: 19.711346\n", + "Epoch: 26 \tTraining Loss: 5.146225 \tValidation Loss: 19.878864\n", + "Epoch: 27 \tTraining Loss: 4.777133 \tValidation Loss: 21.688155\n", + "Epoch: 28 \tTraining Loss: 4.323573 \tValidation Loss: 21.270596\n", + "Epoch: 29 \tTraining Loss: 4.000249 \tValidation Loss: 24.816025\n" + ] + } + ], + "source": [ + "'''implementing the aware quantization'''\n", + "from torch.ao.quantization import QConfigMapping\n", + "import torch.quantization.quantize_fx as quantize_fx\n", + "import copy\n", + "\n", + "model_fp=Second_Net()\n", + "\n", + "model_fp.train()\n", + "model_to_quantize = copy.deepcopy(model_fp)\n", + "model.qconfig = torch.quantization.get_default_qat_qconfig(\"qnnpack\")\n", + "model_qat = torch.quantization.prepare_qat(model_fp, inplace=False)\n", + "# quantization aware training goes here\n", + "model_qat = torch.quantization.convert(model_qat.eval(), inplace=False)\n", + "n_epochs=30\n", + "criterion = nn.CrossEntropyLoss() # specify loss function\n", + "optimizer = optim.SGD(model_qat.parameters(), lr=0.01) # specify optimizer\n", + "for epoch in range(n_epochs):\n", + " # Keep track of training and validation loss\n", + " train_loss = 0.0\n", + " valid_loss = 0.0\n", + "\n", + " # Train the model\n", + " model_qat.train()\n", + " for data, target in train_loader:\n", + " # Move tensors to GPU if CUDA is available\n", + " if train_on_gpu:\n", + " data, target = data.cuda(), target.cuda()\n", + " # Clear the gradients of all optimized variables\n", + " optimizer.zero_grad()\n", + " # Forward pass: compute predicted outputs by passing inputs to the model\n", + " output = model_qat(data)\n", + " # Calculate the batch loss\n", + " loss = criterion(output, target)\n", + " # Backward pass: compute gradient of the loss with respect to model parameters\n", + " loss.backward()\n", + " # Perform a single optimization step (parameter update)\n", + " optimizer.step()\n", + " # Update training loss\n", + " train_loss += loss.item() * data.size(0)\n", + "\n", + " # Validate the model\n", + " model_qat.eval()\n", + " for data, target in valid_loader:\n", + " # Move tensors to GPU if CUDA is available\n", + " if train_on_gpu:\n", + " data, target = data.cuda(), target.cuda()\n", + " # Forward pass: compute predicted outputs by passing inputs to the model\n", + " output = model_qat(data)\n", + " # Calculate the batch loss\n", + " loss = criterion(output, target)\n", + " # Update average validation loss\n", + " valid_loss += loss.item() * data.size(0)\n", + "\n", + " # Calculate average losses\n", + " train_loss = train_loss / len(train_loader)\n", + " valid_loss = valid_loss / len(valid_loader)\n", + " train_loss_list.append(train_loss)\n", + "\n", + " # Print training/validation statistics\n", + " print(\n", + " \"Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}\".format(\n", + " epoch, train_loss, valid_loss\n", + " )\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Second_Net(\n", + " (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (fc1): Linear(in_features=1024, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=64, bias=True)\n", + " (fc3): Linear(in_features=64, out_features=10, bias=True)\n", + " (dropout): Dropout(p=0.2, inplace=False)\n", + " (quant): QuantStub()\n", + " (dequant): DeQuantStub()\n", + ")\n" + ] + } + ], + "source": [ + "print(model_qat)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss: 24.669794\n", + "\n", + "Test Accuracy of airplane: 73% (737/1000)\n", + "Test Accuracy of automobile: 73% (730/1000)\n", + "Test Accuracy of bird: 62% (622/1000)\n", + "Test Accuracy of cat: 47% (472/1000)\n", + "Test Accuracy of deer: 76% (768/1000)\n", + "Test Accuracy of dog: 64% (645/1000)\n", + "Test Accuracy of frog: 83% (832/1000)\n", + "Test Accuracy of horse: 78% (782/1000)\n", + "Test Accuracy of ship: 76% (769/1000)\n", + "Test Accuracy of truck: 83% (833/1000)\n", + "\n", + "Test Accuracy (Overall): 71% (7190/10000)\n" + ] + } + ], + "source": [ + "# 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", + "quantized_model = torch.ao.quantization.convert(model_qat.eval(), inplace=False)\n", + "model_quantized=quantized_model.eval()\n", + "# iterate over test data\n", + "for data, target in test_loader:\n", + " # move tensors to GPU if CUDA is available\n", + " if train_on_gpu:\n", + " data, target = data.cuda(), target.cuda()\n", + " # forward pass: compute predicted outputs by passing inputs to the model\n", + " output = model_quantized(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": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss: 15.936195\n", + "\n", + "Test Loss quantized: 24.669794\n", + "\n", + "Test Accuracy of airplane: 78% (789/1000)\n", + "Test Accuracy of automobile: 89% (898/1000)\n", + "Test Accuracy of bird: 57% (572/1000)\n", + "Test Accuracy of cat: 60% (605/1000)\n", + "Test Accuracy of deer: 73% (733/1000)\n", + "Test Accuracy of dog: 63% (635/1000)\n", + "Test Accuracy of frog: 76% (767/1000)\n", + "Test Accuracy of horse: 75% (751/1000)\n", + "Test Accuracy of ship: 83% (831/1000)\n", + "Test Accuracy of truck: 76% (762/1000)\n", + "\n", + "Test Accuracy (Overall): 73% (7343/10000)\n", + "Test Loss: 0.049340\n", + "\n", + "Test Accuracy of airplane: 73% (737/1000)\n", + "Test Accuracy of automobile: 73% (730/1000)\n", + "Test Accuracy of bird: 62% (622/1000)\n", + "Test Accuracy of cat: 47% (472/1000)\n", + "Test Accuracy of deer: 76% (768/1000)\n", + "Test Accuracy of dog: 64% (645/1000)\n", + "Test Accuracy of frog: 83% (832/1000)\n", + "Test Accuracy of horse: 78% (782/1000)\n", + "Test Accuracy of ship: 76% (769/1000)\n", + "Test Accuracy of truck: 83% (833/1000)\n", + "\n", + "Test Accuracy (Overall): 71% (7190/10000)\n", + "\n", + " \n", + "\n", + "the non quantized model performed better for the class airplane with accuracy equal to 73.7\n", + "the non quantized model performed better for the class automobile with accuracy equal to 73.0\n", + "the quantized model performed better for the class bird with accuracy equal to 62.2\n", + "the non quantized model performed better for the class cat with accuracy equal to 47.2\n", + "the quantized model performed better for the class deer with accuracy equal to 76.8\n", + "the quantized model performed better for the class dog with accuracy equal to 64.5\n", + "the quantized model performed better for the class frog with accuracy equal to 83.2\n", + "the quantized model performed better for the class horse with accuracy equal to 78.2\n", + "the non quantized model performed better for the class ship with accuracy equal to 76.9\n", + "the quantized model performed better for the class truck with accuracy equal to 83.3\n" + ] + } + ], + "source": [ + "quantized_model=model_quantized\n", + "compare()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Even with quantization aware training, the model's accuracy dropped significantly, we can observe a significant loss in the accuracy of the model. We can try to matigate that by retraining the quantized model." + ] + }, + { + "cell_type": "markdown", + "id": "201470f9", + "metadata": {}, + "source": [ + "## Exercise 3: working with pre-trained models.\n", + "\n", + "PyTorch offers several pre-trained models https://pytorch.org/vision/0.8/models.html \n", + "We will use ResNet50 trained on ImageNet dataset (https://www.image-net.org/index.php). Use the following code with the files `imagenet-simple-labels.json` that contains the imagenet labels and the image dog.png that we will use as test.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "b4d13080", + "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": [ + "import json\n", + "from PIL import Image\n", + "\n", + "# Choose an image to pass through the model\n", + "test_image = \"dog.png\"\n", + "\n", + "# Configure matplotlib for pretty inline plots\n", + "#%matplotlib inline\n", + "#%config InlineBackend.figure_format = 'retina'\n", "\n", "# Prepare the labels\n", "with open(\"imagenet-simple-labels.json\") as f:\n", @@ -572,134 +1639,945 @@ }, { "cell_type": "markdown", - "id": "184cfceb", + "id": "184cfceb", + "metadata": {}, + "source": [ + "Experiments:\n", + "\n", + "Study the code and the results obtained. Possibly add other images downloaded from the internet.\n", + "\n", + "What is the size of the model? Quantize it and then check if the model is still able to correctly classify the other images.\n", + "\n", + "Experiment with other pre-trained CNN models.\n", + "\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ResNet(\n", + " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (layer1): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer2): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer3): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (4): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (5): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer4): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", + " (fc): Linear(in_features=2048, out_features=1000, bias=True)\n", + ")\n" + ] + } + ], + "source": [ + "print(models.resnet50(pretrained=True))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Model size" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: fp32 \t Size (KB): 102523.238\n" + ] + }, + { + "data": { + "text/plain": [ + "102523238" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print_size_of_model(model, label=\"fp32\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Model Quantized" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: int8 \t Size (KB): 96379.996\n" + ] + }, + { + "data": { + "text/plain": [ + "96379996" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch.quantization\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "print_size_of_model(quantized_model, label=\"int8\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Testing with model quantized" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: Golden Retriever\n" + ] + } + ], + "source": [ + "\n", + "# Set layers such as dropout and batchnorm in evaluation mode\n", + "quantized_model.eval()\n", + "\n", + "# Get the 1000-dimensional model output\n", + "out = quantized_model(image)\n", + "# Find the predicted class\n", + "print(\"Predicted class is: {}\".format(labels[out.argmax()]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Testing with a new image" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: tabby cat\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import json\n", + "from PIL import Image\n", + "\n", + "# Choose an image to pass through the model\n", + "test_image = \"cat.jpg\"\n", + "\n", + "# Configure matplotlib for pretty inline plots\n", + "#%matplotlib inline\n", + "#%config InlineBackend.figure_format = 'retina'\n", + "\n", + "# Prepare the labels\n", + "with open(\"imagenet-simple-labels.json\") as f:\n", + " labels = json.load(f)\n", + "\n", + "# First prepare the transformations: resize the image to what the model was trained on and convert it to a tensor\n", + "data_transform = transforms.Compose(\n", + " [\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n", + " ]\n", + ")\n", + "# Load the image\n", + "\n", + "image = Image.open(test_image)\n", + "plt.imshow(image), plt.xticks([]), plt.yticks([])\n", + "\n", + "# Now apply the transformation, expand the batch dimension, and send the image to the GPU\n", + "# image = data_transform(image).unsqueeze(0).cuda()\n", + "image = data_transform(image).unsqueeze(0)\n", + "\n", + "# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\n", + "model = models.resnet50(pretrained=True)\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "# Send the model to the GPU\n", + "# model.cuda()\n", + "# Set layers such as dropout and batchnorm in evaluation mode\n", + "quantized_model.eval()\n", + "\n", + "# Get the 1000-dimensional model output\n", + "out = quantized_model(image)\n", + "# Find the predicted class\n", + "print(\"Predicted class is: {}\".format(labels[out.argmax()]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Experiment with Rnest18" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: tabby cat\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import json\n", + "from PIL import Image\n", + "\n", + "# Choose an image to pass through the model\n", + "test_image2= \"cat.jpg\"\n", + "\n", + "# Configure matplotlib for pretty inline plots\n", + "#%matplotlib inline\n", + "#%config InlineBackend.figure_format = 'retina'\n", + "\n", + "# Prepare the labels\n", + "with open(\"imagenet-simple-labels.json\") as f:\n", + " labels = json.load(f)\n", + "\n", + "# First prepare the transformations: resize the image to what the model was trained on and convert it to a tensor\n", + "data_transform = transforms.Compose(\n", + " [\n", + " transforms.Resize((224, 224)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n", + " ]\n", + ")\n", + "# Load the image\n", + "\n", + "image = Image.open(test_image2)\n", + "plt.imshow(image), plt.xticks([]), plt.yticks([])\n", + "\n", + "# Now apply the transformation, expand the batch dimension, and send the image to the GPU\n", + "# image = data_transform(image).unsqueeze(0).cuda()\n", + "image = data_transform(image).unsqueeze(0)\n", + "\n", + "# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\n", + "model = models.resnet18(pretrained=True)\n", + "# Send the model to the GPU\n", + "# model.cuda()\n", + "# Set layers such as dropout and batchnorm in evaluation mode\n", + "model.eval()\n", + "\n", + "# Get the 1000-dimensional model output\n", + "out = model(image)\n", + "# Find the predicted class\n", + "print(\"Predicted class is: {}\".format(labels[out.argmax()]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Even with ResNet18 we can see that we get always the correct prediction" + ] + }, + { + "cell_type": "markdown", + "id": "5d57da4b", + "metadata": {}, + "source": [ + "## Exercise 4: Transfer Learning\n", + " \n", + " \n", + "For this work, we will use a pre-trained model (ResNet18) as a descriptor extractor and will refine the classification by training only the last fully connected layer of the network. Thus, the output layer of the pre-trained network will be replaced by a layer adapted to the new classes to be recognized which will be in our case ants and bees.\n", + "Download and unzip in your working directory the dataset available at the address :\n", + " \n", + "https://download.pytorch.org/tutorial/hymenoptera_data.zip\n", + " \n", + "Execute the following code in order to display some images of the dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "be2d31f5", + "metadata": {}, + "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", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "import torchvision\n", + "from torchvision import datasets, transforms\n", + "\n", + "# Data augmentation and normalization for training\n", + "# Just normalization for validation\n", + "data_transforms = {\n", + " \"train\": transforms.Compose(\n", + " [\n", + " transforms.RandomResizedCrop(\n", + " 224\n", + " ), # ImageNet models were trained on 224x224 images\n", + " transforms.RandomHorizontalFlip(), # flip horizontally 50% of the time - increases train set variability\n", + " transforms.ToTensor(), # convert it to a PyTorch tensor\n", + " transforms.Normalize(\n", + " [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n", + " ), # ImageNet models expect this norm\n", + " ]\n", + " ),\n", + " \"val\": transforms.Compose(\n", + " [\n", + " transforms.Resize(256),\n", + " transforms.CenterCrop(224),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n", + " ]\n", + " ),\n", + "}\n", + "\n", + "data_dir = \"hymenoptera_data\"\n", + "# Create train and validation datasets and loaders\n", + "image_datasets = {\n", + " x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n", + " for x in [\"train\", \"val\"]\n", + "}\n", + "dataloaders = {\n", + " x: torch.utils.data.DataLoader(\n", + " image_datasets[x], batch_size=4, shuffle=True, num_workers=0\n", + " )\n", + " for x in [\"train\", \"val\"]\n", + "}\n", + "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n", + "class_names = image_datasets[\"train\"].classes\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "# Helper function for displaying images\n", + "def imshow(inp, title=None):\n", + " \"\"\"Imshow for Tensor.\"\"\"\n", + " inp = inp.numpy().transpose((1, 2, 0))\n", + " mean = np.array([0.485, 0.456, 0.406])\n", + " std = np.array([0.229, 0.224, 0.225])\n", + "\n", + " # Un-normalize the images\n", + " inp = std * inp + mean\n", + " # Clip just in case\n", + " inp = np.clip(inp, 0, 1)\n", + " plt.imshow(inp)\n", + " if title is not None:\n", + " plt.title(title)\n", + " plt.pause(0.001) # pause a bit so that plots are updated\n", + " plt.show()\n", + "\n", + "\n", + "# Get a batch of training data\n", + "inputs, classes = next(iter(dataloaders[\"train\"]))\n", + "\n", + "# Make a grid from batch\n", + "out = torchvision.utils.make_grid(inputs)\n", + "\n", + "imshow(out, title=[class_names[x] for x in classes])\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "bbd48800", + "metadata": {}, + "source": [ + "Now, execute the following code which uses a pre-trained model ResNet18 having replaced the output layer for the ants/bees classification and performs the model training by only changing the weights of this output layer." + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "572d824c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "----------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Maha Kosksi\\AppData\\Roaming\\Python\\Python311\\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": [ + "train Loss: 0.5899 Acc: 0.6885\n", + "val Loss: 0.3176 Acc: 0.8693\n", + "\n", + "Epoch 2/10\n", + "----------\n", + "train Loss: 0.4949 Acc: 0.7541\n", + "val Loss: 0.2099 Acc: 0.9216\n", + "\n", + "Epoch 3/10\n", + "----------\n", + "train Loss: 0.5228 Acc: 0.7746\n", + "val Loss: 0.2384 Acc: 0.9216\n", + "\n", + "Epoch 4/10\n", + "----------\n", + "train Loss: 0.5035 Acc: 0.8074\n", + "val Loss: 0.1737 Acc: 0.9542\n", + "\n", + "Epoch 5/10\n", + "----------\n", + "train Loss: 0.5170 Acc: 0.7828\n", + "val Loss: 0.2585 Acc: 0.9150\n", + "\n", + "Epoch 6/10\n", + "----------\n", + "train Loss: 0.4609 Acc: 0.8197\n", + "val Loss: 0.3260 Acc: 0.8758\n", + "\n", + "Epoch 7/10\n", + "----------\n", + "train Loss: 0.4133 Acc: 0.8115\n", + "val Loss: 0.2076 Acc: 0.9412\n", + "\n", + "Epoch 8/10\n", + "----------\n", + "train Loss: 0.3287 Acc: 0.8525\n", + "val Loss: 0.2227 Acc: 0.9216\n", + "\n", + "Epoch 9/10\n", + "----------\n", + "train Loss: 0.4231 Acc: 0.7828\n", + "val Loss: 0.2084 Acc: 0.9346\n", + "\n", + "Epoch 10/10\n", + "----------\n", + "train Loss: 0.3747 Acc: 0.8279\n", + "val Loss: 0.1865 Acc: 0.9477\n", + "\n", + "Training complete in 6m 15s\n", + "Best val Acc: 0.954248\n" + ] + } + ], + "source": [ + "import copy\n", + "import os\n", + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import torchvision\n", + "from torch.optim import lr_scheduler\n", + "from torchvision import datasets, transforms\n", + "\n", + "# Data augmentation and normalization for training\n", + "# Just normalization for validation\n", + "data_transforms = {\n", + " \"train\": transforms.Compose(\n", + " [\n", + " transforms.RandomResizedCrop(\n", + " 224\n", + " ), # ImageNet models were trained on 224x224 images\n", + " transforms.RandomHorizontalFlip(), # flip horizontally 50% of the time - increases train set variability\n", + " transforms.ToTensor(), # convert it to a PyTorch tensor\n", + " transforms.Normalize(\n", + " [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n", + " ), # ImageNet models expect this norm\n", + " ]\n", + " ),\n", + " \"val\": transforms.Compose(\n", + " [\n", + " transforms.Resize(256),\n", + " transforms.CenterCrop(224),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n", + " ]\n", + " ),\n", + "}\n", + "\n", + "data_dir = \"hymenoptera_data\"\n", + "# Create train and validation datasets and loaders\n", + "image_datasets = {\n", + " x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n", + " for x in [\"train\", \"val\"]\n", + "}\n", + "dataloaders = {\n", + " x: torch.utils.data.DataLoader(\n", + " image_datasets[x], batch_size=4, shuffle=True, num_workers=4\n", + " )\n", + " for x in [\"train\", \"val\"]\n", + "}\n", + "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n", + "class_names = image_datasets[\"train\"].classes\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "# Helper function for displaying images\n", + "def imshow(inp, title=None):\n", + " \"\"\"Imshow for Tensor.\"\"\"\n", + " inp = inp.numpy().transpose((1, 2, 0))\n", + " mean = np.array([0.485, 0.456, 0.406])\n", + " std = np.array([0.229, 0.224, 0.225])\n", + "\n", + " # Un-normalize the images\n", + " inp = std * inp + mean\n", + " # Clip just in case\n", + " inp = np.clip(inp, 0, 1)\n", + " plt.imshow(inp)\n", + " if title is not None:\n", + " plt.title(title)\n", + " plt.pause(0.001) # pause a bit so that plots are updated\n", + " plt.show()\n", + "\n", + "\n", + "# Get a batch of training data\n", + "# inputs, classes = next(iter(dataloaders['train']))\n", + "\n", + "# Make a grid from batch\n", + "# out = torchvision.utils.make_grid(inputs)\n", + "\n", + "# imshow(out, title=[class_names[x] for x in classes])\n", + "# training\n", + "\n", + "\n", + "def train_model(model, criterion, optimizer, scheduler, num_epochs=25):\n", + " since = time.time()\n", + "\n", + " best_model_wts = copy.deepcopy(model.state_dict())\n", + " best_acc = 0.0\n", + "\n", + " epoch_time = [] # we'll keep track of the time needed for each epoch\n", + "\n", + " for epoch in range(num_epochs):\n", + " epoch_start = time.time()\n", + " print(\"Epoch {}/{}\".format(epoch + 1, num_epochs))\n", + " print(\"-\" * 10)\n", + "\n", + " # Each epoch has a training and validation phase\n", + " for phase in [\"train\", \"val\"]:\n", + " if phase == \"train\":\n", + " scheduler.step()\n", + " model.train() # Set model to training mode\n", + " else:\n", + " model.eval() # Set model to evaluate mode\n", + "\n", + " running_loss = 0.0\n", + " running_corrects = 0\n", + "\n", + " # Iterate over data.\n", + " for inputs, labels in dataloaders[phase]:\n", + " inputs = inputs.to(device)\n", + " labels = labels.to(device)\n", + "\n", + " # zero the parameter gradients\n", + " optimizer.zero_grad()\n", + "\n", + " # Forward\n", + " # Track history if only in training phase\n", + " with torch.set_grad_enabled(phase == \"train\"):\n", + " outputs = model(inputs)\n", + " _, preds = torch.max(outputs, 1)\n", + " loss = criterion(outputs, labels)\n", + "\n", + " # backward + optimize only if in training phase\n", + " if phase == \"train\":\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " # Statistics\n", + " running_loss += loss.item() * inputs.size(0)\n", + " running_corrects += torch.sum(preds == labels.data)\n", + "\n", + " epoch_loss = running_loss / dataset_sizes[phase]\n", + " epoch_acc = running_corrects.double() / dataset_sizes[phase]\n", + "\n", + " print(\"{} Loss: {:.4f} Acc: {:.4f}\".format(phase, epoch_loss, epoch_acc))\n", + "\n", + " # Deep copy the model\n", + " if phase == \"val\" and epoch_acc > best_acc:\n", + " best_acc = epoch_acc\n", + " best_model_wts = copy.deepcopy(model.state_dict())\n", + "\n", + " # Add the epoch time\n", + " t_epoch = time.time() - epoch_start\n", + " epoch_time.append(t_epoch)\n", + " print()\n", + "\n", + " time_elapsed = time.time() - since\n", + " print(\n", + " \"Training complete in {:.0f}m {:.0f}s\".format(\n", + " time_elapsed // 60, time_elapsed % 60\n", + " )\n", + " )\n", + " print(\"Best val Acc: {:4f}\".format(best_acc))\n", + "\n", + " # Load best model weights\n", + " model.load_state_dict(best_model_wts)\n", + " return model, epoch_time\n", + "\n", + "\n", + "# Download a pre-trained ResNet18 model and freeze its weights\n", + "model = torchvision.models.resnet18(pretrained=True)\n", + "for param in model.parameters():\n", + " param.requires_grad = False\n", + "\n", + "# Replace the final fully connected layer\n", + "# Parameters of newly constructed modules have requires_grad=True by default\n", + "num_ftrs = model.fc.in_features\n", + "model.fc = nn.Linear(num_ftrs, 2)\n", + "# Send the model to the GPU\n", + "model = model.to(device)\n", + "# Set the loss function\n", + "criterion = nn.CrossEntropyLoss()\n", + "\n", + "# Observe that only the parameters of the final layer are being optimized\n", + "optimizer_conv = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)\n", + "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)\n", + "model, epoch_time = train_model(\n", + " model, criterion, optimizer_conv, exp_lr_scheduler, num_epochs=10\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "bbd48800", "metadata": {}, "source": [ "Experiments:\n", + "Study the code and the results obtained.\n", "\n", - "Study the code and the results obtained. Possibly add other images downloaded from the internet.\n", - "\n", - "What is the size of the model? Quantize it and then check if the model is still able to correctly classify the other images.\n", + "Modify the code and add an \"eval_model\" function to allow\n", + "the evaluation of the model on a test set (different from the learning and validation sets used during the learning phase). Study the results obtained.\n", "\n", - "Experiment with other pre-trained CNN models.\n", + "Now modify the code to replace the current classification layer with a set of two layers using a \"relu\" activation function for the middle layer, and the \"dropout\" mechanism for both layers. Renew the experiments and study the results obtained.\n", "\n", - " \n" + "Apply ther quantization (post and quantization aware) and evaluate impact on model size and accuracy." ] }, { "cell_type": "markdown", - "id": "5d57da4b", - "metadata": {}, - "source": [ - "## Exercise 4: Transfer Learning\n", - " \n", - " \n", - "For this work, we will use a pre-trained model (ResNet18) as a descriptor extractor and will refine the classification by training only the last fully connected layer of the network. Thus, the output layer of the pre-trained network will be replaced by a layer adapted to the new classes to be recognized which will be in our case ants and bees.\n", - "Download and unzip in your working directory the dataset available at the address :\n", - " \n", - "https://download.pytorch.org/tutorial/hymenoptera_data.zip\n", - " \n", - "Execute the following code in order to display some images of the dataset." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "be2d31f5", "metadata": {}, - "outputs": [], "source": [ - "import os\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import torch\n", - "import torchvision\n", - "from torchvision import datasets, transforms\n", - "\n", - "# Data augmentation and normalization for training\n", - "# Just normalization for validation\n", - "data_transforms = {\n", - " \"train\": transforms.Compose(\n", - " [\n", - " transforms.RandomResizedCrop(\n", - " 224\n", - " ), # ImageNet models were trained on 224x224 images\n", - " transforms.RandomHorizontalFlip(), # flip horizontally 50% of the time - increases train set variability\n", - " transforms.ToTensor(), # convert it to a PyTorch tensor\n", - " transforms.Normalize(\n", - " [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n", - " ), # ImageNet models expect this norm\n", - " ]\n", - " ),\n", - " \"val\": transforms.Compose(\n", - " [\n", - " transforms.Resize(256),\n", - " transforms.CenterCrop(224),\n", - " transforms.ToTensor(),\n", - " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n", - " ]\n", - " ),\n", - "}\n", - "\n", - "data_dir = \"hymenoptera_data\"\n", - "# Create train and validation datasets and loaders\n", - "image_datasets = {\n", - " x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n", - " for x in [\"train\", \"val\"]\n", - "}\n", - "dataloaders = {\n", - " x: torch.utils.data.DataLoader(\n", - " image_datasets[x], batch_size=4, shuffle=True, num_workers=0\n", - " )\n", - " for x in [\"train\", \"val\"]\n", - "}\n", - "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n", - "class_names = image_datasets[\"train\"].classes\n", - "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", - "\n", - "# Helper function for displaying images\n", - "def imshow(inp, title=None):\n", - " \"\"\"Imshow for Tensor.\"\"\"\n", - " inp = inp.numpy().transpose((1, 2, 0))\n", - " mean = np.array([0.485, 0.456, 0.406])\n", - " std = np.array([0.229, 0.224, 0.225])\n", - "\n", - " # Un-normalize the images\n", - " inp = std * inp + mean\n", - " # Clip just in case\n", - " inp = np.clip(inp, 0, 1)\n", - " plt.imshow(inp)\n", - " if title is not None:\n", - " plt.title(title)\n", - " plt.pause(0.001) # pause a bit so that plots are updated\n", - " plt.show()\n", - "\n", - "\n", - "# Get a batch of training data\n", - "inputs, classes = next(iter(dataloaders[\"train\"]))\n", - "\n", - "# Make a grid from batch\n", - "out = torchvision.utils.make_grid(inputs)\n", - "\n", - "imshow(out, title=[class_names[x] for x in classes])\n", - "\n" + "We observe a study growth in accuracy and decline in loss through the epochs.At the end,we obtained a good accuracy equal to 94% " ] }, { "cell_type": "markdown", - "id": "bbd48800", "metadata": {}, "source": [ - "Now, execute the following code which uses a pre-trained model ResNet18 having replaced the output layer for the ants/bees classification and performs the model training by only changing the weights of this output layer." + "Adding the test dataset\n", + "We acquired the test set from the following link: https://www.kaggle.com/datasets/lys620/ants-and-beesWe, after that we add the test set to the repo." ] }, { "cell_type": "code", - "execution_count": null, - "id": "572d824c", + "execution_count": 114, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "----------\n", + "train Loss: 0.5808 Acc: 0.7008\n", + "val Loss: 0.2968 Acc: 0.8889\n", + "\n", + "Epoch 2/10\n", + "----------\n", + "train Loss: 0.5647 Acc: 0.7377\n", + "val Loss: 0.1818 Acc: 0.9412\n", + "\n", + "Epoch 3/10\n", + "----------\n", + "train Loss: 0.5458 Acc: 0.7869\n", + "val Loss: 0.2528 Acc: 0.9150\n", + "\n", + "Epoch 4/10\n", + "----------\n", + "train Loss: 0.5978 Acc: 0.7459\n", + "val Loss: 0.2750 Acc: 0.9085\n", + "\n", + "Epoch 5/10\n", + "----------\n", + "train Loss: 0.5053 Acc: 0.7746\n", + "val Loss: 0.1689 Acc: 0.9477\n", + "\n", + "Epoch 6/10\n", + "----------\n", + "train Loss: 0.3449 Acc: 0.8484\n", + "val Loss: 0.2807 Acc: 0.8954\n", + "\n", + "Epoch 7/10\n", + "----------\n", + "train Loss: 0.3465 Acc: 0.8361\n", + "val Loss: 0.1707 Acc: 0.9542\n", + "\n", + "Epoch 8/10\n", + "----------\n", + "train Loss: 0.3620 Acc: 0.8443\n", + "val Loss: 0.1705 Acc: 0.9412\n", + "\n", + "Epoch 9/10\n", + "----------\n", + "train Loss: 0.3452 Acc: 0.8320\n", + "val Loss: 0.1705 Acc: 0.9477\n", + "\n", + "Epoch 10/10\n", + "----------\n", + "train Loss: 0.3531 Acc: 0.8279\n", + "val Loss: 0.1655 Acc: 0.9542\n", + "\n", + "Training complete in 6m 7s\n", + "Best val Acc: 0.954248\n" + ] + } + ], "source": [ "import copy\n", "import os\n", @@ -737,19 +2615,27 @@ " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n", " ]\n", " ),\n", + " \"test\": transforms.Compose(\n", + " [\n", + " transforms.Resize(256),\n", + " transforms.CenterCrop(224),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n", + " ]\n", + " ),\n", "}\n", "\n", "data_dir = \"hymenoptera_data\"\n", "# Create train and validation datasets and loaders\n", "image_datasets = {\n", " x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n", - " for x in [\"train\", \"val\"]\n", + " for x in [\"train\", \"val\",\"test\"]\n", "}\n", "dataloaders = {\n", " x: torch.utils.data.DataLoader(\n", " image_datasets[x], batch_size=4, shuffle=True, num_workers=4\n", " )\n", - " for x in [\"train\", \"val\"]\n", + " for x in [\"train\", \"val\",\"test\"]\n", "}\n", "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n", "class_names = image_datasets[\"train\"].classes\n", @@ -878,23 +2764,424 @@ "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)\n", "model, epoch_time = train_model(\n", " model, criterion, optimizer_conv, exp_lr_scheduler, num_epochs=10\n", - ")\n" + ")" ] }, { "cell_type": "markdown", - "id": "bbd48800", "metadata": {}, "source": [ - "Experiments:\n", - "Study the code and the results obtained.\n", + " \n", + "Test function" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [], + "source": [ + "def test_model(model,criterion,optimizer):\n", + " was_training = model.training\n", + " model.eval()\n", + " \n", + " class_correct = list(0.0 for i in range(2))\n", + " class_total = list(0.0 for i in range(2))\n", + "\n", + " with torch.no_grad():\n", + " for i, (inputs, labels) in enumerate(dataloaders['test']):\n", + " inputs = inputs.to(device)\n", + " labels = labels.to(device)\n", + "\n", + " outputs = model(inputs)\n", + " _, preds = torch.max(outputs, 1)\n", + " \n", + " correct_tensor = preds.eq(labels.data.view_as(preds))\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(3):\n", + " label = labels.data[i]\n", + " class_correct[label] += correct[i].item()\n", + " class_total[label] += 1\n", "\n", - "Modify the code and add an \"eval_model\" function to allow\n", - "the evaluation of the model on a test set (different from the learning and validation sets used during the learning phase). Study the results obtained.\n", + " model.train(mode=was_training)\n", + " \n", + " for i in range(2):\n", + " if class_total[i] > 0:\n", + " print(\n", + " \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n", + " % (\n", + " class_names[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)\" % (class_names[i]))\n", "\n", - "Now modify the code to replace the current classification layer with a set of two layers using a \"relu\" activation function for the middle layer, and the \"dropout\" mechanism for both layers. Renew the experiments and study the results obtained.\n", + " 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": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Accuracy of ants: 100% (19/19)\n", + "Test Accuracy of bees: 98% (61/62)\n", + "\n", + "Test Accuracy (Overall): 98% (80/81)\n" + ] + } + ], + "source": [ + "##test the model on the dataset used for test part \n", "\n", - "Apply ther quantization (post and quantization aware) and evaluate impact on model size and accuracy." + "test_model(model,criterion,optimizer_conv)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Modification of the FC" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "----------\n", + "train Loss: 0.7118 Acc: 0.5615\n", + "val Loss: 0.6862 Acc: 0.5294\n", + "\n", + "Epoch 2/10\n", + "----------\n", + "train Loss: 0.6555 Acc: 0.5656\n", + "val Loss: 0.5576 Acc: 0.8105\n", + "\n", + "Epoch 3/10\n", + "----------\n", + "train Loss: 0.6732 Acc: 0.5410\n", + "val Loss: 0.5467 Acc: 0.8889\n", + "\n", + "Epoch 4/10\n", + "----------\n", + "train Loss: 0.6386 Acc: 0.6148\n", + "val Loss: 0.5397 Acc: 0.8824\n", + "\n", + "Epoch 5/10\n", + "----------\n", + "train Loss: 0.6324 Acc: 0.6230\n", + "val Loss: 0.5316 Acc: 0.8824\n", + "\n", + "Epoch 6/10\n", + "----------\n", + "train Loss: 0.6388 Acc: 0.6025\n", + "val Loss: 0.4614 Acc: 0.8954\n", + "\n", + "Epoch 7/10\n", + "----------\n", + "train Loss: 0.5687 Acc: 0.6803\n", + "val Loss: 0.4190 Acc: 0.9150\n", + "\n", + "Epoch 8/10\n", + "----------\n", + "train Loss: 0.5868 Acc: 0.6598\n", + "val Loss: 0.4122 Acc: 0.9085\n", + "\n", + "Epoch 9/10\n", + "----------\n", + "train Loss: 0.6109 Acc: 0.5943\n", + "val Loss: 0.4159 Acc: 0.9150\n", + "\n", + "Epoch 10/10\n", + "----------\n", + "train Loss: 0.5935 Acc: 0.6516\n", + "val Loss: 0.4049 Acc: 0.9216\n", + "\n", + "Training complete in 6m 7s\n", + "Best val Acc: 0.921569\n" + ] + } + ], + "source": [ + "model = torchvision.models.resnet18(pretrained=True)\n", + "for param in model.parameters():\n", + " param.requires_grad = False\n", + "\n", + "# Replace the final fully connected layer\n", + "# Parameters of newly constructed modules have requires_grad=True by default\n", + "num_ftrs = model.fc.in_features\n", + "model.fc = nn.Sequential(\n", + " nn.Linear(num_ftrs, 10),\n", + " nn.ReLU(),\n", + " nn.Dropout(0.4),\n", + " nn.Linear(10, 2),\n", + " nn.Dropout(0.4)\n", + " )\n", + "# Send the model to the GPU\n", + "model = model.to(device)\n", + "# Set the loss function\n", + "criterion = nn.CrossEntropyLoss()\n", + "\n", + "# Observe that only the parameters of the final layer are being optimized\n", + "optimizer_conv = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)\n", + "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)\n", + "model, epoch_time = train_model(\n", + " model, criterion, optimizer_conv, exp_lr_scheduler, num_epochs=10\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Accuracy of ants: 100% (17/17)\n", + "Test Accuracy of bees: 92% (59/64)\n", + "\n", + "Test Accuracy (Overall): 93% (76/81)\n" + ] + } + ], + "source": [ + "test_model(model,criterion,optimizer_conv)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Post Quantization" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: fp32 \t Size (KB): 44797.562\n" + ] + }, + { + "data": { + "text/plain": [ + "44797562" + ] + }, + "execution_count": 126, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os\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": 127, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: int8 \t Size (KB): 44783.654\n", + "Test Accuracy of ants: 100% (18/18)\n", + "Test Accuracy of bees: 95% (60/63)\n", + "\n", + "Test Accuracy (Overall): 96% (78/81)\n" + ] + } + ], + "source": [ + "import torch.quantization\n", + "\n", + "\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "print_size_of_model(quantized_model, \"int8\")\n", + "test_model(quantized_model,criterion,optimizer_conv)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can observe that the test accuracy has been decreased." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Aware Quantization" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [], + "source": [ + "class QuantizedResNet18(nn.Module):\n", + " def __init__(self, model_fp32):\n", + "\n", + " super(QuantizedResNet18, self).__init__()\n", + " # QuantStub converts tensors from floating point to quantized.\n", + " # This will only be used for inputs.\n", + " self.quant = torch.quantization.QuantStub()\n", + " # DeQuantStub converts tensors from quantized to floating point.\n", + " # This will only be used for outputs.\n", + " self.dequant = torch.quantization.DeQuantStub()\n", + " # FP32 model\n", + " self.model_fp32 = model_fp32\n", + "\n", + " def forward(self, x):\n", + " # manually specify where tensors will be converted from floating\n", + " # point to quantized in the quantized model\n", + " x = self.quant(x)\n", + " x = self.model_fp32(x)\n", + " # manually specify where tensors will be converted from quantized\n", + " # to floating point in the quantized model\n", + " x = self.dequant(x)\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Maha Kosksi\\AppData\\Roaming\\Python\\Python311\\site-packages\\torch\\ao\\quantization\\utils.py:317: UserWarning: must run observer before calling calculate_qparams. Returning default values.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "----------\n", + "train Loss: 1.7641 Acc: 0.5574\n", + "val Loss: 0.3584 Acc: 0.8889\n", + "\n", + "Epoch 2/10\n", + "----------\n", + "train Loss: 0.6037 Acc: 0.7254\n", + "val Loss: 0.2845 Acc: 0.9150\n", + "\n", + "Epoch 3/10\n", + "----------\n", + "train Loss: 0.4551 Acc: 0.7910\n", + "val Loss: 0.2543 Acc: 0.9216\n", + "\n", + "Epoch 4/10\n", + "----------\n", + "train Loss: 0.5546 Acc: 0.8033\n", + "val Loss: 0.2647 Acc: 0.9216\n", + "\n", + "Epoch 5/10\n", + "----------\n", + "train Loss: 0.5776 Acc: 0.7705\n", + "val Loss: 0.3787 Acc: 0.8758\n", + "\n", + "Epoch 6/10\n", + "----------\n", + "train Loss: 0.3114 Acc: 0.8689\n", + "val Loss: 0.2264 Acc: 0.9346\n", + "\n", + "Epoch 7/10\n", + "----------\n", + "train Loss: 0.3441 Acc: 0.8607\n", + "val Loss: 0.2690 Acc: 0.9281\n", + "\n", + "Epoch 8/10\n", + "----------\n", + "train Loss: 0.4496 Acc: 0.8197\n", + "val Loss: 0.2658 Acc: 0.9346\n", + "\n", + "Epoch 9/10\n", + "----------\n", + "train Loss: 0.4247 Acc: 0.8279\n", + "val Loss: 0.2423 Acc: 0.9346\n", + "\n", + "Epoch 10/10\n", + "----------\n", + "train Loss: 0.3851 Acc: 0.8484\n", + "val Loss: 0.2451 Acc: 0.9477\n", + "\n", + "Training complete in 9m 15s\n", + "Best val Acc: 0.947712\n" + ] + } + ], + "source": [ + "import copy\n", + "import torch.quantization.quantize_fx as quantize_fx\n", + "model = torchvision.models.resnet18(pretrained=True)\n", + "\n", + "model_fp=QuantizedResNet18(model)\n", + "\n", + "model_fp.train()\n", + "model_to_quantize = copy.deepcopy(model_fp)\n", + "model.qconfig = torch.quantization.get_default_qat_qconfig(\"qnnpack\")\n", + "model_qat = torch.quantization.prepare_qat(model_fp, inplace=False)\n", + "# quantization aware training goes here\n", + "model_qat = torch.quantization.convert(model_qat.eval(), inplace=False)\n", + "n_epochs=30\n", + "criterion = nn.CrossEntropyLoss() # specify loss function\n", + "optimizer = optim.SGD(model_qat.parameters(), lr=0.01) # specify optimizer\n", + "optimizer_conv = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)\n", + "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)\n", + "model, epoch_time = train_model(\n", + " model, criterion, optimizer_conv, exp_lr_scheduler, num_epochs=10\n", + ")" ] }, { @@ -940,7 +3227,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.11.1" }, "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 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 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 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 literal 0 HcmV?d00001 diff --git a/tench.png b/tench.png new file mode 100644 index 0000000000000000000000000000000000000000..d2e7279b3533e564c1994dcc572c338df623f4d3 GIT binary patch literal 152194 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%0AHtzz$Z1sx8HBVm7_40AD`d!tz>Rxg`!$NJt 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⁢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⁢~eZ`M} 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%0DxSV@aYa{!;D68*#w{K5> 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 NJYD@<);T3K0RS6=!-4<+ literal 0 HcmV?d00001 -- GitLab