Accueil › Glossaire › Matrice de Confusion

Matrice de Confusion (Confusion Matrix)

La matrice de confusion est un tableau qui résume les résultats d’un modèle de classification en croisant les prédictions du modèle avec les classes réelles, catégorisant chaque prédiction en vrai positif, vrai négatif, faux positif ou faux négatif.

C’est l’outil de diagnostic le plus fondamental en machine learning supervisé. Là où l’accuracy vous donne un seul chiffre, la matrice de confusion décompose les erreurs par type. Elle révèle non seulement combien d’erreurs le modèle commet, mais aussi lesquelles : confond-il les positifs avec les négatifs, ou l’inverse ? Cette distinction est cruciale car, dans la plupart des applications réelles, toutes les erreurs ne se valent pas.

Structure de la matrice de confusion binaire

Pour un problème à deux classes (positif / négatif), la matrice de confusion est un tableau 2 × 2 contenant quatre compteurs. Chaque prédiction du modèle tombe dans exactement l’une de ces quatre catégories.

Les quatre catégories expliquées

Vrai Positif (TP, True Positive) : le modèle a prédit « positif » et la réalité est « positif ». C’est une prédiction correcte. Exemple : le modèle détecte un email spam, et c’est effectivement un spam.

Vrai Négatif (TN, True Negative) : le modèle a prédit « négatif » et la réalité est « négatif ». C’est une prédiction correcte. Exemple : le modèle classe un email légitime comme légitime.

Faux Positif (FP, False Positive) : le modèle a prédit « positif » mais la réalité est « négatif ». C’est une fausse alerte, aussi appelée erreur de Type I en statistiques. Exemple : le modèle envoie un email légitime dans le dossier spam.

Faux Négatif (FN, False Negative) : le modèle a prédit « négatif » mais la réalité est « positif ». C’est un cas manqué, aussi appelé erreur de Type II. Exemple : le modèle laisse passer un spam dans la boîte de réception.

Exemple concret : détection de fraude

Prenons un modèle de détection de fraude évalué sur 10 000 transactions, dont 200 frauduleuses et 9 800 légitimes.

Cette matrice raconte une histoire bien plus riche que l’accuracy seule (98,4 %). On voit immédiatement que :

Le modèle détecte 160 fraudes sur 200 (rappel = 80 %). Il rate 40 fraudes (FN), ce qui représente une perte financière potentielle.

Parmi les 280 alertes « fraude », seules 160 sont réelles (précision = 57 %). Chaque alerte fausse (120 FP) coûte du temps à l’équipe d’investigation.

L’accuracy de 98,4 % semble excellente, mais elle est gonflée par l’énorme majorité de vrais négatifs. Un modèle qui prédirait « légitime » pour tout obtiendrait 98 % d’accuracy tout en manquant 100 % des fraudes.

Les métriques dérivées de la matrice de confusion

La matrice de confusion est la source de presque toutes les métriques de classification. Voici les plus importantes et comment les calculer.

Le compromis précision / rappel

C’est le compromis central en classification. Augmenter la précision (réduire les faux positifs) tend à diminuer le rappel (plus de faux négatifs), et inversement. Ce compromis est directement visible dans la matrice de confusion : réduire les FP augmente souvent les FN.

Le choix dépend du coût relatif des erreurs. En diagnostic médical (cancer, maladies graves), le rappel prime : manquer un cas positif (FN) est potentiellement fatal. En filtrage de spam, la précision prime : envoyer un email important dans le spam (FP) est très problématique pour l’utilisateur.

Le MCC : la métrique la plus complète

Le coefficient de corrélation de Matthews (MCC), inventé par Brian Matthews en 1975, est considéré par des recherches récentes (Chicco & Jurman, 2020, 2023) comme la métrique la plus informative pour résumer une matrice de confusion. Contrairement à l’accuracy ou au F1-Score, le MCC ne produit un score élevé que si les quatre catégories (TP, TN, FP, FN) présentent de bons résultats. Il est particulièrement robuste sur les datasets déséquilibrés.

Le MCC varie de -1 (prédiction parfaitement inversée) à +1 (prédiction parfaite), avec 0 correspondant à une prédiction aléatoire. En Python : sklearn.metrics.matthews_corrcoef(y_true, y_pred).

Créer et visualiser une matrice de confusion en Python

Calcul de base avec scikit-learn

import numpy as np
from sklearn.metrics import confusion_matrix

# Labels réels et prédits
y_true = [1, 0, 1, 1, 0, 0, 1, 0, 1, 0]
y_pred = [1, 0, 0, 1, 0, 1, 1, 0, 1, 0]

# Matrice de confusion
cm = confusion_matrix(y_true, y_pred)
print(cm)
# [[4, 1],   ← [TN, FP]
#  [1, 4]]   ← [FN, TP]

# Extraire les quatre composantes
tn, fp, fn, tp = cm.ravel()
print(f"TP={tp}, TN={tn}, FP={fp}, FN={fn}")

Visualisation en heatmap

