From c8accdd24ddacd7581ab36809987703c9d8ae4b3 Mon Sep 17 00:00:00 2001 From: shthapa Date: Sun, 15 Jun 2025 22:55:56 -0400 Subject: [PATCH 1/2] Assignment 2 complete --- 02_activities/assignments/assignment_2.ipynb | 465 +++++++++++++++++-- 1 file changed, 423 insertions(+), 42 deletions(-) diff --git a/02_activities/assignments/assignment_2.ipynb b/02_activities/assignments/assignment_2.ipynb index 29d661c57..dc816aa72 100644 --- a/02_activities/assignments/assignment_2.ipynb +++ b/02_activities/assignments/assignment_2.ipynb @@ -97,18 +97,53 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "# Load the libraries as required." + "# Load the libraries as required.\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import os\n", + "\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 2, + "metadata": {}, + "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", @@ -129,17 +164,39 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature shape: (517, 12)\n", + "Target shape: (517,)\n" + ] + } + ], + "source": [ + "# Target var\n", + "y = fires_dt['area']\n", + "\n", + "# Feature set \n", + "X = fires_dt.drop(columns=['area'])\n", + "\n", + "# Confirm shapes\n", + "print(\"Feature shape:\", X.shape)\n", + "print(\"Target shape:\", y.shape)" + ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "#to handle 0 values safely\n", + "y = np.log1p(fires_dt['area']) \n" + ] }, { "cell_type": "markdown", @@ -180,10 +237,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "from sklearn.pipeline import Pipeline\n", + "from sklearn.compose import ColumnTransformer\n", + "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n", + "\n", + "# Define feature types\n", + "numeric_features = ['coord_x', 'coord_y', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind', 'rain']\n", + "categorical_features = ['month', 'day']\n", + "\n", + "# Define transformers\n", + "numeric_transformer = Pipeline(steps=[\n", + " ('scaler', StandardScaler())\n", + "])\n", + "\n", + "categorical_transformer = Pipeline(steps=[\n", + " ('onehot', OneHotEncoder(handle_unknown='ignore'))\n", + "])\n", + "\n", + "# Create preprocessor 1\n", + "preproc1 = ColumnTransformer(transformers=[\n", + " ('num', numeric_transformer, numeric_features),\n", + " ('cat', categorical_transformer, categorical_features)\n", + "])" + ] }, { "cell_type": "markdown", @@ -199,10 +279,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "from sklearn.preprocessing import FunctionTransformer\n", + "\n", + "# Split numerical columns\n", + "log_transform_features = ['ffmc', 'dmc', 'dc', 'isi', 'rain']\n", + "other_numeric_features = ['coord_x', 'coord_y', 'temp', 'rh', 'wind']\n", + "\n", + "# Define log + scale pipeline\n", + "log_numeric_transformer = Pipeline(steps=[\n", + " ('log', FunctionTransformer(np.log1p, feature_names_out='one-to-one')),\n", + " ('scaler', StandardScaler())\n", + "])\n", + "\n", + "# Define standard scaling pipeline for other numeric features\n", + "standard_numeric_transformer = Pipeline(steps=[\n", + " ('scaler', StandardScaler())\n", + "])\n", + "\n", + "# Define categorical transformer (same as preproc1)\n", + "categorical_transformer = Pipeline(steps=[\n", + " ('onehot', OneHotEncoder(handle_unknown='ignore'))\n", + "])\n", + "\n", + "# Create ColumnTransformer\n", + "preproc2 = ColumnTransformer(transformers=[\n", + " ('log_num', log_numeric_transformer, log_transform_features),\n", + " ('std_num', standard_numeric_transformer, other_numeric_features),\n", + " ('cat', categorical_transformer, categorical_features)\n", + "])" + ] }, { "cell_type": "markdown", @@ -227,38 +336,62 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ - "# Pipeline A = preproc1 + baseline\n" + "# Pipeline A = preproc1 + baseline\n", + "from sklearn.linear_model import Ridge\n", + "baseline_model = Ridge()\n", + "from sklearn.ensemble import GradientBoostingRegressor\n", + "advanced_model = GradientBoostingRegressor(random_state=42)\n", + "\n", + "from sklearn.pipeline import Pipeline\n", + "\n", + "# Pipeline A: preproc1 + baseline\n", + "pipeline_A = Pipeline(steps=[\n", + " ('preprocessing', preproc1),\n", + " ('regressor', Ridge())\n", + "])" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "# Pipeline B = preproc2 + baseline\n" + "# Pipeline B = preproc2 + baseline\n", + "pipeline_B = Pipeline(steps=[\n", + " ('preprocessing', preproc2),\n", + " ('regressor', Ridge())\n", + "])\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "# Pipeline C = preproc1 + advanced model\n" + "# Pipeline C = preproc1 + advanced model\n", + "pipeline_C = Pipeline(steps=[\n", + " ('preprocessing', preproc1),\n", + " ('regressor', GradientBoostingRegressor(random_state=42))\n", + "])" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# Pipeline D = preproc2 + advanced model\n", + "pipeline_D = Pipeline(steps=[\n", + " ('preprocessing', preproc2),\n", + " ('regressor', GradientBoostingRegressor(random_state=42))\n", + "])\n", "\n", " " ] @@ -276,24 +409,194 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Ridge \n", + "param_A = {'regressor__alpha': [0.01, 0.1, 1.0, 10.0]}\n", + "\n", + "# Ridge with nonlinear preprocessing\n", + "param_B = {'regressor__alpha': [0.01, 0.1, 1.0, 10.0]}\n", + "\n", + "# Gradient Boosting\n", + "param_C = {\n", + " 'regressor__n_estimators': [50, 100],\n", + " 'regressor__learning_rate': [0.05, 0.1]\n", + "}\n", + "\n", + "# Gradient Boosting with nonlinear preprocessing\n", + "param_D = {\n", + " 'regressor__n_estimators': [50, 100],\n", + " 'regressor__learning_rate': [0.05, 0.1]\n", + "}\n" + ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
GridSearchCV(cv=5,\n",
+       "             estimator=Pipeline(steps=[('preprocessing',\n",
+       "                                        ColumnTransformer(transformers=[('log_num',\n",
+       "                                                                         Pipeline(steps=[('log',\n",
+       "                                                                                          FunctionTransformer(feature_names_out='one-to-one',\n",
+       "                                                                                                              func=<ufunc 'log1p'>)),\n",
+       "                                                                                         ('scaler',\n",
+       "                                                                                          StandardScaler())]),\n",
+       "                                                                         ['ffmc',\n",
+       "                                                                          'dmc',\n",
+       "                                                                          'dc',\n",
+       "                                                                          'isi',\n",
+       "                                                                          'rain']),\n",
+       "                                                                        ('std_num',\n",
+       "                                                                         Pipeline(steps=[('scaler',\n",
+       "                                                                                          StandardScaler())]),\n",
+       "                                                                         ['coord_x',\n",
+       "                                                                          'coord_y',\n",
+       "                                                                          'temp',\n",
+       "                                                                          'rh',\n",
+       "                                                                          'wind']),\n",
+       "                                                                        ('cat',\n",
+       "                                                                         Pipeline(steps=[('onehot',\n",
+       "                                                                                          OneHotEncoder(handle_unknown='ignore'))]),\n",
+       "                                                                         ['month',\n",
+       "                                                                          'day'])])),\n",
+       "                                       ('regressor',\n",
+       "                                        GradientBoostingRegressor(random_state=42))]),\n",
+       "             param_grid={'regressor__learning_rate': [0.05, 0.1],\n",
+       "                         'regressor__n_estimators': [50, 100]},\n",
+       "             scoring='neg_mean_squared_error')
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": [ + "GridSearchCV(cv=5,\n", + " estimator=Pipeline(steps=[('preprocessing',\n", + " ColumnTransformer(transformers=[('log_num',\n", + " Pipeline(steps=[('log',\n", + " FunctionTransformer(feature_names_out='one-to-one',\n", + " func=)),\n", + " ('scaler',\n", + " StandardScaler())]),\n", + " ['ffmc',\n", + " 'dmc',\n", + " 'dc',\n", + " 'isi',\n", + " 'rain']),\n", + " ('std_num',\n", + " Pipeline(steps=[('scaler',\n", + " StandardScaler())]),\n", + " ['coord_x',\n", + " 'coord_y',\n", + " 'temp',\n", + " 'rh',\n", + " 'wind']),\n", + " ('cat',\n", + " Pipeline(steps=[('onehot',\n", + " OneHotEncoder(handle_unknown='ignore'))]),\n", + " ['month',\n", + " 'day'])])),\n", + " ('regressor',\n", + " GradientBoostingRegressor(random_state=42))]),\n", + " param_grid={'regressor__learning_rate': [0.05, 0.1],\n", + " 'regressor__n_estimators': [50, 100]},\n", + " scoring='neg_mean_squared_error')" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.model_selection import GridSearchCV\n", + "\n", + "# Set up GridSearchCV for each pipeline\n", + "grid_A = GridSearchCV(pipeline_A, param_grid=param_A, cv=5, scoring='neg_mean_squared_error')\n", + "grid_B = GridSearchCV(pipeline_B, param_grid=param_B, cv=5, scoring='neg_mean_squared_error')\n", + "grid_C = GridSearchCV(pipeline_C, param_grid=param_C, cv=5, scoring='neg_mean_squared_error')\n", + "grid_D = GridSearchCV(pipeline_D, param_grid=param_D, cv=5, scoring='neg_mean_squared_error')\n", + "\n", + "# Fit all\n", + "grid_A.fit(X_train, y_train)\n", + "grid_B.fit(X_train, y_train)\n", + "grid_C.fit(X_train, y_train)\n", + "grid_D.fit(X_train, y_train)" + ] }, { "cell_type": "code", @@ -307,7 +610,9 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "\n" + ] }, { "cell_type": "markdown", @@ -329,17 +634,63 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pipeline A RMSE: 1.4686\n", + "Pipeline B RMSE: 1.4634\n", + "Pipeline C RMSE: 1.4689\n", + "Pipeline D RMSE: 1.4673\n" + ] + } + ], + "source": [ + "from sklearn.metrics import mean_squared_error\n", + "\n", + "def evaluate_model(grid, name):\n", + " preds = grid.predict(X_test)\n", + " rmse = np.sqrt(mean_squared_error(y_test, preds))\n", + " print(f\"{name} RMSE: {rmse:.4f}\")\n", + " return rmse\n", + "\n", + "rmse_A = evaluate_model(grid_A, \"Pipeline A\")\n", + "rmse_B = evaluate_model(grid_B, \"Pipeline B\")\n", + "rmse_C = evaluate_model(grid_C, \"Pipeline C\")\n", + "rmse_D = evaluate_model(grid_D, \"Pipeline D\")\n" + ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Best model saved to best_model.pkl\n" + ] + } + ], + "source": [ + "# Find best model by lowest RMSE\n", + "best_model = min(\n", + " [(grid_A, rmse_A), (grid_B, rmse_B), (grid_C, rmse_C), (grid_D, rmse_D)],\n", + " key=lambda x: x[1]\n", + ")[0]\n", + "\n", + "# Export as pickle\n", + "import pickle\n", + "\n", + "with open('best_model.pkl', 'wb') as f:\n", + " pickle.dump(best_model, f)\n", + "\n", + "print(\"✅ Best model saved to best_model.pkl\")\n" + ] }, { "cell_type": "markdown", @@ -361,14 +712,44 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "import pickle\n", + "import shap\n", + "import pandas as pd\n", + "\n", + "# Load best model\n", + "with open('best_model.pkl', 'rb') as f:\n", + " best_model = pickle.load(f)\n", + "\n", + "# Assume X_test is loaded the same way as before\n", + "preprocessor = best_model.named_steps['preprocessing']\n", + "regressor = best_model.named_steps['regressor']\n", + "X_test_transformed = preprocessor.transform(X_test)\n", + "\n", + "explainer = shap.TreeExplainer(regressor)\n", + "shap_values = explainer.shap_values(X_test_transformed)\n", + "\n", + "# Plot global importance\n", + "shap.summary_plot(shap_values, X_test_transformed, feature_names=preprocessor.get_feature_names_out())\n", + "\n" + ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# observation index\n", + "idx = 0\n", + "\n", + "# Visualize \n", + "shap.plots.waterfall(shap_values[idx])\n", + "\n", + "\n", + "# Summary plot\n", + "shap.plots.beeswarm(shap_values)\n" + ] }, { "cell_type": "markdown", @@ -423,7 +804,7 @@ ], "metadata": { "kernelspec": { - "display_name": "env", + "display_name": "dsi_participant", "language": "python", "name": "python3" }, @@ -437,7 +818,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.9.15" } }, "nbformat": 4, From e47e94a0894c5ee3a0601d371da3eef7daf7a09d Mon Sep 17 00:00:00 2001 From: shthapa Date: Thu, 19 Jun 2025 10:39:29 -0400 Subject: [PATCH 2/2] Updated the explain part. --- 02_activities/assignments/assignment_2.ipynb | 132 ++++++++++++------- 1 file changed, 84 insertions(+), 48 deletions(-) diff --git a/02_activities/assignments/assignment_2.ipynb b/02_activities/assignments/assignment_2.ipynb index dc816aa72..5b98e3968 100644 --- a/02_activities/assignments/assignment_2.ipynb +++ b/02_activities/assignments/assignment_2.ipynb @@ -190,7 +190,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -237,7 +237,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -279,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -336,7 +336,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -357,7 +357,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -370,7 +370,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -383,7 +383,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -409,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -420,7 +420,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -445,7 +445,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -577,7 +577,7 @@ " scoring='neg_mean_squared_error')" ] }, - "execution_count": 17, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -599,28 +599,19 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "\n" + "# Evaluate\n", + "\n", + "+ Which model has the best performance?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Evaluate\n", - "\n", - "+ Which model has the best performance?" + "Pipeline_D (preproc2 + GradientBoostingRegressor) is the best performing model with lowest rmse of 0.9152" ] }, { @@ -634,7 +625,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -665,7 +656,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -709,53 +700,98 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\shail\\.conda\\envs\\dsi_participant\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], "source": [ - "import pickle\n", "import shap\n", - "import pandas as pd\n", "\n", - "# Load best model\n", - "with open('best_model.pkl', 'rb') as f:\n", - " best_model = pickle.load(f)\n", + "# Extract components\n", + "best_pipeline = grid_D.best_estimator_\n", + "preprocessor = best_pipeline.named_steps['preprocessing']\n", + "regressor = best_pipeline.named_steps['regressor']\n", "\n", - "# Assume X_test is loaded the same way as before\n", - "preprocessor = best_model.named_steps['preprocessing']\n", - "regressor = best_model.named_steps['regressor']\n", + "# Transform test data\n", "X_test_transformed = preprocessor.transform(X_test)\n", + "feature_names = preprocessor.get_feature_names_out()\n", "\n", + "# Use TreeExplainer for Gradient Boosting\n", "explainer = shap.TreeExplainer(regressor)\n", "shap_values = explainer.shap_values(X_test_transformed)\n", "\n", - "# Plot global importance\n", - "shap.summary_plot(shap_values, X_test_transformed, feature_names=preprocessor.get_feature_names_out())\n", "\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# observation index\n", - "idx = 0\n", + "# Choose an observation to explain (e.g., index 0)\n", + "instance_index = 0\n", "\n", - "# Visualize \n", - "shap.plots.waterfall(shap_values[idx])\n", + "# Pick the first element of expected_value and shap_values\n", + "shap.plots._waterfall.waterfall_legacy(\n", + " explainer.expected_value[0], # Fix here\n", + " shap_values[instance_index], # Or shap_values[0]\n", + " feature_names=feature_names\n", + ")\n", "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "shap.summary_plot(shap_values, X_test_transformed, feature_names=feature_names, plot_type=\"bar\")\n", "\n", - "# Summary plot\n", - "shap.plots.beeswarm(shap_values)\n" + "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "*(Answer here.)*" + "For a selected test instance SHAP showed that ffeatures like temp, ffmc and isi had the greatest iparct on the predicted burned area.\n", + "\n", + "Across the training se,t the most import features were ffmc, temp, dmc and isi. The least improtant features included rain, coord_xand come one-hot encoded day variable.\n", + "\n", + "cosnider removing features like rain, coor_x and low-impact day variable due to their minimal contribution to prediction." ] }, {