From 4001b2ce8c587bf3e6924479519777158f139230 Mon Sep 17 00:00:00 2001 From: amlloren Date: Mon, 4 Nov 2024 15:09:18 -0500 Subject: [PATCH] Updated Assignment 3 with my Answers --- 02_activities/assignments/assignment_3.ipynb | 2412 +++++++++++++++++- 02_activities/assignments/best_model.pkl | Bin 0 -> 4878 bytes 2 files changed, 2352 insertions(+), 60 deletions(-) create mode 100644 02_activities/assignments/best_model.pkl diff --git a/02_activities/assignments/assignment_3.ipynb b/02_activities/assignments/assignment_3.ipynb index 060c21671..8cb36a942 100644 --- a/02_activities/assignments/assignment_3.ipynb +++ b/02_activities/assignments/assignment_3.ipynb @@ -97,25 +97,224 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n" + ] + } + ], "source": [ - "# Load the libraries as required." + "# Load the libraries as required.\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import joblib\n", + "import shap\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n", + "from sklearn.preprocessing import FunctionTransformer\n", + "from sklearn.linear_model import Ridge\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.model_selection import GridSearchCV\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 517 entries, 0 to 516\n", + "Data columns (total 13 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 coord_x 517 non-null int64 \n", + " 1 coord_y 517 non-null int64 \n", + " 2 month 517 non-null object \n", + " 3 day 517 non-null object \n", + " 4 ffmc 517 non-null float64\n", + " 5 dmc 517 non-null float64\n", + " 6 dc 517 non-null float64\n", + " 7 isi 517 non-null float64\n", + " 8 temp 517 non-null float64\n", + " 9 rh 517 non-null int64 \n", + " 10 wind 517 non-null float64\n", + " 11 rain 517 non-null float64\n", + " 12 area 517 non-null float64\n", + "dtypes: float64(8), int64(3), object(2)\n", + "memory usage: 52.6+ KB\n" + ] + } + ], "source": [ "# Load data\n", "columns = [\n", " 'coord_x', 'coord_y', 'month', 'day', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind', 'rain', 'area' \n", "]\n", "fires_dt = (pd.read_csv('../../05_src/data/fires/forestfires.csv', header = 0, names = columns))\n", - "fires_dt.info()\n" + "fires_dt.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "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", + "
coord_xcoord_ymonthdayffmcdmcdcisitemprhwindrainarea
075marfri86.226.294.35.18.2516.70.00.0
174octtue90.635.4669.16.718.0330.90.00.0
274octsat90.643.7686.96.714.6331.30.00.0
386marfri91.733.377.59.08.3974.00.20.0
486marsun89.351.3102.29.611.4991.80.00.0
\n", + "
" + ], + "text/plain": [ + " coord_x coord_y month day ffmc dmc dc isi temp rh wind rain \\\n", + "0 7 5 mar fri 86.2 26.2 94.3 5.1 8.2 51 6.7 0.0 \n", + "1 7 4 oct tue 90.6 35.4 669.1 6.7 18.0 33 0.9 0.0 \n", + "2 7 4 oct sat 90.6 43.7 686.9 6.7 14.6 33 1.3 0.0 \n", + "3 8 6 mar fri 91.7 33.3 77.5 9.0 8.3 97 4.0 0.2 \n", + "4 8 6 mar sun 89.3 51.3 102.2 9.6 11.4 99 1.8 0.0 \n", + "\n", + " area \n", + "0 0.0 \n", + "1 0.0 \n", + "2 0.0 \n", + "3 0.0 \n", + "4 0.0 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Display the first few rows of the dataset\n", + "fires_dt.head()" ] }, { @@ -129,17 +328,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Create the features DataFrame (X) by dropping the 'area' column\n", + "X = fires_dt.drop(columns=['area'])\n", + "\n", + "# Create the target DataFrame (Y) by selecting the 'area' column\n", + "Y = fires_dt['area']" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape of X: (517, 12)\n", + "Shape of Y: (517,)\n" + ] + } + ], + "source": [ + "# Print the shapes of X and Y to verify\n", + "print(\"Shape of X:\", X.shape)\n", + "print(\"Shape of Y:\", Y.shape)" + ] }, { "cell_type": "markdown", @@ -180,10 +398,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Identify numerical and categorical columns\n", + "numerical_features = X.select_dtypes(include=['int64', 'float64']).columns\n", + "categorical_features = X.select_dtypes(include=['object']).columns\n", + "\n", + "# Preprocessing for numerical data\n", + "numerical_transformer = StandardScaler()\n", + "\n", + "# Preprocessing for categorical data\n", + "categorical_transformer = OneHotEncoder(handle_unknown='ignore')\n", + "\n", + "# Create preproc1 ColumnTransformer\n", + "preproc1 = ColumnTransformer(\n", + " transformers=[\n", + " ('num', numerical_transformer, numerical_features),\n", + " ('cat', categorical_transformer, categorical_features)\n", + " ]\n", + ")" + ] }, { "cell_type": "markdown", @@ -199,10 +435,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Function to apply logarithmic transformation\n", + "def log_transform(x):\n", + " return np.log1p(x) # log1p is used to handle zero values\n", + "\n", + "# Preprocessing for numerical data with non-linear transformation\n", + "numerical_transformer_2 = Pipeline(steps=[\n", + " ('log', FunctionTransformer(log_transform, validate=True)),\n", + " ('scaler', StandardScaler())\n", + "])\n", + "\n", + "# Create preproc2 ColumnTransformer\n", + "preproc2 = ColumnTransformer(\n", + " transformers=[\n", + " ('num', numerical_transformer_2, numerical_features),\n", + " ('cat', categorical_transformer, categorical_features)\n", + " ]\n", + ")" + ] }, { "cell_type": "markdown", @@ -227,40 +481,1900 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('preprocessing',\n",
+       "                 ColumnTransformer(transformers=[('num', StandardScaler(),\n",
+       "                                                  Index(['coord_x', 'coord_y', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind',\n",
+       "       'rain'],\n",
+       "      dtype='object')),\n",
+       "                                                 ('cat',\n",
+       "                                                  OneHotEncoder(handle_unknown='ignore'),\n",
+       "                                                  Index(['month', 'day'], dtype='object'))])),\n",
+       "                ('regressor', Ridge())])
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": [ + "Pipeline(steps=[('preprocessing',\n", + " ColumnTransformer(transformers=[('num', StandardScaler(),\n", + " Index(['coord_x', 'coord_y', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind',\n", + " 'rain'],\n", + " dtype='object')),\n", + " ('cat',\n", + " OneHotEncoder(handle_unknown='ignore'),\n", + " Index(['month', 'day'], dtype='object'))])),\n", + " ('regressor', Ridge())])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Pipeline A = preproc1 + baseline\n" + "# Pipeline A = preproc1 + baseline\n", + "\n", + "pipeline_A = Pipeline(steps=[\n", + " ('preprocessing', preproc1),\n", + " ('regressor', Ridge())\n", + "])\n", + "\n", + "pipeline_A" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('preprocessing',\n",
+       "                 ColumnTransformer(transformers=[('num',\n",
+       "                                                  Pipeline(steps=[('log',\n",
+       "                                                                   FunctionTransformer(func=<function log_transform at 0x1605ef940>,\n",
+       "                                                                                       validate=True)),\n",
+       "                                                                  ('scaler',\n",
+       "                                                                   StandardScaler())]),\n",
+       "                                                  Index(['coord_x', 'coord_y', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind',\n",
+       "       'rain'],\n",
+       "      dtype='object')),\n",
+       "                                                 ('cat',\n",
+       "                                                  OneHotEncoder(handle_unknown='ignore'),\n",
+       "                                                  Index(['month', 'day'], dtype='object'))])),\n",
+       "                ('regressor', Ridge())])
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": [ + "Pipeline(steps=[('preprocessing',\n", + " ColumnTransformer(transformers=[('num',\n", + " Pipeline(steps=[('log',\n", + " FunctionTransformer(func=,\n", + " validate=True)),\n", + " ('scaler',\n", + " StandardScaler())]),\n", + " Index(['coord_x', 'coord_y', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind',\n", + " 'rain'],\n", + " dtype='object')),\n", + " ('cat',\n", + " OneHotEncoder(handle_unknown='ignore'),\n", + " Index(['month', 'day'], dtype='object'))])),\n", + " ('regressor', Ridge())])" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Pipeline B = preproc2 + baseline\n" + "# Pipeline B = preproc2 + baseline\n", + "\n", + "pipeline_B = Pipeline(steps=[\n", + " ('preprocessing', preproc2),\n", + " ('regressor', Ridge())\n", + "])\n", + "\n", + "pipeline_B" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('preprocessing',\n",
+       "                 ColumnTransformer(transformers=[('num', StandardScaler(),\n",
+       "                                                  Index(['coord_x', 'coord_y', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind',\n",
+       "       'rain'],\n",
+       "      dtype='object')),\n",
+       "                                                 ('cat',\n",
+       "                                                  OneHotEncoder(handle_unknown='ignore'),\n",
+       "                                                  Index(['month', 'day'], dtype='object'))])),\n",
+       "                ('regressor', RandomForestRegressor(random_state=42))])
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": [ + "Pipeline(steps=[('preprocessing',\n", + " ColumnTransformer(transformers=[('num', StandardScaler(),\n", + " Index(['coord_x', 'coord_y', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind',\n", + " 'rain'],\n", + " dtype='object')),\n", + " ('cat',\n", + " OneHotEncoder(handle_unknown='ignore'),\n", + " Index(['month', 'day'], dtype='object'))])),\n", + " ('regressor', RandomForestRegressor(random_state=42))])" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Pipeline C = preproc1 + advanced model\n" + "# Pipeline C = preproc1 + advanced model\n", + "\n", + "pipeline_C = Pipeline(steps=[\n", + " ('preprocessing', preproc1),\n", + " ('regressor', RandomForestRegressor(random_state=42))\n", + "])\n", + "\n", + "pipeline_C" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('preprocessing',\n",
+       "                 ColumnTransformer(transformers=[('num',\n",
+       "                                                  Pipeline(steps=[('log',\n",
+       "                                                                   FunctionTransformer(func=<function log_transform at 0x1605ef940>,\n",
+       "                                                                                       validate=True)),\n",
+       "                                                                  ('scaler',\n",
+       "                                                                   StandardScaler())]),\n",
+       "                                                  Index(['coord_x', 'coord_y', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind',\n",
+       "       'rain'],\n",
+       "      dtype='object')),\n",
+       "                                                 ('cat',\n",
+       "                                                  OneHotEncoder(handle_unknown='ignore'),\n",
+       "                                                  Index(['month', 'day'], dtype='object'))])),\n",
+       "                ('regressor', RandomForestRegressor(random_state=42))])
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": [ + "Pipeline(steps=[('preprocessing',\n", + " ColumnTransformer(transformers=[('num',\n", + " Pipeline(steps=[('log',\n", + " FunctionTransformer(func=,\n", + " validate=True)),\n", + " ('scaler',\n", + " StandardScaler())]),\n", + " Index(['coord_x', 'coord_y', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind',\n", + " 'rain'],\n", + " dtype='object')),\n", + " ('cat',\n", + " OneHotEncoder(handle_unknown='ignore'),\n", + " Index(['month', 'day'], dtype='object'))])),\n", + " ('regressor', RandomForestRegressor(random_state=42))])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Pipeline D = preproc2 + advanced model\n", "\n", - " " + "pipeline_D = Pipeline(steps=[\n", + " ('preprocessing', preproc2),\n", + " ('regressor', RandomForestRegressor(random_state=42))\n", + "]) \n", + "\n", + "pipeline_D" ] }, { @@ -276,38 +2390,165 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for Pipeline A: {'regressor__alpha': 10.0}\n", + "Best score for Pipeline A: -4278.655355069461\n" + ] + } + ], + "source": [ + "# Define parameter grid for Pipeline A\n", + "param_grid_A = {\n", + " 'regressor__alpha': [0.1, 1.0, 10.0]\n", + "}\n", + "\n", + "# Perform GridSearchCV\n", + "grid_search_A = GridSearchCV(pipeline_A, param_grid_A, cv=5, scoring='neg_mean_squared_error', n_jobs=-1)\n", + "grid_search_A.fit(X, Y)\n", + "\n", + "# Best parameters and score\n", + "print(\"Best parameters for Pipeline A:\", grid_search_A.best_params_)\n", + "print(\"Best score for Pipeline A:\", grid_search_A.best_score_)" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for Pipeline B: {'regressor__alpha': 10.0}\n", + "Best score for Pipeline B: -4334.079693059389\n" + ] + } + ], + "source": [ + "# Define parameter grid for Pipeline B\n", + "param_grid_B = {\n", + " 'regressor__alpha': [0.1, 1.0, 10.0]\n", + "}\n", + "\n", + "# Perform GridSearchCV for Pipeline B\n", + "grid_search_B = GridSearchCV(pipeline_B, param_grid_B, cv=5, scoring='neg_mean_squared_error', n_jobs=-1)\n", + "grid_search_B.fit(X, Y)\n", + "\n", + "# Best parameters and score for Pipeline B\n", + "print(\"Best parameters for Pipeline B:\", grid_search_B.best_params_)\n", + "print(\"Best score for Pipeline B:\", grid_search_B.best_score_)\n" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for Pipeline C: {'regressor__max_depth': 10, 'regressor__n_estimators': 200}\n", + "Best score for Pipeline C: -4762.587225606292\n" + ] + } + ], + "source": [ + "# Define parameter grid for Pipeline C\n", + "param_grid_C = {\n", + " 'regressor__n_estimators': [50, 100, 200],\n", + " 'regressor__max_depth': [None, 10, 20]\n", + "}\n", + "\n", + "# Perform GridSearchCV for Pipeline C\n", + "grid_search_C = GridSearchCV(pipeline_C, param_grid_C, cv=5, scoring='neg_mean_squared_error', n_jobs=-1)\n", + "grid_search_C.fit(X, Y)\n", + "\n", + "# Best parameters and score for Pipeline C\n", + "print(\"Best parameters for Pipeline C:\", grid_search_C.best_params_)\n", + "print(\"Best score for Pipeline C:\", grid_search_C.best_score_)\n" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best parameters for Pipeline D: {'regressor__max_depth': 10, 'regressor__n_estimators': 100}\n", + "Best score for Pipeline D: -5249.973633394472\n" + ] + } + ], + "source": [ + "# Define parameter grid for Pipeline D\n", + "param_grid_D = {\n", + " 'regressor__n_estimators': [50, 100, 200],\n", + " 'regressor__max_depth': [None, 10, 20]\n", + "}\n", + "\n", + "# Perform GridSearchCV for Pipeline D\n", + "grid_search_D = GridSearchCV(pipeline_D, param_grid_D, cv=5, scoring='neg_mean_squared_error', n_jobs=-1)\n", + "grid_search_D.fit(X, Y)\n", + "\n", + "# Best parameters and score for Pipeline D\n", + "print(\"Best parameters for Pipeline D:\", grid_search_D.best_params_)\n", + "print(\"Best score for Pipeline D:\", grid_search_D.best_score_)\n" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best score for Pipeline A: -4278.655355069461\n", + "Best score for Pipeline B: -4334.079693059389\n", + "Best score for Pipeline C: -4762.587225606292\n", + "Best score for Pipeline D: -5249.973633394472\n", + "The best performing pipeline is Pipeline A with a score of -4278.655355069461\n" + ] + } + ], + "source": [ + "# Best scores for each pipeline\n", + "best_score_A = grid_search_A.best_score_\n", + "best_score_B = grid_search_B.best_score_\n", + "best_score_C = grid_search_C.best_score_\n", + "best_score_D = grid_search_D.best_score_\n", + "\n", + "# Print best scores for comparison\n", + "print(\"Best score for Pipeline A:\", best_score_A)\n", + "print(\"Best score for Pipeline B:\", best_score_B)\n", + "print(\"Best score for Pipeline C:\", best_score_C)\n", + "print(\"Best score for Pipeline D:\", best_score_D)\n", + "\n", + "# Identify the best pipeline\n", + "best_score = max(best_score_A, best_score_B, best_score_C, best_score_D)\n", + "if best_score == best_score_A:\n", + " best_pipeline = 'Pipeline A'\n", + "elif best_score == best_score_B:\n", + " best_pipeline = 'Pipeline B'\n", + "elif best_score == best_score_C:\n", + " best_pipeline = 'Pipeline C'\n", + "else:\n", + " best_pipeline = 'Pipeline D'\n", + "\n", + "print(f\"The best performing pipeline is {best_pipeline} with a score of {best_score}\")" + ] }, { "cell_type": "markdown", @@ -322,24 +2563,40 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Export\n", - "\n", - "+ Save the best performing model to a pickle file." + "To identify the best model, I need to compare the best scores obtained from each pipeline. Since I'm using neg_mean_squared_error, the best score is the one that is closest to zero. The best score among these is Pipeline A." ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "# Export\n", + "\n", + "+ Save the best performing model to a pickle file." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "['best_model.pkl']" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "best_model = grid_search_A.best_estimator_\n", + "\n", + "# Save the best model to a pickle file\n", + "joblib.dump(best_model, 'best_model.pkl')" + ] }, { "cell_type": "markdown", @@ -356,25 +2613,60 @@ "+ If you were to remove features from the model, which ones would you remove? Why? How would you test that these features are actually enhancing model performance?" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*(Answer here.)*" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Load the best model from the pickle file\n", + "best_model = joblib.load('best_model.pkl')\n", + "\n", + "# Create SHAP explainer\n", + "explainer = shap.Explainer(best_model['regressor'], best_model['preprocessing'].transform(X))\n", + "\n", + "# Compute SHAP values for the dataset\n", + "shap_values = explainer(best_model['preprocessing'].transform(X))" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Extract feature names after preprocessing\n", + "preprocessed_feature_names = best_model['preprocessing'].get_feature_names_out()\n", + "\n", + "# Plot summary of SHAP values for all features\n", + "shap.summary_plot(shap_values, best_model['preprocessing'].transform(X), feature_names=preprocessed_feature_names)\n" + ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "*(Answer here.)*" + "#### If you were to remove features from the model, which ones would you remove? Why? How would you test that these features are actually enhancing model performance?\n", + "\n", + "Based on this SHAP summary plot, I would remove the \"month\" and \"day\" features. To test the impact of feature removal, incrementally remove one or a few features at a time and evaluate the model's performance. Use cross-validation to ensure the performance change is consistent and not due to random chance. Track performance metrics such as RMSE, MAE, and R-squared before and after feature removal to quantify the impact and validate that the removal of certain features indeed enhances model performance." ] }, { @@ -423,7 +2715,7 @@ ], "metadata": { "kernelspec": { - "display_name": "env", + "display_name": "dsi_participant", "language": "python", "name": "python3" }, @@ -437,7 +2729,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.9.18" } }, "nbformat": 4, diff --git a/02_activities/assignments/best_model.pkl b/02_activities/assignments/best_model.pkl new file mode 100644 index 0000000000000000000000000000000000000000..dd1691506a9ad2787ec5ec6c52e0c4dccdeee39e GIT binary patch literal 4878 zcmd^DdvH`&8Q(lM*=#m%LK2b?LQo#ULP~^4(Y-X35H2iCC^cG{!`-`Q_uO#b50XqN zg-#)x&Z$&;Q>VjB3#|;LQ>FNatz|S}EYz_&KIk|@Ma8y`wuKP{t)r#*-Fx>Y8_yWA{7fo_ikO_dCDuch2s@(boKc`_M{byNEemj;ex+MM1_k4Q=wx$L;xh><8?5 zG-#MuHSDcmmZ>^cb%n= zz%<;iY+CFr4BEml;CjNT*k;3f!B+I7t(lM{dhN)Y;8P)<`t8jMWVJ(jh?A7vl07DY|VD(2m;!*XC9hVOA&(FF($E#xdyfwqRq=>|rMWvZ5GXGj#_P@EDK z&Ro{vfTx@QnnjE(dAqC(0MLsd!hme(A*m~>9j9fIAfuFyH4CON1Qq2HH;8h^iqqN@ z=1fb+$XO5sR7wC%01AsB{?4LEJ!!BKq>0RgeL!ZBHjgyOC&_%WfX&})lZ9jvOl>Jy zHbR#F$3T^Ti$E2G;7W>Y5`dJ891h?F!Jh`f|Ct;5K!9}mamTbo#}WX<*|?+!_|^-V zNpx%wMNHb=u`^5EhZe~Q*u#Jz)Z|bi8o)xDm`-&u5LN;>7B+4})SU9GB`;Uv4ISX0fV&mpJsX>dIKaD=j0-?gysuVG{(vsG)4e4Mpr19m6x`Y z{Akb-V>i*vWJICUR8FVlp{WVo>5?qVc&VcR)XbTxg(u?QsAjtAzrQQ6w2FzpKWN-_ z^j_x8=l&?Z@zQ;aQ@gii4>S1A-od)k+05FDt1}1RzJtkoa{uYK=d58?KYq5YsJfCV zzx0FB%h4xdqYJWrp@lm*{bMHj=)^Q4j;ivX&CC;@GEglu=WCUx&(8g8j4C599u_{w z)K*=oE&1>m^VNNXWk3%9Z;Ds&OX|nK2*Z| z;^3EOZsNWj8(rwn$Mrn^w`LUfXLJ4fso$m+hj!&NV<^(`qvx)~di#c7YpIydtiHh9 zU-;2R=A9$GSCzlX%wtb&o6dJuGcTS#HUG|zI_Af1f4{t9!xF~soZkA-vmeIN2bOQ& zaN*~%QPszdm+4mw+hiq)Ww-2Iq>HR}q{kZ4P1cg0I9V4bY@Dno8)yx1RaRV>$R~yo zvW?BZX@mb?>4XkHz@?K)%cH`n;^}`b6+427Q}wKL;;b|%aaTlPUx=r00ur!O*U!mW zCEjm|kbm7eO9mnCSQ4j$68Eej5aNy{D?7AC*HU;;(9SVXH_cvQ3lsuuz%5u_*ZXWoZ>K?98wzNZi7N!> zW&@~Qfp>;C(ahXy%OC7j*O%yCf?pk*n+QCqN99;=S9h9eK0>ifV7 zImaXc-oSbbOhp74KV#Wj?>BWVf^?~fpw4a5MMH2SBACJsN3loX?jxy4$S~m`XUBmA zn`w|&aOx&{Z=S&8WWp((r1$H;KCV2~9;;%ir}h8j*y2CLKHGyUYaaP}OljG7q^rA` z+27ro;oh1xzW9yI9gTf~@ejU&244*}FeN>ww*7E<;rQ(DE_ikJ%Ms?mckfxZDR6P@ z)V1>mmNW;(&lfk$cxB*EW2g1fNA7;IjybgRm$E4xAA5fH)2|)ee>Ju*kE*q8rQ>Il zhs8?|w~nvF{lEI@>#gHMhb}+!LHbf`(WRDIC3CNitv@N9Jl9&qoM>J3US8t@rl@G+ zx})7q