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

    def test_gmm_is_gaussian_mixture_with_3_components_and_random_state_42(self):
        import user_code
        from sklearn.mixture import GaussianMixture

        variable = 'gmm'
        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, GaussianMixture):
            condition = actual_value.n_components == 3 and actual_value.random_state == 42
            failure_message = f"Expected `{variable}` to be a `GaussianMixture` with `3` clusters and `random_state=42`, but got `n_components={actual_value.n_components}` and `random_state={actual_value.random_state}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `GaussianMixture`."

        _dynamic_test(
            self,
            condition,
            "`gmm` is a `GaussianMixture` with `3` clusters 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.mixture import GaussianMixture

        # Generating synthetic dataset
        data, _ = make_blobs(n_samples=300, centers=3, cluster_std=2.0, random_state=42)

        # Initialize the model and predict the labels
        gmm = GaussianMixture(n_components=3, random_state=42)
        expected_value = gmm.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.mixture import GaussianMixture

        data, _ = make_blobs(n_samples=300, centers=3, cluster_std=2.0, random_state=42)
        gmm = GaussianMixture(n_components=3, random_state=42)
        labels = gmm.fit_predict(data)

        clusters = []
        for i in range(3):
            cluster_points = data[labels == i]
            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

Acquérez une compréhension approfondie de l'analyse de clusters, une technique clé d'apprentissage non supervisé pour révéler des motifs dans des données non étiquetées. Explorez les principes fondamentaux de K-Means, du clustering hiérarchique, de DBSCAN et des GMM, et mettez en pratique vos connaissances sur des jeux de données réels afin de renforcer votre confiance dans l'application du clustering à des problématiques concrètes.

Approfondissement des fondamentaux du clustering et distinction par rapport à la classification. Exploration des algorithmes, outils et bibliothèques essentiels qui alimentent cette technique d'apprentissage non supervisé pour révéler des structures cachées dans les données.

Acquérir une compréhension approfondie des principales techniques de prétraitement garantissant un regroupement efficace. Comprendre la gestion des valeurs manquantes, l'encodage des variables catégorielles, la normalisation des données, ainsi que le choix des mesures de distance et des méthodes de liaison appropriées pour améliorer la précision du regroupement.

Maîtrise des compétences nécessaires pour appliquer efficacement le clustering K-Means. Compréhension du fonctionnement de l'algorithme, détermination du nombre optimal de clusters et expérience pratique de l'implémentation de K-Means sur des jeux de données synthétiques et réels.

Découvrez les principes fondamentaux du regroupement hiérarchique et la manière de regrouper des données en ensembles significatifs à l'aide de dendrogrammes. Acquérez une maîtrise dans l'identification du nombre optimal de groupes et dans l'application de cette technique sur des jeux de données synthétiques et réels.

Découvrez comment DBSCAN excelle dans la détection de groupes de formes variées et la gestion du bruit dans les données. Comprenez le fonctionnement de cet algorithme basé sur la densité, la méthode d’attribution des points aux groupes, et son application sur des ensembles de données synthétiques et réels en toute confiance.

Compréhension approfondie des modèles de mélange gaussien et de l'utilisation de la probabilité pour modéliser des formes de clusters complexes.
Principes de la distribution gaussienne.
Exploration du fonctionnement des GMM.
Application des GMM à des données factices et réelles pour renforcer la compréhension.

Défi : Mise en Œuvre des Modèles de Mélange Gaussien

Solution

Défi : Mise en Œuvre des Modèles de Mélange Gaussien

Solution