linear_model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import statsmodels.api as sm\n",
    "from sklearn.linear_model import PoissonRegressor, LinearRegression\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.model_selection import cross_val_score, KFold\n",
    "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load Data\n",
    "\n",
    "file_path = 'SeoulBikeData.csv'\n",
    "\n",
    "try:\n",
    "    df = pd.read_csv(file_path, encoding='utf-8')\n",
    "except UnicodeDecodeError:\n",
    "    try:\n",
    "        df = pd.read_csv(file_path, encoding='ISO-8859-1')\n",
    "    except UnicodeDecodeError:\n",
    "        df = pd.read_csv(file_path, encoding='cp1252')\n",
    "        \n",
    "# One-hot encoding for categorical columns\n",
    "df = pd.get_dummies(df, columns=['Seasons', 'Holiday'])\n",
    "x = df.drop(columns=['Rented Bike Count', 'Date', 'Functioning Day', 'Holiday_No Holiday'])\n",
    "y = df[\"Rented Bike Count\"]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split the data into training and testing sets\n",
    "train_ratio = 0.70\n",
    "val_ratio = 0.15\n",
    "test_ratio = 0.15\n",
    "\n",
    "x_train, x_temp, y_train, y_temp = train_test_split(x, y, test_size=test_ratio, random_state=42)\n",
    "x_val, x_test, y_val, y_test = train_test_split(x_temp, y_temp, test_size=val_ratio/(1-test_ratio), random_state=42)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Absolute Error on Validation Set:  519.4656268199428\n",
      "Mean Absolute Error on Test Set:  498.56827780710773 \n",
      "\n",
      "Mean Squared Error on Validation Set:  424409.64234197966\n",
      "Mean Squared Error on Test Set:  359721.9190784558 \n",
      "\n",
      "R2 on Validation Set:  -1.4603966105308785e-06\n",
      "R2 on Test Set:  -0.005570539743149805\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/nelidaschalichayllon/opt/anaconda3/lib/python3.9/site-packages/sklearn/linear_model/_linear_loss.py:290: RuntimeWarning: invalid value encountered in matmul\n",
      "  grad[:n_features] = X.T @ grad_pointwise + l2_reg_strength * weights\n"
     ]
    }
   ],
   "source": [
    "# Create and train the Poisson regression model\n",
    "poisson_model = PoissonRegressor()\n",
    "poisson_model.fit(x_train, y_train)\n",
    "\n",
    "# Make predictions\n",
    "poisson_val_pred = poisson_model.predict(x_val)\n",
    "poisson_test_pred = poisson_model.predict(x_test)\n",
    "\n",
    "# Evaluate the MAE\n",
    "mae_val = mean_absolute_error(y_val, poisson_val_pred)\n",
    "print(\"Mean Absolute Error on Validation Set: \", mae_val)\n",
    "mae_test = mean_absolute_error(y_test, poisson_test_pred)\n",
    "print(\"Mean Absolute Error on Test Set: \", mae_test, \"\\n\")\n",
    "\n",
    "# Evaluate the MSE\n",
    "mse_val = mean_squared_error(y_val, poisson_val_pred)\n",
    "print(\"Mean Squared Error on Validation Set: \", mse_val)\n",
    "mse_test = mean_squared_error(y_test, poisson_test_pred)\n",
    "print(\"Mean Squared Error on Test Set: \", mse_test, \"\\n\")\n",
    "\n",
    "# Evaluate the R2\n",
    "r2_val = r2_score(y_val, poisson_val_pred)\n",
    "print(\"R2 on Validation Set: \", r2_val)\n",
    "r2_test = r2_score(y_test, poisson_test_pred)\n",
    "print(\"R2 on Test Set: \", r2_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Squared Error on Validation Set:  221176.57687142235\n",
      "Mean Squared Error on Test Set:  176709.73285684062 \n",
      "\n",
      "Mean Absolute Error on Validation Set:  346.4958978604754\n",
      "Mean Absolute Error on Test Set:  323.54484353046854 \n",
      "\n",
      "R2 on Validation Set:  0.47885986129710456\n",
      "R2 on Test Set:  0.5060237032484924\n"
     ]
    }
   ],
   "source": [
    "# Create and train the Linear regression model\n",
    "linear_model = LinearRegression()\n",
    "linear_model.fit(x_train, y_train)\n",
    "\n",
    "# Make predictions\n",
    "linear_val_pred = linear_model.predict(x_val)\n",
    "linear_test_pred = linear_model.predict(x_test)\n",
    "\n",
    "# Evaluate the MSE\n",
    "mse_val = mean_squared_error(y_val, linear_val_pred)\n",
    "print(\"Mean Squared Error on Validation Set: \", mse_val)\n",
    "mse_test = mean_squared_error(y_test, linear_test_pred)\n",
    "print(\"Mean Squared Error on Test Set: \", mse_test, \"\\n\")\n",
    "\n",
    "# Evaluate the MAE\n",
    "mae_val = mean_absolute_error(y_val, linear_val_pred)\n",
    "print(\"Mean Absolute Error on Validation Set: \", mae_val)\n",
    "mae_test = mean_absolute_error(y_test, linear_test_pred)\n",
    "print(\"Mean Absolute Error on Test Set: \", mae_test, \"\\n\")\n",
    "\n",
    "# Evaluate the R2\n",
    "r2_val = r2_score(y_val, linear_val_pred)\n",
    "print(\"R2 on Validation Set: \", r2_val)\n",
    "r2_test = r2_score(y_test, linear_test_pred)\n",
    "print(\"R2 on Test Set: \", r2_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Absolute Error on Validation Set:  306.4216391811798\n",
      "Mean Absolute Error on Test Set:  276.5346885526115 \n",
      "\n",
      "Mean Squared Error on Validation Set:  210408.23857721465\n",
      "Mean Squared Error on Test Set:  160528.03752362484 \n",
      "\n",
      "R2 on Validation Set:  0.5042324092930229\n",
      "R2 on Test Set:  0.5512581892421917\n"
     ]
    }
   ],
   "source": [
    "# Create and train the Negative Binomial regression model\n",
    "nb = sm.GLM(y_train, x_train, family=sm.families.NegativeBinomial())\n",
    "nb_model = nb.fit()\n",
    "\n",
    "# Make predictions\n",
    "nb_val_pred = nb_model.predict(x_val)\n",
    "nb_test_pred = nb_model.predict(x_test)\n",
    "\n",
    "# Evaluate the MAE\n",
    "mae_val = mean_absolute_error(y_val, nb_val_pred)\n",
    "print(\"Mean Absolute Error on Validation Set: \", mae_val)\n",
    "mae_test = mean_absolute_error(y_test, nb_test_pred)\n",
    "print(\"Mean Absolute Error on Test Set: \", mae_test, \"\\n\")\n",
    "\n",
    "# Evaluate the MSE\n",
    "mse_val = mean_squared_error(y_val, nb_val_pred)\n",
    "print(\"Mean Squared Error on Validation Set: \", mse_val)\n",
    "mse_test = mean_squared_error(y_test, nb_test_pred)\n",
    "print(\"Mean Squared Error on Test Set: \", mse_test, \"\\n\")\n",
    "\n",
    "# Evaluate the R2\n",
    "r2_val = r2_score(y_val, nb_val_pred)\n",
    "print(\"R2 on Validation Set: \", r2_val)\n",
    "r2_test = r2_score(y_test, nb_test_pred)\n",
    "print(\"R2 on Test Set: \", r2_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "kfold = KFold(n_splits=5, shuffle=True, random_state=42)\n",
    "scores = cross_val_score(linear_model, x_train, y_train, cv=kfold, scoring='neg_mean_absolute_error')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our Negative Binomial Regression Model gave us the best fit as seen by the MAE and other evaluations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([  1.,   0.,   1.,   4.,   2.,   8.,   4.,   8.,   3.,  14.,  12.,\n",
       "         25.,  24.,  37.,  63.,  81., 157., 270., 136.,  98.,  49.,  24.,\n",
       "         18.,  13.,  12.,   5.,   6.,   2.,   4.,   1.]),\n",
       " array([-2250.58287449, -2118.84057967, -1987.09828486, -1855.35599004,\n",
       "        -1723.61369522, -1591.8714004 , -1460.12910558, -1328.38681076,\n",
       "        -1196.64451595, -1064.90222113,  -933.15992631,  -801.41763149,\n",
       "         -669.67533667,  -537.93304185,  -406.19074704,  -274.44845222,\n",
       "         -142.7061574 ,   -10.96386258,   120.77843224,   252.52072706,\n",
       "          384.26302187,   516.00531669,   647.74761151,   779.48990633,\n",
       "          911.23220115,  1042.97449597,  1174.71679078,  1306.4590856 ,\n",
       "         1438.20138042,  1569.94367524,  1701.68597006]),\n",
       " <BarContainer object of 30 artists>)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(nb_val_pred - y_val, bins=30, alpha=0.7, color='blue', edgecolor='black')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8158   -0.287459\n",
      "8493    0.029572\n",
      "5403   -0.018804\n",
      "6050    0.142756\n",
      "8396   -0.026617\n",
      "          ...   \n",
      "503     0.220646\n",
      "8168         inf\n",
      "3071    1.426940\n",
      "8476    3.322223\n",
      "3689   -0.409082\n",
      "Length: 1082, dtype: float64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([  5.,  27.,  58.,  92., 139., 126., 117.,  94.,  65.,  42.,  31.,\n",
       "         29.,  26.,  24.,  18.,  15.,  17.,  12.,   8.,   9.,   9.,   7.,\n",
       "          5.,   2.,   6.,   2.,   4.,   2.,   3.,   3.,   2.,   1.,   0.,\n",
       "          0.,   2.,   2.,   1.,   0.,   2.,   0.,   0.,   2.,   0.,   0.,\n",
       "          0.,   0.,   1.,   0.,   0.,   1.,   1.,   1.,   4.,   0.,   0.,\n",
       "          0.,   0.,   0.,   1.,   1.]),\n",
       " array([-0.90539378, -0.75697055, -0.60854732, -0.46012409, -0.31170086,\n",
       "        -0.16327763, -0.0148544 ,  0.13356883,  0.28199205,  0.43041528,\n",
       "         0.57883851,  0.72726174,  0.87568497,  1.0241082 ,  1.17253143,\n",
       "         1.32095466,  1.46937789,  1.61780112,  1.76622435,  1.91464758,\n",
       "         2.06307081,  2.21149404,  2.35991727,  2.5083405 ,  2.65676373,\n",
       "         2.80518696,  2.95361019,  3.10203342,  3.25045665,  3.39887988,\n",
       "         3.54730311,  3.69572634,  3.84414957,  3.9925728 ,  4.14099603,\n",
       "         4.28941926,  4.43784249,  4.58626572,  4.73468895,  4.88311218,\n",
       "         5.03153541,  5.17995864,  5.32838187,  5.47680509,  5.62522832,\n",
       "         5.77365155,  5.92207478,  6.07049801,  6.21892124,  6.36734447,\n",
       "         6.5157677 ,  6.66419093,  6.81261416,  6.96103739,  7.10946062,\n",
       "         7.25788385,  7.40630708,  7.55473031,  7.70315354,  7.85157677,\n",
       "         8.        ]),\n",
       " <BarContainer object of 60 artists>)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGdCAYAAAA44ojeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAnBklEQVR4nO3df3TU1Z3/8dcYmMmQkwQTYMYpwUY3rpZQf4DLabAlHiAeyo/1sC1rYym7dfdggWgMimRpt6lnSRQLZk+ypBuPR6icLP5Rteye7Upsu6E0yxqDWAVX1i/pMAIxaTYnk8B0JhM+3z88jI6ZJAQmmTvJ83HO5xzn3jsz72EYeZ37uZ/7sVmWZQkAAMAg1yW6AAAAgM8joAAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjDMl0QVcjUuXLuncuXNKT0+XzWZLdDkAAOAKWJal3t5eeTweXXfd8HMkSRlQzp07p5ycnESXAQAAroLP59Ps2bOHHZOUASU9PV3SJx8wIyMjwdUAAIAr4ff7lZOTE/l3fDhJGVAun9bJyMggoAAAkGSuZHkGi2QBAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOOMOqAcPnxYq1atksfjkc1m02uvvTbk2A0bNshms6m6ujqqPRgMqqSkRDNmzFBaWppWr16tjz76aLSlAACACWrUAeXChQu6/fbbVVtbO+y41157Tf/93/8tj8czqK+0tFSvvvqqDhw4oCNHjqivr08rV67UwMDAaMsBAAAT0Ki3ul++fLmWL18+7JizZ89q8+bNev3117VixYqovp6eHr3wwgt66aWXtHTpUknS/v37lZOTozfeeEP33XffaEsCAAATTNzXoFy6dEnr1q3TE088oblz5w7qb21tVX9/v4qKiiJtHo9H+fn5am5ujvmawWBQfr8/6gAAABNX3APKM888oylTpuiRRx6J2d/e3i673a7rr78+qt3lcqm9vT3mc6qqqpSZmRk5cnJy4l02AAAwSFzvZtza2qp//Md/1LFjx67oToWfZVnWkM8pLy9XWVlZ5PHl2zVPNJ2dnUPODmVkZGjmzJnjXBEAAIkR14Dym9/8Rh0dHZozZ06kbWBgQFu2bFF1dbV+//vfy+12KxQKqbu7O2oWpaOjQwUFBTFf1+FwyOFwxLNU43R2dqq4+Hvq6grG7M/OdqihoY6QAgCYFOIaUNatWxdZ+HrZfffdp3Xr1umv//qvJUnz58/X1KlT1djYqLVr10qSzp8/r/fee087d+6MZzlJxe/3q6srKIdji5zO6NmhQMCnrq5d8vv9BBQAwKQw6oDS19enDz/8MPK4ra1Nx48fV1ZWlubMmaPs7Oyo8VOnTpXb7daf/umfSpIyMzP10EMPacuWLcrOzlZWVpYef/xxzZs3b1C4mYyczhylpd08qD0Ye2IFAIAJadQB5a233tK9994beXx5bcj69eu1d+/eK3qN5557TlOmTNHatWsVCAS0ZMkS7d27VykpKaMtBwAATECjDiiFhYWyLOuKx//+978f1JaamqqamhrV1NSM9u0BAMAkwL14AACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgnCmJLgBXpr8/KK/XO2R/RkaGZs6cOY4VAQAwdggoSSAU6pLXe1olJU/L4XDEHJOd7VBDQx0hBQAwIRBQksDAQJ/CYbvs9sc0ffotg/oDAZ+6unbJ7/cTUAAAEwIBJYmkps5WWtrNMfuCwXEuBgCAMcQiWQAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOKMOKIcPH9aqVavk8Xhks9n02muvRfr6+/v15JNPat68eUpLS5PH49F3vvMdnTt3Luo1gsGgSkpKNGPGDKWlpWn16tX66KOPrvnDAACAiWHUAeXChQu6/fbbVVtbO6jv4sWLOnbsmH7wgx/o2LFjeuWVV3Tq1CmtXr06alxpaaleffVVHThwQEeOHFFfX59WrlypgYGBq/8kAABgwhj1VvfLly/X8uXLY/ZlZmaqsbExqq2mpkZ/9md/pjNnzmjOnDnq6enRCy+8oJdeeklLly6VJO3fv185OTl64403dN99913FxwAAABPJmK9B6enpkc1m0/Tp0yVJra2t6u/vV1FRUWSMx+NRfn6+mpubY75GMBiU3++POgAAwMQ1pgHlj3/8o7Zt26bi4mJlZGRIktrb22W323X99ddHjXW5XGpvb4/5OlVVVcrMzIwcOTk5Y1k2AABIsDELKP39/XrggQd06dIl7dmzZ8TxlmXJZrPF7CsvL1dPT0/k8Pl88S4XAAAYZEwCSn9/v9auXau2tjY1NjZGZk8kye12KxQKqbu7O+o5HR0dcrlcMV/P4XAoIyMj6gAAABNX3APK5XDyv//7v3rjjTeUnZ0d1T9//nxNnTo1ajHt+fPn9d5776mgoCDe5QAAgCQ06qt4+vr69OGHH0Yet7W16fjx48rKypLH49E3vvENHTt2TP/2b/+mgYGByLqSrKws2e12ZWZm6qGHHtKWLVuUnZ2trKwsPf7445o3b17kqh4AADC5jTqgvPXWW7r33nsjj8vKyiRJ69evV0VFhQ4ePChJuuOOO6Ke9+tf/1qFhYWSpOeee05TpkzR2rVrFQgEtGTJEu3du1cpKSlX+TEAAMBEMuqAUlhYKMuyhuwfru+y1NRU1dTUqKamZrRvDwAAJoFRBxSYqb8/KK/XG7MvIyNDM2fOHOeKAAC4egSUCSAU6pLXe1olJU/L4XAM6s/OdqihoY6QAgBIGgSUCWBgoE/hsF12+2OaPv2WqL5AwKeurl3y+/0EFABA0iCgTCCpqbOVlnbzoPZgMAHFAABwDcb8XjwAAACjRUABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHFGHVAOHz6sVatWyePxyGaz6bXXXovqtyxLFRUV8ng8cjqdKiws1IkTJ6LGBINBlZSUaMaMGUpLS9Pq1av10UcfXdMHAQAAE8eoA8qFCxd0++23q7a2Nmb/zp07tXv3btXW1qqlpUVut1vLli1Tb29vZExpaaleffVVHThwQEeOHFFfX59WrlypgYGBq/8kAABgwpgy2icsX75cy5cvj9lnWZaqq6u1fft2rVmzRpK0b98+uVwuNTQ0aMOGDerp6dELL7ygl156SUuXLpUk7d+/Xzk5OXrjjTd03333XcPHAQAAE0Fc16C0tbWpvb1dRUVFkTaHw6HFixerublZktTa2qr+/v6oMR6PR/n5+ZExnxcMBuX3+6MOAAAwccU1oLS3t0uSXC5XVLvL5Yr0tbe3y2636/rrrx9yzOdVVVUpMzMzcuTk5MSzbAAAYJgxuYrHZrNFPbYsa1Db5w03pry8XD09PZHD5/PFrVYAAGCeuAYUt9stSYNmQjo6OiKzKm63W6FQSN3d3UOO+TyHw6GMjIyoAwAATFxxDSi5ublyu91qbGyMtIVCITU1NamgoECSNH/+fE2dOjVqzPnz5/Xee+9FxgAAgMlt1Ffx9PX16cMPP4w8bmtr0/Hjx5WVlaU5c+aotLRUlZWVysvLU15eniorKzVt2jQVFxdLkjIzM/XQQw9py5Ytys7OVlZWlh5//HHNmzcvclUPAACY3EYdUN566y3de++9kcdlZWWSpPXr12vv3r3aunWrAoGANm7cqO7ubi1cuFCHDh1Senp65DnPPfecpkyZorVr1yoQCGjJkiXau3evUlJS4vCRAABAsht1QCksLJRlWUP222w2VVRUqKKiYsgxqampqqmpUU1NzWjfHgAATALciwcAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgEFAAAYJxR74OC5NPfH5TX6x2yPyMjQzNnzhzHigAAGB4BZYILhbrk9Z5WScnTcjgcMcdkZzvU0FBHSAEAGIOAMsENDPQpHLbLbn9M06ffMqg/EPCpq2uX/H4/AQUAYAwCyiSRmjpbaWk3x+wLBse5GAAARsAiWQAAYBxmUMZRZ2en/H5/zD6v16twODzOFQEAYCYCyjjp7OxUcfH31NUV+3xKMHhBPt/HyszkfAsAAASUceL3+9XVFZTDsUVOZ86g/u7uowqHdygcHkhAdQAAmIWAMs6czpyYi1UDgaH3KQEAYLJhkSwAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGCcuAeUcDis73//+8rNzZXT6dRNN92kp556SpcuXYqMsSxLFRUV8ng8cjqdKiws1IkTJ+JdCgAASFJxDyjPPPOMfvKTn6i2tlbvv/++du7cqWeffVY1NTWRMTt37tTu3btVW1urlpYWud1uLVu2TL29vfEuBwAAJKG4B5T/+q//0p//+Z9rxYoV+uIXv6hvfOMbKioq0ltvvSXpk9mT6upqbd++XWvWrFF+fr727dunixcvqqGhId7lAACAJBT3gHLPPffol7/8pU6dOiVJeuedd3TkyBF9/etflyS1tbWpvb1dRUVFkec4HA4tXrxYzc3NMV8zGAzK7/dHHQAAYOKaEu8XfPLJJ9XT06Nbb71VKSkpGhgY0I4dO/Stb31LktTe3i5JcrlcUc9zuVzyer0xX7Oqqko/+tGP4l0qAAAwVNxnUF5++WXt379fDQ0NOnbsmPbt26cf//jH2rdvX9Q4m80W9diyrEFtl5WXl6unpydy+Hy+eJcNAAAMEvcZlCeeeELbtm3TAw88IEmaN2+evF6vqqqqtH79erndbkmfzKTccMMNked1dHQMmlW5zOFwyOFwxLtUAABgqLjPoFy8eFHXXRf9sikpKZHLjHNzc+V2u9XY2BjpD4VCampqUkFBQbzLAQAASSjuMyirVq3Sjh07NGfOHM2dO1dvv/22du/ere9+97uSPjm1U1paqsrKSuXl5SkvL0+VlZWaNm2aiouL410OAABIQnEPKDU1NfrBD36gjRs3qqOjQx6PRxs2bNDf//3fR8Zs3bpVgUBAGzduVHd3txYuXKhDhw4pPT093uUAAIAkFPeAkp6erurqalVXVw85xmazqaKiQhUVFfF+ewAAMAFwLx4AAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAONMSXQBSLz+/qC8Xu+Q/RkZGZo5c+Y4VgQAmOwIKJNcKNQlr/e0SkqelsPhiDkmO9uhhoY6QgoAYNwQUCa5gYE+hcN22e2Pafr0Wwb1BwI+dXXtkt/vJ6AAAMYNAQWSpNTU2UpLuzlmXzA4zsUAACY9FskCAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADDOmASUs2fP6tvf/rays7M1bdo03XHHHWptbY30W5aliooKeTweOZ1OFRYW6sSJE2NRCgAASEJxDyjd3d1atGiRpk6dql/84hc6efKkdu3apenTp0fG7Ny5U7t371Ztba1aWlrkdru1bNky9fb2xrscAACQhOK+D8ozzzyjnJwcvfjii5G2L37xi5H/tixL1dXV2r59u9asWSNJ2rdvn1wulxoaGrRhw4Z4lwQAAJJM3GdQDh48qAULFuib3/ymZs2apTvvvFPPP/98pL+trU3t7e0qKiqKtDkcDi1evFjNzc0xXzMYDMrv90cdAABg4op7QDl9+rTq6uqUl5en119/XQ8//LAeeeQR/fSnP5Uktbe3S5JcLlfU81wuV6Tv86qqqpSZmRk5cnJy4l02AAAwSNwDyqVLl3TXXXepsrJSd955pzZs2KC//du/VV1dXdQ4m80W9diyrEFtl5WXl6unpydy+Hy+eJcNAAAMEveAcsMNN+hLX/pSVNttt92mM2fOSJLcbrckDZot6ejoGDSrcpnD4VBGRkbUAQAAJq64B5RFixbpgw8+iGo7deqUbrzxRklSbm6u3G63GhsbI/2hUEhNTU0qKCiIdzkAACAJxf0qnscee0wFBQWqrKzU2rVr9eabb6q+vl719fWSPjm1U1paqsrKSuXl5SkvL0+VlZWaNm2aiouL413OuOvs7Iy5iNfr9SocDiegIgAAkk/cA8rdd9+tV199VeXl5XrqqaeUm5ur6upqPfjgg5ExW7duVSAQ0MaNG9Xd3a2FCxfq0KFDSk9Pj3c546qzs1PFxd9TV1dwUF8weEE+38fKzBzcBwAAosU9oEjSypUrtXLlyiH7bTabKioqVFFRMRZvnzB+v19dXUE5HFvkdEZfadTdfVTh8A6FwwMJqg4AgOQxJgFlsnM6c5SWdnNUWyDgTVA1AAAkH24WCAAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjENAAQAAxiGgAAAA4xBQAACAcQgoAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4UxJdAMzX3x+U1+uN2ZeRkaGZM2eOc0UAgImOgIJhhUJd8npPq6TkaTkcjkH92dkONTTUEVIAAHE15qd4qqqqZLPZVFpaGmmzLEsVFRXyeDxyOp0qLCzUiRMnxroUXIWBgT6Fw3bZ7Y9p+vTqqMPh2KKurqD8fn+iywQATDBjGlBaWlpUX1+vL3/5y1HtO3fu1O7du1VbW6uWlha53W4tW7ZMvb29Y1kOrkFq6mylpd0cdTidOYkuCwAwQY1ZQOnr69ODDz6o559/Xtdff32k3bIsVVdXa/v27VqzZo3y8/O1b98+Xbx4UQ0NDWNVDgAASCJjFlA2bdqkFStWaOnSpVHtbW1tam9vV1FRUaTN4XBo8eLFam5ujvlaweAnpxE+ewAAgIlrTBbJHjhwQMeOHVNLS8ugvvb2dkmSy+WKane5XENeKVJVVaUf/ehH8S8UAAAYKe4zKD6fT48++qj279+v1NTUIcfZbLaox5ZlDWq7rLy8XD09PZHD5/PFtWYAAGCWuM+gtLa2qqOjQ/Pnz4+0DQwM6PDhw6qtrdUHH3wg6ZOZlBtuuCEypqOjY9CsymUOhyPmJa4AAGBiivsMypIlS/Tuu+/q+PHjkWPBggV68MEHdfz4cd10001yu91qbGyMPCcUCqmpqUkFBQXxLgcAACShuM+gpKenKz8/P6otLS1N2dnZkfbS0lJVVlYqLy9PeXl5qqys1LRp01RcXBzvcgAAQBJKyE6yW7duVSAQ0MaNG9Xd3a2FCxfq0KFDSk9PT0Q5AADAMOMSUP7zP/8z6rHNZlNFRYUqKirG4+0BAECS4W7GAADAOAQUAABgHAIKAAAwDgEFAAAYh4ACAACMQ0ABAADGIaAAAADjEFAAAIBxCCgAAMA4BBQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAONMSXQBSG79/UF5vd4h+zMyMjRz5sxxrAgAMBEQUHDVQqEueb2nVVLytBwOR8wx2dkONTTUEVIAAKNCQMFVGxjoUzhsl93+mKZPv2VQfyDgU1fXLvn9fgIKAGBUCCi4Zqmps5WWdnPMvmBwnIsBAEwILJIFAADGYQYFY2q4RbQsoAUADIWAgjEz0iJaFtACAIZCQMGYGW4RLQtoAQDDIaBgzA21iJYFtACAobBIFgAAGIcZlFHq7OyU3++P2ef1ehUOh8e5IgAAJh4Cyih0dnaquPh76uqKfW4iGLwgn+9jZWZy7gIAgGtBQBkFv9+vrq6gHI4tcjpzBvV3dx9VOLxD4fBAAqpLPtzHBwAwFALKVXA6c2Iu+gwEhv7HFtG4jw8AYDgEFCQE9/EBAAyHgIKE4j4+AIBYuMwYAAAYh4ACAACMwykeGIsbDQLA5EVAgZG40SAATG4EFBiJGw0CwORGQIHRuNEgAExOLJIFAADGIaAAAADjxD2gVFVV6e6771Z6erpmzZql+++/Xx988EHUGMuyVFFRIY/HI6fTqcLCQp04cSLepQAAgCQV94DS1NSkTZs26ejRo2psbFQ4HFZRUZEuXLgQGbNz507t3r1btbW1amlpkdvt1rJly9Tb2xvvcgAAQBKK+yLZ//iP/4h6/OKLL2rWrFlqbW3V1772NVmWperqam3fvl1r1qyRJO3bt08ul0sNDQ3asGFDvEsCAABJZszXoPT09EiSsrKyJEltbW1qb29XUVFRZIzD4dDixYvV3Nw81uUAAIAkMKaXGVuWpbKyMt1zzz3Kz8+XJLW3t0uSXC5X1FiXyzXkrqHBYFDBz1xX6vf7x6hiAABggjGdQdm8ebN+97vf6V/+5V8G9dlstqjHlmUNarusqqpKmZmZkSMnJ2dM6gUAAGYYs4BSUlKigwcP6te//rVmz54daXe73ZI+nUm5rKOjY9CsymXl5eXq6emJHD6fb6zKBgAABoh7QLEsS5s3b9Yrr7yiX/3qV8rNzY3qz83NldvtVmNjY6QtFAqpqalJBQUFMV/T4XAoIyMj6gAAABNX3NegbNq0SQ0NDfr5z3+u9PT0yExJZmamnE6nbDabSktLVVlZqby8POXl5amyslLTpk1TcXFxvMsBAABJKO4Bpa6uTpJUWFgY1f7iiy/qr/7qryRJW7duVSAQ0MaNG9Xd3a2FCxfq0KFDSk9Pj3c5mKD6+4NDLqqWpIyMDG4kCABJLO4BxbKsEcfYbDZVVFSooqIi3m+PSSAU6pLXe1olJU/L4XDEHJOd7VBDQx0hBQCSFHczRtIZGOhTOGyX3f6Ypk+/ZVB/IOBTV9cu+f3+mAGls7Nz2EvVmX0BgMQjoCBppabOVlrazTH7PrNtTpTOzk4VF39PXV1DDBCzLwBgAgIKJhW/36+urqAcji1yOgfvpzPS7AsAYHwQUDApOZ05o559AQCMnzG/Fw8AAMBoMYOCCWmoy5C9Xq/C4XACKgIAjAYBBRPOcJchB4MX5PN9rMxMzuMAgMkIKJhwhrsMubv7qMLhHQqHBxJUHQDgShBQMGHFugw5EBh691kAgDlYJAsAAIxDQAEAAMYhoAAAAOMQUAAAgHFYJAt8zlB7qEjcSBAAxgsBBfiM4fZQkbiRIACMFwIK8BnD7aHCjQQBYPwQUIAYYu2hInEjQQAYLyySBQAAxiGgAAAA4xBQAACAcViDAsRRZ2en/H5/zL5QKCS73T7kc7mEGQA+RUAB4qSzs1PFxd9TV9fglbT9/UGdO9emL3zhTzRlSuyfHZcwA8CnCChAnPj9fnV1BeVwbJHTmRPV1919VIHADqWkPDLo8mWJS5gB4PMIKMAoDLfLrNfrVTgc1vTpOYMuUQ4EPnnOUJcvS1zCDACfRUABrtBIu8wGgxfk832szEySBgBcKwIKcIWG22VW+uQ0Tji8Q+HwQAKqA4CJhYACjNJQp2kun8a5WtykEAA+RUABDMBNCgEgGgEFMMBY3qRwuL1ZJGZnAJiJgAIYJN43KRxub5bLmJ0BYCICCjCBDbc3i8T+KwDMRUCJYagp8cv7XADjbbgFtNLIp2mczsF7s1zG/isATERA+ZzhpsTZ5wKJMNICWonTNAAmHgLK54y0XTn7XGC8jbT/yliepmGBLfCp4X4P/Bbij4AyhFhT4te6zwVwLcZ7m3wW2AKfGun3wG8h/ggoAGJigS3wqeF+D/wWxgYBBcCwrnaB7Uinh0KhkOx2e8w+psthqqF+Dyw2jz8CCoC4G2k6vL8/qHPn2vSFL/yJpkwZ/L8hpssBEFCACWCoy5Cv5NL4sXruxx9fUFrakzFPD3V3H1UgsEMpKY/E3Dm3vb1S7777rm688caY7ztWMyyJmvUZy8XILHRGsiKgAEluuMuQR7o0fqyfe/vts4a9sWKshb+Juqw6UbM+Y7kYmYXOSGYJDSh79uzRs88+q/Pnz2vu3Lmqrq7WV7/61USWBCSd4S5DHunS+EQ992o/jzR2CxJHWhQ80qzP1dY0louRWeiMZJawgPLyyy+rtLRUe/bs0aJFi/TP//zPWr58uU6ePKk5c+YkqiwgacWajbjSS+MT9dzRvu5lfX1D76x7racshloEOdysz0g1XUldY7nbr4k7CY/VniLXcppuuL5k3Ul8uD+P4T6vlPjTfwkLKLt379ZDDz2kv/mbv5EkVVdX6/XXX1ddXZ2qqqoSVRYAw410CigRpyzY7Xd0xmpPkWs5TTfSKbxk3El8uD+PkT6vlPi/swkJKKFQSK2trdq2bVtUe1FRkZqbmweNDwaDCn4m5vf09EjSsCn5avX29mpgoF+9vf+jcLg3qu/Chf8nyxrQhQunNHXq4Knr4fqT8bmm1sVzJ/dz/f531N+fonB4tZzOL0T1hUJ/0LlzB3T06FHl5Aw+pTEcn8+nYPCPMX/7I9U1XE0j1TXS+wYCZxUMXtTJkyfV2zu4/1o+07W89rXw+Xw6d65HKSlrZbfPiOq71u9wqNf95LVP6uJFr4LBFbLbP/93Z+g+SQqHT6q//6fq6XlfNlsoqi9Rf44jGf7PefjPGwr9QR0dP9PZs2eHDN1X4/K/25ZljTzYSoCzZ89akqzf/va3Ue07duywbrnllkHjf/jDH1qSODg4ODg4OCbA4fP5RswKCV0ka7PZoh5bljWoTZLKy8tVVlYWeXzp0iX93//9n7Kzs2OOn4z8fr9ycnLk8/mUkZGR6HIgvhMT8Z2Yie/FPGP1nViWpd7eXnk8nhHHJiSgzJgxQykpKWpvb49q7+jokMvlGjTe4XAMmmKaPn36WJaYtDIyMviBG4bvxDx8J2biezHPWHwnmZmZVzTuuri+6xWy2+2aP3++Ghsbo9obGxtVUFCQiJIAAIBBEnaKp6ysTOvWrdOCBQv0la98RfX19Tpz5owefvjhRJUEAAAMkbCA8pd/+Zfq6urSU089pfPnzys/P1///u//PuTW1hiew+HQD3/4w7iutsa14TsxD9+JmfhezGPCd2KzrCu51gcAAGD8JGQNCgAAwHAIKAAAwDgEFAAAYBwCCgAAMA4BZQLYs2ePcnNzlZqaqvnz5+s3v/lNokua1KqqqnT33XcrPT1ds2bN0v33368PPvgg0WXhM6qqqmSz2VRaWproUia1s2fP6tvf/rays7M1bdo03XHHHWptbU10WZNWOBzW97//feXm5srpdOqmm27SU089pUuXLiWkHgJKknv55ZdVWlqq7du36+2339ZXv/pVLV++XGfOnEl0aZNWU1OTNm3apKNHj6qxsVHhcFhFRUW6cOFCokuDpJaWFtXX1+vLX/5yokuZ1Lq7u7Vo0SJNnTpVv/jFL3Ty5Ent2rWLXcIT6JlnntFPfvIT1dbW6v3339fOnTv17LPPqqamJiH1cJlxklu4cKHuuusu1dXVRdpuu+023X///aqqqkpgZbiss7NTs2bNUlNTk772ta8lupxJra+vT3fddZf27Nmjf/iHf9Add9yh6urqRJc1KW3btk2//e1vmfE1yMqVK+VyufTCCy9E2v7iL/5C06ZN00svvTTu9TCDksRCoZBaW1tVVFQU1V5UVKTm5uYEVYXP6+npkSRlZWUluBJs2rRJK1as0NKlSxNdyqR38OBBLViwQN/85jc1a9Ys3XnnnXr++ecTXdakds899+iXv/ylTp06JUl65513dOTIEX39619PSD0JvZsxrs0f/vAHDQwMDLrBosvlGnQjRiSGZVkqKyvTPffco/z8/ESXM6kdOHBAx44dU0tLS6JLgaTTp0+rrq5OZWVl+ru/+zu9+eabeuSRR+RwOPSd73wn0eVNSk8++aR6enp06623KiUlRQMDA9qxY4e+9a1vJaQeAsoEYLPZoh5bljWoDYmxefNm/e53v9ORI0cSXcqk5vP59Oijj+rQoUNKTU1NdDmQdOnSJS1YsECVlZWSpDvvvFMnTpxQXV0dASVBXn75Ze3fv18NDQ2aO3eujh8/rtLSUnk8Hq1fv37c6yGgJLEZM2YoJSVl0GxJR0fHoFkVjL+SkhIdPHhQhw8f1uzZsxNdzqTW2tqqjo4OzZ8/P9I2MDCgw4cPq7a2VsFgUCkpKQmscPK54YYb9KUvfSmq7bbbbtPPfvazBFWEJ554Qtu2bdMDDzwgSZo3b568Xq+qqqoSElBYg5LE7Ha75s+fr8bGxqj2xsZGFRQUJKgqWJalzZs365VXXtGvfvUr5ebmJrqkSW/JkiV69913dfz48cixYMECPfjggzp+/DjhJAEWLVo06PL7U6dOccPYBLp48aKuuy46FqSkpCTsMmNmUJJcWVmZ1q1bpwULFugrX/mK6uvrdebMGT388MOJLm3S2rRpkxoaGvTzn/9c6enpkRmuzMxMOZ3OBFc3OaWnpw9aA5SWlqbs7GzWBiXIY489poKCAlVWVmrt2rV68803VV9fr/r6+kSXNmmtWrVKO3bs0Jw5czR37ly9/fbb2r17t7773e8mpiALSe+f/umfrBtvvNGy2+3WXXfdZTU1NSW6pElNUszjxRdfTHRp+IzFixdbjz76aKLLmNT+9V//1crPz7ccDod16623WvX19YkuaVLz+/3Wo48+as2ZM8dKTU21brrpJmv79u1WMBhMSD3sgwIAAIzDGhQAAGAcAgoAADAOAQUAABiHgAIAAIxDQAEAAMYhoAAAAOMQUAAAgHEIKAAAwDgEFAAAYBwCCgAAMA4BBQAAGIeAAgAAjPP/AclIzld3bBBYAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "perc_error = ((nb_model.predict(x_val) - y_val)) / y_val\n",
    "print(perc_error)\n",
    "plt.hist(perc_error, bins=60, alpha=0.7, color='blue', edgecolor='black', range=[min(perc_error), 8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trying with feature selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Hour', 'Temperature(°C)', 'Humidity(%)', 'Wind speed (m/s)',\n",
       "       'Visibility (10m)', 'Dew point temperature(°C)',\n",
       "       'Solar Radiation (MJ/m2)', 'Rainfall(mm)', 'Snowfall (cm)',\n",
       "       'Seasons_Autumn', 'Seasons_Spring', 'Seasons_Summer', 'Seasons_Winter',\n",
       "       'Holiday_Holiday'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Absolute Error on Validation Set:  329.083996168972\n",
      "Mean Absolute Error on Test Set:  326.4162182376729 \n",
      "\n",
      "Mean Squared Error on Validation Set:  234752.86276679774\n",
      "Mean Squared Error on Test Set:  216542.83389577438 \n",
      "\n",
      "R2 on Validation Set:  0.44687117779966934\n",
      "R2 on Test Set:  0.3946738221681906\n"
     ]
    }
   ],
   "source": [
    "selected_cols = ['Seasons_Autumn', 'Seasons_Spring', 'Seasons_Summer', 'Seasons_Winter', 'Hour', 'Temperature(°C)']\n",
    "\n",
    "# Create and train the Negative Binomial regression model\n",
    "sel_nb = sm.GLM(y_train, x_train[selected_cols], family=sm.families.NegativeBinomial())\n",
    "sel_nb_model = sel_nb.fit()\n",
    "\n",
    "# Make predictions\n",
    "sel_nb_val_pred = sel_nb_model.predict(x_val[selected_cols])\n",
    "sel_nb_test_pred = sel_nb_model.predict(x_test[selected_cols])\n",
    "\n",
    "# Evaluate the MAE\n",
    "mae_val = mean_absolute_error(y_val, sel_nb_val_pred)\n",
    "print(\"Mean Absolute Error on Validation Set: \", mae_val)\n",
    "mae_test = mean_absolute_error(y_test, sel_nb_test_pred)\n",
    "print(\"Mean Absolute Error on Test Set: \", mae_test, \"\\n\")\n",
    "\n",
    "# Evaluate the MSE\n",
    "mse_val = mean_squared_error(y_val, sel_nb_val_pred)\n",
    "print(\"Mean Squared Error on Validation Set: \", mse_val)\n",
    "mse_test = mean_squared_error(y_test, sel_nb_test_pred)\n",
    "print(\"Mean Squared Error on Test Set: \", mse_test, \"\\n\")\n",
    "\n",
    "# Evaluate the R2\n",
    "r2_val = r2_score(y_val, sel_nb_val_pred)\n",
    "print(\"R2 on Validation Set: \", r2_val)\n",
    "r2_test = r2_score(y_test, sel_nb_test_pred)\n",
    "print(\"R2 on Test Set: \", r2_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy within 10% threshold: 12.93%\n"
     ]
    }
   ],
   "source": [
    "'''Create accuracy within range function, exact accuracy is not needed but \n",
    "if the prediction is within a certain range of the actual value, it is considered accurate'''\n",
    "def accuracy_within_range(pred, actual, threshold):\n",
    "    thresh_perc = threshold / 100\n",
    "    errors = np.abs(actual - pred)\n",
    "    within_bounds = errors <= thresh_perc * np.abs(actual)\n",
    "    accuracy = np.mean(within_bounds)\n",
    "    return accuracy\n",
    "\n",
    "# Set the threshold (e.g., 5%)\n",
    "threshold_percent = 10\n",
    "\n",
    "# Calculate accuracy\n",
    "test_accuracy = accuracy_within_range(y_test, nb_test_pred, threshold_percent)\n",
    "print(f\"Accuracy within {threshold_percent}% threshold: {test_accuracy * 100:.2f}%\")\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}