diff --git a/Python/bike-sharing/Chapter5-interpretable_models.ipynb b/Python/bike-sharing/Chapter5-interpretable_models.ipynb new file mode 100644 index 00000000..1a0b43ad --- /dev/null +++ b/Python/bike-sharing/Chapter5-interpretable_models.ipynb @@ -0,0 +1,804 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chapter 5: Interpretable Models" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [], + "source": [ + "# Imports\n", + "\n", + "from preprocess_bike_data import data_pipeline\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reading in the Data" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "df = data_pipeline()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "# Dropping columns not used\n", + "\n", + "sub_features = ['season', 'holiday','workingday', 'weathersit']\n", + "df.drop(sub_features + ['yr', 'mnth', 'weekday'], inplace=True, axis=1)\n", + "\n", + "df_copy = df.copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "# Scaling the data\n", + "\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "\n", + "scaling = {}\n", + "\n", + "for col in ['temp', 'hum', 'windspeed']:\n", + " sc = MinMaxScaler()\n", + " df[col] = sc.fit_transform(df[col].values.reshape(-1,1))\n", + " scaling[col] = sc" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df['temp'].hist()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modeling" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Establishing Features and Target" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [], + "source": [ + "features = [col for col in df.columns if col != 'cnt']\n", + "target = 'cnt'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Linear Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "const 1497.148579\n", + "temp 4175.879086\n", + "hum -1689.932626\n", + "windspeed -1381.678357\n", + "days_since_2011 4.926432\n", + "season_SPRING 473.715303\n", + "season_SUMMER -287.387420\n", + "season_WINTER -425.602853\n", + "holiday_NO HOLIDAY 686.115442\n", + "workingday_WORKING DAY 124.920938\n", + "weathersit_MISTY -379.398530\n", + "weathersit_RAIN/SNOW/STORM -1901.539915\n", + "dtype: float64" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import statsmodels.api as sm\n", + "\n", + "X = sm.add_constant(df[features])\n", + "model = sm.OLS(df['cnt'], X)\n", + "results = model.fit()\n", + "results.params" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
OLS Regression Results
Dep. Variable: cnt R-squared: 0.794
Model: OLS Adj. R-squared: 0.790
Method: Least Squares F-statistic: 251.2
Date: Sat, 10 Dec 2022 Prob (F-statistic): 1.05e-237
Time: 22:38:09 Log-Likelihood: -5993.0
No. Observations: 731 AIC: 1.201e+04
Df Residuals: 719 BIC: 1.207e+04
Df Model: 11
Covariance Type: nonrobust
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
coef std err t P>|t| [0.025 0.975]
const 1497.1486 324.587 4.612 0.000 859.897 2134.400
temp 4175.8791 265.667 15.718 0.000 3654.304 4697.454
hum -1689.9326 308.226 -5.483 0.000 -2295.063 -1084.803
windspeed -1381.6784 223.979 -6.169 0.000 -1821.409 -941.948
days_since_2011 4.9264 0.173 28.507 0.000 4.587 5.266
season_SPRING 473.7153 109.947 4.309 0.000 257.860 689.570
season_SUMMER -287.3874 134.225 -2.141 0.033 -550.906 -23.869
season_WINTER -425.6029 110.820 -3.840 0.000 -643.172 -208.034
holiday_NO HOLIDAY 686.1154 203.301 3.375 0.001 286.980 1085.251
workingday_WORKING DAY 124.9209 73.267 1.705 0.089 -18.921 268.763
weathersit_MISTY -379.3985 87.553 -4.333 0.000 -551.289 -207.508
weathersit_RAIN/SNOW/STORM -1901.5399 223.640 -8.503 0.000 -2340.605 -1462.475
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Omnibus: 91.525 Durbin-Watson: 0.911
Prob(Omnibus): 0.000 Jarque-Bera (JB): 194.706
Skew: -0.719 Prob(JB): 5.25e-43
Kurtosis: 5.079 Cond. No. 5.56e+03


