diff --git a/Pytorch_tutorial.ipynb b/Pytorch_tutorial.ipynb
index 0a1fd56..7006e24 100644
--- a/Pytorch_tutorial.ipynb
+++ b/Pytorch_tutorial.ipynb
@@ -49,7 +49,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 1,
       "metadata": {
         "collapsed": false
       },
@@ -76,7 +76,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 2,
       "metadata": {
         "collapsed": false
       },
@@ -98,7 +98,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 3,
       "metadata": {
         "collapsed": false
       },
@@ -120,11 +120,26 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 4,
       "metadata": {
         "collapsed": false
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Ones Tensor: \n",
+            " tensor([[1, 1],\n",
+            "        [1, 1]]) \n",
+            "\n",
+            "Random Tensor: \n",
+            " tensor([[0.9229, 0.2183],\n",
+            "        [0.3414, 0.8206]]) \n",
+            "\n"
+          ]
+        }
+      ],
       "source": [
         "x_ones = torch.ones_like(x_data) # retains the properties of x_data\n",
         "print(f\"Ones Tensor: \\n {x_ones} \\n\")\n",
@@ -145,11 +160,29 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 5,
       "metadata": {
         "collapsed": false
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Random Tensor: \n",
+            " tensor([[0.2823, 0.4985, 0.7016],\n",
+            "        [0.8856, 0.5882, 0.3516]]) \n",
+            "\n",
+            "Ones Tensor: \n",
+            " tensor([[1., 1., 1.],\n",
+            "        [1., 1., 1.]]) \n",
+            "\n",
+            "Zeros Tensor: \n",
+            " tensor([[0., 0., 0.],\n",
+            "        [0., 0., 0.]])\n"
+          ]
+        }
+      ],
       "source": [
         "shape = (2,3,)\n",
         "rand_tensor = torch.rand(shape)\n",
@@ -174,11 +207,21 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 6,
       "metadata": {
         "collapsed": false
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Shape of tensor: torch.Size([3, 4])\n",
+            "Datatype of tensor: torch.float32\n",
+            "Device tensor is stored on: cpu\n"
+          ]
+        }
+      ],
       "source": [
         "tensor = torch.rand(3,4)\n",
         "\n",
@@ -213,11 +256,22 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 7,
       "metadata": {
         "collapsed": false
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "tensor([[1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1.]])\n"
+          ]
+        }
+      ],
       "source": [
         "tensor = torch.ones(4, 4)\n",
         "tensor[:,1] = 0\n",
@@ -236,11 +290,22 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 8,
       "metadata": {
         "collapsed": false
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "tensor([[1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1.]])\n"
+          ]
+        }
+      ],
       "source": [
         "t1 = torch.cat([tensor, tensor, tensor], dim=1)\n",
         "print(t1)"
@@ -256,11 +321,29 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 9,
       "metadata": {
         "collapsed": false
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "tensor.mul(tensor) \n",
+            " tensor([[1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1.]]) \n",
+            "\n",
+            "tensor * tensor \n",
+            " tensor([[1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1.]])\n"
+          ]
+        }
+      ],
       "source": [
         "# This computes the element-wise product\n",
         "print(f\"tensor.mul(tensor) \\n {tensor.mul(tensor)} \\n\")\n",
@@ -278,11 +361,29 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 10,
       "metadata": {
         "collapsed": false
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "tensor.matmul(tensor.T) \n",
+            " tensor([[3., 3., 3., 3.],\n",
+            "        [3., 3., 3., 3.],\n",
+            "        [3., 3., 3., 3.],\n",
+            "        [3., 3., 3., 3.]]) \n",
+            "\n",
+            "tensor @ tensor.T \n",
+            " tensor([[3., 3., 3., 3.],\n",
+            "        [3., 3., 3., 3.],\n",
+            "        [3., 3., 3., 3.],\n",
+            "        [3., 3., 3., 3.]])\n"
+          ]
+        }
+      ],
       "source": [
         "print(f\"tensor.matmul(tensor.T) \\n {tensor.matmul(tensor.T)} \\n\")\n",
         "# Alternative syntax:\n",
@@ -300,11 +401,27 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 11,
       "metadata": {
         "collapsed": false
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "tensor([[1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1.],\n",
+            "        [1., 0., 1., 1.]]) \n",
+            "\n",
+            "tensor([[6., 5., 6., 6.],\n",
+            "        [6., 5., 6., 6.],\n",
+            "        [6., 5., 6., 6.],\n",
+            "        [6., 5., 6., 6.]])\n"
+          ]
+        }
+      ],
       "source": [
         "print(tensor, \"\\n\")\n",
         "tensor.add_(5)\n",
@@ -335,11 +452,20 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 12,
       "metadata": {
         "collapsed": false
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "t: tensor([1., 1., 1., 1., 1.])\n",
+            "n: [1. 1. 1. 1. 1.]\n"
+          ]
+        }
+      ],
       "source": [
         "t = torch.ones(5)\n",
         "print(f\"t: {t}\")\n",
@@ -357,11 +483,20 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 13,
       "metadata": {
         "collapsed": false
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "t: tensor([2., 2., 2., 2., 2.])\n",
+            "n: [2. 2. 2. 2. 2.]\n"
+          ]
+        }
+      ],
       "source": [
         "t.add_(1)\n",
         "print(f\"t: {t}\")\n",
@@ -378,7 +513,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 14,
       "metadata": {
         "collapsed": false
       },
@@ -398,24 +533,26 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 15,
       "metadata": {
         "collapsed": false
       },
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "t: tensor([2., 2., 2., 2., 2.], dtype=torch.float64)\n",
+            "n: [2. 2. 2. 2. 2.]\n"
+          ]
+        }
+      ],
       "source": [
         "np.add(n, 1, out=n)\n",
         "print(f\"t: {t}\")\n",
         "print(f\"n: {n}\")"
       ]
     },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -463,9 +600,22 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 16,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/Users/ricardofernandezgasca/Library/Python/3.9/lib/python/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",
+            "/Users/ricardofernandezgasca/Library/Python/3.9/lib/python/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.\n",
+            "  warnings.warn(msg)\n",
+            "Downloading: \"https://download.pytorch.org/models/resnet18-f37072fd.pth\" to /Users/ricardofernandezgasca/.cache/torch/hub/checkpoints/resnet18-f37072fd.pth\n",
+            "100%|██████████| 44.7M/44.7M [00:02<00:00, 22.8MB/s]\n"
+          ]
+        }
+      ],
       "source": [
         "import torch, torchvision\n",
         "model = torchvision.models.resnet18(pretrained=True)\n",
@@ -483,7 +633,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 17,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -502,7 +652,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 18,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -523,7 +673,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 19,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -545,7 +695,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 62,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -566,7 +716,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 63,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -599,9 +749,18 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 64,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "tensor([True, True])\n",
+            "tensor([True, True])\n"
+          ]
+        }
+      ],
       "source": [
         "external_grad = torch.tensor([1., 1.])\n",
         "\n",
@@ -613,6 +772,23 @@
         "print(-2*b == b.grad)"
       ]
     },
+    {
+      "cell_type": "code",
+      "execution_count": 65,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "tensor([36., 81.])\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(a.grad)"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -662,9 +838,18 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 23,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Does `a` require gradients? : False\n",
+            "Does `b` require gradients?: True\n"
+          ]
+        }
+      ],
       "source": [
         "x = torch.rand(5, 5)\n",
         "y = torch.rand(5, 5)\n",
@@ -693,7 +878,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 24,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -719,7 +904,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 25,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -778,9 +963,23 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 26,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Net(\n",
+            "  (conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1))\n",
+            "  (conv2): Conv2d(6, 16, kernel_size=(3, 3), stride=(1, 1))\n",
+            "  (fc1): Linear(in_features=576, 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\n",
         "import torch.nn as nn\n",
@@ -837,9 +1036,18 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 27,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "10\n",
+            "torch.Size([6, 1, 3, 3])\n"
+          ]
+        }
+      ],
       "source": [
         "params = list(net.parameters())\n",
         "print(len(params))\n",
@@ -857,9 +1065,18 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 28,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "tensor([[-0.1169, -0.0242,  0.0129, -0.0244, -0.0688, -0.1314, -0.1218,  0.0423,\n",
+            "          0.0293, -0.0737]], grad_fn=<AddmmBackward0>)\n"
+          ]
+        }
+      ],
       "source": [
         "input = torch.randn(1, 1, 32, 32)\n",
         "out = net(input)\n",
@@ -876,7 +1093,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 29,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -940,9 +1157,17 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 30,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "tensor(0.7413, grad_fn=<MseLossBackward0>)\n"
+          ]
+        }
+      ],
       "source": [
         "output = net(input)\n",
         "target = torch.randn(10)  # a dummy target, for example\n",
@@ -977,9 +1202,19 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 31,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "<MseLossBackward0 object at 0x137ea3790>\n",
+            "<AddmmBackward0 object at 0x137ea39d0>\n",
+            "<AccumulateGrad object at 0x137ea3790>\n"
+          ]
+        }
+      ],
       "source": [
         "print(loss.grad_fn)  # MSELoss\n",
         "print(loss.grad_fn.next_functions[0][0])  # Linear\n",
@@ -1003,9 +1238,20 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 32,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "conv1.bias.grad before backward\n",
+            "None\n",
+            "conv1.bias.grad after backward\n",
+            "tensor([-0.0022, -0.0004,  0.0064,  0.0133, -0.0073, -0.0091])\n"
+          ]
+        }
+      ],
       "source": [
         "net.zero_grad()     # zeroes the gradient buffers of all parameters\n",
         "\n",
@@ -1056,7 +1302,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 33,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -1136,7 +1382,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 34,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -1155,9 +1401,32 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 35,
+      "metadata": {},
+      "outputs": [
+        {
+          "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 [00:11<00:00, 14264175.99it/s]\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Extracting ./data/cifar-10-python.tar.gz to ./data\n",
+            "Files already downloaded and verified\n"
+          ]
+        }
+      ],
       "source": [
         "transform = transforms.Compose(\n",
         "    [transforms.ToTensor(),\n",
@@ -1191,9 +1460,36 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 36,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "batch size: 4\n",
+            "color channels : 3\n",
+            "Image size:32x32\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            " deer\t   car\t  frog\t  bird\t\n"
+          ]
+        }
+      ],
       "source": [
         "import matplotlib.pyplot as plt\n",
         "import numpy as np\n",
@@ -1221,6 +1517,26 @@
         "print(' '.join('%5s\\t' % classes[labels[j]] for j in range(4)))"
       ]
     },
