From b048acf20df0972c8643b28e173dbe875a3b568e Mon Sep 17 00:00:00 2001 From: Alan Thankachan Date: Sun, 26 Oct 2025 21:11:32 -0700 Subject: [PATCH] Updated Assignment 2 --- 02_activities/assignments/assignment_2.ipynb | 439 ++++++++++++++++--- 1 file changed, 390 insertions(+), 49 deletions(-) diff --git a/02_activities/assignments/assignment_2.ipynb b/02_activities/assignments/assignment_2.ipynb index 29d661c57..659e1028b 100644 --- a/02_activities/assignments/assignment_2.ipynb +++ b/02_activities/assignments/assignment_2.ipynb @@ -97,25 +97,196 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "metadata": {}, "outputs": [], "source": [ - "# Load the libraries as required." + "# Load the libraries as required.\n", + "import pandas as pd\n", + "from pathlib import Path" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 48, + "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" + ] + }, + { + "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": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], "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 = pd.read_csv('../../05_src/data/fires/forestfires.csv', header = 0, names = columns)\n", + "fires_dt.info()\n", + "fires_dt.head()" ] }, { @@ -129,17 +300,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Features data frame and target data\n", + "X = fires_dt.drop(columns=['area'], axis=1)\n", + "y = fires_dt['area']\n", + "\n", + "\n", + "\n" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Identify numberic and categorical columns\n", + "numeric_features = ['coord_x', 'coord_y', 'ffmc', 'dmc', 'dc', 'isi', 'temp', 'rh', 'wind', 'rain']\n", + "categorical_features = ['month', 'day']" + ] }, { "cell_type": "markdown", @@ -180,10 +362,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 51, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "from sklearn.preprocessing import StandardScaler, OneHotEncoder, PowerTransformer\n", + "from sklearn.compose import ColumnTransformer\n", + "\n", + "# Prepoc 1: Simple scaling and one-hot encoding\n", + "prepoc1 = ColumnTransformer(transformers=[\n", + " ('num', StandardScaler(), numeric_features),\n", + " ('cat', OneHotEncoder(sparse_output=False, handle_unknown='ignore'), categorical_features)\n", + "])" + ] }, { "cell_type": "markdown", @@ -199,10 +390,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 52, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Prepoc 2: Scaled variables with non-linear transformation and one-hot encoding\n", + "prepoc2 = ColumnTransformer(transformers=[\n", + " ('num', PowerTransformer(), numeric_features),\n", + " ('cat', OneHotEncoder(sparse_output=False, handle_unknown='ignore'), categorical_features)\n", + "])" + ] }, { "cell_type": "markdown", @@ -227,38 +424,65 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 53, "metadata": {}, "outputs": [], "source": [ - "# Pipeline A = preproc1 + baseline\n" + "from sklearn.linear_model import Ridge\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.pipeline import Pipeline\n", + "\n", + "# Baseline models\n", + "baseline_model = Ridge()\n", + "\n", + "# Advanced\n", + "advanced_model = RandomForestRegressor(random_state=42)\n", + "\n", + "\n", + "# Pipeline A = preproc1 + baseline\n", + "pipeline_a = Pipeline([\n", + " ('preprocessing', prepoc1),\n", + " ('regressor', baseline_model)\n", + "])\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 54, "metadata": {}, "outputs": [], "source": [ - "# Pipeline B = preproc2 + baseline\n" + "# Pipeline B = preproc2 + baseline\n", + "pipeline_b = Pipeline([\n", + " ('preprocessing', prepoc2),\n", + " ('regressor', baseline_model)\n", + "])\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ - "# Pipeline C = preproc1 + advanced model\n" + "# Pipeline C = preproc1 + advanced model\n", + "pipeline_c = Pipeline([\n", + " ('preprocessing', prepoc1),\n", + " ('regressor', advanced_model)\n", + "])\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 56, "metadata": {}, "outputs": [], "source": [ "# Pipeline D = preproc2 + advanced model\n", + "pipeline_d = Pipeline([\n", + " ('preprocessing', prepoc2),\n", + " ('regressor', advanced_model)\n", + "])\n", "\n", " " ] @@ -276,38 +500,87 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 57, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "from sklearn.model_selection import GridSearchCV, KFold\n", + "\n", + "cv = KFold(n_splits=5, shuffle=True, random_state=42)\n", + "\n", + "\n" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 58, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Example Grid for Ridge\n", + "param_grid_ridge = {\n", + " 'regressor__alpha': [0.1, 1.0, 10.0, 100.0]\n", + "}\n" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 59, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Example Grid for Random Forest\n", + "param_grid_rf = {\n", + " 'regressor__n_estimators': [50, 100, 200, 300],\n", + " 'regressor__max_depth': [None, 5, 10, 20]\n", + "}" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 60, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "grid_a = GridSearchCV(estimator=pipeline_a, param_grid=param_grid_ridge, cv=cv, scoring='neg_mean_squared_error')\n", + "grid_b = GridSearchCV(estimator=pipeline_b, param_grid=param_grid_ridge, cv=cv, scoring='neg_mean_squared_error')\n", + "grid_c = GridSearchCV(estimator=pipeline_c, param_grid=param_grid_rf, cv=cv, scoring='neg_mean_squared_error')\n", + "grid_d = GridSearchCV(estimator=pipeline_d, param_grid=param_grid_rf, cv=cv, scoring='neg_mean_squared_error')" + ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pipeline A: Best RMSE = 4029.713, Best params: {'regressor__alpha': 100.0}\n", + "Pipeline B: Best RMSE = 4018.262, Best params: {'regressor__alpha': 100.0}\n", + "Pipeline C: Best RMSE = 4773.180, Best params: {'regressor__max_depth': 5, 'regressor__n_estimators': 50}\n", + "Pipeline D: Best RMSE = 4794.050, Best params: {'regressor__max_depth': 5, 'regressor__n_estimators': 50}\n" + ] + } + ], + "source": [ + "# Fit models\n", + "grids = [grid_a, grid_b, grid_c, grid_d]\n", + "\n", + "pipeline_names_mapping = {\n", + " 'Pipeline A': 'Preprocessing 1 + Baseline Model (Ridge)',\n", + " 'Pipeline B': 'Preprocessing 2 + Baseline Model (Ridge)',\n", + " 'Pipeline C': 'Preprocessing 1 + Advanced Model (Random Forest)',\n", + " 'Pipeline D': 'Preprocessing 2 + Advanced Model (Random Forest)'\n", + "}\n", + "\n", + "# Find the best model\n", + "for name, g in zip(pipeline_names_mapping.keys(), grids):\n", + " g.fit(X, y)\n", + " print(f\"{name}: Best RMSE = {-g.best_score_:.3f}, Best params: {g.best_params_}\")\n", + "\n" + ] }, { "cell_type": "markdown", @@ -318,6 +591,13 @@ "+ Which model has the best performance?" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pipeline B (preproc2 + baseline regressor) has the lowest RMSE: 4018.262, so it is the best-performing model." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -329,17 +609,36 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best Model Pipeline: {'regressor__alpha': 100.0}, RMSE: 4018.262\n" + ] + } + ], + "source": [ + "import pickle\n", + "\n", + "best_model = max(grids, key=lambda g: g.best_score_)\n", + "\n", + "print(f\"Best Model Pipeline: {best_model.best_params_}, RMSE: {-best_model.best_score_:.3f}\")" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 63, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "\n", + "\n", + "with open('best_model.pkl', 'wb') as f:\n", + " pickle.dump(best_model.best_estimator_, f)" + ] }, { "cell_type": "markdown", @@ -358,23 +657,65 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 64, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "import shap\n", + "\n", + "# Only for tree-based model (Random Forest)\n", + "best_pipeline = best_model.best_estimator_\n", + "X_transformed = best_pipeline.named_steps['preprocessing'].transform(X)\n", + "\n", + "explainer = shap.Explainer(best_pipeline.named_steps['regressor'], X_transformed)\n", + "shap_values = explainer(X_transformed)" + ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Local explanation for one observation\n", + "shap.plots.waterfall(shap_values[0])\n", + "\n", + "# Global explanation\n", + "shap.plots.bar(shap_values)" + ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "*(Answer here.)*" + "*(Answer here.)*\n", + "\n", + "Feature Selection Strategy: \n", + "- Check global SHAP importance > identify least important features. \n", + "- Remove features with near-zero contribution. \n", + "- Retrain model and compare RMSE to validate improvement. \n", + "- Keep only features that enhance model performance." ] }, { @@ -423,7 +764,7 @@ ], "metadata": { "kernelspec": { - "display_name": "env", + "display_name": "dsi_participant", "language": "python", "name": "python3" }, @@ -437,7 +778,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.9.19" } }, "nbformat": 4,