Notes:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.
[2] The condition number is large, 5.56e+03. This might indicate that there are
strong multicollinearity or other numerical problems." + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: cnt R-squared: 0.794\n", + "Model: OLS Adj. R-squared: 0.790\n", + "Method: Least Squares F-statistic: 251.2\n", + "Date: Sat, 10 Dec 2022 Prob (F-statistic): 1.05e-237\n", + "Time: 22:38:09 Log-Likelihood: -5993.0\n", + "No. Observations: 731 AIC: 1.201e+04\n", + "Df Residuals: 719 BIC: 1.207e+04\n", + "Df Model: 11 \n", + "Covariance Type: nonrobust \n", + "==============================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "----------------------------------------------------------------------------------------------\n", + "const 1497.1486 324.587 4.612 0.000 859.897 2134.400\n", + "temp 4175.8791 265.667 15.718 0.000 3654.304 4697.454\n", + "hum -1689.9326 308.226 -5.483 0.000 -2295.063 -1084.803\n", + "windspeed -1381.6784 223.979 -6.169 0.000 -1821.409 -941.948\n", + "days_since_2011 4.9264 0.173 28.507 0.000 4.587 5.266\n", + "season_SPRING 473.7153 109.947 4.309 0.000 257.860 689.570\n", + "season_SUMMER -287.3874 134.225 -2.141 0.033 -550.906 -23.869\n", + "season_WINTER -425.6029 110.820 -3.840 0.000 -643.172 -208.034\n", + "holiday_NO HOLIDAY 686.1154 203.301 3.375 0.001 286.980 1085.251\n", + "workingday_WORKING DAY 124.9209 73.267 1.705 0.089 -18.921 268.763\n", + "weathersit_MISTY -379.3985 87.553 -4.333 0.000 -551.289 -207.508\n", + "weathersit_RAIN/SNOW/STORM -1901.5399 223.640 -8.503 0.000 -2340.605 -1462.475\n", + "==============================================================================\n", + "Omnibus: 91.525 Durbin-Watson: 0.911\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 194.706\n", + "Skew: -0.719 Prob(JB): 5.25e-43\n", + "Kurtosis: 5.079 Cond. No. 5.56e+03\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[2] The condition number is large, 5.56e+03. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + "\"\"\"" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Weight Plot" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [], + "source": [ + "def get_model_stats(results):\n", + " \n", + " coef = results.params.to_dict()\n", + " std_error = results.bse.to_dict()\n", + " conf_intervals = results.conf_int(alpha=0.5).to_dict()\n", + "\n", + " for key, val in coef.items():\n", + " coef[key] = [val]\n", + "\n", + " t = pd.DataFrame(coef).T\n", + " t['std_error'] = t.index.map(std_error)\n", + " t.columns = ['coefficients', 'std_error']\n", + " t['lower'] = t.index.map(conf_intervals[0])\n", + " t['upper'] = t.index.map(conf_intervals[1])\n", + " \n", + " return t, coef" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [], + "source": [ + "t, coef = get_model_stats(results)" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting the Weight Plot\n", + "\n", + "plt.rcParams['figure.dpi'] = 200\n", + "fig, ax = plt.subplots(figsize=(11,6))\n", + "ax.scatter(t['coefficients'], t.index)\n", + "ax.errorbar(t['coefficients'], t.index, xerr=2*t['std_error'], fmt = '.')\n", + "ax.axvline(0, linestyle='-.', color='red')\n", + "ax.set_title(\"Weight Plot\")\n", + "ax.set_xlabel(\"Weights\")\n", + "ax.set_ylabel(\"Features\")\n", + "plt.grid('True')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Weight Plot shows that the feature, \"weathersit_RAIN/SNOW/STORM\", has a strong negative effect on the bike rentals. The features, \"season_WINTER\", \"season_SUMMER\", and \"workingday_WORKING DAY\" have coefficients where 0 falls within its 95% confidence interval. That says that the effect is not statistically significant." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Effect Plot\n", + "The weight plot shows how much *weight* a feature has on the prediction. BUT an effect plot helps understand how much a feature contributes to the predictions. This is done by multiplying the weight by its actual feature values. " + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [], + "source": [ + "for col in [col for col in df.columns if col != 'cnt']:\n", + " df['effect_'+col] = df[col] * coef[col][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['effect_temp',\n", + " 'effect_hum',\n", + " 'effect_windspeed',\n", + " 'effect_days_since_2011',\n", + " 'effect_season_SPRING',\n", + " 'effect_season_SUMMER',\n", + " 'effect_season_WINTER',\n", + " 'effect_holiday_NO HOLIDAY',\n", + " 'effect_workingday_WORKING DAY',\n", + " 'effect_weathersit_MISTY',\n", + " 'effect_weathersit_RAIN/SNOW/STORM']" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "effect_columns = [col for col in df.columns if \"effect_\" in col]\n", + "effect_columns" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,1)\n", + "\n", + "ax.boxplot(df[effect_columns], vert=False)\n", + "ax.set_yticklabels(effect_columns)\n", + "ax.axvline(0, linestyle='-.', color='red')\n", + "ax.set_ylabel(\"Features\")\n", + "ax.set_xlabel(\"Effect\")\n", + "ax.set_title(\"Feature Effect on Predictions\")\n", + "plt.grid();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot Individual Predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [], + "source": [ + "# new_observation = [1.604356, 51.8261, 6.000868, 5, 0, 0, 1, 1, 1, 0, 0]\n", + "\n", + "# fig, ax = plt.subplots(1,1)\n", + "# ax.boxplot(df[effect_columns], vert=False)\n", + "# for idx, col in enumerate(effect_columns):\n", + "# ax.annotate('x', (idx, new_observation[idx]))\n", + "# ax.set_yticklabels(effect_columns)\n", + "# ax.axvline(0, linestyle='-.', color='red')\n", + "# ax.set_ylabel(\"Features\")\n", + "# ax.set_xlabel(\"Effect\")\n", + "# ax.set_title(\"Feature Effect on Predictions\")\n", + "# plt.grid();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Interaction Effect" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [], + "source": [ + "# Creating a interaction effect of workingday and temperature\n", + "\n", + "df_copy['workingday_temp'] = df_copy['workingday_WORKING DAY'] * df_copy['temp']" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['temp',\n", + " 'hum',\n", + " 'windspeed',\n", + " 'days_since_2011',\n", + " 'season_SPRING',\n", + " 'season_SUMMER',\n", + " 'season_WINTER',\n", + " 'holiday_NO HOLIDAY',\n", + " 'workingday_WORKING DAY',\n", + " 'weathersit_MISTY',\n", + " 'weathersit_RAIN/SNOW/STORM',\n", + " 'workingday_temp']" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "interaction_columns = [col for col in df_copy.columns if col not in ['weathersit', 'workingday', 'weekday', 'cnt', 'season', 'yr', 'mnth', 'holiday']]\n", + "interaction_columns = [col for col in interaction_columns if 'effect' not in col]\n", + "interaction_columns" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [], + "source": [ + "X = sm.add_constant(df_copy[interaction_columns])\n", + "interaction_model = sm.OLS(df_copy['cnt'], X)\n", + "interaction_results = interaction_model.fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [], + "source": [ + "interaction_df, interaction_coef = get_model_stats(interaction_results)" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
OLS Regression Results
Dep. Variable: cnt R-squared: 0.796
Model: OLS Adj. R-squared: 0.792
Method: Least Squares F-statistic: 232.9
Date: Sat, 10 Dec 2022 Prob (F-statistic): 4.70e-238
Time: 22:38:11 Log-Likelihood: -5989.4
No. Observations: 731 AIC: 1.200e+04
Df Residuals: 718 BIC: 1.206e+04
Df Model: 12
Covariance Type: nonrobust
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
coef std err t P>|t| [0.025 0.975]
const 1937.9905 329.281 5.886 0.000 1291.521 2584.460
temp 125.4363 8.895 14.102 0.000 107.973 142.899
hum -17.5037 3.156 -5.546 0.000 -23.700 -11.307
windspeed -42.0682 6.864 -6.129 0.000 -55.544 -28.592
days_since_2011 4.9307 0.172 28.654 0.000 4.593 5.268
season_SPRING 467.2725 109.499 4.267 0.000 252.297 682.248
season_SUMMER -289.4902 133.648 -2.166 0.031 -551.877 -27.103
season_WINTER -426.5500 110.342 -3.866 0.000 -643.182 -209.918
holiday_NO HOLIDAY 674.4010 202.471 3.331 0.001 276.895 1071.907
workingday_WORKING DAY 451.8710 141.699 3.189 0.001 173.678 730.064
weathersit_MISTY -382.1347 87.181 -4.383 0.000 -553.296 -210.974
weathersit_RAIN/SNOW/STORM -1898.2107 222.679 -8.524 0.000 -2335.390 -1461.032
workingday_temp -21.7967 8.099 -2.691 0.007 -37.696 -5.897
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Omnibus: 92.795 Durbin-Watson: 0.904
Prob(Omnibus): 0.000 Jarque-Bera (JB): 196.738
Skew: -0.729 Prob(JB): 1.90e-43
Kurtosis: 5.081 Cond. No. 4.72e+03


Notes:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.
[2] The condition number is large, 4.72e+03. This might indicate that there are
strong multicollinearity or other numerical problems." + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: cnt R-squared: 0.796\n", + "Model: OLS Adj. R-squared: 0.792\n", + "Method: Least Squares F-statistic: 232.9\n", + "Date: Sat, 10 Dec 2022 Prob (F-statistic): 4.70e-238\n", + "Time: 22:38:11 Log-Likelihood: -5989.4\n", + "No. Observations: 731 AIC: 1.200e+04\n", + "Df Residuals: 718 BIC: 1.206e+04\n", + "Df Model: 12 \n", + "Covariance Type: nonrobust \n", + "==============================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "----------------------------------------------------------------------------------------------\n", + "const 1937.9905 329.281 5.886 0.000 1291.521 2584.460\n", + "temp 125.4363 8.895 14.102 0.000 107.973 142.899\n", + "hum -17.5037 3.156 -5.546 0.000 -23.700 -11.307\n", + "windspeed -42.0682 6.864 -6.129 0.000 -55.544 -28.592\n", + "days_since_2011 4.9307 0.172 28.654 0.000 4.593 5.268\n", + "season_SPRING 467.2725 109.499 4.267 0.000 252.297 682.248\n", + "season_SUMMER -289.4902 133.648 -2.166 0.031 -551.877 -27.103\n", + "season_WINTER -426.5500 110.342 -3.866 0.000 -643.182 -209.918\n", + "holiday_NO HOLIDAY 674.4010 202.471 3.331 0.001 276.895 1071.907\n", + "workingday_WORKING DAY 451.8710 141.699 3.189 0.001 173.678 730.064\n", + "weathersit_MISTY -382.1347 87.181 -4.383 0.000 -553.296 -210.974\n", + "weathersit_RAIN/SNOW/STORM -1898.2107 222.679 -8.524 0.000 -2335.390 -1461.032\n", + "workingday_temp -21.7967 8.099 -2.691 0.007 -37.696 -5.897\n", + "==============================================================================\n", + "Omnibus: 92.795 Durbin-Watson: 0.904\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 196.738\n", + "Skew: -0.729 Prob(JB): 1.90e-43\n", + "Kurtosis: 5.081 Cond. No. 4.72e+03\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[2] The condition number is large, 4.72e+03. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + "\"\"\"" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "interaction_results.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [], + "source": [ + "temp = interaction_results.params['temp']\n", + "workingday = interaction_results.params['workingday_WORKING DAY']\n", + "working_day_temp = interaction_results.params['workingday_temp']\n", + "intercept = interaction_results.params['const']" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(df_copy['temp'], temp*df_copy['temp'] + intercept, linestyle=\"--\", label='NO WORKING DAY')\n", + "plt.plot(df_copy['temp'], (temp+working_day_temp)*df_copy['temp'] + (intercept + working_day_temp), linestyle=\"--\", label='WORKING DAY')\n", + "plt.legend()\n", + "plt.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Python/bike-sharing/__pycache__/preprocess_bike_data.cpython-310.pyc b/Python/bike-sharing/__pycache__/preprocess_bike_data.cpython-310.pyc new file mode 100644 index 00000000..b65e3125 Binary files /dev/null and b/Python/bike-sharing/__pycache__/preprocess_bike_data.cpython-310.pyc differ diff --git a/Python/bike-sharing/bike_sharing_preprocessing.ipynb b/Python/bike-sharing/bike_sharing_preprocessing.ipynb new file mode 100644 index 00000000..8552b1a2 --- /dev/null +++ b/Python/bike-sharing/bike_sharing_preprocessing.ipynb @@ -0,0 +1,2720 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Imports\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Reading in the Data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
instantdtedayseasonyrmnthholidayweekdayworkingdayweathersittempatemphumwindspeedcasualregisteredcnt
012011-01-0110106020.3441670.3636250.8058330.160446331654985
122011-01-0210100020.3634780.3537390.6960870.248539131670801
232011-01-0310101110.1963640.1894050.4372730.24830912012291349
342011-01-0410102110.2000000.2121220.5904350.16029610814541562
452011-01-0510103110.2269570.2292700.4369570.1869008215181600
\n", + "
" + ], + "text/plain": [ + " instant dteday season yr mnth holiday weekday workingday \\\n", + "0 1 2011-01-01 1 0 1 0 6 0 \n", + "1 2 2011-01-02 1 0 1 0 0 0 \n", + "2 3 2011-01-03 1 0 1 0 1 1 \n", + "3 4 2011-01-04 1 0 1 0 2 1 \n", + "4 5 2011-01-05 1 0 1 0 3 1 \n", + "\n", + " weathersit temp atemp hum windspeed casual registered \\\n", + "0 2 0.344167 0.363625 0.805833 0.160446 331 654 \n", + "1 2 0.363478 0.353739 0.696087 0.248539 131 670 \n", + "2 1 0.196364 0.189405 0.437273 0.248309 120 1229 \n", + "3 1 0.200000 0.212122 0.590435 0.160296 108 1454 \n", + "4 1 0.226957 0.229270 0.436957 0.186900 82 1518 \n", + "\n", + " cnt \n", + "0 985 \n", + "1 801 \n", + "2 1349 \n", + "3 1562 \n", + "4 1600 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Reading in the data\n", + "\n", + "DIR = \"../../data/\"\n", + "DATA = \"bike-sharing-daily.csv\"\n", + "day_bike_rentals = pd.read_csv(DIR+DATA)\n", + "day_bike_rentals.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data Cleaning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Categorical Features" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Label Lists\n", + "\n", + "weekdays = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']\n", + "holidays = ['NO HOLIDAY', 'HOLIDAY']\n", + "working_day = ['NO WORKING DAY', 'WORKING DAY']\n", + "season = ['WINTER', 'SPRING', 'SUMMER', 'FALL']\n", + "weathersit = ['GOOD', 'MISTY', 'RAIN/SNOW/STORM']\n", + "months = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Function to create a dictionary mapping index of list to the respective label\n", + "\n", + "def create_dictionary(label_list, start_at_zero=True):\n", + " d = {}\n", + " if start_at_zero:\n", + " for idx, val in enumerate(label_list):\n", + " d[idx] = val\n", + " else:\n", + " for idx, val in enumerate(label_list):\n", + " d[idx+1] = val\n", + " return d" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Mapping the indicies to actual labels\n", + "\n", + "day_bike_rentals['weekday'] = day_bike_rentals['weekday'].map(create_dictionary(weekdays))\n", + "day_bike_rentals['holiday'] = day_bike_rentals['holiday'].map(create_dictionary(holidays))\n", + "day_bike_rentals['workingday'] = day_bike_rentals['workingday'].map(create_dictionary(working_day))\n", + "day_bike_rentals['season'] = day_bike_rentals['season'].map(create_dictionary(season, start_at_zero=False))\n", + "day_bike_rentals['weathersit'] = day_bike_rentals['weathersit'].map(create_dictionary(weathersit, start_at_zero=False))\n", + "day_bike_rentals['mnth'] = day_bike_rentals['mnth'].map(create_dictionary(months, start_at_zero=False))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Numerical Features" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Denormalizing the temperture\n", + "\n", + "# Function that denormalizes temperture\n", + "def inverse_min_max(row, tmin, tmax):\n", + " return row * (tmax - tmin) + tmin\n", + "\n", + "# t_min=-8, t_max=+39\n", + "day_bike_rentals['temp'] = day_bike_rentals['temp'].apply(inverse_min_max, args=(-8, 39))\n", + "\n", + "# t_min=-16, t_max=+50\n", + "day_bike_rentals['atemp'] = day_bike_rentals['atemp'].apply(inverse_min_max, args=(-16, 50))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# DeNormalized wind speed. The values are divided by 67 (max)\n", + "\n", + "day_bike_rentals['windspeed'] = day_bike_rentals['windspeed'].apply(lambda row: row * 67)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Dormalized humidity. The values are divided by 100 (max)\n", + "\n", + "day_bike_rentals['hum'] = day_bike_rentals['hum'].apply(lambda row: row * 100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Temporal Features" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Processing time features\n", + "\n", + "day_bike_rentals['yr'] = day_bike_rentals['yr'].apply(lambda row: 2011 if row == 0 else 2012)\n", + "day_bike_rentals['dteday'] = pd.to_datetime(day_bike_rentals['dteday'])\n", + "day_bike_rentals['days_since_2011'] = (day_bike_rentals['dteday'] - day_bike_rentals['dteday'].min()).dt.days" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data Processing" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [], + "source": [ + "# Extracting only the needed features\n", + "\n", + "day_bike_rentals = day_bike_rentals[[col for col in day_bike_rentals.columns if col not in ['instant', 'dteday', 'registered', 'casual', 'atemp']]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dummifying Categorical Features" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['season', 'mnth', 'holiday', 'weekday', 'workingday', 'weathersit']" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Collecting only the categorical features\n", + "\n", + "categorical_features = [col for col in day_bike_rentals.columns if day_bike_rentals[col].dtype == 'object']\n", + "categorical_features" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['season', 'holiday', 'workingday', 'weathersit']" + ] + }, + "execution_count": 110, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Collecting all the features that needs to be dummified \n", + "sub_features = ['season', 'holiday','workingday', 'weathersit']\n", + "sub_features" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
temphumwindspeedcntdays_since_2011season_SPRINGseason_SUMMERseason_WINTERholiday_NO HOLIDAYworkingday_WORKING DAYweathersit_MISTYweathersit_RAIN/SNOW/STORM
08.17584980.583310.74988298500011010
19.08346669.608716.65211380110011010
21.22910843.727316.636703134920011100
31.40000059.043510.739832156230011100
42.66697943.695712.522300160040011100
\n", + "
" + ], + "text/plain": [ + " temp hum windspeed cnt days_since_2011 season_SPRING \\\n", + "0 8.175849 80.5833 10.749882 985 0 0 \n", + "1 9.083466 69.6087 16.652113 801 1 0 \n", + "2 1.229108 43.7273 16.636703 1349 2 0 \n", + "3 1.400000 59.0435 10.739832 1562 3 0 \n", + "4 2.666979 43.6957 12.522300 1600 4 0 \n", + "\n", + " season_SUMMER season_WINTER holiday_NO HOLIDAY workingday_WORKING DAY \\\n", + "0 0 1 1 0 \n", + "1 0 1 1 0 \n", + "2 0 1 1 1 \n", + "3 0 1 1 1 \n", + "4 0 1 1 1 \n", + "\n", + " weathersit_MISTY weathersit_RAIN/SNOW/STORM \n", + "0 1 0 \n", + "1 1 0 \n", + "2 0 0 \n", + "3 0 0 \n", + "4 0 0 " + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Dummifying categorical features\n", + "cleaned_bike_data = pd.concat([day_bike_rentals, pd.get_dummies(day_bike_rentals[sub_features], drop_first=True)], axis=1)\n", + "\n", + "# Dropping unnecessary columns\n", + "bike = cleaned_bike_data.drop(sub_features + ['yr', 'mnth', 'weekday'], axis=1)\n", + "\n", + "# Viewing the result\n", + "bike.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countmeanstdmin25%50%75%max
temp731.015.2830858.603397-5.2208717.84292515.42165122.80457532.498349
hum731.062.78940614.2429100.00000052.00000062.66670073.02085097.250000
windspeed731.012.7625765.1923571.5002449.04165012.12532515.62537134.000021
cnt731.04504.3488371937.21145222.0000003152.0000004548.0000005956.0000008714.000000
days_since_2011731.0365.000000211.1658120.000000182.500000365.000000547.500000730.000000
season_SPRING731.00.2517100.4342930.0000000.0000000.0000001.0000001.000000
season_SUMMER731.00.2571820.4373800.0000000.0000000.0000001.0000001.000000
season_WINTER731.00.2476060.4319170.0000000.0000000.0000000.0000001.000000
holiday_NO HOLIDAY731.00.9712720.1671550.0000001.0000001.0000001.0000001.000000
workingday_WORKING DAY731.00.6839950.4652330.0000000.0000001.0000001.0000001.000000
weathersit_MISTY731.00.3378930.4733160.0000000.0000000.0000001.0000001.000000
weathersit_RAIN/SNOW/STORM731.00.0287280.1671550.0000000.0000000.0000000.0000001.000000
\n", + "
" + ], + "text/plain": [ + " count mean std min \\\n", + "temp 731.0 15.283085 8.603397 -5.220871 \n", + "hum 731.0 62.789406 14.242910 0.000000 \n", + "windspeed 731.0 12.762576 5.192357 1.500244 \n", + "cnt 731.0 4504.348837 1937.211452 22.000000 \n", + "days_since_2011 731.0 365.000000 211.165812 0.000000 \n", + "season_SPRING 731.0 0.251710 0.434293 0.000000 \n", + "season_SUMMER 731.0 0.257182 0.437380 0.000000 \n", + "season_WINTER 731.0 0.247606 0.431917 0.000000 \n", + "holiday_NO HOLIDAY 731.0 0.971272 0.167155 0.000000 \n", + "workingday_WORKING DAY 731.0 0.683995 0.465233 0.000000 \n", + "weathersit_MISTY 731.0 0.337893 0.473316 0.000000 \n", + "weathersit_RAIN/SNOW/STORM 731.0 0.028728 0.167155 0.000000 \n", + "\n", + " 25% 50% 75% max \n", + "temp 7.842925 15.421651 22.804575 32.498349 \n", + "hum 52.000000 62.666700 73.020850 97.250000 \n", + "windspeed 9.041650 12.125325 15.625371 34.000021 \n", + "cnt 3152.000000 4548.000000 5956.000000 8714.000000 \n", + "days_since_2011 182.500000 365.000000 547.500000 730.000000 \n", + "season_SPRING 0.000000 0.000000 1.000000 1.000000 \n", + "season_SUMMER 0.000000 0.000000 1.000000 1.000000 \n", + "season_WINTER 0.000000 0.000000 0.000000 1.000000 \n", + "holiday_NO HOLIDAY 1.000000 1.000000 1.000000 1.000000 \n", + "workingday_WORKING DAY 0.000000 1.000000 1.000000 1.000000 \n", + "weathersit_MISTY 0.000000 0.000000 1.000000 1.000000 \n", + "weathersit_RAIN/SNOW/STORM 0.000000 0.000000 0.000000 1.000000 " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bike.describe().T" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def data_pipeline():\n", + " \n", + " # Reading in the data\n", + " day_bike_rentals = pd.read_csv(DIR+DATA)\n", + " \n", + " # Mapping numerical codes with actual values\n", + " day_bike_rentals['weekday'] = day_bike_rentals['weekday'].map(create_dictionary(weekdays))\n", + " day_bike_rentals['holiday'] = day_bike_rentals['holiday'].map(create_dictionary(holidays))\n", + " day_bike_rentals['workingday'] = day_bike_rentals['workingday'].map(create_dictionary(working_day))\n", + " day_bike_rentals['season'] = day_bike_rentals['season'].map(create_dictionary(season, start_at_zero=False))\n", + " day_bike_rentals['weathersit'] = day_bike_rentals['weathersit'].map(create_dictionary(weathersit, start_at_zero=False))\n", + " day_bike_rentals['mnth'] = day_bike_rentals['mnth'].map(create_dictionary(months, start_at_zero=False))\n", + " \n", + " # Reversing min_max\n", + " day_bike_rentals['temp'] = day_bike_rentals['temp'].apply(inverse_min_max, args=(-8, 39))\n", + " day_bike_rentals['atemp'] = day_bike_rentals['atemp'].apply(inverse_min_max, args=(-16, 50))\n", + " \n", + " # Unnormalizing the data\n", + " day_bike_rentals['windspeed'] = day_bike_rentals['windspeed'].apply(lambda row: row * 67)\n", + " day_bike_rentals['hum'] = day_bike_rentals['hum'].apply(lambda row: row * 100)\n", + " \n", + " # Converting labels into actual year\n", + " day_bike_rentals['yr'] = day_bike_rentals['yr'].apply(lambda row: 2011 if row == 0 else 2012)\n", + " \n", + " # Converting 'dteday' to datetime object\n", + " day_bike_rentals['dteday'] = pd.to_datetime(day_bike_rentals['dteday'])\n", + "\n", + " # Calculating days since 2011\n", + " day_bike_rentals['days_since_2011'] = (day_bike_rentals['dteday'] - day_bike_rentals['dteday'].min()).dt.days\n", + " \n", + " # Feature selecting\n", + " day_bike_rentals = day_bike_rentals[[col for col in day_bike_rentals.columns if col not in ['instant', 'dteday', 'registered', 'casual', 'atemp']]]\n", + " \n", + " # Dummifying categorical features\n", + " day_bike_rentals = pd.concat([day_bike_rentals, pd.get_dummies(day_bike_rentals[sub_features], drop_first=True)], axis=1)\n", + " \n", + " # Returning the cleaned data\n", + " return day_bike_rentals " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
seasonyrmnthholidayweekdayworkingdayweathersittemphumwindspeedcntdays_since_2011
0WINTER2011JANNO HOLIDAYSATNO WORKING DAYMISTY8.17584980.583310.7498829850
1WINTER2011JANNO HOLIDAYSUNNO WORKING DAYMISTY9.08346669.608716.6521138011
2WINTER2011JANNO HOLIDAYMONWORKING DAYGOOD1.22910843.727316.63670313492
3WINTER2011JANNO HOLIDAYTUEWORKING DAYGOOD1.40000059.043510.73983215623
4WINTER2011JANNO HOLIDAYWEDWORKING DAYGOOD2.66697943.695712.52230016004
\n", + "
" + ], + "text/plain": [ + " season yr mnth holiday weekday workingday weathersit temp \\\n", + "0 WINTER 2011 JAN NO HOLIDAY SAT NO WORKING DAY MISTY 8.175849 \n", + "1 WINTER 2011 JAN NO HOLIDAY SUN NO WORKING DAY MISTY 9.083466 \n", + "2 WINTER 2011 JAN NO HOLIDAY MON WORKING DAY GOOD 1.229108 \n", + "3 WINTER 2011 JAN NO HOLIDAY TUE WORKING DAY GOOD 1.400000 \n", + "4 WINTER 2011 JAN NO HOLIDAY WED WORKING DAY GOOD 2.666979 \n", + "\n", + " hum windspeed cnt days_since_2011 \n", + "0 80.5833 10.749882 985 0 \n", + "1 69.6087 16.652113 801 1 \n", + "2 43.7273 16.636703 1349 2 \n", + "3 59.0435 10.739832 1562 3 \n", + "4 43.6957 12.522300 1600 4 " + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ef_bike = day_bike_rentals[[col for col in day_bike_rentals.columns if col not in ['instant', 'dteday', 'registered', 'casual', 'atemp']]]\n", + "ef_bike.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "season 4\n", + "yr 2\n", + "mnth 12\n", + "holiday 2\n", + "weekday 7\n", + "workingday 2\n", + "weathersit 3\n", + "temp 499\n", + "hum 595\n", + "windspeed 650\n", + "cnt 696\n", + "days_since_2011 731\n", + "dtype: int64" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ef_bike.nunique()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "GOOD 463\n", + "MISTY 247\n", + "RAIN/SNOW/STORM 21\n", + "Name: weathersit, dtype: int64" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ef_bike['weathersit'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "df_bike = pd.get_dummies(ef_bike['weathersit'], drop_first=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Splitting the Data" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(731, 2)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_bike.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# Training data\n", + "\n", + "X = bike[[col for col in bike.columns if col != 'cnt']]\n", + "y = bike['cnt']" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
LinearRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LinearRegression()" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.linear_model import LinearRegression\n", + "\n", + "lr = LinearRegression()\n", + "lr.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dummy coeficients: [ 110.70958159 -17.37719923 -42.51347178 4.92643186\n", + " 473.71530337 -287.38742028 -425.60285274 686.11544159\n", + " 124.92093811 -379.39852979 -1901.53991489], Dummy intercept: 2138.9296219985613\n" + ] + } + ], + "source": [ + "print(f\"Dummy coeficients: {lr.coef_}, Dummy intercept: {lr.intercept_}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Effect Coding" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 731 entries, 0 to 730\n", + "Data columns (total 2 columns):\n", + " # Column Non-Null Count Dtype\n", + "--- ------ -------------- -----\n", + " 0 MISTY 731 non-null int64\n", + " 1 RAIN/SNOW/STORM 731 non-null int64\n", + "dtypes: int64(2)\n", + "memory usage: 11.5 KB\n" + ] + } + ], + "source": [ + "# Converting numerical values to type int64\n", + "''' \n", + " Currently it is int8 and int8 cannot interpret negative values \n", + "'''\n", + "\n", + "df_bike = df_bike.astype(int)\n", + "df_bike.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# Setting the reference category to -1\n", + "\n", + "df_bike.loc[(df_bike['MISTY']==0) & (df_bike['RAIN/SNOW/STORM']==0),'MISTY'] = -1\n", + "df_bike.loc[(df_bike['MISTY']==-1) & (df_bike['RAIN/SNOW/STORM']==0),'RAIN/SNOW/STORM'] = -1" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Effect Coding coeficients: [ 110.70958159 -17.37719923 -42.51347178 4.92643186\n", + " 473.71530337 -287.38742028 -425.60285274 686.11544159\n", + " 124.92093811 -379.39852979 -1901.53991489]\n", + "Effect Coding intercept: 2138.9296219985613\n" + ] + } + ], + "source": [ + "# Printing the coeficients and intercept of LR\n", + "\n", + "print(f\"Effect Coding coeficients: {lr.coef_}\\nEffect Coding intercept: {lr.intercept_}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Effect of 'GOOD': 2045.5972396403506\n", + "Effect of 'MISTY': 2249.639203591673\n", + "Effect of 'RAIN': 2121.5524227636606\n" + ] + } + ], + "source": [ + "# Calculating effect coding\n", + "\n", + "effect_of_good = lr.intercept_ - (lr.coef_[0]+lr.coef_[1])\n", + "effect_of_misty = lr.intercept_ + lr.coef_[0]\n", + "effect_of_rain = lr.intercept_ + lr.coef_[1]\n", + "print(f\"Effect of 'GOOD': {effect_of_good}\\nEffect of 'MISTY': {effect_of_misty}\\nEffect of 'RAIN': {effect_of_rain}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Splitting Data into Train and Test Sets" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "X = bike[[col for col in bike.columns if col != 'cnt']]\n", + "y = bike['cnt']\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.preprocessing import MinMaxScaler\n", + "\n", + "mms = MinMaxScaler()\n", + "\n", + "scale_columns = ['temp', 'hum', 'windspeed']\n", + "\n", + "for col in scale_columns:\n", + " mms.fit(X_train[col].values.reshape(-1,1))\n", + " X_train[col] = mms.transform(X_train[col].values.reshape(-1,1))\n", + " X_test[col] = mms.transform(X_test[col].values.reshape(-1,1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Linear Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Linear Regession\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 4119.68595694, -1270.84325983, -1128.71029573, 4.8310698 ,\n", + " 468.29339945, -200.30842603, -360.94542215, 485.53541273,\n", + " 96.92766521, -300.13333285, -1896.75540058])" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Training the Data\n", + "\n", + "from sklearn.linear_model import LinearRegression\n", + "\n", + "lr = LinearRegression()\n", + "lr.fit(X_train,y_train)\n", + "\n", + "print(\"Linear Regession\")\n", + "lr.coef_" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE: 884897.294264837\n" + ] + } + ], + "source": [ + "# Evaluate the data\n", + "\n", + "from sklearn.metrics import mean_squared_error\n", + "\n", + "predictions = lr.predict(X_test)\n", + "print(f\"MSE: {mean_squared_error(predictions, y_test)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lasso Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lasso Regression: \n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 4086.18142137, -1251.03700225, -1114.61277435, 4.83844788,\n", + " 475.98848393, -181.43877689, -358.58597195, 465.58406442,\n", + " 96.32689137, -301.20879631, -1885.99734402])" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Imports\n", + "from sklearn.linear_model import Lasso\n", + "\n", + "# Fitting the model\n", + "lasso = Lasso(alpha=0.5)\n", + "lasso.fit(X_train, y_train)\n", + "print(\"Lasso Regression: \")\n", + "lasso.coef_" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE: 751649.6486909935\n", + "MSE: 886927.2630415942\n" + ] + } + ], + "source": [ + "# Evaluate the data\n", + "\n", + "from sklearn.metrics import mean_squared_error\n", + "\n", + "train_mse = mean_squared_error(lasso.predict(X_train), y_train)\n", + "predictions = lasso.predict(X_test)\n", + "\n", + "print(f\"MSE: {train_mse}\")\n", + "print(f\"MSE: {mean_squared_error(predictions, y_test)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hyperparameter Tuning" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['mean_fit_time',\n", + " 'mean_score_time',\n", + " 'mean_test_score',\n", + " 'param_alpha',\n", + " 'params',\n", + " 'rank_test_score',\n", + " 'split0_test_score',\n", + " 'split1_test_score',\n", + " 'split2_test_score',\n", + " 'split3_test_score',\n", + " 'split4_test_score',\n", + " 'std_fit_time',\n", + " 'std_score_time',\n", + " 'std_test_score']" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Using GridSearch and CV to find best alpha\n", + "\n", + "lasso = Lasso()\n", + "\n", + "from sklearn.model_selection import GridSearchCV\n", + "\n", + "parameters = {\"alpha\":np.arange(.1,1.1, 0.1)}\n", + "grid_search = GridSearchCV(\n", + " estimator=Lasso(),\n", + " param_grid=parameters,\n", + ")\n", + "\n", + "grid_search.fit(X_train, y_train)\n", + "\n", + "sorted(grid_search.cv_results_.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.1" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grid_search.best_params_['alpha']" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train performance: 751596.8213950731, Test performance: 885291.6766173533\n" + ] + } + ], + "source": [ + "lasso = Lasso(alpha=0.1)\n", + "\n", + "# Fitting the model\n", + "lasso.fit(X_train, y_train)\n", + "\n", + "# Calculating the train performance\n", + "train_predictions = lasso.predict(X_train)\n", + "train_mse = mean_squared_error(train_predictions, y_train)\n", + "\n", + "# Calculating the test performance\n", + "test_predictions = lasso.predict(X_test)\n", + "test_mse = mean_squared_error(y_test, test_predictions)\n", + "\n", + "print(f\"Train performance: {train_mse}, Test performance: {test_mse}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 4113.03486783, -1266.8947437 , -1125.89284108, 4.83253953,\n", + " 469.8202845 , -196.55402595, -360.46931257, 481.54641279,\n", + " 96.80660755, -300.34475081, -1894.59623269])" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lasso.coef_" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "# Feature is line\n", + "# y: weights are weights\n", + "# x: lambda" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "# for num in np.arange(.1,1.1, 0.01):\n", + "# print(np.log(num))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Decision Trees" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
seasonyrmnthholidayweekdayworkingdayweathersittemphumwindspeedcntdays_since_2011
0WINTER2011JANNO HOLIDAYSATNO WORKING DAYMISTY8.17584980.583310.7498829850
1WINTER2011JANNO HOLIDAYSUNNO WORKING DAYMISTY9.08346669.608716.6521138011
2WINTER2011JANNO HOLIDAYMONWORKING DAYGOOD1.22910843.727316.63670313492
3WINTER2011JANNO HOLIDAYTUEWORKING DAYGOOD1.40000059.043510.73983215623
4WINTER2011JANNO HOLIDAYWEDWORKING DAYGOOD2.66697943.695712.52230016004
\n", + "
" + ], + "text/plain": [ + " season yr mnth holiday weekday workingday weathersit temp \\\n", + "0 WINTER 2011 JAN NO HOLIDAY SAT NO WORKING DAY MISTY 8.175849 \n", + "1 WINTER 2011 JAN NO HOLIDAY SUN NO WORKING DAY MISTY 9.083466 \n", + "2 WINTER 2011 JAN NO HOLIDAY MON WORKING DAY GOOD 1.229108 \n", + "3 WINTER 2011 JAN NO HOLIDAY TUE WORKING DAY GOOD 1.400000 \n", + "4 WINTER 2011 JAN NO HOLIDAY WED WORKING DAY GOOD 2.666979 \n", + "\n", + " hum windspeed cnt days_since_2011 \n", + "0 80.5833 10.749882 985 0 \n", + "1 69.6087 16.652113 801 1 \n", + "2 43.7273 16.636703 1349 2 \n", + "3 59.0435 10.739832 1562 3 \n", + "4 43.6957 12.522300 1600 4 " + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ef_bike.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "# Getting data\n", + "\n", + "dt_columns = ['temp', 'season', 'days_since_2011','windspeed', 'hum', 'cnt']\n", + "\n", + "dt_df = ef_bike[dt_columns]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Label Encoding 'season'" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/3h/n7g9d8x521gg4nfvf31y3_840000gn/T/ipykernel_15068/2549798644.py:5: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " dt_df['labeled_season'] = le.fit_transform(dt_df['season'])\n" + ] + } + ], + "source": [ + "\n", + "from sklearn.preprocessing import LabelEncoder\n", + "\n", + "le = LabelEncoder()\n", + "\n", + "dt_df['labeled_season'] = le.fit_transform(dt_df['season'])" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "# Splitting the data into train test split\n", + "\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "X = dt_df[[col for col in dt_df.columns if col not in ['cnt','season']]]\n", + "y = dt_df['cnt']\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tempdays_since_2011windspeedhumlabeled_season
08.175849010.74988280.58333
19.083466116.65211369.60873
21.229108216.63670343.72733
31.400000310.73983259.04353
42.666979412.52230043.69573
\n", + "
" + ], + "text/plain": [ + " temp days_since_2011 windspeed hum labeled_season\n", + "0 8.175849 0 10.749882 80.5833 3\n", + "1 9.083466 1 16.652113 69.6087 3\n", + "2 1.229108 2 16.636703 43.7273 3\n", + "3 1.400000 3 10.739832 59.0435 3\n", + "4 2.666979 4 12.522300 43.6957 3" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.tree import DecisionTreeRegressor\n", + "\n", + "dt = DecisionTreeRegressor()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
DecisionTreeRegressor()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "DecisionTreeRegressor()" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dt.fit(X_train,y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.22038283, 0.64386564, 0.04414508, 0.08394337, 0.00766308])" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dt.feature_importances_" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['temp', 'days_since_2011', 'windspeed', 'hum', 'labeled_season'],\n", + " dtype=object)" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn import tree\n", + "\n", + "dt.feature_names_in_" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 temp\n", + "1 days_since_2011\n", + "2 windspeed\n", + "3 hum\n", + "4 labeled_season\n", + "dtype: object" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.Series(dt.feature_names_in_)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
featuresimportance
4labeled_season0.007663
2windspeed0.044145
3hum0.083943
0temp0.220383
1days_since_20110.643866
\n", + "
" + ], + "text/plain": [ + " features importance\n", + "4 labeled_season 0.007663\n", + "2 windspeed 0.044145\n", + "3 hum 0.083943\n", + "0 temp 0.220383\n", + "1 days_since_2011 0.643866" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fi_df = pd.DataFrame({'features':dt.feature_names_in_, 'importance': dt.feature_importances_}).sort_values('importance')\n", + "fi_df" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbkAAAD4CAYAAABxJ5hVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZdUlEQVR4nO3df5RddX3u8fdjCGVkICMEUxmEQYRQSSxjRgpKaYK9BvQWY4iWGtTgj2jlR7ssEdLQe+nVmti4/AFV2tBiqsIdNCsOAdRBSaZABCVhQoaAUwOJlcFewXaCg0Mcwuf+sffIyWQmcybzY5/zzfNa66zs893fs/dz9krmmb3PyTmKCMzMzFL0sqIDmJmZjReXnJmZJcslZ2ZmyXLJmZlZslxyZmaWrEOKDmAvmTp1ajQ0NJQ9/7nnnuPwww8fv0DjzPmLU83ZwfmLVmn5N2/e/ExEHDPYOpdcBWloaGDTpk1lz29ra2P27NnjF2icOX9xqjk7OH/RKi2/pJ8Otc6XK83MLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWX53pZmZFaalvYuVrZ081d3LsXU1LJk7nXmN9WO2/RGfyUm6VtKVY5agvH0eK2nNBOznf0jaLKkj//PcknWz8vHtkq6TpHz8XZK2SXpRUlPJ/KMlbZDUI+kfxju7mVm1aWnvYunaDrq6ewmgq7uXpWs7aGnvGrN9VMXlyoh4KiIWTMCungH+JCJmAu8Hvlay7gbgw8DJ+e28fPwRYD5wz4BtPQ/8DTChvxCYmVWLla2d9Pbt2Wust28PK1s7x2wfKuf75CQtI/uh/wvgZ8BmYBewGDgU2A68F5gEbAVOiYg+SUcCDwOnAH8OfBR4AXg0Ii4aYl9/BHwxvxvAOcDRwB0RMUPSIuAC4OXAScC3IuIT+WPPAz6d53gmIt4i6XDgemAGMBm4NiJuK+M5C/gl8CrgKGBDRJyar/szYHZEfKRkfhtwZURsGrCdRUBTRFw2xH4Wkx1Hpk2bNqu5uXm4aL/V09NDbW1t2fMrjfMXp5qzg/MXbazyd3TtGnLdzPopZW9nzpw5myOiabB1w74mJ2kWcBFwej7/IbKSWxsRN+ZzPgV8MCKuz3/Yvx1oyR+3Ni+8q4ETI2K3pLr97PJK4NKI2CipluyMaKDTgUZgN9Ap6fp83o3AORGxQ9JR+dxlwPqI+EC+3x9J+n5EPDfMU78QeCjPWw88WbLuSWBMLhpHxCpgFUBTU1OM5FMEKu1TB0bK+YtTzdnB+Ys2VvmXrVhPV3fvPuP1dTVcvnD024fyLlf+IdnZ0q8j4llgXT4+Q9K9kjqAhcBp+fg/A5fky5cAX8mXtwI3S7qY7GxuKBuBz0m6AqiLiMHm3h0RuyLieeBR4ATgTOCeiNgBEBH/lc99K3C1pC1AG3AYcPz+nrCk04DPAB/Z3zwzMztwS+ZOp2bypL3GaiZPYsnc6WO2j9G8JrcauCx//epvycqDiNgINEiaDUyKiEfy+W8HvgS8AXhQ0qBnkRGxAvgQUANslHTqINN2lyzvYf9npAIujIjT89vxEfHYkJOl44BvAe+LiMfz4S7guJJpx+VjZmZ2gOY11rN8/kzq62oQ2Rnc8vkzx/TdleX8F4J7gNWSlufz/wT4J+AI4OeSJpOdyZX+0P8qcAvwSQBJLwNeHREbJN1HdhmzFugeuDNJJ0VEB9Ah6Y3AqcCWMnI+AHxZ0on9lyvzs7lW4HJJl0dESGqMiPbBNpBfzrwTuDovawAi4ueSnpV0JvBD4H1kr/OZmdkozGusH9NSG2jYM7mIeAi4lewNJN8BHsxX/Q3ZD/yNwI8HPOxm4BXA/83vTwK+nl/abAeui4juIXb5l5IekbQV6Mv3OayIeJrsDRxrJT2cZ4asaCcDWyVty+8P5TLgtcD/krQlv70yX/cxskux24HH+3NJeqekJ4GzgDsltfZvTNJO4HPAIklPSnpdOc/FzMzGRln/GTwi/g74u0FW3TDEQ84G1vQXWUT05WPl7OvyQYZ3kr07kohYTXaptH/+/yxZ/g4DSjEieinztbWI+BTwqSHWberPMGD8W2SXNwd7TEM5+zUzs/Ex5p94kr/T8XzgbWO9bTMzs5EY85Ib4kxsH5IuAf5iwPDGiLh0rDMNsu+5ZO+eLLUjIt453vs2M7OJU9hnV0bEV3jpvxdM9L5byd6QYmZmCauKj/UyMzM7EC45MzNLlkvOzMyS5ZIzM7NkueTMzCxZLjkzM0uWS87MzJLlkjMzs2S55MzMLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWS45MzNLlkvOzMyS5ZIzM7NkueTMzCxZLjkzM0uWS87MzJLlkjMzs2S55MzMLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWS45MzNLlkvOzMyS5ZIzM7NkueTMzCxZLjkzM0uWS87MzJLlkjMzs2S55MzMLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWYcUHaCSSKoD3hMRXy46i1W3lvYuVrZ28lR3L8fW1bBk7nTmNdYXHcvsoOMzub3VAR8rOoRVt5b2Lpau7aCru5cAurp7Wbq2g5b2rqKjmR10XHJ7WwGcJGmLpJWSlkh6UNJWSX8LIKlB0o8lrZb075JulvTHkjZK+omkM/J510r6mqT78/EPF/rMbMKsbO2kt2/PXmO9fXtY2dpZUCKzg5ciougMFUNSA3BHRMyQ9FZgAfARQMA64O+B/wC2A43ANuBB4GHgg8AFwCURMU/StcA7gTOBw4F24A8i4qkB+1wMLAaYNm3arObm5rLz9vT0UFtbe6BPt3Cp5u/o2jXkY2bWTxnPSGVL9dhXC+cfW3PmzNkcEU2DrfNrckN7a35rz+/XAieTldyOiOgAkLQNuDsiQlIH0FCyjdsiohfolbQBOANoKd1JRKwCVgE0NTXF7Nmzyw7Y1tbGSOZXmlTzL1uxnq7u3n3G6+tquHzhvvOLkOqxrxbOP3F8uXJoApZHxOn57bUR8S/5ut0l814suf8ie//iMPA02afNB4Elc6dTM3nSXmM1kyexZO70ghKZHbxccnv7FXBEvtwKfEBSLYCkekmvHOH23iHpMElHA7PJLm1a4uY11rN8/kzq62oQ2Rnc8vkz/e5KswL4cmWJiPhl/gaSR4DvALcA90sC6AEuBvbsZxMDbQU2AFOBTw58Pc7SNa+x3qVmVgFccgNExHsGDH1xkGkzSuYvKlneWboO2BoR7xvLfGZmVj5frjQzs2T5TG6cRMS1RWcwMzvY+UzOzMyS5ZIzM7NkueTMzCxZLjkzM0uWS87MzJLlkjMzs2S55MzMLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWS45MzNLlkvOzMyS5ZIzM7NkueTMzCxZLjkzM0uWS87MzJLlkjMzs2S55MzMLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWS45MzNLlkvOzMyS5ZIzM7NkueTMzCxZLjkzM0uWS87MzJLlkjMzs2S55MzMLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWS45MzNLlkvOzMyS5ZIzM7NkHVJ0gEomqQG4IyJmFJ2lmrS0d7GytZOnuns5tq6GJXOnM6+xvuhYZnYQcsnZmGpp72Lp2g56+/YA0NXdy9K1HQAuOjObcL5cObxJkm6UtE3SXZJqJLVJagKQNFXSznx5kaQWSd+TtFPSZZI+Lqld0gOSjir0mUyAla2dvy24fr19e1jZ2llQIjM7mCkiis5QsfLLlduBpojYIukbwDrgQ8CVEbFJ0lRgU0Q0SFoEXAM0Aoflj70qIv5R0ueBn0bEFwbsYzGwGGDatGmzmpuby87X09NDbW3tKJ/l2Oro2jXkupn1U/a6X4n5R6Ka81dzdnD+olVa/jlz5myOiKbB1vly5fB2RMSWfHkz0DDM/A0R8SvgV5J2Abfn4x3A6wdOjohVwCqApqammD17dtnB2traGMn8ibBsxXq6unv3Ga+vq+HyhbP3GqvE/CNRzfmrOTs4f9GqKb8vVw5vd8nyHrJfDF7gpWN32H7mv1hy/0UOgl8qlsydTs3kSXuN1UyexJK50wtKZGYHM5fcgdkJzMqXFxSYo+LMa6xn+fyZ1NfVILIzuOXzZ/pNJ2ZWiOTPLMbJZ4Fv5K+n3Vl0mEozr7HepWZmFcEltx8RsROYUXL/syWrS19fuyZfvxpYXTK/oWR5r3VmZjb+fLnSzMyS5ZIzM7NkueTMzCxZLjkzM0uWS87MzJLlkjMzs2S55MzMLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWS45MzNLlkvOzMyS5ZIzM7NkueTMzCxZLjkzM0uWS87MzJLlkjMzs2S55MzMLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWS45MzNLlkvOzMyS5ZIzM7NkueTMzCxZLjkzM0uWS87MzJLlkjMzs2S55MzMLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWS45MzNLlkvOzMyS5ZIzM7NkueTMzCxZLjkzM0tWVZecpG9LqhvB/AZJj4xjpP3tu6eI/Zarpb2LN69Yz4lX38mbV6ynpb2r6EhmZqN2SNEBRiMi3lZ0hhS0tHexdG0HvX17AOjq7mXp2g4A5jXWFxnNzGxUKvpMTtISSVfky5+XtD5fPlfSzZJ2Spqan6E9JulGSdsk3SWpJp87S9LDkh4GLi3Z9mmSfiRpi6Stkk7Ot/PjfNuPSVoj6eUl2/k3SZsltUp6VT5+kqTv5uP3Sjo1Hz9R0v2SOiR9aoIP3YisbO38bcH16+3bw8rWzoISmZmNDUVE0RmGJOlM4K8i4l2S7gV+B3gz8NfAfwJLgSagFtgONEXEFknfANZFxNclbQUui4h7JK0Ezo+IGZKuBx6IiJslHQpMAqYBO4CzI2KjpJuAR4EvAv8GvCMinpb0p8DciPiApLuBj0bETyT9AbA8Is6VtA5YExFflXQp8JmIqB3kOS4GFgNMmzZtVnNzc9nHp6enh9rafTY5Yh1du4ZcN7N+yqi3P5Sxyl+Uas5fzdnB+YtWafnnzJmzOSKaBltX6ZcrNwOzJB0J7AYeIiu1PwSuICu5fjsiYkvJ4xry1+vqIuKefPxrwPn58v3AMknHAWvzkgL4WURszOd8Pd/Pd4EZwPfyOZOAn0uqBd4EfDMfh6yIISvjC0v2+5nBnmBErAJWATQ1NcXs2bPLOS4AtLW1MZL5Q1m2Yj1d3b37jNfX1XD5wtFvfyhjlb8o1Zy/mrOD8xetmvJX9OXKiOgjO7NaBPwAuBeYA7wWeGzA9N0ly3sYpsAj4hbgAqAX+Lakc/tXDZwKCNgWEafnt5kR8Vay49ddMn56RPzegMdWvCVzp1MzedJeYzWTJ7Fk7vSCEpmZjY2KLrncvcCVwD358keB9ijjOmtEdAPdks7Ohxb2r5P0GuCJiLgOuA14fb7qeEln5cvvAe4DOoFj+sclTZZ0WkQ8C+yQ9K58XJJ+P3/sRuCigfutRPMa61k+fyb1dTWI7Axu+fyZftOJmVW9Sr9cCVmxLQPuj4jnJD2fj5XrEuAmSQHcVTL+buC9kvrIXt/7NHAkWaFdWvJ63A0R8RtJC4DrJE0hO25fALaRFdgNkq4BJgPNwMPAXwC3SLqKrEQr2rzGepeamSWn4ksuIu4mK4/++6eULDfki8+QvWbWP/7ZkuXNQP/ZFcAn8vEVwIrSfeWv/b0QERcPkmMLcM4g4zuA84YYP6tk6JpBnp6ZmY2jarhcaWZmdkAq/kxuIkXETkrOCM3MrLr5TM7MzJLlkjMzs2S55MzMLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWS45MzNLlkvOzMyS5ZIzM7NkueTMzCxZLjkzM0uWS87MzJLlkjMzs2S55MzMLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWS45MzNLlkvOzMyS5ZIzM7NkueTMzCxZLjkzM0uWS87MzJLlkjMzs2S55MzMLFkuOTMzS5ZLzszMkuWSMzOzZLnkzMwsWS45MzNLlkvOzMyS5ZIzM7NkueTMzCxZLjkzM0uWS87MzJLlkjMzs2S55MzMLFmHFB3ARq+lvYuVrZ081d3LsXU1LJk7nXmN9UXHMjMr3KjP5CT1DLO+QdIjI9zmakkLRjB/xPtIRUt7F0vXdtDV3UsAXd29LF3bQUt7V9HRzMwK58uVVW5laye9fXv2Guvt28PK1s6CEpmZVQ5FxOg2IPVERK2kWuA24BXAZOCaiLhNUgPwXWAz8AZgG/C+iPi1pFnA54Ba4BlgUUT8XNJq4I6IWLOfObOAm/IYdwHnR8SMITKeBnwFOJSs2C+MiJ9Iuhi4Ih//IfCxiNgj6QbgjUANsCYi/ne+nRXABcALwF0RcWX+/G4CpgJPA5dExH/kz+FZoAn4XeATEbFmkGyLgcUA06ZNm9Xc3Fz2se/p6WHHrj1Drp9ZP6XsbRWhp6eH2traomMcsGrOX83ZwfmLVmn558yZszkimgZdGRGjugE9+Z+HAEfmy1OB7YCABiCAN+frbgKuJCvCHwDH5ON/CtyUL68GFgwzZytwTr68EnhkPxmvBxbmy4eSldfvAbcDk/PxL5OVL8BR+Z+TgDbg9cDRQCcv/WJQl/95O/D+fPkDQEvJc/gmWam+Dtg+3LGcNWtWjMSGDRviTcvvjhOuumOf25uW3z2ibRVhw4YNRUcYlWrOX83ZI5y/aJWWH9gUQ/xcHcvLlQI+LWkr8H2gHpiWr/tZRGzMl78OnA1MB2YA35O0BbgGOG7ANgedI6kuL5l78nlfGybb/cBfS7oKOCEieoG3ALOAB/NtvwV4TT7/3ZIeAtqB08hKahfwPPAvkuYDv87nngXcUpLj7JL9tkTEixHxaMmxGFNL5k6nZvKkvcZqJk9iydzp47E7M7OqMpbvrlwIHAPMiog+STuBw/J1A6+JBlkpbouIs/azzUHn5CVXtoi4RdIPgbcD35b0kXzb/xoRSwds+0SyM803RsR/55cdD4uIFySdQVaGC4DLgHOH2fXuAc9lzPW/i9LvrjQz29dYltwU4Bd5wc0BTihZd7yksyLifuA9wH1kl/6O6R+XNBk4JSK2lTxuyDmSuiWdHRH3kRXskCS9BngiIq6TdDzZ5ce7gNskfT4ifiHpKOAI4EjgOWCXpGnA+UBb/prjyyPi25I2Ak/km/8BcBHZWdxC4N4DPH4HbF5jvUvNzGwQY1lyNwO3S+oANgE/LlnXCVwq6SbgUeCGiPhN/t8ErpM0Jc/yBbI3pgAwzJxLgJskBVlh7c+7gfdK6gP+E/h0RPyXpGuAuyS9DOgDLo2IByS15/l/BvRfZj2CrBQPIzsr+3g+fjnwFUlLyN94Uv4hMzOz8TTqkouI2vzPZ8henxrMqUM8dgtwziDji8qYsxn4/ZKhT+wn4wpgxSDjtwK37m//A5wxyNyfMshly4Hb6D9OZmY2cfz/5MzMLFlJfayXpLnAZwYM74iIdxaRx8zMipVUyUVEK9BadA4zM6sMo/7EExs7kp4GfjqCh0wl+xSYauX8xanm7OD8Rau0/CdExDGDrXDJVTFJm2Koj7KpAs5fnGrODs5ftGrK7zeemJlZslxyZmaWLJdcdVtVdIBRcv7iVHN2cP6iVU1+vyZnZmbJ8pmcmZklyyVnZmbJcslVAUnnSeqUtF3S1YOs/x1Jt+brf5h/W3lFKCP7OZIekvRC/mHcFaWM/B+X9KikrZLulnTCYNspShn5PyqpQ9IWSfdJel0ROYcyXP6SeRdKCkkV9bb2Mo7/IklP58d/i6QPFZFzKOUcf0nvzv8NbJN0y2BzCjXUt6n6Vhk3sm8nf5zsC10PBR4GXjdgzseAf8yXLwJuLTr3CLI3kH310VeBBUVnPoD8c8i+ggngzyvl2I8g/5ElyxcA3y0690jy5/OOAO4BHgCais49wuO/CPiHorOOIv/JZF8u/Yr8/iuLzj3w5jO5yncGsD0inoiI3wDNwDsGzHkH8K/58hrgLZLG5UtaR2jY7BGxMyK2Ai8WEXAY5eTfEBH93xL/APt+u32Rysn/bMndw9n3C46LVM7ffYBPkn1m7fMTGa4M5eavVOXk/zDwpYj4b4CI+MUEZxyWS67y1ZN9r12/J/OxQedExAvALuDoCUm3f+Vkr2Qjzf9B4Dvjmmhkysov6VJJjwN/D1wxQdnKMWx+SW8AXh0Rd05ksDKV+/fnwvxy9xpJr56YaGUpJ/8pwCmSNkp6QNJ5E5auTC45szEg6WKgCVhZdJaRiogvRcRJwFXANUXnKVf+ZcefA/6q6CyjcDvQEBGvB77HS1dkqsUhZJcsZwN/Btwoqa7IQAO55CpfF1D6291x+digcyQdAkwBfjkh6favnOyVrKz8kv4YWAZcEBG7JyhbOUZ6/JuBeeMZaISGy38EMANok7QTOBNYV0FvPhn2+EfEL0v+zvwzMGuCspWjnL8/TwLrIqIvInYA/05WehXDJVf5HgROlnSipEPJ3liybsCcdcD78+UFwPrIXwUuWDnZK9mw+SU1Av9EVnCV9npEOflLfyC9HfjJBOYbzn7zR8SuiJgaEQ0R0UD2mugFEbGpmLj7KOf4v6rk7gXAYxOYbzjl/PttITuLQ9JUssuXT0xgxuEV/c4X34a/AW8j+w3pcWBZPvZ/yP5BAxwGfBPYDvwIeE3RmUeQ/Y1kvw0+R3b2ua3ozCPM/33g/wFb8tu6ojOPMP8XgW159g3AaUVnHkn+AXPbqKB3V5Z5/Jfnx//h/PifWnTmEeYX2SXjR4EO4KKiMw+8+WO9zMwsWb5caWZmyXLJmZlZslxyZmaWLJecmZklyyVnZmbJcsmZmVmyXHJmZpas/w8np+WRMaySVgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(fi_df['importance'], fi_df['features'])\n", + "plt.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [], + "source": [ + "# le.inverse_transform(dt_df['labeled_season'])" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "season_map = {\n", + " 'WINTER': 1,\n", + " 'FALL': 2,\n", + " 'SPRING': 3,\n", + " 'SUMMER': 4\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/3h/n7g9d8x521gg4nfvf31y3_840000gn/T/ipykernel_15068/3250286714.py:1: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " dt_df['my_season'] = dt_df['season'].map(season_map)\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tempseasondays_since_2011windspeedhumcntlabeled_seasonmy_season
08.175849WINTER010.74988280.583398531
19.083466WINTER116.65211369.608780131
21.229108WINTER216.63670343.7273134931
31.400000WINTER310.73983259.0435156231
42.666979WINTER412.52230043.6957160031
...........................
7263.945849WINTER72623.45891165.2917211431
7273.906651WINTER72710.41655759.0000309531
7283.906651WINTER7288.33366175.2917134131
7294.024151WINTER72923.50051848.3333179631
7302.144151WINTER73010.37468257.7500272931
\n", + "

