import unittest
import importlib
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
import seaborn as sns

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

class TestTitanicTransformations(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.user_code = importlib.import_module("user_code")
        cls.df = cls.user_code.transformed_data
        cls.original = sns.load_dataset("titanic")

    def test_missing_values_filled(self):
        """Check missing values in 'age' and 'embarked' were handled."""
        df = self.df
        cond = ("age" in df.columns) and not df["age"].isnull().any()
        _dynamic_test(
            self,
            cond,
            "Missing values in 'age' and 'embarked' successfully filled.",
            "Missing values still exist in 'age' or 'embarked'."
        )

    def test_get_dummies_applied(self):
        """Check that get_dummies() was used for 'sex' and 'embarked'."""
        df = self.df
        cond = any(col.startswith("sex_") for col in df.columns) and any(
            col.startswith("embarked_") for col in df.columns
        )
        _dynamic_test(
            self,
            cond,
            "Categorical columns 'sex' and 'embarked' successfully encoded using get_dummies().",
            "'sex' and 'embarked' were not properly one-hot encoded."
        )

    def test_standard_scaler(self):
        """Check scaling of 'age' and 'fare' with StandardScaler."""
        df = self.df
        cond = (
            abs(df["age_scaled"].mean()) < 1e-6 and
            abs(df["fare_scaled"].mean()) < 1e-6 and
            np.isclose(df["age_scaled"].std(), 1, atol=0.1) and
            np.isclose(df["fare_scaled"].std(), 1, atol=0.1)
        )
        _dynamic_test(
            self,
            cond,
            "'age' and 'fare' successfully standardized (mean≈0, std≈1).",
            "'age_scaled' or 'fare_scaled' not properly standardized."
        )

    def test_family_size(self):
        """Check that 'family_size' column exists and was correctly calculated."""
        df = self.df
        cond = "family_size" in df.columns and (
            df["family_size"] == df["sibsp"] + df["parch"] + 1
        ).all()
        _dynamic_test(
            self,
            cond,
            "'family_size' successfully created and computed.",
            "'family_size' missing or incorrectly computed."
        )

if __name__ == "__main__":
    unittest.main(argv=["first-arg-is-ignored"], exit=False)

test_code.py

Aprende técnicas prácticas para limpiar, transformar y diseñar datos para aprendizaje automático utilizando Python. Este curso abarca pasos esenciales de preprocesamiento, creación de características y desafíos prácticos para preparar los datos para la modelización.

Domina los pasos fundamentales para limpiar y preparar datos en bruto para análisis y aprendizaje automático.

Transformación de datos sin procesar en características utilizables para modelos de aprendizaje automático.

Ingeniería y selección de características para mejorar el rendimiento y la interpretabilidad del modelo.

Desafío: Cuadrícula de Transformación

Solución