Comme montré dans les chapitres précédents, les prédictions du modèle peuvent varier en fonction de la valeur de **k** (le nombre de voisins). Lors de la construction d’un modèle k-NN, il est important de choisir la valeur de k qui offre la **meilleure performance**.

Une approche courante consiste à utiliser la **validation croisée** pour évaluer la performance du modèle. Il est possible d’exécuter une boucle et de calculer les scores de validation croisée **pour une plage de valeurs de k**, puis de sélectionner celle qui obtient le meilleur score. Il s’agit de la méthode la plus largement utilisée.

Pour réaliser cela, `sklearn` propose un outil pratique : la classe `GridSearchCV`.

Le paramètre `param_grid` prend un **dictionnaire** dont les clés sont les noms des paramètres et les valeurs sont des listes d’options à tester. Par exemple, pour tester les valeurs de `1` à `99` pour `n_neighbors`, on peut écrire :
```python
param_grid = {'n_neighbors': range(1, 100)}
```
L’appel de la méthode `.fit(X, y)` sur l’objet `GridSearchCV` va parcourir la grille de paramètres pour trouver les meilleurs paramètres puis **réentraîner le modèle sur l’ensemble du jeu de données** en utilisant ces meilleurs paramètres.

Il est possible d’accéder au **meilleur score** via l’attribut `.best_score_` et de faire des prédictions avec le modèle optimisé en utilisant la méthode `.predict()`. De même, il est possible de récupérer le **meilleur modèle** lui-même via l’attribut `.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

Maîtrisez les principaux algorithmes de classification qui alimentent l'apprentissage automatique moderne. Découvrez comment des modèles tels que k-NN, la régression logistique, les arbres de décision et les forêts aléatoires effectuent des prédictions, évaluez leur précision et comprenez quand utiliser chacun d'eux. Développez les compétences nécessaires pour comparer les modèles et choisir le plus adapté à vos données.

Découvrez comment l'algorithme des k plus proches voisins effectue des prédictions basées sur la similarité. Apprenez à gérer plusieurs caractéristiques, à ajuster les paramètres et à appliquer la validation croisée pour améliorer la précision.

Comprendre comment la régression logistique modélise les probabilités et classe les résultats. S'exercer à l'implémenter, à interpréter les frontières de décision et à appliquer la régularisation pour éviter le surapprentissage.

Découvrez comment les arbres de décision divisent les données en groupes significatifs selon les valeurs des caractéristiques. Explorez l'influence de paramètres tels que la profondeur de l'arbre et le nombre minimal d'échantillons par feuille sur la performance et la généralisation du modèle.

Découvrez comment les forêts aléatoires combinent plusieurs arbres de décision pour améliorer la précision et la robustesse. Comprenez le rôle de l'aléatoire et appliquez cette méthode d'ensemble à des données réelles.

Évaluation des modèles à l'aide de métriques telles que l'exactitude, la précision, le rappel et le score F1. Interprétation des matrices de confusion et comparaison de plusieurs classificateurs afin d'identifier le modèle le plus performant.

Défi : Choisir la Meilleure Valeur de K

Solution