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

Clustering ist eine der grundlegenden Techniken des maschinellen Lernens, die es Ihnen ermöglicht, viele komplexe Probleme im realen Leben zu lösen: Marktsegmentierung, Anomalieerkennung, Dimensionsreduktion, Aufdecken versteckter Muster usw.

Dive into the fundamentals of clustering and discover how it differs from classification. Explore essential algorithms, tools, and libraries that power this unsupervised learning technique to uncover hidden patterns in data.

Gain a solid understanding of key preprocessing techniques that ensure effective clustering. Learn how to handle missing values, encode categorical features, normalize data, and choose appropriate distance measures and linkages to boost clustering accuracy.

Master the skills needed to apply K-Means clustering effectively. Learn how the algorithm works, determine the optimal number of clusters, and gain hands-on experience by implementing K-Means on both synthetic and real-world datasets.

Explore the essentials of hierarchical clustering and learn how to group data into meaningful clusters using dendrograms. Build confidence in identifying the optimal number of clusters and implementing the technique on both synthetic and real-world datasets.

Discover how DBSCAN excels at detecting clusters of varying shapes and handling noise in data. Learn the mechanics behind this density-based algorithm, how to assign points to clusters, and apply it to both synthetic and real datasets with confidence.

Gain a solid understanding of Gaussian Mixture Models and how they use probability to model complex cluster shapes. Learn the principles of Gaussian distribution, explore how GMMs work, and build confidence by applying them to both dummy and real-world data.

Clusteranalyse

Challenge: Implementing DBSCAN

Lösung

Challenge: Implementing DBSCAN

Lösung