Car Racing/notebooks/basic_CNN_augmented_edges_thresholded.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import os\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import datasets, transforms\n",
    "from torch.utils.data import DataLoader\n",
    "from sklearn.metrics import classification_report\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu\n"
     ]
    }
   ],
   "source": [
    "# Imposta il device\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ApplyThreshold:\n",
    "    def __init__(self, threshold=0.5):\n",
    "        self.threshold = threshold\n",
    "\n",
    "    def __call__(self, tensor):\n",
    "        # Applica la thresholding: valori >= threshold diventano 1, altri diventano 0\n",
    "        return (tensor >= self.threshold).float()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from PIL import Image\n",
    "\n",
    "# Carica l'immagine\n",
    "img = Image.open(\"./test_edges/0/0000.png\").convert(\"L\")  # Converte in scala di grigi\n",
    "\n",
    "# Converti l'immagine in tensore\n",
    "transform_to_tensor = transforms.ToTensor()\n",
    "img = transform_to_tensor(img)\n",
    "\n",
    "# Applica la threshold\n",
    "img = (img >= 0.1).float()\n",
    "\n",
    "# Rimuovi il canale in eccesso per plt.imshow\n",
    "plt.imshow(img.squeeze(), cmap=\"gray\")\n",
    "plt.title(\"Immagine Sogliata\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision.datasets import ImageFolder\n",
    "from torch.utils.data import DataLoader, random_split\n",
    "\n",
    "# Percorso del dataset (immagini preprocessate con data augmentation)\n",
    "dataset_dir = \"./train_balanced_augmented_edges\"\n",
    "\n",
    "# Trasformazioni: Normalizzazione e Preprocessing finale\n",
    "transform = transforms.Compose([\n",
    "    #transforms.Resize((96, 96)),  # Assicura dimensioni coerenti\n",
    "    transforms.Grayscale(),\n",
    "    transforms.ToTensor(),  # Conversione a tensore\n",
    "    ApplyThreshold(threshold=0.1),\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numero di immagini nel train set: 2952\n",
      "Numero di immagini nel test set: 738\n",
      "Classi disponibili: ['0', '1', '2', '3', '4']\n"
     ]
    }
   ],
   "source": [
    "# Creazione del Dataset\n",
    "dataset = ImageFolder(root=dataset_dir, transform=transform)\n",
    "\n",
    "# Suddivisione Train/Test\n",
    "train_size = int(0.8 * len(dataset))\n",
    "test_size = len(dataset) - train_size\n",
    "train_dataset, test_dataset = random_split(dataset, [train_size, test_size])\n",
    "\n",
    "# DataLoaders\n",
    "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=False)\n",
    "test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)\n",
    "\n",
    "# Controllo rapido\n",
    "print(f\"Numero di immagini nel train set: {len(train_dataset)}\")\n",
    "print(f\"Numero di immagini nel test set: {len(test_dataset)}\")\n",
    "print(f\"Classi disponibili: {dataset.classes}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleCNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(SimpleCNN, self).__init__()\n",
    "\n",
    "        # Convolutional Section\n",
    "        self.network = nn.Sequential(\n",
    "            \n",
    "            nn.Conv2d(1, 16, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(16),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(2,2), \n",
    "\n",
    "            nn.Conv2d(16, 24, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(24),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(2, 2),   \n",
    "        )\n",
    "\n",
    "        # Fully Connected Section\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(24 * 24 * 24, 512),  # Fully connected\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.5),\n",
    "            nn.Linear(512, 256),  # Fully connected\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.5),\n",
    "            nn.Linear(256, 128),  # Fully connected\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.5),\n",
    "            nn.Linear(128, 5) # 5 classi di output\n",
    "            \n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.network(x)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "\n",
    "model = SimpleCNN().to(device)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Funzione di loss con pesi bilanciati\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
    "#optimizer = torch.optim.RMSprop(model.parameters(), lr=0.001)\n",
    "#scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.5) \n",
    "\n",
    "# Loop di training\n",
    "def train(model, loader, criterion, optimizer):\n",
    "    model.train()\n",
    "    running_loss = 0\n",
    "    correct = 0\n",
    "    for inputs, labels in loader:\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        #scheduler.step()\n",
    "\n",
    "        running_loss += loss.item()\n",
    "        _, preds = outputs.max(1)\n",
    "        correct += (preds == labels).sum().item()\n",
    "    \n",
    "    accuracy = 100 * correct / len(loader.dataset)\n",
    "    return running_loss / len(loader), accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(model, loader):\n",
    "    model.eval()\n",
    "    y_true = []\n",
    "    y_pred = []\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for inputs, labels in loader:\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "            outputs = model(inputs)\n",
    "            _, preds = outputs.max(1)\n",
    "            y_true.extend(labels.cpu().numpy())\n",
    "            y_pred.extend(preds.cpu().numpy())\n",
    "    \n",
    "    return y_true, y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/6: Loss: 1.7109, Accuracy: 20.97%\n",
      "Epoch 2/6: Loss: 1.6111, Accuracy: 21.44%\n",
      "Epoch 3/6: Loss: 1.5839, Accuracy: 25.20%\n",
      "Epoch 4/6: Loss: 1.5357, Accuracy: 30.72%\n",
      "Epoch 5/6: Loss: 1.5203, Accuracy: 29.44%\n",
      "Epoch 6/6: Loss: 1.4958, Accuracy: 30.79%\n"
     ]
    }
   ],
   "source": [
    "num_epochs = 6\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    train_loss, train_acc = train(model, train_loader, criterion, optimizer)\n",
    "    print(f\"Epoch {epoch+1}/{num_epochs}: Loss: {train_loss:.4f}, Accuracy: {train_acc:.2f}%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGbCAYAAAAr/4yjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAADq9JREFUeJzt3V9olfUfwPHPKlvWNkxLaxgONdRUlFAhDadEgigIpdZN/6AoEirKGQShdeGFoRWGkSJ0URJZEIRUFNaFGc2IUsOsZhelUZSoSamhz+8i+vzc/DM3N8+z7fW6ajvPjs85K999v59znlNVFEURABARF1X6BAAoD1EAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJFGgx2poaIh777230qcBvYooUDotLS3x4IMPxvDhw+Oyyy6Lurq6mDZtWrz44ovx999/V/r0Om3v3r2xcOHCGDBgQNTV1cW8efNiz549lT4taOWSSp8AnGzTpk2xYMGCqK6ujrvvvjvGjRsXx44diy1btkRTU1N88803sXbt2kqfZocdPnw4Zs6cGQcPHoynnnoq+vXrF88//3w0NjbGV199FYMGDar0KUJEiAIl8uOPP8add94Zw4YNi82bN8e1116bty1atCh++OGH2LRpUwXPsPPWrFkT33//fTQ3N8fkyZMjImL27Nkxbty4WLlyZSxfvrzCZwj/sn1EaaxYsSIOHz4c69evbxWE/4wcOTIeffTRM/78/v37Y/HixTF+/PioqamJurq6mD17dnz99denHLt69eoYO3ZsXH755XHllVfGpEmTYsOGDXn7n3/+GY899lg0NDREdXV1DB48OG699db48ssv85i//vorvv322/j999/bfWxvvfVWTJ48OYMQETF69Oi45ZZb4s0332z35+FCEQVK4913343hw4fH1KlTO/Xze/bsiXfeeSfmzp0bq1atiqamptixY0c0NjbGvn378rh169bFI488EjfccEO88MIL8cwzz8TEiRPj888/z2MeeuihePnll+P222+PNWvWxOLFi6N///6xa9euPKa5uTnGjBkTL7300lnP68SJE7F9+/aYNGnSKbdNmTIlWlpa4s8//+zUY4auZvuIUjh06FDs3bs35s2b1+n7GD9+fHz33Xdx0UX//3+du+66K0aPHh3r16+Pp59+OiL+nVuMHTs2Nm7ceMb72rRpUzzwwAOxcuXK/N6SJUs6dV779++Po0ePnnb189/39u3bF6NGjerU/UNXEgVK4dChQxERUVtb2+n7qK6uzn8+fvx4HDhwIGpqamLUqFGttn0GDBgQP//8c2zbtq3Vds7JBgwYEJ9//nns27cv6uvrT3vMjBkz4lw+o+q/V0ydfH7/ueyyy1odA5Vm+4hSqKuri4g4r22UEydOxPPPPx/XX399VFdXx1VXXRVXX311bN++PQ4ePJjHPfnkk1FTUxNTpkyJ66+/PhYtWhSffvppq/tasWJF7Ny5M6677rqYMmVKLFu2rNMvH+3fv39ERBw9evSU244cOdLqGKg0UaAU6urqor6+Pnbu3Nnp+1i+fHk8/vjjMX369Hjttdfigw8+iA8//DDGjh0bJ06cyOPGjBkTu3fvjjfeeCNuvvnmePvtt+Pmm2+OpUuX5jELFy6MPXv2xOrVq6O+vj6ee+65GDt2bLz33nsdPq+BAwdGdXV1/PLLL6fc9t/3zrQagQutymc0UxYPPvhgrF27NrZu3Ro33XRTu8c3NDTEjBkz4tVXX42IiIkTJ8bAgQNj8+bNrY4bOnRojBw5Mj755JPT3s+xY8fitttui/fffz8OHz6cWzon++233+LGG2+MhoaG2LJlS4cf2+TJk6Oqqiqam5tbfX/WrFnR0tISLS0tHb5P6A5WCpTGkiVL4oorroj7778/fv3111Nub2lpiRdffPGMP3/xxRefsse/cePG2Lt3b6vv/fHHH62+vvTSS+OGG26Ioijin3/+iePHj7faboqIGDx4cNTX17faAurIS1Lnz58f27Ztiy+++CK/t3v37ti8eXMsWLCg3Z+HC8WgmdIYMWJEbNiwIe64444YM2ZMq3c0b926NTZu3HjWax3NnTs3nn322bjvvvti6tSpsWPHjnj99ddj+PDhrY6bNWtWXHPNNTFt2rQYMmRI7Nq1K1566aWYM2dO1NbWxoEDB2Lo0KExf/78mDBhQtTU1MRHH30U27Zta/VqpObm5pg5c2YsXbo0li1bdtbH9vDDD8e6detizpw5sXjx4ujXr1+sWrUqhgwZEk888cT5PG3QtQoome+++6544IEHioaGhuLSSy8tamtri2nTphWrV68ujhw5kscNGzasuOeee/LrI0eOFE888URx7bXXFv379y+mTZtWfPbZZ0VjY2PR2NiYx73yyivF9OnTi0GDBhXV1dXFiBEjiqampuLgwYNFURTF0aNHi6ampmLChAlFbW1tccUVVxQTJkwo1qxZ0+o8P/744yIiiqVLl57T4/rpp5+K+fPnF3V1dUVNTU0xd+7c4vvvv+/08wTdwUwBgGSmAEASBQCSKACQRAGAJAoAJFEAIJ3zm9eqqqq68zzoxTryqmf/nv3Lc0Z3OJd/r6wUAEiiAEASBQCSC+IBnKfzuVpQ2WZCVgoAJFEAIIkCAMlMAej1yvwJAW3PrdIzBisFAJIoAJBEAYBkpgCUQpn3/dvTkTlA2R+nlQIASRQASLaPgHNW9q2PM6n0yzx7EisFAJIoAJBEAYBkpgB9XFnmBPb9y8FKAYAkCgAkUQAgmSlAH9OVMwRzgN7HSgGAJAoAJFEAIJkpAK2YE/RtVgoAJFEAIIkCAEkUAEiiAEASBQCSKACQvE8B4AJq+z6Qtteiavv1hX7fiJUCAEkUAEiiAEAyU6A0n9ELVJ6VAgBJFABIto96CFs8wIVgpQBAEgUAkigAkMwUulBP3ffv7rfR99Tnpa86+fflozn7HisFAJIoAJBEAYBkptBGWfe/7e3SVdq7dDN9m5UCAEkUAEiiAEDq8zOFrtxPte8P9HRWCgAkUQAgiQIAqc/PFNpjTgD0JVYKACRRACCJAgBJFABIogBAEgUAkigAkEQBgCQKACRRACC5zAVAibW9vH93X3rHSgGAJAoAJFEAIJkpAFRQ2xlBV35EcGdYKQCQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJNc+gj7ubNfeudDX8qfyrBQASKIAQBIFAJIoAJBEAYAkCgCkPv+S1PY+Cs9L8oC+xEoBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBAEgUAUp//PAWAMunIZ7x0x+e7WCkAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgOQyF0ArJ1864WyXWGh7LL2DlQIASRQASKIAQDJTAKigtnOaSrNSACCJAgBJFABIZgod1N0fhQeUT5n2/bv77x0rBQCSKACQRAGAZKbQRtv9ujLtJQJn1lP/Wy3bbNJKAYAkCgAkUQAgmSkAF4x9//KzUgAgiQIASRQASGYKQKeVaUbQl/b9u5OVAgBJFABIogBAMlMAzqirrwVm37/8rBQASKIAQLJ9BJwz2z+9n5UCAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEBy7SM6rEwfwQh0LSsFAJIoAJBEAYBkptBL9ZR9f9fnh3KxUgAgiQIASRQASGYK7Wi7533yXn3bffuO7o/3lH3/9rT3uHvL44S+wEoBgCQKACRRACCZKXShMu+dl/X9AOc7lwG6lpUCAEkUAEi2jyrIVglQNlYKACRRACCJAgDJTKGDzAG6lucTysVKAYAkCgAkUQAgiQIASRQASKIAQBIFAJL3KUAP470ddCcrBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQDSJZU+AQD+ryiKiv75VgoAJFEAIIkCAMlMAaCDKr3v352sFABIogBAEgUAkpkC0Cv11H3/qqqqTv9s28fc9r7O5TmxUgAgiQIAyfYRvVZ3bx+czzKfnru9E1He331XnJeVAgBJFABIogBAMlMAuk0l5wZl3fcvOysFAJIoAJBEAYBkpgBUhD3/crJSACCJAgBJFABIogBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkFw6my5XyY9gBM6PlQIASRQASKIAQDJT6KPs+wOnY6UAQBIFAJIoAJDMFEqqJ+/5V1VVtfr6Qj6WSv1ZbR8z9FRWCgAkUQAgiQIAyUzhAirTnMAeOHA6VgoAJFEAIIkCAMlMoRudzwzBnn/nnPy8dfcMx++I3shKAYAkCgAkUQAgmSlUkD3p7tXV12Dy+6IvsFIAIIkCAEkUAEhmCvQZZgIX3tnmOm1nPH4/5WClAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSy1x0o/Yu3ext/kDZWCkAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgCQKAKSqou0FeM50oOvyAPRo5/LXvZUCAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiXdNUdtX379MmXxTjbbR29LwC6j5UCAEkUAEiiAEDq9EyhvUuwnu32c7xa9zn/vJkDQNewUgAgiQIASRQASF32PoXudL4zCADOjZUCAEkUAEiiAEDqETOF9pw8c/CeBYDOs1IAIIkCAEkUAEjdNlM42+cpnM99ne7+zBEAuoaVAgBJFABIogBA6vRMoSP7+F2952+GANA9rBQASKIAQOoVl7k4m46+HPZCbk2dz0t1baEB3cFKAYAkCgAkUQAg9fqZQpn33st8bkDfZKUAQBIFAJIoAJBEAYAkCgAkUQAgiQIA6Zzfp3C+H6kJQPlZKQCQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQ/gdkvqP3w8FwzQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_transform = transforms.Compose([\n",
    "    #transforms.Resize((96, 96)),  # Assicura dimensioni coerenti\n",
    "    transforms.Grayscale(),\n",
    "    transforms.ToTensor(),  # Conversione a tensore\n",
    "    ApplyThreshold(threshold=0.1),\n",
    "])\n",
    "\n",
    "test_set = ImageFolder(root='./test_edges', transform=test_transform)\n",
    "\n",
    "# Carica il primo elemento dal dataset\n",
    "image_tensor, label = test_set[0]  # Prendi il primo elemento trasformato\n",
    "\n",
    "# Se l'immagine ha 1 canale (bianco e nero) usa cmap=\"gray\"\n",
    "# Se ha 3 canali (RGB), mantieni la rappresentazione RGB\n",
    "if image_tensor.shape[0] == 1:\n",
    "    # Semplice immagine in scala di grigi\n",
    "    plt.imshow(image_tensor.squeeze(), cmap=\"gray\")  # Rimuovi canale e usa cmap gray\n",
    "else:\n",
    "    # Immagine a 3 canali\n",
    "    plt.imshow(image_tensor.permute(1, 2, 0))  # Cambia la forma da (C, H, W) a (H, W, C)\n",
    "    \n",
    "plt.title(f\"Class: {label}\")\n",
    "plt.axis('off')  # Rimuovi gli assi\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.06      0.02      0.02       133\n",
      "           1       0.06      0.12      0.08       275\n",
      "           2       0.10      0.19      0.13       406\n",
      "           3       0.83      0.58      0.69      1896\n",
      "           4       0.00      0.00      0.00        39\n",
      "\n",
      "    accuracy                           0.44      2749\n",
      "   macro avg       0.21      0.18      0.19      2749\n",
      "weighted avg       0.60      0.44      0.50      2749\n",
      "\n"
     ]
    }
   ],
   "source": [
    "test_set_loader = DataLoader(test_set, batch_size=32, shuffle=False)\n",
    "\n",
    "y_true, y_pred = evaluate(model, test_set_loader)\n",
    "\n",
    "print(\"\\nClassification Report:\")\n",
    "print(classification_report(y_true, y_pred, target_names=train_dataset.dataset.classes))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save({\n",
    "    'model': model,\n",
    "    'model_state_dict': model.state_dict(),\n",
    "    'optimizer_state_dict': optimizer.state_dict(),\n",
    "}, 'model_58.pth')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".env",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}