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

Hanki vankka ymmärrys klusterianalyysistä, keskeisestä valvomattoman oppimisen menetelmästä, jolla paljastetaan rakenteita merkitsemättömästä datasta. Tutustu K-Means-, hierarkkisen klusteroinnin, DBSCAN:n ja GMM-mallien perusteisiin sekä saa käytännön kokemusta aidoista aineistoista, jotta voit soveltaa klusterointia todellisiin ongelmiin luottavaisesti.

Perehdy klusteroinnin perusteisiin ja selvitä, miten se eroaa luokittelusta. Tutustu keskeisiin algoritmeihin, työkaluihin ja kirjastoihin, jotka mahdollistavat tämän valvomattoman oppimisen menetelmän piilevien rakenteiden löytämiseksi datasta.

Perusteellinen ymmärrys keskeisistä esikäsittelymenetelmistä, jotka varmistavat tehokkaan klusteroinnin. Puuttuvien arvojen käsittely, kategoristen ominaisuuksien koodaus, datan normalisointi sekä sopivien etäisyysmittareiden ja linkitysten valinta klusteroinnin tarkkuuden parantamiseksi.

Hallitse taidot, joita tarvitaan K-Means-klusteroinnin tehokkaaseen soveltamiseen. Opi algoritmin toimintaperiaate, optimaalisen klusterimäärän määrittäminen sekä käytännön toteutus K-Means-menetelmällä synteettisiin ja todellisiin aineistoihin.

Tutustu hierarkkisen klusteroinnin perusteisiin ja opi ryhmittelemään dataa merkityksellisiin klustereihin dendrogrammien avulla. Vahvista osaamistasi optimaalisen klusterimäärän tunnistamisessa ja menetelmän soveltamisessa sekä synteettisiin että todellisiin aineistoihin.

Tutustu siihen, miten DBSCAN tunnistaa erimuotoisia klustereita ja käsittelee kohinaa aineistossa. Ymmärrä tämän tiheysperusteisen algoritmin toimintaperiaatteet, pisteiden liittäminen klustereihin sekä sen soveltaminen sekä synteettisiin että todellisiin aineistoihin.

Perusteellinen ymmärrys Gaussin sekoitusmalleista ja niiden todennäköisyyspohjaisesta tavasta mallintaa monimutkaisia klusterimuotoja. Gaussin jakauman periaatteet. GMM-mallien toimintaperiaatteet. Soveltaminen sekä esimerkkiaineistoon että todellisiin aineistoihin.

Haaste: K-Means-klusteroinnin Toteuttaminen

Ratkaisu

Awesome!

Haaste: K-Means-klusteroinnin Toteuttaminen

Ratkaisu