import unittest
import importlib
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.ensemble import RandomForestClassifier

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

        # Load test dataset
        data = load_iris()
        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
        )

        # Try to extract model and predictions from user code
        cls.rf_model = getattr(cls.user_code, "rf_model", None)
        cls.y_pred = getattr(cls.user_code, "y_pred", None)

        # If rf_model not defined, try to fit a fallback model for test stability
        if cls.rf_model is None:
            cls.rf_model = RandomForestClassifier(
                n_estimators=100, max_depth=4, random_state=42
            )
            cls.rf_model.fit(cls.X_train, cls.y_train)
            cls.y_pred = cls.rf_model.predict(cls.X_test)

        # If only model exists but no predictions, regenerate them
        elif cls.y_pred is None:
            cls.y_pred = cls.rf_model.predict(cls.X_test)

    def test_model_exists(self):
        """Ensure RandomForestClassifier is defined and fitted"""
        condition = isinstance(self.rf_model, RandomForestClassifier)
        _dynamic_test(
            self,
            condition,
            "RandomForestClassifier instance found and valid.",
            "RandomForestClassifier not defined as `rf_model`."
        )

    def test_predictions_exist(self):
        """Ensure predictions are generated and match test size"""
        condition = (
            self.y_pred is not None and len(self.y_pred) == len(self.y_test)
        )
        _dynamic_test(
            self,
            condition,
            "Predictions successfully generated and correct length.",
            "Predictions not generated or incorrect length."
        )

    def test_model_accuracy(self):
        """Check accuracy is reasonable (>0.9)"""
        acc = accuracy_score(self.y_test, self.y_pred)
        condition = acc > 0.9
        _dynamic_test(
            self,
            condition,
            f"Model accuracy is acceptable ({acc:.2f}).",
            f"Model accuracy too low ({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: Random Forest

Ratkaisu

Challenge: Random Forest

Ratkaisu