Som vist i de foregående kapitler, kan modellens forudsigelser variere afhængigt af værdien af **k** (antallet af naboer). Når der opbygges en k-NN-model, er det vigtigt at vælge den k-værdi, der giver den **bedste ydeevne**.

En almindelig tilgang er at anvende **krydsvalidering** til at evaluere modellens ydeevne. Du kan køre et loop og beregne krydsvalideringsscore **for et interval af k-værdier**, og derefter vælge den med den højeste score. Dette er den mest udbredte metode.

Til dette formål tilbyder `sklearn` et praktisk værktøj: klassen `GridSearchCV`.

Parameteren `param_grid` tager et **dictionary**, hvor nøglerne er parameternavne og værdierne er lister over muligheder, der skal afprøves. For eksempel, for at teste værdier fra `1` til `99` for `n_neighbors`, kan du skrive:
```python
param_grid = {'n_neighbors': range(1, 100)}
```
Ved at kalde `.fit(X, y)`-metoden på `GridSearchCV`-objektet vil parametergridet blive gennemgået for at finde de bedste parametre, hvorefter modellen **gen-trænes på hele datasættet** med disse bedste parametre.

Du kan tilgå den **bedste score** via attributten `.best_score_` og lave forudsigelser med den optimerede model ved hjælp af `.predict()`-metoden. Tilsvarende kan du hente **den bedste model** selv ved at bruge attributten `.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

Behersk de centrale klassifikationsalgoritmer, der driver moderne maskinlæring. Udforsk hvordan modeller som k-NN, logistisk regression, beslutningstræer og random forests foretager forudsigelser, evaluerer deres nøjagtighed, og forstå hvornår hver model bør anvendes. Opbyg færdigheder til at sammenligne modeller og vælge den bedste til dine data.

Opdag, hvordan k-nærmeste naboer-algoritmen foretager forudsigelser baseret på lighed. Lær at håndtere flere egenskaber, justere parametre og anvende krydsvalidering for at forbedre nøjagtigheden.

Forstå, hvordan logistisk regression modellerer sandsynligheder og klassificerer udfald. Øv implementering, fortolkning af beslutningsgrænser og anvendelse af regularisering for at forhindre overfitting.

Lær, hvordan beslutningstræer opdeler data i meningsfulde grupper baseret på featureværdier. Udforsk, hvordan parametre som trædybde og minimum antal prøver per blad påvirker modellens ydeevne og generalisering.

Undersøg, hvordan random forests kombinerer flere beslutningstræer for at forbedre nøjagtighed og robusthed. Forstå betydningen af tilfældighed og anvend denne ensemble-metode på virkelige data.

Evaluering af modeller ved hjælp af metrikker såsom nøjagtighed, præcision, recall og F1-score. Lær at fortolke forvekslingsmatrixer og sammenligne flere klassifikatorer for at identificere den bedst præsterende model.

Udfordring: Valg af den Bedste K-værdi

Løsning