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

Focus exclusively on feature scaling and normalization using Python's scikit-learn. Learn why scaling is necessary, how to apply StandardScaler, MinMaxScaler, and MaxAbsScaler, and gain hands-on practice with real data preprocessing challenges. Ideal for preparing data for distance-based algorithms and robust unsupervised learning workflows.

Challenge: Whitening via Eigenvalue Decomposition

Steps:

Lösning