From 53d5116bbdb2a0f84b1ec5bfbb3aa53204615f94 Mon Sep 17 00:00:00 2001
From: Petrus <petrus.einarsson@gmail.com>
Date: Wed, 22 Oct 2025 14:55:06 +0200
Subject: [PATCH] Tried expanding hyperparameter tuning

---
 Analysis.ipynb      |  48 ++++---
 Decision_tree.ipynb | 298 ++++++++++++++++++++++++++++++++++++++++----
 decision_tree.pdf   | Bin 31960 -> 31960 bytes
 3 files changed, 295 insertions(+), 51 deletions(-)

diff --git a/Analysis.ipynb b/Analysis.ipynb
index 4b2c9f80..cf89033f 100644
--- a/Analysis.ipynb
+++ b/Analysis.ipynb
@@ -6,12 +6,12 @@
    "metadata": {},
    "source": [
     "### Creates a correlation matrix\n",
-    "We should probably remove or combine some features"
+    "This used to see if we should remove or combine some features"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "id": "557ed2b5",
    "metadata": {},
    "outputs": [
@@ -30,27 +30,25 @@
      "output_type": "stream",
      "text": [
       "<class 'pandas.core.frame.DataFrame'>\n",
-      "RangeIndex: 32561 entries, 0 to 32560\n",
-      "Data columns (total 15 columns):\n",
-      " #   Column          Non-Null Count  Dtype \n",
-      "---  ------          --------------  ----- \n",
-      " 0   age             32561 non-null  int64 \n",
-      " 1   workclass       32561 non-null  object\n",
-      " 2   fnlwgt          32561 non-null  int64 \n",
-      " 3   education       32561 non-null  object\n",
-      " 4   education.num   32561 non-null  int64 \n",
-      " 5   marital.status  32561 non-null  object\n",
-      " 6   occupation      32561 non-null  object\n",
-      " 7   relationship    32561 non-null  object\n",
-      " 8   race            32561 non-null  object\n",
-      " 9   sex             32561 non-null  object\n",
-      " 10  capital.gain    32561 non-null  int64 \n",
-      " 11  capital.loss    32561 non-null  int64 \n",
-      " 12  hours.per.week  32561 non-null  int64 \n",
-      " 13  native.country  32561 non-null  object\n",
-      " 14  income          32561 non-null  object\n",
-      "dtypes: int64(6), object(9)\n",
-      "memory usage: 3.7+ MB\n"
+      "Index: 30162 entries, 1 to 32560\n",
+      "Data columns (total 13 columns):\n",
+      " #   Column          Non-Null Count  Dtype\n",
+      "---  ------          --------------  -----\n",
+      " 0   age             30162 non-null  int64\n",
+      " 1   workclass       30162 non-null  int64\n",
+      " 2   education.num   30162 non-null  int64\n",
+      " 3   marital.status  30162 non-null  int64\n",
+      " 4   occupation      30162 non-null  int64\n",
+      " 5   relationship    30162 non-null  int64\n",
+      " 6   race            30162 non-null  int64\n",
+      " 7   sex             30162 non-null  int64\n",
+      " 8   capital.gain    30162 non-null  int64\n",
+      " 9   capital.loss    30162 non-null  int64\n",
+      " 10  hours.per.week  30162 non-null  int64\n",
+      " 11  native.country  30162 non-null  int64\n",
+      " 12  income          30162 non-null  int64\n",
+      "dtypes: int64(13)\n",
+      "memory usage: 3.2 MB\n"
      ]
     }
    ],
@@ -91,8 +89,8 @@
     "plt.show()\n",
     "\n",
     "#df_encoded.head(10)\n",
