import unittest
import importlib
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import StackingClassifier

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 TestStackingChallenge(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        """Import user code and test model"""
        try:
            user_code = importlib.import_module("code")
        except Exception as e:
            raise ImportError(f"Cannot import user code: {e}")

        cls.stack_model = getattr(user_code, "stack_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
        )

        # Fallback: retrain if not provided
        if cls.stack_model is None:
            from sklearn.tree import DecisionTreeClassifier
            from sklearn.svm import SVC
            from sklearn.linear_model import LogisticRegression
            from sklearn.ensemble import StackingClassifier
            base_estimators = [
                ('tree', DecisionTreeClassifier(max_depth=3, random_state=42)),
                ('svc', SVC(probability=True, random_state=42))
            ]
            final_estimator = LogisticRegression(random_state=42)
            cls.stack_model = StackingClassifier(
                estimators=base_estimators,
                final_estimator=final_estimator
            )
            cls.stack_model.fit(cls.X_train, cls.y_train)

        cls.y_pred = cls.stack_model.predict(cls.X_test)

    def test_model_exists(self):
        """Check if stacking model exists"""
        condition = isinstance(self.stack_model, StackingClassifier)
        _dynamic_test(
            self,
            condition,
            "Stacking model correctly defined.",
            "Stacking model (`stack_model`) not defined or wrong type."
        )

    def test_predictions_exist(self):
        """Check predictions length"""
        condition = len(self.y_pred) == len(self.y_test)
        _dynamic_test(
            self,
            condition,
            "Predictions generated successfully.",
            "Predictions not generated or incorrect length."
        )

    def test_accuracy(self):
        """Check reasonable accuracy"""
        acc = accuracy_score(self.y_test, self.y_pred)
        condition = acc > 0.85
        _dynamic_test(
            self,
            condition,
            f"Model accuracy acceptable ({acc:.2f}).",
            f"Model accuracy too low ({acc:.2f})."
        )

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

test_code.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: Stacking Model

Oplossing

Challenge: Stacking Model

Oplossing