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

Utforska kraften i dolda mönster med osupervised learning. Behärska de mest inflytelserika klustringsalgoritmerna, inklusive K-Means, Hierarkisk Klustring, DBSCAN och Gaussiska Mixturmodeller. Lär dig att utvärdera klusterkvalitet med hjälp av WSS och Silhouette-poäng, hantera olika avståndsmått och implementera robusta lösningar på verkliga datamängder. Bygg färdigheter för att segmentera kunder och upptäcka strukturer i oetiketterad data med Scikit-learn.

Utmaning: Implementering av DBSCAN

Lösning

Utmaning: Implementering av DBSCAN

Lösning