import unittest
import importlib
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier
from sklearn.metrics import accuracy_score

def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)

class TestBoostingChallenge(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        """Load user models or recreate them if missing."""
        try:
            user_code = importlib.import_module("code")
        except Exception as e:
            raise ImportError(f"Cannot import user code: {e}")

        cls.ada_model = getattr(user_code, "ada_model", None)
        cls.gb_model = getattr(user_code, "gb_model", None)

        # Load dataset
        data = load_breast_cancer()
        X, y = data.data, data.target
        cls.X_train, cls.X_test, cls.y_train, cls.y_test = train_test_split(
            X, y, test_size=0.3, random_state=42
        )

        # --- Recreate models if not found ---
        if cls.ada_model is None:
            cls.ada_model = AdaBoostClassifier(
                estimator=DecisionTreeClassifier(max_depth=1),
                n_estimators=50,
                learning_rate=0.8,
                random_state=42
            )
            cls.ada_model.fit(cls.X_train, cls.y_train)

        if cls.gb_model is None:
            cls.gb_model = GradientBoostingClassifier(
                n_estimators=100,
                learning_rate=0.1,
                max_depth=3,
                random_state=42
            )
            cls.gb_model.fit(cls.X_train, cls.y_train)

        # Generate predictions safely
        cls.ada_preds = cls.ada_model.predict(cls.X_test)
        cls.gb_preds = cls.gb_model.predict(cls.X_test)

    def test_models_exist(self):
        """Ensure both models are defined and trained."""
        condition = hasattr(self, "ada_model") and hasattr(self, "gb_model")
        _dynamic_test(
            self,
            condition,
            "Both AdaBoost and Gradient Boosting models are available.",
            "One or both models (`ada_model`, `gb_model`) are missing."
        )

    def test_predictions_exist(self):
        """Ensure predictions exist and match dataset length."""
        condition = (
            len(self.ada_preds) == len(self.y_test)
            and len(self.gb_preds) == len(self.y_test)
        )
        _dynamic_test(
            self,
            condition,
            "Predictions generated correctly for both models.",
            "Predictions missing or incorrect length for one or both models."
        )

    def test_model_performance(self):
        """Check both models achieve good accuracy."""
        ada_acc = accuracy_score(self.y_test, self.ada_preds)
        gb_acc = accuracy_score(self.y_test, self.gb_preds)
        condition = ada_acc >= 0.85 and gb_acc >= 0.85
        _dynamic_test(
            self,
            condition,
            f"Models perform well (AdaBoost: {ada_acc:.2f}, GB: {gb_acc:.2f}).",
            f"Model accuracy too low (AdaBoost: {ada_acc:.2f}, GB: {gb_acc:.2f})."
        )

if __name__ == "__main__":
    unittest.main(argv=["first-arg-is-ignored"], exit=False)


test_main.py

A comprehensive intermediate course on ensemble learning in machine learning, covering foundational concepts, mathematical intuition, and practical implementation of bagging, boosting, and advanced integration methods using Python and scikit-learn.

Explore the foundational concepts of ensemble learning, including why and how combining multiple models leads to improved performance and robustness.

Learn the principles and implementation of bagging methods, with a focus on Random Forests and Bootstrap Aggregation.

Dive into boosting methods, including AdaBoost and Gradient Boosting, with theory, intuition, and practical implementation.

Explore the concepts and implementation of voting and stacking ensembles, and build a custom stacking ensemble using scikit-learn.

Challenge: Boosting

Soluzione

Challenge: Boosting

Soluzione