Scikit-learn (version 1.8) fournit ConfusionMatrixDisplay pour une visualisation propre :

import matplotlib.pyplot as plt
from sklearn.metrics import ConfusionMatrixDisplay

# Méthode 1 : à partir d'un estimateur
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42)
model = LogisticRegression(max_iter=10000).fit(X_train, y_train)

ConfusionMatrixDisplay.from_estimator(
    model, X_test, y_test,
    display_labels=['Malin', 'Bénin'],
    cmap='Purples'
)
plt.title('Matrice de confusion - Cancer du sein')
plt.tight_layout()
plt.show()

# Méthode 2 : à partir de prédictions existantes
ConfusionMatrixDisplay.from_predictions(
    y_test, model.predict(X_test),
    display_labels=['Malin', 'Bénin'],
    cmap='Purples',
    normalize='true'  # normaliser par ligne (rappel)
)
plt.title('Matrice normalisée (rappel par classe)')
plt.tight_layout()
plt.show()

Les trois modes de normalisation

La normalisation est essentielle pour interpréter correctement une matrice de confusion sur des données déséquilibrées :

normalize='true' : normalise par ligne (par classe réelle). Chaque cellule montre la proportion de la classe réelle. La diagonale affiche le rappel par classe. C’est la normalisation la plus courante.

normalize='pred' : normalise par colonne (par classe prédite). La diagonale affiche la précision par classe.

normalize='all' : normalise par le total global. Chaque cellule montre la proportion du dataset total.

normalize=None (défaut) : affiche les comptes bruts. Utile pour voir les volumes absolus.

Le rapport de classification complet

En pratique, on combine la matrice de confusion avec classification_report() pour obtenir toutes les métriques dérivées d’un coup :

from sklearn.metrics import classification_report

print(classification_report(y_test, model.predict(X_test),
                           target_names=['Malin', 'Bénin']))

#               precision    recall  f1-score   support
#        Malin       0.95      0.93      0.94        63
#        Bénin       0.96      0.97      0.97       108
#     accuracy                           0.96       171
#    macro avg       0.96      0.95      0.95       171
# weighted avg       0.96      0.96      0.96       171

Ce rapport donne la précision, le rappel et le F1-Score pour chaque classe, plus les moyennes macro (non pondérée) et pondérée (par le nombre d’exemples par classe).

Matrice de confusion multiclasse

Pour un problème à N classes, la matrice de confusion est un tableau N × N. La diagonale contient les prédictions correctes, les cellules hors diagonale montrent les confusions entre classes.

Comment lire une matrice multiclasse

Prenons un classifieur d’images qui distingue chats, chiens et oiseaux, évalué sur 90 images :

Lecture ligne par ligne (chaque ligne = une classe réelle) :

Sur 30 chats réels : 25 correctement identifiés, 3 confondus avec des chiens, 2 avec des oiseaux. Rappel chat = 25/30 = 83 %.

Sur 30 chiens réels : 22 corrects, 4 confondus avec des chats, 4 avec des oiseaux. Rappel chien = 73 %.

Sur 30 oiseaux réels : 27 corrects, 1 confondu avec un chat, 2 avec des chiens. Rappel oiseau = 90 %.

Lecture colonne par colonne (chaque colonne = une classe prédite) :

Sur 30 prédictions « chat » : 25 sont vraiment des chats. Précision chat = 25/30 = 83 %.

Les cellules hors diagonale révèlent les confusions spécifiques : le modèle confond davantage les chiens avec les chats (4 cas) qu’avec les oiseaux (2 cas). Ce type d’insight est invisible avec une métrique scalaire.

Métriques par classe en one-vs-rest

Pour calculer la précision, le rappel et le F1-Score d’une classe donnée en multiclasse, on adopte une vision « cette classe vs toutes les autres » :

Pour la classe « chat » : TP = 25, FP = 5 (chiens et oiseaux prédits chat), FN = 5 (chats prédits chien ou oiseau), TN = 55 (tout le reste correctement classé comme non-chat).

Matrice de confusion et déséquilibre de classes

Le déséquilibre de classes est le piège le plus courant dans l’interprétation de la matrice de confusion. Reprenons l’exemple de la détection de fraude : 200 fraudes sur 10 000 transactions (2 % de positifs).

Le piège de l’accuracy

Un modèle trivial qui prédit « légitime » pour toute transaction obtient cette matrice :

Accuracy = 98 %. Pourtant, ce modèle est totalement inutile : il ne détecte aucune fraude (rappel = 0 %, précision = indéfinie). La matrice de confusion révèle immédiatement cette réalité, alors que l’accuracy la masque. C’est pourquoi il faut toujours examiner la matrice complète, pas seulement l’accuracy.

Stratégies face au déséquilibre

Face à un dataset déséquilibré, plusieurs approches aident à mieux interpréter la matrice :

Normaliser par ligne (normalize='true') pour voir le rappel de chaque classe indépendamment de sa taille.

