import unittest
import importlib
import numpy as np

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_X_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'X'),
            "The `X` variable is declared.",
            "Expected `X` to be declared."
        )

    def test_feature_means_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'feature_means'),
            "The `feature_means` variable is declared.",
            "Expected `feature_means` to be declared."
        )

    def test_X_centered_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'X_centered'),
            "The `X_centered` variable is declared.",
            "Expected `X_centered` to be declared."
        )

    def test_feature_means_shape_is_correct(self):
        import user_code
        X = user_code.X
        expected_shape = (X.shape[1],)
        _dynamic_test(
            self,
            hasattr(user_code, 'feature_means') and user_code.feature_means.shape == expected_shape,
            f"The `feature_means` array has the correct shape {expected_shape}.",
            f"Expected `feature_means` shape {expected_shape}, but got {getattr(user_code.feature_means, 'shape', None)}."
        )

    def test_X_centered_shape_is_correct(self):
        import user_code
        X = user_code.X
        _dynamic_test(
            self,
            hasattr(user_code, 'X_centered') and user_code.X_centered.shape == X.shape,
            f"The `X_centered` array has the same shape as `X` ({X.shape}).",
            f"Expected `X_centered` shape {X.shape}, but got {getattr(user_code.X_centered, 'shape', None)}."
        )

    def test_centering_values_are_correct(self):
        import user_code
        X = user_code.X
        expected = X - X.mean(axis=0)
        condition = np.allclose(user_code.X_centered, expected, atol=1e-10)
        _dynamic_test(
            self,
            condition,
            "The `X_centered` array is correctly centered by feature means.",
            "Expected `X_centered` to be `X - X.mean(axis=0)`."
        )

    def test_column_means_are_zero(self):
        import user_code
        col_means = user_code.X_centered.mean(axis=0)
        condition = np.allclose(col_means, np.zeros_like(col_means), atol=1e-10)
        _dynamic_test(
            self,
            condition,
            "Each column in `X_centered` has a mean approximately equal to zero.",
            f"Expected column means to be near zero, but got {col_means}."
        )

    def test_X_not_modified_in_place(self):
        import user_code
        recomputed = user_code.X - user_code.feature_means
        condition = np.allclose(recomputed, user_code.X_centered, atol=1e-10)
        _dynamic_test(
            self,
            condition,
            "The original `X` array is not modified in place.",
            "Expected `X_centered` to be computed as a new array (X - feature_means)."
        )

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: Manual Feature Centering

Ratkaisu

Awesome!

Challenge: Manual Feature Centering

Ratkaisu