BatteryLife.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Remaining Battery Life🔋🪫Prediction\n",
    "\n",
    "The Hawaii Natural Energy Institute conducted an analysis on 14 NMC-LCO 18650 batteries, each with a nominal capacity of 2.8 Ah. These batteries underwent over 1000 charge-discharge cycles at a temperature of 25°C, using a constant current-constant voltage (CC-CV) charging method at a C/2 rate and a discharge rate of 1.5C.\n",
    "\n",
    "<img align=left width=550px src='https://apmonitor.com/pds/uploads/Main/battery_life.png'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data\n",
    "\n",
    " - Cycle Index: number of cycle\n",
    " - F1: Discharge Time (s)\n",
    " - F2: Time at 4.15V (s)\n",
    " - F3: Time Constant Current (s)\n",
    " - F4: Decrement 3.6-3.4V (s)\n",
    " - F5: Max. Voltage Discharge (V)\n",
    " - F6: Min. Voltage Charge (V)\n",
    " - F7: Charging Time (s)\n",
    " - Total time (s)\n",
    " - RUL: target\n",
    "\n",
    "See full [problem statement](https://apmonitor.com/pds/index.php/Main/BatteryLife).\n",
    "\n",
    "### Import Packages and Battery Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 15064 entries, 0 to 15063\n",
      "Data columns (total 9 columns):\n",
      " #   Column                     Non-Null Count  Dtype  \n",
      "---  ------                     --------------  -----  \n",
      " 0   Cycle_Index                15064 non-null  float64\n",
      " 1   Discharge Time (s)         15064 non-null  float64\n",
      " 2   Decrement 3.6-3.4V (s)     15064 non-null  float64\n",
      " 3   Max. Voltage Dischar. (V)  15064 non-null  float64\n",
      " 4   Min. Voltage Charg. (V)    15064 non-null  float64\n",
      " 5   Time at 4.15V (s)          15064 non-null  float64\n",
      " 6   Time constant current (s)  15064 non-null  float64\n",
      " 7   Charging time (s)          15064 non-null  float64\n",
      " 8   RUL                        15064 non-null  int64  \n",
      "dtypes: float64(8), int64(1)\n",
      "memory usage: 1.0 MB\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "url = 'http://apmonitor.com/pds/uploads/Main/'\n",
    "data = pd.read_csv(url+\"battery_data.csv\")\n",
    "data.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Shorten column names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.columns = ['Cycle','Disch_s','Dec_3.6-3.4','MaxVD','MinVC','T4.15V','TCC_s','Charge_s','RUL']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Summarize the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Cycle</th>\n",
       "      <th>Disch_s</th>\n",
       "      <th>Dec_3.6-3.4</th>\n",
       "      <th>MaxVD</th>\n",
       "      <th>MinVC</th>\n",
       "      <th>T4.15V</th>\n",
       "      <th>TCC_s</th>\n",
       "      <th>Charge_s</th>\n",
       "      <th>RUL</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>15064.000000</td>\n",
       "      <td>15064.000000</td>\n",
       "      <td>15064.000000</td>\n",
       "      <td>15064.000000</td>\n",
       "      <td>15064.000000</td>\n",
       "      <td>15064.000000</td>\n",
       "      <td>15064.000000</td>\n",
       "      <td>15064.000000</td>\n",
       "      <td>15064.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>556.155005</td>\n",
       "      <td>4581.273960</td>\n",
       "      <td>1239.784672</td>\n",
       "      <td>3.908176</td>\n",
       "      <td>3.577904</td>\n",
       "      <td>3768.336171</td>\n",
       "      <td>5461.266970</td>\n",
       "      <td>10066.496204</td>\n",
       "      <td>554.194172</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>322.378480</td>\n",
       "      <td>33144.012077</td>\n",
       "      <td>15039.589269</td>\n",
       "      <td>0.091003</td>\n",
       "      <td>0.123695</td>\n",
       "      <td>9129.552477</td>\n",
       "      <td>25155.845202</td>\n",
       "      <td>26415.354121</td>\n",
       "      <td>322.434514</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>8.690000</td>\n",
       "      <td>-397645.908000</td>\n",
       "      <td>3.043000</td>\n",
       "      <td>3.022000</td>\n",
       "      <td>-113.584000</td>\n",
       "      <td>5.980000</td>\n",
       "      <td>5.980000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>271.000000</td>\n",
       "      <td>1169.310000</td>\n",
       "      <td>319.600000</td>\n",
       "      <td>3.846000</td>\n",
       "      <td>3.488000</td>\n",
       "      <td>1828.884179</td>\n",
       "      <td>2564.310000</td>\n",
       "      <td>7841.922500</td>\n",
       "      <td>277.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>560.000000</td>\n",
       "      <td>1557.250000</td>\n",
       "      <td>439.239471</td>\n",
       "      <td>3.906000</td>\n",
       "      <td>3.574000</td>\n",
       "      <td>2930.203500</td>\n",
       "      <td>3824.260000</td>\n",
       "      <td>8320.415000</td>\n",
       "      <td>551.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>833.000000</td>\n",
       "      <td>1908.000000</td>\n",
       "      <td>600.000000</td>\n",
       "      <td>3.972000</td>\n",
       "      <td>3.663000</td>\n",
       "      <td>4088.326500</td>\n",
       "      <td>5012.350000</td>\n",
       "      <td>8763.282500</td>\n",
       "      <td>839.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>1134.000000</td>\n",
       "      <td>958320.370000</td>\n",
       "      <td>406703.768000</td>\n",
       "      <td>4.363000</td>\n",
       "      <td>4.379000</td>\n",
       "      <td>245101.117000</td>\n",
       "      <td>880728.100000</td>\n",
       "      <td>880728.100000</td>\n",
       "      <td>1133.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              Cycle        Disch_s    Dec_3.6-3.4         MaxVD         MinVC  \\\n",
       "count  15064.000000   15064.000000   15064.000000  15064.000000  15064.000000   \n",
       "mean     556.155005    4581.273960    1239.784672      3.908176      3.577904   \n",
       "std      322.378480   33144.012077   15039.589269      0.091003      0.123695   \n",
       "min        1.000000       8.690000 -397645.908000      3.043000      3.022000   \n",
       "25%      271.000000    1169.310000     319.600000      3.846000      3.488000   \n",
       "50%      560.000000    1557.250000     439.239471      3.906000      3.574000   \n",
       "75%      833.000000    1908.000000     600.000000      3.972000      3.663000   \n",
       "max     1134.000000  958320.370000  406703.768000      4.363000      4.379000   \n",
       "\n",
       "              T4.15V          TCC_s       Charge_s           RUL  \n",
       "count   15064.000000   15064.000000   15064.000000  15064.000000  \n",
       "mean     3768.336171    5461.266970   10066.496204    554.194172  \n",
       "std      9129.552477   25155.845202   26415.354121    322.434514  \n",
       "min      -113.584000       5.980000       5.980000      0.000000  \n",
       "25%      1828.884179    2564.310000    7841.922500    277.000000  \n",
       "50%      2930.203500    3824.260000    8320.415000    551.000000  \n",
       "75%      4088.326500    5012.350000    8763.282500    839.000000  \n",
       "max    245101.117000  880728.100000  880728.100000   1133.000000  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![idea](https://apmonitor.com/che263/uploads/Begin_Python/idea.png)\n",
    "\n",
    "### Create new ID Column to Identify 14 Batteries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['ID']= 0 \n",
    "# add ID to DataFrame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![idea](https://apmonitor.com/che263/uploads/Begin_Python/idea.png)\n",
    "\n",
    "### Filter Data\n",
    "\n",
    "There are many bad measurements as shown in the line plot. Data rows with bad values need to be removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a line plot of the data "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove bad values with upper and lower validity limits. A more automated approach could reject values based on rate of change or knowledge of physical constraints that would lead to elimination of data rows. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove bad data values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fewer outliers as shown with line and box plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a line plot of the data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a box plot of the data "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![idea](https://apmonitor.com/che263/uploads/Begin_Python/idea.png)\n",
    "\n",
    "### Pair Plot\n",
    "\n",
    "A pair plot shows the correlation between variables.\n",
    "\n",
    "```python\n",
    "sns.pairplot(data)\n",
    "```\n",
    "\n",
    "It has bar distributions on the diagonal and scatter plots on the off-diagonal. A pair plot also shows a different color (`hue`) by category `ID`. Pair plots show correlations between pairs of variables that may be related and gives a good indication of features (explanatory inputs) that are used for classification or regression. Reduce data by 10x to help with plot speed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a pair plot with reduced data set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![idea](https://apmonitor.com/che263/uploads/Begin_Python/idea.png)\n",
    "\n",
    "### Joint Plot\n",
    "\n",
    "A joint plot shows two variables, with the univariate and joint distributions.\n",
    "\n",
    "```python\n",
    "sns.jointplot(x='MaxVD',y='RUL',data=data,kind=\"kde\")\n",
    "```\n",
    "\n",
    "Try `kind='reg'`, `'kde'`, and `'hex'` to see different joint plot styles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-22T19:08:17.984436Z",
     "start_time": "2021-01-22T19:08:14.233566Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create a joint plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a correlation heat map\n",
    "\n",
    "```python\n",
    "plt.figure(figsize=(10,8))\n",
    "cor = data.corr()\n",
    "sns.heatmap(cor, annot=True,cmap=plt.cm.Reds)\n",
    "plt.show()\n",
    "```\n",
    "\n",
    "to examine the correlation among the variables. Which have the strongest correlation to `RUL`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-22T19:08:21.912049Z",
     "start_time": "2021-01-22T19:08:21.333592Z"
    }
   },
   "outputs": [],
   "source": [
    "# Calculate the data correlation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualize the correlation "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Regression\n",
    "\n",
    "The is objective is to minimize a loss function such as a sum of squared errors between the measured and predicted values:\n",
    "\n",
    "$Loss = \\sum_{i=1}^{n}\\left(y_i-z_i\\right)^2$\n",
    "\n",
    "where `n` is the number of observations. Regression requires labelled data (output values) for training."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![idea](https://apmonitor.com/che263/uploads/Begin_Python/idea.png)\n",
    "\n",
    "### Linear Regression\n",
    "\n",
    "There are many model forms such as linear, polynomial, and nonlinear. A familiar linear model is a line with slope `a` and intercept `b` with `y = a x + b`.   \n",
    "    \n",
    "```python\n",
    "x = data['MaxVD'].values\n",
    "z = data['RUL'].values\n",
    "p1 = np.polyfit(x,z,1)\n",
    "```\n",
    "    \n",
    "A simple method for linear regression is with `numpy` to fit `p=np.polyfit(x,y,1)` and evaluate `np.polyval(p,x)` the model. Determine the slope and intercept that minimize the sum of squared errors (least squares) between the predicted `lnMFR` and measured `lnMFR` output using `H2R` as the input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-22T19:07:45.796466Z",
     "start_time": "2021-01-22T19:07:45.546468Z"
    }
   },
   "outputs": [],
   "source": [
    "# Linear regression with one feature"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![idea](https://apmonitor.com/che263/uploads/Begin_Python/idea.png)\n",
    "\n",
    "### Multiple Linear Regression\n",
    "\n",
    "Multiple linear regression uses more than one feature to predict the label."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-22T19:07:45.811467Z",
     "start_time": "2021-01-22T19:07:45.799467Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create the features and label for multiple linear regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`statsmodels` performs standard Ordinary Least Squares (OLS) analysis with an informative report summary.\n",
    "\n",
    "```python\n",
    "import statsmodels.api as sm\n",
    "xc = sm.add_constant(x)\n",
    "model = sm.OLS(z,xc).fit()\n",
    "predictions = model.predict(xc)\n",
    "model.summary()\n",
    "```\n",
    "\n",
    "The input `x` is augmented with a ones column so that it also predicts the intercept. This is accomplished with `xc=sm.add_constant(x)`. Perform a multiple linear regression with all of the data columns to predict `lnMFR`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-22T19:07:47.669826Z",
     "start_time": "2021-01-22T19:07:45.814471Z"
    }
   },
   "outputs": [],
   "source": [
    "# Linear regression with multiple features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scale Data\n",
    "\n",
    "Many regression algorithms require scaled data to perform well (e.g. Artificial Neural Networks). Scale data with the Standard Scalar from scikit-learn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-22T19:07:43.156052Z",
     "start_time": "2021-01-22T19:07:40.498430Z"
    }
   },
   "outputs": [],
   "source": [
    "# Scale data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The value `ds` is returned as a `numpy` array so we need to convert it back to a `pandas` `DataFrame`.\n",
    "\n",
    "```python\n",
    "ds = pd.DataFrame(ds,columns=data.columns)\n",
    "```\n",
    "\n",
    "Re-use the column names from `data`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-22T19:07:43.188051Z",
     "start_time": "2021-01-22T19:07:43.160051Z"
    }
   },
   "outputs": [],
   "source": [
    "# Restore ID value (unscaled)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![idea](https://apmonitor.com/che263/uploads/Begin_Python/idea.png)\n",
    "\n",
    "### Divide Data\n",
    "\n",
    "Data is divided into train and test sets to separate a fraction of the rows for evaluating classification or regression models. A typical split is 80% for training and 20% for testing, although the range depends on how much data is available and the objective of the study."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `train_test_split` is a function in `sklearn` for the specific purpose of splitting data into train and test sets.\n",
    "\n",
    "```python\n",
    "from sklearn.model_selection import train_test_split\n",
    "train,test = train_test_split(ds, test_size=0.2, shuffle=True)\n",
    "```\n",
    "\n",
    "There are options such as `shuffle=True` to randomize the selection in each set. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-22T19:07:43.295196Z",
     "start_time": "2021-01-22T19:07:43.194053Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Split data - method 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this data set, it is better to split by battery ID than randomly. Otherwise, data from all batteries are used for training and testing. A split by battery ID is better to observe the test performance on battery data not used for training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split data - method 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Select Best Features\n",
    "\n",
    "Rank the features to determine the best set that predicts `RUL`. There is additional information on [Select K Best Features](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectKBest.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select features and label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-01-22T19:07:48.075495Z",
     "start_time": "2021-01-22T19:07:47.673827Z"
    }
   },
   "outputs": [],
   "source": [
    "# Determine the features with the highest correlation to the label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove lowest scoring features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![exercise](https://apmonitor.com/che263/uploads/Begin_Python/exercise.png)\n",
    "\n",
    "### Regression\n",
    "\n",
    "Machine learning is computer algorithms and statistical models that rely on patterns and inference. They perform a specific task without explicit instructions. Machine learned regression models can be as simple as linear regression or as complex as deep learning. This tutorial demonstrates several regression methods with `scikit-learn` and the `lazypredict` package."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pip install lazypredict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Evaluate many regressors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# predict with kernel ridge regressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# predict with linear regressor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### View Remaining Useful Life (Unscaled) on Test Batteries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# view RUL on test batteries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### View Remaining Useful Life on Training Data Batteries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# view RUL on training batteries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Regression with PyTorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# regression with PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Regression with Keras / TensorFlow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# regression with TensorFlow / Keras"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}