{ "cells": [ { "cell_type": "markdown", "id": "4f5e4da6", "metadata": {}, "source": [ "# A5: Heterogeneous regression ensemble\n", "\n", "- Train diverse base models with Lasso, Ridge, Random Forest, Gradient Boosting on different bootstrap samples\n", "- Use different feature subsets for diversity\n", "- Aggregate predictions by simple averaging and weighted averaging\n", "- Evaluate against current champion using corrected resampled t-test (explained later)" ] }, { "cell_type": "markdown", "id": "d8b3a317", "metadata": {}, "source": [ "## 1. Setup & Load Data" ] }, { "cell_type": "code", "execution_count": null, "id": "4c15cc3f", "metadata": {}, "outputs": [], "source": [ "import os\n", "import sys\n", "import pickle\n", "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "from scipy import stats\n", "\n", "from sklearn.linear_model import LassoCV, RidgeCV, ElasticNetCV\n", "from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor\n", "from sklearn.preprocessing import StandardScaler\n", "from sklearn.pipeline import Pipeline\n", "from sklearn.model_selection import cross_val_score, KFold\n", "from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score\n", "\n", "sys.path.insert(0, os.getcwd())\n", "from CorrelationFilter import CorrelationFilter\n", "\n", "RANDOM_STATE = 42\n", "np.random.seed(RANDOM_STATE)" ] }, { "cell_type": "code", "execution_count": null, "id": "64459ebc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Original train: (1675, 43)\n", "Bootstrap samples: 4 sets, each ~1675 rows\n", "Test set: (419, 43)\n" ] } ], "source": [ "DATA_DIR = os.path.join(os.getcwd(), \"data\")\n", "\n", "df_train_original = pd.read_csv(os.path.join(DATA_DIR, \"dataset2_train_original.csv\"))\n", "\n", "# Bootstrap/augmented training sets (for ensemble diversity)\n", "df_train_aug = {}\n", "for i in range(1, 5): # Use 4 bootstrap samples for 4 base models\n", " df_train_aug[i] = pd.read_csv(os.path.join(DATA_DIR, f\"dataset2_train_augmented_{i}.csv\"))\n", "\n", "# Held-out test set\n", "df_test = pd.read_csv(os.path.join(DATA_DIR, \"dataset2_test.csv\"))\n", "\n", "print(f\"Original train: {df_train_original.shape}\")\n", "print(f\"Bootstrap samples: {len(df_train_aug)} sets, each ~{df_train_aug[1].shape[0]} rows\")\n", "print(f\"Test set: {df_test.shape}\")" ] }, { "cell_type": "code", "execution_count": 14, "id": "ec6e0bee", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Total features: 40\n", "Angle features: 13\n", "NASM features: 25\n", "Time features: 2\n" ] } ], "source": [ "# Define target and features\n", "TARGET = \"AimoScore\"\n", "DROP_COLS = [\"ID\", \"EstimatedScore\", TARGET]\n", "\n", "# Feature groups\n", "all_cols = [c for c in df_train_original.columns if c not in DROP_COLS]\n", "angle_cols = [c for c in all_cols if \"Angle\" in c]\n", "nasm_cols = [c for c in all_cols if \"NASM\" in c]\n", "time_cols = [c for c in all_cols if \"Time\" in c]\n", "\n", "print(f\"Total features: {len(all_cols)}\")\n", "print(f\"Angle features: {len(angle_cols)}\")\n", "print(f\"NASM features: {len(nasm_cols)}\")\n", "print(f\"Time features: {len(time_cols)}\")" ] }, { "cell_type": "markdown", "id": "5e493b4a", "metadata": {}, "source": [ "## 2. Define Feature Subsets\n", "Create 4 feature groups with full, angle-only, nasm-only, angle+nasm for ensemble diversity." ] }, { "cell_type": "code", "execution_count": 15, "id": "122de36d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "full: 40 features\n", "angle_only: 13 features\n", "nasm_only: 25 features\n", "angle_nasm: 38 features\n" ] } ], "source": [ "# Feature subsets for ensemble diversity\n", "FEATURE_SUBSETS = {\n", " \"full\": all_cols,\n", " \"angle_only\": angle_cols,\n", " \"nasm_only\": nasm_cols,\n", " \"angle_nasm\": angle_cols + nasm_cols # Exclude time\n", "}\n", "\n", "for name, cols in FEATURE_SUBSETS.items():\n", " print(f\"{name}: {len(cols)} features\")" ] }, { "cell_type": "markdown", "id": "493f2ecb", "metadata": {}, "source": [ "## 3. Define Base Models\n", "Configure 4 regressors LassoCV, RidgeCV, RandomForest, and GradientBoosting." ] }, { "cell_type": "code", "execution_count": null, "id": "82dacd6e", "metadata": {}, "outputs": [], "source": [ "def get_base_models():\n", " return {\n", " \"lasso\": Pipeline([\n", " (\"scaler\", StandardScaler()),\n", " (\"model\", LassoCV(cv=5, random_state=RANDOM_STATE, max_iter=5000))\n", " ]),\n", " \"ridge\": Pipeline([\n", " (\"scaler\", StandardScaler()),\n", " (\"model\", RidgeCV(cv=5))\n", " ]),\n", " \"rf\": Pipeline([\n", " (\"corrfilter\", CorrelationFilter(threshold=0.95)),\n", " (\"model\", RandomForestRegressor(\n", " n_estimators=200, max_depth=15, \n", " min_samples_split=5, min_samples_leaf=2,\n", " random_state=RANDOM_STATE, n_jobs=-1\n", " ))\n", " ]),\n", " \"gb\": Pipeline([\n", " (\"scaler\", StandardScaler()),\n", " (\"model\", GradientBoostingRegressor(\n", " n_estimators=150, max_depth=5, \n", " learning_rate=0.1, min_samples_split=5,\n", " random_state=RANDOM_STATE\n", " ))\n", " ])\n", " }" ] }, { "cell_type": "markdown", "id": "205c1359", "metadata": {}, "source": [ "## 4. Train Base Models on Different Bootstrap Samples\n", "Train each model on a different augmented dataset, evaluate with 5 fold crossvalidation and test set." ] }, { "cell_type": "code", "execution_count": 17, "id": "5b7a7b22", "metadata": {}, "outputs": [], "source": [ "def evaluate_model(model, X_test, y_test):\n", " \"\"\"Calculate regression metrics.\"\"\"\n", " y_pred = model.predict(X_test)\n", " return {\n", " \"r2\": r2_score(y_test, y_pred),\n", " \"rmse\": np.sqrt(mean_squared_error(y_test, y_pred)),\n", " \"mae\": mean_absolute_error(y_test, y_pred),\n", " \"corr\": np.corrcoef(y_test, y_pred)[0, 1]\n", " }" ] }, { "cell_type": "code", "execution_count": 18, "id": "95e96281", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training base models...\n", "\n", "Model Bootstrap Features CV R² Test R² Test RMSE \n", "-----------------------------------------------------------------\n", "lasso 1 full 0.5496 0.5986 0.1548 \n", "ridge 2 full 0.5864 0.6164 0.1513 \n", "rf 3 full 0.7907 0.7195 0.1294 \n", "gb 4 full 0.7809 0.7307 0.1268 \n", "\n", "Base model training complete.\n" ] } ], "source": [ "# Configuration: which model trains on which bootstrap sample with which features\n", "ENSEMBLE_CONFIG = [\n", " {\"name\": \"lasso\", \"bootstrap\": 1, \"features\": \"full\"},\n", " {\"name\": \"ridge\", \"bootstrap\": 2, \"features\": \"full\"},\n", " {\"name\": \"rf\", \"bootstrap\": 3, \"features\": \"full\"},\n", " {\"name\": \"gb\", \"bootstrap\": 4, \"features\": \"full\"},\n", "]\n", "\n", "# Prepare test data\n", "X_test = df_test[all_cols].values\n", "y_test = df_test[TARGET].values\n", "\n", "# Train models and collect predictions\n", "trained_models = []\n", "test_predictions = []\n", "cv_scores = []\n", "\n", "print(\"Training base models...\\n\")\n", "print(f\"{'Model':<10} {'Bootstrap':<10} {'Features':<12} {'CV R²':<10} {'Test R²':<10} {'Test RMSE':<10}\")\n", "print(\"-\" * 65)\n", "\n", "for config in ENSEMBLE_CONFIG:\n", " model_name = config[\"name\"]\n", " boot_idx = config[\"bootstrap\"]\n", " feat_name = config[\"features\"]\n", " feat_cols = FEATURE_SUBSETS[feat_name]\n", " \n", " # Get training data from bootstrap sample\n", " df_train = df_train_aug[boot_idx]\n", " X_train = df_train[feat_cols].values\n", " y_train = df_train[TARGET].values\n", " \n", " # Get model\n", " model = get_base_models()[model_name]\n", " \n", " # Cross-validation on training data\n", " cv = KFold(n_splits=5, shuffle=True, random_state=RANDOM_STATE)\n", " cv_r2 = cross_val_score(model, X_train, y_train, cv=cv, scoring=\"r2\").mean()\n", " cv_scores.append(cv_r2)\n", " \n", " # Train on full bootstrap sample\n", " model.fit(X_train, y_train)\n", " \n", " # Predict on test set (using same feature subset)\n", " X_test_subset = df_test[feat_cols].values\n", " y_pred = model.predict(X_test_subset)\n", " test_predictions.append(y_pred)\n", " \n", " # Evaluate\n", " metrics = evaluate_model(model, X_test_subset, y_test)\n", " \n", " trained_models.append({\n", " \"name\": model_name,\n", " \"model\": model,\n", " \"features\": feat_cols,\n", " \"cv_r2\": cv_r2,\n", " \"test_metrics\": metrics\n", " })\n", " \n", " print(f\"{model_name:<10} {boot_idx:<10} {feat_name:<12} {cv_r2:<10.4f} {metrics['r2']:<10.4f} {metrics['rmse']:<10.4f}\")\n", "\n", "print(\"\\nBase model training complete.\")" ] }, { "cell_type": "markdown", "id": "b587f947", "metadata": {}, "source": [ "## 5. Ensemble Aggregation\n", "Combine base model predictions using simple averaging and crossvalidation weighted averaging." ] }, { "cell_type": "code", "execution_count": 19, "id": "5f2f6ffe", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Ensemble weights (based on CV R²):\n", " lasso: 0.2030\n", " ridge: 0.2166\n", " rf: 0.2920\n", " gb: 0.2884\n" ] } ], "source": [ "# Convert predictions to numpy array\n", "predictions_array = np.array(test_predictions) # Shape: (n_models, n_samples)\n", "\n", "# Simple averaging\n", "y_pred_avg = predictions_array.mean(axis=0)\n", "\n", "# Weighted averaging (weights based on CV R² scores)\n", "weights = np.array(cv_scores)\n", "weights = weights / weights.sum() # Normalize\n", "y_pred_weighted = np.average(predictions_array, axis=0, weights=weights)\n", "\n", "print(\"Ensemble weights (based on CV R²):\")\n", "for i, config in enumerate(ENSEMBLE_CONFIG):\n", " print(f\" {config['name']}: {weights[i]:.4f}\")" ] }, { "cell_type": "code", "execution_count": 20, "id": "bd81c9e7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "============================================================\n", "ENSEMBLE RESULTS\n", "============================================================\n", "\n", "Method R² RMSE MAE Corr \n", "------------------------------------------------------------\n", "Simple Average 0.7110 0.1314 0.0988 0.8476 \n", "Weighted Average 0.7204 0.1292 0.0968 0.8535 \n", "------------------------------------------------------------\n", "Current Champion 0.6356 0.1303 0.0972 0.8089 \n" ] } ], "source": [ "# Evaluate ensemble methods\n", "def calc_metrics(y_true, y_pred):\n", " return {\n", " \"r2\": r2_score(y_true, y_pred),\n", " \"rmse\": np.sqrt(mean_squared_error(y_true, y_pred)),\n", " \"mae\": mean_absolute_error(y_true, y_pred),\n", " \"corr\": np.corrcoef(y_true, y_pred)[0, 1]\n", " }\n", "\n", "metrics_avg = calc_metrics(y_test, y_pred_avg)\n", "metrics_weighted = calc_metrics(y_test, y_pred_weighted)\n", "\n", "print(\"\\n\" + \"=\" * 60)\n", "print(\"ENSEMBLE RESULTS\")\n", "print(\"=\" * 60)\n", "print(f\"\\n{'Method':<20} {'R²':<10} {'RMSE':<10} {'MAE':<10} {'Corr':<10}\")\n", "print(\"-\" * 60)\n", "print(f\"{'Simple Average':<20} {metrics_avg['r2']:<10.4f} {metrics_avg['rmse']:<10.4f} {metrics_avg['mae']:<10.4f} {metrics_avg['corr']:<10.4f}\")\n", "print(f\"{'Weighted Average':<20} {metrics_weighted['r2']:<10.4f} {metrics_weighted['rmse']:<10.4f} {metrics_weighted['mae']:<10.4f} {metrics_weighted['corr']:<10.4f}\")\n", "print(\"-\" * 60)\n", "print(f\"{'Current Champion':<20} {'0.6356':<10} {'0.1303':<10} {'0.0972':<10} {'0.8089':<10}\")" ] }, { "cell_type": "markdown", "id": "d4a8de75", "metadata": {}, "source": [ "## 6. Statistical Comparison (Corrected Resampled t-test)\n", "Test if ensemble improvement over champion is statistically significant using Nadeau-Bengio correction.\n", "\n", "When you compare two models using cross-validation, you're reusing the same data multiple times since each fold overlaps with others. This makes your results look more precise than they really are. \n", "\n", "As in to say standard t tests assume independent samples, and in crossvalidatoon the same data points appear in multiple train/test splits, which will inflate confidence, so one can claim some form of significant improvement eventho it does not exist\n", "\n", "NB correction adds a correction factor which accounts for overlapping samples between folds, which gives a more \"honest\" confidence interval\n", "\n", "ntest/ntrain = 419/1675 is 0.25. so the variance is inflated by about 25% which makes it harder to claim significant improvement. so we use this to be more confident about the improvement" ] }, { "cell_type": "code", "execution_count": 21, "id": "4fc01445", "metadata": {}, "outputs": [], "source": [ "def corrected_resampled_ttest(errors_1, errors_2, n_train, n_test, n_folds=5):\n", " \"\"\"\n", " Corrected resampled t-test for comparing two models.\n", " Nadeau & Bengio (2003) correction for variance inflation.\n", " \"\"\"\n", " diff = errors_1 - errors_2\n", " n = len(diff)\n", " mean_diff = np.mean(diff)\n", " var_diff = np.var(diff, ddof=1)\n", " \n", " # Correction factor\n", " correction = (1/n) + (n_test / n_train)\n", " corrected_var = correction * var_diff\n", " \n", " # t-statistic\n", " t_stat = mean_diff / np.sqrt(corrected_var)\n", " \n", " # p-value (two-tailed)\n", " df = n - 1\n", " p_value = 2 * stats.t.sf(np.abs(t_stat), df)\n", " \n", " return t_stat, p_value, mean_diff" ] }, { "cell_type": "code", "execution_count": 22, "id": "61afcd7d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Simple Average vs Champion:\n", " Mean MSE difference: -0.007098 (positive = champion worse)\n", " t-statistic: -0.6726\n", " p-value: 0.5016\n", " Significant at α=0.05: No\n", "\n", "Weighted Average vs Champion:\n", " Mean MSE difference: -0.006534 (positive = champion worse)\n", " t-statistic: -0.6376\n", " p-value: 0.5241\n", " Significant at α=0.05: No\n" ] } ], "source": [ "# Load current champion for comparison\n", "MODELS_DIR = os.path.join(os.getcwd(), \"models\")\n", "with open(os.path.join(MODELS_DIR, \"aimoscores_improved_A4.pkl\"), \"rb\") as f:\n", " champion_artifact = pickle.load(f)\n", "\n", "champion_model = champion_artifact[\"model\"]\n", "champion_features = champion_artifact[\"feature_columns\"]\n", "\n", "# Champion predictions on test set (keep as DataFrame for CorrelationFilter)\n", "X_test_champion = df_test[champion_features]\n", "y_pred_champion = champion_model.predict(X_test_champion)\n", "\n", "# Calculate squared errors\n", "errors_champion = (y_test - y_pred_champion) ** 2\n", "errors_avg = (y_test - y_pred_avg) ** 2\n", "errors_weighted = (y_test - y_pred_weighted) ** 2\n", "\n", "n_train = len(df_train_original)\n", "n_test = len(df_test)\n", "\n", "# T-test: Simple Average vs Champion\n", "t1, p1, diff1 = corrected_resampled_ttest(errors_champion, errors_avg, n_train, n_test)\n", "print(f\"Simple Average vs Champion:\")\n", "print(f\" Mean MSE difference: {diff1:.6f} (positive = champion worse)\")\n", "print(f\" t-statistic: {t1:.4f}\")\n", "print(f\" p-value: {p1:.4f}\")\n", "print(f\" Significant at α=0.05: {'Yes' if p1 < 0.05 else 'No'}\")\n", "\n", "print()\n", "\n", "# T-test: Weighted Average vs Champion\n", "t2, p2, diff2 = corrected_resampled_ttest(errors_champion, errors_weighted, n_train, n_test)\n", "print(f\"Weighted Average vs Champion:\")\n", "print(f\" Mean MSE difference: {diff2:.6f} (positive = champion worse)\")\n", "print(f\" t-statistic: {t2:.4f}\")\n", "print(f\" p-value: {p2:.4f}\")\n", "print(f\" Significant at α=0.05: {'Yes' if p2 < 0.05 else 'No'}\")" ] }, { "cell_type": "markdown", "id": "c7effacf", "metadata": {}, "source": [ "## 7. Summary & Visualization" ] }, { "cell_type": "code", "execution_count": 23, "id": "ae3afe8a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Model R² RMSE MAE\n", " gb 0.730710 0.126801 0.091136\n", "Ensemble (Weighted) 0.720410 0.129203 0.096843\n", " rf 0.719510 0.129411 0.094176\n", " Ensemble (Avg) 0.710973 0.131366 0.098796\n", " Champion (A4) 0.635600 0.130300 0.097200\n", " ridge 0.616390 0.151342 0.114280\n", " lasso 0.598576 0.154816 0.118236\n" ] } ], "source": [ "# Compare all models\n", "results = []\n", "for m in trained_models:\n", " results.append({\n", " \"Model\": m[\"name\"],\n", " \"R²\": m[\"test_metrics\"][\"r2\"],\n", " \"RMSE\": m[\"test_metrics\"][\"rmse\"],\n", " \"MAE\": m[\"test_metrics\"][\"mae\"]\n", " })\n", "\n", "results.append({\"Model\": \"Ensemble (Avg)\", \"R²\": metrics_avg[\"r2\"], \"RMSE\": metrics_avg[\"rmse\"], \"MAE\": metrics_avg[\"mae\"]})\n", "results.append({\"Model\": \"Ensemble (Weighted)\", \"R²\": metrics_weighted[\"r2\"], \"RMSE\": metrics_weighted[\"rmse\"], \"MAE\": metrics_weighted[\"mae\"]})\n", "results.append({\"Model\": \"Champion (A4)\", \"R²\": 0.6356, \"RMSE\": 0.1303, \"MAE\": 0.0972})\n", "\n", "results_df = pd.DataFrame(results)\n", "results_df = results_df.sort_values(\"R²\", ascending=False).reset_index(drop=True)\n", "print(results_df.to_string(index=False))" ] }, { "cell_type": "code", "execution_count": 24, "id": "92dcec0f", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Visualization: Actual vs Predicted\n", "fig, axes = plt.subplots(1, 3, figsize=(14, 4))\n", "\n", "# Champion\n", "axes[0].scatter(y_test, y_pred_champion, alpha=0.5, s=20)\n", "axes[0].plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)\n", "axes[0].set_xlabel(\"Actual AimoScore\")\n", "axes[0].set_ylabel(\"Predicted\")\n", "axes[0].set_title(f\"Champion (R²={r2_score(y_test, y_pred_champion):.4f})\")\n", "\n", "# Simple Average Ensemble\n", "axes[1].scatter(y_test, y_pred_avg, alpha=0.5, s=20, color='green')\n", "axes[1].plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)\n", "axes[1].set_xlabel(\"Actual AimoScore\")\n", "axes[1].set_ylabel(\"Predicted\")\n", "axes[1].set_title(f\"Ensemble Avg (R²={metrics_avg['r2']:.4f})\")\n", "\n", "# Weighted Average Ensemble\n", "axes[2].scatter(y_test, y_pred_weighted, alpha=0.5, s=20, color='orange')\n", "axes[2].plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)\n", "axes[2].set_xlabel(\"Actual AimoScore\")\n", "axes[2].set_ylabel(\"Predicted\")\n", "axes[2].set_title(f\"Ensemble Weighted (R²={metrics_weighted['r2']:.4f})\")\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 25, "id": "6afeaca5", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Bar chart comparison\n", "fig, ax = plt.subplots(figsize=(10, 5))\n", "\n", "models = results_df[\"Model\"].tolist()\n", "r2_values = results_df[\"R²\"].tolist()\n", "colors = ['steelblue'] * (len(models) - 3) + ['green', 'orange', 'red']\n", "\n", "bars = ax.barh(models, r2_values, color=colors)\n", "ax.axvline(x=0.6356, color='red', linestyle='--', label='Champion R²')\n", "ax.set_xlabel(\"R² Score\")\n", "ax.set_title(\"Model Comparison: R² on Test Set\")\n", "ax.legend()\n", "\n", "for bar, val in zip(bars, r2_values):\n", " ax.text(val + 0.005, bar.get_y() + bar.get_height()/2, f\"{val:.4f}\", va='center')\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "a9e7fae0", "metadata": {}, "source": [ "## 8. Save Best Model \n", "Pickle the ensemble artifact to A5/models/ if it outperforms the current champion." ] }, { "cell_type": "code", "execution_count": 26, "id": "0416e516", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best ensemble: weighted (R²=0.7204)\n", "Champion R²: 0.6356\n", "Improvement: 0.0848\n", "\n", "✓ Ensemble beats champion! Saving new model...\n", "Saved to: /Users/amol/Desktop/LNU/LNU_Masters/intensive/github/Data-intensive-systems/A5/models/aimoscores_ensemble_A5.pkl\n" ] } ], "source": [ "# Determine best ensemble\n", "best_ensemble_r2 = max(metrics_avg[\"r2\"], metrics_weighted[\"r2\"])\n", "best_ensemble_name = \"weighted\" if metrics_weighted[\"r2\"] > metrics_avg[\"r2\"] else \"average\"\n", "best_ensemble_pred = y_pred_weighted if best_ensemble_name == \"weighted\" else y_pred_avg\n", "best_metrics = metrics_weighted if best_ensemble_name == \"weighted\" else metrics_avg\n", "\n", "CHAMPION_R2 = 0.6356\n", "\n", "print(f\"Best ensemble: {best_ensemble_name} (R²={best_ensemble_r2:.4f})\")\n", "print(f\"Champion R²: {CHAMPION_R2:.4f}\")\n", "print(f\"Improvement: {best_ensemble_r2 - CHAMPION_R2:.4f}\")\n", "\n", "if best_ensemble_r2 > CHAMPION_R2:\n", " print(\"\\n✓ Ensemble beats champion! Saving new model...\")\n", " \n", " # Create ensemble artifact\n", " ensemble_artifact = {\n", " \"models\": trained_models,\n", " \"weights\": weights.tolist() if best_ensemble_name == \"weighted\" else None,\n", " \"aggregation\": best_ensemble_name,\n", " \"feature_columns\": all_cols,\n", " \"target\": TARGET,\n", " \"train_metrics\": {\n", " \"cv_r2_mean\": np.mean(cv_scores)\n", " },\n", " \"test_metrics\": best_metrics\n", " }\n", " \n", " output_path = os.path.join(MODELS_DIR, \"aimoscores_ensemble_A5.pkl\")\n", " with open(output_path, \"wb\") as f:\n", " pickle.dump(ensemble_artifact, f)\n", " \n", " print(f\"Saved to: {output_path}\")\n", "else:\n", " print(\"\\n✗ Ensemble does not beat champion. No model saved.\")" ] }, { "cell_type": "markdown", "id": "3eaf1fb3", "metadata": {}, "source": [ "## 9. Conclusion\n", "Summary of ensemble results and statistical significance findings." ] }, { "cell_type": "code", "execution_count": 27, "id": "06c7f134", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "============================================================\n", "A5 HETEROGENEOUS REGRESSION ENSEMBLE - SUMMARY\n", "============================================================\n", "\n", "Base models trained: 4\n", " - Lasso, Ridge, RandomForest, GradientBoosting\n", " - Each trained on different bootstrap sample\n", "\n", "Ensemble methods tested:\n", " - Simple averaging: R²=0.7110\n", " - Weighted averaging: R²=0.7204\n", "\n", "Current champion: R²=0.6356\n", "\n", "Statistical significance (α=0.05):\n", " - Simple Avg vs Champion: p=0.5016 (Not significant)\n", " - Weighted Avg vs Champion: p=0.5241 (Not significant)\n", "============================================================\n" ] } ], "source": [ "print(\"=\" * 60)\n", "print(\"A5 HETEROGENEOUS REGRESSION ENSEMBLE - SUMMARY\")\n", "print(\"=\" * 60)\n", "print(f\"\\nBase models trained: {len(trained_models)}\")\n", "print(f\" - Lasso, Ridge, RandomForest, GradientBoosting\")\n", "print(f\" - Each trained on different bootstrap sample\")\n", "print(f\"\\nEnsemble methods tested:\")\n", "print(f\" - Simple averaging: R²={metrics_avg['r2']:.4f}\")\n", "print(f\" - Weighted averaging: R²={metrics_weighted['r2']:.4f}\")\n", "print(f\"\\nCurrent champion: R²={CHAMPION_R2:.4f}\")\n", "print(f\"\\nStatistical significance (α=0.05):\")\n", "print(f\" - Simple Avg vs Champion: p={p1:.4f} ({'Significant' if p1 < 0.05 else 'Not significant'})\")\n", "print(f\" - Weighted Avg vs Champion: p={p2:.4f} ({'Significant' if p2 < 0.05 else 'Not significant'})\")\n", "print(\"=\" * 60)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.14.0" } }, "nbformat": 4, "nbformat_minor": 5 }