serverlex 1.0.0__py3-none-any.whl

Evaluation.py

@@ -0,0 +1,191 @@
+import logging
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+
+from sklearn.metrics import (
+    confusion_matrix,
+    classification_report,
+    roc_curve,
+    auc,
+    precision_recall_curve,
+    r2_score,
+    mean_squared_error,
+    mean_absolute_error,
+    mean_absolute_percentage_error
+)
+
+logger=logging.getLogger("Evaluator")
+if not logger.handlers:
+    _h=logging.StreamHandler()
+    _h.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s", "%Y-%m-%d %H:%M:%S"))
+    logger.addHandler(_h)
+    logger.setLevel(logging.INFO)
+
+
+class ModelEvaluator:
+    def __init__(self):
+        self.metrics={}
+        self.y_true=None
+        self.y_pred=None
+        self.y_prob=None
+        self.task=None
+
+    # ==============================================================
+    # 1. Classification Diagnostics
+    # ==============================================================
+    def plot_confusion_matrix(self, y_true, y_pred, labels=None, title="Confusion Matrix"):
+        try:
+            cm=confusion_matrix(y_true, y_pred, labels=labels)
+            fig, ax=plt.subplots(figsize=(6, 5))
+            cax=ax.imshow(cm, cmap="Blues")
+            fig.colorbar(cax, ax=ax)
+
+            tick_marks=range(len(cm))
+            display_labels=labels if labels is not None else [f"Class {i}" for i in tick_marks]
+            ax.set_xticks(tick_marks)
+            ax.set_yticks(tick_marks)
+            ax.set_xticklabels(display_labels, rotation=45, ha="right")
+            ax.set_yticklabels(display_labels)
+
+            thresh=cm.max() / 2.0
+            for i in range(len(cm)):
+                for j in range(len(cm)):
+                    ax.text(j, i, f"{cm[i, j]}", ha="center", va="center",
+                            color="white" if cm[i, j] > thresh else "black", fontsize=11, fontweight="bold")
+
+            ax.set_title(title, fontsize=12, fontweight="bold")
+            ax.set_ylabel("Actual Label")
+            ax.set_xlabel("Predicted Label")
+            plt.tight_layout()
+            plt.show()
+            return cm
+        except Exception as e:
+            logger.error("Error in plot_confusion_matrix: %s", e)
+
+    def plot_roc_curve(self, y_true, y_prob, title="ROC Curve"):
+        try:
+            fpr, tpr, _ = roc_curve(y_true, y_prob)
+            roc_auc=auc(fpr, tpr)
+
+            fig, ax=plt.subplots(figsize=(6, 5))
+            ax.plot(fpr, tpr, color="darkorange", lw=2, label=f"ROC (AUC = {roc_auc:.4f})")
+            ax.plot([0, 1], [0, 1], color="navy", lw=1.5, linestyle="--")
+            ax.set_xlim([0.0, 1.0])
+            ax.set_ylim([0.0, 1.05])
+            ax.set_xlabel("False Positive Rate")
+            ax.set_ylabel("True Positive Rate")
+            ax.set_title(title, fontsize=12, fontweight="bold")
+            ax.legend(loc="lower right")
+            ax.grid(True, linestyle="--", alpha=0.5)
+            plt.tight_layout()
+            plt.show()
+            logger.info("ROC-AUC score: %.4f", roc_auc)
+            return roc_auc
+        except Exception as e:
+            logger.error("Error in plot_roc_curve: %s", e)
+
+    def plot_precision_recall(self, y_true, y_prob, title="Precision-Recall Curve"):
+        try:
+            precision, recall, _ = precision_recall_curve(y_true, y_prob)
+            fig, ax=plt.subplots(figsize=(6, 5))
+            ax.plot(recall, precision, color="purple", lw=2)
+            ax.set_xlabel("Recall")
+            ax.set_ylabel("Precision")
+            ax.set_title(title, fontsize=12, fontweight="bold")
+            ax.grid(True, linestyle="--", alpha=0.5)
+            plt.tight_layout()
+            plt.show()
+        except Exception as e:
+            logger.error("Error in plot_precision_recall: %s", e)
+
+    # ==============================================================
+    # 2. Regression Diagnostics
+    # ==============================================================
+    def plot_actual_vs_predicted(self, y_true, y_pred, title="Actual vs. Predicted"):
+        try:
+            fig, ax=plt.subplots(figsize=(6, 5))
+            ax.scatter(y_true, y_pred, alpha=0.6, edgecolors="k", color="royalblue")
+
+            min_val=min(min(y_true), min(y_pred))
+            max_val=max(max(y_true), max(y_pred))
+            ax.plot([min_val, max_val], [min_val, max_val], color="crimson", lw=2, linestyle="--", label="Ideal Fit (y=x)")
+
+            ax.set_xlabel("Actual Values")
+            ax.set_ylabel("Predicted Values")
+            ax.set_title(title, fontsize=12, fontweight="bold")
+            ax.legend()
+            ax.grid(True, linestyle="--", alpha=0.5)
+            plt.tight_layout()
+            plt.show()
+        except Exception as e:
+            logger.error("Error in plot_actual_vs_predicted: %s", e)
+
+    def plot_residuals(self, y_true, y_pred, title="Residual Analysis"):
+        try:
+            residuals = np.array(y_true) - np.array(y_pred)
+            fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4.5))
+
+            ax1.scatter(y_pred, residuals, alpha=0.6, edgecolors="k", color="darkcyan")
+            ax1.axhline(0, color="crimson", linestyle="--", lw=1.5)
+            ax1.set_xlabel("Predicted Values")
+            ax1.set_ylabel("Residuals")
+            ax1.set_title("Residuals vs. Predicted", fontsize=11, fontweight="bold")
+            ax1.grid(True, linestyle="--", alpha=0.5)
+
+            ax2.hist(residuals, bins=20, color="teal", edgecolor="black", alpha=0.7)
+            ax2.axvline(0, color="crimson", linestyle="--", lw=1.5)
+            ax2.set_xlabel("Residual Value")
+            ax2.set_ylabel("Count")
+            ax2.set_title("Distribution of Errors", fontsize=11, fontweight="bold")
+
+            plt.suptitle(title, fontsize=13, fontweight="bold")
+            plt.tight_layout()
+            plt.show()
+        except Exception as e:
+            logger.error("Error in plot_residuals: %s", e)
+
+    # ==============================================================
+    # 3. Deep End-to-End Diagnostics Runner
+    # ==============================================================
+    def evaluate(self, model, X, y):
+        try:
+            self.y_true = np.array(y)
+            self.y_pred = model.predict(X)
+
+            is_class = (
+                self.y_true.dtype == "object"
+                or str(self.y_true.dtype).startswith("cat")
+                or len(np.unique(self.y_true)) <= 20
+            )
+            self.task = "Classification" if is_class else "Regression"
+
+            logger.info("Evaluating model predictions (task=%s, samples=%d)", self.task, len(self.y_true))
+
+            if is_class:
+                logger.info("Classification report:\n%s", classification_report(self.y_true, self.y_pred))
+                self.plot_confusion_matrix(self.y_true, self.y_pred)
+
+                if len(np.unique(self.y_true)) == 2 and hasattr(model, "predict_proba"):
+                    self.y_prob = model.predict_proba(X)[:, 1]
+                    self.plot_roc_curve(self.y_true, self.y_prob)
+                    self.plot_precision_recall(self.y_true, self.y_prob)
+
+            else:
+                r2 = r2_score(self.y_true, self.y_pred)
+                rmse = np.sqrt(mean_squared_error(self.y_true, self.y_pred))
+                mae = mean_absolute_error(self.y_true, self.y_pred)
+                mape = mean_absolute_percentage_error(self.y_true, self.y_pred)
+
+                n = len(self.y_true)
+                p = X.shape[1]
+                adj_r2 = 1 - (1 - r2) * (n - 1) / (n - p - 1) if (n - p - 1) > 0 else r2
+
+                logger.info("Regression metrics: R2=%.4f, Adj_R2=%.4f, RMSE=%.4f, MAE=%.4f, MAPE=%.2f%%",
+                            r2, adj_r2, rmse, mae, mape * 100)
+
+                self.plot_actual_vs_predicted(self.y_true, self.y_pred)
+                self.plot_residuals(self.y_true, self.y_pred)
+
+        except Exception as e:
+            logger.error("Error in evaluate: %s", e)

