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

        X, y = load_diabetes(return_X_y=True)
        cls.ridge_pipe.fit(X, y)
        cls.lasso_pipe.fit(X, y)

        cls.ridge_pred = cls.ridge_pipe.predict(X)
        cls.lasso_pred = cls.lasso_pipe.predict(X)

        cls.ridge_r2 = r2_score(y, cls.ridge_pred)
        cls.lasso_r2 = r2_score(y, cls.lasso_pred)

        cls.ridge_coef = np.asarray(cls.ridge_pipe.named_steps["regressor"].coef_)
        cls.lasso_coef = np.asarray(cls.lasso_pipe.named_steps["regressor"].coef_)

    def test_pipelines_exist(self):
        condition = self.ridge_pipe is not None and self.lasso_pipe is not None
        _dynamic_test(
            self,
            condition,
            "Both Ridge and Lasso pipelines are defined.",
            "One or both model pipelines are missing."
        )

    def test_r2_scores_valid(self):
        condition = self.ridge_r2 > 0.4 and self.lasso_r2 > 0.4
        _dynamic_test(
            self,
            condition,
            "Both Ridge and Lasso achieve acceptable R² scores (>0.4).",
            f"One or both models have too low R² (Ridge={self.ridge_r2:.3f}, Lasso={self.lasso_r2:.3f})."
        )

    def test_lasso_regularization_effective(self):
        ridge_mean_abs = np.mean(np.abs(self.ridge_coef))
        lasso_mean_abs = np.mean(np.abs(self.lasso_coef))
        ridge_nonzero = np.count_nonzero(self.ridge_coef)
        lasso_nonzero = np.count_nonzero(self.lasso_coef)

        # Allow small tolerance since regularization strengths are mild
        tolerance = 0.15  # 15%

        # Check that Lasso does not have *significantly* higher magnitude or complexity
        condition = (
            (lasso_mean_abs <= ridge_mean_abs * (1 + tolerance))
            or (lasso_nonzero <= ridge_nonzero)
        )
        _dynamic_test(
            self,
            condition,
            f"Lasso regularization effective or comparable (mean|coef| Ridge={ridge_mean_abs:.3f}, Lasso={lasso_mean_abs:.3f}; zeros Ridge={len(self.ridge_coef)-ridge_nonzero}, Lasso={len(self.lasso_coef)-lasso_nonzero}).",
            f"Lasso regularization ineffective: coefficients not reduced enough (mean|coef| Ridge={ridge_mean_abs:.3f}, Lasso={lasso_mean_abs:.3f}; zeros Ridge={len(self.ridge_coef)-ridge_nonzero}, Lasso={len(self.lasso_coef)-lasso_nonzero})."
        )

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


test_code.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: Regularized Regression Workflow

Ratkaisu

Awesome!

Challenge: Regularized Regression Workflow

Ratkaisu