-    "df.info()\n",
-    "\n"
+    "df_encoded.info()\n",
+    "#df.head(20)\n"
    ]
   },
   {
diff --git a/Decision_tree.ipynb b/Decision_tree.ipynb
index 32ff772d..7f9e2281 100644
--- a/Decision_tree.ipynb
+++ b/Decision_tree.ipynb
@@ -47,24 +47,25 @@
       "weighted avg       0.81      0.81      0.81      6033\n",
       "\n",
       "<class 'pandas.core.frame.DataFrame'>\n",
-      "Index: 18096 entries, 13586 to 5836\n",
-      "Data columns (total 12 columns):\n",
+      "Index: 30162 entries, 1 to 32560\n",
+      "Data columns (total 13 columns):\n",
       " #   Column          Non-Null Count  Dtype\n",
       "---  ------          --------------  -----\n",
-      " 0   age             18096 non-null  int64\n",
-      " 1   workclass       18096 non-null  int64\n",
-      " 2   education.num   18096 non-null  int64\n",
-      " 3   marital.status  18096 non-null  int64\n",
-      " 4   occupation      18096 non-null  int64\n",
-      " 5   relationship    18096 non-null  int64\n",
-      " 6   race            18096 non-null  int64\n",
-      " 7   sex             18096 non-null  int64\n",
-      " 8   capital.gain    18096 non-null  int64\n",
-      " 9   capital.loss    18096 non-null  int64\n",
-      " 10  hours.per.week  18096 non-null  int64\n",
-      " 11  native.country  18096 non-null  int64\n",
-      "dtypes: int64(12)\n",
-      "memory usage: 1.8 MB\n"
+      " 0   age             30162 non-null  int64\n",
+      " 1   workclass       30162 non-null  int64\n",
+      " 2   education.num   30162 non-null  int64\n",
+      " 3   marital.status  30162 non-null  int64\n",
+      " 4   occupation      30162 non-null  int64\n",
+      " 5   relationship    30162 non-null  int64\n",
+      " 6   race            30162 non-null  int64\n",
+      " 7   sex             30162 non-null  int64\n",
+      " 8   capital.gain    30162 non-null  int64\n",
+      " 9   capital.loss    30162 non-null  int64\n",
+      " 10  hours.per.week  30162 non-null  int64\n",
+      " 11  native.country  30162 non-null  int64\n",
+      " 12  income          30162 non-null  int64\n",
+      "dtypes: int64(13)\n",
+      "memory usage: 3.2 MB\n"
      ]
     }
    ],
@@ -72,7 +73,7 @@
     "import pandas as pd\n",
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
-    "from sklearn.model_selection import train_test_split, RandomizedSearchCV\n",
+    "from sklearn.model_selection import train_test_split, RandomizedSearchCV, KFold, StratifiedKFold, GridSearchCV\n",
     "from sklearn.pipeline import Pipeline\n",
     "from sklearn.tree import DecisionTreeClassifier, plot_tree\n",
     "from sklearn.preprocessing import LabelEncoder\n",
@@ -81,6 +82,7 @@
     "from scipy.stats import randint\n",
     "\n",
     "\n",
+    "\n",
     "# Load dataset\n",
     "df = pd.read_csv('./Datasets/adult.csv', comment = '#')\n",
     "\n",
@@ -146,7 +148,15 @@
     "print(\"Classification Report:\")\n",
     "print(classification_report(y_val, y_pred, target_names=[\"Poor\", \"Rich\"]))\n",
     "\n",
-    "X_train.info()"
+    "df_encoded.info()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bfaae28c",
+   "metadata": {},
+   "source": [
+    "### Hyperparameter tuning"
    ]
   },
   {
@@ -162,13 +172,15 @@
       "Classification Report:\n",
       "              precision    recall  f1-score   support\n",
       "\n",
-      "        Poor       0.89      0.92      0.90      4524\n",
-      "        Rich       0.73      0.65      0.68      1509\n",
+      "        Poor       0.88      0.93      0.90      4524\n",
+      "        Rich       0.75      0.62      0.68      1509\n",
       "\n",
       "    accuracy                           0.85      6033\n",
       "   macro avg       0.81      0.78      0.79      6033\n",
       "weighted avg       0.85      0.85      0.85      6033\n",
-      "\n"
+      "\n",
+      "Best max_depth: 12\n",
+      "Best min_samples_split: 18\n"
      ]
     }
    ],
@@ -176,36 +188,270 @@
     "# Hyperparameters search space\n",
     "param_dist = {\n",
     "    'full_dt_classifier__max_depth': randint(3, 20),\n",
-    "    'full_dt_classifier__min_samples_split': randint(2, 10),\n",
-    "    'full_dt_classifier__min_samples_leaf': randint(1, 10),\n",
+    "    'full_dt_classifier__min_samples_split': randint(2, 20),\n",
+    "    'full_dt_classifier__min_samples_leaf': randint(1, 15),\n",
     "}\n",
     "\n",
     "# Ranodmized search for hyperparameter tuning\n",
     "random_search = RandomizedSearchCV(\n",
     "    estimator=model,\n",
     "    param_distributions=param_dist,\n",
