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

Få en gedigen förståelse för klusteranalys, en central osupervised learning-teknik för att identifiera mönster i oetiketterad data. Utforska grunderna i K-Means, Hierarkisk Klustring, DBSCAN och GMM samt få praktisk erfarenhet med verkliga dataset för att bygga förtroende i att tillämpa klustring på verkliga problem.

Fördjupa dig i grunderna för klustring och upptäck hur det skiljer sig från klassificering. Utforska grundläggande algoritmer, verktyg och bibliotek som driver denna oövervakade inlärningsteknik för att avslöja dolda mönster i data.

Få en gedigen förståelse för centrala förbehandlingstekniker som säkerställer effektiv klustring.
Hantering av saknade värden.
Kodning av kategoriska variabler.
Normalisering av data.
Val av lämpliga avståndsmått och länkningar för att förbättra klustringsnoggrannheten.

Behärska de färdigheter som krävs för att tillämpa K-Means-klustring effektivt. Förstå hur algoritmen fungerar, fastställ det optimala antalet kluster och få praktisk erfarenhet genom att implementera K-Means på både syntetiska och verkliga datamängder.

Utforska grunderna i hierarkisk klustring och lär dig att gruppera data i meningsfulla kluster med hjälp av dendrogram. Få förståelse för att identifiera det optimala antalet kluster och tillämpa tekniken på både syntetiska och verkliga dataset.

Utforska hur DBSCAN utmärker sig vid identifiering av kluster med varierande former och hantering av brus i data. Förstå mekanismerna bakom denna täthetsbaserade algoritm, hur punkter tilldelas kluster samt tillämpa den på både syntetiska och verkliga datamängder med säkerhet.

Få en gedigen förståelse för Gaussiska Mixturmodeller och hur de använder sannolikhet för att modellera komplexa klusterformer. Utforska principerna bakom Gaussisk fördelning, undersök hur GMM fungerar och stärk din kompetens genom att tillämpa dem på både simulerad och verklig data.

Utmaning: Implementering av Gaussian Mixture Models

Lösning

Awesome!

Utmaning: Implementering av Gaussian Mixture Models

Lösning