diff --git "a/Notebooks/Deit_fine_tuning.ipynb" "b/Notebooks/Deit_fine_tuning.ipynb"
new file mode 100644--- /dev/null
+++ "b/Notebooks/Deit_fine_tuning.ipynb"
@@ -0,0 +1,3312 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "NgtT8HqFSRwR",
+        "outputId": "8b9a40dc-148e-4627-cc39-10ec0acbddbe"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (3.10.0)\n",
+            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.12/dist-packages (1.6.1)\n",
+            "Requirement already satisfied: transformers in /usr/local/lib/python3.12/dist-packages (5.0.0)\n",
+            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.3.3)\n",
+            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (0.12.1)\n",
+            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (4.62.1)\n",
+            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.5.0)\n",
+            "Requirement already satisfied: numpy>=1.23 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (2.0.2)\n",
+            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (26.0)\n",
+            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (11.3.0)\n",
+            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (3.3.2)\n",
+            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (2.9.0.post0)\n",
+            "Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.16.3)\n",
+            "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.5.3)\n",
+            "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (3.6.0)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from transformers) (3.25.2)\n",
+            "Requirement already satisfied: huggingface-hub<2.0,>=1.3.0 in /usr/local/lib/python3.12/dist-packages (from transformers) (1.7.1)\n",
+            "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.12/dist-packages (from transformers) (6.0.3)\n",
+            "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.12/dist-packages (from transformers) (2025.11.3)\n",
+            "Requirement already satisfied: tokenizers<=0.23.0,>=0.22.0 in /usr/local/lib/python3.12/dist-packages (from transformers) (0.22.2)\n",
+            "Requirement already satisfied: typer-slim in /usr/local/lib/python3.12/dist-packages (from transformers) (0.24.0)\n",
+            "Requirement already satisfied: safetensors>=0.4.3 in /usr/local/lib/python3.12/dist-packages (from transformers) (0.7.0)\n",
+            "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.12/dist-packages (from transformers) (4.67.3)\n",
+            "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (2025.3.0)\n",
+            "Requirement already satisfied: hf-xet<2.0.0,>=1.4.2 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (1.4.2)\n",
+            "Requirement already satisfied: httpx<1,>=0.23.0 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (0.28.1)\n",
+            "Requirement already satisfied: typer in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (0.24.1)\n",
+            "Requirement already satisfied: typing-extensions>=4.1.0 in /usr/local/lib/python3.12/dist-packages (from huggingface-hub<2.0,>=1.3.0->transformers) (4.15.0)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n",
+            "Requirement already satisfied: anyio in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (4.12.1)\n",
+            "Requirement already satisfied: certifi in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (2026.2.25)\n",
+            "Requirement already satisfied: httpcore==1.* in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (1.0.9)\n",
+            "Requirement already satisfied: idna in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (3.11)\n",
+            "Requirement already satisfied: h11>=0.16 in /usr/local/lib/python3.12/dist-packages (from httpcore==1.*->httpx<1,>=0.23.0->huggingface-hub<2.0,>=1.3.0->transformers) (0.16.0)\n",
+            "Requirement already satisfied: click>=8.2.1 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub<2.0,>=1.3.0->transformers) (8.3.1)\n",
+            "Requirement already satisfied: shellingham>=1.3.0 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub<2.0,>=1.3.0->transformers) (1.5.4)\n",
+            "Requirement already satisfied: rich>=12.3.0 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub<2.0,>=1.3.0->transformers) (13.9.4)\n",
+            "Requirement already satisfied: annotated-doc>=0.0.2 in /usr/local/lib/python3.12/dist-packages (from typer->huggingface-hub<2.0,>=1.3.0->transformers) (0.0.4)\n",
+            "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.12/dist-packages (from rich>=12.3.0->typer->huggingface-hub<2.0,>=1.3.0->transformers) (4.0.0)\n",
+            "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.12/dist-packages (from rich>=12.3.0->typer->huggingface-hub<2.0,>=1.3.0->transformers) (2.19.2)\n",
+            "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.12/dist-packages (from markdown-it-py>=2.2.0->rich>=12.3.0->typer->huggingface-hub<2.0,>=1.3.0->transformers) (0.1.2)\n"
+          ]
+        }
+      ],
+      "source": [
+        "!pip install matplotlib scikit-learn transformers"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "VsIIXQjQL1lz"
+      },
+      "source": [
+        "# Connecting to google drive to load the data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "DHQMpfOOSTDA",
+        "outputId": "50ceaa90-8df0-4a97-f2cd-2571516f183d"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n"
+          ]
+        }
+      ],
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "kVQ3fxaML1l0"
+      },
+      "source": [
+        "# Organising data into train and test folders"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "id": "xO-saItsoKSa"
+      },
+      "outputs": [],
+      "source": [
+        "\n",
+        "import os\n",
+        "import shutil\n",
+        "import random\n",
+        "\n",
+        "base_dir = \"/content/drive/MyDrive/dataset\"\n",
+        "train_dir = os.path.join(base_dir, \"train\")\n",
+        "val_dir   = os.path.join(base_dir, \"val\")\n",
+        "\n",
+        "split_ratio = 0.8\n",
+        "random.seed(42)\n",
+        "\n",
+        "\n",
+        "os.makedirs(train_dir, exist_ok=True)\n",
+        "os.makedirs(val_dir, exist_ok=True)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Mm4_X2VxoRhY",
+        "outputId": "4a4a290b-96c7-4e02-c9d3-f450ebefe558"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "✅ Dataset split completed safely.\n"
+          ]
+        }
+      ],
+      "source": [
+        "classes = [\n",
+        "    d for d in os.listdir(base_dir)\n",
+        "    if os.path.isdir(os.path.join(base_dir, d))\n",
+        "    and d not in [\"train\", \"val\"]\n",
+        "]\n",
+        "\n",
+        "for cls in classes:\n",
+        "    cls_path = os.path.join(base_dir, cls)\n",
+        "    images = [f for f in os.listdir(cls_path) if os.path.isfile(os.path.join(cls_path, f))]\n",
+        "\n",
+        "    random.shuffle(images)\n",
+        "    split_idx = int(len(images) * split_ratio)\n",
+        "\n",
+        "    train_images = images[:split_idx]\n",
+        "    val_images   = images[split_idx:]\n",
+        "\n",
+        "    os.makedirs(os.path.join(train_dir, cls), exist_ok=True)\n",
+        "    os.makedirs(os.path.join(val_dir, cls), exist_ok=True)\n",
+        "\n",
+        "    for img in train_images:\n",
+        "        src = os.path.join(cls_path, img)\n",
+        "        dst = os.path.join(train_dir, cls, img)\n",
+        "        if not os.path.exists(dst):\n",
+        "            shutil.copy2(src, dst)\n",
+        "\n",
+        "    for img in val_images:\n",
+        "        src = os.path.join(cls_path, img)\n",
+        "        dst = os.path.join(val_dir, cls, img)\n",
+        "        if not os.path.exists(dst):\n",
+        "            shutil.copy2(src, dst)\n",
+        "\n",
+        "print(\"✅ Dataset split completed safely.\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "3N_WI8D_L1l1"
+      },
+      "source": [
+        "# Importing necessary libraries"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "MGMH7t8wSS_U"
+      },
+      "outputs": [],
+      "source": [
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "from torch.utils.data import Dataset, DataLoader\n",
+        "from torchvision.datasets import ImageFolder\n",
+        "from torchvision import transforms\n",
+        "from torchvision import models\n",
+        "from tqdm import tqdm\n",
+        "from torchvision import models\n",
+        "import torch.nn as nn\n",
+        "import matplotlib.pyplot as plt\n",
+        "import random\n",
+        "import json\n",
+        "import os\n",
+        "import seaborn as sns\n",
+        "from sklearn.metrics import confusion_matrix, classification_report\n",
+        "from transformers import get_cosine_schedule_with_warmup\n",
+        "from transformers import DeiTForImageClassification, DeiTImageProcessor\n",
+        "import os"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "bSnESArXL1l2"
+      },
+      "source": [
+        "# Loading the porcessor"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 173,
+          "referenced_widgets": [
+            "f0dc4a5c485f4cf0b72d7fcb49b4ec67",
+            "3a9a8cb6dc444a5a9263b984ca57b70f",
+            "84034deb5cdf4409bf4a14eda1afa57c",
+            "fd79865e6bc9421eb3a4a403f861934c",
+            "604ad83134c846c199f0c33da48ae210",
+            "a906705398e6470ba667bb33e4d29e48",
+            "1036cd0b2ce945e69f7934d96dcbd5ca",
+            "f43d2371b08748f6962da8df53abc21a",
+            "2d349b7e5d7b495cbf8c73a20d441741",
+            "77d4bc5c954f447683df61dfb887cd9d",
+            "e4a615aa66f14b4ca6519e8d001e9037"
+          ]
+        },
+        "id": "7HVNvJrWY4O2",
+        "outputId": "52688895-692f-4a28-bab8-4524262222c7"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.12/dist-packages/huggingface_hub/utils/_auth.py:94: UserWarning: \n",
+            "The secret `HF_TOKEN` does not exist in your Colab secrets.\n",
+            "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n",
+            "You will be able to reuse this secret in all of your notebooks.\n",
+            "Please note that authentication is recommended but still optional to access public models or datasets.\n",
+            "  warnings.warn(\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "preprocessor_config.json:   0%|          | 0.00/287 [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "f0dc4a5c485f4cf0b72d7fcb49b4ec67"
+            }
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "model_name = \"facebook/deit-base-distilled-patch16-224\"\n",
+        "processor = DeiTImageProcessor.from_pretrained(model_name)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "OKBTDsIvL1l2"
+      },
+      "source": [
+        "# Custom dataloader class and transforms"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "metadata": {
+        "id": "dXwJBxDaSS8X"
+      },
+      "outputs": [],
+      "source": [
+        "from torchvision import transforms\n",
+        "\n",
+        "train_transforms = transforms.Compose([\n",
+        "    transforms.RandomResizedCrop(224, scale=(0.8, 1.0)),\n",
+        "    transforms.RandomHorizontalFlip(p=0.5),\n",
+        "\n",
+        "    # Slightly stronger but still safe\n",
+        "    transforms.ColorJitter(\n",
+        "        brightness=0.3,\n",
+        "        contrast=0.3,\n",
+        "        saturation=0.2,\n",
+        "        hue=0.05\n",
+        "    ),\n",
+        "\n",
+        "    # VERY IMPORTANT (low risk, high gain)\n",
+        "    transforms.RandomRotation(10),\n",
+        "\n",
+        "    # Helps generalization (don’t remove)\n",
+        "    transforms.RandomApply([\n",
+        "        transforms.GaussianBlur(kernel_size=3)\n",
+        "    ], p=0.2),\n",
+        "])\n",
+        "\n",
+        "val_transforms = transforms.Compose([\n",
+        "    transforms.Resize((224, 224))\n",
+        "])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "id": "rR6ubkCHVHiC"
+      },
+      "outputs": [],
+      "source": [
+        "class Car_damage_dataset(Dataset):\n",
+        "    def __init__(self, data_dir, processor, transform=None):\n",
+        "        self.dataset = ImageFolder(root=data_dir, transform=transform)\n",
+        "        self.processor = processor\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        return len(self.dataset)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        image, label = self.dataset[idx]\n",
+        "\n",
+        "        enc = self.processor(\n",
+        "            images=image,\n",
+        "            return_tensors='pt'\n",
+        "        )\n",
+        "\n",
+        "        return {\n",
+        "            'pixel_values': enc['pixel_values'].squeeze(0),\n",
+        "            'labels': torch.tensor(label)\n",
+        "        }"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "id": "vwJKVoMUVHfM"
+      },
+      "outputs": [],
+      "source": [
+        "train_path = \"/content/drive/MyDrive/dataset/train\"\n",
+        "test_path   = \"/content/drive/MyDrive/dataset/val\"\n",
+        "\n",
+        "\n",
+        "train_dataset = Car_damage_dataset(data_dir=train_path, transform=train_transforms, processor=processor)\n",
+        "\n",
+        "test_dataset  = Car_damage_dataset(data_dir=test_path, transform=val_transforms, processor=processor)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "iqiwgFAcZcFY",
+        "outputId": "ff55ef59-55b4-45bc-c64b-c465d51e6946"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "{0: 'F_Breakage',\n",
+              " 1: 'F_Crushed',\n",
+              " 2: 'F_Normal',\n",
+              " 3: 'R_Breakage',\n",
+              " 4: 'R_Crushed',\n",
+              " 5: 'R_Normal'}"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 10
+        }
+      ],
+      "source": [
+        "class_to_idx = train_dataset.dataset.class_to_idx\n",
+        "idx_to_class = {v: k for k, v in class_to_idx.items()}\n",
+        "idx_to_class"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "8LrzkXLTL1l4"
+      },
+      "source": [
+        "# Visualising the train test split"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 521
+        },
+        "id": "uvAG9UYoZb_F",
+        "outputId": "d6616e39-02ba-4f35-f529-89a781c5f788"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 600x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "labels = ['Training Data', 'Testing Data']\n",
+        "sizes  = [len(train_dataset), len(test_dataset)]\n",
+        "colors = ['lightgreen', 'red']\n",
+        "explode = (0.1, 0)\n",
+        "plt.figure(figsize=(6, 6))\n",
+        "plt.pie(sizes, explode=explode, labels=labels, colors=colors,\n",
+        "        autopct='%1.1f%%', shadow=True, startangle=140)\n",
+        "plt.title('Training vs Testing Data Distribution')\n",
+        "plt.axis('equal')\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "27H0BE6DL1l5"
+      },
+      "source": [
+        "# Ploting the image distribution across the classes"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 536
+        },
+        "id": "1D05WLP_Zb8S",
+        "outputId": "4a7076d6-6946-4ca3-cef0-801025f80cb3"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x500 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "def plot_class_distribution(data_path):\n",
+        "    classes = os.listdir(data_path)\n",
+        "    counts = []\n",
+        "\n",
+        "    for cls in classes:\n",
+        "        cls_path = os.path.join(data_path, cls)\n",
+        "        if os.path.isdir(cls_path):\n",
+        "            counts.append(len(os.listdir(cls_path)))\n",
+        "\n",
+        "    plt.figure(figsize=(12,5))\n",
+        "    plt.bar(classes, counts)\n",
+        "    plt.xticks(rotation=90)\n",
+        "    plt.title(\"Train Class Distribution\")\n",
+        "    plt.show()\n",
+        "\n",
+        "plot_class_distribution(\"/content/drive/MyDrive/dataset/train\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "odZebJKDZb5W",
+        "outputId": "0658ddda-12b2-4576-b587-c597b480a364"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.12/dist-packages/torch/utils/data/dataloader.py:424: UserWarning: This DataLoader will create 10 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
+            "  self.check_worker_number_rationality()\n"
+          ]
+        }
+      ],
+      "source": [
+        "train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=10, pin_memory=True, persistent_workers=True)\n",
+        "\n",
+        "eval_loader = DataLoader(test_dataset, batch_size=128, num_workers=10, pin_memory=True, persistent_workers=True)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "T7nE-s6FZlYY",
+        "outputId": "720debe2-323b-4dd7-da4c-bcb64bf904f4"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Using device: cuda\n"
+          ]
+        }
+      ],
+      "source": [
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "print(f\"Using device: {device}\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "PLRenl1RL1l6"
+      },
+      "source": [
+        "# Initializing the model\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000,
+          "referenced_widgets": [
+            "322d7fe22bfa4a1795b80452960be1b2",
+            "c4671aa066354cdfad280d0477f4a643",
+            "8e9eb33374994be0814d5e0e77ee9b58",
+            "3e42099002474d21bcfa3bb2d550b333",
+            "6a671a36dbb04271937a1daced027151",
+            "0637094274e047ddbe9adf5001806849",
+            "0dc5a5a67c1d4076bb28fffb2e88537e",
+            "2a1212a3a69e4f479ca0674196f6b7f6",
+            "9b0b1db948bf47718d0f1ec61a49ce05",
+            "b5cefbe2f07b4a09afd3d79cc1da8bf0",
+            "6e05d3819a294c92ada4063ed3bf7db8",
+            "bb84d9c025784a45becc9ad1d3760e4a",
+            "df339ccf071b4db896da7f603785cad7",
+            "b54c91db8ccb4a9a9ddd714416cafcbb",
+            "5461c90c719b4c0a915dc4090263bc16",
+            "69b6b828c3bf42d38adbd4406c75b611",
+            "fb0da298e88d4c029d06707bcd1e671b",
+            "ae3948b5c36b48fdb4fe94701831d389",
+            "a00c2fa89f334ea69827c79ece145656",
+            "79b4aa0d6edf47699496f6b71419a2f9",
+            "6847cdb46df54256bf152f60874e12e9",
+            "5c765c6081b646569436c190eb79caef",
+            "01a0abd752874a23b21320faa4a50e96",
+            "7e69b37f77d345cfbf12302005e5f6e6",
+            "bfe3dc2f082a4dbbac5a4d243fdff552",
+            "6b6c5d47cdd64246aa9be34eb69ffa1b",
+            "920788c705e5469693ea54e59113f625",
+            "516c1a4e741d48ada3b5399bda974b0a",
+            "74187d6e7d1a45db9f121f03f66277fe",
+            "1cce8fdebf5d485784461724c1163f4d",
+            "6af1d54b7d7f47efb8c27aaeb1442d5d",
+            "7adbaa39073e431bb5df2cb86c506af2",
+            "0fdb36db08814140b3215b3c297fcacc",
+            "b4ecc700eb0e44db9669727abff367af",
+            "93835ed86f46430296d5b78b333239cc",
+            "d4b2deb439e84bf6add182f21cdfcfe8",
+            "9c6f9f41b0444b05aec374461ea90ddd",
+            "359481807e0d424bbd19e09e8439655e",
+            "956b6d845d77404daa9fd78d7e45eeba",
+            "f7ad414d35b145aa88642ea0be2703c2",
+            "f1406296340b4afe96b975b721ba6019",
+            "e45729f0fe5a4e568f1b7936ec9aff0e",
+            "3f254bbf769345e6b66ff2e5be48347d",
+            "39d2c485a42146c6ab639010c3ce15a8"
+          ]
+        },
+        "id": "P1-cfEV39yV3",
+        "outputId": "28426efc-de3d-4758-9486-8ac11de2a92e"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "config.json: 0.00B [00:00, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "322d7fe22bfa4a1795b80452960be1b2"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n",
+            "WARNING:huggingface_hub.utils._http:Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "pytorch_model.bin:   0%|          | 0.00/349M [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "bb84d9c025784a45becc9ad1d3760e4a"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "Loading weights:   0%|          | 0/199 [00:00<?, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "01a0abd752874a23b21320faa4a50e96"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "model.safetensors:   0%|          | 0.00/349M [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "b4ecc700eb0e44db9669727abff367af"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "DeiTForImageClassification LOAD REPORT from: facebook/deit-base-distilled-patch16-224\n",
+            "Key                            | Status     | \n",
+            "-------------------------------+------------+-\n",
+            "distillation_classifier.bias   | UNEXPECTED | \n",
+            "distillation_classifier.weight | UNEXPECTED | \n",
+            "cls_classifier.weight          | UNEXPECTED | \n",
+            "cls_classifier.bias            | UNEXPECTED | \n",
+            "classifier.weight              | MISSING    | \n",
+            "classifier.bias                | MISSING    | \n",
+            "\n",
+            "Notes:\n",
+            "- UNEXPECTED\t:can be ignored when loading from different task/architecture; not ok if you expect identical arch.\n",
+            "- MISSING\t:those params were newly initialized because missing from the checkpoint. Consider training on your downstream task.\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "DeiTForImageClassification(\n",
+              "  (deit): DeiTModel(\n",
+              "    (embeddings): DeiTEmbeddings(\n",
+              "      (patch_embeddings): DeiTPatchEmbeddings(\n",
+              "        (projection): Conv2d(3, 768, kernel_size=(16, 16), stride=(16, 16))\n",
+              "      )\n",
+              "      (dropout): Dropout(p=0.0, inplace=False)\n",
+              "    )\n",
+              "    (encoder): DeiTEncoder(\n",
+              "      (layer): ModuleList(\n",
+              "        (0-11): 12 x DeiTLayer(\n",
+              "          (attention): DeiTAttention(\n",
+              "            (attention): DeiTSelfAttention(\n",
+              "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
+              "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
+              "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
+              "            )\n",
+              "            (output): DeiTSelfOutput(\n",
+              "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
+              "              (dropout): Dropout(p=0.0, inplace=False)\n",
+              "            )\n",
+              "          )\n",
+              "          (intermediate): DeiTIntermediate(\n",
+              "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
+              "            (intermediate_act_fn): GELUActivation()\n",
+              "          )\n",
+              "          (output): DeiTOutput(\n",
+              "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
+              "            (dropout): Dropout(p=0.0, inplace=False)\n",
+              "          )\n",
+              "          (layernorm_before): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "          (layernorm_after): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "        )\n",
+              "      )\n",
+              "    )\n",
+              "    (layernorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
+              "  )\n",
+              "  (classifier): Linear(in_features=768, out_features=6, bias=True)\n",
+              ")"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 15
+        }
+      ],
+      "source": [
+        "model = DeiTForImageClassification.from_pretrained(\n",
+        "    model_name,\n",
+        "    num_labels=6,\n",
+        "    ignore_mismatched_sizes=True\n",
+        ")\n",
+        "\n",
+        "for param in model.deit.parameters():\n",
+        "    param.requires_grad = False\n",
+        "\n",
+        "# Unfreeze last 4 layers instead of 2\n",
+        "for param in model.deit.encoder.layer[-4:].parameters():\n",
+        "    param.requires_grad = True\n",
+        "\n",
+        "# ALSO unfreeze LayerNorm (important for transformers)\n",
+        "for param in model.deit.layernorm.parameters():\n",
+        "    param.requires_grad = True\n",
+        "\n",
+        "model.to(device)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BcFWw7XoL1l6"
+      },
+      "source": [
+        "# Code for early stopping"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "id": "HZ751j6kZlSZ"
+      },
+      "outputs": [],
+      "source": [
+        "class EarlyStopping:\n",
+        "    def __init__(self, patience=6, min_delta=0.0005):\n",
+        "        self.patience = patience\n",
+        "        self.min_delta = min_delta\n",
+        "        self.counter = 0\n",
+        "        self.best_score = None\n",
+        "        self.early_stop = False\n",
+        "\n",
+        "    def __call__(self, metric):\n",
+        "        if self.best_score is None:\n",
+        "            self.best_score = metric\n",
+        "        elif metric < self.best_score + self.min_delta:\n",
+        "            self.counter += 1\n",
+        "            if self.counter >= self.patience:\n",
+        "                self.early_stop = True\n",
+        "        else:\n",
+        "            self.best_score = metric\n",
+        "            self.counter = 0"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ax8P1uBjL1l6"
+      },
+      "source": [
+        "# Critetion and optimizer\n",
+        "- Uing different LR for classifier and last trainable layers"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "id": "fjuETbYgZlPh"
+      },
+      "outputs": [],
+      "source": [
+        "criterion = nn.CrossEntropyLoss(label_smoothing=0.1)\n",
+        "optimizer = torch.optim.AdamW([\n",
+        "    {\"params\": model.deit.encoder.layer[-4:].parameters(), \"lr\": 3e-5},\n",
+        "    {\"params\": model.deit.layernorm.parameters(), \"lr\": 3e-5},\n",
+        "    {\"params\": model.classifier.parameters(), \"lr\": 1e-4}\n",
+        "], weight_decay=1e-4)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "nYSeqTGtL1l6"
+      },
+      "source": [
+        "# Training Function"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "id": "Ep_04TvAXmD0"
+      },
+      "outputs": [],
+      "source": [
+        "def train_model(\n",
+        "    model,\n",
+        "    epochs,\n",
+        "    train_loader,\n",
+        "    eval_loader,\n",
+        "    optimizer,\n",
+        "    criterion,\n",
+        "    device,\n",
+        "    patience=6,\n",
+        "    checkpoint_model_name=\"model\"\n",
+        "):\n",
+        "\n",
+        "    print(\"Starting training...\")\n",
+        "    print(f\"Epochs: {epochs} | Device: {device}\")\n",
+        "    print(\"-\" * 60)\n",
+        "\n",
+        "    # ------------------------- SCHEDULER -------------------------\n",
+        "    num_training_steps = epochs * len(train_loader)\n",
+        "    num_warmup_steps = int(0.1 * num_training_steps)\n",
+        "\n",
+        "    scheduler = get_cosine_schedule_with_warmup(\n",
+        "        optimizer,\n",
+        "        num_warmup_steps=num_warmup_steps,\n",
+        "        num_training_steps=num_training_steps\n",
+        "    )\n",
+        "\n",
+        "    early_stopping = EarlyStopping(patience=patience)\n",
+        "\n",
+        "    train_losses, train_accs = [], []\n",
+        "    val_losses, val_accs = [], []\n",
+        "\n",
+        "    best_acc = 0.0\n",
+        "\n",
+        "    # ------------------------- TRAIN LOOP -------------------------\n",
+        "    for epoch in range(epochs):\n",
+        "\n",
+        "        # --------------------- TRAIN ---------------------\n",
+        "        model.train()\n",
+        "        running_loss, correct, total = 0, 0, 0\n",
+        "\n",
+        "        for batch in tqdm(train_loader, desc=f\"Epoch {epoch+1} Training\"):\n",
+        "\n",
+        "            images = batch['pixel_values'].to(device)\n",
+        "            labels = batch['labels'].to(device)\n",
+        "\n",
+        "            optimizer.zero_grad(set_to_none=True)\n",
+        "\n",
+        "            outputs = model(images)\n",
+        "            logits = outputs.logits\n",
+        "\n",
+        "            loss = criterion(logits, labels)\n",
+        "            loss.backward()\n",
+        "\n",
+        "            optimizer.step()\n",
+        "            scheduler.step()\n",
+        "\n",
+        "            running_loss += loss.item()\n",
+        "            preds = torch.argmax(logits, dim=1)\n",
+        "\n",
+        "            correct += (preds == labels).sum().item()\n",
+        "            total += labels.size(0)\n",
+        "\n",
+        "        train_loss = running_loss / len(train_loader)\n",
+        "        train_acc = 100 * correct / total\n",
+        "\n",
+        "        train_losses.append(train_loss)\n",
+        "        train_accs.append(train_acc)\n",
+        "\n",
+        "        # --------------------- VALIDATION ---------------------\n",
+        "        model.eval()\n",
+        "        val_running_loss, val_correct, val_total = 0, 0, 0\n",
+        "\n",
+        "        all_preds, all_labels = [], []\n",
+        "\n",
+        "        with torch.no_grad():\n",
+        "            for batch in tqdm(eval_loader, desc=f\"Epoch {epoch+1} Validation\"):\n",
+        "\n",
+        "                images = batch['pixel_values'].to(device)\n",
+        "                labels = batch['labels'].to(device)\n",
+        "\n",
+        "                outputs = model(images)\n",
+        "                logits = outputs.logits\n",
+        "\n",
+        "                loss = criterion(logits, labels)\n",
+        "\n",
+        "                val_running_loss += loss.item()\n",
+        "\n",
+        "                preds = torch.argmax(logits, dim=1)\n",
+        "                val_correct += (preds == labels).sum().item()\n",
+        "                val_total += labels.size(0)\n",
+        "\n",
+        "                all_preds.extend(preds.cpu().numpy())\n",
+        "                all_labels.extend(labels.cpu().numpy())\n",
+        "\n",
+        "        val_loss = val_running_loss / len(eval_loader)\n",
+        "        val_acc = 100 * val_correct / val_total\n",
+        "\n",
+        "        val_losses.append(val_loss)\n",
+        "        val_accs.append(val_acc)\n",
+        "\n",
+        "        print(\n",
+        "            f\"Results \"\n",
+        "            f\"Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.2f}% || \"\n",
+        "            f\"Val Loss: {val_loss:.4f} | Val Acc: {val_acc:.2f}%\"\n",
+        "        )\n",
+        "        print(\"-\" * 60)\n",
+        "\n",
+        "        # --------------------- SAVE BEST MODEL (BY ACCURACY) ---------------------\n",
+        "        if val_acc > best_acc:\n",
+        "            best_acc = val_acc\n",
+        "\n",
+        "            os.makedirs(\"checkpoints\", exist_ok=True)\n",
+        "\n",
+        "            torch.save({\n",
+        "                \"model_state_dict\": model.state_dict(),\n",
+        "                \"optimizer_state_dict\": optimizer.state_dict(),\n",
+        "                \"epoch\": epoch,\n",
+        "                \"val_acc\": val_acc\n",
+        "            }, f\"checkpoints/{checkpoint_model_name}.pt\")\n",
+        "\n",
+        "            print(f\"Best model saved (Acc: {val_acc:.2f}%)\")\n",
+        "\n",
+        "        # --------------------- EARLY STOPPING ---------------------\n",
+        "        early_stopping(val_acc)\n",
+        "\n",
+        "        if early_stopping.early_stop:\n",
+        "            print(f\"Early stopping at epoch {epoch+1}\")\n",
+        "            break\n",
+        "\n",
+        "    return (\n",
+        "        train_losses,\n",
+        "        train_accs,\n",
+        "        val_losses,\n",
+        "        val_accs,\n",
+        "        all_preds,\n",
+        "        all_labels\n",
+        "    )"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "YzvDqaf8L1l7"
+      },
+      "source": [
+        "# Training the model"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "PdgQz2OeYN6C",
+        "outputId": "1e5dba0f-0af2-4de8-a268-63ffd460e7eb"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Starting training...\n",
+            "Epochs: 100 | Device: cuda\n",
+            "------------------------------------------------------------\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n",
+            "Epoch 1 Training:   0%|          | 0/14 [00:00<?, ?it/s]\u001b[A/usr/local/lib/python3.12/dist-packages/torch/utils/data/dataloader.py:432: UserWarning: This DataLoader will create 10 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
+            "  self.check_worker_number_rationality()\n",
+            "\n",
+            "Epoch 1 Training:   7%|▋         | 1/14 [00:47<10:11, 47.01s/it]\u001b[A\n",
+            "Epoch 1 Training:  14%|█▍        | 2/14 [00:49<04:06, 20.53s/it]\u001b[A\n",
+            "Epoch 1 Training:  21%|██▏       | 3/14 [00:51<02:12, 12.07s/it]\u001b[A\n",
+            "Epoch 1 Training:  29%|██▊       | 4/14 [00:53<01:21,  8.11s/it]\u001b[A\n",
+            "Epoch 1 Training:  36%|███▌      | 5/14 [00:55<00:53,  5.92s/it]\u001b[A\n",
+            "Epoch 1 Training:  43%|████▎     | 6/14 [00:57<00:36,  4.59s/it]\u001b[A\n",
+            "Epoch 1 Training:  50%|█████     | 7/14 [00:59<00:26,  3.76s/it]\u001b[A\n",
+            "Epoch 1 Training:  57%|█████▋    | 8/14 [01:01<00:19,  3.21s/it]\u001b[A\n",
+            "Epoch 1 Training:  64%|██████▍   | 9/14 [01:03<00:14,  2.85s/it]\u001b[A\n",
+            "Epoch 1 Training:  71%|███████▏  | 10/14 [01:05<00:10,  2.60s/it]\u001b[A\n",
+            "Epoch 1 Training:  79%|███████▊  | 11/14 [01:16<00:15,  5.22s/it]\u001b[A\n",
+            "Epoch 1 Training:  86%|████████▌ | 12/14 [01:18<00:08,  4.26s/it]\u001b[A\n",
+            "Epoch 1 Training:  93%|█████████▎| 13/14 [01:20<00:03,  3.61s/it]\u001b[A\n",
+            "Epoch 1 Training: 100%|██████████| 14/14 [01:22<00:00,  5.87s/it]\n",
+            "Epoch 1 Validation: 100%|██████████| 4/4 [00:38<00:00,  9.62s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 1.8422 | Train Acc: 19.77% || Val Loss: 1.8379 | Val Acc: 21.32%\n",
+            "------------------------------------------------------------\n",
+            "Best model saved (Acc: 21.32%)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 2 Training: 100%|██████████| 14/14 [00:59<00:00,  4.26s/it]\n",
+            "Epoch 2 Validation: 100%|██████████| 4/4 [00:13<00:00,  3.27s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 1.7477 | Train Acc: 26.21% || Val Loss: 1.6967 | Val Acc: 30.39%\n",
+            "------------------------------------------------------------\n",
+            "Best model saved (Acc: 30.39%)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 3 Training: 100%|██████████| 14/14 [01:03<00:00,  4.52s/it]\n",
+            "Epoch 3 Validation: 100%|██████████| 4/4 [00:13<00:00,  3.32s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 1.6163 | Train Acc: 39.26% || Val Loss: 1.5199 | Val Acc: 46.94%\n",
+            "------------------------------------------------------------\n",
+            "Best model saved (Acc: 46.94%)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 4 Training: 100%|██████████| 14/14 [01:07<00:00,  4.80s/it]\n",
+            "Epoch 4 Validation: 100%|██████████| 4/4 [00:12<00:00,  3.24s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 1.4117 | Train Acc: 52.99% || Val Loss: 1.2870 | Val Acc: 58.28%\n",
+            "------------------------------------------------------------\n",
+            "Best model saved (Acc: 58.28%)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 5 Training: 100%|██████████| 14/14 [01:01<00:00,  4.40s/it]\n",
+            "Epoch 5 Validation: 100%|██████████| 4/4 [00:13<00:00,  3.29s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 1.1867 | Train Acc: 61.88% || Val Loss: 1.0664 | Val Acc: 64.17%\n",
+            "------------------------------------------------------------\n",
+            "Best model saved (Acc: 64.17%)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 6 Training: 100%|██████████| 14/14 [01:00<00:00,  4.33s/it]\n",
+            "Epoch 6 Validation: 100%|██████████| 4/4 [00:11<00:00,  2.79s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 1.0244 | Train Acc: 68.72% || Val Loss: 0.9735 | Val Acc: 68.48%\n",
+            "------------------------------------------------------------\n",
+            "Best model saved (Acc: 68.48%)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 7 Training: 100%|██████████| 14/14 [01:00<00:00,  4.29s/it]\n",
+            "Epoch 7 Validation: 100%|██████████| 4/4 [00:10<00:00,  2.62s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.9391 | Train Acc: 72.14% || Val Loss: 0.9293 | Val Acc: 72.79%\n",
+            "------------------------------------------------------------\n",
+            "Best model saved (Acc: 72.79%)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 8 Training: 100%|██████████| 14/14 [00:59<00:00,  4.22s/it]\n",
+            "Epoch 8 Validation: 100%|██████████| 4/4 [00:12<00:00,  3.21s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.8887 | Train Acc: 75.56% || Val Loss: 0.9040 | Val Acc: 70.52%\n",
+            "------------------------------------------------------------\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 9 Training: 100%|██████████| 14/14 [00:59<00:00,  4.28s/it]\n",
+            "Epoch 9 Validation: 100%|██████████| 4/4 [00:10<00:00,  2.64s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.8280 | Train Acc: 80.85% || Val Loss: 0.8784 | Val Acc: 74.38%\n",
+            "------------------------------------------------------------\n",
+            "Best model saved (Acc: 74.38%)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 10 Training: 100%|██████████| 14/14 [01:02<00:00,  4.43s/it]\n",
+            "Epoch 10 Validation: 100%|██████████| 4/4 [00:11<00:00,  2.96s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.7887 | Train Acc: 83.70% || Val Loss: 0.8526 | Val Acc: 77.55%\n",
+            "------------------------------------------------------------\n",
+            "Best model saved (Acc: 77.55%)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 11 Training: 100%|██████████| 14/14 [01:07<00:00,  4.80s/it]\n",
+            "Epoch 11 Validation: 100%|██████████| 4/4 [00:10<00:00,  2.74s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.7416 | Train Acc: 86.21% || Val Loss: 0.8535 | Val Acc: 78.68%\n",
+            "------------------------------------------------------------\n",
+            "Best model saved (Acc: 78.68%)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 12 Training: 100%|██████████| 14/14 [01:03<00:00,  4.56s/it]\n",
+            "Epoch 12 Validation: 100%|██████████| 4/4 [00:11<00:00,  2.89s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.7133 | Train Acc: 88.15% || Val Loss: 0.8349 | Val Acc: 77.55%\n",
+            "------------------------------------------------------------\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 13 Training: 100%|██████████| 14/14 [01:05<00:00,  4.71s/it]\n",
+            "Epoch 13 Validation: 100%|██████████| 4/4 [00:11<00:00,  2.80s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.6730 | Train Acc: 90.43% || Val Loss: 0.8370 | Val Acc: 76.87%\n",
+            "------------------------------------------------------------\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 14 Training: 100%|██████████| 14/14 [01:04<00:00,  4.60s/it]\n",
+            "Epoch 14 Validation: 100%|██████████| 4/4 [00:11<00:00,  2.94s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.6451 | Train Acc: 91.85% || Val Loss: 0.8299 | Val Acc: 78.91%\n",
+            "------------------------------------------------------------\n",
+            "Best model saved (Acc: 78.91%)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 15 Training: 100%|██████████| 14/14 [01:06<00:00,  4.77s/it]\n",
+            "Epoch 15 Validation: 100%|██████████| 4/4 [00:11<00:00,  2.81s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.6082 | Train Acc: 94.47% || Val Loss: 0.8110 | Val Acc: 80.73%\n",
+            "------------------------------------------------------------\n",
+            "Best model saved (Acc: 80.73%)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 16 Training: 100%|██████████| 14/14 [01:05<00:00,  4.65s/it]\n",
+            "Epoch 16 Validation: 100%|██████████| 4/4 [00:12<00:00,  3.06s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.5923 | Train Acc: 95.04% || Val Loss: 0.8182 | Val Acc: 78.46%\n",
+            "------------------------------------------------------------\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 17 Training: 100%|██████████| 14/14 [01:06<00:00,  4.73s/it]\n",
+            "Epoch 17 Validation: 100%|██████████| 4/4 [00:13<00:00,  3.35s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.5732 | Train Acc: 96.01% || Val Loss: 0.8069 | Val Acc: 80.50%\n",
+            "------------------------------------------------------------\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 18 Training: 100%|██████████| 14/14 [01:06<00:00,  4.78s/it]\n",
+            "Epoch 18 Validation: 100%|██████████| 4/4 [00:13<00:00,  3.30s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.5516 | Train Acc: 96.70% || Val Loss: 0.8286 | Val Acc: 79.37%\n",
+            "------------------------------------------------------------\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 19 Training: 100%|██████████| 14/14 [01:06<00:00,  4.77s/it]\n",
+            "Epoch 19 Validation: 100%|██████████| 4/4 [00:12<00:00,  3.07s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.5483 | Train Acc: 96.75% || Val Loss: 0.8233 | Val Acc: 79.82%\n",
+            "------------------------------------------------------------\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 20 Training: 100%|██████████| 14/14 [01:06<00:00,  4.78s/it]\n",
+            "Epoch 20 Validation: 100%|██████████| 4/4 [00:11<00:00,  2.90s/it]\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.5301 | Train Acc: 97.55% || Val Loss: 0.8255 | Val Acc: 79.14%\n",
+            "------------------------------------------------------------\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Epoch 21 Training: 100%|██████████| 14/14 [01:06<00:00,  4.78s/it]\n",
+            "Epoch 21 Validation: 100%|██████████| 4/4 [00:11<00:00,  2.82s/it]"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Results Train Loss: 0.5188 | Train Acc: 98.63% || Val Loss: 0.8077 | Val Acc: 80.73%\n",
+            "------------------------------------------------------------\n",
+            "Early stopping at epoch 21\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "train_losses, train_accuracy, eval_losses, eval_accuracies, all_preds, all_labels = train_model(model=model,\n",
+        "                                           epochs=100,\n",
+        "                                           train_loader=train_loader,\n",
+        "                                           eval_loader=eval_loader,\n",
+        "                                           optimizer=optimizer,\n",
+        "                                           criterion=criterion,\n",
+        "                                           patience=6,\n",
+        "                                           device=device,\n",
+        "                                           checkpoint_model_name='best_deit_model')\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "LeV5HMFVL1l7"
+      },
+      "source": [
+        "# Plotting the loss and accuracy"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 527
+        },
+        "id": "OnW-WhGLYNrO",
+        "outputId": "215510f2-396e-4ca7-a4e0-eadac257d023"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x500 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "def plot_training_curves(train_losses, eval_losses, train_acc, eval_acc):\n",
+        "    epochs = range(1, len(train_losses) + 1)\n",
+        "\n",
+        "    plt.figure(figsize=(12,5))\n",
+        "\n",
+        "    # Loss\n",
+        "    plt.subplot(1,2,1)\n",
+        "    plt.plot(epochs, train_losses, label=\"Train Loss\")\n",
+        "    plt.plot(epochs, eval_losses, label=\"Val Loss\")\n",
+        "    plt.xlabel(\"Epochs\")\n",
+        "    plt.ylabel(\"Loss\")\n",
+        "    plt.title(\"Loss Curve\")\n",
+        "    plt.legend()\n",
+        "\n",
+        "    # Accuracy\n",
+        "    plt.subplot(1,2,2)\n",
+        "    plt.plot(epochs, train_acc, label=\"Train Acc\")\n",
+        "    plt.plot(epochs, eval_acc, label=\"Val Acc\")\n",
+        "    plt.xlabel(\"Epochs\")\n",
+        "    plt.ylabel(\"Accuracy (%)\")\n",
+        "    plt.title(\"Accuracy Curve\")\n",
+        "    plt.legend()\n",
+        "\n",
+        "    plt.tight_layout()\n",
+        "    plt.show()\n",
+        "\n",
+        "plot_training_curves(\n",
+        "    train_losses,\n",
+        "    eval_losses,\n",
+        "    train_accuracy,\n",
+        "    eval_accuracies\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "VB-5eo-HL1l7"
+      },
+      "source": [
+        "# Plotting Confusion Matrix"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 556
+        },
+        "id": "CM3KXCXkZ3cp",
+        "outputId": "8dea8a09-82ee-4e00-9d6f-f908ad9d2a7f"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 600x500 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "def plot_confusion_matrix_normalized(all_labels, all_preds):\n",
+        "  class_names = train_dataset.dataset.classes\n",
+        "  cm = confusion_matrix(all_labels, all_preds)\n",
+        "  plt.figure(figsize=(6, 5))\n",
+        "  sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\", xticklabels=class_names, yticklabels=class_names)\n",
+        "  plt.xlabel(\"Predicted\")\n",
+        "  plt.ylabel(\"True\")\n",
+        "  plt.title(\"Confusion Matrix\")\n",
+        "  plt.show()\n",
+        "\n",
+        "plot_confusion_matrix_normalized(all_labels, all_preds)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "VW37TJjbL1l7"
+      },
+      "source": [
+        "# Classification Report"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "jxK54MRRZ3ZS",
+        "outputId": "e5904cb9-4301-40ea-81b3-b5feb8fc1c06"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "  F_Breakage       0.85      0.86      0.86        95\n",
+            "   F_Crushed       0.79      0.76      0.78        75\n",
+            "    F_Normal       0.90      0.92      0.91       100\n",
+            "  R_Breakage       0.83      0.54      0.65        54\n",
+            "   R_Crushed       0.62      0.74      0.67        57\n",
+            "    R_Normal       0.79      0.90      0.84        60\n",
+            "\n",
+            "    accuracy                           0.81       441\n",
+            "   macro avg       0.80      0.79      0.79       441\n",
+            "weighted avg       0.81      0.81      0.80       441\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "def print_classification_report(all_labels, all_preds, class_names=None):\n",
+        "    class_names = train_dataset.dataset.classes\n",
+        "    report = classification_report(\n",
+        "        all_labels,\n",
+        "        all_preds,\n",
+        "        target_names=class_names\n",
+        "    )\n",
+        "    print(report)\n",
+        "print_classification_report(all_labels, all_preds)"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "f0dc4a5c485f4cf0b72d7fcb49b4ec67": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_3a9a8cb6dc444a5a9263b984ca57b70f",
+              "IPY_MODEL_84034deb5cdf4409bf4a14eda1afa57c",
+              "IPY_MODEL_fd79865e6bc9421eb3a4a403f861934c"
+            ],
+            "layout": "IPY_MODEL_604ad83134c846c199f0c33da48ae210"
+          }
+        },
+        "3a9a8cb6dc444a5a9263b984ca57b70f": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a906705398e6470ba667bb33e4d29e48",
+            "placeholder": "​",
+            "style": "IPY_MODEL_1036cd0b2ce945e69f7934d96dcbd5ca",
+            "value": "preprocessor_config.json: 100%"
+          }
+        },
+        "84034deb5cdf4409bf4a14eda1afa57c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_f43d2371b08748f6962da8df53abc21a",
+            "max": 287,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_2d349b7e5d7b495cbf8c73a20d441741",
+            "value": 287
+          }
+        },
+        "fd79865e6bc9421eb3a4a403f861934c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_77d4bc5c954f447683df61dfb887cd9d",
+            "placeholder": "​",
+            "style": "IPY_MODEL_e4a615aa66f14b4ca6519e8d001e9037",
+            "value": " 287/287 [00:00&lt;00:00, 25.1kB/s]"
+          }
+        },
+        "604ad83134c846c199f0c33da48ae210": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "a906705398e6470ba667bb33e4d29e48": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "1036cd0b2ce945e69f7934d96dcbd5ca": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "f43d2371b08748f6962da8df53abc21a": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2d349b7e5d7b495cbf8c73a20d441741": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "77d4bc5c954f447683df61dfb887cd9d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e4a615aa66f14b4ca6519e8d001e9037": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "322d7fe22bfa4a1795b80452960be1b2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_c4671aa066354cdfad280d0477f4a643",
+              "IPY_MODEL_8e9eb33374994be0814d5e0e77ee9b58",
+              "IPY_MODEL_3e42099002474d21bcfa3bb2d550b333"
+            ],
+            "layout": "IPY_MODEL_6a671a36dbb04271937a1daced027151"
+          }
+        },
+        "c4671aa066354cdfad280d0477f4a643": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_0637094274e047ddbe9adf5001806849",
+            "placeholder": "​",
+            "style": "IPY_MODEL_0dc5a5a67c1d4076bb28fffb2e88537e",
+            "value": "config.json: "
+          }
+        },
+        "8e9eb33374994be0814d5e0e77ee9b58": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_2a1212a3a69e4f479ca0674196f6b7f6",
+            "max": 1,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_9b0b1db948bf47718d0f1ec61a49ce05",
+            "value": 1
+          }
+        },
+        "3e42099002474d21bcfa3bb2d550b333": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_b5cefbe2f07b4a09afd3d79cc1da8bf0",
+            "placeholder": "​",
+            "style": "IPY_MODEL_6e05d3819a294c92ada4063ed3bf7db8",
+            "value": " 69.6k/? [00:00&lt;00:00, 5.06MB/s]"
+          }
+        },
+        "6a671a36dbb04271937a1daced027151": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0637094274e047ddbe9adf5001806849": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0dc5a5a67c1d4076bb28fffb2e88537e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "2a1212a3a69e4f479ca0674196f6b7f6": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": "20px"
+          }
+        },
+        "9b0b1db948bf47718d0f1ec61a49ce05": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "b5cefbe2f07b4a09afd3d79cc1da8bf0": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "6e05d3819a294c92ada4063ed3bf7db8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "bb84d9c025784a45becc9ad1d3760e4a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_df339ccf071b4db896da7f603785cad7",
+              "IPY_MODEL_b54c91db8ccb4a9a9ddd714416cafcbb",
+              "IPY_MODEL_5461c90c719b4c0a915dc4090263bc16"
+            ],
+            "layout": "IPY_MODEL_69b6b828c3bf42d38adbd4406c75b611"
+          }
+        },
+        "df339ccf071b4db896da7f603785cad7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_fb0da298e88d4c029d06707bcd1e671b",
+            "placeholder": "​",
+            "style": "IPY_MODEL_ae3948b5c36b48fdb4fe94701831d389",
+            "value": "pytorch_model.bin: 100%"
+          }
+        },
+        "b54c91db8ccb4a9a9ddd714416cafcbb": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_a00c2fa89f334ea69827c79ece145656",
+            "max": 349435207,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_79b4aa0d6edf47699496f6b71419a2f9",
+            "value": 349435207
+          }
+        },
+        "5461c90c719b4c0a915dc4090263bc16": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_6847cdb46df54256bf152f60874e12e9",
+            "placeholder": "​",
+            "style": "IPY_MODEL_5c765c6081b646569436c190eb79caef",
+            "value": " 349M/349M [00:02&lt;00:00, 245MB/s]"
+          }
+        },
+        "69b6b828c3bf42d38adbd4406c75b611": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "fb0da298e88d4c029d06707bcd1e671b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ae3948b5c36b48fdb4fe94701831d389": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "a00c2fa89f334ea69827c79ece145656": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "79b4aa0d6edf47699496f6b71419a2f9": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "6847cdb46df54256bf152f60874e12e9": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "5c765c6081b646569436c190eb79caef": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "01a0abd752874a23b21320faa4a50e96": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_7e69b37f77d345cfbf12302005e5f6e6",
+              "IPY_MODEL_bfe3dc2f082a4dbbac5a4d243fdff552",
+              "IPY_MODEL_6b6c5d47cdd64246aa9be34eb69ffa1b"
+            ],
+            "layout": "IPY_MODEL_920788c705e5469693ea54e59113f625"
+          }
+        },
+        "7e69b37f77d345cfbf12302005e5f6e6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_516c1a4e741d48ada3b5399bda974b0a",
+            "placeholder": "​",
+            "style": "IPY_MODEL_74187d6e7d1a45db9f121f03f66277fe",
+            "value": "Loading weights: 100%"
+          }
+        },
+        "bfe3dc2f082a4dbbac5a4d243fdff552": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_1cce8fdebf5d485784461724c1163f4d",
+            "max": 199,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_6af1d54b7d7f47efb8c27aaeb1442d5d",
+            "value": 199
+          }
+        },
+        "6b6c5d47cdd64246aa9be34eb69ffa1b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_7adbaa39073e431bb5df2cb86c506af2",
+            "placeholder": "​",
+            "style": "IPY_MODEL_0fdb36db08814140b3215b3c297fcacc",
+            "value": " 199/199 [00:00&lt;00:00, 577.78it/s, Materializing param=deit.layernorm.weight]"
+          }
+        },
+        "920788c705e5469693ea54e59113f625": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "516c1a4e741d48ada3b5399bda974b0a": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "74187d6e7d1a45db9f121f03f66277fe": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "1cce8fdebf5d485784461724c1163f4d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "6af1d54b7d7f47efb8c27aaeb1442d5d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "7adbaa39073e431bb5df2cb86c506af2": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0fdb36db08814140b3215b3c297fcacc": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "b4ecc700eb0e44db9669727abff367af": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_93835ed86f46430296d5b78b333239cc",
+              "IPY_MODEL_d4b2deb439e84bf6add182f21cdfcfe8",
+              "IPY_MODEL_9c6f9f41b0444b05aec374461ea90ddd"
+            ],
+            "layout": "IPY_MODEL_359481807e0d424bbd19e09e8439655e"
+          }
+        },
+        "93835ed86f46430296d5b78b333239cc": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_956b6d845d77404daa9fd78d7e45eeba",
+            "placeholder": "​",
+            "style": "IPY_MODEL_f7ad414d35b145aa88642ea0be2703c2",
+            "value": "model.safetensors: 100%"
+          }
+        },
+        "d4b2deb439e84bf6add182f21cdfcfe8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_f1406296340b4afe96b975b721ba6019",
+            "max": 349376512,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_e45729f0fe5a4e568f1b7936ec9aff0e",
+            "value": 349376512
+          }
+        },
+        "9c6f9f41b0444b05aec374461ea90ddd": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_3f254bbf769345e6b66ff2e5be48347d",
+            "placeholder": "​",
+            "style": "IPY_MODEL_39d2c485a42146c6ab639010c3ce15a8",
+            "value": " 349M/349M [00:03&lt;00:00, 230MB/s]"
+          }
+        },
+        "359481807e0d424bbd19e09e8439655e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "956b6d845d77404daa9fd78d7e45eeba": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f7ad414d35b145aa88642ea0be2703c2": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "f1406296340b4afe96b975b721ba6019": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e45729f0fe5a4e568f1b7936ec9aff0e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "3f254bbf769345e6b66ff2e5be48347d": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "39d2c485a42146c6ab639010c3ce15a8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        }
+      }
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file