{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CNN Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "from tqdm import tqdm  # Fortschrittsbalken\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_46830/3644220936.py:6: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  train_dataset = torch.load(data_path + '/train.pt')\n",
      "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_46830/3644220936.py:7: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  test_dataset = torch.load(data_path + '/test.pt')\n",
      "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_46830/3644220936.py:8: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
      "  val_dataset = torch.load(data_path + '/val.pt')\n"
     ]
    }
   ],
   "source": [
    "# Daten laden\n",
    "\n",
    "data_path = 'data/embedded_padded'\n",
    "BATCH_SIZE = 32\n",
    "\n",
    "train_dataset = torch.load(data_path + '/train.pt')\n",
    "test_dataset = torch.load(data_path + '/test.pt')\n",
    "val_dataset = torch.load(data_path + '/val.pt')\n",
    "\n",
    "# DataLoader vorbereiten\n",
    "def collate_fn(batch):\n",
    "    input_ids = torch.stack([item[\"input_ids\"] for item in batch])  \n",
    "    labels = torch.tensor([item[\"labels\"] for item in batch], dtype=torch.float32).unsqueeze(1)  \n",
    "    return input_ids, labels\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_fn)\n",
    "val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False, collate_fn=collate_fn)\n",
    "test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False, collate_fn=collate_fn)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/michellegoppinger/Documents/Dokumente – Laptop von Michelle/Uni/Master/ANLP/ANLP_WS24_CA2/HumorDataset.py:56: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/utils/tensor_new.cpp:281.)\n",
      "  item = {'input_ids': torch.tensor(self.data[idx], dtype=torch.float)}\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Labels extrahieren und in eine Liste konvertieren\n",
    "train_labels = [item[\"labels\"].item() for item in train_dataset]  \n",
    "\n",
    "# Verteilung der Labels visualisieren\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.histplot(train_labels, bins=20)\n",
    "plt.xlabel(\"Humor Scores\")\n",
    "plt.ylabel(\"Frequency\")\n",
    "plt.title(\"Verteilung der Trainingslabels\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WeightedMSELoss(nn.Module):\n",
    "    def __init__(self, weights):\n",
    "        super(WeightedMSELoss, self).__init__()\n",
    "        self.weights = weights\n",
    "\n",
    "    def forward(self, inputs, targets):\n",
    "        weights = self.weights[targets.long()]\n",
    "        loss = weights * (inputs - targets) ** 2\n",
    "        return loss.mean()\n",
    "\n",
    "# Gewichtung basierend auf Seltenheit der Zwischenwerte\n",
    "weights = torch.tensor([2.0 if 0.2 <= x <= 0.8 else 1.0 for x in range(2)], dtype=torch.float32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN_HumorRegressor(nn.Module):\n",
    "    def __init__(self, embed_dim, filter_sizes, num_filters, dropout=0.5):\n",
    "        super(CNN_HumorRegressor, self).__init__()\n",
    "\n",
    "        # Convolutional Layers mit verschiedenen Filtergrößen\n",
    "        self.convs = nn.ModuleList([\n",
    "            nn.Conv2d(in_channels=1, out_channels=num_filters, kernel_size=(fs, embed_dim)) \n",
    "            for fs in filter_sizes\n",
    "        ])\n",
    "\n",
    "        # Highway-Netzwerk für bessere Feature-Extraktion\n",
    "        self.highway = nn.Linear(len(filter_sizes) * num_filters, len(filter_sizes) * num_filters)\n",
    "\n",
    "        # Dropout zur Vermeidung von Overfitting\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "        # Fully Connected Layers\n",
    "        self.fc1 = nn.Linear(len(filter_sizes) * num_filters, 256)\n",
    "        self.fc2 = nn.Linear(256, 128)\n",
    "        self.fc3 = nn.Linear(128, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.unsqueeze(1)  # [Batch Size, 1, Seq Length, Embed Dim]\n",
    "\n",
    "        # Convolution + ReLU activation\n",
    "        conved = [F.relu(conv(x)).squeeze(3) for conv in self.convs]\n",
    "\n",
    "        # Max-Pooling über jede Feature-Map\n",
    "        pooled = [F.max_pool1d(c, c.size(2)).squeeze(2) for c in conved]\n",
    "\n",
    "        # Feature-Vektor kombinieren\n",
    "        cat = torch.cat(pooled, dim=1)\n",
    "\n",
    "        # Highway-Netzwerk\n",
    "        highway = F.relu(self.highway(cat))\n",
    "        highway = self.dropout(highway + cat)\n",
    "\n",
    "        # Fully Connected Layers\n",
    "        fc_out = F.relu(self.fc1(highway))\n",
    "        fc_out = F.relu(self.fc2(fc_out))\n",
    "        return torch.sigmoid(self.fc3(fc_out))  # Sigmoid für Wertebereich [0, 1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "EMBED_DIM = train_dataset[0][\"input_ids\"].shape[1]\n",
    "FILTER_SIZES = [2, 3, 4, 5]\n",
    "NUM_FILTERS = 300\n",
    "DROPOUT = 0.5\n",
    "LR = 0.001\n",
    "EPOCHS = 10\n",
    "\n",
    "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Modell initialisieren\n",
    "model = CNN_HumorRegressor(EMBED_DIM, FILTER_SIZES, NUM_FILTERS, DROPOUT).to(device)\n",
    "\n",
    "# Gewichtete Verlustfunktion und Optimierer\n",
    "criterion = WeightedMSELoss(weights.to(device))\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=LR)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, train_loader, val_loader, criterion, optimizer, epochs, device):\n",
    "    for epoch in range(epochs):\n",
    "        model.train()\n",
    "        total_loss = 0\n",
    "\n",
    "        # Fortschrittsbalken für das Training\n",
    "        with tqdm(train_loader, unit=\"batch\", desc=f\"Epoch {epoch+1}/{epochs}\") as tepoch:\n",
    "            for inputs, labels in tepoch:\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",
    "\n",
    "                total_loss += loss.item()\n",
    "                tepoch.set_postfix(loss=loss.item())\n",
    "\n",
    "        val_loss = evaluate(model, val_loader, criterion, device)\n",
    "        print(f\"Epoch {epoch+1}/{epochs} - Train Loss: {total_loss:.4f} - Val Loss: {val_loss:.4f}\")\n",
    "\n",
    "def evaluate(model, test_loader, criterion, device):\n",
    "    model.eval()\n",
    "    total_loss = 0\n",
    "    with tqdm(test_loader, unit=\"batch\", desc=\"Evaluating\") as tepoch:\n",
    "        with torch.no_grad():\n",
    "            for inputs, labels in tepoch:\n",
    "                inputs, labels = inputs.to(device), labels.to(device)\n",
    "                outputs = model(inputs)\n",
    "                loss = criterion(outputs, labels)\n",
    "                total_loss += loss.item()\n",
    "    return total_loss / len(test_loader)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1/10:   0%|          | 0/124 [00:00<?, ?batch/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1/10: 100%|██████████| 124/124 [00:41<00:00,  2.99batch/s, loss=0.249]\n",
      "Evaluating: 100%|██████████| 16/16 [00:02<00:00,  7.09batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10 - Train Loss: 30.5479 - Val Loss: 0.2415\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2/10: 100%|██████████| 124/124 [00:40<00:00,  3.08batch/s, loss=0.297]\n",
      "Evaluating: 100%|██████████| 16/16 [00:02<00:00,  7.36batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/10 - Train Loss: 27.5358 - Val Loss: 0.2162\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3/10: 100%|██████████| 124/124 [00:40<00:00,  3.03batch/s, loss=0.286]\n",
      "Evaluating: 100%|██████████| 16/16 [00:02<00:00,  7.26batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3/10 - Train Loss: 23.0742 - Val Loss: 0.2215\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4/10: 100%|██████████| 124/124 [00:43<00:00,  2.83batch/s, loss=0.123] \n",
      "Evaluating: 100%|██████████| 16/16 [00:02<00:00,  7.24batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4/10 - Train Loss: 16.9821 - Val Loss: 0.2608\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5/10: 100%|██████████| 124/124 [00:41<00:00,  3.01batch/s, loss=0.104] \n",
      "Evaluating: 100%|██████████| 16/16 [00:02<00:00,  7.43batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5/10 - Train Loss: 10.0560 - Val Loss: 0.2646\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6/10: 100%|██████████| 124/124 [00:28<00:00,  4.34batch/s, loss=0.138]  \n",
      "Evaluating: 100%|██████████| 16/16 [00:01<00:00, 10.23batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6/10 - Train Loss: 9.3069 - Val Loss: 0.2535\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7/10: 100%|██████████| 124/124 [00:28<00:00,  4.31batch/s, loss=0.00183]\n",
      "Evaluating: 100%|██████████| 16/16 [00:01<00:00, 10.21batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7/10 - Train Loss: 6.4416 - Val Loss: 0.2688\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8/10: 100%|██████████| 124/124 [00:28<00:00,  4.37batch/s, loss=0.00722]\n",
      "Evaluating: 100%|██████████| 16/16 [00:30<00:00,  1.92s/batch]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8/10 - Train Loss: 4.9270 - Val Loss: 0.2915\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 9/10: 100%|██████████| 124/124 [00:29<00:00,  4.13batch/s, loss=0.0664]  \n",
      "Evaluating: 100%|██████████| 16/16 [00:01<00:00, 10.17batch/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9/10 - Train Loss: 2.8456 - Val Loss: 0.3152\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 10/10: 100%|██████████| 124/124 [00:27<00:00,  4.48batch/s, loss=0.0111]  \n",
      "Evaluating: 100%|██████████| 16/16 [00:01<00:00, 10.12batch/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10/10 - Train Loss: 2.2282 - Val Loss: 0.2945\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "train_model(model, train_loader, val_loader, criterion, optimizer, EPOCHS, device)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Evaluating: 100%|██████████| 16/16 [00:01<00:00,  9.59batch/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss (MSE): 0.3395\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "test_loss = evaluate(model, test_loader, criterion, device)\n",
    "print(f\"Test Loss (MSE): {test_loss:.4f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation Metrics on Test Data:\n",
      "Mean Squared Error (MSE): 0.3358\n",
      "Root Mean Squared Error (RMSE): 0.5795\n",
      "Mean Absolute Error (MAE): 0.3900\n",
      "R² Score: -0.3445\n"
     ]
    }
   ],
   "source": [
    "def evaluate_metrics(model, test_loader, device):\n",
    "    model.eval()\n",
    "    predictions = []\n",
    "    actuals = []\n",
    "    with torch.no_grad():\n",
    "        for inputs, labels in test_loader:\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "            outputs = model(inputs)\n",
    "            predictions.extend(outputs.cpu().numpy().flatten())\n",
    "            actuals.extend(labels.cpu().numpy().flatten())\n",
    "\n",
    "    mse = mean_squared_error(actuals, predictions)\n",
    "    rmse = np.sqrt(mse)\n",
    "    mae = mean_absolute_error(actuals, predictions)\n",
    "    r2 = r2_score(actuals, predictions)\n",
    "\n",
    "    return mse, rmse, mae, r2, actuals, predictions\n",
    "\n",
    "mse, rmse, mae, r2, actuals, predictions = evaluate_metrics(model, test_loader, device)\n",
    "\n",
    "print(\"Evaluation Metrics on Test Data:\")\n",
    "print(f\"Mean Squared Error (MSE): {mse:.4f}\")\n",
    "print(f\"Root Mean Squared Error (RMSE): {rmse:.4f}\")\n",
    "print(f\"Mean Absolute Error (MAE): {mae:.4f}\")\n",
    "print(f\"R² Score: {r2:.4f}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Definiere korrekte und falsche Vorhersagen basierend auf einem Schwellenwert\n",
    "threshold = 0.5\n",
    "predicted_labels = (np.array(predictions) > threshold).astype(int)\n",
    "true_labels = (np.array(actuals) > threshold).astype(int)\n",
    "\n",
    "# Bool-Array für korrekte Vorhersagen\n",
    "correct = predicted_labels == true_labels\n",
    "\n",
    "# Farben zuordnen: Grün für korrekt, Rot für falsch\n",
    "colors = ['green' if is_correct else 'red' for is_correct in correct]\n",
    "\n",
    "# Scatter-Plot\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.scatter(actuals, predictions, c=colors, alpha=0.6, edgecolor='k')\n",
    "\n",
    "\n",
    "# Legende anpassen\n",
    "import matplotlib.patches as mpatches\n",
    "green_patch = mpatches.Patch(color='green', label='Correct Predictions')\n",
    "red_patch = mpatches.Patch(color='red', label='Incorrect Predictions')\n",
    "plt.legend(handles=[green_patch, red_patch])\n",
    "\n",
    "# Achsen und Titel\n",
    "plt.title('True vs. Predicted Humor Scores')\n",
    "plt.xlabel('True Humor Score')\n",
    "plt.ylabel('Predicted Humor Score')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "239\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Load the data from csv\n",
    "df = pd.read_csv('data/hack.csv')\n",
    "df_test = df.iloc[test_dataset.original_indices].copy()\n",
    "df_test['prediction'] = predicted_labels\n",
    "df_test['label'] = true_labels\n",
    "df_test['pred_correct'] = (df_test['prediction'] == df_test['label'])\n",
    "\n",
    "df_test_sorted = df_test.sort_values(by='humor_rating').reset_index(drop=True)\n",
    "\n",
    "from matplotlib import patches as mpatches\n",
    "\n",
    "median_rating = df['humor_rating'].median()\n",
    "# get first index where humor_rating is greater than median_rating\n",
    "median_idx = df_test_sorted[df_test_sorted['humor_rating'] > median_rating].index[0]\n",
    "print(median_idx)\n",
    "# range idx for len df_test\n",
    "range_idx = range(len(df_test))\n",
    "colors = df_test_sorted['pred_correct'].map({True: 'g', False: 'r'})\n",
    "# bar plot for each df_test humor_rating value \n",
    "plt.bar(range_idx, df_test_sorted['humor_rating'], color=colors)\n",
    "# vertical line for True/False cut off\n",
    "plt.axvline(x=median_idx, color='black', linestyle='--')\n",
    "# Create a legend handles\n",
    "green_patch = mpatches.Patch(color='g', label='Correct Prediction')\n",
    "red_patch = mpatches.Patch(color='r', label='Incorrect Prediction')\n",
    "line_patch = mpatches.Patch(color='black', label='humor_rating cut off')\n",
    "plt.title('Humor Rating vs Prediction for Test Set')\n",
    "plt.xlabel('Index')\n",
    "plt.ylabel('Humor Rating')\n",
    "plt.legend(handles=[green_patch, red_patch, line_patch])\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}