{ "cells": [ { "cell_type": "markdown", "id": "18a5703a", "metadata": {}, "source": [ "
\n", "Name: Tareque Hasnat Tuhin
\n", "ID: 2513674\n", "
\n", "Feature selection and model comparison (Random Forest, PCA, Logistic Regression, Naïve Bayes)\n", "
Activity: Implementing and Comparing ML Algorithms on the Diabetes Dataset
" ] }, { "cell_type": "code", "execution_count": 1, "id": "2a8eb00a", "metadata": {}, "outputs": [], "source": [ "# Cell 1: Imports & configuration\n", "import os\n", "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.ensemble import RandomForestClassifier\n", "from sklearn.decomposition import PCA\n", "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n", "from sklearn.compose import ColumnTransformer\n", "from sklearn.pipeline import Pipeline\n", "from sklearn.linear_model import LogisticRegression\n", "from sklearn.naive_bayes import GaussianNB\n", "from sklearn.metrics import (\n", " accuracy_score, precision_score, recall_score, f1_score, classification_report, confusion_matrix\n", ")\n", "import seaborn as sns\n", "sns.set(style=\"whitegrid\")\n", "\n", "# User settings - choose dataset: 'diabetes' or 'titanic'\n", "DATASET = 'diabetes' # change to 'titanic' if you'd like\n", "RANDOM_STATE = 42\n", "TOP_N_FEATURES = 5 # for manual feature selection\n", "PCA_VARIANCE_THRESHOLD = 0.95 # use n_components to capture this fraction of variance\n", "TEST_SIZE = 0.25\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "7d94d2d4", "metadata": {}, "outputs": [], "source": [ "# Cell 2: Utility functions for evaluating and summarizing metrics\n", "def compute_metrics(y_true, y_pred, average='binary', pos_label=1):\n", " \"\"\"\n", " Returns a dict of metrics. For multi-class, set average='macro' or 'weighted'.\n", " \"\"\"\n", " metrics = {\n", " 'accuracy': accuracy_score(y_true, y_pred),\n", " 'precision': precision_score(y_true, y_pred, average=average, zero_division=0),\n", " 'recall': recall_score(y_true, y_pred, average=average, zero_division=0),\n", " 'f1': f1_score(y_true, y_pred, average=average, zero_division=0)\n", " }\n", " return metrics\n", "\n", "def print_classification_results(name, y_true, y_pred, target_names=None):\n", " print(f\"--- {name} ---\")\n", " print(\"Accuracy:\", accuracy_score(y_true, y_pred))\n", " if target_names is None:\n", " print(classification_report(y_true, y_pred, zero_division=0))\n", " else:\n", " print(classification_report(y_true, y_pred, target_names=target_names, zero_division=0))\n", " cm = confusion_matrix(y_true, y_pred)\n", " print(\"Confusion matrix:\\n\", cm)\n", " print()\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "ffe6141f", "metadata": {}, "outputs": [], "source": [ "# Cell 3: Data loading + basic preprocessing functions for both datasets\n", "\n", "def load_diabetes(path='diabetes.csv'):\n", " \"\"\"\n", " Expect typical diabetes dataset with a 'Outcome' column (0/1) or 'target'.\n", " If your column names differ, adapt accordingly.\n", " \"\"\"\n", " if not os.path.exists(path):\n", " raise FileNotFoundError(f\"File not found: {path}. Please place diabetes.csv in the notebook folder.\")\n", " df = pd.read_csv(path)\n", " # Inspect columns quickly\n", " print(\"Diabetes dataset loaded. Shape:\", df.shape)\n", " display(df.head())\n", " return df\n", "\n", "def preprocess_diabetes(df):\n", " \"\"\"\n", " Typical preprocessing for Pima diabetes dataset:\n", " - Replace zeros in certain columns (where 0 is physiologically impossible) with NaN, then impute median.\n", " - No categorical features by default. Target column assumed 'Outcome' or 'target'.\n", " \"\"\"\n", " df = df.copy()\n", " # Identify target column\n", " if 'Outcome' in df.columns:\n", " target_col = 'Outcome'\n", " elif 'target' in df.columns:\n", " target_col = 'target'\n", " else:\n", " # if user uses different naming, raise\n", " raise ValueError(\"Diabetes dataset: target column not found (expected 'Outcome' or 'target').\")\n", " \n", " # Columns where 0 is not a valid value (common with Pima dataset)\n", " zero_impute_cols = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']\n", " for c in zero_impute_cols:\n", " if c in df.columns:\n", " df[c] = df[c].replace(0, np.nan)\n", " # Impute median for missing numeric values\n", " df.fillna(df.median(), inplace=True)\n", " \n", " X = df.drop(columns=[target_col])\n", " y = df[target_col].astype(int)\n", " return X, y\n", "\n", "def load_titanic(path='titanic.csv'):\n", " \"\"\"\n", " Expects a titanic CSV with standard columns: Survived, Pclass, Sex, Age, SibSp, Parch, Fare, Embarked, etc.\n", " \"\"\"\n", " if not os.path.exists(path):\n", " raise FileNotFoundError(f\"File not found: {path}. Please place titanic.csv in the notebook folder.\")\n", " df = pd.read_csv(path)\n", " print(\"Titanic dataset loaded. Shape:\", df.shape)\n", " display(df.head())\n", " return df\n", "\n", "def preprocess_titanic(df):\n", " \"\"\"\n", " Preprocessing pipeline for Titanic:\n", " - Keep a useful subset of columns\n", " - Fill missing Age with median, Embarked with mode\n", " - Encode Sex and Embarked with one-hot encoding\n", " - Drop columns not used (Name, Ticket, Cabin)\n", " \"\"\"\n", " df = df.copy()\n", " # Ensure target column\n", " if 'Survived' not in df.columns:\n", " raise ValueError(\"Titanic dataset: target column 'Survived' not found.\")\n", " target_col = 'Survived'\n", " \n", " # Select features (common choices)\n", " features = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']\n", " for c in features:\n", " if c not in df.columns:\n", " raise ValueError(f\"Expected column {c} in Titanic dataset but not found.\")\n", " \n", " # Fill missing values\n", " df['Age'] = df['Age'].fillna(df['Age'].median())\n", " df['Fare'] = df['Fare'].fillna(df['Fare'].median())\n", " df['Embarked'] = df['Embarked'].fillna(df['Embarked'].mode()[0])\n", " \n", " X = df[features].copy()\n", " y = df[target_col].astype(int)\n", " return X, y\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "4e4f2c4c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Diabetes dataset loaded. Shape: (768, 10)\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", "
PatientIdPregnanciesGlucoseBloodPressureSkinThicknessInsulinBMIDiabetesPedigreeFunctionAgeOutcome
0161487235033.60.627501
121856629026.60.351310
238183640023.30.672321
3418966239428.10.167210
450137403516843.12.288331
\n", "
" ], "text/plain": [ " PatientId Pregnancies Glucose BloodPressure SkinThickness Insulin \\\n", "0 1 6 148 72 35 0 \n", "1 2 1 85 66 29 0 \n", "2 3 8 183 64 0 0 \n", "3 4 1 89 66 23 94 \n", "4 5 0 137 40 35 168 \n", "\n", " BMI DiabetesPedigreeFunction Age Outcome \n", "0 33.6 0.627 50 1 \n", "1 26.6 0.351 31 0 \n", "2 23.3 0.672 32 1 \n", "3 28.1 0.167 21 0 \n", "4 43.1 2.288 33 1 " ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Features shape: (768, 9)\n", "Target distribution:\n", " 0 500\n", "1 268\n", "Name: Outcome, dtype: int64\n" ] } ], "source": [ "# Cell 4: Prepare dataset based on user selection\n", "if DATASET.lower() == 'diabetes':\n", " raw = load_diabetes('diabetes.csv')\n", " X, y = preprocess_diabetes(raw)\n", " average_for_metrics = 'binary' # binary classification\n", " target_names = None\n", "elif DATASET.lower() == 'titanic':\n", " raw = load_titanic('titanic.csv')\n", " X, y = preprocess_titanic(raw)\n", " average_for_metrics = 'binary'\n", " target_names = ['Not Survived', 'Survived']\n", "else:\n", " raise ValueError(\"DATASET must be 'diabetes' or 'titanic'\")\n", "\n", "print(\"Features shape:\", X.shape)\n", "print(\"Target distribution:\\n\", y.value_counts())\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "b4f5c905", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Numeric cols: ['PatientId', 'Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DiabetesPedigreeFunction', 'Age']\n", "Categorical cols: []\n" ] } ], "source": [ "# Cell 5: Create preprocessing + training pipeline utilities\n", "def build_numeric_preprocessor():\n", " return Pipeline([\n", " ('scaler', StandardScaler())\n", " ])\n", "\n", "def build_full_preprocessor(X):\n", " \"\"\"\n", " Create a ColumnTransformer that scales numeric data and one-hot encodes categorical columns.\n", " Returns ColumnTransformer and list of feature names after transformation (approximate).\n", " \"\"\"\n", " numeric_cols = X.select_dtypes(include=['int64', 'float64']).columns.tolist()\n", " categorical_cols = X.select_dtypes(include=['object', 'category']).columns.tolist()\n", " \n", " transformers = []\n", " if numeric_cols:\n", " transformers.append(('num', StandardScaler(), numeric_cols))\n", " if categorical_cols:\n", " transformers.append(('cat', OneHotEncoder(handle_unknown='ignore', sparse=False), categorical_cols))\n", " \n", " col_transformer = ColumnTransformer(transformers=transformers, remainder='drop')\n", " return col_transformer, numeric_cols, categorical_cols\n", "\n", "preprocessor, numeric_cols, categorical_cols = build_full_preprocessor(X)\n", "print(\"Numeric cols:\", numeric_cols)\n", "print(\"Categorical cols:\", categorical_cols)\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "c401355a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processed feature shape: (576, 9)\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", "
PatientIdPregnanciesGlucoseBloodPressureSkinThicknessInsulinBMIDiabetesPedigreeFunctionAge
01.667936-0.855471-0.0192660.4860751.124727-0.8030100.954719-0.658457-0.466486
1-0.1014082.467805-1.1157250.1595691.238125-1.0573520.405410-0.3069991.218656
21.519366-0.855471-0.451205-0.9832041.9185130.5195690.435102-0.195854-0.803514
30.699975-1.157587-0.5508831.465594-0.009253-0.154438-0.440824-0.8507081.050142
41.217722-0.855471-0.152171-0.983204-0.689641-0.3960630.182717-0.042655-0.550743
\n", "
" ], "text/plain": [ " PatientId Pregnancies Glucose BloodPressure SkinThickness Insulin \\\n", "0 1.667936 -0.855471 -0.019266 0.486075 1.124727 -0.803010 \n", "1 -0.101408 2.467805 -1.115725 0.159569 1.238125 -1.057352 \n", "2 1.519366 -0.855471 -0.451205 -0.983204 1.918513 0.519569 \n", "3 0.699975 -1.157587 -0.550883 1.465594 -0.009253 -0.154438 \n", "4 1.217722 -0.855471 -0.152171 -0.983204 -0.689641 -0.396063 \n", "\n", " BMI DiabetesPedigreeFunction Age \n", "0 0.954719 -0.658457 -0.466486 \n", "1 0.405410 -0.306999 1.218656 \n", "2 0.435102 -0.195854 -0.803514 \n", "3 -0.440824 -0.850708 1.050142 \n", "4 0.182717 -0.042655 -0.550743 " ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Cell 6: Split data and create preprocessed training/test sets\n", "X_train_raw, X_test_raw, y_train, y_test = train_test_split(X, y, test_size=TEST_SIZE, random_state=RANDOM_STATE, stratify=y)\n", "\n", "# Fit the preprocessor on X_train and transform both train and test\n", "preprocessor.fit(X_train_raw)\n", "X_train = pd.DataFrame(preprocessor.transform(X_train_raw))\n", "X_test = pd.DataFrame(preprocessor.transform(X_test_raw))\n", "\n", "# Build proper feature names after columntransformer\n", "feature_names = []\n", "if numeric_cols:\n", " feature_names.extend(numeric_cols)\n", "if categorical_cols:\n", " # reconstruct onehot names\n", " ohe = preprocessor.named_transformers_.get('cat', None)\n", " if ohe is not None:\n", " cat_feature_names = ohe.get_feature_names_out(categorical_cols).tolist()\n", " feature_names.extend(cat_feature_names)\n", "\n", "X_train.columns = feature_names\n", "X_test.columns = feature_names\n", "\n", "print(\"Processed feature shape:\", X_train.shape)\n", "display(X_train.head())\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "a9957849", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "--- Random Forest (original features) ---\n", "Accuracy: 0.734375\n", " precision recall f1-score support\n", "\n", " 0 0.76 0.86 0.81 125\n", " 1 0.66 0.49 0.56 67\n", "\n", " accuracy 0.73 192\n", " macro avg 0.71 0.68 0.69 192\n", "weighted avg 0.73 0.73 0.72 192\n", "\n", "Confusion matrix:\n", " [[108 17]\n", " [ 34 33]]\n", "\n" ] } ], "source": [ "# Cell 7: Train Random Forest on original features\n", "rf = RandomForestClassifier(n_estimators=200, random_state=RANDOM_STATE)\n", "rf.fit(X_train, y_train)\n", "y_pred_rf = rf.predict(X_test)\n", "\n", "print_classification_results(\"Random Forest (original features)\", y_test, y_pred_rf, target_names=target_names)\n", "\n", "# Save metrics\n", "metrics_rf = compute_metrics(y_test, y_pred_rf, average=average_for_metrics)\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "591be690", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Top features:\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", "
featureimportance
2Glucose0.281562
6BMI0.143892
8Age0.111680
7DiabetesPedigreeFunction0.107287
0PatientId0.088247
5Insulin0.077022
1Pregnancies0.067935
3BloodPressure0.064632
4SkinThickness0.057744
\n", "
" ], "text/plain": [ " feature importance\n", "2 Glucose 0.281562\n", "6 BMI 0.143892\n", "8 Age 0.111680\n", "7 DiabetesPedigreeFunction 0.107287\n", "0 PatientId 0.088247\n", "5 Insulin 0.077022\n", "1 Pregnancies 0.067935\n", "3 BloodPressure 0.064632\n", "4 SkinThickness 0.057744" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Cell 8: Manual feature importance selection from Random Forest\n", "importances = rf.feature_importances_\n", "feat_imp_df = pd.DataFrame({'feature': feature_names, 'importance': importances})\n", "feat_imp_df.sort_values('importance', ascending=False, inplace=True)\n", "print(\"Top features:\")\n", "display(feat_imp_df.head(20))\n", "\n", "# Plot feature importances (top 15)\n", "plt.figure(figsize=(8,6))\n", "sns.barplot(data=feat_imp_df.head(15), x='importance', y='feature')\n", "plt.title(\"Top feature importances (Random Forest)\")\n", "plt.tight_layout()\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "cd8239ae", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Selected top features: ['Glucose', 'BMI', 'Age', 'DiabetesPedigreeFunction', 'PatientId']\n", "--- Random Forest (top 5 features) ---\n", "Accuracy: 0.765625\n", " precision recall f1-score support\n", "\n", " 0 0.79 0.86 0.83 125\n", " 1 0.70 0.58 0.63 67\n", "\n", " accuracy 0.77 192\n", " macro avg 0.75 0.72 0.73 192\n", "weighted avg 0.76 0.77 0.76 192\n", "\n", "Confusion matrix:\n", " [[108 17]\n", " [ 28 39]]\n", "\n" ] } ], "source": [ "# Cell 9: Retrain using top N features (manual selection)\n", "top_n = TOP_N_FEATURES\n", "top_features = feat_imp_df['feature'].head(top_n).tolist()\n", "print(\"Selected top features:\", top_features)\n", "\n", "X_train_top = X_train[top_features]\n", "X_test_top = X_test[top_features]\n", "\n", "rf_top = RandomForestClassifier(n_estimators=200, random_state=RANDOM_STATE)\n", "rf_top.fit(X_train_top, y_train)\n", "y_pred_rf_top = rf_top.predict(X_test_top)\n", "\n", "print_classification_results(f\"Random Forest (top {top_n} features)\", y_test, y_pred_rf_top, target_names=target_names)\n", "metrics_rf_top = compute_metrics(y_test, y_pred_rf_top, average=average_for_metrics)\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "bc649378", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "PCA chosen components (to reach 95% variance): 8\n", "--- Random Forest (PCA, n_components=8) ---\n", "Accuracy: 0.703125\n", " precision recall f1-score support\n", "\n", " 0 0.77 0.78 0.77 125\n", " 1 0.58 0.57 0.57 67\n", "\n", " accuracy 0.70 192\n", " macro avg 0.67 0.67 0.67 192\n", "weighted avg 0.70 0.70 0.70 192\n", "\n", "Confusion matrix:\n", " [[97 28]\n", " [29 38]]\n", "\n" ] } ], "source": [ "# Cell 10: PCA dimensionality reduction and Random Forest on PCA features\n", "# Scale already applied; we'll apply PCA to X_train/X_test (which are scaled numeric + one-hot).\n", "pca = PCA(n_components=PCA_VARIANCE_THRESHOLD, svd_solver='full', random_state=RANDOM_STATE)\n", "pca.fit(X_train)\n", "\n", "# Determine number of components selected\n", "n_components = pca.n_components_\n", "print(f\"PCA chosen components (to reach {PCA_VARIANCE_THRESHOLD*100:.0f}% variance):\", n_components)\n", "\n", "X_train_pca = pca.transform(X_train)\n", "X_test_pca = pca.transform(X_test)\n", "\n", "# Train RF on PCA features\n", "rf_pca = RandomForestClassifier(n_estimators=200, random_state=RANDOM_STATE)\n", "rf_pca.fit(X_train_pca, y_train)\n", "y_pred_rf_pca = rf_pca.predict(X_test_pca)\n", "\n", "print_classification_results(f\"Random Forest (PCA, n_components={n_components})\", y_test, y_pred_rf_pca, target_names=target_names)\n", "metrics_rf_pca = compute_metrics(y_test, y_pred_rf_pca, average=average_for_metrics)\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "2c3e32ce", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "--- Logistic Regression (full features) ---\n", "Accuracy: 0.7291666666666666\n", " precision recall f1-score support\n", "\n", " 0 0.77 0.84 0.80 125\n", " 1 0.64 0.52 0.57 67\n", "\n", " accuracy 0.73 192\n", " macro avg 0.70 0.68 0.69 192\n", "weighted avg 0.72 0.73 0.72 192\n", "\n", "Confusion matrix:\n", " [[105 20]\n", " [ 32 35]]\n", "\n", "--- Gaussian Naive Bayes (full features) ---\n", "Accuracy: 0.71875\n", " precision recall f1-score support\n", "\n", " 0 0.79 0.78 0.78 125\n", " 1 0.59 0.61 0.60 67\n", "\n", " accuracy 0.72 192\n", " macro avg 0.69 0.69 0.69 192\n", "weighted avg 0.72 0.72 0.72 192\n", "\n", "Confusion matrix:\n", " [[97 28]\n", " [26 41]]\n", "\n" ] } ], "source": [ "# Cell 11: Logistic Regression and Gaussian Naive Bayes\n", "# Logistic Regression on full features\n", "logreg = LogisticRegression(max_iter=1000, solver='liblinear', random_state=RANDOM_STATE)\n", "logreg.fit(X_train, y_train)\n", "y_pred_logreg = logreg.predict(X_test)\n", "print_classification_results(\"Logistic Regression (full features)\", y_test, y_pred_logreg, target_names=target_names)\n", "metrics_logreg = compute_metrics(y_test, y_pred_logreg, average=average_for_metrics)\n", "\n", "# Gaussian Naive Bayes (on full features)\n", "gnb = GaussianNB()\n", "# GaussianNB expects dense arrays; X_train/X_test are already dense DataFrames\n", "gnb.fit(X_train.values, y_train)\n", "y_pred_gnb = gnb.predict(X_test.values)\n", "print_classification_results(\"Gaussian Naive Bayes (full features)\", y_test, y_pred_gnb, target_names=target_names)\n", "metrics_gnb = compute_metrics(y_test, y_pred_gnb, average=average_for_metrics)\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "051612b3", "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", "
modelaccuracyprecisionrecallf1
0RandomForest (top_5)0.76560.69640.58210.6341
1GaussianNB0.71880.59420.61190.6029
2LogisticRegression0.72920.63640.52240.5738
3RandomForest (PCA_8)0.70310.57580.56720.5714
4RandomForest (full)0.73440.66000.49250.5641
\n", "
" ], "text/plain": [ " model accuracy precision recall f1\n", "0 RandomForest (top_5) 0.7656 0.6964 0.5821 0.6341\n", "1 GaussianNB 0.7188 0.5942 0.6119 0.6029\n", "2 LogisticRegression 0.7292 0.6364 0.5224 0.5738\n", "3 RandomForest (PCA_8) 0.7031 0.5758 0.5672 0.5714\n", "4 RandomForest (full) 0.7344 0.6600 0.4925 0.5641" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Cell 12: Collect and compare metrics in a summary table\n", "results = pd.DataFrame([\n", " {'model': 'RandomForest (full)', **metrics_rf},\n", " {'model': f'RandomForest (top_{TOP_N_FEATURES})', **metrics_rf_top},\n", " {'model': f'RandomForest (PCA_{n_components})', **metrics_rf_pca},\n", " {'model': 'LogisticRegression', **metrics_logreg},\n", " {'model': 'GaussianNB', **metrics_gnb},\n", "])\n", "\n", "# Format numbers\n", "results[['accuracy', 'precision', 'recall', 'f1']] = results[['accuracy', 'precision', 'recall', 'f1']].applymap(lambda x: round(x, 4))\n", "display(results.sort_values('f1', ascending=False).reset_index(drop=True))\n" ] }, { "cell_type": "code", "execution_count": 13, "id": "65263c02", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Cell 13: Optional — show ROC curve and AUC if you want (binary tasks)\n", "# We'll compute ROC AUC for models that provide decision_function or predict_proba\n", "from sklearn.metrics import roc_auc_score, roc_curve, RocCurveDisplay\n", "\n", "def safe_proba(model, X):\n", " if hasattr(model, \"predict_proba\"):\n", " return model.predict_proba(X)[:,1]\n", " elif hasattr(model, \"decision_function\"):\n", " # scale decision function to 0..1 via logistic-ish mapping for plot only\n", " scores = model.decision_function(X)\n", " # not ideal, but we can still compute AUC using scores directly\n", " return scores\n", " else:\n", " return None\n", "\n", "models_for_auc = {\n", " 'RF_full': (rf, X_test),\n", " 'RF_top': (rf_top, X_test_top),\n", " 'RF_pca': (rf_pca, X_test_pca),\n", " 'LogReg': (logreg, X_test),\n", " 'GNB': (gnb, X_test.values)\n", "}\n", "\n", "plt.figure(figsize=(8,6))\n", "for name, (model_obj, X_for) in models_for_auc.items():\n", " scores = safe_proba(model_obj, X_for)\n", " if scores is None:\n", " continue\n", " try:\n", " auc = roc_auc_score(y_test, scores)\n", " except Exception as e:\n", " auc = None\n", " if auc is not None:\n", " fpr, tpr, _ = roc_curve(y_test, scores)\n", " plt.plot(fpr, tpr, label=f\"{name} (AUC={auc:.3f})\")\n", "\n", "plt.plot([0,1],[0,1],'k--', linewidth=0.7)\n", "plt.xlabel(\"False Positive Rate\")\n", "plt.ylabel(\"True Positive Rate\")\n", "plt.title(\"ROC Curves\")\n", "plt.legend()\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": 17, "id": "7e3dab34", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Conclusions / Next steps:\n", "\n", "1. Compare the table above to see which model has the best F1 (balanced measure of precision & recall).\n", "2. Manual feature selection reduced the feature set to the top N by RandomForest importance. Often this speeds up inference and can reduce overfitting, but check if metrics improved or slightly dropped.\n", "3. PCA reduced dimensionality (keeps variance) — useful if features are highly correlated; sometimes RF still performs well on PCA features, sometimes worse because interpretability is lost.\n", "4. Logistic Regression and GaussianNB serve as simple baselines. If LogisticRegression performs similarly to RF, prefer LR for interpretability in production.\n", "Next steps to improve experiments:\n", "- Cross-validate each model (use cross_val_score or GridSearchCV) to get more stable metric estimates.\n", "- Tune hyperparameters for RandomForest and LogisticRegression.\n", "- Try feature engineering (interaction terms, polynomial features), or other dimensionality reduction (SelectFromModel, L1-based selection).\n" ] } ], "source": [ "# Cell 14: Short write-up / conclusions (printable)\n", "print(\"Conclusions / Next steps:\\n\")\n", "print(\"1. Compare the table above to see which model has the best F1 (balanced measure of precision & recall).\")\n", "print(\"2. Manual feature selection reduced the feature set to the top N by RandomForest importance. Often this speeds up inference and can reduce overfitting, but check if metrics improved or slightly dropped.\")\n", "print(\"3. PCA reduced dimensionality (keeps variance) — useful if features are highly correlated; sometimes RF still performs well on PCA features, sometimes worse because interpretability is lost.\")\n", "print(\"4. Logistic Regression and GaussianNB serve as simple baselines. If LogisticRegression performs similarly to RF, prefer LR for interpretability in production.\")\n", "print(\"Next steps to improve experiments:\")\n", "print(\"- Cross-validate each model (use cross_val_score or GridSearchCV) to get more stable metric estimates.\")\n", "print(\"- Tune hyperparameters for RandomForest and LogisticRegression.\")\n", "print(\"- Try feature engineering (interaction terms, polynomial features), or other dimensionality reduction (SelectFromModel, L1-based selection).\")\n" ] } ], "metadata": { "kernelspec": { "display_name": "base", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.12" } }, "nbformat": 4, "nbformat_minor": 5 }