import unittest
import importlib
import numpy as np
from sklearn.datasets import load_diabetes
from sklearn.metrics import r2_score

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 TestFeatureSelectionPipeline(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.user = importlib.import_module("user_code")
        cls.pipeline = getattr(cls.user, "pipeline", None)

        # Fit once on full data to keep test fast & deterministic
        X, y = load_diabetes(return_X_y=True)
        cls.X, cls.y = X, y
        cls.pipeline.fit(X, y)
        y_pred = cls.pipeline.predict(X)
        cls.r2 = r2_score(y, y_pred)

        # Feature selection info
        cls.selector = cls.pipeline.named_steps.get("selector")
        cls.n_total = cls.X.shape[1]
        cls.n_selected = int(getattr(cls.selector, "get_support")().sum())
        # For Lasso-based selector we can inspect sparsity of estimator_
        cls.estimator_coef_nz = None
        if hasattr(cls.selector, "estimator_") and hasattr(cls.selector.estimator_, "coef_"):
            coef = np.asarray(cls.selector.estimator_.coef_)
            cls.estimator_coef_nz = int(np.count_nonzero(coef))

    def test_pipeline_structure(self):
        steps = list(self.pipeline.named_steps.keys())
        condition = steps == ["scaler", "selector", "regressor"]
        _dynamic_test(
            self,
            condition,
            "Pipeline includes all required steps (scaler, selector, regressor).",
            "Pipeline missing required steps or wrong order."
        )

    def test_feature_selection_present_and_fitted(self):
        # Pass if: selector exists AND (either features reduced OR estimator produced any non-zero coef)
        reduced = self.n_selected < self.n_total
        has_estimator_signal = (self.estimator_coef_nz is not None) and (self.estimator_coef_nz > 0)
        condition = (self.selector is not None) and (reduced or has_estimator_signal)
        _dynamic_test(
            self,
            condition,
            f"Feature selection step is fitted (selected {self.n_selected}/{self.n_total}; non-zero coef={self.estimator_coef_nz}).",
            f"Feature selection seems ineffective or not fitted (selected {self.n_selected}/{self.n_total}; non-zero coef={self.estimator_coef_nz})."
        )

    def test_r2_score_reasonable(self):
        condition = self.r2 > 0.4
        _dynamic_test(
            self,
            condition,
            "Pipeline achieves reasonable R² score (>0.4).",
            f"Pipeline R² score too low ({self.r2:.3f})."
        )

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


test_main.py

A comprehensive intermediate course on regularization and feature selection in Python using scikit-learn, numpy, pandas, matplotlib, and seaborn. Learn to combat overfitting, apply L1/L2/Elastic Net regularization, select features using various strategies, and build robust pipelines for real-world data science tasks.

Explore the motivation for regularization, compare L1 and L2 penalties, and implement Ridge and Lasso regression.

Learn and apply filter, wrapper, and embedded feature selection methods, and integrate them into pipelines.

Delve into Elastic Net, hyperparameter tuning, coefficient visualization, and practical workflow challenges.

Challenge: Feature Selection Pipeline

解答