import unittest
import importlib
import numpy as np
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans


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

    def test_kmeans_is_correct(self):
        import user_code
        from sklearn.cluster import KMeans

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

        _dynamic_test(
            self,
            condition,
            "`kmeans` is a `KMeans` with `n_clusters=3`, `n_init='auto'`, 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

        data, _ = make_blobs(n_samples=300, centers=3, cluster_std=1.0, random_state=42)
        kmeans = KMeans(n_clusters=3, random_state=42, n_init='auto')
        expected_value = kmeans.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
        
        data, _ = make_blobs(n_samples=300, centers=3, cluster_std=1.0, random_state=42)
        kmeans = KMeans(n_clusters=3, random_state=42, n_init='auto')
        labels = kmeans.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

Erwerben Sie ein fundiertes Verständnis der Clusteranalyse, einer zentralen Methode des unüberwachten Lernens zur Entdeckung von Mustern in nicht gelabelten Daten. Erforschen Sie die Grundlagen von K-Means, hierarchischem Clustering, DBSCAN und GMMs und sammeln Sie praktische Erfahrungen mit realen Datensätzen, um Sicherheit bei der Anwendung von Clustering auf reale Problemstellungen zu gewinnen.

Tauchen Sie in die Grundlagen der Clusteranalyse ein und erfahren Sie, wie sie sich von der Klassifikation unterscheidet. Erkunden Sie wesentliche Algorithmen, Werkzeuge und Bibliotheken, die diese Methode des unbeaufsichtigten Lernens unterstützen, um verborgene Muster in Daten zu erkennen.

Erwerben Sie ein fundiertes Verständnis der wichtigsten Vorverarbeitungstechniken, die eine effektive Clusterbildung gewährleisten. Erfahren Sie, wie fehlende Werte behandelt, kategoriale Merkmale codiert, Daten normalisiert und geeignete Distanzmaße sowie Verknüpfungen ausgewählt werden, um die Genauigkeit der Clusterbildung zu erhöhen.

Beherrschen der Fähigkeiten zur effektiven Anwendung des K-Means-Clusterings. Verständnis der Funktionsweise des Algorithmus. Bestimmung der optimalen Clusteranzahl. Praktische Erfahrung durch Implementierung von K-Means auf synthetischen und realen Datensätzen.

Erkunden Sie die Grundlagen des hierarchischen Clusterings und erfahren Sie, wie Daten mithilfe von Dendrogrammen in sinnvolle Cluster gruppiert werden. Sicherheit beim Erkennen der optimalen Clusteranzahl und Anwendung der Methode auf synthetische sowie reale Datensätze.

Erfahren Sie, wie DBSCAN bei der Erkennung von Clustern unterschiedlicher Formen und der Handhabung von Ausreißern in Daten überzeugt. Verstehen Sie die Mechanismen dieses dichtebasierten Algorithmus, die Zuordnung von Punkten zu Clustern und die Anwendung auf synthetische sowie reale Datensätze.

Fundierte Kenntnisse über Gaußsche Mischmodelle und deren Verwendung von Wahrscheinlichkeiten zur Modellierung komplexer Clusterformen. Prinzipien der Gaußschen Verteilung. Funktionsweise von GMMs. Anwendung auf Dummy- und Realweltdaten zur Festigung des Verständnisses.

Herausforderung: Implementierung des K-Means-Clustering-Verfahrens

Lösung

Awesome!

Herausforderung: Implementierung des K-Means-Clustering-Verfahrens

Lösung