Évaluation et réglage des modèles Sklearn

L'évaluation et le réglage des modèles d'apprentissage automatique sont des étapes clés pour garantir la capacité de généralisation et la précision des prédictions du modèle.

Grâce à des métriques d'évaluation et des méthodes de réglage appropriées, les performances du modèle peuvent être efficacement améliorées, en évitant le risque de surapprentissage ou de sous-apprentissage.

Ce chapitre présentera en détail la validation croisée, la recherche par grille, la recherche aléatoire, les méthodes d'évaluation de modèle et d'autres contenus.


1. Validation croisée

Présenter le concept de validation croisée

La validation croisée est une technique utilisée pour évaluer les performances d'un modèle. Elle divise le jeu de données en plusieurs sous-ensembles (plis) et entraîne et teste le modèle plusieurs fois afin d'obtenir des résultats d'évaluation plus stables et fiables.

La validation croisée aide à détecter si le modèle est en surapprentissage, et permet d'évaluer plus précisément la capacité de généralisation du modèle.

Les méthodes courantes de validation croisée comprennent :

  • Validation croisée K-fold: Diviser les données en K plis, sélectionner un pli comme ensemble de test à tour de rôle, utiliser les autres K-1 plis comme ensemble d'entraînement, répéter K fois, et enfin calculer la moyenne des K résultats.
  • Validation croisée leave-one-out (LOOCV): Ne conserver qu'un seul point de données comme ensemble de test à chaque fois, et le reste comme ensemble d'entraînement. Cette méthode est très chronophage mais peut être utilisée pour de petits jeux de données.
  • Validation croisée K-fold stratifiée: Dans la validation croisée K-fold, s'assurer que la distribution des classes dans chaque pli est similaire à celle de l'ensemble du jeu de données, adaptée aux situations de déséquilibre de classes.

scikit-learn fournit plusieurs méthodes de validation croisée, telles que cross_val_score et cross_val_predict, qui peuvent nous aider à effectuer efficacement la validation croisée.

Utiliser cross_val_score pour effectuer une validation croisée K-fold

La fonction cross_val_score est utilisée pour effectuer une validation croisée K-fold, renvoyant le score de chaque pli pour nous aider à évaluer la stabilité et les performances du modèle.

Utiliser cross_val_score pour effectuer une validation croisée en K plis :

Exemple

from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris

# Charger les données
data = load_iris()
X, y = data.data, data.target

# Créer le modèle
model = RandomForestClassifier()

# Effectuer une validation croisée en K plis
scores = cross_val_score(model, X, y, cv=5)  # validation croisée à 5 plis
print(f"Scores de validation croisée : {scores}")
print(f"Exactitude moyenne : {scores.mean()}")
  • cv=5: Indique l'utilisation d'une validation croisée à 5 plis.
  • scores: Renvoie le score de chaque pli, et le résultat final est la moyenne de ces scores, représentant la performance du modèle.

La sortie est la suivante :

Cross-validation scores: [0.96666667 0.96666667 0.93333333 0.96666667 1.        ]
Mean accuracy: 0.9666666666666668

2. Recherche par grille et recherche aléatoire

Utiliser GridSearchCV pour l'optimisation des hyperparamètres

GridSearchCV est une technique qui trouve les meilleurs hyperparamètres en parcourant exhaustivement toutes les combinaisons d'hyperparamètres.

GridSearchCV calcule la performance de chaque combinaison en fournissant un ensemble de valeurs candidates pour les paramètres, puis sélectionne finalement la meilleure combinaison de paramètres.

Paramètres courants de GridSearchCV :

  • param_grid: La grille d'hyperparamètres à ajuster, généralement un dictionnaire, où les clés sont les noms des paramètres et les valeurs sont les valeurs candidates des paramètres.
  • cv: Le nombre de plis pour la validation croisée, généralement fixé à 5 ou 10.

Exemple d'utilisation de GridSearchCV avec scikit-learn :

Exemple

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVC
from sklearn.datasets import load_iris

# Charger les données
data = load_iris()
X, y = data.data, data.target

# Créer le modèle
model = SVC()

# Définir la grille d'hyperparamètres
param_grid = {'kernel': ['linear', 'rbf'], 'C': [1, 10, 100]}

# Effectuer la recherche sur grille
grid_search = GridSearchCV(model, param_grid, cv=5)
grid_search.fit(X, y)

# Afficher les meilleurs paramètres et le meilleur score
print(f"Meilleurs paramètres : {grid_search.best_params_}")
print(f"Meilleur score : {grid_search.best_score_}")
  • grid_search.best_params_: Renvoie la combinaison d'hyperparamètres la plus performante dans la recherche sur grille.
  • grid_search.best_score_: Renvoie le score de validation croisée pour la meilleure combinaison de paramètres.

La sortie est la suivante :

Best parameters: {'C': 1, 'kernel': 'linear'}
Best score: 0.9800000000000001

