Wie in den vorherigen Kapiteln gezeigt, können die Vorhersagen des Modells je nach Wert von **k** (der Anzahl der Nachbarn) variieren. Beim Erstellen eines k-NN-Modells ist es wichtig, den k-Wert zu wählen, der die **beste Leistung** erzielt.

Ein gängiger Ansatz ist die Verwendung von **Cross-Validation**, um die Modellleistung zu bewerten. Es kann eine Schleife ausgeführt und die Cross-Validation-Ergebnisse **für verschiedene k-Werte** berechnet werden, um anschließend den Wert mit dem höchsten Score auszuwählen. Dies ist die am weitesten verbreitete Methode.

Zur Durchführung bietet `sklearn` ein praktisches Werkzeug: die Klasse `GridSearchCV`.

Der Parameter `param_grid` erwartet ein **Dictionary**, bei dem die Schlüssel die Namen der Parameter und die Werte Listen von Optionen sind, die getestet werden sollen. Um beispielsweise Werte von `1` bis `99` für `n_neighbors` zu testen, kann man schreiben:
```python
param_grid = {'n_neighbors': range(1, 100)}
```
Durch Aufruf der Methode `.fit(X, y)` auf dem `GridSearchCV`-Objekt wird das Parameter-Raster durchsucht, um die besten Parameter zu finden, und anschließend das Modell **mit diesen besten Parametern auf dem gesamten Datensatz erneut trainiert**.

Der **beste Score** kann über das Attribut `.best_score_` abgerufen werden. Vorhersagen mit dem optimierten Modell sind über die Methode `.predict()` möglich. Ebenso kann das **beste Modell** selbst über das Attribut `.best_estimator_` abgerufen werden.

import unittest
import importlib


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)


class TestUserCode(unittest.TestCase):

    def test_param_grid_is_declared(self):
        import user_code

        variable = 'param_grid'
        _dynamic_test(
            self,
            hasattr(user_code, variable),
            f"The `{variable}` variable is declared.",
            f"Expected `{variable}` to be declared."
        )

    def test_para_grid_is_dict(self):
        import user_code

        try:
            condition = isinstance(user_code.param_grid, dict)
            failure_message = f"Expected `param_grid` to be a `dict`, but got `{type(user_code.param_grid).__name__}`."
        except AttributeError:
            condition = False
            failure_message = "The `param_grid` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "`param_grid` is a `dict`.",
            failure_message
        )

    def test_param_grid_is_correct(self):
        import user_code
        expected_value = {'n_neighbors': [3, 9, 18, 27]}

        variable = 'param_grid'
        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, dict):
            condition = actual_value == expected_value
            failure_message = f"Expected `{variable}` to contain `{expected_value}`, but got `{actual_value}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `dict`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct values.",
            failure_message
        )

    def test_grid_search_is_declared(self):
        import user_code

        variable = 'grid_search'
        _dynamic_test(
            self,
            hasattr(user_code, variable),
            f"The `{variable}` variable is declared.",
            f"Expected `{variable}` to be declared."
        )

    def test_grid_search_is_correct(self):
        import user_code
        from sklearn.model_selection import GridSearchCV
        from sklearn.neighbors import KNeighborsClassifier

        knn = KNeighborsClassifier()
        param_grid = {'n_neighbors': [3, 9, 18, 27]}

        variable = 'grid_search'
        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, GridSearchCV):
            condition = isinstance(actual_value.estimator, KNeighborsClassifier) and actual_value.param_grid == param_grid and actual_value.cv == 4
            failure_message = f"Expected `{variable}` to be a `GridSearchCV` with `knn` as the model, `4` folds, and `param_grid` as the grid of parameters, but got `estimator={actual_value.estimator}`, `param_grid={actual_value.param_grid}`, and `cv={actual_value.cv}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `GridSearchCV`."

        _dynamic_test(
            self,
            condition,
            "`grid_search` is a `GridSearchCV` with `estimator=knn`, `param_grid=param_grid`, and `cv=4`.",
            failure_message
        )

    def test_best_model_is_declared(self):
        import user_code

        variable = 'best_model'
        _dynamic_test(
            self,
            hasattr(user_code, variable),
            f"The `{variable}` variable is declared.",
            f"Expected `{variable}` to be declared."
        )

    def test_best_model_is_correct(self):
        import user_code
        from sklearn.neighbors import KNeighborsClassifier

        variable = 'best_model'
        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, KNeighborsClassifier):
            condition = actual_value.n_neighbors == 27
            failure_message = f"Expected `{variable}` to be a `KNeighborsClassifier` with `27` neighbors, but got `n_neighbors={actual_value.n_neighbors}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `KNeighborsClassifier`."

        _dynamic_test(
            self,
            condition,
            "`best_model` is a `KNeighborsClassifier` with `27` neighbors.",
            failure_message
        )

    def test_best_score_is_declared(self):
        import user_code

        variable = 'best_score'
        _dynamic_test(
            self,
            hasattr(user_code, variable),
            f"The `{variable}` variable is declared.",
            f"Expected `{variable}` to be declared."
        )

    def test_best_score_is_correct(self):
        import user_code
        expected_value = 0.8039505464098539

        variable = 'best_score'
        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, float):
            condition = actual_value == expected_value
            failure_message = f"Expected `{variable}` to contain `{expected_value}`, but got `{actual_value}`."
        else:
            condition = False
            failure_message = f"`{variable}` is not a `float`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` is correct.",
            failure_message
        )


if __name__ == '__main__':
    unittest.main()

test_main.py

Beherrschen Sie die grundlegenden Klassifikationsalgorithmen, die moderne Machine-Learning-Anwendungen antreiben. Erforschen Sie, wie Modelle wie k-NN, logistische Regression, Entscheidungsbäume und Random Forests Vorhersagen treffen, deren Genauigkeit bewerten und verstehen, wann welches Modell eingesetzt wird. Entwickeln Sie die Fähigkeiten, Modelle zu vergleichen und das beste für Ihre Daten auszuwählen.

Erfahren Sie, wie der k-nächste-Nachbarn-Algorithmus Vorhersagen auf Basis von Ähnlichkeiten trifft. Umgang mit mehreren Merkmalen, Parametereinstellung und Anwendung von Kreuzvalidierung zur Verbesserung der Genauigkeit.

Verstehen, wie die logistische Regression Wahrscheinlichkeiten modelliert und Ergebnisse klassifiziert. Anwendung der Implementierung, Interpretation von Entscheidungsgrenzen und Einsatz von Regularisierung zur Vermeidung von Overfitting.

Erfahren Sie, wie Entscheidungsbäume Daten anhand von Merkmalswerten in sinnvolle Gruppen unterteilen. Untersuchen Sie, wie Parameter wie Baumtiefe und minimale Stichprobengröße pro Blatt die Modellleistung und Generalisierung beeinflussen.

Erkunden, wie Random Forests mehrere Entscheidungsbäume kombinieren, um Genauigkeit und Robustheit zu verbessern.
Die Rolle des Zufalls verstehen und diese Ensemble-Methode auf reale Daten anwenden.

Bewertung von Modellen anhand von Metriken wie Genauigkeit, Präzision, Recall und F1-Score. Interpretation von Konfusionsmatrizen und Vergleich mehrerer Klassifikatoren zur Identifikation des leistungsstärksten Modells.

Herausforderung: Auswahl des optimalen K-Werts

Lösung