From f991ee177d9de167d648c6ec597284762cc48170 Mon Sep 17 00:00:00 2001
From: RAMAGE PAULINE s318321 <s318321@studenti.polito.it>
Date: Thu, 21 Nov 2024 11:57:42 +0100
Subject: [PATCH] commit ex1 et ex2
---
TD2 Deep Learning.ipynb | 987 ++++++++++++++++++++++++++++++++++++++--
1 file changed, 954 insertions(+), 33 deletions(-)
diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb
index 00e4fdc..1cc8183 100644
--- a/TD2 Deep Learning.ipynb
+++ b/TD2 Deep Learning.ipynb
@@ -33,10 +33,30 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 29,
"id": "330a42f5",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: torch in /opt/anaconda3/envs/infa4/lib/python3.8/site-packages (2.2.2)\n",
+ "Requirement already satisfied: torchvision in /opt/anaconda3/envs/infa4/lib/python3.8/site-packages (0.17.2)\n",
+ "Requirement already satisfied: filelock in /opt/anaconda3/envs/infa4/lib/python3.8/site-packages (from torch) (3.16.1)\n",
+ "Requirement already satisfied: sympy in /opt/anaconda3/envs/infa4/lib/python3.8/site-packages (from torch) (1.13.3)\n",
+ "Requirement already satisfied: typing-extensions>=4.8.0 in /opt/anaconda3/envs/infa4/lib/python3.8/site-packages (from torch) (4.12.2)\n",
+ "Requirement already satisfied: networkx in /opt/anaconda3/envs/infa4/lib/python3.8/site-packages (from torch) (3.1)\n",
+ "Requirement already satisfied: jinja2 in /opt/anaconda3/envs/infa4/lib/python3.8/site-packages (from torch) (3.0.3)\n",
+ "Requirement already satisfied: fsspec in /opt/anaconda3/envs/infa4/lib/python3.8/site-packages (from torch) (2024.10.0)\n",
+ "Requirement already satisfied: numpy in /opt/anaconda3/envs/infa4/lib/python3.8/site-packages (from torchvision) (1.22.4)\n",
+ "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /opt/anaconda3/envs/infa4/lib/python3.8/site-packages (from torchvision) (9.2.0)\n",
+ "Requirement already satisfied: MarkupSafe>=2.0 in /opt/anaconda3/envs/infa4/lib/python3.8/site-packages (from jinja2->torch) (2.1.1)\n",
+ "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /opt/anaconda3/envs/infa4/lib/python3.8/site-packages (from sympy->torch) (1.3.0)\n",
+ "Note: you may need to restart the kernel to use updated packages.\n"
+ ]
+ }
+ ],
"source": [
"%pip install torch torchvision"
]
@@ -52,10 +72,72 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 30,
"id": "b1950f0a",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[-1.4659, -0.1341, 0.1910, 0.0218, 1.3658, 0.8917, 1.0628, -0.3176,\n",
+ " -0.2600, -0.2872],\n",
+ " [-0.0126, -0.0465, 0.2912, 0.4202, 1.2204, 0.1587, 0.3785, 0.0893,\n",
+ " -1.2530, -0.5823],\n",
+ " [-0.1116, -0.4923, 0.1068, -2.2929, 1.1194, 0.1912, 0.1003, -0.3300,\n",
+ " 1.2028, 0.4128],\n",
+ " [ 0.0107, -0.9120, 0.7665, 0.3744, -1.5287, 0.0866, -0.2056, 0.1550,\n",
+ " -0.0897, 0.2161],\n",
+ " [-0.6883, 0.0320, -0.2972, -1.1948, -1.5010, 1.8736, 0.1917, -0.7650,\n",
+ " -1.3622, 0.3975],\n",
+ " [ 0.1935, -0.9554, -1.1062, 0.2188, 1.6034, -0.0754, -0.1147, -2.2671,\n",
+ " 1.3213, 2.1263],\n",
+ " [ 1.9160, -1.4137, 0.2075, 0.3736, -0.0277, -0.8734, -0.6322, -0.1003,\n",
+ " -1.5709, 0.6832],\n",
+ " [-0.1293, -1.2336, -0.6936, 0.2776, -0.8490, -0.4399, -0.1854, 0.0193,\n",
+ " 0.5169, 0.1895],\n",
+ " [ 0.8107, -0.4397, -0.7788, 0.2323, -0.2399, -0.3275, 0.9527, 1.1022,\n",
+ " 0.2348, 1.8839],\n",
+ " [-0.2577, 0.5727, -0.6433, -1.1216, -0.7814, 2.6153, -0.9804, 0.9203,\n",
+ " 0.2468, 0.1160],\n",
+ " [-0.4528, -3.0148, 0.2142, -0.6560, -0.5975, -0.3176, 0.9180, 0.2664,\n",
+ " -1.4368, -0.0199],\n",
+ " [-0.4210, 0.1599, 0.7807, -1.1358, -0.8921, 0.8362, -1.0528, -1.4270,\n",
+ " 0.2394, 0.4054],\n",
+ " [-1.4733, 0.7435, -0.5230, -0.9226, 0.6155, -0.0909, 1.4459, 1.8425,\n",
+ " -0.8389, 2.5789],\n",
+ " [ 2.4644, -1.4380, -0.3848, 0.4128, 1.3633, 0.3712, -0.8086, -1.3316,\n",
+ " -1.9959, -0.6573]])\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 +177,18 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 31,
"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 +211,19 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 32,
"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 +292,25 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 33,
"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 +356,24 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 41,
"id": "4b53f229",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: 0 \tTraining Loss: 9.849982 \tValidation Loss: 16.806046\n",
+ "Validation loss decreased (inf --> 16.806046). Saving model ...\n",
+ "Epoch: 1 \tTraining Loss: 9.694958 \tValidation Loss: 17.402767\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 2 \tTraining Loss: 9.317991 \tValidation Loss: 16.902088\n",
+ "No improvement in validation loss for 2 epoch(s).\n",
+ "Early stopping triggered. Stopping training.\n"
+ ]
+ }
+ ],
"source": [
"import torch.optim as optim\n",
"\n",
@@ -255,6 +383,8 @@
"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",
+ "trigger = 2 # Number of epochs to wait before stopping\n",
+ "early_stop_counter = 0 # Counter for early stopping\n",
"\n",
"for epoch in range(n_epochs):\n",
" # Keep track of training and validation loss\n",
@@ -313,7 +443,16 @@
" )\n",
" )\n",
" torch.save(model.state_dict(), \"model_cifar.pt\")\n",
- " valid_loss_min = valid_loss"
+ " valid_loss_min = valid_loss\n",
+ " early_stop_counter = 0 # Reset the counter if validation loss improves\n",
+ " else:\n",
+ " early_stop_counter += 1 # Increment the counter if no improvement\n",
+ " print(f\"No improvement in validation loss for {early_stop_counter} epoch(s).\")\n",
+ "\n",
+ " # Check for early stopping condition\n",
+ " if early_stop_counter >= trigger:\n",
+ " print(\"Early stopping triggered. Stopping training.\")\n",
+ " break"
]
},
{
@@ -321,18 +460,62 @@
"id": "13e1df74",
"metadata": {},
"source": [
- "Does overfit occur? If so, do an early stopping."
+ "Does overfit occur? If so, do an early stopping. \n",
+ "Yes at some point, the validation loss increases while the training loss is still decreasing. The gap between the training loss and the validation loss is increasing. This means the model is overfitting the training data and is not good on adapting to other data than the training data. \n",
+ "Epoch: 0 \tTraining Loss: 42.229941 \tValidation Loss: 37.315443\n",
+ "Validation loss decreased (inf --> 37.315443). Saving model ...\n",
+ "Epoch: 1 \tTraining Loss: 34.319380 \tValidation Loss: 31.597989\n",
+ "Validation loss decreased (37.315443 --> 31.597989). Saving model ...\n",
+ "Epoch: 2 \tTraining Loss: 30.519103 \tValidation Loss: 28.500407\n",
+ "Validation loss decreased (31.597989 --> 28.500407). Saving model ...\n",
+ "Epoch: 3 \tTraining Loss: 28.410455 \tValidation Loss: 27.284037\n",
+ "Validation loss decreased (28.500407 --> 27.284037). Saving model ...\n",
+ "Epoch: 4 \tTraining Loss: 26.793309 \tValidation Loss: 26.645246\n",
+ "Validation loss decreased (27.284037 --> 26.645246). Saving model ...\n",
+ "Epoch: 5 \tTraining Loss: 25.407288 \tValidation Loss: 25.301372\n",
+ "Validation loss decreased (26.645246 --> 25.301372). Saving model ...\n",
+ "Epoch: 6 \tTraining Loss: 24.219666 \tValidation Loss: 24.314122\n",
+ "Validation loss decreased (25.301372 --> 24.314122). Saving model ...\n",
+ "Epoch: 7 \tTraining Loss: 23.164498 \tValidation Loss: 23.535732\n",
+ "Validation loss decreased (24.314122 --> 23.535732). Saving model ...\n",
+ "Epoch: 8 \tTraining Loss: 22.176390 \tValidation Loss: 23.461353\n",
+ "Validation loss decreased (23.535732 --> 23.461353). Saving model ...\n",
+ "Epoch: 9 \tTraining Loss: 21.281976 \tValidation Loss: 22.478021\n",
+ "Validation loss decreased (23.461353 --> 22.478021). Saving model ...\n",
+ "Epoch: 10 \tTraining Loss: 20.414580 \tValidation Loss: 22.096407\n",
+ "Validation loss decreased (22.478021 --> 22.096407). Saving model ...\n",
+ "Epoch: 11 \tTraining Loss: 19.702178 \tValidation Loss: 22.104724\n",
+ "Epoch: 12 \tTraining Loss: 18.904676 \tValidation Loss: 22.039121\n",
+ "Validation loss decreased (22.096407 --> 22.039121). Saving model ...\n",
+ "...\n",
+ "Epoch: 26 \tTraining Loss: 11.553949 \tValidation Loss: 24.366738\n",
+ "Epoch: 27 \tTraining Loss: 11.138622 \tValidation Loss: 25.671352\n",
+ "Epoch: 28 \tTraining Loss: 10.805559 \tValidation Loss: 25.136608\n",
+ "Epoch: 29 \tTraining Loss: 10.427645 \tValidation Loss: 25.924139"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 37,
"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",
+ "n_epochs=19\n",
+ "\n",
"plt.plot(range(n_epochs), train_loss_list)\n",
"plt.xlabel(\"Epoch\")\n",
"plt.ylabel(\"Loss\")\n",
@@ -350,10 +533,31 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 43,
"id": "e93efdfc",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Test Loss: 17.170850\n",
+ "\n",
+ "Test Accuracy of airplane: 73% (736/1000)\n",
+ "Test Accuracy of automobile: 89% (898/1000)\n",
+ "Test Accuracy of bird: 57% (573/1000)\n",
+ "Test Accuracy of cat: 60% (601/1000)\n",
+ "Test Accuracy of deer: 75% (753/1000)\n",
+ "Test Accuracy of dog: 56% (569/1000)\n",
+ "Test Accuracy of frog: 88% (884/1000)\n",
+ "Test Accuracy of horse: 74% (742/1000)\n",
+ "Test Accuracy of ship: 84% (846/1000)\n",
+ "Test Accuracy of truck: 73% (735/1000)\n",
+ "\n",
+ "Test Accuracy (Overall): 73% (7337/10000)\n"
+ ]
+ }
+ ],
"source": [
"model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n",
"\n",
@@ -434,6 +638,355 @@
"Compare the results obtained with this new network to those obtained previously."
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "id": "3f0e1df3",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "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.5, 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 Net(nn.Module):\n",
+ " def __init__(self):\n",
+ " super(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.5) #0.5 is a common value for dropout\n",
+ "\n",
+ " def forward(self, x):\n",
+ " x = self.pool(F.relu(self.conv1(x)))\n",
+ " x = self.pool(F.relu(self.conv2(x)))\n",
+ " x = self.pool(F.relu(self.conv3(x)))\n",
+ " x = x.view(-1, 64 * 4 * 4)\n",
+ " x = F.relu(self.fc1(x))\n",
+ " x = self.dropout(x)\n",
+ " x = F.relu(self.fc2(x))\n",
+ " x = self.dropout(x)\n",
+ " x = self.fc3(x)\n",
+ " return x\n",
+ "\n",
+ "\n",
+ "# create a complete CNN\n",
+ "model = Net()\n",
+ "print(model)\n",
+ "# move tensors to GPU if CUDA is available\n",
+ "if train_on_gpu:\n",
+ " model.cuda()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "id": "aa2236d4",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: 0 \tTraining Loss: 45.562531 \tValidation Loss: 42.305997\n",
+ "Validation loss decreased (inf --> 42.305997). Saving model ...\n",
+ "Epoch: 1 \tTraining Loss: 39.474510 \tValidation Loss: 34.808490\n",
+ "Validation loss decreased (42.305997 --> 34.808490). Saving model ...\n",
+ "Epoch: 2 \tTraining Loss: 34.700151 \tValidation Loss: 31.855279\n",
+ "Validation loss decreased (34.808490 --> 31.855279). Saving model ...\n",
+ "Epoch: 3 \tTraining Loss: 32.568385 \tValidation Loss: 30.140585\n",
+ "Validation loss decreased (31.855279 --> 30.140585). Saving model ...\n",
+ "Epoch: 4 \tTraining Loss: 30.986165 \tValidation Loss: 28.920407\n",
+ "Validation loss decreased (30.140585 --> 28.920407). Saving model ...\n",
+ "Epoch: 5 \tTraining Loss: 29.480848 \tValidation Loss: 27.039851\n",
+ "Validation loss decreased (28.920407 --> 27.039851). Saving model ...\n",
+ "Epoch: 6 \tTraining Loss: 28.076040 \tValidation Loss: 25.635999\n",
+ "Validation loss decreased (27.039851 --> 25.635999). Saving model ...\n",
+ "Epoch: 7 \tTraining Loss: 26.760129 \tValidation Loss: 23.955000\n",
+ "Validation loss decreased (25.635999 --> 23.955000). Saving model ...\n",
+ "Epoch: 8 \tTraining Loss: 25.494585 \tValidation Loss: 22.745345\n",
+ "Validation loss decreased (23.955000 --> 22.745345). Saving model ...\n",
+ "Epoch: 9 \tTraining Loss: 24.251832 \tValidation Loss: 22.095386\n",
+ "Validation loss decreased (22.745345 --> 22.095386). Saving model ...\n",
+ "Epoch: 10 \tTraining Loss: 23.139143 \tValidation Loss: 21.138833\n",
+ "Validation loss decreased (22.095386 --> 21.138833). Saving model ...\n",
+ "Epoch: 11 \tTraining Loss: 21.975158 \tValidation Loss: 20.665420\n",
+ "Validation loss decreased (21.138833 --> 20.665420). Saving model ...\n",
+ "Epoch: 12 \tTraining Loss: 21.043967 \tValidation Loss: 19.621433\n",
+ "Validation loss decreased (20.665420 --> 19.621433). Saving model ...\n",
+ "Epoch: 13 \tTraining Loss: 20.083247 \tValidation Loss: 19.357569\n",
+ "Validation loss decreased (19.621433 --> 19.357569). Saving model ...\n",
+ "Epoch: 14 \tTraining Loss: 19.313826 \tValidation Loss: 17.967391\n",
+ "Validation loss decreased (19.357569 --> 17.967391). Saving model ...\n",
+ "Epoch: 15 \tTraining Loss: 18.373283 \tValidation Loss: 17.859599\n",
+ "Validation loss decreased (17.967391 --> 17.859599). Saving model ...\n",
+ "Epoch: 16 \tTraining Loss: 17.662972 \tValidation Loss: 17.973600\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 17 \tTraining Loss: 16.953707 \tValidation Loss: 17.344405\n",
+ "Validation loss decreased (17.859599 --> 17.344405). Saving model ...\n",
+ "Epoch: 18 \tTraining Loss: 16.256076 \tValidation Loss: 17.016450\n",
+ "Validation loss decreased (17.344405 --> 17.016450). Saving model ...\n",
+ "Epoch: 19 \tTraining Loss: 15.596459 \tValidation Loss: 16.758178\n",
+ "Validation loss decreased (17.016450 --> 16.758178). Saving model ...\n",
+ "Epoch: 20 \tTraining Loss: 14.904443 \tValidation Loss: 17.566068\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 21 \tTraining Loss: 14.407137 \tValidation Loss: 16.661745\n",
+ "Validation loss decreased (16.758178 --> 16.661745). Saving model ...\n",
+ "Epoch: 22 \tTraining Loss: 13.845622 \tValidation Loss: 16.064557\n",
+ "Validation loss decreased (16.661745 --> 16.064557). Saving model ...\n",
+ "Epoch: 23 \tTraining Loss: 13.241376 \tValidation Loss: 16.710681\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 24 \tTraining Loss: 12.743690 \tValidation Loss: 16.099553\n",
+ "No improvement in validation loss for 2 epoch(s).\n",
+ "Epoch: 25 \tTraining Loss: 12.296984 \tValidation Loss: 16.603530\n",
+ "No improvement in validation loss for 3 epoch(s).\n",
+ "Epoch: 26 \tTraining Loss: 11.733432 \tValidation Loss: 16.308954\n",
+ "No improvement in validation loss for 4 epoch(s).\n",
+ "Epoch: 27 \tTraining Loss: 11.293886 \tValidation Loss: 15.828966\n",
+ "Validation loss decreased (16.064557 --> 15.828966). Saving model ...\n",
+ "Epoch: 28 \tTraining Loss: 10.787941 \tValidation Loss: 16.363491\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 29 \tTraining Loss: 10.433505 \tValidation Loss: 16.555964\n",
+ "No improvement in validation loss for 2 epoch(s).\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch.optim as optim\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",
+ "trigger = 2 # Number of epochs to wait before stopping\n",
+ "early_stop_counter = 0 # Counter for early stopping\n",
+ "\n",
+ "for epoch in range(n_epochs):\n",
+ " # Keep track of training and validation loss\n",
+ " train_loss = 0.0\n",
+ " valid_loss = 0.0\n",
+ "\n",
+ " # Train the model\n",
+ " model.train()\n",
+ " for data, target in train_loader:\n",
+ " # Move tensors to GPU if CUDA is available\n",
+ " if train_on_gpu:\n",
+ " data, target = data.cuda(), target.cuda()\n",
+ " # Clear the gradients of all optimized variables\n",
+ " optimizer.zero_grad()\n",
+ " # Forward pass: compute predicted outputs by passing inputs to the model\n",
+ " output = model(data)\n",
+ " # Calculate the batch loss\n",
+ " loss = criterion(output, target)\n",
+ " # Backward pass: compute gradient of the loss with respect to model parameters\n",
+ " loss.backward()\n",
+ " # Perform a single optimization step (parameter update)\n",
+ " optimizer.step()\n",
+ " # Update training loss\n",
+ " train_loss += loss.item() * data.size(0)\n",
+ "\n",
+ " # Validate the model\n",
+ " model.eval()\n",
+ " for data, target in valid_loader:\n",
+ " # Move tensors to GPU if CUDA is available\n",
+ " if train_on_gpu:\n",
+ " data, target = data.cuda(), target.cuda()\n",
+ " # Forward pass: compute predicted outputs by passing inputs to the model\n",
+ " output = model(data)\n",
+ " # Calculate the batch loss\n",
+ " loss = criterion(output, target)\n",
+ " # Update average validation loss\n",
+ " valid_loss += loss.item() * data.size(0)\n",
+ "\n",
+ " # Calculate average losses\n",
+ " train_loss = train_loss / len(train_loader)\n",
+ " valid_loss = valid_loss / len(valid_loader)\n",
+ " train_loss_list.append(train_loss)\n",
+ "\n",
+ " # Print training/validation statistics\n",
+ " print(\n",
+ " \"Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}\".format(\n",
+ " epoch, train_loss, valid_loss\n",
+ " )\n",
+ " )\n",
+ "\n",
+ " # Save model if validation loss has decreased\n",
+ " if valid_loss <= valid_loss_min:\n",
+ " print(\n",
+ " \"Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...\".format(\n",
+ " valid_loss_min, valid_loss\n",
+ " )\n",
+ " )\n",
+ " torch.save(model.state_dict(), \"model_cifar.pt\")\n",
+ " valid_loss_min = valid_loss\n",
+ " early_stop_counter = 0 # Reset the counter if validation loss improves\n",
+ " else:\n",
+ " early_stop_counter += 1 # Increment the counter if no improvement\n",
+ " print(f\"No improvement in validation loss for {early_stop_counter} epoch(s).\")\n",
+ "\n",
+ " # Check for early stopping condition\n",
+ " if early_stop_counter >= trigger:\n",
+ " print(\"Early stopping triggered. Stopping training.\")\n",
+ " break"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "id": "96d4a864",
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "ValueError",
+ "evalue": "x and y must have same first dimension, but have shapes (30,) and (3,)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m/var/folders/c_/bcjgdb5j6wq89qpwvs1rl29h0000gn/T/ipykernel_27875/286785084.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpyplot\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn_epochs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_loss_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxlabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Epoch\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mylabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Loss\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mplot\u001b[0;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2785\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mdocstring\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mAxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2786\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscalex\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscaley\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2787\u001b[0;31m return gca().plot(\n\u001b[0m\u001b[1;32m 2788\u001b[0m *args, scalex=scalex, scaley=scaley, **({\"data\": data} if data\n\u001b[1;32m 2789\u001b[0m is not None else {}), **kwargs)\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/matplotlib/axes/_axes.py\u001b[0m in \u001b[0;36mplot\u001b[0;34m(self, scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1663\u001b[0m \"\"\"\n\u001b[1;32m 1664\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcbook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormalize_kwargs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmlines\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLine2D\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_alias_map\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1665\u001b[0;31m \u001b[0mlines\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_lines\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1666\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mline\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mlines\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1667\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_line\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mline\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 223\u001b[0m \u001b[0mthis\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 224\u001b[0m \u001b[0margs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 225\u001b[0;31m \u001b[0;32myield\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_plot_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 226\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 227\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_next_color\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36m_plot_args\u001b[0;34m(self, tup, kwargs)\u001b[0m\n\u001b[1;32m 389\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mindex_of\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtup\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 390\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 391\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_xy_from_xy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 392\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 393\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcommand\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'plot'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36m_xy_from_xy\u001b[0;34m(self, x, y)\u001b[0m\n\u001b[1;32m 267\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_check_1d\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 268\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 269\u001b[0;31m raise ValueError(\"x and y must have same first dimension, but \"\n\u001b[0m\u001b[1;32m 270\u001b[0m \"have shapes {} and {}\".format(x.shape, y.shape))\n\u001b[1;32m 271\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mValueError\u001b[0m: x and y must have same first dimension, but have shapes (30,) and (3,)"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi4AAAGiCAYAAADA0E3hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAc2UlEQVR4nO3dfWyV5f348U9paaturRG0lgcRNt1QohttYJR1fue0CxgXli2wuIg6TdbsAYHptGNTcWbNXGTTTXAPoDFBR1R0LOkc/WPDKu4BVswiJC7CLLhWUowt6lYG3L8/DP2ta3Gc2geu9vVK7j/O5X2fc51c1vP2vs9DXpZlWQAAJGDMcE8AAOBECRcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGTmHyzPPPBNXXnllTJgwIfLy8uKpp576n8ds2bIlKioqori4OKZNmxYPPPBAvyYLAIxuOYfLW2+9FRdffHH85Cc/OaH99+zZE/Pnz4/q6upobm6Ob33rW7FkyZJ44okncp4sADC65b2XH1nMy8uLJ598MhYsWHDcfW655ZbYtGlT7Nq1q3ustrY2XnjhhXj++ef7+9AAwChUMNgP8Pzzz0dNTU2PsU9/+tOxdu3a+Pe//x1jx47tdUxXV1d0dXV13z569Gi8/vrrMW7cuMjLyxvsKQMAAyDLsjh48GBMmDAhxowZmLfVDnq4tLW1RVlZWY+xsrKyOHz4cLS3t0d5eXmvY+rr62PlypWDPTUAYAjs3bs3Jk2aNCD3NejhEhG9zpIcuzp1vLMndXV1sXz58u7bHR0dcc4558TevXujpKRk8CYKAAyYzs7OmDx5crz//e8fsPsc9HA5++yzo62trcfY/v37o6CgIMaNG9fnMUVFRVFUVNRrvKSkRLgAQGIG8m0eg/49LnPmzInGxsYeY5s3b47Kyso+398CAHA8OYfLm2++GTt27IgdO3ZExDsfd96xY0e0tLRExDuXeRYvXty9f21tbbzyyiuxfPny2LVrV6xbty7Wrl0bN9100wA9BQBgtMj5UtG2bdvik5/8ZPftY+9Fueaaa+Khhx6K1tbW7oiJiJg6dWo0NDTEsmXL4v77748JEybEfffdF5/73OcGYPoAwGjynr7HZah0dnZGaWlpdHR0eI8LACRiMF6//VYRAJAM4QIAJEO4AADJEC4AQDKECwCQDOECACRDuAAAyRAuAEAyhAsAkAzhAgAkQ7gAAMkQLgBAMoQLAJAM4QIAJEO4AADJEC4AQDKECwCQDOECACRDuAAAyRAuAEAyhAsAkAzhAgAkQ7gAAMkQLgBAMoQLAJAM4QIAJEO4AADJEC4AQDKECwCQDOECACRDuAAAyRAuAEAyhAsAkAzhAgAkQ7gAAMkQLgBAMoQLAJAM4QIAJEO4AADJEC4AQDKECwCQDOECACRDuAAAyRAuAEAyhAsAkAzhAgAkQ7gAAMkQLgBAMoQLAJAM4QIAJEO4AADJEC4AQDKECwCQDOECACRDuAAAyRAuAEAyhAsAkAzhAgAkQ7gAAMkQLgBAMoQLAJAM4QIAJEO4AADJ6Fe4rF69OqZOnRrFxcVRUVERTU1N77r/+vXr4+KLL45TTz01ysvL47rrrosDBw70a8IAwOiVc7hs2LAhli5dGitWrIjm5uaorq6OefPmRUtLS5/7P/vss7F48eK4/vrr48UXX4zHHnss/vznP8cNN9zwnicPAIwuOYfLqlWr4vrrr48bbrghpk+fHj/60Y9i8uTJsWbNmj73/8Mf/hDnnntuLFmyJKZOnRof//jH48tf/nJs27btPU8eABhdcgqXQ4cOxfbt26OmpqbHeE1NTWzdurXPY6qqqmLfvn3R0NAQWZbFa6+9Fo8//nhcccUVx32crq6u6Ozs7LEBAOQULu3t7XHkyJEoKyvrMV5WVhZtbW19HlNVVRXr16+PRYsWRWFhYZx99tlx+umnx49//OPjPk59fX2UlpZ2b5MnT85lmgDACNWvN+fm5eX1uJ1lWa+xY3bu3BlLliyJ2267LbZv3x5PP/107NmzJ2pra497/3V1ddHR0dG97d27tz/TBABGmIJcdh4/fnzk5+f3Oruyf//+Xmdhjqmvr4+5c+fGzTffHBERF110UZx22mlRXV0dd911V5SXl/c6pqioKIqKinKZGgAwCuR0xqWwsDAqKiqisbGxx3hjY2NUVVX1eczbb78dY8b0fJj8/PyIeOdMDQDAicr5UtHy5cvjF7/4Raxbty527doVy5Yti5aWlu5LP3V1dbF48eLu/a+88srYuHFjrFmzJnbv3h3PPfdcLFmyJGbNmhUTJkwYuGcCAIx4OV0qiohYtGhRHDhwIO68885obW2NGTNmRENDQ0yZMiUiIlpbW3t8p8u1114bBw8ejJ/85CfxjW98I04//fS49NJL4/vf//7APQsAYFTIyxK4XtPZ2RmlpaXR0dERJSUlwz0dAOAEDMbrt98qAgCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGf0Kl9WrV8fUqVOjuLg4Kioqoqmp6V337+rqihUrVsSUKVOiqKgoPvCBD8S6dev6NWEAYPQqyPWADRs2xNKlS2P16tUxd+7c+OlPfxrz5s2LnTt3xjnnnNPnMQsXLozXXnst1q5dGx/84Adj//79cfjw4fc8eQBgdMnLsizL5YDZs2fHzJkzY82aNd1j06dPjwULFkR9fX2v/Z9++un4whe+ELt3744zzjijX5Ps7OyM0tLS6OjoiJKSkn7dBwAwtAbj9TunS0WHDh2K7du3R01NTY/xmpqa2Lp1a5/HbNq0KSorK+Puu++OiRMnxvnnnx833XRT/POf/zzu43R1dUVnZ2ePDQAgp0tF7e3tceTIkSgrK+sxXlZWFm1tbX0es3v37nj22WejuLg4nnzyyWhvb4+vfOUr8frrrx/3fS719fWxcuXKXKYGAIwC/Xpzbl5eXo/bWZb1Gjvm6NGjkZeXF+vXr49Zs2bF/PnzY9WqVfHQQw8d96xLXV1ddHR0dG979+7tzzQBgBEmpzMu48ePj/z8/F5nV/bv39/rLMwx5eXlMXHixCgtLe0emz59emRZFvv27Yvzzjuv1zFFRUVRVFSUy9QAgFEgpzMuhYWFUVFREY2NjT3GGxsbo6qqqs9j5s6dG//4xz/izTff7B576aWXYsyYMTFp0qR+TBkAGK1yvlS0fPny+MUvfhHr1q2LXbt2xbJly6KlpSVqa2sj4p3LPIsXL+7e/6qrropx48bFddddFzt37oxnnnkmbr755vjSl74Up5xyysA9EwBgxMv5e1wWLVoUBw4ciDvvvDNaW1tjxowZ0dDQEFOmTImIiNbW1mhpaene/33ve180NjbG17/+9aisrIxx48bFwoUL46677hq4ZwEAjAo5f4/LcPA9LgCQnmH/HhcAgOEkXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZ/QqX1atXx9SpU6O4uDgqKiqiqanphI577rnnoqCgID7ykY/052EBgFEu53DZsGFDLF26NFasWBHNzc1RXV0d8+bNi5aWlnc9rqOjIxYvXhyf+tSn+j1ZAGB0y8uyLMvlgNmzZ8fMmTNjzZo13WPTp0+PBQsWRH19/XGP+8IXvhDnnXde5Ofnx1NPPRU7duw47r5dXV3R1dXVfbuzszMmT54cHR0dUVJSkst0AYBh0tnZGaWlpQP6+p3TGZdDhw7F9u3bo6ampsd4TU1NbN269bjHPfjgg/Hyyy/H7bfffkKPU19fH6Wlpd3b5MmTc5kmADBC5RQu7e3tceTIkSgrK+sxXlZWFm1tbX0e87e//S1uvfXWWL9+fRQUFJzQ49TV1UVHR0f3tnfv3lymCQCMUCdWEv8lLy+vx+0sy3qNRUQcOXIkrrrqqli5cmWcf/75J3z/RUVFUVRU1J+pAQAjWE7hMn78+MjPz+91dmX//v29zsJERBw8eDC2bdsWzc3N8bWvfS0iIo4ePRpZlkVBQUFs3rw5Lr300vcwfQBgNMnpUlFhYWFUVFREY2Njj/HGxsaoqqrqtX9JSUn89a9/jR07dnRvtbW18aEPfSh27NgRs2fPfm+zBwBGlZwvFS1fvjyuvvrqqKysjDlz5sTPfvazaGlpidra2oh45/0pr776ajz88MMxZsyYmDFjRo/jzzrrrCguLu41DgDwv+QcLosWLYoDBw7EnXfeGa2trTFjxoxoaGiIKVOmREREa2vr//xOFwCA/sj5e1yGw2B8DhwAGFzD/j0uAADDSbgAAMkQLgBAMoQLAJAM4QIAJEO4AADJEC4AQDKECwCQDOECACRDuAAAyRAuAEAyhAsAkAzhAgAkQ7gAAMkQLgBAMoQLAJAM4QIAJEO4AADJEC4AQDKECwCQDOECACRDuAAAyRAuAEAyhAsAkAzhAgAkQ7gAAMkQLgBAMoQLAJAM4QIAJEO4AADJEC4AQDKECwCQDOECACRDuAAAyRAuAEAyhAsAkAzhAgAkQ7gAAMkQLgBAMoQLAJAM4QIAJEO4AADJEC4AQDKECwCQDOECACRDuAAAyRAuAEAyhAsAkAzhAgAkQ7gAAMkQLgBAMoQLAJAM4QIAJEO4AADJEC4AQDKECwCQDOECACRDuAAAyRAuAEAyhAsAkAzhAgAkQ7gAAMkQLgBAMvoVLqtXr46pU6dGcXFxVFRURFNT03H33bhxY1x++eVx5plnRklJScyZMyd++9vf9nvCAMDolXO4bNiwIZYuXRorVqyI5ubmqK6ujnnz5kVLS0uf+z/zzDNx+eWXR0NDQ2zfvj0++clPxpVXXhnNzc3vefIAwOiSl2VZlssBs2fPjpkzZ8aaNWu6x6ZPnx4LFiyI+vr6E7qPCy+8MBYtWhS33XZbn/+8q6srurq6um93dnbG5MmTo6OjI0pKSnKZLgAwTDo7O6O0tHRAX79zOuNy6NCh2L59e9TU1PQYr6mpia1bt57QfRw9ejQOHjwYZ5xxxnH3qa+vj9LS0u5t8uTJuUwTABihcgqX9vb2OHLkSJSVlfUYLysri7a2thO6j3vuuSfeeuutWLhw4XH3qauri46Oju5t7969uUwTABihCvpzUF5eXo/bWZb1GuvLo48+GnfccUf86le/irPOOuu4+xUVFUVRUVF/pgYAjGA5hcv48eMjPz+/19mV/fv39zoL8982bNgQ119/fTz22GNx2WWX5T5TAGDUy+lSUWFhYVRUVERjY2OP8cbGxqiqqjrucY8++mhce+218cgjj8QVV1zRv5kCAKNezpeKli9fHldffXVUVlbGnDlz4mc/+1m0tLREbW1tRLzz/pRXX301Hn744Yh4J1oWL14c9957b3zsYx/rPltzyimnRGlp6QA+FQBgpMs5XBYtWhQHDhyIO++8M1pbW2PGjBnR0NAQU6ZMiYiI1tbWHt/p8tOf/jQOHz4cX/3qV+OrX/1q9/g111wTDz300Ht/BgDAqJHz97gMh8H4HDgAMLiG/XtcAACGk3ABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZAgXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIhnABAJIhXACAZPQrXFavXh1Tp06N4uLiqKioiKampnfdf8uWLVFRURHFxcUxbdq0eOCBB/o1WQBgdMs5XDZs2BBLly6NFStWRHNzc1RXV8e8efOipaWlz/337NkT8+fPj+rq6mhubo5vfetbsWTJknjiiSfe8+QBgNElL8uyLJcDZs+eHTNnzow1a9Z0j02fPj0WLFgQ9fX1vfa/5ZZbYtOmTbFr167usdra2njhhRfi+eef7/Mxurq6oqurq/t2R0dHnHPOObF3794oKSnJZboAwDDp7OyMyZMnxxtvvBGlpaUDc6dZDrq6urL8/Pxs48aNPcaXLFmSfeITn+jzmOrq6mzJkiU9xjZu3JgVFBRkhw4d6vOY22+/PYsIm81ms9lsI2B7+eWXc8mNd1UQOWhvb48jR45EWVlZj/GysrJoa2vr85i2trY+9z98+HC0t7dHeXl5r2Pq6upi+fLl3bffeOONmDJlSrS0tAxcsdEvx+rZ2a/hZy1OHtbi5GI9Th7HrpicccYZA3afOYXLMXl5eT1uZ1nWa+x/7d/X+DFFRUVRVFTUa7y0tNS/hCeJkpISa3GSsBYnD2txcrEeJ48xYwbuQ8w53dP48eMjPz+/19mV/fv39zqrcszZZ5/d5/4FBQUxbty4HKcLAIxmOYVLYWFhVFRURGNjY4/xxsbGqKqq6vOYOXPm9Np/8+bNUVlZGWPHjs1xugDAaJZ/xx133JHLASUlJfGd73wnJk6cGMXFxfG9730vfve738WDDz4Yp59+etTV1cXDDz8cn/3sZyMi4oMf/GDU19fHgQMH4pxzzolf//rX8d3vfjdWrVoVF1xwwYlPND8//u///i8KCvp1dYsBZC1OHtbi5GEtTi7W4+Qx0GuR88ehI975Arq77747WltbY8aMGfHDH/4wPvGJT0RExLXXXht///vf4/e//333/lu2bIlly5bFiy++GBMmTIhbbrklamtrB+QJAACjR7/CBQBgOPitIgAgGcIFAEiGcAEAkiFcAIBknDThsnr16pg6dWoUFxdHRUVFNDU1vev+W7ZsiYqKiiguLo5p06bFAw88MEQzHflyWYuNGzfG5ZdfHmeeeWaUlJTEnDlz4re//e0QznZky/Xv4pjnnnsuCgoK4iMf+cggz3D0yHUturq6YsWKFTFlypQoKiqKD3zgA7Fu3bohmu3IlutarF+/Pi6++OI49dRTo7y8PK677ro4cODAEM125HrmmWfiyiuvjAkTJkReXl489dRT//OYAXntHrBfPXoPfvnLX2Zjx47Nfv7zn2c7d+7Mbrzxxuy0007LXnnllT733717d3bqqadmN954Y7Zz587s5z//eTZ27Njs8ccfH+KZjzy5rsWNN96Yff/738/+9Kc/ZS+99FJWV1eXjR07NvvLX/4yxDMfeXJdi2PeeOONbNq0aVlNTU128cUXD9FsR7b+rMVnPvOZbPbs2VljY2O2Z8+e7I9//GP23HPPDeGsR6Zc16KpqSkbM2ZMdu+992a7d+/OmpqasgsvvDBbsGDBEM985GloaMhWrFiRPfHEE1lEZE8++eS77j9Qr90nRbjMmjUrq62t7TH24Q9/OLv11lv73P+b3/xm9uEPf7jH2Je//OXsYx/72KDNcbTIdS36csEFF2QrV64c6KmNOv1di0WLFmXf/va3s9tvv124DJBc1+I3v/lNVlpamh04cGAopjeq5LoWP/jBD7Jp06b1GLvvvvuySZMmDdocR6MTCZeBeu0e9ktFhw4diu3bt0dNTU2P8Zqamti6dWufxzz//PO99v/0pz8d27Zti3//+9+DNteRrj9r8d+OHj0aBw8eHNBfAh2N+rsWDz74YLz88stx++23D/YUR43+rMWmTZuisrIy7r777pg4cWKcf/75cdNNN8U///nPoZjyiNWftaiqqop9+/ZFQ0NDZFkWr732Wjz++ONxxRVXDMWU+Q8D9do97N+F3N7eHkeOHOn1I41lZWW9fpzxmLa2tj73P3z4cLS3t0d5efmgzXck689a/Ld77rkn3nrrrVi4cOFgTHHU6M9a/O1vf4tbb701mpqafM35AOrPWuzevTueffbZKC4ujieffDLa29vjK1/5Srz++uve5/Ie9GctqqqqYv369bFo0aL417/+FYcPH47PfOYz8eMf/3gopsx/GKjX7mE/43JMXl5ej9tZlvUa+1/79zVO7nJdi2MeffTRuOOOO2LDhg1x1llnDdb0RpUTXYsjR47EVVddFStXrozzzz9/qKY3quTyd3H06NHIy8uL9evXx6xZs2L+/PmxatWqeOihh5x1GQC5rMXOnTtjyZIlcdttt8X27dvj6aefjj179vjZmWEyEK/dw/6/ZePHj4/8/Pxetbx///5eZXbM2Wef3ef+BQUFMW7cuEGb60jXn7U4ZsOGDXH99dfHY489FpdddtlgTnNUyHUtDh48GNu2bYvm5ub42te+FhHvvHhmWRYFBQWxefPmuPTSS4dk7iNNf/4uysvLY+LEiVFaWto9Nn369MiyLPbt2xfnnXfeoM55pOrPWtTX18fcuXPj5ptvjoiIiy66KE477bSorq6Ou+66yxn6ITRQr93DfsalsLAwKioqorGxscd4Y2NjVFVV9XnMnDlzeu2/efPmqKysjLFjxw7aXEe6/qxFxDtnWq699tp45JFHXDceILmuRUlJSfz1r3+NHTt2dG+1tbXxoQ99KHbs2BGzZ88eqqmPOP35u5g7d2784x//iDfffLN77KWXXooxY8bEpEmTBnW+I1l/1uLtt9+OMWN6vtTl5+dHxP//v32GxoC9duf0Vt5BcuzjbWvXrs127tyZLV26NDvttNOyv//971mWZdmtt96aXX311d37H/tI1bJly7KdO3dma9eu9XHoAZLrWjzyyCNZQUFBdv/992etra3d2xtvvDFcT2HEyHUt/ptPFQ2cXNfi4MGD2aRJk7LPf/7z2Ysvvpht2bIlO++887IbbrhhuJ7CiJHrWjz44INZQUFBtnr16uzll1/Onn322ayysjKbNWvWcD2FEePgwYNZc3Nz1tzcnEVEtmrVqqy5ubn7o+mD9dp9UoRLlmXZ/fffn02ZMiUrLCzMZs6cmW3ZsqX7n11zzTXZJZdc0mP/3//+99lHP/rRrLCwMDv33HOzNWvWDPGMR65c1uKSSy7JIqLXds011wz9xEegXP8u/pNwGVi5rsWuXbuyyy67LDvllFOySZMmZcuXL8/efvvtIZ71yJTrWtx3333ZBRdckJ1yyilZeXl59sUvfjHbt2/fEM965Pnd7373rv/9H6zX7rwsc64MAEjDsL/HBQDgRAkXACAZwgUASIZwAQCSIVwAgGQIFwAgGcIFAEiGcAEAkiFcAIBkCBcAIBnCBQBIxv8DdgKZtXsFZmAAAAAASUVORK5CYII=",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "plt.plot(range(n_epochs), train_loss_list)\n",
+ "plt.xlabel(\"Epoch\")\n",
+ "plt.ylabel(\"Loss\")\n",
+ "plt.title(\"Performance of Model 1\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "id": "b86dd2c4",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Test Loss: 17.170850\n",
+ "\n",
+ "Test Accuracy of airplane: 73% (736/1000)\n",
+ "Test Accuracy of automobile: 89% (898/1000)\n",
+ "Test Accuracy of bird: 57% (573/1000)\n",
+ "Test Accuracy of cat: 60% (601/1000)\n",
+ "Test Accuracy of deer: 75% (753/1000)\n",
+ "Test Accuracy of dog: 56% (569/1000)\n",
+ "Test Accuracy of frog: 88% (884/1000)\n",
+ "Test Accuracy of horse: 74% (742/1000)\n",
+ "Test Accuracy of ship: 84% (846/1000)\n",
+ "Test Accuracy of truck: 73% (735/1000)\n",
+ "\n",
+ "Test Accuracy (Overall): 73% (7337/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 +1004,28 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 42,
"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": 42,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
"import os\n",
"\n",
@@ -480,10 +1051,28 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 15,
"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": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
"import torch.quantization\n",
"\n",
@@ -500,6 +1089,296 @@
"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": 52,
+ "id": "35135f12",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torch/autograd/__init__.py:266: UserWarning: quantized::linear_dynamic: an autograd kernel was not registered to the Autograd key(s) but we are trying to backprop through it. This may lead to silently incorrect behavior. This behavior is deprecated and will be removed in a future version of PyTorch. If your operator is differentiable, please ensure you have registered an autograd kernel to the correct Autograd key (e.g. DispatchKey::Autograd, DispatchKey::CompositeImplicitAutograd). If your operator is not differentiable, or to squash this warning and use the previous behavior, please register torch::CppFunction::makeFallthrough() to DispatchKey::Autograd. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/autograd_not_implemented_fallback.cpp:72.)\n",
+ " Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: 0 \tTraining Loss: 17.109160 \tValidation Loss: 17.287051\n",
+ "Validation loss decreased (inf --> 17.287051). Saving model ...\n",
+ "Epoch: 1 \tTraining Loss: 17.108934 \tValidation Loss: 17.279689\n",
+ "Validation loss decreased (17.287051 --> 17.279689). Saving model ...\n",
+ "Epoch: 2 \tTraining Loss: 17.114191 \tValidation Loss: 17.282382\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 3 \tTraining Loss: 17.112787 \tValidation Loss: 17.279775\n",
+ "No improvement in validation loss for 2 epoch(s).\n",
+ "Epoch: 4 \tTraining Loss: 17.114435 \tValidation Loss: 17.270469\n",
+ "Validation loss decreased (17.279689 --> 17.270469). Saving model ...\n",
+ "Epoch: 5 \tTraining Loss: 17.110570 \tValidation Loss: 17.282572\n",
+ "No improvement in validation loss for 1 epoch(s).\n",
+ "Epoch: 6 \tTraining Loss: 17.106720 \tValidation Loss: 17.281430\n",
+ "No improvement in validation loss for 2 epoch(s).\n",
+ "Epoch: 7 \tTraining Loss: 17.106561 \tValidation Loss: 17.282130\n",
+ "No improvement in validation loss for 3 epoch(s).\n",
+ "Early stopping triggered. Stopping training.\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch.optim as optim\n",
+ "\n",
+ "criterion = nn.CrossEntropyLoss() # specify loss function\n",
+ "optimizer = optim.SGD(quantized_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",
+ "trigger = 3 # Number of epochs to wait before stopping\n",
+ "early_stop_counter = 0 # Counter for early stopping\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",
+ " quantized_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 = quantized_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",
+ " quantized_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 = quantized_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(quantized_model.state_dict(), \"model_cifar_quantized.pt\")\n",
+ " valid_loss_min = valid_loss\n",
+ " early_stop_counter = 0 # Reset the counter if validation loss improves\n",
+ " else:\n",
+ " early_stop_counter += 1 # Increment the counter if no improvement\n",
+ " print(f\"No improvement in validation loss for {early_stop_counter} epoch(s).\")\n",
+ "\n",
+ " # Check for early stopping condition\n",
+ " if early_stop_counter >= trigger:\n",
+ " print(\"Early stopping triggered. Stopping training.\")\n",
+ " break"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "id": "2c5913bd",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Test Loss Model Quantized : 21.156928\n",
+ "\n",
+ "Test Accuracy Model Quantized of airplane: 70% (700/1000)\n",
+ "Test Accuracy Model Quantized of automobile: 77% (771/1000)\n",
+ "Test Accuracy Model Quantized of bird: 47% (475/1000)\n",
+ "Test Accuracy Model Quantized of cat: 43% (438/1000)\n",
+ "Test Accuracy Model Quantized of deer: 50% (503/1000)\n",
+ "Test Accuracy Model Quantized of dog: 55% (550/1000)\n",
+ "Test Accuracy Model Quantized of frog: 80% (802/1000)\n",
+ "Test Accuracy Model Quantized of horse: 66% (661/1000)\n",
+ "Test Accuracy Model Quantized of ship: 71% (719/1000)\n",
+ "Test Accuracy Model Quantized of truck: 77% (779/1000)\n",
+ "\n",
+ "Test Accuracy Model Quantized (Overall): 63% (6398/10000)\n"
+ ]
+ },
+ {
+ "ename": "RuntimeError",
+ "evalue": "Error(s) in loading state_dict for Net:\n\tMissing key(s) in state_dict: \"conv3.weight\", \"conv3.bias\", \"fc1.weight\", \"fc1.bias\", \"fc2.weight\", \"fc2.bias\", \"fc3.weight\", \"fc3.bias\". \n\tUnexpected key(s) in state_dict: \"fc1.scale\", \"fc1.zero_point\", \"fc1._packed_params.dtype\", \"fc1._packed_params._packed_params\", \"fc2.scale\", \"fc2.zero_point\", \"fc2._packed_params.dtype\", \"fc2._packed_params._packed_params\", \"fc3.scale\", \"fc3.zero_point\", \"fc3._packed_params.dtype\", \"fc3._packed_params._packed_params\". \n\tsize mismatch for conv1.weight: copying a param with shape torch.Size([6, 3, 5, 5]) from checkpoint, the shape in current model is torch.Size([16, 3, 3, 3]).\n\tsize mismatch for conv1.bias: copying a param with shape torch.Size([6]) from checkpoint, the shape in current model is torch.Size([16]).\n\tsize mismatch for conv2.weight: copying a param with shape torch.Size([16, 6, 5, 5]) from checkpoint, the shape in current model is torch.Size([32, 16, 3, 3]).\n\tsize mismatch for conv2.bias: copying a param with shape torch.Size([16]) from checkpoint, the shape in current model is torch.Size([32]).",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m/var/folders/c_/bcjgdb5j6wq89qpwvs1rl29h0000gn/T/ipykernel_27875/2110516623.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 60\u001b[0m )\n\u001b[1;32m 61\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 62\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_state_dict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"./model_cifar.pt\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 63\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 64\u001b[0m \u001b[0;31m# track test loss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36mload_state_dict\u001b[0;34m(self, state_dict, strict, assign)\u001b[0m\n\u001b[1;32m 2151\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2152\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merror_msgs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2153\u001b[0;31m raise RuntimeError('Error(s) in loading state_dict for {}:\\n\\t{}'.format(\n\u001b[0m\u001b[1;32m 2154\u001b[0m self.__class__.__name__, \"\\n\\t\".join(error_msgs)))\n\u001b[1;32m 2155\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_IncompatibleKeys\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmissing_keys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0munexpected_keys\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mRuntimeError\u001b[0m: Error(s) in loading state_dict for Net:\n\tMissing key(s) in state_dict: \"conv3.weight\", \"conv3.bias\", \"fc1.weight\", \"fc1.bias\", \"fc2.weight\", \"fc2.bias\", \"fc3.weight\", \"fc3.bias\". \n\tUnexpected key(s) in state_dict: \"fc1.scale\", \"fc1.zero_point\", \"fc1._packed_params.dtype\", \"fc1._packed_params._packed_params\", \"fc2.scale\", \"fc2.zero_point\", \"fc2._packed_params.dtype\", \"fc2._packed_params._packed_params\", \"fc3.scale\", \"fc3.zero_point\", \"fc3._packed_params.dtype\", \"fc3._packed_params._packed_params\". \n\tsize mismatch for conv1.weight: copying a param with shape torch.Size([6, 3, 5, 5]) from checkpoint, the shape in current model is torch.Size([16, 3, 3, 3]).\n\tsize mismatch for conv1.bias: copying a param with shape torch.Size([6]) from checkpoint, the shape in current model is torch.Size([16]).\n\tsize mismatch for conv2.weight: copying a param with shape torch.Size([16, 6, 5, 5]) from checkpoint, the shape in current model is torch.Size([32, 16, 3, 3]).\n\tsize mismatch for conv2.bias: copying a param with shape torch.Size([16]) from checkpoint, the shape in current model is torch.Size([32])."
+ ]
+ }
+ ],
+ "source": [
+ "quantized_model.load_state_dict(torch.load(\"./model_cifar_quantized.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",
+ "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 = quantized_model(data)\n",
+ " # calculate the batch loss\n",
+ " loss = criterion(output, target)\n",
+ " # update test loss\n",
+ " test_loss += loss.item() * data.size(0)\n",
+ " # convert output probabilities to predicted class\n",
+ " _, pred = torch.max(output, 1)\n",
+ " # compare predictions to true label\n",
+ " correct_tensor = pred.eq(target.data.view_as(pred))\n",
+ " correct = (\n",
+ " np.squeeze(correct_tensor.numpy())\n",
+ " if not train_on_gpu\n",
+ " else np.squeeze(correct_tensor.cpu().numpy())\n",
+ " )\n",
+ " # calculate test accuracy for each object class\n",
+ " for i in range(batch_size):\n",
+ " label = target.data[i]\n",
+ " class_correct[label] += correct[i].item()\n",
+ " class_total[label] += 1\n",
+ "\n",
+ "# average test loss\n",
+ "test_loss = test_loss / len(test_loader)\n",
+ "print(\"Test Loss Model Quantized : {:.6f}\\n\".format(test_loss))\n",
+ "\n",
+ "for i in range(10):\n",
+ " if class_total[i] > 0:\n",
+ " print(\n",
+ " \"Test Accuracy Model Quantized 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 Model Quantized of %5s: N/A (no training examples)\" % (classes[i]))\n",
+ "\n",
+ "print(\n",
+ " \"\\nTest Accuracy Model Quantized (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",
+ "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 Initial Model : {:.6f}\\n\".format(test_loss))\n",
+ "\n",
+ "for i in range(10):\n",
+ " if class_total[i] > 0:\n",
+ " print(\n",
+ " \"Test Accuracy Initial Model 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 Initial Model of %5s: N/A (no training examples)\" % (classes[i]))\n",
+ "\n",
+ "print(\n",
+ " \"\\nTest Accuracy Initial Model (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": null,
+ "id": "748b1915",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
{
"cell_type": "markdown",
"id": "a0a34b90",
@@ -521,10 +1400,40 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 16,
"id": "b4d13080",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+ " warnings.warn(\n",
+ "/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
+ " warnings.warn(msg)\n",
+ "Downloading: \"https://download.pytorch.org/models/resnet50-0676ba61.pth\" to /Users/paulineramage/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth\n",
+ "100.0%\n"
+ ]
+ },
+ {
+ "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",
@@ -604,10 +1513,27 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 17,
"id": "be2d31f5",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "ename": "FileNotFoundError",
+ "evalue": "[Errno 2] No such file or directory: 'hymenoptera_data/train'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m/var/folders/c_/bcjgdb5j6wq89qpwvs1rl29h0000gn/T/ipykernel_27875/1654466997.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0mdata_dir\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"hymenoptera_data\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[0;31m# Create train and validation datasets and loaders\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 36\u001b[0;31m image_datasets = {\n\u001b[0m\u001b[1;32m 37\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mImageFolder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata_transforms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m\"train\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"val\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/var/folders/c_/bcjgdb5j6wq89qpwvs1rl29h0000gn/T/ipykernel_27875/1654466997.py\u001b[0m in \u001b[0;36m<dictcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[0;31m# Create train and validation datasets and loaders\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m image_datasets = {\n\u001b[0;32m---> 37\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mImageFolder\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata_transforms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 38\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m\"train\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"val\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m }\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torchvision/datasets/folder.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, root, transform, target_transform, loader, is_valid_file)\u001b[0m\n\u001b[1;32m 307\u001b[0m \u001b[0mis_valid_file\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mCallable\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 308\u001b[0m ):\n\u001b[0;32m--> 309\u001b[0;31m super().__init__(\n\u001b[0m\u001b[1;32m 310\u001b[0m \u001b[0mroot\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 311\u001b[0m \u001b[0mloader\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torchvision/datasets/folder.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, root, loader, extensions, transform, target_transform, is_valid_file)\u001b[0m\n\u001b[1;32m 142\u001b[0m ) -> None:\n\u001b[1;32m 143\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mroot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtransform\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_transform\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtarget_transform\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 144\u001b[0;31m \u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclass_to_idx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfind_classes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroot\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 145\u001b[0m \u001b[0msamples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake_dataset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroot\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclass_to_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mextensions\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mis_valid_file\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 146\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torchvision/datasets/folder.py\u001b[0m in \u001b[0;36mfind_classes\u001b[0;34m(self, directory)\u001b[0m\n\u001b[1;32m 216\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mDict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mList\u001b[0m \u001b[0mof\u001b[0m \u001b[0mall\u001b[0m \u001b[0mclasses\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mdictionary\u001b[0m \u001b[0mmapping\u001b[0m \u001b[0meach\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mto\u001b[0m \u001b[0man\u001b[0m \u001b[0mindex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 217\u001b[0m \"\"\"\n\u001b[0;32m--> 218\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfind_classes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdirectory\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 219\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 220\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindex\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mTuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mAny\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mAny\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/opt/anaconda3/envs/infa4/lib/python3.8/site-packages/torchvision/datasets/folder.py\u001b[0m in \u001b[0;36mfind_classes\u001b[0;34m(directory)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0mSee\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;32mclass\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0mDatasetFolder\u001b[0m\u001b[0;31m`\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mdetails\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \"\"\"\n\u001b[0;32m---> 40\u001b[0;31m \u001b[0mclasses\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msorted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mentry\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mentry\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscandir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdirectory\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mentry\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_dir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 41\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mclasses\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mFileNotFoundError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Couldn't find any class folder in {directory}.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'hymenoptera_data/train'"
+ ]
+ }
+ ],
"source": [
"import os\n",
"\n",
@@ -926,7 +1852,7 @@
],
"metadata": {
"kernelspec": {
- "display_name": "Python 3.8.5 ('base')",
+ "display_name": "infa4",
"language": "python",
"name": "python3"
},
@@ -940,12 +1866,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.8.5"
- },
- "vscode": {
- "interpreter": {
- "hash": "9e3efbebb05da2d4a1968abe9a0645745f54b63feb7a85a514e4da0495be97eb"
- }
+ "version": "3.8.13"
}
},
"nbformat": 4,
--
GitLab