Explainability.py

@@ -0,0 +1,89 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.inspection import permutation_importance
+
+
+class ModelExplainer:
+    """
+    Model Explainability & Feature Importance:
+    - Native feature importances (Tree-based & Linear models).
+    - Model-agnostic Permutation Importance.
+    - Publication-ready bar plots of top driving features.
+    """
+
+    def __init__(self, model, feature_names=None):
+        self.model = model
+        self.feature_names = list(feature_names) if feature_names is not None else None
+
+    def get_feature_importances(self):
+        """
+        Extracts native feature importances or linear coefficients.
+        Returns a sorted pandas DataFrame.
+        """
+        # 1. Tree-based models (RandomForest, DecisionTree, GradientBoosting)
+        if hasattr(self.model, "feature_importances_"):
+            importances = self.model.feature_importances_
+            names = self.feature_names or [f"Feature_{i}" for i in range(len(importances))]
+            df = pd.DataFrame({"Feature": names, "Importance": importances})
+            return df.sort_values(by="Importance", ascending=False).reset_index(drop=True)
+
+        # 2. Linear models (LogisticRegression, Ridge, LinearRegression)
+        elif hasattr(self.model, "coef_"):
+            coef = self.model.coef_
+            if coef.ndim > 1:
+                coef = np.mean(np.abs(coef), axis=0)  # Multi-class or 2D coefs
+            else:
+                coef = np.abs(coef)
+            names = self.feature_names or [f"Feature_{i}" for i in range(len(coef))]
+            df = pd.DataFrame({"Feature": names, "Importance": coef})
+            return df.sort_values(by="Importance", ascending=False).reset_index(drop=True)
+
+        else:
+            raise AttributeError("Model does not have native feature_importances_ or coef_. Use permutation_importance() instead.")
+
+    def compute_permutation_importance(self, X, y, scoring=None, n_repeats=10, random_state=42):
+        """
+        Calculates Model-Agnostic Permutation Importance:
+        Measures the drop in model score when a feature's values are randomly shuffled.
+        """
+        print("Computing Permutation Importance across features...")
+        res = permutation_importance(
+            self.model,
+            X,
+            y,
+            scoring=scoring,
+            n_repeats=n_repeats,
+            random_state=random_state,
+            n_jobs=-1
+        )
+
+        names = self.feature_names or (X.columns.tolist() if hasattr(X, "columns") else [f"Feature_{i}" for i in range(X.shape[1])])
+        df = pd.DataFrame({
+            "Feature": names,
+            "Importance_Mean": res.importances_mean,
+            "Importance_Std": res.importances_std
+        }).sort_values(by="Importance_Mean", ascending=False).reset_index(drop=True)
+
+        return df
+
+    def plot_feature_importance(self, top_n=10, title="Top Feature Importances", save_path=None):
+        """Plots a horizontal bar chart of the top N most important features."""
+        try:
+            df = self.get_feature_importances().head(top_n)
+        except AttributeError:
+            print("Cannot extract native feature importance. Run compute_permutation_importance() first.")
+            return
+
+        fig, ax = plt.subplots(figsize=(8, max(4, top_n * 0.4)))
+        ax.barh(df["Feature"], df["Importance"], color="teal", edgecolor="black")
+        ax.invert_yaxis()
+        ax.set_title(title, fontsize=12, fontweight="bold")
+        ax.set_xlabel("Importance Score")
+        plt.tight_layout()
+
+        if save_path:
+            plt.savefig(save_path, dpi=150)
+            print(f"Feature importance plot saved to '{save_path}'")
+
+        plt.show()

