import unittest
import importlib
import numpy as np
import re

# Helper for dynamic messages
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_variables_declared(self):
        import user_code
        condition = all(hasattr(user_code, name) for name in
                        ['X', 'row_norms', 'X_l2', 'norms_before', 'norms_after'])
        _dynamic_test(
            self,
            condition,
            "All required variables (`X`, `row_norms`, `X_l2`, `norms_before`, `norms_after`) are declared.",
            "Expected all required variables to be declared."
        )

    def test_row_norms_shape(self):
        import user_code
        n_samples = user_code.X.shape[0]
        expected_shape = (n_samples, 1)
        _dynamic_test(
            self,
            getattr(user_code, 'row_norms', None) is not None and user_code.row_norms.shape == expected_shape,
            f"`row_norms` has the correct shape {expected_shape}.",
            f"Expected `row_norms` shape {expected_shape}, got {getattr(getattr(user_code, 'row_norms', None), 'shape', None)}."
        )

    def test_X_l2_shape(self):
        import user_code
        _dynamic_test(
            self,
            getattr(user_code, 'X_l2', None) is not None and user_code.X_l2.shape == user_code.X.shape,
            f"`X_l2` has the same shape as `X` ({user_code.X.shape}).",
            f"Expected `X_l2` shape {user_code.X.shape}, got {getattr(getattr(user_code, 'X_l2', None), 'shape', None)}."
        )

    def test_values_are_correct(self):
        import user_code
        X = user_code.X.copy()
        expected_row_norms = np.linalg.norm(X, axis=1, keepdims=True)
        expected_X_l2 = X / expected_row_norms
        cond1 = np.allclose(user_code.row_norms, expected_row_norms, atol=1e-10)
        cond2 = np.allclose(user_code.X_l2, expected_X_l2, atol=1e-10)
        _dynamic_test(
            self,
            cond1 and cond2,
            "`row_norms` and `X_l2` are computed correctly using L2 normalization.",
            "Expected L2 normalization with `np.linalg.norm(..., axis=1, keepdims=True)` and division via broadcasting."
        )

    def test_norms_before_after(self):
        import user_code
        expected_before = np.linalg.norm(user_code.X, axis=1)
        expected_after = np.linalg.norm(user_code.X_l2, axis=1)
        cond1 = np.allclose(user_code.norms_before, expected_before, atol=1e-10)
        cond2 = np.allclose(user_code.norms_after, expected_after, atol=1e-10)
        _dynamic_test(
            self,
            cond1 and cond2,
            "`norms_before` and `norms_after` contain correct L2 norms.",
            "Expected correct values for `norms_before` and `norms_after`."
        )

    def test_norms_after_are_one(self):
        import user_code
        try:
            cond = np.allclose(user_code.norms_after, np.ones_like(user_code.norms_after), atol=1e-10)
            fail_msg = f"Expected all L2 norms after normalization to be 1, got {user_code.norms_after}."
        except Exception as e:
            cond = False
            fail_msg = f"Could not compute check on `norms_after`: {e}"
        _dynamic_test(
            self,
            cond,
            "All rows in `X_l2` have L2 norm equal to 1 (within tolerance).",
            fail_msg
        )

    def test_original_X_not_modified(self):
        import user_code
        # Recompute from X to ensure X_l2 was not obtained by modifying X in place
        recomputed = user_code.X / np.linalg.norm(user_code.X, axis=1, keepdims=True)
        _dynamic_test(
            self,
            np.allclose(user_code.X_l2, recomputed, atol=1e-10),
            "The original `X` was not modified in place; `X_l2` is a separate normalized array.",
            "Expected `X` to remain unchanged and `X_l2` to be computed via division by row norms."
        )

    def test_linalg_norm_is_used(self):
        # Check presence of np.linalg.norm in user code (per checklist: check only for function presence)
        with open('user_code.py', 'r') as f:
            src = f.read()
        pattern = r'np\.linalg\.norm\s*\('
        _dynamic_test(
            self,
            re.search(pattern, src) is not None,
            "`np.linalg.norm` is used to compute L2 norms.",
            "Expected `np.linalg.norm` to be used for L2 norm computation."
        )

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


test_main.py

A comprehensive exploration of feature scaling, normalization, and data preprocessing techniques essential for effective machine learning. This course covers the mathematical foundations, intuition, practical implementation, and impact of various scaling methods on model performance.

Explore the core motivations for feature scaling, including its mathematical basis and practical impact on machine learning algorithms.

Investigate L1, L2, and Max normalization, their mathematical foundations, and their effects on data geometry.

Understand the concepts of covariance, correlation, and the whitening transformation for decorrelating features.

Analyze the impact of feature scaling on model optimization, convergence, and performance.

Learn to select appropriate scaling and normalization techniques, avoid data leakage, and build robust preprocessing pipelines.

Challenge: L2 Normalization and Norm Comparison

解答