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)


def get_first_differing_index(expected_array, actual_array):
    for i, (val_1, val_2) in enumerate(zip(expected_array, actual_array)):
        if not np.array_equal(val_1, val_2):
            return i, expected_array[i], actual_array[i]

    if len(expected_array) > len(actual_array):
        return len(actual_array), expected_array[len(actual_array)], None
    else:
        return len(expected_array), None, actual_array[len(expected_array)]


class TestUserCode(unittest.TestCase):

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

    def test_dbscan_is_correct(self):
        import user_code
        from sklearn.cluster import DBSCAN

        variable = 'dbscan'
        actual_value = getattr(user_code, variable, None)
        if actual_value is None:
            condition = False
            failure_message = f"The `{variable}` variable is not declared."
        elif isinstance(actual_value, DBSCAN):
            condition = actual_value.eps == 0.3 and actual_value.min_samples == 6
            failure_message = f"Expected `{variable}` to be a `DBSCAN` with `eps=0.3` and `min_samples=6`, but got `eps={actual_value.eps}` and `min_samples={actual_value.min_samples}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `DBSCAN`."

        _dynamic_test(
            self,
            condition,
            "`dbscan` is a `DBSCAN` with `eps=0.3`, `min_samples=6`, and `random_state=42`.",
            failure_message
        )

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

    def test_labels_is_correct(self):
        import user_code

        from sklearn.datasets import make_blobs
        from sklearn.cluster import DBSCAN
        from sklearn.preprocessing import StandardScaler

        data, _ = make_blobs(n_samples=300, centers=3, cluster_std=0.5, random_state=42)
        transformation_matrix = np.array([[0.6, -0.6], [0.4, 0.8]])
        data = np.dot(data, transformation_matrix)
        data = StandardScaler().fit_transform(data)
        dbscan = DBSCAN(eps=0.3, min_samples=6)
        expected_value = dbscan.fit_predict(data)

        variable = 'labels'
        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, np.ndarray):
            failure_message = f"`{variable}` is not a `numpy.ndarray`."
        elif actual_value.size == 0:
            failure_message = f"`{variable}` is empty."
        elif np.array_equal(actual_value, expected_value):
            condition = True
            failure_message = None
        else:
            idx, expected_element, actual_element = get_first_differing_index(expected_value, actual_value)
            failure_message = f"Expected `{variable}` to contain `{expected_element}` at index {idx}, but got `{actual_element}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )

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

    def test_clusters_is_correct(self):
        import user_code

        from sklearn.datasets import make_blobs
        from sklearn.cluster import DBSCAN
        from sklearn.preprocessing import StandardScaler

        data, _ = make_blobs(n_samples=300, centers=3, cluster_std=0.5, random_state=42)
        transformation_matrix = np.array([[0.6, -0.6], [0.4, 0.8]])
        data = np.dot(data, transformation_matrix)
        data = StandardScaler().fit_transform(data)
        dbscan = DBSCAN(eps=0.3, min_samples=6)
        labels = dbscan.fit_predict(data)
        unique_labels = set(labels)
        clusters = []

        for label in unique_labels:
            cluster_points = data[labels == label]
            clusters.append(cluster_points)

        expected_value = clusters

        variable = 'clusters'
        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, list):
            failure_message = f"`{variable}` is not a `list`."
        elif not actual_value:
            failure_message = f"`{variable}` is empty."
        elif all(np.array_equal(a, b) for a, b in zip(actual_value, expected_value)):
            condition = True
            failure_message = None
        elif len(actual_value) != 3:
            failure_message = f"Expected `{variable}` to contain `3` arrays, but got `{len(actual_value)}`."
        else:
            for i in range(len(actual_value)):
                if isinstance(actual_value[i], np.ndarray):
                    if np.array_equal(actual_value[i], expected_value[i]):
                        continue
                    idx, expected_element, actual_element = get_first_differing_index(expected_value[i], actual_value[i])
                    failure_message = f"Expected `{variable}[{i}]` to contain `{expected_element}` at index {idx}, but got `{actual_element}`."
                else:
                    failure_message = f"`{variable}[{i}]` is not a `numpy.ndarray`."
                break

        _dynamic_test(
            self,
            condition,
            "`cluster_points` are correctly selected from `data` using `labels`.",
            failure_message
        )


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

test_main.py

Obtenha uma compreensão sólida de análise de clusters, uma técnica fundamental de aprendizado não supervisionado para identificar padrões em dados não rotulados. Explore os conceitos essenciais de K-Means, Agrupamento Hierárquico, DBSCAN e GMMs, e adquira experiência prática com conjuntos de dados reais para desenvolver confiança na aplicação de clustering em problemas do mundo real.

Aprofunde-se nos fundamentos do clustering e descubra como ele difere da classificação. Explore algoritmos, ferramentas e bibliotecas essenciais que impulsionam essa técnica de aprendizado não supervisionado para revelar padrões ocultos nos dados.

Obtenha uma compreensão sólida das principais técnicas de pré-processamento que garantem uma clusterização eficaz. Aprenda a lidar com valores ausentes, codificar variáveis categóricas, normalizar dados e escolher medidas de distância e métodos de ligação apropriados para aumentar a precisão da clusterização.

Domine as habilidades necessárias para aplicar a clusterização K-Means de forma eficaz. Compreenda o funcionamento do algoritmo, determine o número ideal de clusters e obtenha experiência prática implementando o K-Means em conjuntos de dados sintéticos e reais.

Explore os conceitos essenciais do agrupamento hierárquico e aprenda a agrupar dados em clusters significativos utilizando dendrogramas. Desenvolva confiança na identificação do número ideal de clusters e na aplicação da técnica em conjuntos de dados sintéticos e do mundo real.

Descubra como o DBSCAN se destaca na detecção de agrupamentos com formas variadas e no tratamento de ruídos nos dados. Compreenda a mecânica por trás deste algoritmo baseado em densidade, como atribuir pontos a agrupamentos e aplicá-lo com confiança em conjuntos de dados sintéticos e reais.

Compreensão sólida de Modelos de Mistura Gaussiana e de como utilizam probabilidade para modelar formas complexas de agrupamentos. Princípios da distribuição Gaussiana, funcionamento dos GMMs e aplicação prática em dados simulados e reais.

Desafio: Implementando DBSCAN

Solução

Awesome!

Desafio: Implementando DBSCAN

Solução

Awesome!