FeatureSelector.py

@@ -0,0 +1,90 @@
+import logging
+import pandas as pd
+import numpy as np
+
+from sklearn.feature_selection import (
+    mutual_info_classif,
+    mutual_info_regression,
+    VarianceThreshold,
+    SelectKBest
+)
+
+logger=logging.getLogger("FeatureSelector")
+if not logger.handlers:
+    _h=logging.StreamHandler()
+    _h.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s", "%Y-%m-%d %H:%M:%S"))
+    logger.addHandler(_h)
+    logger.setLevel(logging.INFO)
+
+
+class FeatureSelector:
+    def __init__(self, k=10, variance_threshold=0.01, corr_threshold=0.90):
+        self.k=k
+        self.variance_threshold=variance_threshold
+        self.corr_threshold=corr_threshold
+        self.selected_features=[]
+        self.feature_scores={}
+        self.is_fitted=False
+
+    def fit(self, X, y):
+        try:
+            if not isinstance(X, pd.DataFrame):
+                X=pd.DataFrame(X)
+            if not isinstance(y, pd.Series):
+                y=pd.Series(y)
+
+            num_cols=X.select_dtypes(include='number').columns.tolist()
+            cur_X=X[num_cols].copy()
+
+            # 1. Prune near-zero variance features
+            var_selector=VarianceThreshold(threshold=self.variance_threshold)
+            var_selector.fit(cur_X)
+            non_zero_cols=cur_X.columns[var_selector.get_support()].tolist()
+            cur_X=cur_X[non_zero_cols]
+
+            # 2. Prune collinear features (redundant duplicates)
+            corr_matrix=cur_X.corr().abs()
+            upper_tri=corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
+            cols_to_drop=[col for col in upper_tri.columns if any(upper_tri[col] > self.corr_threshold)]
+            cur_X=cur_X.drop(columns=cols_to_drop)
+
+            # 3. Mutual Information Feature Importance
+            is_class=y.dtype == 'object' or str(y.dtype).startswith('cat') or y.nunique() <= 20
+            mi_func=mutual_info_classif if is_class else mutual_info_regression
+
+            mi_scores=mi_func(cur_X, y, random_state=42)
+            score_series=pd.Series(mi_scores, index=cur_X.columns).sort_values(ascending=False)
+            self.feature_scores=score_series.to_dict()
+
+            # Pick top K features
+            k_val=min(self.k, len(score_series))
+            self.selected_features=score_series.head(k_val).index.tolist()
+            self.is_fitted=True
+
+            logger.info("Feature selection complete: %d features selected from %d initial features", len(self.selected_features), X.shape[1])
+            return self
+        except Exception as e:
+            logger.error("Error in FeatureSelector.fit: %s", e)
+            return self
+
+    def transform(self, X):
+        try:
+            if not self.is_fitted:
+                raise ValueError("FeatureSelector is not fitted yet. Call fit() first.")
+
+            if not isinstance(X, pd.DataFrame):
+                X=pd.DataFrame(X)
+
+            # Align to selected features (fill missing with 0)
+            return X.reindex(columns=self.selected_features, fill_value=0)
+        except Exception as e:
+            logger.error("Error in FeatureSelector.transform: %s", e)
+            return X
+
+    def fit_transform(self, X, y):
+        self.fit(X, y)
+        return self.transform(X)
+
+    def get_ranked_scores(self):
+        """Returns DataFrame of features ranked by Mutual Information."""
+        return pd.DataFrame(list(self.feature_scores.items()), columns=["Feature", "Mutual_Information_Score"])

