import unittest
import importlib
import numpy as np
import pandas as pd


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_age_column_has_no_missing_values(self):
        import user_code

        variable = 'data'
        actual_df = getattr(user_code, variable, None)
        condition = False
        if actual_df is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_df, pd.DataFrame):
            failure_message = f"`{variable}` is not a `DataFrame`."
        elif actual_df.empty:
            failure_message = f"`{variable}` is empty."
        elif 'Age' not in actual_df.columns:
            failure_message = f"`{variable}` has no 'Age' column."
        elif not actual_df['Age'].isnull().any():
            condition = True
            failure_message = None
        else:
            null_count = actual_df['Age'].isnull().sum()
            failure_message = f"Expected the 'Age' column to contain no missing values, but got `{null_count}`."

        _dynamic_test(
            self,
            condition,
            "The 'Age' column contains no missing values.",
            failure_message
        )

    def test_missing_values_are_replaced_correctly(self):
        import user_code

        expected_value = pd.Series([25, 30, 30, 35, 30]).astype(float)

        variable = 'data'
        actual_df = getattr(user_code, variable, None)
        condition = False
        if actual_df is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_df, pd.DataFrame):
            failure_message = f"`{variable}` is not a `DataFrame`."
        elif actual_df.empty:
            failure_message = f"`{variable}` is empty."
        elif 'Age' not in actual_df.columns:
            failure_message = f"`{variable}` has no 'Age' column."
        elif actual_df['Age'].equals(expected_value):
            condition = True
            failure_message = None
        else:
            failure_message = f"Expected `{variable}['Age']` to contain `{expected_value.values}`, but got `{actual_df['Age'].values}`."

        _dynamic_test(
            self,
            condition,
            "The missing values in the 'Age' column are correctly replaced with the mean.",
            failure_message
        )

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

    def test_city_encoder_is_onehotencoder(self):
        import user_code
        from sklearn.preprocessing import OneHotEncoder

        try:
            condition = isinstance(user_code.city_encoder, OneHotEncoder)
            failure_message = f"Expected `city_encoder` to be an instance of `OneHotEncoder`, but got `{type(user_code.city_encoder).__name__}`."
        except AttributeError:
            condition = False
            failure_message = "The `city_encoder` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "The `city_encoder` is an instance of `OneHotEncoder`.",
            failure_message
        )

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

    def test_city_encoded_is_correct(self):
        import user_code
        from sklearn.preprocessing import OneHotEncoder
        from scipy.sparse import csr_matrix

        data = pd.DataFrame({
            'Age': [25, np.nan, 30, 35, np.nan],
            'City': ['New York', 'London', 'Paris', 'Berlin', 'London'],
            'Income': ['Low', 'Middle', 'High', 'High', 'Middle']
        })

        city_encoder = OneHotEncoder(drop='first')
        expected_value = city_encoder.fit_transform(data[['City']]).toarray()

        variable = 'city_encoded'
        actual_value = getattr(user_code, variable, None)
        condition = False
        if actual_value is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_value, csr_matrix):
            failure_message = f"`{variable}` is not a `scipy.sparse.csr_matrix`."
        elif not actual_value.size:
            failure_message = f"`{variable}` is empty."
        elif np.array_equal(actual_value.toarray(), expected_value):
            condition = True
            failure_message = None
        else:
            failure_message = f"Expected `{variable}` to contain `{expected_value}`, but got `{actual_value.toarray()}`."

        _dynamic_test(
            self,
            condition,
            f"The 'City' column is encoded correctly.",
            failure_message
        )

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

    def test_income_encoder_is_ordinalencoder(self):
        import user_code
        from sklearn.preprocessing import OrdinalEncoder

        try:
            condition = isinstance(user_code.income_encoder, OrdinalEncoder)
            failure_message = f"Expected `income_encoder` to be an instance of `OrdinalEncoder`, but got `{type(user_code.income_encoder).__name__}`."
        except AttributeError:
            condition = False
            failure_message = "The `income_encoder` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "The `income_encoder` is an instance of `OrdinalEncoder`.",
            failure_message
        )

    def test_income_column_is_encoded_correctly(self):
        import user_code

        expected_value = pd.Series([0, 1, 2, 2, 1]).astype(float)

        variable = 'data'
        actual_df = getattr(user_code, variable, None)
        condition = False
        if actual_df is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_df, pd.DataFrame):
            failure_message = f"`{variable}` is not a `DataFrame`."
        elif actual_df.empty:
            failure_message = f"`{variable}` is empty."
        elif 'Income' not in actual_df.columns:
            failure_message = f"`{variable}` has no 'Income' column."
        elif actual_df['Income'].equals(expected_value):
            condition = True
            failure_message = None
        else:
            failure_message = f"Expected `{variable}['Income']` to contain `{expected_value.values}`, but got `{actual_df['Income'].values}`."

        _dynamic_test(
            self,
            condition,
            "The 'Income' column is encoded correctly.",
            failure_message
        )


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


test_main.py

Acquisire una solida comprensione dell'analisi dei cluster, una tecnica chiave di apprendimento non supervisionato per individuare schemi in dati non etichettati. Esplorare i fondamenti di K-Means, Clustering Gerarchico, DBSCAN e GMM, con esperienza pratica su dataset reali per sviluppare sicurezza nell'applicazione del clustering a problemi reali.

Approfondimento sui fondamenti del clustering e sulle differenze rispetto alla classificazione. Esplorazione degli algoritmi, strumenti e librerie essenziali che alimentano questa tecnica di apprendimento non supervisionato per individuare schemi nascosti nei dati.

Acquisizione di una solida comprensione delle principali tecniche di preprocessamento che garantiscono un clustering efficace. Gestione dei valori mancanti, codifica delle variabili categoriche, normalizzazione dei dati e selezione di misure di distanza e metodi di collegamento appropriati per migliorare l'accuratezza del clustering.

Acquisire le competenze necessarie per applicare efficacemente il clustering K-Means. Comprendere il funzionamento dell'algoritmo, determinare il numero ottimale di cluster e acquisire esperienza pratica implementando K-Means su dataset sintetici e reali.

Esplora i fondamenti della clusterizzazione gerarchica e scopri come raggruppare i dati in cluster significativi utilizzando i dendrogrammi. Acquisizione di competenze nell'identificazione del numero ottimale di cluster e nell'applicazione della tecnica su dataset sintetici e reali.

Scopri come DBSCAN eccelle nell'individuare cluster di forme diverse e nella gestione del rumore nei dati. Esplora i meccanismi alla base di questo algoritmo basato sulla densità, le modalità di assegnazione dei punti ai cluster e la sua applicazione sia a set di dati sintetici che reali con sicurezza.

Acquisire una solida comprensione dei Gaussian Mixture Models e di come utilizzano la probabilità per modellare forme di cluster complesse. Esaminare i principi della distribuzione gaussiana, analizzare il funzionamento dei GMM e consolidare le conoscenze applicandoli sia a dati simulati che reali.

Sfida: Pre-Elaborazione del Dataset

Soluzione

Awesome!

Sfida: Pre-Elaborazione del Dataset

Soluzione