Métriques de classification

Dans le monde de l'apprentissage automatique, construire un modèle de classification n'est que la première étape. Tout comme un médecin ne peut pas juger une maladie par simple intuition, nous avons aussi besoin d'un ensemble de mesures scientifiquesde contrôle de santépour évaluer la santé du modèle. Ces métriques sontmétriques de classification, qui peuvent nous dire à quel point les prédictions du modèle sont précises, ce qu'il fait bien et où il échoue.

Aujourd'hui, nous allons découvrir ensemble ces outils d'évaluation essentiels.


Pourquoi avons-nous besoin de métriques de classification ?

Imaginez que vous avez entraîné un modèle pour identifier si un e-mail est un spam. Le modèle a fait des prédictions sur 100 e-mails, et vous pourriez demander :

  • "Combien en a-t-il prédit correctement ?" -> Cela mène àl'exactitude。
  • "Parmi les e-mails qui sont réellement du spam, combien en a-t-il trouvés ?" -> Cela mène aurappel。
  • « Parmi les e-mails qu'il a déclarés comme spam, combien sont réellement du spam ? » -> Cela mène àla précision。

Si nous jugeons uniquement par le nombre de réponses correctes, c'est comme évaluer un étudiant uniquement par sa note totale à l'examen, en ignorant beaucoup d'informations importantes. Différents scénarios métier ont des priorités différentes :

  • Diagnostic médical: Nous tenons davantage à ne manquer aucun patient (rappel élevé), même si cela signifie examiner plus de personnes en bonne santé (sacrifier un peu de précision).
  • Filtrage des spams: Nous tenons davantage à ne pas jeter d'e-mails importants dans le dossier des indésirables (précision élevée), même si cela signifie manquer certains e-mails indésirables (sacrifier un peu de rappel).

Par conséquent, nous avons besoin d'une série de métriques pour évaluer de manière complète les performances du modèle sous différents angles.


Concept clé : Matrice de confusion

Presque toutes les métriques de classification proviennent d'un outil puissant —la matrice de confusion.Il s'agit d'une « carte panoramique » pour comprendre les résultats de prédiction du modèle.

Qu'est-ce qu'une matrice de confusion ?

C'est un tableau qui montre les quatre situations possibles entre les résultats prédits par le modèle et les vraies étiquettes.

Exemple

# Un exemple de matrice de confusion (avec une classification binaire « spam / non spam » comme exemple)
from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

# Supposons que nous ayons les vraies étiquettes et les étiquettes prédites
y_true = [1, 0, 1, 1, 0, 0, 1, 0, 0, 1]  # 1 représente un spam, 0 représente un e-mail normal
y_pred = [1, 0, 0, 1, 0, 0, 1, 1, 0, 1]  # Prédictions du modèle

# Calculer la matrice de confusion
cm = confusion_matrix(y_true, y_pred)
print("Matrice de confusion :")
print(cm)
# La sortie pourrait être :
# [[4 1] # La vraie valeur est 0 (normal), 4 prédits comme 0 (TN), 1 prédit comme 1 (FP)
# [1 4]] # La vraie valeur est 1 (spam), 1 prédit comme 0 (FN), 4 prédits comme 1 (TP)

Pour mieux le comprendre, visualisons-le :

Décomposons ces quatre termes essentiels :

Terme Abréviation Signification Explication dans l'exemple du spam
Vrai positif TP Le modèle a prédit commecorrect, et la réalité est aussicorrecte。 Correctement identifiés par le modèleles courriels indésirables。
Faux positif FP Le modèle a prédit commecorrect, mais la réalité estnégative。 Le modèleclasse à tortcomme spamles courriels normaux。 (Erreur de type I)
Vrai négatif TN Le modèle a prédit commenégatif, et la réalité est aussinégative。 Correctement identifiés par le modèleles courriels normaux。
Faux négatif FN Le modèle a prédit commenégatif, mais la réalité estcorrecte。 Le modèlea manquédescourriels indésirables。 (Erreur de type II)

Astuce mnémotechnique:

  • Vrai/Fauxfait référence àsi la prédiction est correcte。
  • Positif/Négatifdésignele résultat de prédiction du modèle。

3. Explication détaillée des métriques de classification principales

Avec la matrice de confusion, nous pouvons dériver diverses métriques d'évaluation, tout comme en calculant avec des formules.

1. Exactitude - La métrique la plus intuitive

Exactitudemesure la proportion d'échantillons correctement prédits sur l'ensemble des échantillons.

\[ \text{Accuracy} = \frac{TP + TN}{TP + TN + FP + FN} \]

Exemple

from sklearn.metrics import accuracy_score

exactitude = accuracy_score(y_true, y_pred)
print(f"Accuracy: {accuracy:.2f}")  # Output: 0.80 (8/10)

