regression_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pathlib import Path\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regression Analysis: Seasonal Effects with Sklearn Linear Regression\n",
    "In this notebook, you will build a SKLearn linear regression model to predict Yen futures (\"settle\") returns with *lagged* CAD/JPY exchange rate returns. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>Price</th>\n",
       "      <th>Open</th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1982-01-05</th>\n",
       "      <td>184.65</td>\n",
       "      <td>184.65</td>\n",
       "      <td>184.65</td>\n",
       "      <td>184.65</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1982-01-06</th>\n",
       "      <td>185.06</td>\n",
       "      <td>185.06</td>\n",
       "      <td>185.06</td>\n",
       "      <td>185.06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1982-01-07</th>\n",
       "      <td>186.88</td>\n",
       "      <td>186.88</td>\n",
       "      <td>186.88</td>\n",
       "      <td>186.88</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1982-01-08</th>\n",
       "      <td>186.58</td>\n",
       "      <td>186.58</td>\n",
       "      <td>186.58</td>\n",
       "      <td>186.58</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1982-01-11</th>\n",
       "      <td>187.64</td>\n",
       "      <td>187.64</td>\n",
       "      <td>187.64</td>\n",
       "      <td>187.64</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Price    Open    High     Low\n",
       "Date                                      \n",
       "1982-01-05  184.65  184.65  184.65  184.65\n",
       "1982-01-06  185.06  185.06  185.06  185.06\n",
       "1982-01-07  186.88  186.88  186.88  186.88\n",
       "1982-01-08  186.58  186.58  186.58  186.58\n",
       "1982-01-11  187.64  187.64  187.64  187.64"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Currency pair exchange rates for CAD/JPY\n",
    "cad_jpy_df = pd.read_csv(\n",
    "    Path(\"cad_jpy.csv\"), index_col=\"Date\", infer_datetime_format=True, parse_dates=True\n",
    ")\n",
    "cad_jpy_df.head()"
   ]
  },
  {
   "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>Price</th>\n",
       "      <th>Open</th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1990-01-02</th>\n",
       "      <td>126.37</td>\n",
       "      <td>126.31</td>\n",
       "      <td>126.37</td>\n",
       "      <td>126.31</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1990-01-03</th>\n",
       "      <td>125.30</td>\n",
       "      <td>125.24</td>\n",
       "      <td>125.30</td>\n",
       "      <td>125.24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1990-01-04</th>\n",
       "      <td>123.46</td>\n",
       "      <td>123.41</td>\n",
       "      <td>123.46</td>\n",
       "      <td>123.41</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1990-01-05</th>\n",
       "      <td>124.54</td>\n",
       "      <td>124.48</td>\n",
       "      <td>124.54</td>\n",
       "      <td>124.48</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1990-01-08</th>\n",
       "      <td>124.27</td>\n",
       "      <td>124.21</td>\n",
       "      <td>124.27</td>\n",
       "      <td>124.21</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Price    Open    High     Low\n",
       "Date                                      \n",
       "1990-01-02  126.37  126.31  126.37  126.31\n",
       "1990-01-03  125.30  125.24  125.30  125.24\n",
       "1990-01-04  123.46  123.41  123.46  123.41\n",
       "1990-01-05  124.54  124.48  124.54  124.48\n",
       "1990-01-08  124.27  124.21  124.27  124.21"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Trim the dataset to begin on January 1st, 1990\n",
    "cad_jpy_df = cad_jpy_df.loc[\"1990-01-01\":, :]\n",
    "cad_jpy_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>Price</th>\n",
       "      <th>Open</th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "      <th>Return</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-05-29</th>\n",
       "      <td>78.29</td>\n",
       "      <td>78.21</td>\n",
       "      <td>78.41</td>\n",
       "      <td>77.75</td>\n",
       "      <td>0.076697</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-06-01</th>\n",
       "      <td>79.27</td>\n",
       "      <td>78.21</td>\n",
       "      <td>79.36</td>\n",
       "      <td>78.04</td>\n",
       "      <td>1.251756</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-06-02</th>\n",
       "      <td>80.40</td>\n",
       "      <td>79.26</td>\n",
       "      <td>80.56</td>\n",
       "      <td>79.15</td>\n",
       "      <td>1.425508</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-06-03</th>\n",
       "      <td>80.70</td>\n",
       "      <td>80.40</td>\n",
       "      <td>80.82</td>\n",
       "      <td>79.96</td>\n",
       "      <td>0.373134</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-06-04</th>\n",
       "      <td>80.71</td>\n",
       "      <td>80.80</td>\n",
       "      <td>80.89</td>\n",
       "      <td>80.51</td>\n",
       "      <td>0.012392</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Price   Open   High    Low    Return\n",
       "Date                                            \n",
       "2020-05-29  78.29  78.21  78.41  77.75  0.076697\n",
       "2020-06-01  79.27  78.21  79.36  78.04  1.251756\n",
       "2020-06-02  80.40  79.26  80.56  79.15  1.425508\n",
       "2020-06-03  80.70  80.40  80.82  79.96  0.373134\n",
       "2020-06-04  80.71  80.80  80.89  80.51  0.012392"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a series using \"Price\" percentage returns, drop any nan\"s, and check the results:\n",
    "# (Make sure to multiply the pct_change() results by 100)\n",
    "# In this case, you may have to replace inf, -inf values with np.nan\"s\n",
    "returns = (cad_jpy_df[[\"Price\"]].pct_change() * 100)\n",
    "returns = returns.rename(columns={'Price':'Return'})\n",
    "cad_jpy_returns_df = pd.concat([cad_jpy_df, returns], axis=1, join='outer')\n",
    "cad_jpy_returns_df = cad_jpy_returns_df.replace(-np.inf, np.nan).dropna()\n",
    "cad_jpy_returns_df.tail()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lagged Returns "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>Price</th>\n",
       "      <th>Open</th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "      <th>Return</th>\n",
       "      <th>Lagged_Return</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-05-29</th>\n",
       "      <td>78.29</td>\n",
       "      <td>78.21</td>\n",
       "      <td>78.41</td>\n",
       "      <td>77.75</td>\n",
       "      <td>0.076697</td>\n",
       "      <td>-0.114913</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-06-01</th>\n",
       "      <td>79.27</td>\n",
       "      <td>78.21</td>\n",
       "      <td>79.36</td>\n",
       "      <td>78.04</td>\n",
       "      <td>1.251756</td>\n",
       "      <td>0.076697</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-06-02</th>\n",
       "      <td>80.40</td>\n",
       "      <td>79.26</td>\n",
       "      <td>80.56</td>\n",
       "      <td>79.15</td>\n",
       "      <td>1.425508</td>\n",
       "      <td>1.251756</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-06-03</th>\n",
       "      <td>80.70</td>\n",
       "      <td>80.40</td>\n",
       "      <td>80.82</td>\n",
       "      <td>79.96</td>\n",
       "      <td>0.373134</td>\n",
       "      <td>1.425508</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-06-04</th>\n",
       "      <td>80.71</td>\n",
       "      <td>80.80</td>\n",
       "      <td>80.89</td>\n",
       "      <td>80.51</td>\n",
       "      <td>0.012392</td>\n",
       "      <td>0.373134</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Price   Open   High    Low    Return  Lagged_Return\n",
       "Date                                                           \n",
       "2020-05-29  78.29  78.21  78.41  77.75  0.076697      -0.114913\n",
       "2020-06-01  79.27  78.21  79.36  78.04  1.251756       0.076697\n",
       "2020-06-02  80.40  79.26  80.56  79.15  1.425508       1.251756\n",
       "2020-06-03  80.70  80.40  80.82  79.96  0.373134       1.425508\n",
       "2020-06-04  80.71  80.80  80.89  80.51  0.012392       0.373134"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a lagged return using the shift function\n",
    "cad_jpy_returns_df['Lagged_Return'] = cad_jpy_returns_df['Return'].shift()\n",
    "cad_jpy_returns_df = cad_jpy_returns_df.replace(-np.inf, np.nan).dropna()\n",
    "cad_jpy_returns_df.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train Test Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a train/test split for the data using 2018-2019 for testing and the rest for training\n",
    "train = cad_jpy_returns_df[:'2017']\n",
    "test = cad_jpy_returns_df['2018':]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create four dataframes:\n",
    "# X_train (training set using just the independent variables), X_test (test set of just the independent variables)\n",
    "# Y_train (training set using just the \"y\" variable, i.e., \"Futures Return\"), Y_test (test set of just the \"y\" variable):\n",
    "X_train = train[\"Lagged_Return\"].to_frame()\n",
    "X_test = test[\"Lagged_Return\"].to_frame()\n",
    "Y_train = train[\"Return\"]\n",
    "Y_test = test[\"Return\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>Lagged_Return</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1990-01-04</th>\n",
       "      <td>-0.846720</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1990-01-05</th>\n",
       "      <td>-1.468476</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1990-01-08</th>\n",
       "      <td>0.874777</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1990-01-09</th>\n",
       "      <td>-0.216798</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1990-01-10</th>\n",
       "      <td>0.667901</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Lagged_Return\n",
       "Date                     \n",
       "1990-01-04      -0.846720\n",
       "1990-01-05      -1.468476\n",
       "1990-01-08       0.874777\n",
       "1990-01-09      -0.216798\n",
       "1990-01-10       0.667901"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Preview the X_train data\n",
    "X_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Regression Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression()"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a Linear Regression model and fit it to the training data\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "# Fit a SKLearn linear regression using  just the training set (X_train, Y_train):\n",
    "model = LinearRegression()\n",
    "model.fit(X_train, Y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Make predictions using the Testing Data\n",
    "\n",
    "**Note:** We want to evaluate the model using data that it has never seen before, in this case: `X_test`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a prediction of \"y\" values using just the test dataset\n",
    "predictions = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assemble actual y data (Y_test) with predicted y data (from just above) into two columns in a dataframe:\n",
    "results = Y_test.to_frame()\n",
    "results[\"Predicted Return\"] = predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([<AxesSubplot:xlabel='Date'>, <AxesSubplot:xlabel='Date'>],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the first 20 predictions vs the true values\n",
    "results[:20].plot(subplots=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Out-of-Sample Performance\n",
    "\n",
    "Evaluate the model using \"out-of-sample\" data (`X_test` and `y_test`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Out-of-Sample Root Mean Squared Error (RMSE): 0.6445805658569028\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import mean_squared_error\n",
    "# Calculate the mean_squared_error (MSE) on actual versus predicted test \"y\" \n",
    "# (Hint: use the dataframe from above)\n",
    "mse = mean_squared_error(\n",
    "    results[\"Return\"],\n",
    "    results[\"Predicted Return\"]\n",
    ")\n",
    "\n",
    "# Using that mean-squared-error, calculate the root-mean-squared error (RMSE):\n",
    "rmse = np.sqrt(mse)\n",
    "print(f\"Out-of-Sample Root Mean Squared Error (RMSE): {rmse}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# In-Sample Performance\n",
    "\n",
    "Evaluate the model using in-sample data (X_train and y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In-sample Root Mean Squared Error (RMSE): 0.841994632894117\n"
     ]
    }
   ],
   "source": [
    "# Construct a dataframe using just the \"y\" training data:\n",
    "in_sample_results = Y_train.to_frame()\n",
    "\n",
    "# Add a column of \"in-sample\" predictions to that dataframe:  \n",
    "in_sample_results[\"In-sample Predictions\"] = model.predict(X_train)\n",
    "\n",
    "# Calculate in-sample mean_squared_error (for comparison to out-of-sample)\n",
    "in_sample_mse = mean_squared_error(\n",
    "    in_sample_results[\"Return\"],\n",
    "    in_sample_results[\"In-sample Predictions\"]\n",
    ")\n",
    "# Calculate in-sample root mean_squared_error (for comparison to out-of-sample)\n",
    "in_sample_rmse = np.sqrt(in_sample_mse)\n",
    "print(f\"In-sample Root Mean Squared Error (RMSE): {in_sample_rmse}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question:** Does this model perform better or worse on out-of-sample data as compared to in-sample data?\n",
    "\n",
    "**Answer:** The model performs better in out-of-sample vs in-sample due to its lower RMSE score."
   ]
  }
 ],
 "metadata": {
  "file_extension": ".py",
  "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.8.12"
  },
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "nbformat": 4,
 "nbformat_minor": 4
}