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 StackingClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression


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

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

    def test_model_type(self):
        _dynamic_test(
            self,
            isinstance(self.stack_model, StackingClassifier),
            "`stack_model` is a StackingClassifier.",
            "Expected `stack_model` to be a StackingClassifier."
        )

    def test_base_estimators_present(self):
        try:
            estimators = getattr(self.stack_model, "estimators", None)
            names = [name for name, _ in estimators] if estimators else []
            types = [type(est) for _, est in estimators] if estimators else []

            has_tree = any(t is DecisionTreeClassifier for t in types)
            has_svc = any(t is SVC for t in types)

            ok = has_tree and has_svc and len(names) >= 2
        except Exception:
            ok = False

        _dynamic_test(
            self,
            ok,
            "Base estimators include DecisionTreeClassifier and SVC.",
            "Expected base estimators to include DecisionTreeClassifier and SVC."
        )

    def test_final_estimator_type(self):
        try:
            final_est = getattr(self.stack_model, "final_estimator", None)
            ok = isinstance(final_est, LogisticRegression)
        except Exception:
            ok = False

        _dynamic_test(
            self,
            ok,
            "Final estimator is LogisticRegression.",
            "Expected final estimator to be LogisticRegression."
        )

    def test_model_fitted(self):
        fitted = hasattr(self.stack_model, "estimators_")
        _dynamic_test(
            self,
            fitted,
            "`stack_model` appears to be fitted.",
            "Expected `stack_model` to be fitted."
        )

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

    def test_predictions_length(self):
        try:
            ok = len(self.y_pred) == len(self.y_test)
        except Exception:
            ok = False

        _dynamic_test(
            self,
            ok,
            "`y_pred` has the correct length.",
            "Expected `y_pred` to have the same length as the test set."
        )

    def test_predictions_values(self):
        try:
            ok = np.isin(self.y_pred, [0, 1]).all()
        except Exception:
            ok = False

        _dynamic_test(
            self,
            ok,
            "`y_pred` contains valid class labels (0 or 1).",
            "`y_pred` contains invalid class labels."
        )

    def test_accuracy_reasonable(self):
        try:
            acc = accuracy_score(self.y_test, self.y_pred)
            ok = 0.7 <= acc <= 1.0
        except Exception:
            acc = 0.0
            ok = False

        _dynamic_test(
            self,
            ok,
            f"Stacking accuracy is within a reasonable range ({acc:.2f}).",
            f"Stacking accuracy is abnormal ({acc:.2f}). Expected at least 0.70."
        )


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


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

Ratkaisu

Challenge: Stacking Model

Ratkaisu