import unittest
import importlib
import numpy as np
import scipy.spatial.distance as dist
import scipy.cluster.hierarchy as sch


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_distance_matrix_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'distance_matrix'),
            "The `distance_matrix` variable is declared.",
            "Expected `distance_matrix` to be declared."
        )

    def test_linkage_matrix_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'linkage_matrix'),
            "The `linkage_matrix` variable is declared.",
            "Expected `linkage_matrix` to be declared."
        )

    def test_distance_matrix_is_correct(self):
        import user_code
        from sklearn.datasets import make_blobs

        data, _ = make_blobs(n_samples=10, centers=3, cluster_std=1.0, random_state=42)
        expected_value = dist.pdist(data, metric='euclidean')

        variable = 'distance_matrix'
        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_linkage_matrix_is_correct(self):
        import user_code
        from sklearn.datasets import make_blobs

        data, _ = make_blobs(n_samples=10, centers=3, cluster_std=1.0, random_state=42)
        expected_distance = dist.pdist(data, metric='euclidean')
        expected_value = sch.linkage(expected_distance, method='single')

        variable = 'linkage_matrix'
        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
        )


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 Hierarkisk Klynging

Løsning

Awesome!

Utfordring: Implementering av Hierarkisk Klynging

Løsning