Évaluation de modèle Scikit-learn

Introduction

Après avoir entraîné un modèle d'apprentissage automatique, il est crucial d'évaluer ses performances pour comprendre dans quelle mesure il généralise à de nouvelles données inédites. Scikit-learn, une puissante bibliothèque Python pour l'apprentissage automatique, fournit un ensemble complet d'outils pour l'évaluation de modèles dans son module sklearn.metrics.

Dans ce laboratoire, vous apprendrez à évaluer un modèle de classification en utilisant certaines des métriques les plus courantes. Nous utiliserons un ensemble prédéfini d'étiquettes réelles et d'étiquettes prédites pour nous concentrer uniquement sur le processus d'évaluation. Vous apprendrez à calculer :

• Accuracy Score (Score de précision)
• Confusion Matrix (Matrice de confusion)
• Precision Score (Score de précision)
• Recall Score (Score de rappel)
• F1 Score (Score F1)

À la fin de ce laboratoire, vous maîtriserez l'utilisation de ces fonctions fondamentales de scikit-learn pour évaluer les performances de vos modèles de classification.

Calculer le score d'accuracy avec accuracy_score de sklearn.metrics

Dans cette étape, nous allons calculer la précision des prédictions de notre modèle. La précision est l'une des métriques de classification les plus simples. Elle mesure le rapport entre les instances correctement prédites et le nombre total d'instances.

La fonction accuracy_score de sklearn.metrics calcule cette valeur. Elle prend les étiquettes réelles et les étiquettes prédites comme arguments.

Tout d'abord, ouvrez le fichier evaluate.py depuis l'explorateur de fichiers sur la gauche. Le fichier contient déjà les listes y_true et y_pred. Ajoutez maintenant le code suivant à la fin du fichier pour importer la fonction accuracy_score, calculer la précision et afficher le résultat.

from sklearn.metrics import accuracy_score

## Calculate accuracy
accuracy = accuracy_score(y_true, y_pred)

print(f"Accuracy: {accuracy}")

Votre fichier evaluate.py complet devrait maintenant ressembler à ceci :

## In this lab, we will use a predefined set of true labels and predicted labels
## to understand different evaluation metrics.

## y_true represents the actual, ground truth labels for our data points.
## For a binary classification, 0 could mean 'negative' and 1 could mean 'positive'.
y_true = [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]

## y_pred represents the labels predicted by our hypothetical classification model.
y_pred = [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]

print("Setup complete. True and predicted labels are defined in evaluate.py.")
print(f"True labels:    {y_true}")
print(f"Predicted labels: {y_pred}")

from sklearn.metrics import accuracy_score

## Calculate accuracy
accuracy = accuracy_score(y_true, y_pred)

print(f"Accuracy: {accuracy}")

Maintenant, exécutons le script. Ouvrez le terminal dans votre IDE et exécutez la commande suivante :

python3 evaluate.py

Vous devriez voir la sortie suivante, qui inclut le score de précision. Une précision de 0.8 signifie que 80 % des prédictions étaient correctes.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8

Générer la matrice de confusion avec confusion_matrix de sklearn.metrics

Dans cette étape, nous allons générer une matrice de confusion. Bien que la précision donne un résumé rapide des performances, elle peut être trompeuse, en particulier pour les ensembles de données déséquilibrés. Une matrice de confusion fournit une ventilation plus détaillée des performances d'un classifieur en montrant le nombre de prédictions correctes et incorrectes pour chaque classe.

La matrice est un tableau avec quatre combinaisons de valeurs prédites et réelles :

• Vrais Négatifs (TN - True Negatives) : Le modèle a correctement prédit la classe négative.
• Faux Positifs (FP - False Positives) : Le modèle a incorrectement prédit la classe positive.
• Faux Négatifs (FN - False Negatives) : Le modèle a incorrectement prédit la classe négative.
• Vrais Positifs (TP - True Positives) : Le modèle a correctement prédit la classe positive.

Nous utiliserons la fonction confusion_matrix de sklearn.metrics. Ajoutez le code suivant à la fin de votre fichier evaluate.py.

from sklearn.metrics import confusion_matrix

## Generate confusion matrix
cm = confusion_matrix(y_true, y_pred)

print("Confusion Matrix:")
print(cm)

Maintenant, exécutez à nouveau le script depuis le terminal :

python3 evaluate.py

La sortie inclura maintenant la matrice de confusion.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]

Cette matrice nous indique :

• TN = 4 (En haut à gauche)
• FP = 1 (En haut à droite)
• FN = 1 (En bas à gauche)
• TP = 4 (En bas à droite)

Calculer le score de précision avec precision_score de sklearn.metrics

