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

Få en solid forståelse av klyngeanalyse, en sentral usupervisert læringsteknikk for å avdekke mønstre i umerkede data. Utforsk det grunnleggende om K-Means, hierarkisk klynging, DBSCAN og GMM, og få praktisk erfaring med ekte datasett for å bygge selvtillit i anvendelse av klyngeanalyse på reelle problemer.

Fordyp deg i det grunnleggende innen klyngeanalyse og oppdag hvordan det skiller seg fra klassifisering. Utforsk sentrale algoritmer, verktøy og biblioteker som driver denne teknikken for ikke-veiledet læring for å avdekke skjulte mønstre i data.

Få en grundig forståelse av sentrale forhåndsbehandlingsteknikker som sikrer effektiv klyngeanalyse. Lær hvordan man håndterer manglende verdier, koder kategoriske egenskaper, normaliserer data og velger passende avstandsmål og koblinger for å øke nøyaktigheten i klyngeanalysen.

Behersk ferdighetene som kreves for å anvende K-Means-klynging effektivt. Lær hvordan algoritmen fungerer, bestem det optimale antallet klynger, og få praktisk erfaring ved å implementere K-Means på både syntetiske og virkelige datasett.

Utforsk det grunnleggende innen hierarkisk klynging og lær hvordan data kan grupperes i meningsfulle klynger ved hjelp av dendrogrammer. Bygg trygghet i å identifisere det optimale antallet klynger og implementere teknikken på både syntetiske og virkelige datasett.

Utforsk hvordan DBSCAN utmerker seg i å oppdage klynger med varierende former og håndtere støy i data. Lær mekanismene bak denne tetthetsbaserte algoritmen, hvordan punkter tilordnes klynger, og bruk den på både syntetiske og virkelige datasett med trygghet.

Få en grundig forståelse av gaussiske blandingsmodeller og hvordan de bruker sannsynlighet for å modellere komplekse klyngestrukturer. Prinsipper for gaussisk fordeling, utforskning av hvordan GMM fungerer, samt anvendelse på både dummydata og virkelige datasett.

Utfordring: Implementering av K-Means Klynging

Løsning

Awesome!

Utfordring: Implementering av K-Means Klynging

Løsning