MNIST_Early_Stopping_example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Early Stopping Example\n",
    "In this notebook, we will train an Multi-Layer Perceptron (MLP) to classify images from the [MNIST database](http://yann.lecun.com/exdb/mnist/) hand-written digit database, and use early stopping to stop the training when the model starts to overfit to the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import libraries\n",
    "import torch\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load and Batch the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision import datasets\n",
    "import torchvision.transforms as transforms\n",
    "from torch.utils.data.sampler import SubsetRandomSampler\n",
    "\n",
    "def create_datasets(batch_size):\n",
    "\n",
    "    # percentage of training set to use as validation\n",
    "    valid_size = 0.2\n",
    "\n",
    "    # convert data to torch.FloatTensor\n",
    "    transform = transforms.ToTensor()\n",
    "\n",
    "    # choose the training and test datasets\n",
    "    train_data = datasets.MNIST(root='data', \n",
    "                                train=True,\n",
    "                                download=True, \n",
    "                                transform=transform)\n",
    "\n",
    "    test_data = datasets.MNIST(root='data',\n",
    "                               train=False,\n",
    "                               download=True,\n",
    "                               transform=transform)\n",
    "\n",
    "    # obtain training indices that will be used for validation\n",
    "    num_train = len(train_data)\n",
    "    indices = list(range(num_train))\n",
    "    np.random.shuffle(indices)\n",
    "    split = int(np.floor(valid_size * num_train))\n",
    "    train_idx, valid_idx = indices[split:], indices[:split]\n",
    "    \n",
    "    # define samplers for obtaining training and validation batches\n",
    "    train_sampler = SubsetRandomSampler(train_idx)\n",
    "    valid_sampler = SubsetRandomSampler(valid_idx)\n",
    "    \n",
    "    # load training data in batches\n",
    "    train_loader = torch.utils.data.DataLoader(train_data,\n",
    "                                               batch_size=batch_size,\n",
    "                                               sampler=train_sampler,\n",
    "                                               num_workers=0)\n",
    "    \n",
    "    # load validation data in batches\n",
    "    valid_loader = torch.utils.data.DataLoader(train_data,\n",
    "                                               batch_size=batch_size,\n",
    "                                               sampler=valid_sampler,\n",
    "                                               num_workers=0)\n",
    "    \n",
    "    # load test data in batches\n",
    "    test_loader = torch.utils.data.DataLoader(test_data,\n",
    "                                              batch_size=batch_size,\n",
    "                                              num_workers=0)\n",
    "    \n",
    "    return train_loader, test_loader, valid_loader"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the Network\n",
    "Defining a simple MLP model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net(\n",
      "  (fc1): Linear(in_features=784, out_features=128, bias=True)\n",
      "  (fc2): Linear(in_features=128, out_features=128, bias=True)\n",
      "  (fc3): Linear(in_features=128, out_features=10, bias=True)\n",
      "  (dropout): Dropout(p=0.5, inplace=False)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = nn.Linear(28 * 28, 128)\n",
    "        self.fc2 = nn.Linear(128, 128)\n",
    "        self.fc3 = nn.Linear(128, 10)\n",
    "        self.dropout = nn.Dropout(0.5)\n",
    "    def forward(self, x):\n",
    "        # flatten image input\n",
    "        x = x.view(-1, 28 * 28)\n",
    "        # add hidden layer, with relu activation function\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.dropout(x)\n",
    "        # add hidden layer, with relu activation function\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.dropout(x)\n",
    "        # add output layer\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "# initialize the NN\n",
    "model = Net()\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specify Loss Function and Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# specify loss function\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "# specify optimizer\n",
    "optimizer = torch.optim.Adam(model.parameters())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import the Early Stopping Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import EarlyStopping\n",
    "from early_stopping_pytorch import EarlyStopping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the Model using Early Stopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, batch_size, patience, n_epochs):\n",
    "    \n",
    "    # to track the training loss as the model trains\n",
    "    train_losses = []\n",
    "    # to track the validation loss as the model trains\n",
    "    valid_losses = []\n",
    "    # to track the average training loss per epoch as the model trains\n",
    "    avg_train_losses = []\n",
    "    # to track the average validation loss per epoch as the model trains\n",
    "    avg_valid_losses = [] \n",
    "    \n",
    "    # initialize the early_stopping object\n",
    "    early_stopping = EarlyStopping(patience=patience, verbose=True)\n",
    "    \n",
    "    for epoch in range(1, n_epochs + 1):\n",
    "\n",
    "        ###################\n",
    "        # train the model #\n",
    "        ###################\n",
    "        model.train() # prep model for training\n",
    "        for batch, (data, target) in enumerate(train_loader, 1):\n",
    "            # clear the gradients of all optimized variables\n",
    "            optimizer.zero_grad()\n",
    "            # forward pass: compute predicted outputs by passing inputs to the model\n",
    "            output = model(data)\n",
    "            # calculate the loss\n",
    "            loss = criterion(output, target)\n",
    "            # backward pass: compute gradient of the loss with respect to model parameters\n",
    "            loss.backward()\n",
    "            # perform a single optimization step (parameter update)\n",
    "            optimizer.step()\n",
    "            # record training loss\n",
    "            train_losses.append(loss.item())\n",
    "\n",
    "        ######################    \n",
    "        # validate the model #\n",
    "        ######################\n",
    "        model.eval() # prep model for evaluation\n",
    "        for data, target in valid_loader:\n",
    "            # forward pass: compute predicted outputs by passing inputs to the model\n",
    "            output = model(data)\n",
    "            # calculate the loss\n",
    "            loss = criterion(output, target)\n",
    "            # record validation loss\n",
    "            valid_losses.append(loss.item())\n",
    "\n",
    "        # print training/validation statistics \n",
    "        # calculate average loss over an epoch\n",
    "        train_loss = np.average(train_losses)\n",
    "        valid_loss = np.average(valid_losses)\n",
    "        avg_train_losses.append(train_loss)\n",
    "        avg_valid_losses.append(valid_loss)\n",
    "        \n",
    "        epoch_len = len(str(n_epochs))\n",
    "        \n",
    "        print_msg = (f'[{epoch:>{epoch_len}}/{n_epochs:>{epoch_len}}] ' +\n",
    "                     f'train_loss: {train_loss:.5f} ' +\n",
    "                     f'valid_loss: {valid_loss:.5f}')\n",
    "        \n",
    "        print(print_msg)\n",
    "        \n",
    "        # clear lists to track next epoch\n",
    "        train_losses = []\n",
    "        valid_losses = []\n",
    "        \n",
    "        # early_stopping needs the validation loss to check if it has decresed, \n",
    "        # and if it has, it will make a checkpoint of the current model\n",
    "        early_stopping(valid_loss, model)\n",
    "        \n",
    "        if early_stopping.early_stop:\n",
    "            print(\"Early stopping\")\n",
    "            break\n",
    "        \n",
    "    # load the last checkpoint with the best model\n",
    "    model.load_state_dict(torch.load('checkpoint.pt', weights_only=True))\n",
    "\n",
    "    return  model, avg_train_losses, avg_valid_losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1/100] train_loss: 0.82703 valid_loss: 0.30238\n",
      "Validation loss decreased (inf --> 0.302376).  Saving model ...\n",
      "[  2/100] train_loss: 0.37277 valid_loss: 0.22491\n",
      "Validation loss decreased (0.302376 --> 0.224906).  Saving model ...\n",
      "[  3/100] train_loss: 0.29670 valid_loss: 0.18630\n",
      "Validation loss decreased (0.224906 --> 0.186303).  Saving model ...\n",
      "[  4/100] train_loss: 0.25662 valid_loss: 0.16485\n",
      "Validation loss decreased (0.186303 --> 0.164847).  Saving model ...\n",
      "[  5/100] train_loss: 0.22976 valid_loss: 0.14947\n",
      "Validation loss decreased (0.164847 --> 0.149469).  Saving model ...\n",
      "[  6/100] train_loss: 0.21193 valid_loss: 0.14102\n",
      "Validation loss decreased (0.149469 --> 0.141021).  Saving model ...\n",
      "[  7/100] train_loss: 0.19462 valid_loss: 0.13308\n",
      "Validation loss decreased (0.141021 --> 0.133076).  Saving model ...\n",
      "[  8/100] train_loss: 0.18161 valid_loss: 0.12685\n",
      "Validation loss decreased (0.133076 --> 0.126854).  Saving model ...\n",
      "[  9/100] train_loss: 0.17665 valid_loss: 0.12394\n",
      "Validation loss decreased (0.126854 --> 0.123937).  Saving model ...\n",
      "[ 10/100] train_loss: 0.16941 valid_loss: 0.11810\n",
      "Validation loss decreased (0.123937 --> 0.118096).  Saving model ...\n",
      "[ 11/100] train_loss: 0.15594 valid_loss: 0.11303\n",
      "Validation loss decreased (0.118096 --> 0.113027).  Saving model ...\n",
      "[ 12/100] train_loss: 0.15550 valid_loss: 0.10889\n",
      "Validation loss decreased (0.113027 --> 0.108887).  Saving model ...\n",
      "[ 13/100] train_loss: 0.14627 valid_loss: 0.11325\n",
      "EarlyStopping counter: 1 out of 20\n",
      "[ 14/100] train_loss: 0.14303 valid_loss: 0.11015\n",
      "EarlyStopping counter: 2 out of 20\n",
      "[ 15/100] train_loss: 0.13929 valid_loss: 0.10911\n",
      "EarlyStopping counter: 3 out of 20\n",
      "[ 16/100] train_loss: 0.13594 valid_loss: 0.10694\n",
      "Validation loss decreased (0.108887 --> 0.106941).  Saving model ...\n",
      "[ 17/100] train_loss: 0.13264 valid_loss: 0.10758\n",
      "EarlyStopping counter: 1 out of 20\n",
      "[ 18/100] train_loss: 0.13120 valid_loss: 0.10633\n",
      "Validation loss decreased (0.106941 --> 0.106329).  Saving model ...\n",
      "[ 19/100] train_loss: 0.12495 valid_loss: 0.10490\n",
      "Validation loss decreased (0.106329 --> 0.104902).  Saving model ...\n",
      "[ 20/100] train_loss: 0.12678 valid_loss: 0.10082\n",
      "Validation loss decreased (0.104902 --> 0.100817).  Saving model ...\n",
      "[ 21/100] train_loss: 0.12108 valid_loss: 0.10459\n",
      "EarlyStopping counter: 1 out of 20\n",
      "[ 22/100] train_loss: 0.11912 valid_loss: 0.10085\n",
      "EarlyStopping counter: 2 out of 20\n",
      "[ 23/100] train_loss: 0.11640 valid_loss: 0.10019\n",
      "Validation loss decreased (0.100817 --> 0.100187).  Saving model ...\n",
      "[ 24/100] train_loss: 0.11428 valid_loss: 0.10181\n",
      "EarlyStopping counter: 1 out of 20\n",
      "[ 25/100] train_loss: 0.11413 valid_loss: 0.10021\n",
      "EarlyStopping counter: 2 out of 20\n",
      "[ 26/100] train_loss: 0.11314 valid_loss: 0.09910\n",
      "Validation loss decreased (0.100187 --> 0.099096).  Saving model ...\n",
      "[ 27/100] train_loss: 0.10640 valid_loss: 0.10084\n",
      "EarlyStopping counter: 1 out of 20\n",
      "[ 28/100] train_loss: 0.11099 valid_loss: 0.09766\n",
      "Validation loss decreased (0.099096 --> 0.097662).  Saving model ...\n",
      "[ 29/100] train_loss: 0.10586 valid_loss: 0.09884\n",
      "EarlyStopping counter: 1 out of 20\n",
      "[ 30/100] train_loss: 0.10330 valid_loss: 0.10240\n",
      "EarlyStopping counter: 2 out of 20\n",
      "[ 31/100] train_loss: 0.10459 valid_loss: 0.09871\n",
      "EarlyStopping counter: 3 out of 20\n",
      "[ 32/100] train_loss: 0.10138 valid_loss: 0.09863\n",
      "EarlyStopping counter: 4 out of 20\n",
      "[ 33/100] train_loss: 0.10169 valid_loss: 0.09559\n",
      "Validation loss decreased (0.097662 --> 0.095588).  Saving model ...\n",
      "[ 34/100] train_loss: 0.09978 valid_loss: 0.09849\n",
      "EarlyStopping counter: 1 out of 20\n",
      "[ 35/100] train_loss: 0.10002 valid_loss: 0.09962\n",
      "EarlyStopping counter: 2 out of 20\n",
      "[ 36/100] train_loss: 0.09926 valid_loss: 0.10318\n",
      "EarlyStopping counter: 3 out of 20\n",
      "[ 37/100] train_loss: 0.09605 valid_loss: 0.09884\n",
      "EarlyStopping counter: 4 out of 20\n",
      "[ 38/100] train_loss: 0.09251 valid_loss: 0.10079\n",
      "EarlyStopping counter: 5 out of 20\n",
      "[ 39/100] train_loss: 0.09370 valid_loss: 0.10138\n",
      "EarlyStopping counter: 6 out of 20\n",
      "[ 40/100] train_loss: 0.09134 valid_loss: 0.10156\n",
      "EarlyStopping counter: 7 out of 20\n",
      "[ 41/100] train_loss: 0.09198 valid_loss: 0.10168\n",
      "EarlyStopping counter: 8 out of 20\n",
      "[ 42/100] train_loss: 0.09012 valid_loss: 0.10093\n",
      "EarlyStopping counter: 9 out of 20\n",
      "[ 43/100] train_loss: 0.09017 valid_loss: 0.10074\n",
      "EarlyStopping counter: 10 out of 20\n",
      "[ 44/100] train_loss: 0.09035 valid_loss: 0.09982\n",
      "EarlyStopping counter: 11 out of 20\n",
      "[ 45/100] train_loss: 0.08858 valid_loss: 0.09864\n",
      "EarlyStopping counter: 12 out of 20\n",
      "[ 46/100] train_loss: 0.08830 valid_loss: 0.09890\n",
      "EarlyStopping counter: 13 out of 20\n",
      "[ 47/100] train_loss: 0.08519 valid_loss: 0.10297\n",
      "EarlyStopping counter: 14 out of 20\n",
      "[ 48/100] train_loss: 0.08402 valid_loss: 0.10301\n",
      "EarlyStopping counter: 15 out of 20\n",
      "[ 49/100] train_loss: 0.08680 valid_loss: 0.10121\n",
      "EarlyStopping counter: 16 out of 20\n",
      "[ 50/100] train_loss: 0.08755 valid_loss: 0.10025\n",
      "EarlyStopping counter: 17 out of 20\n",
      "[ 51/100] train_loss: 0.08680 valid_loss: 0.10176\n",
      "EarlyStopping counter: 18 out of 20\n",
      "[ 52/100] train_loss: 0.07961 valid_loss: 0.10526\n",
      "EarlyStopping counter: 19 out of 20\n",
      "[ 53/100] train_loss: 0.08318 valid_loss: 0.10343\n",
      "EarlyStopping counter: 20 out of 20\n",
      "Early stopping\n"
     ]
    }
   ],
   "source": [
    "batch_size = 256\n",
    "n_epochs = 100\n",
    "\n",
    "train_loader, test_loader, valid_loader = create_datasets(batch_size)\n",
    "\n",
    "# early stopping patience; how long to wait after last time validation loss improved.\n",
    "patience = 20\n",
    "\n",
    "model, train_loss, valid_loss = train_model(model, batch_size, patience, n_epochs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing the Loss and the Early Stopping Checkpoint\n",
    "From the plot we can see that the last Early Stopping Checkpoint was saved right before the model started to overfit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# visualize the loss as the network trained\n",
    "fig = plt.figure(figsize=(10,8))\n",
    "plt.plot(range(1,len(train_loss)+1),train_loss, label='Training Loss')\n",
    "plt.plot(range(1,len(valid_loss)+1),valid_loss,label='Validation Loss')\n",
    "\n",
    "# find position of lowest validation loss\n",
    "minposs = valid_loss.index(min(valid_loss))+1 \n",
    "plt.axvline(minposs, linestyle='--', color='r',label='Early Stopping Checkpoint')\n",
    "\n",
    "plt.xlabel('epochs')\n",
    "plt.ylabel('loss')\n",
    "plt.ylim(0, 0.5) # consistent scale\n",
    "plt.xlim(0, len(train_loss)+1) # consistent scale\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "fig.savefig('loss_plot.png', bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test the Trained Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.085494\n",
      "\n",
      "Test Accuracy of     0: 98% (969/979)\n",
      "Test Accuracy of     1: 98% (1121/1133)\n",
      "Test Accuracy of     2: 97% (1006/1030)\n",
      "Test Accuracy of     3: 98% (988/1008)\n",
      "Test Accuracy of     4: 97% (953/980)\n",
      "Test Accuracy of     5: 96% (860/890)\n",
      "Test Accuracy of     6: 97% (935/956)\n",
      "Test Accuracy of     7: 97% (1002/1027)\n",
      "Test Accuracy of     8: 95% (932/973)\n",
      "Test Accuracy of     9: 96% (973/1008)\n",
      "\n",
      "Test Accuracy (Overall): 97% (9739/9984)\n"
     ]
    }
   ],
   "source": [
    "# initialize lists to monitor test loss and accuracy\n",
    "test_loss = 0.0\n",
    "class_correct = list(0. for i in range(10))\n",
    "class_total = list(0. for i in range(10))\n",
    "\n",
    "model.eval() # prep model for evaluation\n",
    "\n",
    "for data, target in test_loader:\n",
    "    if len(target.data) != batch_size:\n",
    "        break\n",
    "    # forward pass: compute predicted outputs by passing inputs to the model\n",
    "    output = model(data)\n",
    "    # calculate the loss\n",
    "    loss = criterion(output, target)\n",
    "    # update test loss \n",
    "    test_loss += loss.item()*data.size(0)\n",
    "    # convert output probabilities to predicted class\n",
    "    _, pred = torch.max(output, 1)\n",
    "    # compare predictions to true label\n",
    "    correct = np.squeeze(pred.eq(target.data.view_as(pred)))\n",
    "    # calculate test accuracy for each object class\n",
    "    for i in range(batch_size):\n",
    "        label = target.data[i]\n",
    "        class_correct[label] += correct[i].item()\n",
    "        class_total[label] += 1\n",
    "\n",
    "# calculate and print avg test loss\n",
    "test_loss = test_loss/len(test_loader.dataset)\n",
    "print('Test Loss: {:.6f}\\n'.format(test_loss))\n",
    "\n",
    "for i in range(10):\n",
    "    if class_total[i] > 0:\n",
    "        print('Test Accuracy of %5s: %2d%% (%2d/%2d)' % (\n",
    "            str(i), 100 * class_correct[i] / class_total[i],\n",
    "            np.sum(class_correct[i]), np.sum(class_total[i])))\n",
    "    else:\n",
    "        print('Test Accuracy of %5s: N/A (no training examples)' % (classes[i]))\n",
    "\n",
    "print('\\nTest Accuracy (Overall): %2d%% (%2d/%2d)' % (\n",
    "    100. * np.sum(class_correct) / np.sum(class_total),\n",
    "    np.sum(class_correct), np.sum(class_total)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize Sample Test Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2500x400 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# obtain one batch of test images\n",
    "dataiter = iter(test_loader)\n",
    "images, labels = next(dataiter)  # Use the built-in next() function\n",
    "\n",
    "# get sample outputs\n",
    "output = model(images)\n",
    "# convert output probabilities to predicted class\n",
    "_, preds = torch.max(output, 1)\n",
    "# prep images for display\n",
    "images = images.numpy()\n",
    "\n",
    "# plot the images in the batch, along with predicted and true labels\n",
    "fig = plt.figure(figsize=(25, 4))\n",
    "for idx in np.arange(20):\n",
    "    ax = fig.add_subplot(2, 20 // 2, idx+1, xticks=[], yticks=[])\n",
    "    ax.imshow(np.squeeze(images[idx]), cmap='gray')\n",
    "    ax.set_title(\"{} ({})\".format(str(preds[idx].item()), str(labels[idx].item())),\n",
    "                 color=(\"green\" if preds[idx]==labels[idx] else \"red\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The MNIST training example code is mainly taken from the [mnist_mlp_solution_with_validation.ipynb](https://github.com/udacity/deep-learning-v2-pytorch/blob/master/convolutional-neural-networks/mnist-mlp/mnist_mlp_solution_with_validation.ipynb) notebook from the [deep-learning-v2-pytorch repository](https://github.com/udacity/deep-learning-v2-pytorch) made by [Udacity](https://www.udacity.com/), and has been fitted with my early stopping code. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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": 4
}