-    "    n_iter = 50,\n",
+    "    n_iter = 300,\n",
     "    cv = 10,\n",
     "    scoring = 'r2',\n",
     "    n_jobs = -1,\n",
     "    random_state = 42\n",
     ")\n",
     "\n",
+    "#K_fold = KFold(n_splits=10, shuffle=True, random_state=42)\n",
+    "#cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)\n",
+    "#grid_search = GridSearchCV(model, param_grid, scoring='accuracy', cv=cv, n_jobs=-1)\n",
+    "\n",
     "# Fit search\n",
     "random_search.fit(X_train, y_train)\n",
+    "random_search.fit(X_train, y_train)\n",
     "\n",
     "# Best model training\n",
     "best_model = random_search.best_estimator_\n",
     "y_pred_best = best_model.predict(X_val)\n",
     "\n",
     "print(\"Classification Report:\")\n",
-    "print(classification_report(y_val, y_pred_best, target_names=[\"Poor\", \"Rich\"]))"
+    "print(classification_report(y_val, y_pred_best, target_names=[\"Poor\", \"Rich\"]))\n",
+    "\n",
+    "best_max_depth = best_model.named_steps['full_dt_classifier'].max_depth\n",
+    "best_min_samples_split = best_model.named_steps['full_dt_classifier'].min_samples_split\n",
+    "best_min_samples_leaf = best_model.named_steps['full_dt_classifier'].min_samples_leaf\n",
+    "\n",
+    "print(f'Best max_depth: {best_max_depth}')\n",
+    "print(f'Best min_samples_split: {best_min_samples_split}')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a37f45b4",
+   "metadata": {},
+   "source": [
+    "### Classifier comparison\n",
+    "(This is taken from the ensemble lab)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e68b1ea9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.model_selection import GridSearchCV, StratifiedKFold\n",
+    "import time\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.metrics import (accuracy_score, precision_score, \n",
+    "                             recall_score, f1_score, \n",
+    "                             confusion_matrix, ConfusionMatrixDisplay)\n",
+    "from sklearn.ensemble import (RandomForestClassifier, BaggingClassifier, \n",
+    "                              AdaBoostClassifier, GradientBoostingClassifier)\n",
+    "from xgboost import XGBClassifier        # Requires installation of the package ; Not a native function in sklearn\n",
+    "from lightgbm import LGBMClassifier      # Requires installation of the package; Not a native function in sklearn\n",
+    "from catboost import CatBoostClassifier  # Requires installation of the package; Not a native function in sklearn\n",
+    "\n",
+    "class ClassifierComparisonOpt:\n",
+    "    def __init__(self, X, y, test_size=0.3, use_bootstrap=True, random_state=42, cv_folds=10):\n",
+    "        # Split data stratified by labels\n",
+    "        X_train, X_test, y_train, y_test = train_test_split(\n",
+    "            X, y, test_size=test_size, stratify=y, random_state=random_state)\n",
+    "\n",
+    "        # Scale features\n",
+    "        scaler = StandardScaler()\n",
+    "        self.X_train = scaler.fit_transform(X_train)\n",
+    "        self.X_test  = scaler.transform(X_test)\n",
+    "\n",
+    "        self.y_train       = y_train\n",
+    "        self.y_test        = y_test\n",
+    "        self.use_bootstrap = use_bootstrap\n",
+    "        self.cv_folds      = cv_folds\n",
+    "        self.models        = {}\n",
+    "        self.results       = {}\n",
+    "        self.results_df    = None\n",
+    "\n",
+    "    # Define the classifiers and their hyperparameters\n",
+    "    def get_models_with_params(self):\n",
+    "        return {\n",
+    "            'Decision Tree': (DecisionTreeClassifier(random_state=42), {\n",
+    "                'max_depth': [None, 10, 11, 12, 13, 14, 15, 16],\n",
+    "                'min_samples_split': [3, 4, 5, 6, 7, 8, 9]\n",
+    "            }),\n",
+    "            'Random Forest': (RandomForestClassifier(bootstrap=self.use_bootstrap, random_state=42), {\n",
+    "                'n_estimators': [50, 100, 200], # I currently don't know how to tune this\n",
+    "                'max_depth': [None, 10, 11, 12, 13, 14, 15, 16],\n",
+    "                'min_samples_split': [3, 4, 5, 6, 7, 8, 9]\n",
+    "            }),\n",
+    "            #'Bagging': (BaggingClassifier(bootstrap=self.use_bootstrap, random_state=42), {\n",
+    "            #    'n_estimators': [50, 100, 200],\n",
+    "            #    'max_samples': [0.5, 1.0],\n",
+    "            #    'oob_score': [True, False],\n",
+    "            #}),\n",
+    "            # SAMME: Stagewise Additive Modeling using a Multi-class Exponential loss\n",
+    "            #'AdaBoost': (AdaBoostClassifier(algorithm='SAMME', random_state=42), {\n",
+    "            #    'n_estimators': [50, 100, 200],\n",
+    "            #    'learning_rate': [0.01, 0.1, 0.2, 0.5, 1.0]\n",
+    "            #}),\n",
+    "            #'Gradient Boosting': (GradientBoostingClassifier(random_state=42), {\n",
+    "            #    'n_estimators': [50, 100, 200],\n",
+    "            #    'learning_rate': [0.01, 0.1, 0.2, 0.5, 1.0],\n",
+    "            #    'max_depth': [3, 5, 10]\n",
+    "            #}),\n",
+    "            #'XGBoost': (XGBClassifier(eval_metric='mlogloss', random_state=42), {\n",
+    "            #    'n_estimators': [50, 100, 200],\n",
+    "            #    'learning_rate': [0.01, 0.1, 0.2, 0.5, 1.0],\n",
+    "            #    'max_depth': [3, 5, 10]\n",
+    "            #}),\n",
+    "            #'LightGBM': (LGBMClassifier(random_state=42), {\n",
+    "            #    'n_estimators': [50, 100, 200],\n",
+    "            #    'learning_rate': [0.01, 0.1, 0.2, 0.5, 1.0],\n",
+    "            #    'max_depth': [-1, 5, 10]\n",
+    "            #}),\n",
+    "            #'CatBoost': (CatBoostClassifier(verbose=0, random_state=42), {\n",
+    "            #    'iterations': [50, 100, 200],\n",
+    "            #    'learning_rate': [0.01, 0.1, 0.2, 0.5, 1.0],\n",
+    "            #    'depth': [4, 6, 10]\n",
+    "            #})\n",
+    "        }\n",
+    "\n",
+    "    def fit_models(self):\n",
+    "        results_list = []\n",
+    "        cv = StratifiedKFold(n_splits=self.cv_folds, shuffle=True, random_state=42)\n",
+    "        models_with_params = self.get_models_with_params()\n",
+    "\n",
+    "        for name, (model, param_grid) in models_with_params.items():\n",
+    "            print(f\"Tuning {name} ...\")\n",
+    "            \n",
+    "            grid_search = GridSearchCV(model, param_grid, scoring='accuracy', cv=cv, n_jobs=-1)\n",
+    "            \n",
+    "            start_train = time.time()\n",
+    "            grid_search.fit(self.X_train, self.y_train)\n",
+    "            end_train = time.time()\n",
+    "\n",
+    "            best_model = grid_search.best_estimator_\n",
+    "            y_pred = best_model.predict(self.X_test)\n",
+    "            end_pred = time.time()\n",
+    "\n",
+    "            self.models[name] = {\n",
+    "                'model': best_model,\n",
+    "                'confusion_matrix': confusion_matrix(self.y_test, y_pred)\n",
+    "            }\n",
+    "\n",
+    "            metrics = {\n",
+    "                'Model': name,\n",
+    "                'Accuracy': accuracy_score(self.y_test, y_pred),\n",
+    "                'Precision': precision_score(self.y_test, y_pred, average='weighted', zero_division=0),\n",
+    "                'Recall': recall_score(self.y_test, y_pred, average='weighted'),\n",
+    "                'F1 Score': f1_score(self.y_test, y_pred, average='weighted'),\n",
+    "                'Best Params': grid_search.best_params_,\n",
+    "                'Training Time (s)': (end_train - start_train),\n",
+    "                'Prediction Time (s)': (end_pred - end_train),\n",
+    "                'Total Time (s)': (end_pred - start_train)\n",
+    "            }\n",
+    "\n",
+    "            results_list.append(metrics)\n",
+    "\n",
+    "        self.results_df = pd.DataFrame(results_list)\n",
+    "\n",
+    "    def print_summary(self):\n",
+    "        print(\"\\n------ Results Sorted by Accuracy ------\")\n",
+    "        print(self.results_df.sort_values(by='Accuracy', ascending=False).to_string(index=False))\n",
+    "\n",
+    "        print(\"\\n------ Results Sorted by Total Time ------\")\n",
+    "        print(self.results_df.sort_values(by='Total Time (s)', ascending=True).to_string(index=False))\n",
+    "\n",
+    "    # Show feature importance for models that support it          \n",
+    "    def show_feature_importance(self):\n",
+    "        importance = {}\n",
+    "\n",
+    "        for name, result in self.models.items():\n",
+    "            model = result['model']\n",
+    "            if hasattr(model, 'feature_importances_'):\n",
+    "                importance[name] = model.feature_importances_\n",
+    "            elif hasattr(model, 'coef_'):\n",
+    "                coef = model.coef_\n",
+    "                if coef.ndim == 1:\n",
+    "                    importance[name] = np.abs(coef)\n",
+    "                else:\n",
+    "                    importance[name] = np.mean(np.abs(coef), axis=0)\n",
+    "            else:\n",
+    "                print(f\"Feature importance not available for model {name}\")\n",
+    "\n",
+    "        for name, imp in importance.items():\n",
+    "            sorted_idx = np.argsort(imp)[::-1]\n",
+    "            plt.figure()\n",
+    "            plt.bar(range(len(imp)), imp[sorted_idx], align='center')\n",
+    "            plt.xticks(range(len(imp)), sorted_idx)\n",
+    "            plt.title(f\"Feature importance for {name}\")\n",
+    "            plt.xlabel(\"Feature index\")\n",
+    "            plt.ylabel(\"Importance score\")\n",
+    "            plt.grid(True, linestyle='--', alpha=0.6)\n",
+    "            plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "d6fd1fee",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tuning Decision Tree ...\n",
+      "Tuning Random Forest ...\n",
+      "\n",
+      "------ Results Sorted by Accuracy ------\n",
+      "        Model  Accuracy  Precision   Recall  F1 Score                                                    Best Params  Training Time (s)  Prediction Time (s)  Total Time (s)\n",
+      "Random Forest  0.857617   0.852147 0.857617  0.852588 {'max_depth': 16, 'min_samples_split': 5, 'n_estimators': 200}         303.932920             0.216372      304.149293\n",
+      "Decision Tree  0.846381   0.840787 0.846381  0.842219                      {'max_depth': 10, 'min_samples_split': 9}           3.946769             0.001706        3.948475\n",
+      "\n",
+      "------ Results Sorted by Total Time ------\n",
+      "        Model  Accuracy  Precision   Recall  F1 Score                                                    Best Params  Training Time (s)  Prediction Time (s)  Total Time (s)\n",
+      "Decision Tree  0.846381   0.840787 0.846381  0.842219                      {'max_depth': 10, 'min_samples_split': 9}           3.946769             0.001706        3.948475\n",
+      "Random Forest  0.857617   0.852147 0.857617  0.852588 {'max_depth': 16, 'min_samples_split': 5, 'n_estimators': 200}         303.932920             0.216372      304.149293\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# ===== MAIN =====\n",
+    "# optimized classifiers and find their hyperparameters\n",
+    "clf_opt = ClassifierComparisonOpt(X_train, y_train)\n",
+    "clf_opt.fit_models()\n",
+    "clf_opt.print_summary()\n",
+    "\n",
+    "# Show feature importance for each model\n",
+    "clf_opt.show_feature_importance()"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": ".venv",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
diff --git a/decision_tree.pdf b/decision_tree.pdf
index 4b67ae7dbf09c093020feea4f8bc4da09abaddf5..12aead1592f9ae94dbe66898bc4519f148d52106 100644
GIT binary patch
delta 20
ccmccdlkvt+#tm!ASxpQrjZ8LgELUd*0BN}hhyVZp

delta 20
ccmccdlkvt+#tm!ASq+Vhj4U^AELUd*0BMQ{ga7~l