731 rows × 8 columns

\n", + "
" + ], + "text/plain": [ + " temp season days_since_2011 windspeed hum cnt \\\n", + "0 8.175849 WINTER 0 10.749882 80.5833 985 \n", + "1 9.083466 WINTER 1 16.652113 69.6087 801 \n", + "2 1.229108 WINTER 2 16.636703 43.7273 1349 \n", + "3 1.400000 WINTER 3 10.739832 59.0435 1562 \n", + "4 2.666979 WINTER 4 12.522300 43.6957 1600 \n", + ".. ... ... ... ... ... ... \n", + "726 3.945849 WINTER 726 23.458911 65.2917 2114 \n", + "727 3.906651 WINTER 727 10.416557 59.0000 3095 \n", + "728 3.906651 WINTER 728 8.333661 75.2917 1341 \n", + "729 4.024151 WINTER 729 23.500518 48.3333 1796 \n", + "730 2.144151 WINTER 730 10.374682 57.7500 2729 \n", + "\n", + " labeled_season my_season \n", + "0 3 1 \n", + "1 3 1 \n", + "2 3 1 \n", + "3 3 1 \n", + "4 3 1 \n", + ".. ... ... \n", + "726 3 1 \n", + "727 3 1 \n", + "728 3 1 \n", + "729 3 1 \n", + "730 3 1 \n", + "\n", + "[731 rows x 8 columns]" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dt_df['my_season'] = dt_df['season'].map(season_map)\n", + "dt_df" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "# Splitting the data into train test split\n", + "\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "X = dt_df[[col for col in dt_df.columns if col not in ['cnt','season', 'labeled_season']]]\n", + "y = dt_df['cnt']\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Features')" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "dt = DecisionTreeRegressor()\n", + "dt.fit(X,y)\n", + "fi_df = pd.DataFrame({'features':dt.feature_names_in_, 'importance': dt.feature_importances_}).sort_values('importance')\n", + "plt.scatter(fi_df['importance'], fi_df['features'])\n", + "plt.grid()\n", + "plt.xlabel('Importance')\n", + "plt.ylabel('Features')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On average, 70% of node purity was explained by (contributed to) 'days_since_2011'." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Partial Dependence Plot\n", + "1. Run a model (preferably Tree model)\n", + "2. from sklearn.inspection import plot_partial_dependence" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.ensemble import RandomForestRegressor" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
RandomForestRegressor(n_estimators=50, random_state=0)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "RandomForestRegressor(n_estimators=50, random_state=0)" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rf = RandomForestRegressor(\n", + " n_estimators=50,\n", + " random_state=0\n", + ")\n", + "\n", + "rf.fit(\n", + " X_train,\n", + " y_train,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.inspection import plot_partial_dependence, PartialDependenceDisplay\n", + "\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "PartialDependenceDisplay.from_estimator(\n", + " estimator=rf,\n", + " X=X_train,\n", + " features=X_train.columns,\n", + " target=y_train,\n", + " ax=ax\n", + ")\n", + "ax.set_title(\"Partial Dependence Plot\")\n", + "plt.tight_layout();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Temperature affects the Bike Count by:\n", + "* positively correlation from 0-15 degrees C\n", + "* levels off from 15-25 degrees C\n", + "* starts a slight dip after 25 deegrees C\n", + "\n", + "Days Since 2011\n", + "* Overall positive trend\n", + "* Cyclic\n", + "\n", + "Windspeed\n", + "* As wind speed increases, the bike count decreases\n", + "\n", + "Humidity\n", + "* Similar to windspeed\n", + "* As Humidity increases, the number of bikes rented decreases slightly\n", + "\n", + "Season\n", + "* Seems not to affect the number of rented bikes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ALE Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "from PyALE import ale" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [], + "source": [ + "le = LabelEncoder()\n", + "cleaned_bike_data['mnth'] = le.fit_transform(cleaned_bike_data['mnth'])" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [], + "source": [ + "# Splitting the data into train test split\n", + "\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "X = cleaned_bike_data[[col for col in cleaned_bike_data.columns if col not in ['cnt', 'season', 'working_day', 'weathersit']]]\n", + "y = cleaned_bike_data['cnt']\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "could not convert string to float: 'NO HOLIDAY'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/Users/tqrahman/Desktop/Biased_Outliers/interpretable-ml-book/Python/bike-sharing/bike-sharing-dataset.ipynb Cell 82\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m rf \u001b[39m=\u001b[39m RandomForestRegressor()\n\u001b[0;32m----> 2\u001b[0m rf\u001b[39m.\u001b[39;49mfit(X_train, y_train)\n", + "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/sklearn/ensemble/_forest.py:331\u001b[0m, in \u001b[0;36mBaseForest.fit\u001b[0;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[1;32m 329\u001b[0m \u001b[39mif\u001b[39;00m issparse(y):\n\u001b[1;32m 330\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39msparse multilabel-indicator for y is not supported.\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m--> 331\u001b[0m X, y \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_validate_data(\n\u001b[1;32m 332\u001b[0m X, y, multi_output\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m, accept_sparse\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mcsc\u001b[39;49m\u001b[39m\"\u001b[39;49m, dtype\u001b[39m=\u001b[39;49mDTYPE\n\u001b[1;32m 333\u001b[0m )\n\u001b[1;32m 334\u001b[0m \u001b[39mif\u001b[39;00m sample_weight \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 335\u001b[0m sample_weight \u001b[39m=\u001b[39m _check_sample_weight(sample_weight, X)\n", + "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/sklearn/base.py:596\u001b[0m, in \u001b[0;36mBaseEstimator._validate_data\u001b[0;34m(self, X, y, reset, validate_separately, **check_params)\u001b[0m\n\u001b[1;32m 594\u001b[0m y \u001b[39m=\u001b[39m check_array(y, input_name\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39my\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mcheck_y_params)\n\u001b[1;32m 595\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 596\u001b[0m X, y \u001b[39m=\u001b[39m check_X_y(X, y, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mcheck_params)\n\u001b[1;32m 597\u001b[0m out \u001b[39m=\u001b[39m X, y\n\u001b[1;32m 599\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m no_val_X \u001b[39mand\u001b[39;00m check_params\u001b[39m.\u001b[39mget(\u001b[39m\"\u001b[39m\u001b[39mensure_2d\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mTrue\u001b[39;00m):\n", + "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/sklearn/utils/validation.py:1074\u001b[0m, in \u001b[0;36mcheck_X_y\u001b[0;34m(X, y, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, multi_output, ensure_min_samples, ensure_min_features, y_numeric, estimator)\u001b[0m\n\u001b[1;32m 1069\u001b[0m estimator_name \u001b[39m=\u001b[39m _check_estimator_name(estimator)\n\u001b[1;32m 1070\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m 1071\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m{\u001b[39;00mestimator_name\u001b[39m}\u001b[39;00m\u001b[39m requires y to be passed, but the target y is None\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 1072\u001b[0m )\n\u001b[0;32m-> 1074\u001b[0m X \u001b[39m=\u001b[39m check_array(\n\u001b[1;32m 1075\u001b[0m X,\n\u001b[1;32m 1076\u001b[0m accept_sparse\u001b[39m=\u001b[39;49maccept_sparse,\n\u001b[1;32m 1077\u001b[0m accept_large_sparse\u001b[39m=\u001b[39;49maccept_large_sparse,\n\u001b[1;32m 1078\u001b[0m dtype\u001b[39m=\u001b[39;49mdtype,\n\u001b[1;32m 1079\u001b[0m order\u001b[39m=\u001b[39;49morder,\n\u001b[1;32m 1080\u001b[0m copy\u001b[39m=\u001b[39;49mcopy,\n\u001b[1;32m 1081\u001b[0m force_all_finite\u001b[39m=\u001b[39;49mforce_all_finite,\n\u001b[1;32m 1082\u001b[0m ensure_2d\u001b[39m=\u001b[39;49mensure_2d,\n\u001b[1;32m 1083\u001b[0m allow_nd\u001b[39m=\u001b[39;49mallow_nd,\n\u001b[1;32m 1084\u001b[0m ensure_min_samples\u001b[39m=\u001b[39;49mensure_min_samples,\n\u001b[1;32m 1085\u001b[0m ensure_min_features\u001b[39m=\u001b[39;49mensure_min_features,\n\u001b[1;32m 1086\u001b[0m estimator\u001b[39m=\u001b[39;49mestimator,\n\u001b[1;32m 1087\u001b[0m input_name\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mX\u001b[39;49m\u001b[39m\"\u001b[39;49m,\n\u001b[1;32m 1088\u001b[0m )\n\u001b[1;32m 1090\u001b[0m y \u001b[39m=\u001b[39m _check_y(y, multi_output\u001b[39m=\u001b[39mmulti_output, y_numeric\u001b[39m=\u001b[39my_numeric, estimator\u001b[39m=\u001b[39mestimator)\n\u001b[1;32m 1092\u001b[0m check_consistent_length(X, y)\n", + "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/sklearn/utils/validation.py:856\u001b[0m, in \u001b[0;36mcheck_array\u001b[0;34m(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, estimator, input_name)\u001b[0m\n\u001b[1;32m 854\u001b[0m array \u001b[39m=\u001b[39m array\u001b[39m.\u001b[39mastype(dtype, casting\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39munsafe\u001b[39m\u001b[39m\"\u001b[39m, copy\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n\u001b[1;32m 855\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 856\u001b[0m array \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49masarray(array, order\u001b[39m=\u001b[39;49morder, dtype\u001b[39m=\u001b[39;49mdtype)\n\u001b[1;32m 857\u001b[0m \u001b[39mexcept\u001b[39;00m ComplexWarning \u001b[39mas\u001b[39;00m complex_warning:\n\u001b[1;32m 858\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m 859\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mComplex data not supported\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39m{}\u001b[39;00m\u001b[39m\\n\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(array)\n\u001b[1;32m 860\u001b[0m ) \u001b[39mfrom\u001b[39;00m \u001b[39mcomplex_warning\u001b[39;00m\n", + "File \u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/pandas/core/generic.py:2064\u001b[0m, in \u001b[0;36mNDFrame.__array__\u001b[0;34m(self, dtype)\u001b[0m\n\u001b[1;32m 2063\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__array__\u001b[39m(\u001b[39mself\u001b[39m, dtype: npt\u001b[39m.\u001b[39mDTypeLike \u001b[39m|\u001b[39m \u001b[39mNone\u001b[39;00m \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m np\u001b[39m.\u001b[39mndarray:\n\u001b[0;32m-> 2064\u001b[0m \u001b[39mreturn\u001b[39;00m np\u001b[39m.\u001b[39;49masarray(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_values, dtype\u001b[39m=\u001b[39;49mdtype)\n", + "\u001b[0;31mValueError\u001b[0m: could not convert string to float: 'NO HOLIDAY'" + ] + } + ], + "source": [ + "rf = RandomForestRegressor()\n", + "rf.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PyALE._ALE_generic:INFO: Continuous feature detected.\n", + "PyALE._ALE_generic:INFO: Continuous feature detected.\n", + "PyALE._ALE_generic:INFO: Continuous feature detected.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# fig, [ax1, ax2, ax3] = plt.subplots(nrows=1,ncols=3,figsize=(12,6))\n", + "\n", + "ale_temp = ale(\n", + " X=cleaned_bike_data, \n", + " model=rf, \n", + " feature=['temp'], \n", + " grid_size=50, \n", + " include_CI=False,\n", + " # ax=ax1\n", + ")\n", + "\n", + "ale_hum = ale(\n", + " X=X_train, \n", + " model=rf, \n", + " feature=['hum'], \n", + " grid_size=50, \n", + " include_CI=False,\n", + " # ax=ax2\n", + ")\n", + "\n", + "ale_ws = ale(\n", + " X=X_train, \n", + " model=rf, \n", + " feature=['windspeed'], \n", + " grid_size=50, \n", + " include_CI=False,\n", + " # ax=ax3\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "PyALE._ALE_generic:INFO: Discrete feature detected.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ale_eff = ale(\n", + " X=X_train, \n", + " model=rf, \n", + " feature=['my_season'], \n", + " grid_size=50, \n", + " include_CI=False,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['temp', 'hum', 'windspeed', 'days_since_2011', 'season_SPRING',\n", + " 'season_SUMMER', 'season_WINTER', 'holiday_NO HOLIDAY',\n", + " 'workingday_WORKING DAY', 'weathersit_MISTY',\n", + " 'weathersit_RAIN/SNOW/STORM'],\n", + " dtype='object')" + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train.columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ale_eff = ale(\n", + " X=X_train, \n", + " model=rf, \n", + " feature=[''], \n", + " grid_size=50, \n", + " include_CI=False,\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.5 64-bit", + "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.10.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Python/bike-sharing/preprocess_bike_data.py b/Python/bike-sharing/preprocess_bike_data.py new file mode 100644 index 00000000..15c07ab6 --- /dev/null +++ b/Python/bike-sharing/preprocess_bike_data.py @@ -0,0 +1,70 @@ +# Imports +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt + +# Setting up the path +DIR = "../../data/" +DATA = "bike-sharing-daily.csv" + +# Label Lists +weekdays = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT'] +holidays = ['NO HOLIDAY', 'HOLIDAY'] +working_day = ['NO WORKING DAY', 'WORKING DAY'] +season = ['WINTER', 'SPRING', 'SUMMER', 'FALL'] +weathersit = ['GOOD', 'MISTY', 'RAIN/SNOW/STORM'] +months = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC'] + +# Function to create a dictionary mapping index of list to the respective label +def create_dictionary(label_list, start_at_zero=True): + d = {} + if start_at_zero: + for idx, val in enumerate(label_list): + d[idx] = val + else: + for idx, val in enumerate(label_list): + d[idx+1] = val + return d + +# Function that denormalizes temperture +def inverse_min_max(row, tmin, tmax): + return row * (tmax - tmin) + tmin + +def data_pipeline(): + + # Reading in the data + day_bike_rentals = pd.read_csv(DIR+DATA) + + # Mapping numerical codes with actual values + day_bike_rentals['weekday'] = day_bike_rentals['weekday'].map(create_dictionary(weekdays)) + day_bike_rentals['holiday'] = day_bike_rentals['holiday'].map(create_dictionary(holidays)) + day_bike_rentals['workingday'] = day_bike_rentals['workingday'].map(create_dictionary(working_day)) + day_bike_rentals['season'] = day_bike_rentals['season'].map(create_dictionary(season, start_at_zero=False)) + day_bike_rentals['weathersit'] = day_bike_rentals['weathersit'].map(create_dictionary(weathersit, start_at_zero=False)) + day_bike_rentals['mnth'] = day_bike_rentals['mnth'].map(create_dictionary(months, start_at_zero=False)) + + # Reversing min_max + day_bike_rentals['temp'] = day_bike_rentals['temp'].apply(inverse_min_max, args=(-8, 39)) + day_bike_rentals['atemp'] = day_bike_rentals['atemp'].apply(inverse_min_max, args=(-16, 50)) + + # Unnormalizing the data + day_bike_rentals['windspeed'] = day_bike_rentals['windspeed'].apply(lambda row: row * 67) + day_bike_rentals['hum'] = day_bike_rentals['hum'].apply(lambda row: row * 100) + + # Converting labels into actual year + day_bike_rentals['yr'] = day_bike_rentals['yr'].apply(lambda row: 2011 if row == 0 else 2012) + + # Converting 'dteday' to datetime object + day_bike_rentals['dteday'] = pd.to_datetime(day_bike_rentals['dteday']) + + # Calculating days since 2011 + day_bike_rentals['days_since_2011'] = (day_bike_rentals['dteday'] - day_bike_rentals['dteday'].min()).dt.days + + # Feature selecting + day_bike_rentals = day_bike_rentals[[col for col in day_bike_rentals.columns if col not in ['instant', 'dteday', 'registered', 'casual', 'atemp']]] + + # Dummifying categorical features + day_bike_rentals = pd.concat([day_bike_rentals, pd.get_dummies(day_bike_rentals[['season', 'holiday','workingday', 'weathersit']], drop_first=True)], axis=1) + + # Returning the cleaned data + return day_bike_rentals \ No newline at end of file diff --git a/Python/cervical-cancer/Chapter5-interpretable_models.ipynb b/Python/cervical-cancer/Chapter5-interpretable_models.ipynb new file mode 100644 index 00000000..9045ced2 --- /dev/null +++ b/Python/cervical-cancer/Chapter5-interpretable_models.ipynb @@ -0,0 +1,461 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from preprocess_cervical_cancer_data import data_pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AgeNumber.of.sexual.partnersFirst.sexual.intercourseNum.of.pregnanciesSmokesSmokes..years.Hormonal.ContraceptivesHormonal.Contraceptives..years.IUDIUD..years.STDsSTDs..number.STDs..Number.of.diagnosisSTDs..Time.since.first.diagnosisSTDs..Time.since.last.diagnosisBiopsy
018415100.000.000.0000110
115114100.000.000.0000110
234115100.000.000.0000110
3525164137.013.000.0000110
446321400.0115.000.0000110
\n", + "
" + ], + "text/plain": [ + " Age Number.of.sexual.partners ... STDs..Time.since.last.diagnosis Biopsy\n", + "0 18 4 ... 1 0\n", + "1 15 1 ... 1 0\n", + "2 34 1 ... 1 0\n", + "3 52 5 ... 1 0\n", + "4 46 3 ... 1 0\n", + "\n", + "[5 rows x 16 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cervical = data_pipeline()\n", + "cervical.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "some_risk_factors = ['Hormonal.Contraceptives', 'Smokes', 'Num.of.pregnancies', 'STDs..Number.of.diagnosis', 'IUD']" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
LogisticRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LogisticRegression()" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# from sklearn.linear_model import LogisticRegression\n", + "\n", + "# lr = LogisticRegression()\n", + "# lr.fit(cervical[some_risk_factors], cervical['Biopsy'])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimization terminated successfully.\n", + " Current function value: 0.297389\n", + " Iterations 7\n" + ] + } + ], + "source": [ + "import statsmodels.api as sm\n", + "\n", + "lr = sm.Logit(cervical['Biopsy'], cervical[some_risk_factors]).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Logit Regression Results
Dep. Variable: Biopsy No. Observations: 858
Model: Logit Df Residuals: 853
Method: MLE Df Model: 4
Date: Tue, 06 Dec 2022 Pseudo R-squ.: -0.2490
Time: 10:41:08 Log-Likelihood: -255.16
converged: True LL-Null: -204.30
Covariance Type: nonrobust LLR p-value: 1.000
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
coef std err z P>|z| [0.025 0.975]
Hormonal.Contraceptives -1.2914 0.220 -5.857 0.000 -1.723 -0.859
Smokes -0.3487 0.365 -0.955 0.339 -1.064 0.367
Num.of.pregnancies -0.8171 0.099 -8.284 0.000 -1.010 -0.624
STDs..Number.of.diagnosis 0.3884 0.329 1.181 0.238 -0.256 1.033
IUD 0.6721 0.416 1.617 0.106 -0.143 1.487
" + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " Logit Regression Results \n", + "==============================================================================\n", + "Dep. Variable: Biopsy No. Observations: 858\n", + "Model: Logit Df Residuals: 853\n", + "Method: MLE Df Model: 4\n", + "Date: Tue, 06 Dec 2022 Pseudo R-squ.: -0.2490\n", + "Time: 10:41:08 Log-Likelihood: -255.16\n", + "converged: True LL-Null: -204.30\n", + "Covariance Type: nonrobust LLR p-value: 1.000\n", + "=============================================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "---------------------------------------------------------------------------------------------\n", + "Hormonal.Contraceptives -1.2914 0.220 -5.857 0.000 -1.723 -0.859\n", + "Smokes -0.3487 0.365 -0.955 0.339 -1.064 0.367\n", + "Num.of.pregnancies -0.8171 0.099 -8.284 0.000 -1.010 -0.624\n", + "STDs..Number.of.diagnosis 0.3884 0.329 1.181 0.238 -0.256 1.033\n", + "IUD 0.6721 0.416 1.617 0.106 -0.143 1.487\n", + "=============================================================================================\n", + "\"\"\"" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lr.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "weights = lr.params.to_dict()\n", + "std_error = lr.bse.to_dict()\n", + "odds_ratio = {}\n", + "for key, val in weights.items():\n", + " odds_ratio[key] = np.exp(val)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
weightsodds_ratiostd_error
Hormonal.Contraceptives-1.2913530.2748990.220483
Smokes-0.3487320.7055820.365052
Num.of.pregnancies-0.8171200.4417020.098634
STDs..Number.of.diagnosis0.3883921.4746080.328834
IUD0.6721031.9583510.415768
\n", + "
" + ], + "text/plain": [ + " weights odds_ratio std_error\n", + "Hormonal.Contraceptives -1.291353 0.274899 0.220483\n", + "Smokes -0.348732 0.705582 0.365052\n", + "Num.of.pregnancies -0.817120 0.441702 0.098634\n", + "STDs..Number.of.diagnosis 0.388392 1.474608 0.328834\n", + "IUD 0.672103 1.958351 0.415768" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "for key, val in weights.items():\n", + " weights[key] = [val]\n", + "\n", + "t = pd.DataFrame(weights, index=['weights']).T\n", + "t['odds_ratio'] = t.index.map(odds_ratio)\n", + "t['std_error'] = t.index.map(std_error)\n", + "\n", + "t" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Python/cervical-cancer/__pycache__/preprocess_cervical_cancer_data.cpython-310.pyc b/Python/cervical-cancer/__pycache__/preprocess_cervical_cancer_data.cpython-310.pyc new file mode 100644 index 00000000..5141eb60 Binary files /dev/null and b/Python/cervical-cancer/__pycache__/preprocess_cervical_cancer_data.cpython-310.pyc differ diff --git a/Python/cervical-cancer/cervical_cancer_data.ipynb b/Python/cervical-cancer/cervical_cancer_data.ipynb new file mode 100644 index 00000000..42d6d442 --- /dev/null +++ b/Python/cervical-cancer/cervical_cancer_data.ipynb @@ -0,0 +1,733 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Imports\n", + "\n", + "import pandas as pd\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from sklearn.inspection import PartialDependenceDisplay\n", + "from sklearn.ensemble import RandomForestClassifier" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AgeNumber.of.sexual.partnersFirst.sexual.intercourseNum.of.pregnanciesSmokesSmokes..years.Hormonal.ContraceptivesHormonal.Contraceptives..years.IUDIUD..years.STDsSTDs..number.STDs..Number.of.diagnosisSTDs..Time.since.first.diagnosisSTDs..Time.since.last.diagnosisBiopsy
018415100.000.000.000011Healthy
115114100.000.000.000011Healthy
234115100.000.000.000011Healthy
3525164137.013.000.000011Healthy
446321400.0115.000.000011Healthy
\n", + "
" + ], + "text/plain": [ + " Age Number.of.sexual.partners First.sexual.intercourse \\\n", + "0 18 4 15 \n", + "1 15 1 14 \n", + "2 34 1 15 \n", + "3 52 5 16 \n", + "4 46 3 21 \n", + "\n", + " Num.of.pregnancies Smokes Smokes..years. Hormonal.Contraceptives \\\n", + "0 1 0 0.0 0 \n", + "1 1 0 0.0 0 \n", + "2 1 0 0.0 0 \n", + "3 4 1 37.0 1 \n", + "4 4 0 0.0 1 \n", + "\n", + " Hormonal.Contraceptives..years. IUD IUD..years. STDs STDs..number. \\\n", + "0 0.0 0 0.0 0 0 \n", + "1 0.0 0 0.0 0 0 \n", + "2 0.0 0 0.0 0 0 \n", + "3 3.0 0 0.0 0 0 \n", + "4 15.0 0 0.0 0 0 \n", + "\n", + " STDs..Number.of.diagnosis STDs..Time.since.first.diagnosis \\\n", + "0 0 1 \n", + "1 0 1 \n", + "2 0 1 \n", + "3 0 1 \n", + "4 0 1 \n", + "\n", + " STDs..Time.since.last.diagnosis Biopsy \n", + "0 1 Healthy \n", + "1 1 Healthy \n", + "2 1 Healthy \n", + "3 1 Healthy \n", + "4 1 Healthy " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Reading in the data\n", + "\n", + "DIR = \"../../data/\"\n", + "DATA = \"cervical.csv\"\n", + "cervical = pd.read_csv(DIR+DATA)\n", + "cervical.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Converting the \"Biopsy\" to binary\n", + "\n", + "cervical['Biopsy'] = cervical['Biopsy'].apply(lambda row: 1 if row=='Cancer' else 0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "cervical.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AgeNumber.of.sexual.partnersFirst.sexual.intercourseNum.of.pregnanciesSmokesSmokes..years.Hormonal.ContraceptivesHormonal.Contraceptives..years.IUDIUD..years.STDsSTDs..number.STDs..Number.of.diagnosisSTDs..Time.since.first.diagnosisSTDs..Time.since.last.diagnosis
count858.000000858.000000858.000000858.000000858.000000858.000000858.000000858.000000858.000000858.000000858.000000858.000000858.000000858.000000858.000000
mean26.8205132.51165516.9790212.1923080.1433571.2012410.6864801.9723940.0967370.4446040.0920750.1550120.0874131.4254081.398601
std8.4979481.6447592.7976531.4343950.3506414.0606230.4641943.5978880.2957711.8142180.2893000.5296170.3025452.2015502.113931
min13.0000001.00000010.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000001.0000001.000000
25%20.0000002.00000015.0000001.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000000.0000001.0000001.000000
50%25.0000002.00000017.0000002.0000000.0000000.0000001.0000000.2500000.0000000.0000000.0000000.0000000.0000001.0000001.000000
75%32.0000003.00000018.0000003.0000000.0000000.0000001.0000002.0000000.0000000.0000000.0000000.0000000.0000001.0000001.000000
max84.00000028.00000032.00000011.0000001.00000037.0000001.00000030.0000001.00000019.0000001.0000004.0000003.00000022.00000022.000000
\n", + "
" + ], + "text/plain": [ + " Age Number.of.sexual.partners First.sexual.intercourse \\\n", + "count 858.000000 858.000000 858.000000 \n", + "mean 26.820513 2.511655 16.979021 \n", + "std 8.497948 1.644759 2.797653 \n", + "min 13.000000 1.000000 10.000000 \n", + "25% 20.000000 2.000000 15.000000 \n", + "50% 25.000000 2.000000 17.000000 \n", + "75% 32.000000 3.000000 18.000000 \n", + "max 84.000000 28.000000 32.000000 \n", + "\n", + " Num.of.pregnancies Smokes Smokes..years. \\\n", + "count 858.000000 858.000000 858.000000 \n", + "mean 2.192308 0.143357 1.201241 \n", + "std 1.434395 0.350641 4.060623 \n", + "min 0.000000 0.000000 0.000000 \n", + "25% 1.000000 0.000000 0.000000 \n", + "50% 2.000000 0.000000 0.000000 \n", + "75% 3.000000 0.000000 0.000000 \n", + "max 11.000000 1.000000 37.000000 \n", + "\n", + " Hormonal.Contraceptives Hormonal.Contraceptives..years. IUD \\\n", + "count 858.000000 858.000000 858.000000 \n", + "mean 0.686480 1.972394 0.096737 \n", + "std 0.464194 3.597888 0.295771 \n", + "min 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 \n", + "50% 1.000000 0.250000 0.000000 \n", + "75% 1.000000 2.000000 0.000000 \n", + "max 1.000000 30.000000 1.000000 \n", + "\n", + " IUD..years. STDs STDs..number. STDs..Number.of.diagnosis \\\n", + "count 858.000000 858.000000 858.000000 858.000000 \n", + "mean 0.444604 0.092075 0.155012 0.087413 \n", + "std 1.814218 0.289300 0.529617 0.302545 \n", + "min 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 0.000000 \n", + "50% 0.000000 0.000000 0.000000 0.000000 \n", + "75% 0.000000 0.000000 0.000000 0.000000 \n", + "max 19.000000 1.000000 4.000000 3.000000 \n", + "\n", + " STDs..Time.since.first.diagnosis STDs..Time.since.last.diagnosis \n", + "count 858.000000 858.000000 \n", + "mean 1.425408 1.398601 \n", + "std 2.201550 2.113931 \n", + "min 1.000000 1.000000 \n", + "25% 1.000000 1.000000 \n", + "50% 1.000000 1.000000 \n", + "75% 1.000000 1.000000 \n", + "max 22.000000 22.000000 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cervical.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Organizing features and label\n", + "\n", + "features = [col for col in cervical.columns if col != 'Biopsy']\n", + "X = cervical[features]\n", + "y = cervical['Biopsy']" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
RandomForestClassifier()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "RandomForestClassifier()" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Running a random forest\n", + "\n", + "rf = RandomForestClassifier()\n", + "rf.fit(X,y)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plotting a Partial Dependence Plot\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 20))\n", + "PartialDependenceDisplay.from_estimator(\n", + " estimator=rf,\n", + " X=X,\n", + " features=features,\n", + " target=y,\n", + " ax=ax\n", + ")\n", + "ax.set_title(\"Partial Dependence Plot\")\n", + "plt.tight_layout();" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "data = cervical[['Age', 'Num.of.pregnancies']]" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
AgeNum.of.pregnancies
0181
1151
2341
3524
4464
.........
853340
854321
855250
856332
857291
\n", + "

858 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " Age Num.of.pregnancies\n", + "0 18 1\n", + "1 15 1\n", + "2 34 1\n", + "3 52 4\n", + "4 46 4\n", + ".. ... ...\n", + "853 34 0\n", + "854 32 1\n", + "855 25 0\n", + "856 33 2\n", + "857 29 1\n", + "\n", + "[858 rows x 2 columns]" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "# fig, ax = plt.subplots(figsize=(8,6))\n", + "\n", + "# plt.subplot(1,1,1)\n", + "# plt.pcolormesh(data, cmap = 'rainbow')\n", + "# plt.title('HeatMap Using pcolormesh function')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.6 64-bit", + "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.10.6" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Python/cervical-cancer/preprocess_cervical_cancer_data.py b/Python/cervical-cancer/preprocess_cervical_cancer_data.py new file mode 100644 index 00000000..d659e407 --- /dev/null +++ b/Python/cervical-cancer/preprocess_cervical_cancer_data.py @@ -0,0 +1,15 @@ +# Imports +import pandas as pd + +# Reading in the data + + +def data_pipeline(): + DIR = "../../data/" + DATA = "cervical.csv" + cervical = pd.read_csv(DIR+DATA) + + # Converting target into binary variable + cervical['Biopsy'] = cervical['Biopsy'].apply(lambda row: 1 if row=='Cancer' else 0) + + return cervical \ No newline at end of file