import unittest
import numpy as np
import re

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
        vars_expected = [
            'X', 'X_centered', 'cov_matrix',
            'eig_vals', 'eig_vecs', 'whitening_matrix',
            'X_whitened', 'cov_whitened'
        ]
        condition = all(hasattr(user_code, v) for v in vars_expected)
        _dynamic_test(
            self,
            condition,
            "All required variables are declared.",
            f"Expected all variables {vars_expected} to be declared."
        )

    def test_cov_matrix_shape(self):
        import user_code
        n_features = user_code.X.shape[1]
        condition = user_code.cov_matrix.shape == (n_features, n_features)
        _dynamic_test(
            self,
            condition,
            f"The covariance matrix has shape ({n_features}, {n_features}).",
            f"Expected covariance matrix shape ({n_features}, {n_features}), got {user_code.cov_matrix.shape}."
        )

    def test_eigh_used(self):
        with open('user_code.py', 'r') as f:
            src = f.read()
        _dynamic_test(
            self,
            re.search(r'np\.linalg\.eigh\s*\(', src),
            "`np.linalg.eigh` is used for eigenvalue decomposition.",
            "Expected `np.linalg.eigh` to be used for covariance matrix decomposition."
        )

    def test_whitening_matrix_is_valid(self):
        import user_code
        eig_vals, eig_vecs = user_code.eig_vals, user_code.eig_vecs
        eig_vals_safe = np.where(eig_vals < 1e-10, 1e-10, eig_vals)
        expected = eig_vecs @ np.diag(1.0 / np.sqrt(eig_vals_safe)) @ eig_vecs.T
        wm = user_code.whitening_matrix

        if wm.shape != expected.shape:
            condition = False
        else:
            # Accept equivalent scaling
            same_scale = np.allclose(wm / np.linalg.norm(wm), expected / np.linalg.norm(expected), atol=1e-2)
            almost_equal = np.allclose(wm, expected, atol=1e-2)
            condition = same_scale or almost_equal

        _dynamic_test(
            self,
            condition,
            "The `whitening_matrix` is computed correctly (robust to small eigenvalues).",
            "Expected whitening matrix equivalent to eig_vecs @ diag(1/sqrt(eig_vals_safe)) @ eig_vecs.T."
        )

    def test_whitened_covariance_is_identity_in_nonzero_subspace(self):
        import user_code
        cov_w = user_code.cov_whitened
        eig_vals, _ = np.linalg.eigh(cov_w)
        nonzero_eigs = eig_vals[eig_vals > 1e-8]
        if len(nonzero_eigs) == 0:
            condition = True
        else:
            nonzero_eigs /= np.mean(nonzero_eigs)
            condition = np.allclose(nonzero_eigs, np.ones_like(nonzero_eigs), atol=1e-2)
        _dynamic_test(
            self,
            condition,
            "The covariance of `X_whitened` is approximately identity in its nonzero subspace.",
            f"Expected eigenvalues near 1 for nonzero subspace, got: {np.array2string(eig_vals, precision=4)}"
        )

    def test_X_not_modified(self):
        import user_code
        original = np.array([
            [2.0, 4.0, 6.0],
            [3.0, 6.0, 9.0],
            [4.0, 8.0, 12.0],
            [5.0, 10.0, 15.0],
        ], dtype=float)
        condition = np.allclose(user_code.X, original, atol=1e-10)
        _dynamic_test(
            self,
            condition,
            "The original array `X` was not modified.",
            "Expected the original dataset `X` to remain unchanged."
        )

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: Whitening via Eigenvalue Decomposition

Steps:

Solution

Challenge: Whitening via Eigenvalue Decomposition

Steps:

Solution