+    {
+      "cell_type": "code",
+      "execution_count": 67,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "2.1.2\n"
+          ]
+        }
+      ],
+      "source": [
+        "import torch.version\n",
+        "\n",
+        "\n",
+        "print(torch.__version__)"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -1246,14 +1562,82 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 37,
       "metadata": {},
       "outputs": [],
       "source": [
         "\n",
         "## TO BE COMPLETED !!!\n",
         "import torch.nn as nn\n",
-        "import torch.nn.functional as F\n"
+        "import torch.nn.functional as F\n",
+        "\n",
+        "class Net(nn.Module):\n",
+        "\n",
+        "    def __init__(self):\n",
+        "        super(Net, self).__init__()\n",
+        "        # 3 input image channel, 6 output channels, 3x3 square convolution\n",
+        "        # kernel\n",
+        "        self.conv1 = nn.Conv2d(3, 6, 3)\n",
+        "        self.conv2 = nn.Conv2d(6, 16, 3)\n",
+        "        # an affine operation: y = Wx + b\n",
+        "        self.fc1 = nn.Linear(16 * 6 * 6, 120)  # 6*6 from image dimension, 16 for channels\n",
+        "        self.fc2 = nn.Linear(120, 84)\n",
+        "        self.fc3 = nn.Linear(84, 10)\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        # Max pooling over a (2, 2) window\n",
+        "        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))\n",
+        "        # If the size is a square you can only specify a single number\n",
+        "        x = F.max_pool2d(F.relu(self.conv2(x)), 2)\n",
+        "        x = x.view(-1, self.num_flat_features(x))\n",
+        "        x = F.relu(self.fc1(x))\n",
+        "        x = F.relu(self.fc2(x))\n",
+        "        x = self.fc3(x)\n",
+        "        return x\n",
+        "\n",
+        "    def num_flat_features(self, x):\n",
+        "        size = x.size()[1:]  # all dimensions except the batch dimension\n",
+        "        num_features = 1\n",
+        "        for s in size:\n",
+        "            num_features *= s\n",
+        "        return num_features\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 77,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "----------------------------------------------------------------\n",
+            "        Layer (type)               Output Shape         Param #\n",
+            "================================================================\n",
+            "            Conv2d-1            [-1, 6, 30, 30]             168\n",
+            "            Conv2d-2           [-1, 16, 13, 13]             880\n",
+            "            Linear-3                  [-1, 120]          69,240\n",
+            "            Linear-4                   [-1, 84]          10,164\n",
+            "            Linear-5                   [-1, 10]             850\n",
+            "================================================================\n",
+            "Total params: 81,302\n",
+            "Trainable params: 81,302\n",
+            "Non-trainable params: 0\n",
+            "----------------------------------------------------------------\n",
+            "Input size (MB): 0.01\n",
+            "Forward/backward pass size (MB): 0.06\n",
+            "Params size (MB): 0.31\n",
+            "Estimated Total Size (MB): 0.39\n",
+            "----------------------------------------------------------------\n"
+          ]
+        }
+      ],
+      "source": [
+        "from torchsummary import summary\n",
+        "net = Net()\n",
+        "summary(net, (3, 32, 32))"
       ]
     },
     {
@@ -1267,12 +1651,16 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 50,
       "metadata": {},
       "outputs": [],
       "source": [
-        "# TO BE COMPLETED !!!\n",
-        "import torch.optim as optim\n"
+        "import torch.optim as optim\n",
+        "# Cross entropy loss and SDG with momentum\n",
+        "criterion = nn.CrossEntropyLoss()\n",
+        "\n",
+        "net = Net()\n",
+        "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)\n"
       ]
     },
     {
@@ -1288,13 +1676,226 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "n_epochs=2\n",
-        "\n",
-        "for epoch in range(n_epochs):  # loop over the dataset multiple times\n",
+      "execution_count": 51,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "  0%|          | 0/10 [00:00<?, ?it/s]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[1,  2000] loss: 2.246\n",
+            "[1,  4000] loss: 1.883\n",
+            "[1,  6000] loss: 1.675\n",
+            "[1,  8000] loss: 1.565\n",
+            "[1, 10000] loss: 1.498\n",
+            "[1, 12000] loss: 1.439\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 10%|█         | 1/10 [00:30<04:36, 30.74s/it]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[2,  2000] loss: 1.359\n",
+            "[2,  4000] loss: 1.316\n",
+            "[2,  6000] loss: 1.298\n",
+            "[2,  8000] loss: 1.260\n",
+            "[2, 10000] loss: 1.250\n",
+            "[2, 12000] loss: 1.218\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 20%|██        | 2/10 [01:00<04:03, 30.45s/it]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[3,  2000] loss: 1.135\n",
+            "[3,  4000] loss: 1.157\n",
+            "[3,  6000] loss: 1.140\n",
+            "[3,  8000] loss: 1.122\n",
+            "[3, 10000] loss: 1.106\n",
+            "[3, 12000] loss: 1.091\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 30%|███       | 3/10 [01:30<03:31, 30.17s/it]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[4,  2000] loss: 1.015\n",
+            "[4,  4000] loss: 1.048\n",
+            "[4,  6000] loss: 1.026\n",
+            "[4,  8000] loss: 1.008\n",
+            "[4, 10000] loss: 1.039\n",
+            "[4, 12000] loss: 1.030\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 40%|████      | 4/10 [02:00<03:00, 30.04s/it]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[5,  2000] loss: 0.951\n",
+            "[5,  4000] loss: 0.946\n",
+            "[5,  6000] loss: 0.940\n",
+            "[5,  8000] loss: 0.956\n",
+            "[5, 10000] loss: 0.940\n",
+            "[5, 12000] loss: 0.956\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 50%|█████     | 5/10 [02:31<02:31, 30.26s/it]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[6,  2000] loss: 0.848\n",
+            "[6,  4000] loss: 0.833\n",
+            "[6,  6000] loss: 0.901\n",
+            "[6,  8000] loss: 0.878\n",
+            "[6, 10000] loss: 0.891\n",
+            "[6, 12000] loss: 0.909\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 60%|██████    | 6/10 [03:01<02:01, 30.34s/it]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[7,  2000] loss: 0.783\n",
+            "[7,  4000] loss: 0.802\n",
+            "[7,  6000] loss: 0.837\n",
+            "[7,  8000] loss: 0.819\n",
+            "[7, 10000] loss: 0.844\n",
+            "[7, 12000] loss: 0.847\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 70%|███████   | 7/10 [03:32<01:31, 30.37s/it]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[8,  2000] loss: 0.715\n",
+            "[8,  4000] loss: 0.764\n",
+            "[8,  6000] loss: 0.779\n",
+            "[8,  8000] loss: 0.795\n",
+            "[8, 10000] loss: 0.797\n",
+            "[8, 12000] loss: 0.785\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 80%|████████  | 8/10 [04:02<01:00, 30.28s/it]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[9,  2000] loss: 0.656\n",
+            "[9,  4000] loss: 0.725\n",
+            "[9,  6000] loss: 0.723\n",
+            "[9,  8000] loss: 0.736\n",
+            "[9, 10000] loss: 0.755\n",
+            "[9, 12000] loss: 0.762\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            " 90%|█████████ | 9/10 [04:32<00:30, 30.29s/it]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "[10,  2000] loss: 0.625\n",
+            "[10,  4000] loss: 0.679\n",
+            "[10,  6000] loss: 0.685\n",
+            "[10,  8000] loss: 0.714\n",
+            "[10, 10000] loss: 0.735\n",
+            "[10, 12000] loss: 0.710\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "100%|██████████| 10/10 [05:02<00:00, 30.27s/it]"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Finished Training\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "from tqdm import tqdm\n",
+        "n_epochs=10\n",
+        "\n",
+        "for epoch in tqdm(range(n_epochs)):  # loop over the dataset multiple times\n",
         "\n",
         "    running_loss = 0.0\n",
         "    for i, data in enumerate(trainloader, 0):\n",
@@ -1329,7 +1930,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 52,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -1357,9 +1958,27 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 53,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "GroundTruth:    cat  ship  ship plane\n"
+          ]
+        }
+      ],
       "source": [
         "dataiter = iter(testloader)\n",
         "images, labels = next(dataiter)\n",
@@ -1379,9 +1998,20 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 54,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "<All keys matched successfully>"
+            ]
+          },
+          "execution_count": 54,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
       "source": [
         "net = Net()\n",
         "net.load_state_dict(torch.load(PATH))"
@@ -1401,9 +2031,17 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 55,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Predicted:    dog  ship  ship  ship\n"
+          ]
+        }
+      ],
       "source": [
         "outputs = net(images)\n",
         "\n",
@@ -1422,9 +2060,17 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 56,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Accuracy of the network on the 10000 test images: 63 %\n"
+          ]
+        }
+      ],
       "source": [
         "correct = 0\n",
         "total = 0\n",
@@ -1454,12 +2100,31 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
+      "execution_count": 69,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Accuracy of plane : 67 %\n",
+            "Accuracy of   car : 74 %\n",
+            "Accuracy of  bird : 52 %\n",
+            "Accuracy of   cat : 35 %\n",
+            "Accuracy of  deer : 60 %\n",
+            "Accuracy of   dog : 59 %\n",
+            "Accuracy of  frog : 61 %\n",
+            "Accuracy of horse : 70 %\n",
+            "Accuracy of  ship : 85 %\n",
+            "Accuracy of truck : 68 %\n"
+          ]
+        }
+      ],
       "source": [
         "class_correct = list(0. for i in range(10))\n",
         "class_total = list(0. for i in range(10))\n",
+        "predicted_list = []\n",
+        "labels_list = []\n",
         "with torch.no_grad():\n",
         "    for data in testloader:\n",
         "        images, labels = data\n",
@@ -1471,12 +2136,47 @@
         "            class_correct[label] += c[i].item()\n",
         "            class_total[label] += 1\n",
         "\n",
+        "            predicted_list.append(predicted[i].item())\n",
+        "            labels_list.append(label.item())\n",
         "\n",
         "for i in range(10):\n",
         "    print('Accuracy of %5s : %2d %%' % (\n",
         "        classes[i], 100 * class_correct[i] / class_total[i]))"
       ]
     },
