import unittest
import importlib
import numpy as np

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 solution
        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}")

        # Reference split required by the task
        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
        )

        cls.rf_model = getattr(cls.user_code, "rf_model", None)
        cls.y_pred = getattr(cls.user_code, "y_pred", None)

    def test_rf_model_exists(self):
        _dynamic_test(
            self,
            self.rf_model is not None,
            "The `rf_model` variable is defined.",
            "Expected a variable named `rf_model` to be defined."
        )

    def test_rf_model_type(self):
        _dynamic_test(
            self,
            isinstance(self.rf_model, RandomForestClassifier),
            "`rf_model` is a `RandomForestClassifier`.",
            "Expected `rf_model` to be an instance of `RandomForestClassifier`."
        )

    def test_rf_model_params_reasonable(self):
        # Not overly strict, but aligned with task requirements
        try:
            ok = (
                getattr(self.rf_model, "n_estimators", None) == 100
                and getattr(self.rf_model, "max_depth", None) == 4
                and getattr(self.rf_model, "random_state", None) == 42
            )
        except Exception:
            ok = False

        _dynamic_test(
            self,
            ok,
            "`rf_model` uses the required parameters (`n_estimators=100`, `max_depth=4`, `random_state=42`).",
            "Expected `rf_model` to use `n_estimators=100`, `max_depth=4`, and `random_state=42`."
        )

    def test_rf_model_is_fitted(self):
        fitted = hasattr(self.rf_model, "estimators_") and len(getattr(self.rf_model, "estimators_", [])) > 0
        _dynamic_test(
            self,
            fitted,
            "`rf_model` appears to be fitted.",
            "Expected `rf_model` to be fitted (missing `estimators_`)."
        )

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

    def test_y_pred_length_matches_test_set(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 (matches the test set).",
            "Expected `y_pred` to have the same length as the test set."
        )

    def test_y_pred_values_valid(self):
        try:
            preds = np.array(self.y_pred)
            ok = preds.ndim == 1 and np.isin(preds, [0, 1, 2]).all()
        except Exception:
            ok = False

        _dynamic_test(
            self,
            ok,
            "`y_pred` contains valid Iris class labels (0, 1, 2).",
            "Expected `y_pred` to contain only valid Iris class labels (0, 1, 2)."
        )

    def test_accuracy_not_anomalous(self):
        # Not strict: just ensures the model isn't broken
        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"Accuracy looks reasonable ({acc:.2f}).",
            f"Accuracy looks abnormal ({acc:.2f}). Expected at least 0.70."
        )


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


test_main.py

Pythonとscikit-learnを用いた教師あり学習のための木構造アンサンブル手法（ランダムフォレスト、AdaBoost、勾配ブースティング、スタッキング手法）を網羅的に解説します。実践的な例や現実世界のシナリオを通じて、モデル構築、チューニング、評価の実践的なスキル習得に重点を置いています。


チャレンジ：ランダムフォレスト

解答