Wie in den vorherigen Kapiteln gezeigt, können die Vorhersagen des Modells je nach Wert von **k** (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-Scores **für verschiedene k-Werte** berechnet werden, wobei anschließend der Wert mit dem höchsten Score ausgewählt wird. Dies ist die am weitesten verbreitete Methode.

Dafür bietet `sklearn` ein praktisches Werkzeug: die Klasse `GridSearchCV`.


### Konstruktor:
* `GridSearchCV(estimator, param_grid, scoring, cv = 5)`
* `estimator` — das Modellobjekt;
* `param_grid` — Dictionary mit den zu durchsuchenden Parameterwerten;
    * `scoring` — die Metrik zur Bewertung des Cross-Validation-Scores;
* `cv` — die Anzahl der Folds (standardmäßig 5);

### Methoden:
* `fit(X, y)` — trainiert die Modelle mit X, y;
* `predict(X)` — sagt die Klasse für X voraus;
* `score(X, y)` — gibt die Genauigkeit für das X, y-Set zurück;

### Attribute:
* `best_estimator_` — Objekt des Modells mit dem höchsten Score;
* `best_score_` — der Score des `best_estimator_`.

Der Parameter `param_grid` erwartet ein **Dictionary**, bei dem die Schlüssel die Parameternamen und die Werte Listen mit auszuprobierenden Optionen sind. Um beispielsweise Werte von `1` bis `99` für `n_neighbors` zu testen, kann Folgendes geschrieben werden:
```python
param_grid = {'n_neighbors': range(1, 100)}
```
Durch Aufruf der Methode `.fit(X, y)` auf dem `GridSearchCV`-Objekt wird das Parameter-Grid 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, und 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

Beherrschung der grundlegenden Algorithmen des überwachten Lernens und deren Implementierung mit Scikit-learn. Untersuchung von linearer und polynomialer Regression zur Preisvorhersage sowie Übergang zur Klassifikation mit k-NN, logistischer Regression und Entscheidungsbäumen. Bewertung von Modellen durch Kreuzvalidierung, Steuerung von Overfitting mittels Regularisierung und Optimierung von Hyperparametern. Aufbau robuster prädiktiver Systeme und Definition komplexer Entscheidungsgrenzen für Aufgaben der Mehrklassenklassifikation.

Herausforderung: Auswahl des optimalen K-Werts

Konstruktor:

Methoden:

Attribute:

Lösung