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

Tutustu piilevien rakenteiden tunnistamiseen ohjaamattoman oppimisen avulla. Hallitse keskeisimmät klusterointialgoritmit, kuten K-Means, hierarkkinen klusterointi, DBSCAN ja Gaussin seosmallit. Opettele arvioimaan klusteroinnin laatua WSS- ja Silhouette-mittareilla, käsittelemään erilaisia etäisyysmittareita sekä toteuttamaan kestäviä ratkaisuja aidoilla aineistoilla. Kehitä osaamista asiakassegmentoinnissa ja rakenteiden löytämisessä merkitsemättömästä datasta Scikit-learnin avulla.

Haaste: K-Means-klusteroinnin Toteuttaminen

Ratkaisu

Haaste: K-Means-klusteroinnin Toteuttaminen

Ratkaisu