ModelDeployer.py

@@ -0,0 +1,89 @@
+import logging
+import joblib
+import pandas as pd
+import numpy as np
+from datetime import datetime
+
+logger=logging.getLogger("ModelDeployer")
+if not logger.handlers:
+    _h=logging.StreamHandler()
+    _h.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s", "%Y-%m-%d %H:%M:%S"))
+    logger.addHandler(_h)
+    logger.setLevel(logging.INFO)
+
+
+class ModelDeployer:
+    """
+    Production Model Serving Engine:
+    - Bundles fitted MLPipeline + trained Model into a single deployable artifact.
+    - Saves and loads via joblib.
+    - Supports predict() directly on raw, uncleaned data (DataFrames or JSON/dicts).
+    """
+
+    def __init__(self, pipeline=None, model=None, metadata=None):
+        self.pipeline = pipeline
+        self.model = model
+        self.metadata = metadata or {}
+        if "created_at" not in self.metadata:
+            self.metadata["created_at"] = str(datetime.now())
+
+    def save(self, filepath="model_bundle.joblib"):
+        if self.pipeline is None or self.model is None:
+            raise ValueError("Both pipeline and model must be provided before saving.")
+
+        bundle = {
+            "pipeline": self.pipeline,
+            "model": self.model,
+            "metadata": self.metadata
+        }
+        joblib.dump(bundle, filepath)
+        logger.info("Saved model artifact bundle to '%s'", filepath)
+
+    @classmethod
+    def load(cls, filepath="model_bundle.joblib"):
+        bundle = joblib.load(filepath)
+        deployer = cls(
+            pipeline=bundle["pipeline"],
+            model=bundle["model"],
+            metadata=bundle.get("metadata", {})
+        )
+        logger.info("Loaded model artifact bundle from '%s'", filepath)
+        return deployer
+
+    def _prepare_input(self, raw_input):
+        if isinstance(raw_input, dict):
+            df = pd.DataFrame([raw_input])
+        elif isinstance(raw_input, list):
+            df = pd.DataFrame(raw_input)
+        elif isinstance(raw_input, pd.DataFrame):
+            df = raw_input.copy()
+        else:
+            raise TypeError("Input must be a pandas DataFrame, a dict (single sample), or a list of dicts.")
+        return df
+
+    def predict(self, raw_input):
+        df = self._prepare_input(raw_input)
+        transformed_res = self.pipeline.transform(df)
+
+        if isinstance(transformed_res, tuple):
+            X = transformed_res[0]
+        else:
+            X = transformed_res
+
+        predictions = self.model.predict(X)
+        return predictions
+
+    def predict_proba(self, raw_input):
+        if not hasattr(self.model, "predict_proba"):
+            raise AttributeError(f"Model '{type(self.model).__name__}' does not support predict_proba().")
+
+        df = self._prepare_input(raw_input)
+        transformed_res = self.pipeline.transform(df)
+
+        if isinstance(transformed_res, tuple):
+            X = transformed_res[0]
+        else:
+            X = transformed_res
+
+        probabilities = self.model.predict_proba(X)
+        return probabilities