Caractéristiques et limites:

  • Avantages: Très intuitif et facile à comprendre.
  • Inconvénients: Dansles données déséquilibrées,cela peut être trompeur. Par exemple, si 99% des e-mails sont normaux, un « modèle naïf » qui prédit tous les e-mails comme normaux peut aussi atteindre 99% d'exactitude, mais il ne peut pas détecter un seul e-mail spam.

2. Précision - La métrique « Qualité plutôt que quantité »

La précisionse concentre sur le nombre d'échantillons positifs prédits par le modèlequi sont réellement de vrais positifs. Elle mesure lafiabilitédes résultats de prédiction ouet la précision.。

\[ \text{Precision} = \frac{TP}{TP + FP} \]

Question: Parmi les e-mails que nous avons prédits comme spam, combien sont réellement du spam ?Une précision élevée signifie: Lorsque le modèle dit « ceci est du spam », la crédibilité est très élevée.

Exemple

from sklearn.metrics import precision_score

précision = precision_score(y_true, y_pred)
print(f"Précision : {precision:.2f}")  # Sortie : 0.80 (TP=4, TP+FP=5)

3. Rappel - La métrique « Mieux vaut ratisser large »

Le rappelse concentre sur tous les échantillons réellementpositifscombien ont été trouvés par le modèle. Il mesure la capacité du modèleà découvrir des échantillons positifs.。

\[ \text{Rappel} = \frac{TP}{TP + FN} \]

Question: Sur tous les e-mails spam réels, combien en avons-nous trouvés ?Un rappel élevé signifie: Le modèle rate rarement de vrais e-mails spam.

Exemple

from sklearn.metrics import recall_score

recall = recall_score(y_true, y_pred)
print(f"Rappel : {recall:.2f}")  # Sortie : 0.80 (TP=4, TP+FN=5)

4. Score F1 - La moyenne harmonique de la précision et du rappel

La précision et le rappel sont généralement en tension (améliorer l'un abaisse souvent l'autre).Le score F1est la moyenne harmonique des deux, visant à trouver un équilibre.

\[ \text{Score F1} = 2 \times \frac{\text{Précision} \times \text{Rappel}}{\text{Précision} + \text{Rappel}} \]

Caractéristiques de la moyenne harmonique: Elle tend à pénaliser les valeurs extrêmes. Ce n'est que lorsque la précision et le rappel sont tous deux élevés que le score F1 sera élevé.

Exemple

from sklearn.metrics import f1_score

f1 = f1_score(y_true, y_pred)
print(f"Score F1 : {f1:.2f}")  # Sortie : 0.80

Guide de comparaison et de sélection des métriques

Métrique Formule Focus Exemples de scénarios d'application
Précision (TP+TN)/Total Exactitude globale des prédictions Scénarios où les classes sont équilibrées et les coûts des FP et des FN sont similaires.
Precision TP/(TP+FP) Prédits comme positifs :précision des échantillons. Coût élevé des faux positifs.Par exemple le filtrage des spams (peur de supprimer des e-mails importants), les systèmes de recommandation (peur de recommander des produits de mauvaise qualité).
Rappel TP/(TP+FN) Réellement positifsLa proportion d'échantillons détectés Le coût des FN est élevéComme le dépistage des maladies (peur d'un diagnostic manqué), la détection de fraude (peur de manquer des transactions frauduleuses).
Score F1 2PR/(P+R) Équilibre entre précision et rappel Scénarios nécessitant une prise en compte globale sans biais évident ; meilleur que l'exactitude lorsque les classes sont déséquilibrées.

4. Métriques avancées : courbe ROC et AUC

Lorsque le résultat de prédiction du modèle est une valeur de probabilité (par exemple, la probabilité qu'un e-mail soit un spam est de 0.8), nous devons définir unseuil(par exemple, 0.5) pour décider de la classification finale. La courbe ROC nous aide à évaluer la performance globale du modèle sous différents seuils.

1. Taux de vrais positifs et taux de faux positifs

  • Taux de vrais positifs (TPR): est en fait lerappel。TPR = TP / (TP + FN)
  • Taux de faux positifs (FPR): La proportion de tous les échantillons réellement négatifs qui sont incorrectement prédits comme positifs. FPR = FP / (FP + TN)

2. Courbe ROC

La courbe ROC utiliseFPR comme axe horizontal,TPR comme axe vertical. Chaque point de la courbe correspond à un seuil de classification spécifique.

  • Point idéal: coin supérieur gauche (0, 1), c'est-à-dire FPR=0 (aucun faux positif), TPR=1 (tous rappelés).
  • Ligne aléatoire: diagonale de (0,0) à (1,1), représentant la performance d'un modèle qui devine au hasard.

3. Valeur de l'AUC

L'AUC est l'aire sous la courbe ROC.

  • AUC = 1: modèle parfait.
  • AUC = 0.5: le modèle n'a aucune capacité discriminante, équivalent à deviner au hasard.
  • 0.5 < AUC < 1: le modèle a une certaine capacité prédictive, plus la valeur est élevée, mieux c'est.
  • AUC < 0.5: le modèle est moins bon que deviner au hasard, ce qui signifie généralement que le sens de la prédiction est inversé.

L'avantage de l'AUC est qu'ilest insensible au déséquilibre des classes, et qu'il évalue la capacité de classement globale du modèle (la capacité à classer les échantillons positifs avant les échantillons négatifs).

Exemple

from sklearn.metrics import roc_curve, auc
import numpy as np
import matplotlib.pyplot as plt
# Supposons que nous ayons des probabilités prédites (simulées ici avec des nombres aléatoires)
y_true = [1, 0, 1, 0, 1]
y_scores = [0.9, 0.4, 0.6, 0.3, 0.8]  # Probabilité que le modèle prédise un exemple positif

fpr, tpr, thresholds = roc_curve(y_true, y_scores)
roc_auc = auc(fpr, tpr)

print(f"Valeur AUC : {roc_auc:.2f}")

# Tracer la courbe ROC (facultatif, nécessite matplotlib)
plt.figure()
plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'Courbe ROC (aire = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--', label='Hasard')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('Taux de faux positifs')
plt.ylabel('Taux de vrais positifs')
plt.title('Courbe caractéristique de fonctionnement du récepteur (ROC)')
plt.legend(loc="lower right")
plt.show()