+    {
+      "cell_type": "code",
+      "execution_count": 73,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1000x700 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# Print a confusion matrix\n",
+        "from sklearn.metrics import confusion_matrix\n",
+        "import matplotlib.pyplot as plt\n",
+        "import seaborn as sns\n",
+        "\n",
+        "conf_mat = confusion_matrix(labels_list, predicted_list)\n",
+        "label_names = [classes[label] for label in labels_list]\n",
+        "\n",
+        "# Create a heatmap from the confusion matrix\n",
+        "plt.figure(figsize=(10, 7))\n",
+        "sns.heatmap(conf_mat, annot=True, fmt='d', xticklabels=classes, yticklabels=classes)\n",
+        "plt.xlabel('Predicted')\n",
+        "plt.ylabel('True')\n",
+        "plt.show()\n"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -1496,15 +2196,20 @@
     },
     {
       "cell_type": "code",
-      "execution_count": null,
+      "execution_count": 66,
       "metadata": {},
-      "outputs": [],
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "mps\n"
+          ]
+        }
+      ],
       "source": [
-        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
-        "\n",
-        "# Assuming that we are on a CUDA machine, this should print a CUDA device:\n",
-        "\n",
-        "print(device)"
+        "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cpu\")\n",
+        "print(device)\n"
       ]
     },
     {
@@ -1556,7 +2261,7 @@
       "name": "python",
       "nbconvert_exporter": "python",
       "pygments_lexer": "ipython3",
-      "version": "3.10.12"
+      "version": "3.9.6"
     }
   },
   "nbformat": 4,
