Zoals getoond in de vorige hoofdstukken kunnen de voorspellingen van het model variëren afhankelijk van de waarde van **k** (het aantal buren). Bij het bouwen van een k-NN-model is het belangrijk om de k-waarde te kiezen die de **beste prestaties** oplevert.

Een veelgebruikte methode is het gebruik van **cross-validatie** om de modelprestaties te evalueren. Je kunt een lus uitvoeren en cross-validatiescores **voor een reeks k-waarden** berekenen, waarna je de waarde met de hoogste score selecteert. Dit is de meest gebruikte methode.

Om dit uit te voeren biedt `sklearn` een handig hulpmiddel: de `GridSearchCV`-klasse.

De parameter `param_grid` neemt een **dictionary** waarbij de sleutels parameternamen zijn en de waarden lijsten met opties om te proberen. Om bijvoorbeeld waarden van `1` tot `99` voor `n_neighbors` te testen, kun je het volgende schrijven:
```python
param_grid = {'n_neighbors': range(1, 100)}
```
Door de methode `.fit(X, y)` aan te roepen op het `GridSearchCV`-object wordt het parameterrooster doorzocht om de beste parameters te vinden en vervolgens wordt het model **opnieuw getraind op de volledige dataset** met deze beste parameters.

Je kunt de **beste score** opvragen met het attribuut `.best_score_` en voorspellingen doen met het geoptimaliseerde model via de methode `.predict()`. Op dezelfde manier kun je het **beste model** zelf ophalen met het attribuut `.best_estimator_`.

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

Beheers de kernclassificatie-algoritmen die moderne machine learning aandrijven. Ontdek hoe modellen zoals k-NN, logistische regressie, beslissingsbomen en random forests voorspellingen doen, hun nauwkeurigheid evalueren en begrijp wanneer elk model te gebruiken. Ontwikkel vaardigheden om modellen te vergelijken en de beste keuze te maken voor uw data.

Ontdek hoe het k-nearest neighbors-algoritme voorspellingen doet op basis van gelijkenis. Leer omgaan met meerdere kenmerken, parameters afstemmen en kruisvalidatie toepassen om de nauwkeurigheid te verbeteren.

Inzicht in hoe logistische regressie waarschijnlijkheden modelleert en uitkomsten classificeert. Oefenen met het implementeren ervan, het interpreteren van beslissingsgrenzen en het toepassen van regularisatie om overfitting te voorkomen.

Leer hoe beslisbomen gegevens opdelen in betekenisvolle groepen op basis van kenmerkwaarden. Ontdek hoe parameters zoals boomdiepte en het minimum aantal monsters per blad de modelprestaties en generalisatie beïnvloeden.

Ontdek hoe random forests meerdere beslissingsbomen combineren om de nauwkeurigheid en robuustheid te verbeteren. Begrijp de rol van willekeur en pas deze ensemblemethode toe op real-world data.

Modellen evalueren met behulp van metriek zoals nauwkeurigheid, precisie, recall en F1-score. Interpretatie van verwarringsmatrices en vergelijking van meerdere classificatie-algoritmen om het best presterende model te identificeren.

Uitdaging: De Beste K-Waarde Kiezen

Oplossing