Dans cette étape, nous allons calculer le score de précision. La précision répond à la question : "Parmi toutes les instances que le modèle a prédites comme positives, quelle proportion était réellement positive ?" C'est une mesure de l'exactitude d'un classifieur.

La précision est calculée comme suit : Précision = Vrais Positifs / (Vrais Positifs + Faux Positifs)

Une faible précision indique un nombre élevé de faux positifs. Nous utiliserons la fonction precision_score de sklearn.metrics.

Ajoutez le code suivant à la fin de votre fichier evaluate.py pour calculer et afficher la précision.

from sklearn.metrics import precision_score

## Calculate precision
precision = precision_score(y_true, y_pred)

print(f"Precision: {precision}")

Exécutez le script depuis le terminal :

python3 evaluate.py

Vous verrez le score de précision ajouté à la sortie. D'après notre matrice de confusion (TP=4, FP=1), la précision est de 4 / (4 + 1) = 0.8.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]
Precision: 0.8

Calculer le score de rappel avec recall_score de sklearn.metrics

Dans cette étape, nous allons calculer le score de rappel. Le rappel, également connu sous le nom de sensibilité ou taux de vrais positifs, répond à la question : "Parmi toutes les instances positives réelles, quelle proportion le modèle a-t-il correctement identifiée ?" C'est une mesure de l'exhaustivité d'un classifieur.

Le rappel est calculé comme suit : Rappel = Vrais Positifs / (Vrais Positifs + Faux Négatifs)

Un faible rappel indique un nombre élevé de faux négatifs. Nous utiliserons la fonction recall_score de sklearn.metrics.

Ajoutez le code suivant à la fin de votre fichier evaluate.py.

from sklearn.metrics import recall_score

## Calculate recall
recall = recall_score(y_true, y_pred)

print(f"Recall: {recall}")

Exécutez le script depuis le terminal :

python3 evaluate.py

La sortie inclura maintenant le score de rappel. D'après notre matrice de confusion (TP=4, FN=1), le rappel est de 4 / (4 + 1) = 0.8.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]
Precision: 0.8
Recall: 0.8

Calculer le score F1 avec f1_score de sklearn.metrics

Dans cette dernière étape, nous allons calculer le score F1. Le score F1 est la moyenne harmonique de la précision et du rappel. Il cherche à trouver un équilibre entre les deux. Alors que la précision se concentre sur la minimisation des faux positifs et le rappel sur la minimisation des faux négatifs, le score F1 fournit une métrique unique qui prend en compte les deux.

Le score F1 est calculé comme suit : Score F1 = 2 * (Précision * Rappel) / (Précision + Rappel)

Il est particulièrement utile lorsque vous avez besoin d'un équilibre entre la précision et le rappel et lorsqu'il existe une distribution de classes inégale. Nous utiliserons la fonction f1_score de sklearn.metrics.

Ajoutez la dernière partie du code à votre fichier evaluate.py.

from sklearn.metrics import f1_score

## Calculate F1 score
f1 = f1_score(y_true, y_pred)

print(f"F1 Score: {f1}")

Exécutez le script une dernière fois depuis le terminal :

python3 evaluate.py

La sortie finale affichera toutes les métriques que nous avons calculées. Avec une précision et un rappel de 0.8, le score F1 sera également de 0.8.

Setup complete. True and predicted labels are defined in evaluate.py.
True labels:    [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]
Predicted labels: [0, 1, 0, 0, 1, 1, 0, 1, 0, 1]
Accuracy: 0.8
Confusion Matrix:
[[4 1]
 [1 4]]
Precision: 0.8
Recall: 0.8
F1 Score: 0.8

Résumé

Félicitations pour avoir terminé le laboratoire ! Vous avez appris avec succès à évaluer un modèle de classification à l'aide de plusieurs métriques clés de la bibliothèque scikit-learn.

Dans ce laboratoire, vous avez pratiqué :

• Le calcul de l'accuracy (précision globale) avec accuracy_score pour avoir une idée générale des performances du modèle.
• La génération d'une matrice de confusion (confusion matrix) avec confusion_matrix pour obtenir une vue détaillée des vrais/faux positifs et négatifs.
• Le calcul de la precision (précision) avec precision_score pour mesurer l'exactitude du modèle.
• Le calcul du recall (rappel) avec recall_score pour mesurer l'exhaustivité du modèle.
• Le calcul du score F1 avec f1_score pour trouver un équilibre entre la précision et le rappel.

Ces métriques sont des outils fondamentaux pour tout scientifique des données ou ingénieur en apprentissage automatique. Leur compréhension vous permet de mieux diagnostiquer les forces et les faiblesses de votre modèle et de choisir le bon modèle pour votre problème spécifique.