import unittest
import importlib
import numpy as np

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 AdaBoostClassifier, GradientBoostingClassifier
from sklearn.tree import DecisionTreeClassifier


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 TestBoostingModelsChallenge(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        try:
            cls.user_code = importlib.import_module("user_code")
            importlib.reload(cls.user_code)
        except Exception as e:
            raise ImportError(f"Could not import `user_code.py`: {e}")

        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
        )

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

    def test_adaboost_model_exists(self):
        _dynamic_test(
            self,
            self.ada_model is not None,
            "The `ada_model` variable is defined.",
            "Expected a variable named `ada_model`."
        )

    def test_gradient_boosting_model_exists(self):
        _dynamic_test(
            self,
            self.gb_model is not None,
            "The `gb_model` variable is defined.",
            "Expected a variable named `gb_model`."
        )

    def test_adaboost_model_type(self):
        _dynamic_test(
            self,
            isinstance(self.ada_model, AdaBoostClassifier),
            "`ada_model` is an AdaBoostClassifier.",
            "Expected `ada_model` to be an AdaBoostClassifier."
        )

    def test_gradient_boosting_model_type(self):
        _dynamic_test(
            self,
            isinstance(self.gb_model, GradientBoostingClassifier),
            "`gb_model` is a GradientBoostingClassifier.",
            "Expected `gb_model` to be a GradientBoostingClassifier."
        )

    def test_adaboost_base_estimator(self):
        try:
            base = self.ada_model.estimator
            ok = isinstance(base, DecisionTreeClassifier) and base.max_depth == 1
        except Exception:
            ok = False

        _dynamic_test(
            self,
            ok,
            "AdaBoost uses DecisionTreeClassifier with max_depth=1.",
            "Expected AdaBoost to use DecisionTreeClassifier(max_depth=1)."
        )

    def test_models_are_fitted(self):
        ada_fitted = hasattr(self.ada_model, "estimators_")
        gb_fitted = hasattr(self.gb_model, "estimators_")

        _dynamic_test(
            self,
            ada_fitted and gb_fitted,
            "Both boosting models are fitted.",
            "Expected both models to be fitted."
        )

    def test_predictions_exist(self):
        ok = self.ada_pred is not None and self.gb_pred is not None
        _dynamic_test(
            self,
            ok,
            "Predictions for both models are defined.",
            "Expected `ada_pred` and `gb_pred` to be defined."
        )

    def test_predictions_length(self):
        try:
            ok = (
                len(self.ada_pred) == len(self.y_test)
                and len(self.gb_pred) == len(self.y_test)
            )
        except Exception:
            ok = False

        _dynamic_test(
            self,
            ok,
            "Predictions have correct length.",
            "Prediction length does not match test set."
        )

    def test_predictions_values_valid(self):
        try:
            ada_ok = np.isin(self.ada_pred, [0, 1]).all()
            gb_ok = np.isin(self.gb_pred, [0, 1]).all()
            ok = ada_ok and gb_ok
        except Exception:
            ok = False

        _dynamic_test(
            self,
            ok,
            "Predictions contain valid class labels (0 or 1).",
            "Predictions contain invalid class labels."
        )

    def test_accuracy_reasonable(self):
        try:
            ada_acc = accuracy_score(self.y_test, self.ada_pred)
            gb_acc = accuracy_score(self.y_test, self.gb_pred)
            ok = (0.7 <= ada_acc <= 1.0) and (0.7 <= gb_acc <= 1.0)
        except Exception:
            ok = False

        _dynamic_test(
            self,
            ok,
            f"Both models achieve reasonable accuracy (AdaBoost={ada_acc:.2f}, GradientBoosting={gb_acc:.2f}).",
            "One or both models have abnormal accuracy."
        )


if __name__ == "__main__":
    unittest.main()


test_main.py

Covers tree-based ensemble methods for supervised learning, including Random Forest, AdaBoost, Gradient Boosting, and stacking techniques, using Python and scikit-learn. Emphasizes hands-on model building, tuning, and evaluation through practical examples and real-world scenarios.


Challenge: Boosting

Solution