import unittest
import numpy as np
from sklearn.compose import ColumnTransformer

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_preprocessor_exists(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "preprocessor"),
            "The `preprocessor` variable is defined.",
            "Expected `preprocessor` to be defined."
        )

    def test_preprocessor_type(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.preprocessor, ColumnTransformer),
            "The preprocessor is a ColumnTransformer.",
            "Expected `preprocessor` to be a ColumnTransformer."
        )

    def test_result_exists(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "result"),
            "The `result` variable is defined.",
            "Expected `result` to be defined."
        )

    def test_result_shape(self):
        import user_code
        result = user_code.result
        expected_rows = 4

        _dynamic_test(
            self,
            result.shape[0] == expected_rows,
            "The transformed data has the correct number of rows.",
            f"Expected {expected_rows} rows, but got {result.shape[0]}."
        )

    def test_no_missing_values(self):
        import user_code
        result = user_code.result

        _dynamic_test(
            self,
            not np.isnan(result).any(),
            "The transformed data contains no missing values.",
            "Expected the transformed data to contain no NaN values."
        )

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

test_main.py

Master the scikit-learn library by learning its API, core abstractions, and engineering patterns. Focus on syntax, structure, and workflow to confidently build, compose, and inspect machine learning pipelines using scikit-learn.

Explore the foundational Estimator API, understand fit/predict/transform, and learn the design philosophy behind scikit-learn’s consistent interface.

Dive into transformers, preprocessing objects, and how to build robust data pipelines using scikit-learn’s modular approach.

Master scikit-learn’s pipeline and composition tools to create maintainable, reproducible workflows.

Leverage scikit-learn’s model selection and evaluation tools for robust, reproducible workflows.

Learn to inspect, configure, and refactor scikit-learn objects for robust, maintainable code. Avoid common anti-patterns.

Challenge: Build a Preprocessing Workflow

解答