ModelHyperparameter.py

@@ -0,0 +1,162 @@
+import logging
+import pandas as pd
+import numpy as np
+
+from sklearn.model_selection import GridSearchCV, cross_val_score, KFold, StratifiedKFold
+from sklearn.linear_model import LogisticRegression, Ridge
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor, GradientBoostingClassifier, GradientBoostingRegressor
+
+logger=logging.getLogger("HyperparameterTuner")
+if not logger.handlers:
+    _h=logging.StreamHandler()
+    _h.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s", "%Y-%m-%d %H:%M:%S"))
+    logger.addHandler(_h)
+    logger.setLevel(logging.INFO)
+
+
+class ModelHyperparameter:
+    @staticmethod
+    def get_default_param_grid(model_name: str, task: str = "classification"):
+        name = model_name.lower().replace(" ", "_")
+
+        if "forest" in name or name == "rf":
+            return {
+                "n_estimators": [50, 100, 200],
+                "max_depth": [None, 5, 10],
+                "min_samples_split": [2, 5]
+            }
+        elif "tree" in name or name == "dt":
+            return {
+                "max_depth": [3, 5, 10, None],
+                "min_samples_split": [2, 5, 10]
+            }
+        elif "gradient" in name or "boost" in name or name == "gb":
+            return {
+                "n_estimators": [50, 100],
+                "learning_rate": [0.01, 0.1, 0.2],
+                "max_depth": [3, 5]
+            }
+        elif "logistic" in name:
+            return {
+                "C": [0.01, 0.1, 1.0, 10.0],
+                "penalty": ["l2"]
+            }
+        elif "ridge" in name or "linear" in name:
+            return {
+                "alpha": [0.01, 0.1, 1.0, 10.0, 100.0]
+            }
+        else:
+            raise ValueError(f"No default grid for '{model_name}'. Please provide a custom param_grid.")
+
+    # ==============================================================
+    # 1. Non-Nested Cross-Validation (Standard GridSearchCV)
+    # ==============================================================
+    def tune_non_nested(self, estimator, param_grid, X, y, cv=5, scoring=None):
+        logger.info("Running GridSearchCV (estimator=%s, cv=%d, param_combinations=%s)",
+                    type(estimator).__name__, cv, list(param_grid.keys()))
+        grid = GridSearchCV(
+            estimator=estimator,
+            param_grid=param_grid,
+            cv=cv,
+            scoring=scoring,
+            n_jobs=-1
+        )
+        grid.fit(X, y)
+
+        logger.info("GridSearchCV complete. Best score: %.4f | Optimal params: %s",
+                    grid.best_score_, grid.best_params_)
+
+        return {
+            "best_estimator": grid.best_estimator_,
+            "best_params": grid.best_params_,
+            "best_score": grid.best_score_,
+            "cv_results": pd.DataFrame(grid.cv_results_)
+        }
+
+    # ==============================================================
+    # 2. Nested Cross-Validation (Unbiased Generalization Estimate)
+    # ==============================================================
+    def tune_nested_cv(self, estimator, param_grid, X, y, outer_cv=5, inner_cv=3, scoring=None):
+        logger.info("Running Nested CV (estimator=%s, outer_cv=%d, inner_cv=%d)",
+                    type(estimator).__name__, outer_cv, inner_cv)
+
+        is_classification = (
+            y.dtype == "object"
+            or str(y.dtype).startswith("cat")
+            or (isinstance(y, pd.Series) and y.nunique() <= 20)
+            or len(np.unique(y)) <= 20
+        )
+
+        if is_classification:
+            outer_splitter = StratifiedKFold(n_splits=outer_cv, shuffle=True, random_state=42)
+            inner_splitter = StratifiedKFold(n_splits=inner_cv, shuffle=True, random_state=42)
+            default_scoring = "accuracy"
+        else:
+            outer_splitter = KFold(n_splits=outer_cv, shuffle=True, random_state=42)
+            inner_splitter = KFold(n_splits=inner_cv, shuffle=True, random_state=42)
+            default_scoring = "r2"
+
+        active_scoring = scoring or default_scoring
+
+        inner_grid = GridSearchCV(
+            estimator=estimator,
+            param_grid=param_grid,
+            cv=inner_splitter,
+            scoring=active_scoring,
+            n_jobs=-1
+        )
+
+        nested_scores = cross_val_score(
+            inner_grid,
+            X,
+            y,
+            cv=outer_splitter,
+            scoring=active_scoring,
+            n_jobs=-1
+        )
+
+        logger.info("Nested CV outer fold scores: %s", np.round(nested_scores, 4).tolist())
+        logger.info("Nested CV generalization score: %.4f (+/- %.4f)", nested_scores.mean(), nested_scores.std())
+
+        final_grid = GridSearchCV(estimator=estimator, param_grid=param_grid, cv=inner_splitter, scoring=active_scoring, n_jobs=-1)
+        final_grid.fit(X, y)
+
+        return {
+            "nested_scores": nested_scores,
+            "nested_mean": nested_scores.mean(),
+            "nested_std": nested_scores.std(),
+            "best_estimator": final_grid.best_estimator_,
+            "best_params": final_grid.best_params_,
+            "metric": active_scoring
+        }
+
+    # ==============================================================
+    # 3. Side-by-Side Comparison: Nested vs Non-Nested
+    # ==============================================================
+    def compare_nested_vs_non_nested(self, estimator, param_grid, X, y, outer_cv=5, inner_cv=3, scoring=None):
+        logger.info("Executing comparison between Non-Nested and Nested CV")
+
+        non_nested_res = self.tune_non_nested(estimator, param_grid, X, y, cv=outer_cv, scoring=scoring)
+        nested_res = self.tune_nested_cv(estimator, param_grid, X, y, outer_cv=outer_cv, inner_cv=inner_cv, scoring=scoring)
+
+        comparison_df = pd.DataFrame([
+            {
+                "Method": "Non-Nested CV (GridSearchCV)",
+                "Score": f"{non_nested_res['best_score']:.4f}",
+                "Type": "Optimized deployment score"
+            },
+            {
+                "Method": "Nested CV (Outer + Inner)",
+                "Score": f"{nested_res['nested_mean']:.4f} (+/- {nested_res['nested_std']:.4f})",
+                "Type": "Unbiased generalization estimate"
+            }
+        ])
+
+        logger.info("Comparison summary:\n%s", comparison_df.to_string(index=False))
+
+        return {
+            "comparison": comparison_df,
+            "non_nested": non_nested_res,
+            "nested": nested_res
+        }