diff --git a/lab_1_OA_RF.ipynb b/lab_1_OA_RF.ipynb
new file mode 100644
index 0000000..2914f16
--- /dev/null
+++ b/lab_1_OA_RF.ipynb
@@ -0,0 +1,3392 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Files already downloaded and verified\n",
+      "Files already downloaded and verified\n"
+     ]
+    }
+   ],
+   "source": [
+    "from torchvision.datasets import CIFAR10\n",
+    "import numpy as np \n",
+    "import torchvision.transforms as transforms\n",
+    "import torch \n",
+    "from torch.utils.data.dataloader import DataLoader\n",
+    "\n",
+    "## Normalization adapted for CIFAR10\n",
+    "normalize_scratch = transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n",
+    "\n",
+    "# Transforms is a list of transformations applied on the 'raw' dataset before the data is fed to the network. \n",
+    "# Here, Data augmentation (RandomCrop and Horizontal Flip) are applied to each batch, differently at each epoch, on the training set data only\n",
+    "transform_train = transforms.Compose([\n",
+    "    transforms.RandomCrop(32, padding=4),\n",
+    "    transforms.RandomHorizontalFlip(),\n",
+    "    transforms.ToTensor(),\n",
+    "    normalize_scratch,\n",
+    "])\n",
+    "\n",
+    "transform_test = transforms.Compose([\n",
+    "    transforms.ToTensor(),\n",
+    "    normalize_scratch,\n",
+    "])\n",
+    "\n",
+    "### The data from CIFAR10 will be downloaded in the following folder\n",
+    "rootdir = './data/cifar10'\n",
+    "\n",
+    "c10train = CIFAR10(rootdir,train=True,download=True,transform=transform_train)\n",
+    "c10test = CIFAR10(rootdir,train=False,download=True,transform=transform_test)\n",
+    "\n",
+    "trainloader = DataLoader(c10train,batch_size=32,shuffle=True)\n",
+    "testloader = DataLoader(c10test,batch_size=32) \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of training examples:  50000\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Number of training examples: ',len(c10train))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initial CIFAR10 dataset has 50000 samples\n",
+      "Subset of CIFAR10 dataset has 15000 samples\n"
+     ]
+    }
+   ],
+   "source": [
+    "## number of target samples for the final dataset\n",
+    "num_train_examples = len(c10train)\n",
+    "num_samples_subset = 15000\n",
+    "\n",
+    "## We set a seed manually so as to reproduce the results easily\n",
+    "seed  = 2147483647\n",
+    "\n",
+    "## Generate a list of shuffled indices ; with the fixed seed, the permutation will always be the same, for reproducibility\n",
+    "indices = list(range(num_train_examples))\n",
+    "np.random.RandomState(seed=seed).shuffle(indices)## modifies the list in place\n",
+    "\n",
+    "## We define the Subset using the generated indices \n",
+    "c10train_subset = torch.utils.data.Subset(c10train,indices[:num_samples_subset])\n",
+    "print(f\"Initial CIFAR10 dataset has {len(c10train)} samples\")\n",
+    "print(f\"Subset of CIFAR10 dataset has {len(c10train_subset)} samples\")\n",
+    "\n",
+    "# Finally we can define anoter dataloader for the training data\n",
+    "trainloader_subset = DataLoader(c10train_subset,batch_size=16,shuffle=True,num_workers=1)\n",
+    "### You can now use either trainloader (full CIFAR10) or trainloader_subset (subset of CIFAR10) to train your networks."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Get ResNet from pytorch models\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "from torchvision.models import resnet18\n",
+    "\n",
+    "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cpu\")\n",
+    "model = resnet18()\n",
+    "\n",
+    "model.fc = nn.Linear(512,10)\n",
+    "model = model.to(device)\n",
+    "\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.SGD(model.parameters(),lr=0.001,momentum=0.9,weight_decay=5e-4)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "def train_model(model, trainloader, device, optimizer, criterion, epochs=50, save_path=None):\n",
+    "    model.train()\n",
+    "\n",
+    "    loss_values = []  # Empty list to store the loss values\n",
+    "    for epoch in tqdm(range(epochs), desc='Training', unit='epochs'):\n",
+    "        running_loss = 0.0\n",
+    "        for i, data in enumerate(trainloader,0):\n",
+    "            inputs,labels = data\n",
+    "            inputs,labels = inputs.to(device),labels.to(device)\n",
+    "            optimizer.zero_grad()\n",
+    "            outputs = model(inputs)\n",
+    "            loss = criterion(outputs,labels)\n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "            running_loss += loss.item()\n",
+    "            if i % 100 == 99:\n",
+    "                #print(f'[{epoch+1}] loss: {running_loss/100}')\n",
+    "                loss_values.append(running_loss/100)  # Append the loss value to the list\n",
+    "                running_loss = 0.0\n",
+    "    if save_path:\n",
+    "        # Save the model\n",
+    "        torch.save(model.state_dict(), save_path + '.pth')\n",
+    "\n",
+    "\n",
+    "\n",
+    "    # Plotting the loss values\n",
+    "    plt.plot(loss_values)\n",
+    "    plt.xlabel('Iteration')\n",
+    "    plt.ylabel('Loss')\n",
+    "    plt.title('Loss at each iteration')\n",
+    "    plt.show()\n",
+    "    return loss_values\n",
+    "#train_model(model, trainloader_subset, device, optimizer, criterion, epochs=50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Save the model\n",
+    "torch.save(model.state_dict(), 'RsNt18_subset_50epochs.pth')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load the model\n",
+    "model.load_state_dict(torch.load('RsNt18_subset_50epochs.pth'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "label_mapping = {0: 'airplane', 1: 'automobile', 2: 'bird', 3: 'cat', 4: 'deer', 5: 'dog', 6: 'frog', 7: 'horse', 8: 'ship', 9: 'truck'}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import confusion_matrix, accuracy_score\n",
+    "\n",
+    "def evaluate_model(testloader, model, device, label_mapping):\n",
+    "    # Initialize the model to evaluation mode\n",
+    "    predicted_labels = []\n",
+    "    true_labels = []\n",
+    "    model.eval()\n",
+    "    with torch.no_grad():\n",
+    "        for data in testloader:\n",
+    "            images, labels = data\n",
+    "            images, labels = images.to(device), labels.to(device)\n",
+    "            outputs = model(images)\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "\n",
+    "            predicted_labels.extend(predicted.cpu().numpy())\n",
+    "            true_labels.extend(labels.cpu().numpy())\n",
+    "    accuracy_global = accuracy_score(true_labels, predicted_labels)\n",
+    "    print(f\"Global accuracy: {accuracy_global}\")\n",
+    "\n",
+    "    # Create the confusion matrix\n",
+    "    cm = confusion_matrix(true_labels, predicted_labels)\n",
+    "\n",
+    "    # Calculate accuracy by label\n",
+    "    accuracy_by_label = {}\n",
+    "    for i in range(len(label_mapping)):\n",
+    "        label = label_mapping[i]\n",
+    "        indices = np.where(np.array(true_labels) == i)[0]\n",
+    "        accuracy = accuracy_score(np.array(true_labels)[indices], np.array(predicted_labels)[indices])\n",
+    "        accuracy_by_label[label] = accuracy\n",
+    "    \n",
+    "\n",
+    "    # Print the confusion matrix and accuracy by label\n",
+    "    print(\"Confusion Matrix:\")\n",
+    "    print(cm)\n",
+    "    print(\"\\nAccuracy by Label:\")\n",
+    "    for label, accuracy in accuracy_by_label.items():\n",
+    "        print(f\"{label}: {accuracy}\")\n",
+    "    return accuracy_global, accuracy_by_label"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Training: 100%|██████████| 50/50 [42:32<00:00, 51.05s/epochs]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "criterion = nn.CrossEntropyLoss() \n",
+    "model_subset = resnet18()\n",
+    "model_subset.fc = nn.Linear(512,10)\n",
+    "model_subset = model_subset.to(device)\n",
+    "model_subset.load_state_dict(torch.load('RsNt18_subset_50epochs.pth'))\n",
+    "optimizer_subset = torch.optim.Adam(model_subset.parameters(), lr=0.008)\n",
+    "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer_subset, 'min', patience=3, verbose=True)\n",
+    "loss=train_model(model_subset, trainloader_subset, device, optimizer_subset, criterion, save_path='RsNt18_subset_50epochs_lr001_noDecay_batchsize16', epochs=50)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Global accuracy: 0.7802\n",
+      "Confusion Matrix:\n",
+      "[[725  19  36  20  10   7   8   9 143  23]\n",
+      " [  8 890   3   4   2   3   5   0  33  52]\n",
+      " [ 36   4 714  69  57  39  37   8  24  12]\n",
+      " [ 11   9  51 687  44 131  28  11  20   8]\n",
+      " [ 12   3  42  71 814  14  16  17  11   0]\n",
+      " [  5   3  39 169  45 698  11  17  10   3]\n",
+      " [  5   8  39 102  35  14 773   3  19   2]\n",
+      " [ 10   2  30  64  64  80   5 728   3  14]\n",
+      " [ 15  13   6   5   3   2   1   0 941  14]\n",
+      " [ 12  90   6  11   1   4   5   4  35 832]]\n",
+      "\n",
+      "Accuracy by Label:\n",
+      "airplane: 0.725\n",
+      "automobile: 0.89\n",
+      "bird: 0.714\n",
+      "cat: 0.687\n",
+      "deer: 0.814\n",
+      "dog: 0.698\n",
+      "frog: 0.773\n",
+      "horse: 0.728\n",
+      "ship: 0.941\n",
+      "truck: 0.832\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Evaluate the model\n",
+    "loss_model_subset = loss\n",
+    "accuracy_global, accuracy_by_label = evaluate_model(testloader, model_subset, device, label_mapping)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Train model with all data\n",
+    "model_all_data = resnet18()\n",
+    "model_all_data.fc = nn.Linear(512,10)\n",
+    "model_all_data = model_all_data.to(device)\n",
+    "optimizer_all_data = optim.SGD(model_all_data.parameters(),lr=0.001,momentum=0.9,weight_decay=5e-4)\n",
+    "train_model(model_all_data, trainloader, device, optimizer_all_data, criterion, epochs=10, save_path='RsNt18_all_data_50epochs')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Evaluate the model trained with all data and the model trained with the subset\n",
+    "evaluate_model(testloader, model_all_data, device, label_mapping)\n",
+    "evaluate_model(testloader, model, device, label_mapping)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Implement a hyperparameter search with Optuna\n",
+    "import optuna\n",
+    "\n",
+    "def objective(trial):\n",
+    "    # Generate a trial model\n",
+    "    model = resnet18()\n",
+    "    model.fc = nn.Linear(512,10)\n",
+    "    model = model.to(device)\n",
+    "\n",
+    "    # Generate a trial optimizer\n",
+    "    optimizer = optim.SGD(model.parameters(), lr=trial.suggest_loguniform('lr', 0.001, 0.007), momentum=0.9, weight_decay=5e-4)\n",
+    "\n",
+    "    # Train the model\n",
+    "    train_model(model, trainloader_subset, device, optimizer, criterion, epochs= trial.suggest_int('epochs', 50, 200), save_path='Optuna_model')\n",
+    "\n",
+    "    # Evaluate the model\n",
+    "    model.eval()\n",
+    "    accuracy,_ = evaluate_model(testloader, model, device, label_mapping)\n",
+    "\n",
+    "    # Calculate the accuracy\n",
+    "\n",
+    "    return accuracy\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[I 2024-04-09 17:52:05,693] A new study created in memory with name: no-name-6990be50-95f8-40d0-9d9d-0b6951a432c2\n",
+      "/var/folders/z8/5xwgt9dn43n0_s6896y6y4yc0000gn/T/ipykernel_99236/3164015185.py:11: FutureWarning: suggest_loguniform has been deprecated in v3.0.0. This feature will be removed in v6.0.0. See https://github.com/optuna/optuna/releases/tag/v3.0.0. Use suggest_float(..., log=True) instead.\n",
+      "  optimizer = optim.SGD(model.parameters(), lr=trial.suggest_loguniform('lr', 0.001, 0.007), momentum=0.9, weight_decay=5e-4)\n",
+      "  1%|          | 1/168 [00:14<39:02, 14.03s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1] loss: 9.422862590551377\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  1%|          | 2/168 [00:27<38:05, 13.77s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2] loss: 7.792450266480446\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  2%|▏         | 3/168 [00:41<37:51, 13.76s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[3] loss: 7.237838609218597\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  2%|▏         | 4/168 [00:54<37:25, 13.69s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[4] loss: 6.76401636660099\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  3%|▎         | 5/168 [01:08<36:59, 13.62s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[5] loss: 6.309144909381867\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  4%|▎         | 6/168 [01:22<36:54, 13.67s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[6] loss: 5.934114470481872\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  4%|▍         | 7/168 [01:35<36:42, 13.68s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[7] loss: 5.630524178743363\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  5%|▍         | 8/168 [01:49<36:34, 13.72s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[8] loss: 5.36318727016449\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  5%|▌         | 9/168 [02:03<36:27, 13.76s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[9] loss: 5.1021829730272295\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  6%|▌         | 10/168 [02:17<36:12, 13.75s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[10] loss: 4.905500646829605\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  7%|▋         | 11/168 [02:31<35:58, 13.75s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[11] loss: 4.760140551328659\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  7%|▋         | 12/168 [02:44<35:51, 13.79s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[12] loss: 4.524000889658928\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  8%|▊         | 13/168 [02:59<36:19, 14.06s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[13] loss: 4.430608091056347\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  8%|▊         | 14/168 [03:13<36:06, 14.07s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[14] loss: 4.276755943596363\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  9%|▉         | 15/168 [03:27<35:49, 14.05s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[15] loss: 4.161425115466118\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 10%|▉         | 16/168 [03:41<35:32, 14.03s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[16] loss: 4.023747999370098\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 10%|█         | 17/168 [03:55<35:24, 14.07s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[17] loss: 3.903548299074173\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 11%|█         | 18/168 [04:10<35:27, 14.19s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[18] loss: 3.778951304554939\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 11%|█▏        | 19/168 [04:25<35:36, 14.34s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[19] loss: 3.7077313578128814\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 12%|█▏        | 20/168 [04:39<35:27, 14.38s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[20] loss: 3.5651040276885033\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 12%|█▎        | 21/168 [04:53<34:59, 14.28s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[21] loss: 3.55243594199419\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 13%|█▎        | 22/168 [05:07<34:18, 14.10s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[22] loss: 3.4191235914826392\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 14%|█▎        | 23/168 [05:20<33:44, 13.96s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[23] loss: 3.357293419241905\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 14%|█▍        | 24/168 [05:35<34:07, 14.22s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[24] loss: 3.2862638112902642\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 15%|█▍        | 25/168 [05:49<33:55, 14.24s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[25] loss: 3.187322819828987\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 15%|█▌        | 26/168 [06:03<33:21, 14.09s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[26] loss: 3.1213694149255753\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 16%|█▌        | 27/168 [06:17<33:03, 14.07s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[27] loss: 3.122536995112896\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 17%|█▋        | 28/168 [06:31<32:45, 14.04s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[28] loss: 3.0145498180389403\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 17%|█▋        | 29/168 [06:45<32:23, 13.98s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[29] loss: 2.9679759526252747\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 18%|█▊        | 30/168 [06:59<31:53, 13.87s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[30] loss: 2.8826093554496763\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 18%|█▊        | 31/168 [07:12<31:31, 13.81s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[31] loss: 2.782070584446192\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 19%|█▉        | 32/168 [07:26<31:09, 13.74s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[32] loss: 2.75589305087924\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 20%|█▉        | 33/168 [07:40<30:53, 13.73s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[33] loss: 2.709947653710842\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 20%|██        | 34/168 [07:53<30:37, 13.71s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[34] loss: 2.6628180238604546\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 21%|██        | 35/168 [08:07<30:22, 13.71s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[35] loss: 2.6106252306699753\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 21%|██▏       | 36/168 [08:21<30:05, 13.68s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[36] loss: 2.5751957762241364\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 22%|██▏       | 37/168 [08:34<29:47, 13.64s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[37] loss: 2.51325913310051\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 23%|██▎       | 38/168 [08:48<29:31, 13.62s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[38] loss: 2.4061092899739744\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 23%|██▎       | 39/168 [09:01<29:18, 13.63s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[39] loss: 2.4305035816133023\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 24%|██▍       | 40/168 [09:15<29:03, 13.62s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[40] loss: 2.3803510518372057\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 24%|██▍       | 41/168 [09:29<28:50, 13.63s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[41] loss: 2.322143271267414\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 25%|██▌       | 42/168 [09:42<28:42, 13.67s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[42] loss: 2.3018843917548657\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 26%|██▌       | 43/168 [09:56<28:27, 13.66s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[43] loss: 2.2576945407688616\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 26%|██▌       | 44/168 [10:10<28:10, 13.64s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[44] loss: 2.1925941367447375\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 27%|██▋       | 45/168 [10:23<28:00, 13.66s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[45] loss: 2.136726848110557\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 27%|██▋       | 46/168 [10:37<27:51, 13.70s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[46] loss: 2.178995748460293\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 28%|██▊       | 47/168 [10:51<27:40, 13.73s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[47] loss: 2.0870420104265213\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 29%|██▊       | 48/168 [11:05<27:29, 13.74s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[48] loss: 2.016331396996975\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 29%|██▉       | 49/168 [11:19<27:20, 13.79s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[49] loss: 2.0857494173944\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 30%|██▉       | 50/168 [11:32<27:06, 13.78s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[50] loss: 2.0270586272329094\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 30%|███       | 51/168 [11:46<26:56, 13.82s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[51] loss: 1.9730391503870488\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 31%|███       | 52/168 [12:00<26:45, 13.84s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[52] loss: 1.9105470160394906\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 32%|███▏      | 53/168 [12:14<26:23, 13.77s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[53] loss: 1.9259834749251603\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 32%|███▏      | 54/168 [12:27<26:02, 13.70s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[54] loss: 1.9210965149104595\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 33%|███▎      | 55/168 [12:41<25:46, 13.68s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[55] loss: 1.909306999593973\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 33%|███▎      | 56/168 [12:55<25:33, 13.70s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[56] loss: 1.8231822603940964\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 34%|███▍      | 57/168 [13:08<25:16, 13.66s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[57] loss: 1.8545599275827407\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 35%|███▍      | 58/168 [13:22<25:03, 13.67s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[58] loss: 1.8091287157684564\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 35%|███▌      | 59/168 [13:36<24:49, 13.67s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[59] loss: 1.7877144403755665\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 36%|███▌      | 60/168 [13:49<24:38, 13.69s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[60] loss: 1.7514951791614295\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 36%|███▋      | 61/168 [14:03<24:27, 13.72s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[61] loss: 1.7489148492366076\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 37%|███▋      | 62/168 [14:17<24:14, 13.73s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[62] loss: 1.6296101345866918\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 38%|███▊      | 63/168 [14:31<24:01, 13.73s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[63] loss: 1.763045240715146\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 38%|███▊      | 64/168 [14:44<23:51, 13.76s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[64] loss: 1.665902824923396\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 39%|███▊      | 65/168 [14:59<24:02, 14.01s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[65] loss: 1.6077203042805195\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 39%|███▉      | 66/168 [15:14<24:07, 14.19s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[66] loss: 1.598957790285349\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 40%|███▉      | 67/168 [15:28<23:49, 14.15s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[67] loss: 1.65119821511209\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 40%|████      | 68/168 [15:42<23:30, 14.11s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[68] loss: 1.5394992630183697\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 41%|████      | 69/168 [15:56<23:12, 14.06s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[69] loss: 1.5849344461411237\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 42%|████▏     | 70/168 [16:10<22:58, 14.07s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[70] loss: 1.539152367413044\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 42%|████▏     | 71/168 [16:24<22:47, 14.10s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[71] loss: 1.5397011908516287\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 43%|████▎     | 72/168 [16:38<22:38, 14.15s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[72] loss: 1.5120035108923913\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 43%|████▎     | 73/168 [16:52<22:24, 14.15s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[73] loss: 1.528502348586917\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 44%|████▍     | 74/168 [17:06<22:00, 14.05s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[74] loss: 1.495211517214775\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 45%|████▍     | 75/168 [17:20<21:33, 13.90s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[75] loss: 1.4751230369508266\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 45%|████▌     | 76/168 [19:29<1:14:12, 48.40s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[76] loss: 1.458164021372795\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 46%|████▌     | 77/168 [19:44<58:31, 38.59s/it]  "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[77] loss: 1.4681756868213416\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 46%|████▋     | 78/168 [19:57<46:28, 30.99s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[78] loss: 1.4789013562351465\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 47%|████▋     | 79/168 [20:11<38:00, 25.63s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[79] loss: 1.4769948079437016\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 48%|████▊     | 80/168 [22:34<1:29:16, 60.87s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[80] loss: 1.3654077115654946\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 48%|████▊     | 81/168 [22:47<1:07:32, 46.58s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[81] loss: 1.4274398352578281\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 49%|████▉     | 82/168 [23:00<52:23, 36.56s/it]  "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[82] loss: 1.3966791942715644\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 49%|████▉     | 83/168 [24:45<1:20:41, 56.95s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[83] loss: 1.328833008185029\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 50%|█████     | 84/168 [24:58<1:01:25, 43.88s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[84] loss: 1.366758951433003\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 51%|█████     | 85/168 [25:11<48:03, 34.74s/it]  "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[85] loss: 1.352954030893743\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 51%|█████     | 86/168 [25:25<38:41, 28.32s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[86] loss: 1.321883611679077\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 52%|█████▏    | 87/168 [31:01<2:42:52, 120.64s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[87] loss: 1.3045702395960688\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 52%|█████▏    | 88/168 [31:14<1:57:47, 88.35s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[88] loss: 1.315513711795211\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 53%|█████▎    | 89/168 [31:27<1:26:36, 65.78s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[89] loss: 1.3301346496492625\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 54%|█████▎    | 90/168 [32:39<1:27:58, 67.67s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[90] loss: 1.264306075386703\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 54%|█████▍    | 91/168 [32:52<1:05:52, 51.33s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[91] loss: 1.2956748128682376\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 55%|█████▍    | 92/168 [33:06<50:35, 39.94s/it]  "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[92] loss: 1.238478477410972\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 55%|█████▌    | 93/168 [33:19<39:55, 31.94s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[93] loss: 1.275935904122889\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 56%|█████▌    | 94/168 [33:32<32:32, 26.38s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[94] loss: 1.3025377794355153\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 57%|█████▋    | 95/168 [33:46<27:22, 22.50s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[95] loss: 1.258018624819815\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 57%|█████▋    | 96/168 [33:59<23:44, 19.79s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[96] loss: 1.2467361557856202\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 58%|█████▊    | 97/168 [34:13<21:09, 17.87s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[97] loss: 1.2496702728420497\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 58%|█████▊    | 98/168 [34:26<19:16, 16.52s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[98] loss: 1.1993033458665012\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 59%|█████▉    | 99/168 [35:00<25:03, 21.78s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[99] loss: 1.2335865347832442\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 60%|█████▉    | 100/168 [44:29<3:30:51, 186.05s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[100] loss: 1.1869227293878795\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 60%|██████    | 101/168 [44:42<2:29:46, 134.13s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[101] loss: 1.210255386196077\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 61%|██████    | 102/168 [44:55<1:47:36, 97.83s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[102] loss: 1.1789188939332962\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 61%|██████▏   | 103/168 [45:09<1:18:29, 72.45s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[103] loss: 1.2000786917284132\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 62%|██████▏   | 104/168 [45:22<58:21, 54.71s/it]  "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[104] loss: 1.142682369761169\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 62%|██████▎   | 105/168 [45:35<44:25, 42.31s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[105] loss: 1.1631868626363575\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 63%|██████▎   | 106/168 [45:49<34:43, 33.61s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[106] loss: 1.1619325532764195\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 64%|██████▎   | 107/168 [46:02<28:00, 27.55s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[107] loss: 1.1617120557278395\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 64%|██████▍   | 108/168 [46:15<23:15, 23.26s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[108] loss: 1.2024575907364488\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 65%|██████▍   | 109/168 [46:29<19:54, 20.24s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[109] loss: 1.157916172929108\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 65%|██████▌   | 110/168 [46:42<17:34, 18.19s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[110] loss: 1.1198387117683888\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 66%|██████▌   | 111/168 [46:55<15:52, 16.71s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[111] loss: 1.0770965415239333\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 67%|██████▋   | 112/168 [47:08<14:37, 15.66s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[112] loss: 1.1272054262831808\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 67%|██████▋   | 113/168 [47:22<13:44, 15.00s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[113] loss: 1.1214576677232981\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 68%|██████▊   | 114/168 [47:35<13:04, 14.52s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[114] loss: 1.123800216447562\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 68%|██████▊   | 115/168 [47:49<12:28, 14.13s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[115] loss: 1.0500698785111309\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 69%|██████▉   | 116/168 [48:20<16:49, 19.41s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[116] loss: 1.1524625663645565\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 70%|██████▉   | 117/168 [49:21<27:06, 31.90s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[117] loss: 1.0488305239006877\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 70%|███████   | 118/168 [49:55<27:02, 32.44s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[118] loss: 1.0661822570487858\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 71%|███████   | 119/168 [50:10<22:16, 27.27s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[119] loss: 1.1160423377901316\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 71%|███████▏  | 120/168 [50:26<19:07, 23.90s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[120] loss: 1.0673465127497912\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 72%|███████▏  | 121/168 [50:41<16:36, 21.21s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[121] loss: 1.0864263591915369\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 73%|███████▎  | 122/168 [50:56<14:49, 19.34s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[122] loss: 1.0632323499768972\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 73%|███████▎  | 123/168 [51:11<13:32, 18.05s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[123] loss: 1.0387098265066743\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 74%|███████▍  | 124/168 [51:27<12:38, 17.23s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[124] loss: 1.1030402705445885\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 74%|███████▍  | 125/168 [52:17<19:34, 27.32s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[125] loss: 1.0200461779907346\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 75%|███████▌  | 126/168 [52:56<21:32, 30.78s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[126] loss: 1.0623282304406165\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 76%|███████▌  | 127/168 [53:13<18:09, 26.57s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[127] loss: 1.0222081493213773\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 76%|███████▌  | 128/168 [53:30<15:42, 23.56s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[128] loss: 1.0009294691681863\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 77%|███████▋  | 129/168 [53:46<13:51, 21.31s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[129] loss: 1.0866367200762033\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 77%|███████▋  | 130/168 [54:02<12:32, 19.79s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[130] loss: 1.0483400913886727\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 78%|███████▊  | 131/168 [54:18<11:33, 18.74s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[131] loss: 1.0076501268148421\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 79%|███████▊  | 132/168 [54:35<10:50, 18.06s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[132] loss: 1.0219182295538485\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 79%|███████▉  | 133/168 [54:52<10:20, 17.72s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[133] loss: 1.0146058875322341\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 80%|███████▉  | 134/168 [55:16<11:08, 19.65s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[134] loss: 1.0275335101038217\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 80%|████████  | 135/168 [56:03<15:17, 27.80s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[135] loss: 1.0144779866188764\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 81%|████████  | 136/168 [56:22<13:30, 25.34s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[136] loss: 0.991762755420059\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 82%|████████▏ | 137/168 [56:41<12:09, 23.54s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[137] loss: 0.9984993146732449\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 82%|████████▏ | 138/168 [57:00<11:04, 22.15s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[138] loss: 0.9878306019306183\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 83%|████████▎ | 139/168 [57:19<10:12, 21.11s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[139] loss: 0.9192868838459254\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 83%|████████▎ | 140/168 [57:37<09:24, 20.18s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[140] loss: 1.0042274387180805\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 84%|████████▍ | 141/168 [57:56<08:52, 19.72s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[141] loss: 0.9879569128435105\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 85%|████████▍ | 142/168 [58:14<08:21, 19.28s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[142] loss: 0.9902582805231214\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 85%|████████▌ | 143/168 [58:33<08:00, 19.24s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[143] loss: 0.9808878721483052\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 86%|████████▌ | 144/168 [58:53<07:46, 19.43s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[144] loss: 0.9176047392375767\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 86%|████████▋ | 145/168 [59:13<07:33, 19.71s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[145] loss: 0.9929313072562218\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 87%|████████▋ | 146/168 [59:34<07:18, 19.95s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[146] loss: 0.9308071241620928\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 88%|████████▊ | 147/168 [59:55<07:06, 20.33s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[147] loss: 0.9748139287158847\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 88%|████████▊ | 148/168 [1:00:16<06:52, 20.61s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[148] loss: 0.9906308367103338\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 89%|████████▊ | 149/168 [1:00:39<06:45, 21.32s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[149] loss: 0.9329269659891725\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 89%|████████▉ | 150/168 [1:01:02<06:30, 21.68s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[150] loss: 1.0051170142553747\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 90%|████████▉ | 151/168 [1:01:24<06:08, 21.69s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[151] loss: 0.9474140919744969\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 90%|█████████ | 152/168 [1:01:45<05:45, 21.60s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[152] loss: 0.9337273210287094\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 91%|█████████ | 153/168 [1:02:08<05:30, 22.02s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[153] loss: 0.9890214686840773\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 92%|█████████▏| 154/168 [1:02:29<05:06, 21.87s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[154] loss: 0.9347922270186245\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 92%|█████████▏| 155/168 [1:02:51<04:41, 21.66s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[155] loss: 0.9479011158272624\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 93%|█████████▎| 156/168 [1:03:12<04:18, 21.58s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[156] loss: 0.9545077313482762\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 93%|█████████▎| 157/168 [1:03:33<03:53, 21.26s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[157] loss: 0.9757081762515009\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 94%|█████████▍| 158/168 [1:03:53<03:30, 21.00s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[158] loss: 0.9265058207884431\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 95%|█████████▍| 159/168 [1:04:13<03:07, 20.83s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[159] loss: 0.9591339866258204\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 95%|█████████▌| 160/168 [1:04:34<02:46, 20.80s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[160] loss: 0.9778343894332647\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 96%|█████████▌| 161/168 [1:04:55<02:25, 20.75s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[161] loss: 0.9703891616500914\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 96%|█████████▋| 162/168 [1:05:15<02:03, 20.64s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[162] loss: 0.9046339152380825\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 97%|█████████▋| 163/168 [1:05:36<01:43, 20.61s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[163] loss: 0.8894137741439044\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 98%|█████████▊| 164/168 [1:05:56<01:21, 20.43s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[164] loss: 0.9338223798200488\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 98%|█████████▊| 165/168 [1:06:15<01:00, 20.17s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[165] loss: 0.8916218169778586\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 99%|█████████▉| 166/168 [1:06:35<00:40, 20.10s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[166] loss: 0.9765969038940966\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 99%|█████████▉| 167/168 [1:06:55<00:20, 20.13s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[167] loss: 0.8979447180218995\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 168/168 [1:07:15<00:00, 24.02s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[168] loss: 0.8999329889193177\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[I 2024-04-09 18:59:24,718] Trial 0 finished with value: 0.7581 and parameters: {'lr': 0.005174730363273795, 'epochs': 168}. Best is trial 0 with value: 0.7581.\n",
+      "/var/folders/z8/5xwgt9dn43n0_s6896y6y4yc0000gn/T/ipykernel_99236/3164015185.py:11: FutureWarning: suggest_loguniform has been deprecated in v3.0.0. This feature will be removed in v6.0.0. See https://github.com/optuna/optuna/releases/tag/v3.0.0. Use suggest_float(..., log=True) instead.\n",
+      "  optimizer = optim.SGD(model.parameters(), lr=trial.suggest_loguniform('lr', 0.001, 0.007), momentum=0.9, weight_decay=5e-4)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Global accuracy: 0.7581\n",
+      "Confusion Matrix:\n",
+      "[[780  14  55  18  18  10   6  12  67  20]\n",
+      " [ 25 864   4  14   2   4   3   3  35  46]\n",
+      " [ 46   4 734  48  75  33   9  34  11   6]\n",
+      " [ 29  10  54 557  67 189  25  36  15  18]\n",
+      " [ 20   1  57  37 762  36  11  63   9   4]\n",
+      " [ 14   7  51 149  29 669   7  58  10   6]\n",
+      " [  8   3  74  86  70  42 690  10   9   8]\n",
+      " [ 15   3  28  36  44  47   2 811   4  10]\n",
+      " [ 55   6  14   6   5   7   1   5 888  13]\n",
+      " [ 26  62  12  11   2   6   3   4  48 826]]\n",
+      "\n",
+      "Accuracy by Label:\n",
+      "airplane: 0.78\n",
+      "automobile: 0.864\n",
+      "bird: 0.734\n",
+      "cat: 0.557\n",
+      "deer: 0.762\n",
+      "dog: 0.669\n",
+      "frog: 0.69\n",
+      "horse: 0.811\n",
+      "ship: 0.888\n",
+      "truck: 0.826\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  1%|          | 1/132 [00:21<47:42, 21.85s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1] loss: 9.3245443212986\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  2%|▏         | 2/132 [00:42<45:10, 20.85s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2] loss: 7.668702917098999\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  2%|▏         | 3/132 [01:01<43:17, 20.14s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[3] loss: 6.979228001832962\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  3%|▎         | 4/132 [01:21<43:19, 20.31s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[4] loss: 6.504987050890922\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  4%|▍         | 5/132 [01:42<43:00, 20.32s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[5] loss: 6.118141946792602\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  5%|▍         | 6/132 [02:02<42:29, 20.23s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[6] loss: 5.88563547372818\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  5%|▌         | 7/132 [02:22<42:24, 20.36s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[7] loss: 5.577511522173881\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  6%|▌         | 8/132 [02:42<41:48, 20.23s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[8] loss: 5.374951508641243\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  7%|▋         | 9/132 [03:02<41:22, 20.18s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[9] loss: 5.130331813097\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  8%|▊         | 10/132 [03:22<40:43, 20.03s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[10] loss: 4.880659177303314\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  8%|▊         | 11/132 [03:37<37:24, 18.55s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[11] loss: 4.7414539730548855\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  9%|▉         | 12/132 [03:52<35:01, 17.51s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[12] loss: 4.64084365606308\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 10%|▉         | 13/132 [04:06<32:31, 16.40s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[13] loss: 4.450649637579918\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 11%|█         | 14/132 [04:20<30:41, 15.60s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[14] loss: 4.353629199266433\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 11%|█▏        | 15/132 [04:34<29:24, 15.08s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[15] loss: 4.182191348969936\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 12%|█▏        | 16/132 [04:48<28:25, 14.70s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[16] loss: 4.09333246320486\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 13%|█▎        | 17/132 [05:01<27:38, 14.42s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[17] loss: 4.004940604567528\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 14%|█▎        | 18/132 [05:15<27:04, 14.25s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[18] loss: 3.8709226790070534\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 14%|█▍        | 19/132 [05:30<26:52, 14.27s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[19] loss: 3.743499090373516\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 15%|█▌        | 20/132 [05:44<26:42, 14.30s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[20] loss: 3.686976233720779\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 16%|█▌        | 21/132 [05:58<26:23, 14.27s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[21] loss: 3.610847706198692\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 17%|█▋        | 22/132 [06:12<26:06, 14.24s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[22] loss: 3.546858816742897\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 17%|█▋        | 23/132 [06:26<25:34, 14.07s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[23] loss: 3.4938973718881607\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 18%|█▊        | 24/132 [06:40<25:18, 14.06s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[24] loss: 3.3281022499501707\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 19%|█▉        | 25/132 [06:54<25:09, 14.11s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[25] loss: 3.2824899700284003\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 20%|█▉        | 26/132 [07:09<24:59, 14.14s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[26] loss: 3.1770938521623613\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 20%|██        | 27/132 [07:22<24:35, 14.05s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[27] loss: 3.1288150210678576\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 21%|██        | 28/132 [07:36<24:12, 13.97s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[28] loss: 3.029553910493851\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 22%|██▏       | 29/132 [07:50<23:50, 13.88s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[29] loss: 3.0161086064577103\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 23%|██▎       | 30/132 [08:04<23:33, 13.86s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[30] loss: 2.92598101913929\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 23%|██▎       | 31/132 [08:18<23:23, 13.89s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[31] loss: 2.8491721980273725\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 24%|██▍       | 32/132 [08:32<23:16, 13.97s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[32] loss: 2.7713975186645983\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 25%|██▌       | 33/132 [08:46<23:05, 14.00s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[33] loss: 2.706846835166216\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 26%|██▌       | 34/132 [09:00<22:48, 13.97s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[34] loss: 2.6645671631395818\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 27%|██▋       | 35/132 [09:14<22:49, 14.12s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[35] loss: 2.6779004664719106\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 27%|██▋       | 36/132 [09:28<22:29, 14.06s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[36] loss: 2.6064164531230927\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 28%|██▊       | 37/132 [09:42<22:11, 14.02s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[37] loss: 2.52805104136467\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 28%|██▊       | 37/132 [09:54<25:25, 16.05s/it]\n",
+      "[W 2024-04-09 19:09:18,897] Trial 1 failed with parameters: {'lr': 0.00343465286530756, 'epochs': 132} because of the following error: KeyboardInterrupt().\n",
+      "Traceback (most recent call last):\n",
+      "  File \"/Users/ricardofernandezgasca/Library/Python/3.9/lib/python/site-packages/optuna/study/_optimize.py\", line 200, in _run_trial\n",
+      "    value_or_values = func(trial)\n",
+      "  File \"/var/folders/z8/5xwgt9dn43n0_s6896y6y4yc0000gn/T/ipykernel_99236/3164015185.py\", line 14, in objective\n",
+      "    train_model(model, trainloader_subset, device, optimizer, criterion, epochs= trial.suggest_int('epochs', 50, 200), save_path='Optuna_model')\n",
+      "  File \"/var/folders/z8/5xwgt9dn43n0_s6896y6y4yc0000gn/T/ipykernel_99236/3472054811.py\", line 17, in train_model\n",
+      "    optimizer.step()\n",
+      "  File \"/Users/ricardofernandezgasca/Library/Python/3.9/lib/python/site-packages/torch/optim/optimizer.py\", line 373, in wrapper\n",
+      "    out = func(*args, **kwargs)\n",
+      "  File \"/Users/ricardofernandezgasca/Library/Python/3.9/lib/python/site-packages/torch/optim/optimizer.py\", line 76, in _use_grad\n",
+      "    ret = func(self, *args, **kwargs)\n",
+      "  File \"/Users/ricardofernandezgasca/Library/Python/3.9/lib/python/site-packages/torch/optim/sgd.py\", line 75, in step\n",
+      "    sgd(params_with_grad,\n",
+      "  File \"/Users/ricardofernandezgasca/Library/Python/3.9/lib/python/site-packages/torch/optim/sgd.py\", line 220, in sgd\n",
+      "    func(params,\n",
+      "  File \"/Users/ricardofernandezgasca/Library/Python/3.9/lib/python/site-packages/torch/optim/sgd.py\", line 256, in _single_tensor_sgd\n",
+      "    buf.mul_(momentum).add_(d_p, alpha=1 - dampening)\n",
+      "KeyboardInterrupt\n",
+      "[W 2024-04-09 19:09:18,909] Trial 1 failed with value None.\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[52], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m study \u001b[38;5;241m=\u001b[39m optuna\u001b[38;5;241m.\u001b[39mcreate_study(direction\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmaximize\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m----> 2\u001b[0m \u001b[43mstudy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobjective\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_trials\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;66;03m# Get the best hyperparameters\u001b[39;00m\n\u001b[1;32m      5\u001b[0m best_params \u001b[38;5;241m=\u001b[39m study\u001b[38;5;241m.\u001b[39mbest_params\n",
+      "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/optuna/study/study.py:451\u001b[0m, in \u001b[0;36mStudy.optimize\u001b[0;34m(self, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial, show_progress_bar)\u001b[0m\n\u001b[1;32m    348\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21moptimize\u001b[39m(\n\u001b[1;32m    349\u001b[0m     \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m    350\u001b[0m     func: ObjectiveFuncType,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    357\u001b[0m     show_progress_bar: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m    358\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    359\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Optimize an objective function.\u001b[39;00m\n\u001b[1;32m    360\u001b[0m \n\u001b[1;32m    361\u001b[0m \u001b[38;5;124;03m    Optimization is done by choosing a suitable set of hyperparameter values from a given\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    449\u001b[0m \u001b[38;5;124;03m            If nested invocation of this method occurs.\u001b[39;00m\n\u001b[1;32m    450\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 451\u001b[0m     \u001b[43m_optimize\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    452\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstudy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    453\u001b[0m \u001b[43m        \u001b[49m\u001b[43mfunc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    454\u001b[0m \u001b[43m        \u001b[49m\u001b[43mn_trials\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_trials\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    455\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    456\u001b[0m \u001b[43m        \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    457\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcatch\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mtuple\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43misinstance\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mIterable\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    458\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallbacks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    459\u001b[0m \u001b[43m        \u001b[49m\u001b[43mgc_after_trial\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgc_after_trial\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    460\u001b[0m \u001b[43m        \u001b[49m\u001b[43mshow_progress_bar\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshow_progress_bar\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    461\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/optuna/study/_optimize.py:66\u001b[0m, in \u001b[0;36m_optimize\u001b[0;34m(study, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial, show_progress_bar)\u001b[0m\n\u001b[1;32m     64\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m     65\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m n_jobs \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m---> 66\u001b[0m         \u001b[43m_optimize_sequential\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     67\u001b[0m \u001b[43m            \u001b[49m\u001b[43mstudy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     68\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     69\u001b[0m \u001b[43m            \u001b[49m\u001b[43mn_trials\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     70\u001b[0m \u001b[43m            \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     71\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     72\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     73\u001b[0m \u001b[43m            \u001b[49m\u001b[43mgc_after_trial\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     74\u001b[0m \u001b[43m            \u001b[49m\u001b[43mreseed_sampler_rng\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m     75\u001b[0m \u001b[43m            \u001b[49m\u001b[43mtime_start\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m     76\u001b[0m \u001b[43m            \u001b[49m\u001b[43mprogress_bar\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprogress_bar\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     77\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     78\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m     79\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m n_jobs \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m:\n",
+      "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/optuna/study/_optimize.py:163\u001b[0m, in \u001b[0;36m_optimize_sequential\u001b[0;34m(study, func, n_trials, timeout, catch, callbacks, gc_after_trial, reseed_sampler_rng, time_start, progress_bar)\u001b[0m\n\u001b[1;32m    160\u001b[0m         \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[1;32m    162\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 163\u001b[0m     frozen_trial \u001b[38;5;241m=\u001b[39m \u001b[43m_run_trial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstudy\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    164\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m    165\u001b[0m     \u001b[38;5;66;03m# The following line mitigates memory problems that can be occurred in some\u001b[39;00m\n\u001b[1;32m    166\u001b[0m     \u001b[38;5;66;03m# environments (e.g., services that use computing containers such as GitHub Actions).\u001b[39;00m\n\u001b[1;32m    167\u001b[0m     \u001b[38;5;66;03m# Please refer to the following PR for further details:\u001b[39;00m\n\u001b[1;32m    168\u001b[0m     \u001b[38;5;66;03m# https://github.com/optuna/optuna/pull/325.\u001b[39;00m\n\u001b[1;32m    169\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m gc_after_trial:\n",
+      "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/optuna/study/_optimize.py:251\u001b[0m, in \u001b[0;36m_run_trial\u001b[0;34m(study, func, catch)\u001b[0m\n\u001b[1;32m    244\u001b[0m         \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mShould not reach.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    246\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m    247\u001b[0m     frozen_trial\u001b[38;5;241m.\u001b[39mstate \u001b[38;5;241m==\u001b[39m TrialState\u001b[38;5;241m.\u001b[39mFAIL\n\u001b[1;32m    248\u001b[0m     \u001b[38;5;129;01mand\u001b[39;00m func_err \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m    249\u001b[0m     \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(func_err, catch)\n\u001b[1;32m    250\u001b[0m ):\n\u001b[0;32m--> 251\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m func_err\n\u001b[1;32m    252\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m frozen_trial\n",
+      "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/optuna/study/_optimize.py:200\u001b[0m, in \u001b[0;36m_run_trial\u001b[0;34m(study, func, catch)\u001b[0m\n\u001b[1;32m    198\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m get_heartbeat_thread(trial\u001b[38;5;241m.\u001b[39m_trial_id, study\u001b[38;5;241m.\u001b[39m_storage):\n\u001b[1;32m    199\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 200\u001b[0m         value_or_values \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrial\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    201\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m exceptions\u001b[38;5;241m.\u001b[39mTrialPruned \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    202\u001b[0m         \u001b[38;5;66;03m# TODO(mamu): Handle multi-objective cases.\u001b[39;00m\n\u001b[1;32m    203\u001b[0m         state \u001b[38;5;241m=\u001b[39m TrialState\u001b[38;5;241m.\u001b[39mPRUNED\n",
+      "Cell \u001b[0;32mIn[50], line 14\u001b[0m, in \u001b[0;36mobjective\u001b[0;34m(trial)\u001b[0m\n\u001b[1;32m     11\u001b[0m optimizer \u001b[38;5;241m=\u001b[39m optim\u001b[38;5;241m.\u001b[39mSGD(model\u001b[38;5;241m.\u001b[39mparameters(), lr\u001b[38;5;241m=\u001b[39mtrial\u001b[38;5;241m.\u001b[39msuggest_loguniform(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlr\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;241m0.001\u001b[39m, \u001b[38;5;241m0.007\u001b[39m), momentum\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.9\u001b[39m, weight_decay\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5e-4\u001b[39m)\n\u001b[1;32m     13\u001b[0m \u001b[38;5;66;03m# Train the model\u001b[39;00m\n\u001b[0;32m---> 14\u001b[0m \u001b[43mtrain_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtrainloader_subset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcriterion\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mtrial\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msuggest_int\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mepochs\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m50\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m200\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msave_path\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mOptuna_model\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     16\u001b[0m \u001b[38;5;66;03m# Evaluate the model\u001b[39;00m\n\u001b[1;32m     17\u001b[0m model\u001b[38;5;241m.\u001b[39meval()\n",
+      "Cell \u001b[0;32mIn[38], line 17\u001b[0m, in \u001b[0;36mtrain_model\u001b[0;34m(model, trainloader, device, optimizer, criterion, save_path, epochs)\u001b[0m\n\u001b[1;32m     15\u001b[0m     loss \u001b[38;5;241m=\u001b[39m criterion(outputs,labels)\n\u001b[1;32m     16\u001b[0m     loss\u001b[38;5;241m.\u001b[39mbackward()\n\u001b[0;32m---> 17\u001b[0m     \u001b[43moptimizer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstep\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     18\u001b[0m     running_loss \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m loss\u001b[38;5;241m.\u001b[39mitem()\n\u001b[1;32m     19\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m[\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mepoch\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m] loss: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mrunning_loss\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m100\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n",
+      "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/optim/optimizer.py:373\u001b[0m, in \u001b[0;36mOptimizer.profile_hook_step.<locals>.wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    368\u001b[0m         \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    369\u001b[0m             \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[1;32m    370\u001b[0m                 \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m must return None or a tuple of (new_args, new_kwargs), but got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mresult\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    371\u001b[0m             )\n\u001b[0;32m--> 373\u001b[0m out \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    374\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_optimizer_step_code()\n\u001b[1;32m    376\u001b[0m \u001b[38;5;66;03m# call optimizer step post hooks\u001b[39;00m\n",
+      "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/optim/optimizer.py:76\u001b[0m, in \u001b[0;36m_use_grad_for_differentiable.<locals>._use_grad\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m     74\u001b[0m     torch\u001b[38;5;241m.\u001b[39mset_grad_enabled(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdefaults[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdifferentiable\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m     75\u001b[0m     torch\u001b[38;5;241m.\u001b[39m_dynamo\u001b[38;5;241m.\u001b[39mgraph_break()\n\u001b[0;32m---> 76\u001b[0m     ret \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     77\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m     78\u001b[0m     torch\u001b[38;5;241m.\u001b[39m_dynamo\u001b[38;5;241m.\u001b[39mgraph_break()\n",
+      "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/optim/sgd.py:75\u001b[0m, in \u001b[0;36mSGD.step\u001b[0;34m(self, closure)\u001b[0m\n\u001b[1;32m     71\u001b[0m momentum_buffer_list \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m     73\u001b[0m has_sparse_grad \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_init_group(group, params_with_grad, d_p_list, momentum_buffer_list)\n\u001b[0;32m---> 75\u001b[0m \u001b[43msgd\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams_with_grad\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     76\u001b[0m \u001b[43m    \u001b[49m\u001b[43md_p_list\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     77\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmomentum_buffer_list\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     78\u001b[0m \u001b[43m    \u001b[49m\u001b[43mweight_decay\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mweight_decay\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     79\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmomentum\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmomentum\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     80\u001b[0m \u001b[43m    \u001b[49m\u001b[43mlr\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mlr\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     81\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdampening\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mdampening\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     82\u001b[0m \u001b[43m    \u001b[49m\u001b[43mnesterov\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mnesterov\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     83\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmaximize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmaximize\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     84\u001b[0m \u001b[43m    \u001b[49m\u001b[43mhas_sparse_grad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhas_sparse_grad\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     85\u001b[0m \u001b[43m    \u001b[49m\u001b[43mforeach\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgroup\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mforeach\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     87\u001b[0m \u001b[38;5;66;03m# update momentum_buffers in state\u001b[39;00m\n\u001b[1;32m     88\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m p, momentum_buffer \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(params_with_grad, momentum_buffer_list):\n",
+      "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/optim/sgd.py:220\u001b[0m, in \u001b[0;36msgd\u001b[0;34m(params, d_p_list, momentum_buffer_list, has_sparse_grad, foreach, weight_decay, momentum, lr, dampening, nesterov, maximize)\u001b[0m\n\u001b[1;32m    217\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    218\u001b[0m     func \u001b[38;5;241m=\u001b[39m _single_tensor_sgd\n\u001b[0;32m--> 220\u001b[0m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    221\u001b[0m \u001b[43m     \u001b[49m\u001b[43md_p_list\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    222\u001b[0m \u001b[43m     \u001b[49m\u001b[43mmomentum_buffer_list\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    223\u001b[0m \u001b[43m     \u001b[49m\u001b[43mweight_decay\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mweight_decay\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    224\u001b[0m \u001b[43m     \u001b[49m\u001b[43mmomentum\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmomentum\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    225\u001b[0m \u001b[43m     \u001b[49m\u001b[43mlr\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlr\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    226\u001b[0m \u001b[43m     \u001b[49m\u001b[43mdampening\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdampening\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    227\u001b[0m \u001b[43m     \u001b[49m\u001b[43mnesterov\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnesterov\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    228\u001b[0m \u001b[43m     \u001b[49m\u001b[43mhas_sparse_grad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mhas_sparse_grad\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    229\u001b[0m \u001b[43m     \u001b[49m\u001b[43mmaximize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmaximize\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/torch/optim/sgd.py:256\u001b[0m, in \u001b[0;36m_single_tensor_sgd\u001b[0;34m(params, d_p_list, momentum_buffer_list, weight_decay, momentum, lr, dampening, nesterov, maximize, has_sparse_grad)\u001b[0m\n\u001b[1;32m    254\u001b[0m     momentum_buffer_list[i] \u001b[38;5;241m=\u001b[39m buf\n\u001b[1;32m    255\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 256\u001b[0m     \u001b[43mbuf\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmul_\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmomentum\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39madd_(d_p, alpha\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m \u001b[38;5;241m-\u001b[39m dampening)\n\u001b[1;32m    258\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m nesterov:\n\u001b[1;32m    259\u001b[0m     d_p \u001b[38;5;241m=\u001b[39m d_p\u001b[38;5;241m.\u001b[39madd(buf, alpha\u001b[38;5;241m=\u001b[39mmomentum)\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "study = optuna.create_study(direction='maximize')\n",
+    "study.optimize(objective, n_trials=10)\n",
+    "\n",
+    "# Get the best hyperparameters\n",
+    "best_params = study.best_params\n",
+    "print(f\"Best hyperparameters: {best_params}\")\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}