Utilisez RandomizedSearchCV pour accélérer le processus de réglage

RandomizedSearchCV est une méthode de réglage des hyperparamètres plus efficace qui accélère le processus de réglage en sélectionnant aléatoirement un certain nombre de combinaisons dans l'espace des hyperparamètres pour évaluation.

RandomizedSearchCV est adapté aux grands espaces d'hyperparamètres et peut permettre d'économiser du temps de calcul.

Paramètres courants de RandomizedSearchCV :

  • param_distributions: La distribution des hyperparamètres à régler, généralement un dictionnaire, où les valeurs peuvent être des objets de distribution (tels quescipy.statsdistributions dans) ou une liste de valeurs discrètes.
  • n_iter: Le nombre d'itérations pour la recherche aléatoire, c'est-à-dire le nombre de combinaisons d'hyperparamètres sélectionnées aléatoirement.

Exemple d'utilisation de RandomizedSearchCV avec scikit-learn :

Exemple

from sklearn.model_selection import RandomizedSearchCV
from sklearn.svm import SVC
from sklearn.datasets import load_iris
from scipy.stats import uniform

# Charger les données
data = load_iris()
X, y = data.data, data.target

# Créer le modèle
model = SVC()

# Définir la distribution des hyperparamètres
param_distributions = {'C': uniform(0, 10), 'kernel': ['linear', 'rbf']}

# Effectuer une recherche aléatoire
random_search = RandomizedSearchCV(model, param_distributions, n_iter=10, cv=5)
random_search.fit(X, y)

# Afficher les meilleurs paramètres et le meilleur score
print(f"Meilleurs paramètres : {random_search.best_params_}")
print(f"Meilleur score : {random_search.best_score_}")
  • random_search.best_params_: Renvoie la combinaison d'hyperparamètres la plus performante lors de la recherche aléatoire.
  • random_search.best_score_: Renvoie le score de validation croisée pour la meilleure combinaison de paramètres.

La sortie est la suivante :

Best parameters: {'C': 8.355688344706016, 'kernel': 'rbf'}
Best score: 0.9866666666666667

3. Évaluation du modèle

Utiliser classification_report, confusion_matrix, roc_auc_score

Pour les modèles de classification, nous utilisons généralement des métriques telles que la précision, le rappel et le score F1 pour évaluer les performances du modèle.

scikit-learn fournit de nombreux outils d'évaluation pour nous aider à comprendre en profondeur les performances du modèle.

classification_report- Fournit des informations telles que la précision, le rappel, le score F1 et le support (le nombre d'échantillons dans chaque classe).

Exemple

from sklearn.metrics import classification_report

# Supposons que y_test contient les vraies étiquettes et y_pred les résultats de prédiction du modèle
print(classification_report(y_test, y_pred))

confusion_matrix- La matrice de confusion est utilisée pour afficher les performances d'un modèle de classification sur chaque classe, en particulier comment les classes positives sont prédites comme des classes négatives, et vice versa.

Exemple

from sklearn.metrics import confusion_matrix

# Supposons que y_test contient les vraies étiquettes et y_pred les résultats de prédiction du modèle
print(confusion_matrix(y_test, y_pred))

roc_auc_score- ROC AUC (Area Under the Receiver Operating Characteristic Curve) est une métrique pour évaluer les performances d'un modèle de classification, particulièrement adaptée aux jeux de données déséquilibrés. Plus la valeur de l'AUC est élevée, meilleures sont les performances du modèle.

Exemple

from sklearn.metrics import roc_auc_score

# Supposons que y_test correspond aux étiquettes vraies, y_pred_proba aux valeurs de probabilité prédites par le modèle
print(f"Score ROC AUC : {roc_auc_score(y_test, y_pred_proba)}")

Évaluation du modèle de régression : mean_squared_error, r2_score

Pour les problèmes de régression, les métriques d'évaluation couramment utilisées incluent l'erreur quadratique moyenne (MSE) et le coefficient de détermination (R²).

mean_squared_error- L'erreur quadratique moyenne est un critère d'évaluation courant pour les modèles de régression, calculant la moyenne des erreurs au carré entre les valeurs prédites et les valeurs vraies.

Exemple

from sklearn.metrics import mean_squared_error

# Supposons que y_test correspond aux valeurs vraies, y_pred aux valeurs prédites
print(f"Erreur quadratique moyenne : {mean_squared_error(y_test, y_pred)}")

r2_score- Le coefficient de détermination R² est utilisé pour mesurer dans quelle mesure le modèle s'ajuste aux données. Plus la valeur est proche de 1, meilleur est l'ajustement du modèle.

Exemple

from sklearn.metrics import r2_score

# Supposons que y_test correspond aux valeurs vraies, y_pred aux valeurs prédites
print(f"Score R² : {r2_score(y_test, y_pred)}")
Autres extensions