diff --git "a/IDK_mnist.ipynb" "b/IDK_mnist.ipynb"
new file mode 100644--- /dev/null
+++ "b/IDK_mnist.ipynb"
@@ -0,0 +1,2903 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Assignment 1 - MNIST Dataset Curation\n",
+        "Implementation of the Assignment 1 of \"Applied Hands-on Copmuter Vision Seminar\".\n",
+        "Parts of this Notebook are copied from [this](https://colab.research.google.com/github/andandandand/practical-computer-vision/blob/main/notebooks/Image_Dataset_Curation_with_Foundation_and_Specialist_Models_MNIST_CLIP_vs_LeNet5.ipynb) Notebook by Antonio Rueda-Toicen.\n"
+      ],
+      "metadata": {
+        "id": "suzIBmvIgpqG"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Hs5tMrbla44u"
+      },
+      "outputs": [],
+      "source": [
+        "%%capture\n",
+        "!uv pip install fiftyone==1.7.0 torch==2.6.0 torchvision==0.21 numpy==2.0.2 open-clip-torch==3.2.0"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "mPiPPk8La7FB",
+        "outputId": "e743d072-3730-4eb7-bd7e-f9a763f46060"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.12/dist-packages/glob2/fnmatch.py:141: SyntaxWarning: invalid escape sequence '\\Z'\n",
+            "  return '(?ms)' + res + '\\Z'\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "('1.7.0', '2.6.0+cu124', '0.21.0+cu124', '2.0.2', '3.2.0')"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 3
+        }
+      ],
+      "source": [
+        "# Check installed versions\n",
+        "import fiftyone\n",
+        "import torch\n",
+        "import torchvision\n",
+        "import numpy\n",
+        "import open_clip\n",
+        "(fiftyone.__version__, torch.__version__,\n",
+        " torchvision.__version__, numpy.__version__,\n",
+        " open_clip.__version__)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ksKibU9Va94j"
+      },
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "\n",
+        "# Set environment variables for reproducibility BEFORE importing torch\n",
+        "os.environ['PYTHONHASHSEED'] = '51'\n",
+        "os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8'\n",
+        "\n",
+        "from PIL import Image\n",
+        "import numpy as np\n",
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "import torch.nn.functional as Fun\n",
+        "import torchvision.transforms.v2 as transforms\n",
+        "import fiftyone as fo\n",
+        "import fiftyone.zoo as foz\n",
+        "import fiftyone.brain as fob\n",
+        "from torch.utils.data import Dataset, ConcatDataset\n",
+        "from fiftyone import ViewField as F\n",
+        "import fiftyone.utils.random as four\n",
+        "from tqdm import tqdm\n",
+        "from torch.optim import Adam\n",
+        "from pathlib import Path\n",
+        "import matplotlib.pyplot as plt\n",
+        "import gc\n",
+        "import albumentations as A\n",
+        "import cv2\n",
+        "import random\n",
+        "from typing import Optional, Dict, Tuple, Any"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "guvIsCBPf5sW",
+        "outputId": "0ffca016-dd35-4012-f072-cb3e4c25fe98"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "device(type='cpu')"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 5
+        }
+      ],
+      "source": [
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "device"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "DZwO7YAAagPx",
+        "outputId": "b2d944f6-878b-4447-a3ef-c2bea0965ea3"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "All random seeds set to 51 for reproducibility\n"
+          ]
+        }
+      ],
+      "source": [
+        "def set_seeds(seed=51):\n",
+        "    \"\"\"\n",
+        "    Set seeds for complete reproducibility across all libraries and operations.\n",
+        "\n",
+        "    Args:\n",
+        "        seed (int): Random seed value\n",
+        "    \"\"\"\n",
+        "    # Set environment variables before other imports\n",
+        "    os.environ['PYTHONHASHSEED'] = str(seed)\n",
+        "    os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8'\n",
+        "\n",
+        "    # Python random module\n",
+        "    random.seed(seed)\n",
+        "\n",
+        "    # NumPy\n",
+        "    np.random.seed(seed)\n",
+        "\n",
+        "    # PyTorch CPU\n",
+        "    torch.manual_seed(seed)\n",
+        "\n",
+        "    # PyTorch GPU (all devices)\n",
+        "    if torch.cuda.is_available():\n",
+        "        torch.cuda.manual_seed(seed)\n",
+        "        torch.cuda.manual_seed_all(seed)  # For multi-GPU setups\n",
+        "\n",
+        "        # CUDA deterministic operations\n",
+        "        torch.backends.cudnn.deterministic = True\n",
+        "        torch.backends.cudnn.benchmark = False\n",
+        "\n",
+        "    # OpenCV\n",
+        "    cv2.setRNGSeed(seed)\n",
+        "\n",
+        "    # Albumentations (for data augmentation)\n",
+        "    try:\n",
+        "        A.seed_everything(seed)\n",
+        "    except AttributeError:\n",
+        "        # Older versions of albumentations\n",
+        "        pass\n",
+        "\n",
+        "    # PyTorch deterministic algorithms (may impact performance)\n",
+        "    try:\n",
+        "        torch.use_deterministic_algorithms(True)\n",
+        "    except RuntimeError:\n",
+        "        # Some operations don't have deterministic implementations\n",
+        "        print(\"Warning: Some operations may not be deterministic\")\n",
+        "\n",
+        "    print(f\"All random seeds set to {seed} for reproducibility\")\n",
+        "\n",
+        "\n",
+        "\n",
+        "# Usage: Call this function at the beginning and before each training phase\n",
+        "set_seeds(51)\n",
+        "\n",
+        "# Additional reproducibility considerations:\n",
+        "\n",
+        "def create_deterministic_training_dataloader(dataset, batch_size, shuffle=True, **kwargs):\n",
+        "    \"\"\"\n",
+        "    Create a DataLoader with deterministic behavior.\n",
+        "\n",
+        "    Args:\n",
+        "        dataset: PyTorch Dataset instance\n",
+        "        batch_size: Batch size\n",
+        "        shuffle: Whether to shuffle data\n",
+        "        **kwargs: Additional DataLoader arguments\n",
+        "\n",
+        "    Returns:\n",
+        "        Training DataLoader with reproducible behavior\n",
+        "    \"\"\"\n",
+        "    # Use a generator with fixed seed for reproducible shuffling\n",
+        "    generator = torch.Generator()\n",
+        "    generator.manual_seed(51)\n",
+        "\n",
+        "    return torch.utils.data.DataLoader(\n",
+        "        dataset,\n",
+        "        batch_size=batch_size,\n",
+        "        shuffle=shuffle,\n",
+        "        generator=generator if shuffle else None,\n",
+        "        **kwargs\n",
+        "    )\n",
+        "\n",
+        "# Example usage:\n",
+        "# train_loader = create_deterministic_dataloader(\n",
+        "#     torch_train_set,\n",
+        "#     batch_size=64,\n",
+        "#     shuffle=True,\n",
+        "#     num_workers=4,\n",
+        "#     pin_memory=True\n",
+        "# )\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "NRmDOUFhazsF"
+      },
+      "outputs": [],
+      "source": [
+        "# Alternative modern version with ReLU and MaxPooling\n",
+        "class ModernLeNet5(nn.Module):\n",
+        "    \"\"\"\n",
+        "    Modernized version of LeNet-5 with ReLU activations and max pooling.\n",
+        "    Often performs better on MNIST than the original version.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    def __init__(self, num_classes=10):\n",
+        "        super(ModernLeNet5, self).__init__()\n",
+        "\n",
+        "        self.conv1 = nn.Conv2d(1, 6, kernel_size=5)\n",
+        "        self.conv2 = nn.Conv2d(6, 16, kernel_size=5)\n",
+        "        self.conv3 = nn.Conv2d(16, 120, kernel_size=4)\n",
+        "\n",
+        "        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
+        "\n",
+        "        self.fc1 = nn.Linear(120, 84)\n",
+        "        self.fc2 = nn.Linear(84, num_classes)\n",
+        "\n",
+        "        self.dropout = nn.Dropout(0.5)\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        x = self.pool(Fun.relu(self.conv1(x)))\n",
+        "        x = self.pool(Fun.relu(self.conv2(x)))\n",
+        "        x = Fun.relu(self.conv3(x))\n",
+        "\n",
+        "        x = x.view(x.size(0), -1)\n",
+        "        x = Fun.relu(self.fc1(x))\n",
+        "        x = self.dropout(x)  # Add dropout for regularization\n",
+        "        x = self.fc2(x)\n",
+        "\n",
+        "        return x\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "qRNQT5S7buy6",
+        "outputId": "78eae02b-41e7-4c5d-f242-6ad0d214a58a"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading split 'train' to '/root/fiftyone/mnist/train'\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.zoo.datasets:Downloading split 'train' to '/root/fiftyone/mnist/train'\n",
+            "100%|██████████| 9.91M/9.91M [00:00<00:00, 16.2MB/s]\n",
+            "100%|██████████| 28.9k/28.9k [00:00<00:00, 484kB/s]\n",
+            "100%|██████████| 1.65M/1.65M [00:00<00:00, 4.44MB/s]\n",
+            "100%|██████████| 4.54k/4.54k [00:00<00:00, 3.07MB/s]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "   0% |/------------|   160/60000 [103.8ms elapsed, 38.8s remaining, 1.5K samples/s] "
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |█████████████| 60000/60000 [33.6s elapsed, 0s remaining, 2.1K samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |█████████████| 60000/60000 [33.6s elapsed, 0s remaining, 2.1K samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Dataset info written to '/root/fiftyone/mnist/info.json'\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.zoo.datasets:Dataset info written to '/root/fiftyone/mnist/info.json'\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Loading 'mnist' split 'train'\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.zoo.datasets:Loading 'mnist' split 'train'\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |█████████████| 60000/60000 [52.3s elapsed, 0s remaining, 1.4K samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |█████████████| 60000/60000 [52.3s elapsed, 0s remaining, 1.4K samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Dataset 'mnist-train-val' created\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.zoo.datasets:Dataset 'mnist-train-val' created\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Computing metadata...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.core.metadata:Computing metadata...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |█████████████| 60000/60000 [30.5s elapsed, 0s remaining, 2.5K samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |█████████████| 60000/60000 [30.5s elapsed, 0s remaining, 2.5K samples/s]      \n"
+          ]
+        }
+      ],
+      "source": [
+        "# We use the training split to train our LeNet model\n",
+        "# We make this dataset persistent as we want to save our changes for multiple sessions\n",
+        "train_val_dataset = foz.load_zoo_dataset(\"mnist\",\n",
+        "                                         split='train',\n",
+        "                                         dataset_name=\"mnist-train-val\",\n",
+        "                                         persistent=True)\n",
+        "\n",
+        "train_val_dataset.compute_metadata()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "YJ9gbGjrb1iy"
+      },
+      "outputs": [],
+      "source": [
+        "# The images come with the 'train' tag and this must be deleted\n",
+        "# at the sample level.\n",
+        "train_val_dataset.untag_samples([\"train\", \"validation\"])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "pggFDMhzjqfG",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "adbe812e-47ee-464d-9147-67ac85b5a0d4"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading split 'test' to '/root/fiftyone/mnist/test'\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.zoo.datasets:Downloading split 'test' to '/root/fiftyone/mnist/test'\n",
+            "100%|██████████| 9.91M/9.91M [00:00<00:00, 18.0MB/s]\n",
+            "100%|██████████| 28.9k/28.9k [00:00<00:00, 484kB/s]\n",
+            "100%|██████████| 1.65M/1.65M [00:00<00:00, 4.48MB/s]\n",
+            "100%|██████████| 4.54k/4.54k [00:00<00:00, 9.54MB/s]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "   2% |/------------|   181/10000 [100.7ms elapsed, 5.5s remaining, 1.8K samples/s] "
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |█████████████| 10000/10000 [6.4s elapsed, 0s remaining, 1.5K samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |█████████████| 10000/10000 [6.4s elapsed, 0s remaining, 1.5K samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Dataset info written to '/root/fiftyone/mnist/info.json'\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.zoo.datasets:Dataset info written to '/root/fiftyone/mnist/info.json'\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Loading 'mnist' split 'test'\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.zoo.datasets:Loading 'mnist' split 'test'\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |█████████████| 10000/10000 [7.7s elapsed, 0s remaining, 1.4K samples/s]        \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |█████████████| 10000/10000 [7.7s elapsed, 0s remaining, 1.4K samples/s]        \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Dataset 'mnist-test' created\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.zoo.datasets:Dataset 'mnist-test' created\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Computing metadata...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.core.metadata:Computing metadata...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |█████████████| 10000/10000 [6.1s elapsed, 0s remaining, 1.7K samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |█████████████| 10000/10000 [6.1s elapsed, 0s remaining, 1.7K samples/s]      \n"
+          ]
+        }
+      ],
+      "source": [
+        "# We will load the test split from the dataset first\n",
+        "test_dataset = foz.load_zoo_dataset(\"mnist\", split='test')\n",
+        "test_dataset\n",
+        "test_dataset.compute_metadata()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "nmdEM4IRb7Nf",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "80bac2a3-631d-457c-e1da-0c9da6977567"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "All random seeds set to 51 for reproducibility\n",
+            "Tag counts after split:\n",
+            "{'validation': 9000, 'train': 51000}\n"
+          ]
+        }
+      ],
+      "source": [
+        "set_seeds(51)\n",
+        "# Create random 85%/15% split using tags\n",
+        "four.random_split(train_val_dataset,\n",
+        "                  {\"train\": 0.85, \"validation\": 0.15},\n",
+        "                  # The seed makes the split reproducible\n",
+        "                  seed=51)\n",
+        "\n",
+        "# Verify the split by counting tags\n",
+        "tag_counts = train_val_dataset.count_sample_tags()\n",
+        "print(\"Tag counts after split:\")\n",
+        "print(tag_counts)\n",
+        "\n",
+        "# Separate validation and train FO datasets\n",
+        "train_dataset = train_val_dataset.match_tags(\"train\").clone()\n",
+        "val_dataset = train_val_dataset.match_tags(\"validation\").clone()\n",
+        "\n",
+        "# Set names for FO datasets using the 'name' property\n",
+        "train_dataset.name = \"mnist-training-set\"\n",
+        "val_dataset.name = \"mnist-validation-set\"\n",
+        "\n",
+        "# Define persistency\n",
+        "train_dataset.persistent = True\n",
+        "val_dataset.persistent = True\n",
+        "\n",
+        "# Verify no overlap between train and validation\n",
+        "train_ids = set(train_dataset.values(\"id\"))\n",
+        "val_ids = set(val_dataset.values(\"id\"))\n",
+        "overlap = train_ids.intersection(val_ids)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "00JOHxXUj5Ow",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "1f86506d-b862-4a1c-9ada-1866bae64734"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\r\n",
+            "Could not connect session, trying again in 10 seconds\r\n",
+            "\n",
+            "Session launched. Run `session.show()` to open the App in a cell output.\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.core.session.session:Session launched. Run `session.show()` to open the App in a cell output.\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "\n",
+            "Welcome to\n",
+            "\n",
+            "███████╗██╗███████╗████████╗██╗   ██╗ ██████╗ ███╗   ██╗███████╗\n",
+            "██╔════╝██║██╔════╝╚══██╔══╝╚██╗ ██╔╝██╔═══██╗████╗  ██║██╔════╝\n",
+            "█████╗  ██║█████╗     ██║    ╚████╔╝ ██║   ██║██╔██╗ ██║█████╗\n",
+            "██╔══╝  ██║██╔══╝     ██║     ╚██╔╝  ██║   ██║██║╚██╗██║██╔══╝\n",
+            "██║     ██║██║        ██║      ██║   ╚██████╔╝██║ ╚████║███████╗\n",
+            "╚═╝     ╚═╝╚═╝        ╚═╝      ╚═╝    ╚═════╝ ╚═╝  ╚═══╝╚══════╝ v1.7.0\n",
+            "\n",
+            "If you're finding FiftyOne helpful, here's how you can get involved:\n",
+            "\n",
+            "|\n",
+            "|  ⭐⭐⭐ Give the project a star on GitHub ⭐⭐⭐\n",
+            "|  https://github.com/voxel51/fiftyone\n",
+            "|\n",
+            "|  🚀🚀🚀 Join the FiftyOne Discord community 🚀🚀🚀\n",
+            "|  https://community.voxel51.com/\n",
+            "|\n",
+            "\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.core.session.session:\n",
+            "Welcome to\n",
+            "\n",
+            "███████╗██╗███████╗████████╗██╗   ██╗ ██████╗ ███╗   ██╗███████╗\n",
+            "██╔════╝██║██╔════╝╚══██╔══╝╚██╗ ██╔╝██╔═══██╗████╗  ██║██╔════╝\n",
+            "█████╗  ██║█████╗     ██║    ╚████╔╝ ██║   ██║██╔██╗ ██║█████╗\n",
+            "██╔══╝  ██║██╔══╝     ██║     ╚██╔╝  ██║   ██║██║╚██╗██║██╔══╝\n",
+            "██║     ██║██║        ██║      ██║   ╚██████╔╝██║ ╚████║███████╗\n",
+            "╚═╝     ╚═╝╚═╝        ╚═╝      ╚═╝    ╚═════╝ ╚═╝  ╚═══╝╚══════╝ v1.7.0\n",
+            "\n",
+            "If you're finding FiftyOne helpful, here's how you can get involved:\n",
+            "\n",
+            "|\n",
+            "|  ⭐⭐⭐ Give the project a star on GitHub ⭐⭐⭐\n",
+            "|  https://github.com/voxel51/fiftyone\n",
+            "|\n",
+            "|  🚀🚀🚀 Join the FiftyOne Discord community 🚀🚀🚀\n",
+            "|  https://community.voxel51.com/\n",
+            "|\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "session = fo.launch_app(train_dataset, auto=False)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "RqZ-erhVkHP3",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 35
+        },
+        "outputId": "2bec2206-dabc-4f24-8b63-00be8048aabb"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "https://5151-m-s-36rrqai9ebe4u-b.us-west1-1.prod.colab.dev?polling=true\n"
+          ]
+        }
+      ],
+      "source": [
+        "session.refresh()\n",
+        "print(session.url)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "S530ibD4cFlD"
+      },
+      "outputs": [],
+      "source": [
+        "# Custom PyTorch Dataset class for MNIST training data\n",
+        "class CustomTorchImageDataset(torch.utils.data.Dataset):\n",
+        "    def __init__(self, fiftyone_dataset,\n",
+        "                 image_transforms=None,\n",
+        "                 label_map=None,\n",
+        "                 gt_field=\"ground_truth\"):\n",
+        "        self.fiftyone_dataset = fiftyone_dataset\n",
+        "        self.image_paths = self.fiftyone_dataset.values(\"filepath\")\n",
+        "        self.str_labels = self.fiftyone_dataset.values(f\"{gt_field}.label\")\n",
+        "        self.image_transforms = image_transforms\n",
+        "\n",
+        "        if label_map is None:\n",
+        "            self.label_map = {str(i): i for i in range(10)}  # \"0\"->0, \"1\"->1, etc.\n",
+        "        else:\n",
+        "            self.label_map = label_map\n",
+        "\n",
+        "        print(f\"CustomTorchImageDataset initialized with {len(self.image_paths)} samples.\")\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        return len(self.image_paths)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        image_path = self.image_paths[idx]\n",
+        "        try:\n",
+        "            image = Image.open(image_path).convert('L')\n",
+        "        except Exception as e:\n",
+        "            print(f\"Error loading image {image_path}: {e}\")\n",
+        "            return torch.randn(1, 28, 28), torch.tensor(-1, dtype=torch.long)\n",
+        "\n",
+        "        if self.image_transforms:\n",
+        "            image = self.image_transforms(image)\n",
+        "\n",
+        "        label_str = self.str_labels[idx]\n",
+        "        label_idx = self.label_map.get(label_str, -1)\n",
+        "        if label_idx == -1:\n",
+        "            print(f\"Warning: Label '{label_str}' not in label_map for image {image_path}\")\n",
+        "\n",
+        "        return image, torch.tensor(label_idx, dtype=torch.long)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Tr-yQGPteVo7",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 107
+        },
+        "outputId": "01580b80-594d-42d8-d8f6-9146c0b69ad4"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Computing image intensity statistics from FiftyOne view...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "100%|██████████| 51000/51000 [00:10<00:00, 4740.79it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Computed from 51000 images\n",
+            "Total pixels: 39,984,000\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "'Mean: 0.1318, Std: 0.3075'"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            }
+          },
+          "metadata": {},
+          "execution_count": 17
+        }
+      ],
+      "source": [
+        "def compute_stats_fiftyone(fiftyone_view):\n",
+        "    \"\"\"\n",
+        "    Compute stats directly from FiftyOne using aggregations.\n",
+        "    Requires images to be loaded as arrays.\n",
+        "    \"\"\"\n",
+        "\n",
+        "    print(\"Computing image intensity statistics from FiftyOne view...\")\n",
+        "\n",
+        "    # Get all image filepaths\n",
+        "    filepaths = fiftyone_view.values(\"filepath\")\n",
+        "\n",
+        "    # Load all pixel values\n",
+        "    all_pixels = []\n",
+        "\n",
+        "    for filepath in tqdm(filepaths):\n",
+        "\n",
+        "        try:\n",
+        "            # Load image as grayscale array\n",
+        "            image = Image.open(filepath).convert('L')\n",
+        "            # Scale values to the range [0, 1]\n",
+        "            pixels = np.array(image, dtype=np.float32) / 255.0\n",
+        "            all_pixels.append(pixels.flatten())\n",
+        "        except Exception as e:\n",
+        "            print(f\"Error loading {filepath}: {e}\")\n",
+        "            continue\n",
+        "\n",
+        "    # Concatenate all pixel values\n",
+        "    all_pixels = np.concatenate(all_pixels)\n",
+        "\n",
+        "    # Compute statistics\n",
+        "    mean = np.mean(all_pixels)\n",
+        "    std = np.std(all_pixels)\n",
+        "\n",
+        "    print(f\"Computed from {len(filepaths)} images\")\n",
+        "    print(f\"Total pixels: {len(all_pixels):,}\")\n",
+        "\n",
+        "    return mean, std\n",
+        "\n",
+        "mean_intensity, std_intensity = compute_stats_fiftyone(train_dataset)\n",
+        "f\"Mean: {mean_intensity:.4f}, Std: {std_intensity:.4f}\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2Nt9yYrvezae",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "855e8752-49c7-4177-9cb2-db6dee3000b0"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "['0 - zero',\n",
+              " '1 - one',\n",
+              " '2 - two',\n",
+              " '3 - three',\n",
+              " '4 - four',\n",
+              " '5 - five',\n",
+              " '6 - six',\n",
+              " '7 - seven',\n",
+              " '8 - eight',\n",
+              " '9 - nine']"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 18
+        }
+      ],
+      "source": [
+        "# We obtain the distinct labels of the dataset\n",
+        "dataset_classes = sorted(train_dataset.distinct(\"ground_truth.label\"))\n",
+        "dataset_classes"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "PsY2alXreoSY",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "15d017fb-0fba-41c9-d6a7-f8d2b191f775"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "{'0 - zero': 0,\n",
+              " '1 - one': 1,\n",
+              " '2 - two': 2,\n",
+              " '3 - three': 3,\n",
+              " '4 - four': 4,\n",
+              " '5 - five': 5,\n",
+              " '6 - six': 6,\n",
+              " '7 - seven': 7,\n",
+              " '8 - eight': 8,\n",
+              " '9 - nine': 9}"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 19
+        }
+      ],
+      "source": [
+        "# Map the string labels to numerical values (we need this for the PyTorch dataset)\n",
+        "label_map = {string_label: index for index, string_label in enumerate(dataset_classes)}\n",
+        "label_map"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Bz4EefnjfM-x"
+      },
+      "outputs": [],
+      "source": [
+        "image_transforms = transforms.Compose([\n",
+        "    transforms.ToImage(),\n",
+        "    transforms.ToDtype(torch.float32, scale=True),\n",
+        "    transforms.Normalize((mean_intensity,), (std_intensity,))\n",
+        "])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "X8R4ssx7fPai",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "c4ca46f6-a4c7-42cc-c23b-498c55e82f34"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "CustomTorchImageDataset initialized with 51000 samples.\n"
+          ]
+        }
+      ],
+      "source": [
+        "torch_train_set = CustomTorchImageDataset(train_dataset,\n",
+        "                                          label_map=label_map,\n",
+        "                                          image_transforms=image_transforms)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "UoO6EmfUfSFX",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "20f95164-4994-464f-8fe7-e40d30b12858"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "CustomTorchImageDataset initialized with 9000 samples.\n"
+          ]
+        }
+      ],
+      "source": [
+        "torch_val_set = CustomTorchImageDataset(val_dataset,\n",
+        "                                     label_map=label_map,\n",
+        "                                     image_transforms=image_transforms)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "torch_test_set = CustomTorchImageDataset(test_dataset,\n",
+        "                                          label_map=label_map,\n",
+        "                                          image_transforms=image_transforms)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "K_s59TFkfjnt",
+        "outputId": "0fb08ce8-1934-41fe-abca-4ef674f8364d"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "CustomTorchImageDataset initialized with 10000 samples.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "YJ5L0KIHfoaR"
+      },
+      "outputs": [],
+      "source": [
+        "# Define batch size (you can adjust this based on your GPU memory)\n",
+        "batch_size = 64\n",
+        "num_workers = os.cpu_count()  # Number of CPU cores\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "VLKbjYUsfq_C"
+      },
+      "outputs": [],
+      "source": [
+        "train_loader = create_deterministic_training_dataloader(\n",
+        "    torch_train_set,\n",
+        "    batch_size=64,\n",
+        "    shuffle=True,\n",
+        "    num_workers=num_workers,\n",
+        "    pin_memory=True\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "972yRfcwf2UF",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "c1f76bad-36c5-49f5-fe0f-fe25186483f3"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Train and validation DataLoaders created successfully.\n",
+            "Train DataLoader has 797 batches.\n",
+            "Validation DataLoader has 141 batches.\n"
+          ]
+        }
+      ],
+      "source": [
+        "val_loader = torch.utils.data.DataLoader(\n",
+        "    torch_val_set,\n",
+        "    batch_size=batch_size,\n",
+        "    shuffle=False, # No need to shuffle validation data\n",
+        "    num_workers=num_workers,\n",
+        "    pin_memory=True\n",
+        ")\n",
+        "\n",
+        "print(\"Train and validation DataLoaders created successfully.\")\n",
+        "print(f\"Train DataLoader has {len(train_loader)} batches.\")\n",
+        "print(f\"Validation DataLoader has {len(val_loader)} batches.\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "OmNj4vGagM1j"
+      },
+      "outputs": [],
+      "source": [
+        "ce_loss = nn.CrossEntropyLoss()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "b_B2tV4cg-oR"
+      },
+      "outputs": [],
+      "source": [
+        "def train_epoch(model, train_loader):\n",
+        "  batch_losses = []\n",
+        "  model.train()\n",
+        "  for images, labels in tqdm(train_loader, desc=\"Training: \"):\n",
+        "      #import pdb; pdb.set_trace()\n",
+        "\n",
+        "      images = images.to(device)\n",
+        "      labels = labels.to(device)\n",
+        "      # Forward pass\n",
+        "      logits = model(images)\n",
+        "      loss_value = ce_loss(logits, labels)\n",
+        "      # Clear gradients from previous iteration (PyTorch accumulates by default)\n",
+        "      optimizer.zero_grad()\n",
+        "      # Computes the gradients with backpropagation\n",
+        "      loss_value.backward()\n",
+        "      # Updates the weights\n",
+        "      optimizer.step()\n",
+        "\n",
+        "      batch_losses.append(loss_value.item())\n",
+        "\n",
+        "  train_loss = np.mean(batch_losses)\n",
+        "  return train_loss\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "XagMtENEhBQJ"
+      },
+      "outputs": [],
+      "source": [
+        "def val_epoch(model, val_loader):\n",
+        "  batch_losses = []\n",
+        "  model.eval()\n",
+        "  with torch.inference_mode():\n",
+        "    for images, labels in tqdm(val_loader, desc=\"Validation: \"):\n",
+        "      images = images.to(device)\n",
+        "      labels = labels.to(device)\n",
+        "      # Forward pass\n",
+        "      logits = model(images)\n",
+        "      loss_value = ce_loss(logits, labels)\n",
+        "      batch_losses.append(loss_value.item())\n",
+        "  val_loss = np.mean(batch_losses)\n",
+        "  return val_loss"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ktX5NL12hFX9"
+      },
+      "outputs": [],
+      "source": [
+        "model = ModernLeNet5().to(device)\n",
+        "\n",
+        "# Define the optimizer (variant of stochastic gradient descent)\n",
+        "optimizer = Adam(model.parameters(),\n",
+        "                 lr=0.003, betas=(0.9, 0.999),\n",
+        "                 eps=1e-08, weight_decay=0)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "QwoC85zKhKV6",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "b147ea55-2916-4228-e84c-32d673168fda"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "All random seeds set to 51 for reproducibility\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:43<00:00, 18.53it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:05<00:00, 24.14it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 1/10 - Train Loss: 0.2194 - Val Loss: 0.0868\n",
+            "Found and saved better weights for the model\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:53<00:00, 14.86it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:04<00:00, 28.88it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 2/10 - Train Loss: 0.0798 - Val Loss: 0.0565\n",
+            "Found and saved better weights for the model\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:44<00:00, 18.02it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:06<00:00, 21.56it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 3/10 - Train Loss: 0.0605 - Val Loss: 0.0584\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:42<00:00, 18.95it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:06<00:00, 20.71it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 4/10 - Train Loss: 0.0530 - Val Loss: 0.0593\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:42<00:00, 18.77it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:04<00:00, 29.03it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 5/10 - Train Loss: 0.0468 - Val Loss: 0.0543\n",
+            "Found and saved better weights for the model\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:44<00:00, 17.90it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:04<00:00, 29.11it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 6/10 - Train Loss: 0.0461 - Val Loss: 0.0474\n",
+            "Found and saved better weights for the model\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:41<00:00, 19.24it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:07<00:00, 18.04it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 7/10 - Train Loss: 0.0384 - Val Loss: 0.0793\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:42<00:00, 18.80it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:06<00:00, 23.41it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 8/10 - Train Loss: 0.0401 - Val Loss: 0.0610\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:44<00:00, 18.08it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:04<00:00, 30.40it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 9/10 - Train Loss: 0.0341 - Val Loss: 0.0752\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:43<00:00, 18.40it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:07<00:00, 19.34it/s]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 10/10 - Train Loss: 0.0298 - Val Loss: 0.0611\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Ensure reproducibility for the training process\n",
+        "set_seeds(51) # You can change this number to get different results\n",
+        "\n",
+        "num_epochs = 10\n",
+        "train_losses = []\n",
+        "val_losses = []\n",
+        "\n",
+        "best_val_loss = float('inf')\n",
+        "best_model = None\n",
+        "\n",
+        "# Define the path to save the model within your hard-drive\n",
+        "path = Path(os.getcwd()) # Feel free to change the path\n",
+        "\n",
+        "model_save_path = path / 'best_lenet.pth'\n",
+        "\n",
+        "for epoch in range(num_epochs):\n",
+        "    train_loss = train_epoch(model, train_loader)\n",
+        "    val_loss = val_epoch(model, val_loader)\n",
+        "    train_losses.append(train_loss)\n",
+        "    val_losses.append(val_loss)\n",
+        "\n",
+        "\n",
+        "    print(f\"Epoch {epoch+1}/{num_epochs} - Train Loss: {train_loss:.4f} - Val Loss: {val_loss:.4f}\")\n",
+        "\n",
+        "    if val_loss < best_val_loss:\n",
+        "        best_val_loss = val_loss\n",
+        "        best_model = model\n",
+        "        # Save the best model\n",
+        "        torch.save(best_model.state_dict(), model_save_path)\n",
+        "        print('Found and saved better weights for the model')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "OWKQT900hps7",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 487
+        },
+        "outputId": "6f64e894-d6a3-437a-f812-c27e241a04c9"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.plot(train_losses, label='Training Loss')\n",
+        "plt.plot(val_losses, label='Validation Loss')\n",
+        "plt.xlabel('Epochs')\n",
+        "plt.ylabel('Loss')\n",
+        "plt.legend()\n",
+        "plt.title('Training and Validation Loss')\n",
+        "\n",
+        "# Find the epoch with the best validation loss\n",
+        "best_epoch = np.argmin(val_losses) + 1 # Add 1 because epochs are 1-indexed\n",
+        "\n",
+        "# Add a vertical red line at the epoch with the best validation loss\n",
+        "plt.axvline(x=best_epoch, color='red', linestyle='--', label=f'Best Val Loss Epoch {best_epoch}')\n",
+        "plt.legend()\n",
+        "\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "aGRh6O7WivMj",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "6806f0c1-2c21-4c6f-df4f-503c3ef3fb30"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Model loaded successfully from /content/best_lenet.pth\n",
+            "Model is on device: cpu\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Define the path where the best model was saved\n",
+        "path = Path(os.getcwd())\n",
+        "model_save_path = path / 'best_lenet.pth'\n",
+        "\n",
+        "# Instantiate a new model with the same architecture\n",
+        "# Make sure you use the same model class that was trained\n",
+        "loaded_model = ModernLeNet5()\n",
+        "\n",
+        "# Load the saved state dictionary into the new model instance\n",
+        "# Make sure the model is on the correct device (CPU or GPU)\n",
+        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+        "loaded_model.load_state_dict(torch.load(model_save_path, map_location=device))\n",
+        "\n",
+        "# Move the model to the device\n",
+        "loaded_model = loaded_model.to(device)\n",
+        "\n",
+        "# Set the model to evaluation mode\n",
+        "loaded_model.eval()\n",
+        "\n",
+        "print(f\"Model loaded successfully from {model_save_path}\")\n",
+        "print(f\"Model is on device: {next(loaded_model.parameters()).device}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "We now use this model to discover Images for manual curation. Therfore we calculate hardness and mistakeness metrics."
+      ],
+      "metadata": {
+        "id": "fJCtD1akh9qB"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "d-rpeU2Es6wg"
+      },
+      "outputs": [],
+      "source": [
+        "def doInferenceOnTorchSet(model, torch_set, fiftyone_set, batch_size, num_workers):\n",
+        "\n",
+        "  # This uses the torch_train_set which is derived from train_dataset\n",
+        "  inference_loader = torch.utils.data.DataLoader(\n",
+        "      torch_set,\n",
+        "      batch_size=batch_size,\n",
+        "      shuffle=False,    # CRITICAL: Must be False for ordered predictions\n",
+        "      num_workers=num_workers,\n",
+        "      pin_memory=True\n",
+        "  )\n",
+        "\n",
+        "  # Set the loaded model to evaluation mode\n",
+        "  model.eval()\n",
+        "\n",
+        "  # Lists to store predictions and logits for the training set\n",
+        "  predictions = []\n",
+        "  all_logits = []\n",
+        "\n",
+        "  # Run inference on the training set using the NON-SHUFFLED loader\n",
+        "  print(\"Applying LeNet model to the train_dataset (using non-shuffled loader)...\")\n",
+        "  with torch.inference_mode(): # Disable gradient calculation\n",
+        "      # Use the new inference_loader\n",
+        "      for images, _ in tqdm(inference_loader, desc=\"Processing train batches for inference\"):\n",
+        "          images = images.to(device)\n",
+        "\n",
+        "          # Forward pass to get logits\n",
+        "          logits = loaded_model(images)\n",
+        "          all_logits.append(logits.cpu().numpy()) # Store logits\n",
+        "\n",
+        "          # Get predicted class indices\n",
+        "          _, predicted = torch.max(logits.data, 1)\n",
+        "          predictions.extend(predicted.cpu().numpy()) # Store predictions\n",
+        "\n",
+        "  # Concatenate logits from all batches\n",
+        "  all_logits = np.concatenate(all_logits, axis=0)\n",
+        "\n",
+        "  print(\"Inference on dataset complete.\")\n",
+        "  print(f\"Shape of collected logits: {all_logits.shape}\")\n",
+        "  print(f\"Number of collected predictions: {len(predictions)}\")\n",
+        "\n",
+        "  # Store the predictions and logits back into the FiftyOne dataset as Classification objects\n",
+        "  print(\"Storing predictions and logits as FiftyOne Classifications for fiftyone_set...\")\n",
+        "  for i, sample in enumerate(tqdm(fiftyone_set, desc=\"Storing train classifications\")):\n",
+        "      predicted_idx = predictions[i]\n",
+        "      predicted_label = dataset_classes[predicted_idx] # Assuming dataset_classes is consistent\n",
+        "      sample_logits = all_logits[i]\n",
+        "      confidences = Fun.softmax(torch.tensor(sample_logits), dim=0).numpy()\n",
+        "      predicted_confidence = float(confidences[predicted_idx])\n",
+        "      classification = fo.Classification(\n",
+        "          label=predicted_label,\n",
+        "          confidence=predicted_confidence,\n",
+        "          logits=sample_logits.tolist()\n",
+        "      )\n",
+        "      sample[\"lenet_train_classification\"] = classification\n",
+        "      sample.save()\n",
+        "\n",
+        "  print(\"Predictions and logits stored successfully as FiftyOne Classifications for fiftyone_set.\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def computeMetrics(fiftyone_set, label_field):\n",
+        "  #Hardness is a measure computed based on model prediction output (through\n",
+        "#logits) that summarizes a measure of the uncertainty the model had with the\n",
+        "#sample. This makes hardness quantitative and can be used to detect things\n",
+        "#like hard samples and annotation errors\n",
+        "  fob.compute_hardness(fiftyone_set,\n",
+        "                      label_field=label_field,\n",
+        "                      )\n",
+        "  # Evaluate sample mistakenness (how likely the sample is mislabeled)\n",
+        "# Samples with high mistakenness often have conflicting model output and ground truth\n",
+        "  fob.compute_mistakenness(fiftyone_set,\n",
+        "                          pred_field=label_field,\n",
+        "                          label_field=\"ground_truth\")\n"
+      ],
+      "metadata": {
+        "id": "zhx-1ioBZC4C"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "doInferenceOnTorchSet(loaded_model, torch_train_set, train_dataset, batch_size, num_workers)\n",
+        "doInferenceOnTorchSet(loaded_model, torch_val_set, val_dataset, batch_size, num_workers)\n",
+        "doInferenceOnTorchSet(loaded_model, torch_test_set, test_dataset, batch_size, num_workers)"
+      ],
+      "metadata": {
+        "id": "o4Cl5wStVvpC",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "92956395-ac9a-44ad-acbf-d7a79cb40f1e"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Applying LeNet model to the train_dataset (using non-shuffled loader)...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Processing train batches for inference: 100%|██████████| 797/797 [00:32<00:00, 24.18it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Inference on dataset complete.\n",
+            "Shape of collected logits: (51000, 10)\n",
+            "Number of collected predictions: 51000\n",
+            "Storing predictions and logits as FiftyOne Classifications for fiftyone_set...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Storing train classifications: 100%|██████████| 51000/51000 [02:03<00:00, 414.44it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Predictions and logits stored successfully as FiftyOne Classifications for fiftyone_set.\n",
+            "Applying LeNet model to the train_dataset (using non-shuffled loader)...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Processing train batches for inference: 100%|██████████| 141/141 [00:06<00:00, 20.66it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Inference on dataset complete.\n",
+            "Shape of collected logits: (9000, 10)\n",
+            "Number of collected predictions: 9000\n",
+            "Storing predictions and logits as FiftyOne Classifications for fiftyone_set...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Storing train classifications: 100%|██████████| 9000/9000 [00:18<00:00, 483.56it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Predictions and logits stored successfully as FiftyOne Classifications for fiftyone_set.\n",
+            "Applying LeNet model to the train_dataset (using non-shuffled loader)...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Processing train batches for inference: 100%|██████████| 157/157 [00:05<00:00, 30.62it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Inference on dataset complete.\n",
+            "Shape of collected logits: (10000, 10)\n",
+            "Number of collected predictions: 10000\n",
+            "Storing predictions and logits as FiftyOne Classifications for fiftyone_set...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Storing train classifications: 100%|██████████| 10000/10000 [00:24<00:00, 407.74it/s]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Predictions and logits stored successfully as FiftyOne Classifications for fiftyone_set.\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "computeMetrics(train_dataset, \"lenet_train_classification\")\n",
+        "computeMetrics(val_dataset, \"lenet_train_classification\")\n",
+        "computeMetrics(test_dataset, \"lenet_train_classification\")"
+      ],
+      "metadata": {
+        "id": "4vZgT3ImbAOW",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "2d5d7d92-c087-4aba-be63-c4677809f9ab"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Computing hardness...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.brain.internal.core.hardness:Computing hardness...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |█████████████| 51000/51000 [2.2m elapsed, 0s remaining, 339.8 samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |█████████████| 51000/51000 [2.2m elapsed, 0s remaining, 339.8 samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Hardness computation complete\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.brain.internal.core.hardness:Hardness computation complete\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Computing mistakenness...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.brain.internal.core.mistakenness:Computing mistakenness...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |█████████████| 51000/51000 [1.9m elapsed, 0s remaining, 428.8 samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |█████████████| 51000/51000 [1.9m elapsed, 0s remaining, 428.8 samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mistakenness computation complete\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.brain.internal.core.mistakenness:Mistakenness computation complete\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Computing hardness...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.brain.internal.core.hardness:Computing hardness...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |███████████████| 9000/9000 [22.8s elapsed, 0s remaining, 427.0 samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |███████████████| 9000/9000 [22.8s elapsed, 0s remaining, 427.0 samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Hardness computation complete\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.brain.internal.core.hardness:Hardness computation complete\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Computing mistakenness...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.brain.internal.core.mistakenness:Computing mistakenness...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |███████████████| 9000/9000 [20.3s elapsed, 0s remaining, 390.9 samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |███████████████| 9000/9000 [20.3s elapsed, 0s remaining, 390.9 samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mistakenness computation complete\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.brain.internal.core.mistakenness:Mistakenness computation complete\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Computing hardness...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.brain.internal.core.hardness:Computing hardness...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |█████████████| 10000/10000 [26.7s elapsed, 0s remaining, 414.9 samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |█████████████| 10000/10000 [26.7s elapsed, 0s remaining, 414.9 samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Hardness computation complete\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.brain.internal.core.hardness:Hardness computation complete\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Computing mistakenness...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.brain.internal.core.mistakenness:Computing mistakenness...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |█████████████| 10000/10000 [22.5s elapsed, 0s remaining, 364.3 samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |█████████████| 10000/10000 [22.5s elapsed, 0s remaining, 364.3 samples/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mistakenness computation complete\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.brain.internal.core.mistakenness:Mistakenness computation complete\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "suspicious_train_samples_view = train_dataset.match(\n",
+        "                             F(\"mistakenness\") > train_dataset.quantiles(\"mistakenness\", [0.99])[0]\n",
+        "                             ).sort_by(\"mistakenness\", reverse=True)\n",
+        "suspicious_val_samples_view = val_dataset.match(\n",
+        "                             F(\"mistakenness\") >train_dataset.quantiles(\"mistakenness\", [0.99])[0]\n",
+        "                             ).sort_by(\"mistakenness\", reverse=True)\n",
+        "suspicious_test_samples_view = test_dataset.match(\n",
+        "                             F(\"mistakenness\") > train_dataset.quantiles(\"mistakenness\", [0.99])[0]\n",
+        "                             ).sort_by(\"mistakenness\", reverse=True)\n"
+      ],
+      "metadata": {
+        "id": "UW56mqdqrs0E"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "suspicious_train_samples_view = train_dataset.match(\n",
+        "                             F(\"hardness\") > train_dataset.quantiles(\"hardness\", [0.99])[0]\n",
+        "                             ).sort_by(\"hardness\", reverse=True)\n",
+        "suspicious_val_samples_view = val_dataset.match(\n",
+        "                             F(\"hardness\") > val_dataset.quantiles(\"hardness\", [0.99])[0]\n",
+        "                             ).sort_by(\"hardness\", reverse=True)\n",
+        "suspicious_test_samples_view = test_dataset.match(\n",
+        "                             F(\"hardness\") > test_dataset.quantiles(\"hardness\", [0.99])[0]\n",
+        "                             ).sort_by(\"hardness\", reverse=True)"
+      ],
+      "metadata": {
+        "id": "o0mt2-UQwRjL"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Inspect all suspicious samples manually an set \"idk\" labels."
+      ],
+      "metadata": {
+        "id": "UIZ5m6IzsDK_"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "v72vWWoVtRNz",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 35
+        },
+        "outputId": "348fad4f-64b9-4ecd-a671-e3a8dc87d80a"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "https://5151-m-s-36rrqai9ebe4u-b.us-west1-1.prod.colab.dev?polling=true\n"
+          ]
+        }
+      ],
+      "source": [
+        "session.view = suspicious_train_samples_view\n",
+        "session.refresh()\n",
+        "print(session.url)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# suspicious images found manually\n",
+        "idk_train_ids = [\n",
+        "    '/root/fiftyone/mnist/train/data/043455.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/043110.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/007081.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/051945.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/001605.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/028653.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/056597.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/010945.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/000903.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/034405.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/056229.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/053763.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/046858.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/012651.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/056163.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/019361.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/000495.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/019125.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/032748.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/057381.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/005069.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/058023.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/048812.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/021383.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/055341.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/041905.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/003757.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/033507.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/040387.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/000141.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/026883.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/024799.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/053874.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/019905.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/054307.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/020977.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/035325.jpg',\n",
+        "\n",
+        "    '/root/fiftyone/mnist/train/data/016677.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/034708.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/020170.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/038409.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/026749.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/047248.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/036819.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/010316.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/020642.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/015325.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/039424.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/052969.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/001128.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/030765.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/026406.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/031855.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/005791.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/056453.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/004356.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/030605.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/032476.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/050995.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/030752.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/038371.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/053479.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/008854.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/026941.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/023017.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/050213.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/040467.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/017959.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/057663.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/046395.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/001112.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/059400.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/019949.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/047635.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/045869.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/002015.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/043671.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/007600.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/046436.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/013692.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/059720.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/034862.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/051301.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/049791.jpg',\n",
+        "    '/root/fiftyone/mnist/train/data/017210.jpg'\n",
+        "]\n",
+        "\n",
+        "idk_images_in_validation = [\n",
+        "    \"/root/fiftyone/mnist/train/data/036447.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/042113.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/051249.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/007147.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/058259.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/026623.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/002555.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/057543.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/013509.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/020968.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/010383.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/017818.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/025160.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/001377.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/032418.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/007185.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/033305.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/059748.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/032511.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/018248.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/001048.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/036837.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/011782.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/019397.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/013651.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/010242.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/056015.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/034011.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/006051.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/013943.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/015992.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/027557.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/016699.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/028711.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/023869.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/010065.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/048931.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/029239.jpg\",\n",
+        "    \"/root/fiftyone/mnist/train/data/032889.jpg\"\n",
+        "]\n",
+        "\n",
+        "idk_images_in_test = [\n",
+        "    \"/root/fiftyone/mnist/test/data/009730.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/008528.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/008317.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/006756.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/006626.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/006577.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/005956.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/004700.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/004548.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/004177.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/003986.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/003809.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/002655.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/002598.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/002294.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/001902.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/001528.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/001233.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/000957.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/000647.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/009693.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/009643.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/006572.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/006561.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/005601.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/003860.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/003559.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/003370.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/003017.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/002463.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/002190.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/001051.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/000727.jpg\",\n",
+        "    \"/root/fiftyone/mnist/test/data/000176.jpg\"\n",
+        "]\n",
+        "\n",
+        "\n",
+        "# Merge to get one array with all images that should be labled \"idk\"\n",
+        "all_idk_image_paths = idk_images_in_validation + idk_images_in_test + idk_train_ids\n",
+        "\n",
+        "print(f\"Number of 'idk' labels provided: {len(all_idk_image_paths)}\")"
+      ],
+      "metadata": {
+        "id": "KfkQjnZWr438",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "357d06c9-2088-4dd0-8c8e-92d84309e6b7"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Number of 'idk' labels provided: 158\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now we add the new label with two classifications \"idk\" / \"i_know\" to  all threee datasets. We then merge to get the full curated dataset."
+      ],
+      "metadata": {
+        "id": "iqkq91ug0Li3"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "1YAhmEkgtsbl"
+      },
+      "outputs": [],
+      "source": [
+        "\n",
+        "def addIdkToDataset(dataset, image_paths):\n",
+        "  # Get all sample IDs in the train dataset\n",
+        "  all_ids = dataset.values(\"filepath\")\n",
+        "\n",
+        "  # Prepare a list of Classification objects for the new field\n",
+        "  idk_classification_labels = []\n",
+        "  for sample_id in all_ids:\n",
+        "      if sample_id in all_idk_image_paths:\n",
+        "          idk_classification_labels.append(fo.Classification(label=\"idk\"))\n",
+        "      else:\n",
+        "          idk_classification_labels.append(fo.Classification(label=\"i_know\"))\n",
+        "\n",
+        "  # Write the list of Classification objects to the dataset\n",
+        "  dataset.set_values(\"idk_label\", idk_classification_labels)\n",
+        "\n",
+        "  # Persist the change\n",
+        "  dataset.save()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "addIdkToDataset(train_dataset, all_idk_image_paths)\n",
+        "addIdkToDataset(val_dataset, all_idk_image_paths)\n",
+        "addIdkToDataset(test_dataset, all_idk_image_paths)"
+      ],
+      "metadata": {
+        "id": "UGL_MXPFtElb"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Create a new merged dataset\n",
+        "merged_dataset = fo.Dataset(\"mnist-curated\")\n",
+        "\n",
+        "# Add training samples with split tag\n",
+        "for sample in train_dataset:\n",
+        "    sample.tags.append(\"train\")\n",
+        "    merged_dataset.add_sample(sample)\n",
+        "\n",
+        "# Add validation samples with split tag\n",
+        "for sample in val_dataset:\n",
+        "    sample.tags.append(\"validation\")\n",
+        "    merged_dataset.add_sample(sample)\n",
+        "\n",
+        "# Add test samples with split tag\n",
+        "for sample in test_dataset:\n",
+        "    sample.tags.append(\"test\")\n",
+        "    merged_dataset.add_sample(sample)\n",
+        "\n",
+        "# Save the merged dataset\n",
+        "merged_dataset.persistent = True\n",
+        "\n",
+        "print(f\"Merged dataset created with {len(merged_dataset)} total samples\")\n",
+        "print(f\"Train samples: {len(merged_dataset.match_tags('train'))}\")\n",
+        "print(f\"Validation samples: {len(merged_dataset.match_tags('validation'))}\")\n",
+        "print(f\"Test samples: {len(merged_dataset.match_tags('test'))}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "PX0_o8pdy6Q5",
+        "outputId": "5c6e6081-f2cb-449f-8180-388ab7a4bc56"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Merged dataset created with 70000 total samples\n",
+            "Train samples: 51000\n",
+            "Validation samples: 9000\n",
+            "Test samples: 10000\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Save merged_dataset to disk using FiftyOneDataset type\n",
+        "export_dir = Path.cwd() / \"Classification\" / \"curated_mnist_fiftyone\"\n",
+        "export_dir.mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "merged_dataset.export(\n",
+        "    export_dir=str(export_dir),\n",
+        "    dataset_type=fo.types.FiftyOneDataset,\n",
+        "    export_media=True  # This exports the actual image files along with metadata\n",
+        ")\n",
+        "\n",
+        "print(f\"Merged dataset exported to: {export_dir}\")\n",
+        "print(f\"Total samples exported: {len(merged_dataset)}\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "hB-CdR9B0ana",
+        "outputId": "231234fe-55ac-462f-da97-b1c926114e80"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Directory '/content/Classification/curated_mnist_fiftyone' already exists; export will be merged with existing files\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "WARNING:fiftyone.core.collections:Directory '/content/Classification/curated_mnist_fiftyone' already exists; export will be merged with existing files\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Exporting samples...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:fiftyone.utils.data.exporters:Exporting samples...\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            " 100% |████████████████| 70000/70000 [33.1s elapsed, 0s remaining, 2.7K docs/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "INFO:eta.core.utils: 100% |████████████████| 70000/70000 [33.1s elapsed, 0s remaining, 2.7K docs/s]      \n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Merged dataset exported to: /content/Classification/curated_mnist_fiftyone\n",
+            "Total samples exported: 70000\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Upload to huggingface\n",
+        "upload_to_huggingface = False\n",
+        "if upload_to_huggingface:\n",
+        "  !pip install -q fiftyone huggingface_hub\n",
+        "\n",
+        "  from fiftyone.utils.huggingface import push_to_hub\n",
+        "\n",
+        "  hf_token = \"\" # Use your actual token here or load it securely\n",
+        "\n",
+        "  push_to_hub(merged_dataset, \"curated-mnist\", chunk_size=1000, token=hf_token)"
+      ],
+      "metadata": {
+        "id": "TZqwUEtJ1WdD"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "We need to consider the imbalence in the dataset. Therfore we calculate the counts and apply weights."
+      ],
+      "metadata": {
+        "id": "h3fyzuDsYKo2"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from collections import Counter\n",
+        "\n",
+        "# Count labels in the FiftyOne train dataset\n",
+        "train_idk_labels = train_dataset.values(\"idk_label.label\")\n",
+        "counts = Counter(train_idk_labels)\n",
+        "print(counts)  # sanity check\n",
+        "\n",
+        "n_pos = counts[\"idk\"]      # now the minority, and mapped to 1\n",
+        "n_neg = counts[\"i_know\"]\n",
+        "\n",
+        "# e.g. if n_pos = 150, n_neg = 50_000 ==> pos_weight = ~333\n",
+        "pos_weight_value = n_neg / n_pos\n",
+        "print(\"pos_weight:\", pos_weight_value)\n",
+        "\n",
+        "pos_weight = torch.tensor([pos_weight_value], device=device)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "pyadeRrUYSr0",
+        "outputId": "49bd249e-453d-428e-edd7-4aed22fbe80a"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Counter({'i_know': 50915, 'idk': 85})\n",
+            "pos_weight: 599.0\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "KxB-6TtuD1v9"
+      },
+      "outputs": [],
+      "source": [
+        "model = ModernLeNet5(num_classes=1).to(device)\n",
+        "optimizer = Adam(model.parameters(),\n",
+        "                 lr=0.003, betas=(0.9, 0.999),\n",
+        "                 eps=1e-08, weight_decay=0)\n",
+        "loss_function = nn.BCEWithLogitsLoss(pos_weight=pos_weight)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "wPSwSE1ZEL0p"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "RNxbcqNGJ_mK"
+      },
+      "outputs": [],
+      "source": [
+        "def train_epoch(model, train_loader, optimizer, device):\n",
+        "    model.train()\n",
+        "    batch_losses = []\n",
+        "    correct = 0\n",
+        "    total = 0\n",
+        "\n",
+        "    for images, labels in tqdm(train_loader, desc=\"Training: \"):\n",
+        "        images = images.to(device)\n",
+        "\n",
+        "        # labels: from bool/int -> float tensor of shape [B, 1]\n",
+        "        labels = labels.float().unsqueeze(1).to(device)\n",
+        "\n",
+        "        optimizer.zero_grad()\n",
+        "\n",
+        "        # Forward pass: logits shape [B, 1]\n",
+        "        logits = model(images)\n",
+        "\n",
+        "        # BCE with logits expects raw logits + float targets\n",
+        "        loss = loss_function(logits, labels)\n",
+        "\n",
+        "        loss.backward()\n",
+        "        optimizer.step()\n",
+        "\n",
+        "        batch_losses.append(loss.item())\n",
+        "\n",
+        "        # Optional: track accuracy\n",
+        "        with torch.no_grad():\n",
+        "            probs = torch.sigmoid(logits)          # [B, 1]\n",
+        "            preds = (probs >= 0.5).float()         # threshold at 0.5\n",
+        "            correct += (preds == labels).sum().item()\n",
+        "            total += labels.numel()\n",
+        "\n",
+        "    epoch_loss = np.mean(batch_losses)\n",
+        "    epoch_acc = correct / total if total > 0 else 0.0\n",
+        "    return epoch_loss, epoch_acc\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "label_map = {\n",
+        "    \"idk\": 1,      # minority -> positive class\n",
+        "    \"i_know\": 0    # majority -> negative class\n",
+        "}"
+      ],
+      "metadata": {
+        "id": "UzbFF5bnFXcC"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "train_set_idk = CustomTorchImageDataset(train_dataset, label_map=label_map, image_transforms=image_transforms, gt_field=\"idk_label\")\n",
+        "val_set_idk = CustomTorchImageDataset(val_dataset, label_map=label_map, image_transforms=image_transforms, gt_field=\"idk_label\")\n"
+      ],
+      "metadata": {
+        "id": "JsJcz5zXEM3Z",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "bdb36fcf-d879-4a3b-bc44-b8a6be389e7c"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "CustomTorchImageDataset initialized with 51000 samples.\n",
+            "CustomTorchImageDataset initialized with 9000 samples.\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "train_set_idk[0]"
+      ],
+      "metadata": {
+        "collapsed": true,
+        "id": "QO6M2RCEHU0q"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "session.view = train_dataset.view()\n",
+        "session.refresh()\n",
+        "print(session.url)"
+      ],
+      "metadata": {
+        "id": "rA49jVdtG5XZ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "169bxh0FG4Dn"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "train_loader_idk = create_deterministic_training_dataloader(\n",
+        "    train_set_idk,\n",
+        "    batch_size=batch_size,\n",
+        "    num_workers=num_workers,\n",
+        ")\n",
+        "val_loader_idk = create_deterministic_training_dataloader(\n",
+        "    val_set_idk,\n",
+        "    batch_size=batch_size,\n",
+        "    num_workers=num_workers,\n",
+        ")"
+      ],
+      "metadata": {
+        "id": "yerjgRuIFjph"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def val_epoch(model, val_loader):\n",
+        "  batch_losses = []\n",
+        "  model.eval()\n",
+        "  with torch.inference_mode():\n",
+        "    for images, labels in tqdm(val_loader, desc=\"Validation: \"):\n",
+        "      images = images.to(device)\n",
+        "      # For binary classification, labels need to be float and unsqueezed\n",
+        "      labels = labels.float().unsqueeze(1).to(device)\n",
+        "      # Forward pass\n",
+        "      logits = model(images)\n",
+        "      # Use the binary classification loss function\n",
+        "      loss_value = loss_function(logits, labels)\n",
+        "      batch_losses.append(loss_value.item())\n",
+        "  val_loss = np.mean(batch_losses)\n",
+        "  return val_loss"
+      ],
+      "metadata": {
+        "id": "ThPil0WlMf_r"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "YwvNFScPK9mF",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "c5bbf840-2b51-4188-bcfc-118ddc4fb2ab"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "All random seeds set to 51 for reproducibility\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:41<00:00, 19.25it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:06<00:00, 23.16it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 1/5 - Train Loss: 2.0867 - Train Acc: 0.5647 - Val Loss: 2.6552\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:43<00:00, 18.23it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:04<00:00, 28.91it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 2/5 - Train Loss: 1.9293 - Train Acc: 0.4407 - Val Loss: 2.4106\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:45<00:00, 17.64it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:04<00:00, 29.82it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 3/5 - Train Loss: 1.3914 - Train Acc: 0.2610 - Val Loss: 2.4445\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:42<00:00, 18.96it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:07<00:00, 18.38it/s]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 4/5 - Train Loss: 1.3882 - Train Acc: 0.4211 - Val Loss: 2.4329\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Training: 100%|██████████| 797/797 [00:41<00:00, 19.10it/s]\n",
+            "Validation: 100%|██████████| 141/141 [00:06<00:00, 23.37it/s]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 5/5 - Train Loss: 1.3870 - Train Acc: 0.2460 - Val Loss: 2.4992\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "set_seeds(51) # You can change this number to get different results\n",
+        "\n",
+        "num_epochs = 10\n",
+        "train_losses = []\n",
+        "val_losses = []\n",
+        "\n",
+        "best_val_loss = float('inf')\n",
+        "best_model = None\n",
+        "\n",
+        "# Define the path to save the model within your hard-drive\n",
+        "path = Path(os.getcwd()) # Feel free to change the path\n",
+        "\n",
+        "# model_save_path = path / 'best_lenet.pth'\n",
+        "\n",
+        "for epoch in range(num_epochs):\n",
+        "    train_loss, train_acc = train_epoch(model, train_loader_idk, optimizer=optimizer, device=device)\n",
+        "    val_loss = val_epoch(model, val_loader_idk)\n",
+        "    train_losses.append(train_loss)\n",
+        "    val_losses.append(val_loss)\n",
+        "\n",
+        "\n",
+        "    print(f\"Epoch {epoch+1}/{num_epochs} - Train Loss: {train_loss:.4f} - Train Acc: {train_acc:.4f} - Val Loss: {val_loss:.4f}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plt.figure(figsize=(10, 5))\n",
+        "plt.plot(train_losses, label='Training Loss')\n",
+        "plt.plot(val_losses, label='Validation Loss')\n",
+        "plt.xlabel('Epochs')\n",
+        "plt.ylabel('Loss')\n",
+        "plt.legend()\n",
+        "plt.title('Training and Validation Loss')\n",
+        "\n",
+        "# Find the epoch with the best validation loss\n",
+        "best_epoch = np.argmin(val_losses) + 1 # Add 1 because epochs are 1-indexed\n",
+        "\n",
+        "# Add a vertical red line at the epoch with the best validation loss\n",
+        "plt.axvline(x=best_epoch, color='red', linestyle='--', label=f'Best Val Loss Epoch {best_epoch}')\n",
+        "plt.legend()\n",
+        "\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "id": "76Dzb9o6SsaL",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 487
+        },
+        "outputId": "a066b1d9-94b1-40fe-d4a7-c3767ef9b406"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "During Training the Training loss decreases, however the validation loss stays at a high level. This shows the model does not function as intended.\n",
+        "A further approach could use data augmentation to increase the number of \"idk\" samples in the training data."
+      ],
+      "metadata": {
+        "id": "UOTTzaN6dWeQ"
+      }
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file