Utiliser le MCC au lieu de l’accuracy comme métrique résumée, car il prend en compte les quatre cellules proportionnellement.

Reporter la précision et le rappel séparément pour la classe minoritaire, qui est généralement celle qui vous intéresse.

Compléter par la courbe ROC ou la courbe Precision-Recall pour une vue indépendante du seuil.

Applications concrètes par domaine

Diagnostic médical

En médecine, les quatre cellules ont des significations cliniques directes. Un FN en dépistage du cancer signifie un diagnostic manqué avec des conséquences potentiellement graves. Un FP signifie des examens complémentaires inutiles (biopsie, stress pour le patient). Le seuil de classification est ajusté pour minimiser les FN, en acceptant plus de FP.

NLP et classification de texte

En analyse de sentiment ou classification de texte, la matrice multiclasse montre quelles catégories le modèle confond. Par exemple, un classifieur de sentiments confond souvent « neutre » avec « positif » ou « négatif », mais rarement « positif » avec « négatif ». Cette information guide l’amélioration du modèle.

Vision par ordinateur

En classification d’images et détection d’objets, la matrice multiclasse identifie les classes visuellement similaires que le modèle confond (par exemple, loups et huskies, ou chats et petits félins). Ces confusions orientent le choix des données d’entraînement supplémentaires.

Cybersécurité

En détection d’intrusion, les FP (fausses alertes) épuisent les analystes de sécurité. Les FN (intrusions manquées) peuvent avoir des conséquences catastrophiques. La matrice de confusion quantifie ce compromis et permet d’ajuster la sensibilité du système selon la capacité d’investigation de l’équipe.

Erreurs courantes d’interprétation

Erreur n°1 : confondre les conventions d’affichage

Il n’existe pas de convention universelle pour l’orientation de la matrice. Scikit-learn met les classes réelles en lignes et les prédictions en colonnes, avec la classe 0 en premier. D’autres outils (comme R ou certaines publications médicales) inversent lignes et colonnes, ou mettent la classe positive en premier. Vérifiez toujours les labels avant d’interpréter.

Erreur n°2 : ignorer les volumes absolus

Une matrice normalisée qui montre 95 % de rappel pour chaque classe semble excellente. Mais si la classe positive contient 10 exemples et la négative 10 000, les 5 % d’erreurs sur la classe positive ne représentent que 0,5 cas manqué, tandis que 5 % d’erreurs sur la négative représentent 500 faux positifs. Regardez toujours les comptes bruts en complément des pourcentages.

Erreur n°3 : oublier que la matrice dépend du seuil

Pour les modèles probabilistes (régression logistique, Random Forest, XGBoost), la matrice de confusion dépend du seuil de classification choisi. Changer le seuil de 0,5 à 0,3 produira une matrice complètement différente. Une matrice seule ne montre qu’un point de fonctionnement. La courbe ROC ou la courbe Precision-Recall montrent tous les points possibles.

Erreur n°4 : évaluer sur les données d’entraînement

La matrice de confusion sur le jeu d’entraînement est quasi toujours trop optimiste. Un modèle complexe peut obtenir une diagonale parfaite sur l’entraînement tout en étant médiocre sur des données nouvelles. Calculez toujours la matrice sur un jeu de test séparé ou en validation croisée.

Outils avancés autour de la matrice de confusion

Matrice de confusion multi-label

En classification multi-label (chaque observation peut appartenir à plusieurs classes), scikit-learn fournit multilabel_confusion_matrix() qui retourne une matrice 2 × 2 par label :

from sklearn.metrics import multilabel_confusion_matrix

y_true = [[1, 0, 1], [0, 1, 0], [1, 1, 1]]
y_pred = [[1, 0, 0], [0, 1, 0], [1, 0, 1]]

mcm = multilabel_confusion_matrix(y_true, y_pred)
# mcm[0] = matrice pour le label 0
# mcm[1] = matrice pour le label 1
# mcm[2] = matrice pour le label 2

Visualisation personnalisée avec seaborn

Pour plus de contrôle visuel, seaborn offre des heatmaps configurables :

import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Purples',
            xticklabels=['Négatif', 'Positif'],
            yticklabels=['Négatif', 'Positif'])
plt.xlabel('Prédiction')
plt.ylabel('Réalité')
plt.title('Matrice de confusion')
plt.tight_layout()
plt.show()

Verdict

La matrice de confusion est l’outil d’évaluation le plus fondamental en classification. Elle ne ment pas : elle montre exactement où le modèle se trompe et de quelle manière. Son principal avantage sur les métriques scalaires (accuracy, F1-Score) est de préserver l’information sur les types d’erreurs, ce qui est critique pour toute décision opérationnelle.

En pratique, commencez toujours par la matrice de confusion avant de regarder les métriques dérivées. Utilisez la normalisation pour les datasets déséquilibrés, le MCC comme métrique résumée la plus fiable, et n’oubliez pas que la matrice ne montre qu’un seul point de fonctionnement (un seuil). Pour une vue complète, combinez-la avec la courbe ROC ou Precision-Recall.