Sortie :

AUC 值: 1.00


Métriques pour les problèmes de classification multiclasse

Lorsqu'il y a plus de deux classes (par exemple, identifier des chats, des chiens, des lapins), les métriques ci-dessus peuvent être étendues de la manière suivante :

  1. Moyenne macro: calculez d'abord la métrique pour chaque classe (par ex., la précision), puis prenez la moyenne arithmétique des métriques de toutes les classes.Traiter chaque classe de manière égale。
  2. Moyenne micro: agrégez d'abord les TP, FP, etc. de toutes les classes, puis utilisez les valeurs agrégées pour calculer une métrique globale.Traiter chaque échantillon de manière égale, plus influencée par les classes nombreuses.

Dans Scikit-learn, vous pouvez spécifier viaaverageles paramètres :

Exemple

from sklearn.metrics import precision_score
# y_true et y_pred sont maintenant des étiquettes multiclasse, par ex., [0, 1, 2, 0, 1]

precision_macro = precision_score(y_true, y_pred, average='macro') # Moyenne macro
precision_micro = precision_score(y_true, y_pred, average='micro') # Moyenne micro

6. Exercice pratique : Évaluation complète d'un modèle de classification

Maintenant, entraînons-nous avec un jeu de données réel. Nous allons utiliser le célèbre jeu de données Iris.

Exemple

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score

# 1. Charger les données
iris = load_iris()
X = iris.data
y = iris.target
target_names = iris.target_names

# 2. Scinder en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 3. Entraîner un modèle simple de régression logistique
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)

# 4. Faire des prédictions sur l'ensemble de test
y_pred = model.predict(X_test)
y_pred_proba = model.predict_proba(X_test) # Obtenir les probabilités prédites pour l'AUC

# 5. Calculer et afficher diverses métriques
print("=== Matrice de confusion ===")
print(confusion_matrix(y_test, y_test))
# Remarque : la matrice de confusion pour multiclasse est N x N

print("\n=== Rapport de classification (incluant précision, rappel, F1) ===")
print(classification_report(y_test, y_pred, target_names=target_names))
# classification_report est une fonction très pratique qui produit plusieurs métriques en une seule fois.

print(f"\n=== Exactitude ===")
print(f"{accuracy_score(y_test, y_pred):.4f}")

# 6. Pour l'AUC multiclasse, on calcule généralement l'AUC "un contre tous" pour chaque classe par rapport aux autres classes, puis on prend la moyenne.
from sklearn.metrics import roc_auc_score
# Note : roc_auc_score nécessite de spécifier multi_class='ovr' (un contre tous) et average pour le multiclasse
try:
    auc_ovr = roc_auc_score(y_test, y_pred_proba, multi_class='ovr', average='macro')
    print(f"\n=== Moyenne macro AUC (OvR) ===")
    print(f"{auc_ovr:.4f}")
except Exception as e:
    print(f"\nErreur lors du calcul de l'AUC (certaines classes peuvent ne pas apparaître dans l'ensemble de test) : {e}")

Exécutez ce code et vous verrez un rapport complet d'évaluation du modèle. Essayez de modifier les paramètres du modèle ou d'utiliser un modèle différent (tel quesklearn.tree.DecisionTreeClassifier) et observez comment ces métriques changent.

=== 混淆矩阵 ===
[[19  0  0]
 [ 0 13  0]
 [ 0  0 13]]

=== 分类报告(包含精确率、召回率、F1)===
              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        19
  versicolor       1.00      1.00      1.00        13
   virginica       1.00      1.00      1.00        13

    accuracy                           1.00        45
   macro avg       1.00      1.00      1.00        45
weighted avg       1.00      1.00      1.00        45


=== 准确率 ===
1.0000

=== 宏平均 AUC (OvR) ===
1.0000
Autres extensions