diff --git a/TD2 Deep Learning - Modifications.ipynb b/TD2 Deep Learning - Modifications.ipynb
index 6cadeb1aa085de7c161b24df21bf66b90a0f5127..955c7267a5d3262f2ed6728129e16e8f73b5d891 100644
--- a/TD2 Deep Learning - Modifications.ipynb
+++ b/TD2 Deep Learning - Modifications.ipynb
@@ -10,160 +10,47 @@
},
{
"cell_type": "markdown",
- "id": "fbb8c8df",
+ "id": "23f266da",
"metadata": {},
"source": [
- "In this TD, you must modify this notebook to answer the questions. To do this,\n",
- "\n",
- "1. Fork this repository\n",
- "2. Clone your forked repository on your local computer\n",
- "3. Answer the questions\n",
- "4. Commit and push regularly\n",
- "\n",
- "The last commit is due on Sunday, December 1, 11:59 PM. Later commits will not be taken into account."
+ "## Exercise 1: CNN on CIFAR10"
]
},
{
"cell_type": "markdown",
- "id": "3d167a29",
+ "id": "4ba1c82d",
"metadata": {},
"source": [
- "Install and test PyTorch from https://pytorch.org/get-started/locally."
+ "Importing matplotlib before torch to avoid kernel to crash."
]
},
{
"cell_type": "code",
- "execution_count": null,
- "id": "330a42f5",
+ "execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
- "%pip install torch torchvision"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "0882a636",
- "metadata": {},
- "source": [
- "\n",
- "To test run the following code"
+ "import matplotlib.pyplot as plt"
]
},
{
"cell_type": "code",
- "execution_count": 1,
- "id": "b1950f0a",
+ "execution_count": 17,
+ "id": "6e18f2fd",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "tensor([[ 1.2152, 0.3670, 1.4724, 0.6574, -1.1470, 0.1384, -0.2122, -0.2540,\n",
- " -0.5946, 1.4338],\n",
- " [-0.9999, -0.4958, -0.7781, -1.3471, 1.4822, -0.6562, -1.5544, -0.0770,\n",
- " 0.7636, -0.6855],\n",
- " [-1.3101, 2.7463, -0.7688, -1.6940, 0.3552, -1.8348, -0.0332, 0.3274,\n",
- " -0.3457, -1.0419],\n",
- " [ 1.0307, -0.3965, 0.4003, 0.1125, 1.6926, -0.9130, 1.3309, 0.6459,\n",
- " 0.3604, 1.5173],\n",
- " [ 0.7499, 0.2977, 0.1724, -0.5378, -1.3688, -0.1464, 1.2683, 0.1289,\n",
- " 0.3752, 0.4581],\n",
- " [ 0.3065, -1.9399, -0.9450, -0.4325, -0.4795, -0.0654, 0.2026, 2.1386,\n",
- " 1.2124, -0.3596],\n",
- " [ 0.1435, -1.2549, 0.5267, 0.7166, 0.5016, 0.4083, -1.6958, -0.4954,\n",
- " 0.0137, 0.5876],\n",
- " [ 0.3211, 0.7731, 0.5658, -0.5253, -0.8105, -0.7658, 0.8030, 0.2201,\n",
- " -0.5437, 1.8546],\n",
- " [ 0.8188, -0.7614, -1.0847, -2.3338, 1.3845, 0.3507, 0.6594, 0.0203,\n",
- " -0.5632, -0.8828],\n",
- " [ 0.6672, -0.6090, 1.6467, -0.2667, -1.6417, 0.9440, 0.9482, -0.4426,\n",
- " -0.3587, 1.9819],\n",
- " [ 0.9627, -0.0084, 0.8293, -0.7658, -0.0055, 0.7720, 1.2134, 1.6272,\n",
- " -0.3042, 1.5390],\n",
- " [ 0.7760, -0.3414, -0.6955, 0.2269, 0.5333, 1.1075, -1.6572, -0.7557,\n",
- " 1.2431, -1.1733],\n",
- " [ 0.2489, -1.2784, 0.4107, -0.1329, 1.2123, 0.2058, -1.8864, 0.3815,\n",
- " -0.4064, -0.5395],\n",
- " [ 1.5754, 0.5068, 0.3330, 0.0316, 0.4159, 1.0519, 1.8176, 0.6531,\n",
- " 0.7915, -0.5090]])\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"
+ "CUDA is not available. Training on CPU ...\n"
]
}
],
"source": [
"import torch\n",
- "\n",
- "N, D = 14, 10\n",
- "x = torch.randn(N, D).type(torch.FloatTensor)\n",
- "print(x)\n",
- "\n",
"from torchvision import models\n",
"\n",
- "alexnet = models.alexnet()\n",
- "print(alexnet)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "23f266da",
- "metadata": {},
- "source": [
- "## Exercise 1: CNN on CIFAR10\n",
- "\n",
- "The goal is to apply a Convolutional Neural Net (CNN) model on the CIFAR10 image dataset and test the accuracy of the model on the basis of image classification. Compare the Accuracy VS the neural network implemented during TD1.\n",
- "\n",
- "Have a look at the following documentation to be familiar with PyTorch.\n",
- "\n",
- "https://pytorch.org/tutorials/beginner/pytorch_with_examples.html\n",
- "\n",
- "https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "4ba1c82d",
- "metadata": {},
- "source": [
- "You can test if GPU is available on your machine and thus train on it to speed up the process"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "6e18f2fd",
- "metadata": {},
- "outputs": [],
- "source": [
- "import torch\n",
- "\n",
"# check if CUDA is available\n",
"train_on_gpu = torch.cuda.is_available()\n",
"\n",
@@ -185,10 +72,19 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 5,
"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",
@@ -252,15 +148,33 @@
"id": "58ec3903",
"metadata": {},
"source": [
- "CNN definition (this one is an example)"
+ "Defining the CNN model."
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 7,
"id": "317bf070",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Net(\n",
+ " (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+ " (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+ " (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+ " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+ " (fc1): Linear(in_features=1024, out_features=512, bias=True)\n",
+ " (dropout1): Dropout(p=0.01, inplace=False)\n",
+ " (fc2): Linear(in_features=512, out_features=64, bias=True)\n",
+ " (dropout2): Dropout(p=0.01, inplace=False)\n",
+ " (fc3): Linear(in_features=64, out_features=10, bias=True)\n",
+ ")\n"
+ ]
+ }
+ ],
"source": [
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
@@ -271,21 +185,23 @@
"class Net(nn.Module):\n",
" def __init__(self):\n",
" super(Net, self).__init__()\n",
- " self.conv1 = nn.Conv2d(3, 16, 5)\n",
- " self.conv2 = nn.Conv2d(16, 32, 5)\n",
- " self.conv3 = nn.Conv2d(32, 64, 5)\n",
- " self.pool = nn.MaxPool2d(2, 2) \n",
- " self.fc1 = nn.Linear(64 * 5 * 5, 512)\n",
+ " self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)\n",
+ " self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
+ " self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+ " self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
+ " self.fc1 = nn.Linear(64 * 4 * 4, 512)\n",
+ " self.dropout1 = nn.Dropout(p = 0.01) #p = probability of an element to be equal to 0.\n",
" self.fc2 = nn.Linear(512, 64)\n",
+ " self.dropout2 = nn.Dropout(p = 0.01)\n",
" self.fc3 = nn.Linear(64, 10)\n",
"\n",
" def forward(self, x):\n",
" x = self.pool(F.relu(self.conv1(x)))\n",
" x = self.pool(F.relu(self.conv2(x)))\n",
" x = self.pool(F.relu(self.conv3(x)))\n",
- " x = x.view(-1, 64 * 5 * 5)\n",
- " x = F.relu(self.fc1(x))\n",
- " x = F.relu(self.fc2(x))\n",
+ " x = x.view(-1, 64*4*4)\n",
+ " x = self.dropout1(F.relu(self.fc1(x)))\n",
+ " x = self.dropout2(F.relu(self.fc2(x)))\n",
" x = self.fc3(x)\n",
" return x\n",
"\n",
@@ -303,22 +219,31 @@
"id": "a2dc4974",
"metadata": {},
"source": [
- "Loss function and training using SGD (Stochastic Gradient Descent) optimizer"
+ "Training using SGD (Stochastic Gradient Descent) optimizer."
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 8,
"id": "4b53f229",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: 0 \tTraining Loss: 45.052960 \tValidation Loss: 40.418226\n",
+ "Validation loss decreased (inf --> 40.418226). Saving model ...\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",
+ "n_epochs = 1 # 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",
@@ -387,15 +312,26 @@
"id": "13e1df74",
"metadata": {},
"source": [
- "Does overfit occur? If so, do an early stopping."
+ "Plotting the loss over the number of epoch."
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 9,
"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",
@@ -411,93 +347,118 @@
"id": "11df8fd4",
"metadata": {},
"source": [
- "Now loading the model with the lowest validation loss value\n"
+ "Computing the accuracy of the new model.\n"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 10,
"id": "e93efdfc",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Test Loss: 40.275133\n",
+ "\n",
+ "Test Accuracy of airplane: 49% (493/1000)\n",
+ "Test Accuracy of automobile: 37% (375/1000)\n",
+ "Test Accuracy of bird: 3% (34/1000)\n",
+ "Test Accuracy of cat: 0% ( 1/1000)\n",
+ "Test Accuracy of deer: 0% ( 5/1000)\n",
+ "Test Accuracy of dog: 31% (319/1000)\n",
+ "Test Accuracy of frog: 75% (759/1000)\n",
+ "Test Accuracy of horse: 4% (42/1000)\n",
+ "Test Accuracy of ship: 30% (307/1000)\n",
+ "Test Accuracy of truck: 30% (307/1000)\n",
+ "\n",
+ "Test Accuracy (Overall): 26% (2642/10000)\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "([0.493, 0.375, 0.034, 0.001, 0.005, 0.319, 0.759, 0.042, 0.307, 0.307],\n",
+ " 0.2642)"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"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",
+ "def test_accuracy(model_to_evaluate):\n",
+ " \"\"\"\n",
+ " Return the percentage of True Positive data of each class for a model.\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_to_evaluate.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_to_evaluate(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",
+ " percentage_true_positive = []\n",
+ " for i in range(10):\n",
+ " \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",
+ " percentage_true_positive.append(np.sum(class_correct[i]) / class_total[i])\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",
- " else:\n",
- " print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n",
- "\n",
- "print(\n",
- " \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n",
- " % (\n",
- " 100.0 * np.sum(class_correct) / np.sum(class_total),\n",
- " np.sum(class_correct),\n",
- " np.sum(class_total),\n",
" )\n",
- ")"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "944991a2",
- "metadata": {},
- "source": [
- "Build a new network with the following structure.\n",
- "\n",
- "- It has 3 convolutional layers of kernel size 3 and padding of 1.\n",
- "- The first convolutional layer must output 16 channels, the second 32 and the third 64.\n",
- "- At each convolutional layer output, we apply a ReLU activation then a MaxPool with kernel size of 2.\n",
- "- Then, three fully connected layers, the first two being followed by a ReLU activation and a dropout whose value you will suggest.\n",
- "- The first fully connected layer will have an output size of 512.\n",
- "- The second fully connected layer will have an output size of 64.\n",
+ " percentage_overall = np.sum(class_correct) / np.sum(class_total)\n",
+ " return percentage_true_positive, percentage_overall\n",
"\n",
- "Compare the results obtained with this new network to those obtained previously."
+ "test_accuracy(model)"
]
},
{
@@ -505,22 +466,33 @@
"id": "bc381cf4",
"metadata": {},
"source": [
- "## Exercise 2: Quantization: try to compress the CNN to save space\n",
- "\n",
- "Quantization doc is available from https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic\n",
- " \n",
- "The Exercise is to quantize post training the above CNN model. Compare the size reduction and the impact on the classification accuracy \n",
- "\n",
- "\n",
- "The size of the model is simply the size of the file."
+ "## Exercise 2: Quantization: try to compress the CNN to save space"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 11,
"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": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
"import os\n",
"\n",
@@ -546,10 +518,28 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 12,
"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": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
"import torch.quantization\n",
"\n",
@@ -567,11 +557,67 @@
]
},
{
- "cell_type": "markdown",
- "id": "a0a34b90",
+ "cell_type": "code",
+ "execution_count": 16,
"metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Test Loss: 40.275133\n",
+ "\n",
+ "Test Accuracy of airplane: 49% (493/1000)\n",
+ "Test Accuracy of automobile: 37% (375/1000)\n",
+ "Test Accuracy of bird: 3% (34/1000)\n",
+ "Test Accuracy of cat: 0% ( 1/1000)\n",
+ "Test Accuracy of deer: 0% ( 5/1000)\n",
+ "Test Accuracy of dog: 31% (319/1000)\n",
+ "Test Accuracy of frog: 75% (759/1000)\n",
+ "Test Accuracy of horse: 4% (42/1000)\n",
+ "Test Accuracy of ship: 30% (307/1000)\n",
+ "Test Accuracy of truck: 30% (307/1000)\n",
+ "\n",
+ "Test Accuracy (Overall): 26% (2642/10000)\n",
+ "Test Loss: 40.275133\n",
+ "\n",
+ "Test Accuracy of airplane: 49% (493/1000)\n",
+ "Test Accuracy of automobile: 37% (375/1000)\n",
+ "Test Accuracy of bird: 3% (34/1000)\n",
+ "Test Accuracy of cat: 0% ( 1/1000)\n",
+ "Test Accuracy of deer: 0% ( 5/1000)\n",
+ "Test Accuracy of dog: 31% (319/1000)\n",
+ "Test Accuracy of frog: 75% (759/1000)\n",
+ "Test Accuracy of horse: 4% (42/1000)\n",
+ "Test Accuracy of ship: 30% (307/1000)\n",
+ "Test Accuracy of truck: 30% (307/1000)\n",
+ "\n",
+ "Test Accuracy (Overall): 26% (2642/10000)\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
"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)"
+ "percentage_each_class_initial_model, percentage_overall_initial_model = test_accuracy(model)\n",
+ "percentage_each_class_quantized_model, percentage_overall_quantized_model = test_accuracy(model)\n",
+ "x = [1,2,3,4,5,6,7,8,9,10]\n",
+ "plt.scatter(x, percentage_each_class_initial_model, color='r', label=\"initial model\")\n",
+ "plt.scatter(x, percentage_each_class_quantized_model, color='b', label=\"quantized model\")\n",
+ "plt.xlabel(\"Classes\")\n",
+ "plt.ylabel(\"Percentage of true positive for each model\")\n",
+ "plt.title(\"comparis between itinial and quantized model\")\n",
+ "plt.xticks(x, x)\n",
+ "plt.legend()\n",
+ "plt.show()\n"
]
},
{
diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb
index a75e5831a1e5fc066adaff59ce2b89ddc9819374..ab0a72119f6b9074843af30e433df60ceac85669 100644
--- a/TD2 Deep Learning.ipynb
+++ b/TD2 Deep Learning.ipynb
@@ -33,7 +33,7 @@
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": 1,
"id": "330a42f5",
"metadata": {},
"outputs": [],
@@ -52,10 +52,72 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 1,
"id": "b1950f0a",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[ 3.5952e-02, 1.5850e+00, -6.1439e-01, -1.8454e+00, 1.5693e+00,\n",
+ " -1.0824e+00, -3.7289e-01, -2.1153e-01, -1.6742e+00, 1.3601e-01],\n",
+ " [-2.7437e+00, -2.6916e+00, 1.3533e-01, 1.1285e+00, -1.1632e+00,\n",
+ " 3.3866e-01, 3.4433e-01, -1.5130e+00, -9.3060e-02, 2.3610e-02],\n",
+ " [ 5.5523e-01, 1.3594e+00, -6.4875e-01, 8.5343e-01, 2.3547e-01,\n",
+ " -1.3069e+00, -8.9231e-01, 4.8508e-01, -3.0876e-01, -1.6876e+00],\n",
+ " [-5.8294e-01, -3.2342e-01, 1.1461e+00, 4.3821e-01, 1.0372e-01,\n",
+ " 8.8310e-01, 4.1910e-01, 1.6699e-01, -4.1339e-01, 3.8288e-01],\n",
+ " [ 3.1609e-01, 4.9072e-02, 2.5041e-01, 8.7993e-01, -1.0776e+00,\n",
+ " -1.8168e+00, -7.1222e-01, 4.9301e-01, -3.1248e-01, 2.4786e-01],\n",
+ " [ 5.5113e-01, -6.3463e-02, -7.5762e-01, -3.3491e-01, 1.6080e+00,\n",
+ " -5.8469e-01, -5.2522e-01, -4.0390e-01, 1.9460e-01, -3.9486e-02],\n",
+ " [ 7.8967e-01, 1.0366e-01, 9.1126e-01, 4.6190e-02, -9.2092e-01,\n",
+ " -6.8794e-02, 1.3282e+00, -1.9440e-01, 9.2454e-01, -1.0689e+00],\n",
+ " [ 3.7633e-01, -1.5810e-01, -2.0268e-01, 2.0838e+00, -5.1147e-01,\n",
+ " -6.4326e-01, 1.3969e-01, 1.5354e+00, 1.2074e+00, -2.5025e-01],\n",
+ " [-1.9491e-03, -1.1078e+00, 1.0198e+00, -8.2351e-01, -5.2787e-01,\n",
+ " -1.2990e+00, 1.3976e-01, 1.0703e+00, 1.3790e+00, -3.8714e-01],\n",
+ " [ 6.0412e-01, -6.4909e-01, 3.2755e-04, 7.3678e-01, -3.3949e-01,\n",
+ " 1.3958e+00, -5.6852e-01, -6.7470e-01, -2.6016e-01, -2.3779e+00],\n",
+ " [ 6.9705e-01, -4.7411e-01, 2.3302e-01, -2.0634e-01, 1.9855e+00,\n",
+ " 5.6177e-02, 4.8835e-01, -8.6410e-01, -7.4032e-01, 9.6845e-01],\n",
+ " [-7.6496e-01, 1.3892e+00, 6.6274e-01, -6.8691e-01, -4.9880e-01,\n",
+ " 8.3306e-01, -1.5698e+00, 1.2847e+00, -8.4168e-01, 3.2569e-01],\n",
+ " [-2.0578e+00, 1.3907e+00, -6.2604e-01, 7.7819e-01, -1.2116e-02,\n",
+ " -1.7752e+00, -5.5279e-01, 2.2114e-01, -1.5261e-01, -2.1155e+00],\n",
+ " [-2.4226e+00, -1.9817e+00, -2.0580e-01, 5.2790e-02, 3.4320e-02,\n",
+ " -7.5778e-02, 1.1910e+00, 1.8493e-01, -8.0021e-01, 7.8425e-02]])\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",
@@ -96,6 +158,30 @@
{
"cell_type": "code",
"execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGxCAYAAABBZ+3pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAoJklEQVR4nO3df3RU5YH/8c+QTGYiJNPwKyESEmArPwQsBAsEU8RKQsQUuqigFqGnckyPll/rFkJxiXAMCErRQkADSF27QOVX0bK7ogKiieaEEkRCYRFCKCayoZoEqCE/nu8ffjPrkAQzkMCT+H6dM+d0nnnunede0bx7505wGGOMAAAALNbmRi8AAADg2xAsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLEALlJWVpbS0NH355ZfN+j4ZGRlav359s77H1WiK4y8oKJDD4biq48vPz1daWpoKCgrqvDZlyhTFxMT4jMXExGjKlCne53v27JHD4dDmzZv9fm/gu4pgAVqgrKwsPf3009/pYLkex9+Q/Px8Pf300/UGS322bdump556qnkXBbRygTd6AQDQ2g0cOPBGLwFo8bjCArQwaWlp+td//VdJUvfu3eVwOORwOLRnzx7vnE2bNmnYsGFq27at2rVrp8TERB04cMBnPydOnNDEiRMVGRkpl8ul8PBw/fjHP1ZeXp6krz/GOHz4sPbu3et9j8s/6ricw+HQE088oVdeeUW9evVScHCwBg8erA8//FDGGC1dulTdu3dXu3btdNddd+n48eM+2+/atUtjx45V165d5Xa79U//9E967LHHVFJS0ujjj4mJ0b333qtt27ZpwIABcrvd6tGjh1588cVGnd/3339fP/7xjxUSEqKbbrpJcXFx+vOf/+x9ff369br//vslSSNHjvS+/5WuRF3+kVCtr776SrNmzVJERISCg4M1YsSIOv+cAHyNKyxAC/Poo4/q73//u373u99p69at6tKliySpb9++kqT09HTNmzdPP//5zzVv3jxdunRJS5cuVXx8vHJycrzz7rnnHlVXV2vJkiXq1q2bSkpKlJWV5f2YZdu2bbrvvvvk8XiUkZEhSXK5XN+6vjfffFMHDhzQ4sWL5XA4NHv2bI0ZM0aTJ0/WiRMntGLFCpWWlmrWrFkaP3688vLy5HA4JEmffvqphg0bpkcffVQej0cFBQVatmyZ7rjjDh06dEhOp/Nbj1+S8vLyNGPGDKWlpSkiIkJ/+MMfNH36dF26dElPPvlkg2vfu3evRo0apQEDBmjt2rVyuVzKyMhQcnKyNmzYoAkTJmjMmDFKT0/X3LlztXLlSg0aNEiS1LNnT3/+MUqS5s6dq0GDBmnNmjUqLS1VWlqa7rzzTh04cEA9evTwe39Aq2YAtDhLly41kszJkyd9xgsLC01gYKD51a9+5TNeXl5uIiIizAMPPGCMMaakpMRIMsuXL7/i+9x6661mxIgRjV6XJBMREWHOnz/vHdu+fbuRZH7wgx+Ympoa7/jy5cuNJPPxxx/Xu6+amhpTWVlpTp06ZSSZP/3pT97XGjp+Y4yJjo42DofD5OXl+YyPGjXKhIaGmgsXLhhjjDl58qSRZF555RXvnKFDh5rOnTub8vJy71hVVZXp16+f6dq1q3f9r7/+upFkdu/eXef9J0+ebKKjo+usafLkyd7nu3fvNpLMoEGDfM5JQUGBcTqd5tFHH633nADfZXwkBLQi//3f/62qqio98sgjqqqq8j7cbrdGjBjh/dikffv26tmzp5YuXaply5bpwIEDqqmpaZI1jBw5Um3btvU+79OnjyQpKSnJeyXlm+OnTp3yjp09e1YpKSmKiopSYGCgnE6noqOjJUlHjhxp9BpuvfVW3XbbbT5jDz30kMrKyvSXv/yl3m0uXLigjz76SPfdd5/atWvnHQ8ICNCkSZP0t7/9TUePHm30GhrjoYce8jkn0dHRiouL0+7du5v0fYDWgGABWpHPP/9cknT77bfL6XT6PDZt2uS9F8ThcOidd95RYmKilixZokGDBqlTp06aNm2aysvLr2kN7du393keFBR0xfGvvvpKklRTU6OEhARt3bpVv/71r/XOO+8oJydHH374oSTpH//4R6PXEBER0eDYuXPn6t3miy++kDHG+xHTN0VGRl5x26vV0Dqb+n2A1oB7WIBWpGPHjpKkzZs3e69MNCQ6Olpr166VJB07dkx//OMflZaWpkuXLmn16tXNvtbLffLJJzp48KDWr1+vyZMne8cvvzG3MYqLixsc69ChQ73bhIWFqU2bNioqKqrz2meffSbp/85vU2lonQ2tEfgu4woL0ALV3vx6+VWHxMREBQYG6tNPP9XgwYPrfdTnlltu0bx589S/f3+fj0xcLpdfVzauRe1HI5ff2PvSSy/VmdvQ8dc6fPiwDh486DP2H//xHwoJCfHeJHu5tm3basiQIdq6davPfmtqavTaa6+pa9euuuWWWxr1/o21YcMGGWO8z0+dOqWsrCzdeeed17RfoDXiCgvQAvXv31+S9MILL2jy5MlyOp3q1auXYmJitGDBAv3mN7/RiRMnNHr0aIWFhenzzz9XTk6O2rZtq6effloff/yxnnjiCd1///36/ve/r6CgIL377rv6+OOPNWfOHJ/32bhxozZt2qQePXrI7XZ737up9e7dWz179tScOXNkjFH79u31xhtvaNeuXY0+/pCQEElff4Tzk5/8RGlpaerSpYtee+017dq1S88++6xuuummBtewaNEijRo1SiNHjtSTTz6poKAgZWRk6JNPPtGGDRu8UdWvXz9J0ssvv6yQkBC53W51797d7ysjZ8+e1U9/+lNNnTpVpaWlmj9/vtxut1JTU/3aD/CdcINv+gVwlVJTU01kZKRp06ZNnW+sbN++3YwcOdKEhoYal8tloqOjzX333WfefvttY4wxn3/+uZkyZYrp3bu3adu2rWnXrp0ZMGCA+e1vf2uqqqq8+ykoKDAJCQkmJCTESKrz7ZfLSTKPP/64z1jtt3GWLl3qM177TZnXX3/dO5afn29GjRplQkJCTFhYmLn//vtNYWGhkWTmz5/fqOOPjo42Y8aMMZs3bza33nqrCQoKMjExMWbZsmX1ruub3xIyxph9+/aZu+66y7Rt29YEBweboUOHmjfeeKPOsS5fvtx0797dBAQE+OzHn28J/fu//7uZNm2a6dSpk3G5XCY+Pt7k5uY2cHaB7zaHMd+4HgkALVxMTIz69eunN99880YvBUAT4h4WAABgPYIFAABYj4+EAACA9bjCAgAArEewAAAA6xEsAADAeq3mF8fV1NTos88+U0hIiM9fJgYAAOxljFF5ebkiIyPVpk3D11FaTbB89tlnioqKutHLAAAAV+H06dPq2rVrg6+3mmCp/ZXcp0+fVmho6A1eDQAAaIyysjJFRUV5f443pNUES+3HQKGhoQQLAAAtzLfdzsFNtwAAwHoECwAAsB7BAgAArEewAAAA6xEsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLAAAwHoECwAAsB7BAgAArEewAAAA6xEsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLAAAwHoECwAAsB7BAgAArEewAAAA6xEsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLAAAwHoECwAAsB7BAgAArEewAAAA6xEsAADAegQLAACwHsECAACs53ewvPfee0pOTlZkZKQcDoe2b9/+rdvs3btXsbGxcrvd6tGjh1avXt3g3I0bN8rhcGjcuHH+Lg0AALRSfgfLhQsXdNttt2nFihWNmn/y5Endc889io+P14EDBzR37lxNmzZNW7ZsqTP31KlTevLJJxUfH+/vsgAAQCsW6O8GSUlJSkpKavT81atXq1u3blq+fLkkqU+fPsrNzdVzzz2n8ePHe+dVV1fr4Ycf1tNPP619+/bpyy+/9HdpAACglWr2e1iys7OVkJDgM5aYmKjc3FxVVlZ6xxYsWKBOnTrpF7/4RaP2W1FRobKyMp8HAABonZo9WIqLixUeHu4zFh4erqqqKpWUlEiSPvjgA61du1aZmZmN3u+iRYvk8Xi8j6ioqCZdNwAAsMd1+ZaQw+HweW6M8Y6Xl5frZz/7mTIzM9WxY8dG7zM1NVWlpaXex+nTp5t0zQAAwB5+38Pir4iICBUXF/uMnT17VoGBgerQoYMOHz6sgoICJScne1+vqan5enGBgTp69Kh69uxZZ78ul0sul6t5Fw8AAKzQ7MEybNgwvfHGGz5jb731lgYPHiyn06nevXvr0KFDPq/PmzdP5eXleuGFF/ioBwAA+B8s58+f1/Hjx73PT548qby8PLVv317dunVTamqqzpw5o1dffVWSlJKSohUrVmjWrFmaOnWqsrOztXbtWm3YsEGS5Ha71a9fP5/3+N73vidJdcYBAMB3k9/Bkpubq5EjR3qfz5o1S5I0efJkrV+/XkVFRSosLPS+3r17d+3cuVMzZ87UypUrFRkZqRdffNHnK80AAABX4jC1d8C2cGVlZfJ4PCotLVVoaOiNXg4AAGiExv785u8SAgAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFiPYAEAANYjWAAAgPUIFgAAYD2CBQAAWI9gAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFiPYAEAANYjWAAAgPUIFgAAYD2CBQAAWI9gAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFiPYAEAANYjWAAAgPUIFgAAYD2CBQAAWI9gAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFiPYAEAANYjWAAAgPUIFgAAYD2CBQAAWI9gAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFjP72B57733lJycrMjISDkcDm3fvv1bt9m7d69iY2PldrvVo0cPrV692uf1zMxMxcfHKywsTGFhYbr77ruVk5Pj79IAAEAr5XewXLhwQbfddptWrFjRqPknT57UPffco/j4eB04cEBz587VtGnTtGXLFu+cPXv26MEHH9Tu3buVnZ2tbt26KSEhQWfOnPF3eQAAoBVyGGPMVW/scGjbtm0aN25cg3Nmz56tHTt26MiRI96xlJQUHTx4UNnZ2fVuU11drbCwMK1YsUKPPPJIo9ZSVlYmj8ej0tJShYaG+nUcAADgxmjsz+9mv4clOztbCQkJPmOJiYnKzc1VZWVlvdtcvHhRlZWVat++fYP7raioUFlZmc8DAAC0Ts0eLMXFxQoPD/cZCw8PV1VVlUpKSurdZs6cObr55pt19913N7jfRYsWyePxeB9RUVFNum4AAGCP6/ItIYfD4fO89lOoy8clacmSJdqwYYO2bt0qt9vd4D5TU1NVWlrqfZw+fbppFw0AAKwR2NxvEBERoeLiYp+xs2fPKjAwUB06dPAZf+6555Senq63335bAwYMuOJ+XS6XXC5Xk68XAADYp9mvsAwbNky7du3yGXvrrbc0ePBgOZ1O79jSpUu1cOFC/dd//ZcGDx7c3MsCAAAtiN/Bcv78eeXl5SkvL0/S119bzsvLU2FhoaSvP6r55jd7UlJSdOrUKc2aNUtHjhzRunXrtHbtWj355JPeOUuWLNG8efO0bt06xcTEqLi4WMXFxTp//vw1Hh4AAGgN/P5a8549ezRy5Mg645MnT9b69es1ZcoUFRQUaM+ePd7X9u7dq5kzZ+rw4cOKjIzU7NmzlZKS4n09JiZGp06dqrPP+fPnKy0trVHr4mvNAAC0PI39+X1Nv4fFJgQLAAAtjzW/hwUAAOBaESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLAAAwHoECwAAsB7BAgAArEewAAAA6xEsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLAAAwHoECwAAsB7BAgAArEewAAAA6xEsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLAAAwHoECwAAsB7BAgAArEewAAAA6xEsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLAAAwHoECwAAsB7BAgAArEewAAAA6xEsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLAAAwHoECwAAsB7BAgAArEewAAAA6/kdLO+9956Sk5MVGRkph8Oh7du3f+s2e/fuVWxsrNxut3r06KHVq1fXmbNlyxb17dtXLpdLffv21bZt2/xdGgAAaKX8DpYLFy7otttu04oVKxo1/+TJk7rnnnsUHx+vAwcOaO7cuZo2bZq2bNninZOdna0JEyZo0qRJOnjwoCZNmqQHHnhAH330kb/LAwAArZDDGGOuemOHQ9u2bdO4ceManDN79mzt2LFDR44c8Y6lpKTo4MGDys7OliRNmDBBZWVl+s///E/vnNGjRyssLEwbNmyod78VFRWqqKjwPi8rK1NUVJRKS0sVGhp6tYcEAACuo7KyMnk8nm/9+d3s97BkZ2crISHBZywxMVG5ubmqrKy84pysrKwG97to0SJ5PB7vIyoqqukXDwAArNDswVJcXKzw8HCfsfDwcFVVVamkpOSKc4qLixvcb2pqqkpLS72P06dPN/3iAQCAFQKvx5s4HA6f57WfQn1zvL45l499k8vlksvlasJVAgAAWzX7FZaIiIg6V0rOnj2rwMBAdejQ4YpzLr/qAgAAvpuaPViGDRumXbt2+Yy99dZbGjx4sJxO5xXnxMXFNffyAABAC+D3R0Lnz5/X8ePHvc9PnjypvLw8tW/fXt26dVNqaqrOnDmjV199VdLX3whasWKFZs2apalTpyo7O1tr1671+fbP9OnT9aMf/UjPPvusxo4dqz/96U96++239f777zfBIQIAgJbO7yssubm5GjhwoAYOHChJmjVrlgYOHKh/+7d/kyQVFRWpsLDQO7979+7auXOn9uzZox/84AdauHChXnzxRY0fP947Jy4uThs3btQrr7yiAQMGaP369dq0aZOGDBlyrccHAABagWv6PSw2aez3uAEAgD2s+T0sAAAA14pgAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFiPYAEAANYjWAAAgPUIFgAAYD2CBQAAWI9gAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFiPYAEAANYjWAAAgPUIFgAAYD2CBQAAWI9gAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFiPYAEAANYjWAAAgPUIFgAAYD2CBQAAWI9gAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFiPYAEAANYjWAAAgPUIFgAAYD2CBQAAWI9gAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGC9qwqWjIwMde/eXW63W7Gxsdq3b98V569cuVJ9+vRRcHCwevXqpVdffbXOnOXLl6tXr14KDg5WVFSUZs6cqa+++upqlgcAAFqZQH832LRpk2bMmKGMjAwNHz5cL730kpKSkpSfn69u3brVmb9q1SqlpqYqMzNTt99+u3JycjR16lSFhYUpOTlZkvSHP/xBc+bM0bp16xQXF6djx45pypQpkqTf/va313aEAACgxXMYY4w/GwwZMkSDBg3SqlWrvGN9+vTRuHHjtGjRojrz4+LiNHz4cC1dutQ7NmPGDOXm5ur999+XJD3xxBM6cuSI3nnnHe+cf/mXf1FOTs63Xr2pVVZWJo/Ho9LSUoWGhvpzSAAA4AZp7M9vvz4SunTpkvbv36+EhASf8YSEBGVlZdW7TUVFhdxut89YcHCwcnJyVFlZKUm64447tH//fuXk5EiSTpw4oZ07d2rMmDENrqWiokJlZWU+DwAA0Dr5FSwlJSWqrq5WeHi4z3h4eLiKi4vr3SYxMVFr1qzR/v37ZYxRbm6u1q1bp8rKSpWUlEiSJk6cqIULF+qOO+6Q0+lUz549NXLkSM2ZM6fBtSxatEgej8f7iIqK8udQAABAC3JVN906HA6f58aYOmO1nnrqKSUlJWno0KFyOp0aO3as9/6UgIAASdKePXv0zDPPKCMjQ3/5y1+0detWvfnmm1q4cGGDa0hNTVVpaan3cfr06as5FAAA0AL4FSwdO3ZUQEBAnaspZ8+erXPVpVZwcLDWrVunixcvqqCgQIWFhYqJiVFISIg6duwo6euomTRpkh599FH1799fP/3pT5Wenq5Fixappqam3v26XC6Fhob6PAAAQOvkV7AEBQUpNjZWu3bt8hnftWuX4uLirrit0+lU165dFRAQoI0bN+ree+9VmzZfv/3Fixe9/7tWQECAjDHy855gAADQCvn9teZZs2Zp0qRJGjx4sIYNG6aXX35ZhYWFSklJkfT1RzVnzpzx/q6VY8eOKScnR0OGDNEXX3yhZcuW6ZNPPtHvf/977z6Tk5O1bNkyDRw4UEOGDNHx48f11FNP6Sc/+Yn3YyMAAPDd5XewTJgwQefOndOCBQtUVFSkfv36aefOnYqOjpYkFRUVqbCw0Du/urpazz//vI4ePSqn06mRI0cqKytLMTEx3jnz5s2Tw+HQvHnzdObMGXXq1EnJycl65plnrv0IAQBAi+f372GxFb+HBQCAlqdZfg8LAADAjUCwAAAA6xEsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLAAAwHoECwAAsB7BAgAArEewAAAA6xEsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLAAAwHoECwAAsB7BAgAArEewAAAA6xEsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLAAAwHoECwAAsB7BAgAArEewAAAA6xEsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsAAAAOsRLAAAwHoECwAAsB7BAgAArEewAAAA6xEsAADAegQLAACwHsECAACsR7AAAADrESwAAMB6BAsAALDeVQVLRkaGunfvLrfbrdjYWO3bt++K81euXKk+ffooODhYvXr10quvvlpnzpdffqnHH39cXbp0kdvtVp8+fbRz586rWR4AAGhlAv3dYNOmTZoxY4YyMjI0fPhwvfTSS0pKSlJ+fr66detWZ/6qVauUmpqqzMxM3X777crJydHUqVMVFham5ORkSdKlS5c0atQode7cWZs3b1bXrl11+vRphYSEXPsRAgCAFs9hjDH+bDBkyBANGjRIq1at8o716dNH48aN06JFi+rMj4uL0/Dhw7V06VLv2IwZM5Sbm6v3339fkrR69WotXbpUf/3rX+V0Oq/qQMrKyuTxeFRaWqrQ0NCr2gcAALi+Gvvz26+PhC5duqT9+/crISHBZzwhIUFZWVn1blNRUSG32+0zFhwcrJycHFVWVkqSduzYoWHDhunxxx9XeHi4+vXrp/T0dFVXVze4loqKCpWVlfk8AABA6+RXsJSUlKi6ulrh4eE+4+Hh4SouLq53m8TERK1Zs0b79++XMUa5ublat26dKisrVVJSIkk6ceKENm/erOrqau3cuVPz5s3T888/r2eeeabBtSxatEgej8f7iIqK8udQAABAC3JVN906HA6f58aYOmO1nnrqKSUlJWno0KFyOp0aO3aspkyZIkkKCAiQJNXU1Khz5856+eWXFRsbq4kTJ+o3v/mNz8dOl0tNTVVpaan3cfr06as5FAAA0AL4FSwdO3ZUQEBAnaspZ8+erXPVpVZwcLDWrVunixcvqqCgQIWFhYqJiVFISIg6duwoSerSpYtuueUWb8BIX98XU1xcrEuXLtW7X5fLpdDQUJ8HAABonfwKlqCgIMXGxmrXrl0+47t27VJcXNwVt3U6neratasCAgK0ceNG3XvvvWrT5uu3Hz58uI4fP66amhrv/GPHjqlLly4KCgryZ4kAAKAV8vsjoVmzZmnNmjVat26djhw5opkzZ6qwsFApKSmSvv6o5pFHHvHOP3bsmF577TX9z//8j3JycjRx4kR98sknSk9P98755S9/qXPnzmn69Ok6duyY/vznPys9PV2PP/54ExwiAABo6fz+PSwTJkzQuXPntGDBAhUVFalfv37auXOnoqOjJUlFRUUqLCz0zq+urtbzzz+vo0ePyul0auTIkcrKylJMTIx3TlRUlN566y3NnDlTAwYM0M0336zp06dr9uzZ136EAACgxfP797DYit/DAgBAy9Msv4cFAADgRiBYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFiPYAEAANYjWAAAgPUIFgAAYD2CBQAAWI9gAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFiPYAEAANYjWAAAgPUIFgAAYD2CBQAAWI9gAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFiPYAEAANYjWAAAgPUIFgAAYD2CBQAAWI9gAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1Am/0ApqKMUaSVFZWdoNXAgAAGqv253btz/GGtJpgKS8vlyRFRUXd4JUAAAB/lZeXy+PxNPi6w3xb0rQQNTU1+uyzzxQSEiKHw3Gjl3NDlZWVKSoqSqdPn1ZoaOiNXk6rxrm+PjjP1wfn+frgPPsyxqi8vFyRkZFq06bhO1VazRWWNm3aqGvXrjd6GVYJDQ3lX4brhHN9fXCerw/O8/XBef4/V7qyUoubbgEAgPUIFgAAYD2CpRVyuVyaP3++XC7XjV5Kq8e5vj44z9cH5/n64DxfnVZz0y0AAGi9uMICAACsR7AAAADrESwAAMB6BAsAALAewQIAAKxHsLRQX3zxhSZNmiSPxyOPx6NJkybpyy+/vOI2xhilpaUpMjJSwcHBuvPOO3X48OEG5yYlJcnhcGj79u1NfwAtRHOc57///e/61a9+pV69eummm25St27dNG3aNJWWljbz0dgjIyND3bt3l9vtVmxsrPbt23fF+Xv37lVsbKzcbrd69Oih1atX15mzZcsW9e3bVy6XS3379tW2bduaa/ktRlOf58zMTMXHxyssLExhYWG6++67lZOT05yH0CI0x5/nWhs3bpTD4dC4ceOaeNUtkEGLNHr0aNOvXz+TlZVlsrKyTL9+/cy99957xW0WL15sQkJCzJYtW8yhQ4fMhAkTTJcuXUxZWVmducuWLTNJSUlGktm2bVszHYX9muM8Hzp0yPzzP/+z2bFjhzl+/Lh55513zPe//30zfvz463FIN9zGjRuN0+k0mZmZJj8/30yfPt20bdvWnDp1qt75J06cMDfddJOZPn26yc/PN5mZmcbpdJrNmzd752RlZZmAgACTnp5ujhw5YtLT001gYKD58MMPr9dhWac5zvNDDz1kVq5caQ4cOGCOHDlifv7znxuPx2P+9re/Xa/Dsk5znOdaBQUF5uabbzbx8fFm7NixzXwk9iNYWqD8/Hwjyec/xtnZ2UaS+etf/1rvNjU1NSYiIsIsXrzYO/bVV18Zj8djVq9e7TM3Ly/PdO3a1RQVFX2ng6W5z/M3/fGPfzRBQUGmsrKy6Q7AUj/84Q9NSkqKz1jv3r3NnDlz6p3/61//2vTu3dtn7LHHHjNDhw71Pn/ggQfM6NGjfeYkJiaaiRMnNtGqW57mOM+Xq6qqMiEhIeb3v//9tS+4hWqu81xVVWWGDx9u1qxZYyZPnkywGGP4SKgFys7Olsfj0ZAhQ7xjQ4cOlcfjUVZWVr3bnDx5UsXFxUpISPCOuVwujRgxwmebixcv6sEHH9SKFSsUERHRfAfRAjTneb5caWmpQkNDFRjYav4+0npdunRJ+/fv9zk/kpSQkNDg+cnOzq4zPzExUbm5uaqsrLzinCud89asuc7z5S5evKjKykq1b9++aRbewjTneV6wYIE6deqkX/ziF02/8BaKYGmBiouL1blz5zrjnTt3VnFxcYPbSFJ4eLjPeHh4uM82M2fOVFxcnMaOHduEK26ZmvM8f9O5c+e0cOFCPfbYY9e4YvuVlJSourrar/NTXFxc7/yqqiqVlJRccU5D+2ztmus8X27OnDm6+eabdffddzfNwluY5jrPH3zwgdauXavMzMzmWXgLRbBYJC0tTQ6H44qP3NxcSZLD4aizvTGm3vFvuvz1b26zY8cOvfvuu1q+fHnTHJClbvR5/qaysjKNGTNGffv21fz586/hqFqWxp6fK82/fNzffX4XNMd5rrVkyRJt2LBBW7duldvtboLVtlxNeZ7Ly8v1s5/9TJmZmerYsWPTL7YFa93Xn1uYJ554QhMnTrzinJiYGH388cf6/PPP67z2v//7v3XKvVbtxzvFxcXq0qWLd/zs2bPebd599119+umn+t73vuez7fjx4xUfH689e/b4cTT2utHnuVZ5eblGjx6tdu3aadu2bXI6nf4eSovTsWNHBQQE1Pl/n/Wdn1oRERH1zg8MDFSHDh2uOKehfbZ2zXWeaz333HNKT0/X22+/rQEDBjTt4luQ5jjPhw8fVkFBgZKTk72v19TUSJICAwN19OhR9ezZs4mPpIW4QffO4BrU3gz60Ucfecc+/PDDRt0M+uyzz3rHKioqfG4GLSoqMocOHfJ5SDIvvPCCOXHiRPMelIWa6zwbY0xpaakZOnSoGTFihLlw4ULzHYSFfvjDH5pf/vKXPmN9+vS54k2Kffr08RlLSUmpc9NtUlKSz5zRo0d/52+6berzbIwxS5YsMaGhoSY7O7tpF9xCNfV5/sc//lHnv8Njx441d911lzl06JCpqKhongNpAQiWFmr06NFmwIABJjs722RnZ5v+/fvX+bptr169zNatW73PFy9ebDwej9m6das5dOiQefDBBxv8WnMtfYe/JWRM85znsrIyM2TIENO/f39z/PhxU1RU5H1UVVVd1+O7EWq/Brp27VqTn59vZsyYYdq2bWsKCgqMMcbMmTPHTJo0yTu/9mugM2fONPn5+Wbt2rV1vgb6wQcfmICAALN48WJz5MgRs3jxYr7W3Azn+dlnnzVBQUFm8+bNPn9uy8vLr/vx2aI5zvPl+JbQ1wiWFurcuXPm4YcfNiEhISYkJMQ8/PDD5osvvvCZI8m88sor3uc1NTVm/vz5JiIiwrhcLvOjH/3IHDp06Irv810PluY4z7t37zaS6n2cPHny+hzYDbZy5UoTHR1tgoKCzKBBg8zevXu9r02ePNmMGDHCZ/6ePXvMwIEDTVBQkImJiTGrVq2qs8/XX3/d9OrVyzidTtO7d2+zZcuW5j4M6zX1eY6Ojq73z+38+fOvw9HYqzn+PH8TwfI1hzH//24fAAAAS/EtIQAAYD2CBQAAWI9gAQAA1iNYAACA9QgWAABgPYIFAABYj2ABAADWI1gAAID1CBYAAGA9ggUAAFiPYAEAANb7fzqF+pHWFg1OAAAAAElFTkSuQmCC",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "plt.plot(range(1),[1])\n",
+ "plt.title(\"test matplotlib\")\n",
+ "plt.show()\n",
+ "plt.close()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
"id": "6e18f2fd",
"metadata": {},
"outputs": [
@@ -110,6 +196,7 @@
"source": [
"import torch\n",
"\n",
+ "\n",
"# check if CUDA is available\n",
"train_on_gpu = torch.cuda.is_available()\n",
"\n",
@@ -129,7 +216,7 @@
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": 3,
"id": "462666a2",
"metadata": {},
"outputs": [
@@ -137,21 +224,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to data\\cifar-10-python.tar.gz\n"
- ]
- },
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "100%|██████████| 170498071/170498071 [04:53<00:00, 581202.85it/s]\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "Extracting data\\cifar-10-python.tar.gz to data\n",
+ "Files already downloaded and verified\n",
"Files already downloaded and verified\n"
]
}
@@ -224,7 +297,7 @@
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": 4,
"id": "317bf070",
"metadata": {},
"outputs": [
@@ -288,7 +361,7 @@
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": 5,
"id": "4b53f229",
"metadata": {},
"outputs": [
@@ -296,50 +369,8 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Epoch: 0 \tTraining Loss: 43.620827 \tValidation Loss: 38.082290\n",
- "Validation loss decreased (inf --> 38.082290). Saving model ...\n",
- "Epoch: 1 \tTraining Loss: 34.754982 \tValidation Loss: 32.406397\n",
- "Validation loss decreased (38.082290 --> 32.406397). Saving model ...\n",
- "Epoch: 2 \tTraining Loss: 31.071355 \tValidation Loss: 30.083758\n",
- "Validation loss decreased (32.406397 --> 30.083758). Saving model ...\n",
- "Epoch: 3 \tTraining Loss: 28.824865 \tValidation Loss: 28.158049\n",
- "Validation loss decreased (30.083758 --> 28.158049). Saving model ...\n",
- "Epoch: 4 \tTraining Loss: 27.086696 \tValidation Loss: 27.524005\n",
- "Validation loss decreased (28.158049 --> 27.524005). Saving model ...\n",
- "Epoch: 5 \tTraining Loss: 25.775216 \tValidation Loss: 26.724925\n",
- "Validation loss decreased (27.524005 --> 26.724925). Saving model ...\n",
- "Epoch: 6 \tTraining Loss: 24.630849 \tValidation Loss: 24.679501\n",
- "Validation loss decreased (26.724925 --> 24.679501). Saving model ...\n",
- "Epoch: 7 \tTraining Loss: 23.555644 \tValidation Loss: 24.299120\n",
- "Validation loss decreased (24.679501 --> 24.299120). Saving model ...\n",
- "Epoch: 8 \tTraining Loss: 22.633386 \tValidation Loss: 24.419877\n",
- "Epoch: 9 \tTraining Loss: 21.833010 \tValidation Loss: 23.774966\n",
- "Validation loss decreased (24.299120 --> 23.774966). Saving model ...\n",
- "Epoch: 10 \tTraining Loss: 21.093354 \tValidation Loss: 22.663309\n",
- "Validation loss decreased (23.774966 --> 22.663309). Saving model ...\n",
- "Epoch: 11 \tTraining Loss: 20.392617 \tValidation Loss: 23.545277\n",
- "Epoch: 12 \tTraining Loss: 19.715720 \tValidation Loss: 22.203841\n",
- "Validation loss decreased (22.663309 --> 22.203841). Saving model ...\n",
- "Epoch: 13 \tTraining Loss: 19.026628 \tValidation Loss: 22.396531\n",
- "Epoch: 14 \tTraining Loss: 18.439459 \tValidation Loss: 22.169182\n",
- "Validation loss decreased (22.203841 --> 22.169182). Saving model ...\n",
- "Epoch: 15 \tTraining Loss: 17.880429 \tValidation Loss: 22.110950\n",
- "Validation loss decreased (22.169182 --> 22.110950). Saving model ...\n",
- "Epoch: 16 \tTraining Loss: 17.275769 \tValidation Loss: 22.278844\n",
- "Epoch: 17 \tTraining Loss: 16.708472 \tValidation Loss: 21.790319\n",
- "Validation loss decreased (22.110950 --> 21.790319). Saving model ...\n",
- "Epoch: 18 \tTraining Loss: 16.176635 \tValidation Loss: 22.427330\n",
- "Epoch: 19 \tTraining Loss: 15.644963 \tValidation Loss: 22.843680\n",
- "Epoch: 20 \tTraining Loss: 15.144519 \tValidation Loss: 22.096128\n",
- "Epoch: 21 \tTraining Loss: 14.678875 \tValidation Loss: 22.581978\n",
- "Epoch: 22 \tTraining Loss: 14.155724 \tValidation Loss: 22.721574\n",
- "Epoch: 23 \tTraining Loss: 13.704624 \tValidation Loss: 23.446930\n",
- "Epoch: 24 \tTraining Loss: 13.257443 \tValidation Loss: 23.317373\n",
- "Epoch: 25 \tTraining Loss: 12.793901 \tValidation Loss: 24.044483\n",
- "Epoch: 26 \tTraining Loss: 12.436155 \tValidation Loss: 23.708570\n",
- "Epoch: 27 \tTraining Loss: 11.934613 \tValidation Loss: 24.193758\n",
- "Epoch: 28 \tTraining Loss: 11.549681 \tValidation Loss: 24.913614\n",
- "Epoch: 29 \tTraining Loss: 11.075718 \tValidation Loss: 25.863216\n"
+ "Epoch: 0 \tTraining Loss: 43.309637 \tValidation Loss: 38.015603\n",
+ "Validation loss decreased (inf --> 38.015603). Saving model ...\n"
]
}
],
@@ -349,7 +380,7 @@
"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",
+ "n_epochs = 1 # 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",
@@ -423,10 +454,21 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 8,
"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",
@@ -447,10 +489,31 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 9,
"id": "e93efdfc",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Test Loss: 37.275009\n",
+ "\n",
+ "Test Accuracy of airplane: 43% (437/1000)\n",
+ "Test Accuracy of automobile: 27% (272/1000)\n",
+ "Test Accuracy of bird: 1% (14/1000)\n",
+ "Test Accuracy of cat: 6% (64/1000)\n",
+ "Test Accuracy of deer: 26% (263/1000)\n",
+ "Test Accuracy of dog: 20% (203/1000)\n",
+ "Test Accuracy of frog: 57% (574/1000)\n",
+ "Test Accuracy of horse: 59% (598/1000)\n",
+ "Test Accuracy of ship: 34% (345/1000)\n",
+ "Test Accuracy of truck: 47% (470/1000)\n",
+ "\n",
+ "Test Accuracy (Overall): 32% (3240/10000)\n"
+ ]
+ }
+ ],
"source": [
"model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n",
"\n",
@@ -548,10 +611,28 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 10,
"id": "ef623c26",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "model: fp32 \t Size (KB): 251.278\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "251278"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
"import os\n",
"\n",
@@ -577,10 +658,28 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 11,
"id": "c4c65d4b",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "model: int8 \t Size (KB): 76.522\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "76522"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
"import torch.quantization\n",
"\n",
diff --git a/model_cifar.pt b/model_cifar.pt
index c5d98e122eddc64e4a1d7a85c1ba7418a8ea4b7d..f8e931a9231bb799ab9fe95a5eb6e293bef88aa9 100644
Binary files a/model_cifar.pt and b/model_cifar.pt differ
diff --git a/test.ipynb b/test.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..b5a40891adccd86048026b1714fbce2bc57fa90c
--- /dev/null
+++ b/test.ipynb
@@ -0,0 +1,51 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "import matplotlib.pyplot as plt\n",
+ "plt.plot(range(1),[1])\n",
+ "plt.xlabel(\"Epoch\")\n",
+ "plt.ylabel(\"Loss\")\n",
+ "plt.title(\"Performance of Model 1\")\n",
+ "plt.show()"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "base",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}