Logistic_Regression.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7e95ec08",
   "metadata": {},
   "source": [
    "<h1>Logistic Regression</h1>\n",
    "\n",
    "\n",
    "Linear Regression is for estimating continuous values, such as predicting house prices. However, Linear Regression falls short when the goal shifts to predicting the most likely class for a given data point. In such cases, <u>Logistic</u> Regression emerges as the preferred choice. Unlike Linear Regression, Logistic Regression assesses the probability of a data point belonging to a specific class, thus proving invaluable in classification tasks.\n",
    "\n",
    "Logistic Regression is a variation of Linear Regression, useful when the dependent variable <i>y</i> is categorical. Despite the name logistic <i>regression</i>, it is a <b>probabilistic classification</b> model. Logistic regression fits a special s-shaped curve by taking the linear regression and transforming the numeric estimate into a probability with the following function:\n",
    "\n",
    "$$\n",
    "ProbabilityOfaClass = \\theta(y) = \\frac{e^y}{1 + e^y}\n",
    "$$\n",
    "\n",
    "which produces values between 0 (as y approaches minus infinity $-\\infty$) and 1 (as y approaches plus infinity $+\\infty$). This now becomes a special kind of non-linear regression.\n",
    "\n",
    "In the equation, <i>y</i> is the regression result (the sum of the variables weighted by the coefficients), $e$ is the exponential function, and $\\theta(y)$ is the logistic function, also called a logistic curve. It is a common \"S\" shape (sigmoid curve)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e36f4a01",
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MinMaxScaler, OneHotEncoder"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "13d5c644",
   "metadata": {},
   "source": [
    "<h2>Iris Dataset</h2>\n",
    "\n",
    "<a href=\"https://archive.ics.uci.edu/ml/datasets/iris\">The Iris Dataset</a> consists of 50 samples from each of the three species of Iris. In total, it has 150 records under five attributes and species.\n",
    "\n",
    "Attributes Independent Variables:\n",
    "<ul>\n",
    "    <li>petal length</li>\n",
    "    <li>petal width</li>\n",
    "    <li>sepal length</li>\n",
    "    <li>sepal width</li>\n",
    "</ul>\n",
    "Dependent Variables:\n",
    "<ul>\n",
    "    <li>Iris setosa</li>\n",
    "    <li>Iris virginica</li>\n",
    "    <li>Iris versicolor</li>\n",
    "</ul>\n",
    "<br>\n",
    "\n",
    "Next, we load the dataset pre-built within the sklearn library. Preprocess the features and values, and then we can start using it. Afterward, we separate the dataset into training and testing parts randomly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "512b7c06",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = load_iris() # Load the dataset\n",
    "x, y = dataset.data, dataset.target # Seperate x (independent variable) and y (dependent variable)\n",
    "\n",
    "# Preprocess the x values by normalizing them:\n",
    "scaler = MinMaxScaler()\n",
    "x = scaler.fit_transform(x)\n",
    "\n",
    "# Preprocess the y values by encoding them to one-hot vector:\n",
    "encoder = OneHotEncoder()\n",
    "y = encoder.fit_transform(y.reshape(-1, 1)).toarray()\n",
    "\n",
    "# Split the dataset to train and test sets:\n",
    "train_x, test_x, train_y, test_y = train_test_split(x, y, test_size=0.2, random_state=2024, shuffle=True)\n",
    "\n",
    "# transform the arrays into tensors\n",
    "train_x = tf.constant(train_x, dtype=tf.float32)\n",
    "test_x = tf.constant(test_x, dtype=tf.float32)\n",
    "train_y = tf.constant(train_y, dtype=tf.float32)\n",
    "test_y = tf.constant(test_y, dtype=tf.float32)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "afd25f92",
   "metadata": {},
   "source": [
    "<h2>Define Model Components</h2>\n",
    "\n",
    "We start by defining the loss function. Since we want to solve a classification task, we need to define an appropriate loss function that can aid the model in providing valuable signal based on correct predicting the label class. Therefore, we are going to define and use cross-entropy loss function for binary classification as follows:\n",
    "\n",
    "<!DOCTYPE html>\n",
    "<html>\n",
    "<body>\n",
    "  <p>\\[ \\text{Binary Cross-Entropy Loss} = - \\sum_{i=1}^{N} y_{i} \\cdot \\log(p_{i}) + (1 - y_{i}) \\cdot \\log(1 - p_{i}) \\]</p>\n",
    "  <ul>\n",
    "    <li>\\( N \\) is the number of samples.</li>\n",
    "    <li>\\( y_{i} \\) is the actual label (0 or 1) for the \\( i \\)th sample.</li>\n",
    "    <li>\\( p_{i} \\) is the predicted probability that the \\( i \\)th sample belongs to the positive class.</li>\n",
    "  </ul>\n",
    "  <p>This formula calculates the cross-entropy loss over the entire batch for classification tasks.</p>\n",
    "</body>\n",
    "</html>\n",
    "\n",
    "<h3>Loss Function</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2d0b2235-d145-4162-ac47-06519284a36c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss_function(pred, actual):\n",
    "    loss = - tf.reduce_mean(actual * tf.math.log(pred)\n",
    "                            + (1 - actual) * tf.math.log(1 - pred))\n",
    "    return loss"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "4c758723",
   "metadata": {},
   "source": [
    "<h3>Logistic Regression Model</h3>\n",
    "\n",
    "Now, let's define the logistic regression model:\n",
    "\n",
    "Logistic regression is typically thought of as a single equation:\n",
    "\n",
    "ŷ = sigmoid(w * x + b)\n",
    "\n",
    "We can have it broken into its three main components: \n",
    "\n",
    "-   a weight times features matrix multiplication operation, \n",
    "-   a summation of the weighted features and a bias term, \n",
    "-   and the application of a sigmoid function.\n",
    "\n",
    "The function we are going to use is the <i>logistic function</i> $(\\frac{1}{1+e^{-Wx}})$, which is fed the input data after applying weights and bias. In TensorFlow, this function is implemented as the <code>nn.sigmoid</code> function. Effectively, this fits the weighted input with bias into a 0-100 % curve, which is the probability function we want.\n",
    "\n",
    "We can't use <b>least-squares linear regression</b> here, so we should use Adam optimizer to reduce the loss through looping over the entire batch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "546b1373-5e96-4f4f-a5b9-481758977be5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def logistic_regression(features, weights, bias):\n",
    "    linear_transformation = tf.matmul(features, weights, name='linear_transformation') # Calculate the linear transformation\n",
    "    with_bias = tf.add(linear_transformation, bias, name='add_bias') # Add the bias term\n",
    "    output = tf.nn.sigmoid(with_bias, name='sigmoid_activation') # Apply the sigmoid activation function\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bca74b78-d9ae-403b-b20e-017f9a9e98dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def run(learning_rate, total_epochs, train_y, interval_print=10):\n",
    "    accuracy_values = []\n",
    "    loss_values = []\n",
    "\n",
    "    optimizer = tf.keras.optimizers.Adam(learning_rate)\n",
    "\n",
    "    weights = tf.Variable(tf.random.normal((train_x.shape[-1], 1), mean=0.5, stddev=0.5), dtype=tf.float32)\n",
    "    bias = tf.Variable(tf.random.normal((1, 1), mean=0.5, stddev=0.5), dtype=tf.float32)\n",
    "    \n",
    "    for epoch in range(1, total_epochs + 1):\n",
    "        with tf.GradientTape() as tape:\n",
    "            pred = logistic_regression(train_x, weights, bias)\n",
    "            loss = loss_function(pred, train_y)\n",
    "        gradient = tape.gradient(loss, [weights, bias])\n",
    "        optimizer.apply_gradients(zip(gradient, [weights, bias]))\n",
    "    \n",
    "        loss_values.append(loss.numpy())\n",
    "        accuracy = compute_accuracy(pred, train_y)\n",
    "        accuracy_values.append(accuracy.numpy())\n",
    "        \n",
    "        if epoch % interval_print == 0:           \n",
    "            print(f'Epoch: {epoch:04d} || Train Loss: {loss:.3f}, Train Accuracy: {accuracy:.3f}')\n",
    "\n",
    "    return {\n",
    "        'weights' : weights,\n",
    "        'bias'    : bias,\n",
    "        'accuracy': accuracy_values,\n",
    "        'loss'    : loss_values\n",
    "        }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0daf480b-33f7-4301-9d77-a5c81090ba5c",
   "metadata": {},
   "source": [
    "<h3>Accuracy</h3>\n",
    "We also want some additional operations to keep track of our model's efficiency over time. We can do this like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4e281b63-36c2-4ce2-91e0-a976dab74f6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_accuracy(predicted_y, actual_y):\n",
    "    # print(predicted_y, '\\n', actual_y)\n",
    "    # correct_prediction = tf.equal(tf.argmax(predicted_y, axis=1), tf.argmax(actual_y, axis=1))\n",
    "    predicted_y = tf.where(predicted_y > 0.5, 1.0, 0.0)\n",
    "    correct_prediction = tf.equal(predicted_y, actual_y)\n",
    "    return tf.reduce_mean(tf.cast(correct_prediction, dtype=tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5926dad-bafa-4f3b-87ba-59216e98adcf",
   "metadata": {},
   "source": [
    "<h2>One-vs-All</h2>\n",
    "<h3>Training</h3>\n",
    "In the context of training a logistic regression model on the Iris dataset, the One-vs-All (OvA) approach, involves training multiple binary classifiers, each designed to distinguish between one class and the rest of the classes.\n",
    "\n",
    "The Iris dataset consists of three different classes of iris plants. Since logistic regression is inherently a binary classifier, we need to extend it to handle multi-class classification problems like the Iris dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "dffe30b3-a2ca-43b9-96e5-2b1100005a89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0010 || Train Loss: 0.204, Train Accuracy: 0.967\n",
      "Epoch: 0020 || Train Loss: 0.072, Train Accuracy: 1.000\n",
      "Epoch: 0030 || Train Loss: 0.025, Train Accuracy: 1.000\n",
      "Epoch: 0040 || Train Loss: 0.018, Train Accuracy: 1.000\n",
      "Epoch: 0050 || Train Loss: 0.013, Train Accuracy: 1.000\n",
      "Epoch: 0060 || Train Loss: 0.011, Train Accuracy: 1.000\n",
      "Epoch: 0070 || Train Loss: 0.010, Train Accuracy: 1.000\n",
      "Epoch: 0080 || Train Loss: 0.009, Train Accuracy: 1.000\n",
      "Epoch: 0090 || Train Loss: 0.008, Train Accuracy: 1.000\n",
      "Epoch: 0100 || Train Loss: 0.007, Train Accuracy: 1.000\n",
      "Epoch: 0110 || Train Loss: 0.007, Train Accuracy: 1.000\n",
      "Epoch: 0120 || Train Loss: 0.006, Train Accuracy: 1.000\n",
      "Epoch: 0130 || Train Loss: 0.006, Train Accuracy: 1.000\n",
      "Epoch: 0140 || Train Loss: 0.005, Train Accuracy: 1.000\n",
      "Epoch: 0150 || Train Loss: 0.005, Train Accuracy: 1.000\n",
      "Epoch: 0160 || Train Loss: 0.005, Train Accuracy: 1.000\n",
      "Epoch: 0170 || Train Loss: 0.004, Train Accuracy: 1.000\n",
      "Epoch: 0180 || Train Loss: 0.004, Train Accuracy: 1.000\n",
      "Epoch: 0190 || Train Loss: 0.004, Train Accuracy: 1.000\n",
      "Epoch: 0200 || Train Loss: 0.004, Train Accuracy: 1.000\n",
      "\n",
      "Epoch: 0010 || Train Loss: 0.652, Train Accuracy: 0.667\n",
      "Epoch: 0020 || Train Loss: 0.567, Train Accuracy: 0.575\n",
      "Epoch: 0030 || Train Loss: 0.539, Train Accuracy: 0.683\n",
      "Epoch: 0040 || Train Loss: 0.525, Train Accuracy: 0.708\n",
      "Epoch: 0050 || Train Loss: 0.517, Train Accuracy: 0.717\n",
      "Epoch: 0060 || Train Loss: 0.512, Train Accuracy: 0.700\n",
      "Epoch: 0070 || Train Loss: 0.510, Train Accuracy: 0.700\n",
      "Epoch: 0080 || Train Loss: 0.508, Train Accuracy: 0.700\n",
      "Epoch: 0090 || Train Loss: 0.507, Train Accuracy: 0.700\n",
      "Epoch: 0100 || Train Loss: 0.506, Train Accuracy: 0.700\n",
      "Epoch: 0110 || Train Loss: 0.506, Train Accuracy: 0.700\n",
      "Epoch: 0120 || Train Loss: 0.505, Train Accuracy: 0.700\n",
      "Epoch: 0130 || Train Loss: 0.504, Train Accuracy: 0.708\n",
      "Epoch: 0140 || Train Loss: 0.504, Train Accuracy: 0.708\n",
      "Epoch: 0150 || Train Loss: 0.503, Train Accuracy: 0.700\n",
      "Epoch: 0160 || Train Loss: 0.503, Train Accuracy: 0.700\n",
      "Epoch: 0170 || Train Loss: 0.503, Train Accuracy: 0.708\n",
      "Epoch: 0180 || Train Loss: 0.502, Train Accuracy: 0.708\n",
      "Epoch: 0190 || Train Loss: 0.502, Train Accuracy: 0.717\n",
      "Epoch: 0200 || Train Loss: 0.502, Train Accuracy: 0.717\n",
      "\n",
      "Epoch: 0010 || Train Loss: 0.382, Train Accuracy: 0.792\n",
      "Epoch: 0020 || Train Loss: 0.261, Train Accuracy: 0.942\n",
      "Epoch: 0030 || Train Loss: 0.209, Train Accuracy: 0.958\n",
      "Epoch: 0040 || Train Loss: 0.180, Train Accuracy: 0.958\n",
      "Epoch: 0050 || Train Loss: 0.159, Train Accuracy: 0.975\n",
      "Epoch: 0060 || Train Loss: 0.145, Train Accuracy: 0.975\n",
      "Epoch: 0070 || Train Loss: 0.133, Train Accuracy: 0.975\n",
      "Epoch: 0080 || Train Loss: 0.123, Train Accuracy: 0.975\n",
      "Epoch: 0090 || Train Loss: 0.115, Train Accuracy: 0.975\n",
      "Epoch: 0100 || Train Loss: 0.108, Train Accuracy: 0.975\n",
      "Epoch: 0110 || Train Loss: 0.102, Train Accuracy: 0.975\n",
      "Epoch: 0120 || Train Loss: 0.097, Train Accuracy: 0.975\n",
      "Epoch: 0130 || Train Loss: 0.092, Train Accuracy: 0.975\n",
      "Epoch: 0140 || Train Loss: 0.088, Train Accuracy: 0.975\n",
      "Epoch: 0150 || Train Loss: 0.085, Train Accuracy: 0.975\n",
      "Epoch: 0160 || Train Loss: 0.082, Train Accuracy: 0.975\n",
      "Epoch: 0170 || Train Loss: 0.079, Train Accuracy: 0.975\n",
      "Epoch: 0180 || Train Loss: 0.076, Train Accuracy: 0.975\n",
      "Epoch: 0190 || Train Loss: 0.074, Train Accuracy: 0.975\n",
      "Epoch: 0200 || Train Loss: 0.072, Train Accuracy: 0.975\n"
     ]
    }
   ],
   "source": [
    "learning_rate = 0.5\n",
    "total_epochs = 200\n",
    "\n",
    "\n",
    "# label 1 - first classifier\n",
    "train_y_1 = train_y.numpy()[:, 0:2] # transform to NumPy and select index 0 and 1 from the one-hot vector of label\n",
    "train_y_1[:, -1] = 0 # only label 1 can have 1 and zero value, the second index is all negative, thus 0.\n",
    "train_y_1 = np.max(train_y_1, axis=1).reshape(-1, 1) # create a single value from the one-hot vector which either is 0 or 1\n",
    "train_y_1 = tf.constant(train_y_1, dtype=tf.float32) # transform it to tensor for processing\n",
    "\n",
    "classifier_1 = run(learning_rate, total_epochs, train_y_1) # run the first classifier\n",
    "\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "print()\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "\n",
    "# label 2 - Second classifier\n",
    "train_y_2 = train_y.numpy()[:, 1:3]\n",
    "train_y_2[:, -1] = 0\n",
    "train_y_2 = np.max(train_y_2, axis=1).reshape(-1, 1)\n",
    "train_y_2 = tf.constant(train_y_2, dtype=tf.float32)\n",
    "\n",
    "classifier_2 = run(learning_rate, total_epochs, train_y_2)\n",
    "\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "print()\n",
    "#~~~~~~~~~~~~~~~~~~~~~~~~~~~\n",
    "\n",
    "# label 3 - Third classifier\n",
    "train_y_3 = train_y.numpy()[:, 1:3]\n",
    "train_y_3[:, 0] = 0\n",
    "train_y_3 = np.max(train_y_3, axis=1).reshape(-1, 1)\n",
    "train_y_3 = tf.constant(train_y_3, dtype=tf.float32)\n",
    "\n",
    "classifier_3 = run(learning_rate, total_epochs, train_y_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "028725ba-40c8-42e4-9465-fa5af6fae75f",
   "metadata": {},
   "source": [
    "<h3>Testing</h3>\n",
    "We utilize the weights and biases of each trained classifier to predict the labels of the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "41f1f32e-61aa-47d6-9edb-abffaaf7ba3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Label 1\n",
    "weights = classifier_1['weights']\n",
    "bias = classifier_1['bias']\n",
    "\n",
    "label_1 = logistic_regression(test_x, weights, bias)\n",
    "label_1 = tf.where(label_1 > 0.5, 1.0, 0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c6ae22e0-e500-4394-8d68-0b9c1adbc830",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Label 2\n",
    "weights = classifier_2['weights']\n",
    "bias = classifier_2['bias']\n",
    "\n",
    "label_2 = logistic_regression(test_x, weights, bias)\n",
    "label_2 = tf.where(label_2 > 0.5, 1.0, 0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "91d8689e-57c1-4d8c-ad4d-a90a8cec08b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Label 3\n",
    "weights = classifier_3['weights']\n",
    "bias = classifier_3['bias']\n",
    "\n",
    "label_3 = logistic_regression(test_x, weights, bias)\n",
    "label_3 = tf.where(label_3 > 0.5, 1.0, 0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "846b4f66-a4a3-49c2-915e-09474dd6b062",
   "metadata": {},
   "source": [
    "After each classifier has predicted its associated labels, we combine all predictions into a single array. This allows us to evaluate the accuracy of our prediction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c4703b26-1aa1-417e-a480-858fdc9e9ede",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy: 0.733\n"
     ]
    }
   ],
   "source": [
    "zeroes = np.zeros(shape=(len(test_y), test_y.shape[-1]), dtype=np.uint16)\n",
    "\n",
    "zeroes[:,0] = label_1.numpy().reshape(-1)\n",
    "zeroes[:,1] = label_2.numpy().reshape(-1)\n",
    "zeroes[:,2] = label_3.numpy().reshape(-1)\n",
    "\n",
    "row_equality = np.all(zeroes == test_y.numpy().astype(np.uint16), axis=1)\n",
    "num_corrects  = np.mean(row_equality)\n",
    "\n",
    "print(f'Test Accuracy: {num_corrects:.3f}')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7cc39055",
   "metadata": {},
   "source": [
    "Let's plot the loss values and accuracy during training to see how it has changed during the training:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c464bb62-3bd3-465e-b7ee-4f002b3298b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "losses = [classifier_1['loss'], classifier_2['loss'], classifier_3['loss']]\n",
    "accuracy = [classifier_1['accuracy'], classifier_2['accuracy'], classifier_3['accuracy']]\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))\n",
    "\n",
    "selected_color_set = 'Set1'\n",
    "colormap = plt.get_cmap(selected_color_set)\n",
    "\n",
    "for i, (loss, accuracy) in enumerate(zip(losses, accuracy)):\n",
    "    ax1.plot(loss, color=colormap(i), label=f'Classifier {i+1}')\n",
    "    ax2.plot(accuracy, color=colormap(i), label=f'Classifier {i+1}')\n",
    "    \n",
    "ax1.set_xlabel(\"Epochs\")\n",
    "ax1.set_ylabel('Loss')\n",
    "ax2.set_xlabel(\"Epochs\")\n",
    "ax2.set_ylabel('Accuracy')\n",
    "ax1.legend()\n",
    "ax2.legend()\n",
    "\n",
    "plt.savefig('./plot.png', format='png', dpi=600, bbox_inches='tight', transparent=True)\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d660dbd5-1a61-4d68-bb17-dac4c9d3866b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}