Seaborn Heatmap : Guide Complet pour Créer des Cartes de Chaleur en Python

Name

Soren Atelier

Updated on 09/02/2026

Vous avez un jeu de données avec des dizaines de variables. Vous devez comprendre quelles caractéristiques sont corrélées, où se cachent les motifs, ou pourquoi votre modèle d'apprentissage automatique continue de mal fonctionner. Fixer des rangées et des colonnes de chiffres ne vous dit presque rien. C'est exactement le problème qu'une carte de chaleur seaborn résout - elle convertit une matrice dense de valeurs en une grille codée par couleur que votre cerveau peut analyser en quelques secondes.

Les cartes de chaleur sont l'un des types de visualisation les plus utilisés en science des données, et la bibliothèque seaborn de Python rend leur création remarquablement simple. Que vous construisiez une matrice de corrélation, analysiez une matrice de confusion ou visualisiez des modèles de séries temporelles, sns.heatmap() vous donne un graphique prêt à publier avec seulement quelques lignes de code.

Ce guide vous guide à travers tout : syntaxe de base, options de personnalisation, techniques avancées comme les cartes de chaleur groupées, et un tableau de référence complet des paramètres. Chaque exemple de code est prêt à copier-coller.

Syntaxe de Base de la Carte de Chaleur Seaborn

La fonction principale est sns.heatmap(). Elle accepte un jeu de données 2D - typiquement un DataFrame pandas ou un tableau NumPy - et le rend sous forme de grille colorée.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
# Create sample data
data = np.random.rand(5, 7)
ax = sns.heatmap(data)
plt.title("Basic Seaborn Heatmap")
plt.show()

C'est la carte de chaleur la plus simple possible. La couleur de chaque cellule représente sa valeur numérique, et seaborn ajoute automatiquement une barre de couleur sur le côté droit. Mais l'utilisation réelle implique presque toujours plus de configuration, que nous couvrirons ensuite.

Créer une Carte de Chaleur de Matrice de Corrélation

Le cas d'utilisation le plus courant pour une carte de chaleur seaborn est la visualisation d'une matrice de corrélation. Cela vous indique à quel point chaque paire de variables dans votre jeu de données est liée.

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
 
# Load a built-in dataset
df = sns.load_dataset("mpg").select_dtypes(include="number")
 
# Compute the correlation matrix
corr = df.corr()
 
# Plot the heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(
    corr,
    annot=True,
    fmt=".2f",
    cmap="coolwarm",
    center=0,
    square=True,
    linewidths=0.5
)
plt.title("Correlation Matrix - MPG Dataset")
plt.tight_layout()
plt.show()

Éléments clés qui se passent ici :

• annot=True imprime le coefficient de corrélation à l'intérieur de chaque cellule.
• fmt=".2f" formate ces nombres à deux décimales.
• cmap="coolwarm" utilise une palette de couleurs divergente où les corrélations négatives sont bleues et les corrélations positives sont rouges.
• center=0 garantit que la corrélation zéro est mappée à la couleur de point médian neutre.
• square=True force chaque cellule à être un carré parfait pour des visuels plus propres.

Options de Personnalisation

Palettes de Couleurs (paramètre cmap)

Le paramètre cmap contrôle le schéma de couleurs. Le choix de la bonne palette dépend de votre type de données.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.rand(6, 6)
fig, axes = plt.subplots(1, 3, figsize=(18, 5))
 
cmaps = ["viridis", "coolwarm", "YlOrRd"]
for ax, cmap in zip(axes, cmaps):
    sns.heatmap(data, cmap=cmap, ax=ax, annot=True, fmt=".2f")
    ax.set_title(f'cmap="{cmap}"')
 
plt.tight_layout()
plt.show()

Annotations (paramètres annot et fmt)

Les annotations affichent la valeur numérique à l'intérieur de chaque cellule. Vous pouvez contrôler leur format :

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.randint(0, 1000, size=(4, 5))
 
plt.figure(figsize=(8, 5))
sns.heatmap(
    data,
    annot=True,
    fmt="d",            # integer format
    cmap="Blues",
    annot_kws={"size": 14, "weight": "bold"}  # customize font
)
plt.title("Heatmap with Integer Annotations")
plt.show()

Valeurs fmt courantes : ".2f" pour deux décimales, "d" pour les entiers, ".1%" pour les pourcentages, ".1e" pour la notation scientifique.

Taille de Figure et Rapport d'Aspect

Les cartes de chaleur Seaborn héritent leur taille de la figure matplotlib. Définissez-la avant d'appeler sns.heatmap() :

plt.figure(figsize=(12, 8))  # width=12, height=8 inches
sns.heatmap(data, cmap="viridis")
plt.show()

Pour des cellules carrées, passez square=True à sns.heatmap(). Cela remplace le rapport d'aspect de la figure pour rendre chaque cellule de taille égale.

Masquer le Triangle Supérieur ou Inférieur

Les matrices de corrélation sont symétriques. Montrer les deux moitiés est redondant. Utilisez triu ou tril de NumPy pour masquer une moitié :

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
df = sns.load_dataset("mpg").select_dtypes(include="number")
corr = df.corr()
 
# Create a mask for the upper triangle
mask = np.triu(np.ones_like(corr, dtype=bool))
 
plt.figure(figsize=(10, 8))
sns.heatmap(
    corr,
    mask=mask,
    annot=True,
    fmt=".2f",
    cmap="coolwarm",
    center=0,
    square=True,
    linewidths=0.5
)
plt.title("Lower Triangle Correlation Heatmap")
plt.tight_layout()
plt.show()

Le paramètre mask accepte un tableau booléen de la même forme que les données. Les cellules où mask=True sont masquées.

Tableau de Référence des Paramètres de Carte de Chaleur

Exemples Avancés

Carte de Chaleur Groupée avec sns.clustermap

Lorsque vous souhaitez regrouper des lignes et colonnes similaires, sns.clustermap() applique un clustering hiérarchique et réorganise automatiquement les axes :

import seaborn as sns
import matplotlib.pyplot as plt
 
df = sns.load_dataset("mpg").select_dtypes(include="number").dropna()
corr = df.corr()
 
g = sns.clustermap(
    corr,
    annot=True,
    fmt=".2f",
    cmap="vlag",
    center=0,
    linewidths=0.5,
    figsize=(8, 8),
    dendrogram_ratio=0.15
)
g.ax_heatmap.set_title("Clustered Correlation Heatmap", pad=60)
plt.show()

Les dendrogrammes à gauche et en haut montrent la hiérarchie de clustering. Les variables les plus étroitement corrélées sont placées les unes à côté des autres, rendant les motifs beaucoup plus faciles à repérer.

Plages de Couleurs Personnalisées (vmin, vmax)

Par défaut, seaborn met à l'échelle les couleurs au minimum et au maximum de vos données. Vous pouvez remplacer cela pour comparer plusieurs cartes de chaleur sur la même échelle ou pour mettre en évidence une plage spécifique :

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
data = np.random.uniform(-1, 1, size=(8, 8))
 
plt.figure(figsize=(8, 6))
sns.heatmap(
    data,
    vmin=-1,
    vmax=1,
    center=0,
    cmap="RdBu_r",
    annot=True,
    fmt=".2f"
)
plt.title("Heatmap with Fixed Color Range (-1 to 1)")
plt.show()

Définir vmin=-1 et vmax=1 est particulièrement utile lors du traçage de matrices de corrélation ou de données normalisées où la plage théorique est connue.

Carte de Chaleur de Matrice de Confusion

Une autre application pratique est la visualisation d'une matrice de confusion d'un modèle de classification :

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
from sklearn.metrics import confusion_matrix
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
 
# Train a quick model
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.3, random_state=42
)
clf = RandomForestClassifier(random_state=42)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
 
# Build and plot the confusion matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(7, 5))
sns.heatmap(
    cm,
    annot=True,
    fmt="d",
    cmap="Blues",
    xticklabels=iris.target_names,
    yticklabels=iris.target_names
)
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.title("Confusion Matrix - Iris Classification")
plt.tight_layout()
plt.show()

La diagonale montre les prédictions correctes. Les cellules hors diagonale révèlent où le modèle confond une classe avec une autre.

Carte de Chaleur de Séries Temporelles

Les cartes de chaleur fonctionnent également bien pour repérer des motifs à travers les dimensions temporelles. Voici un exemple montrant l'activité par jour de la semaine et heure :

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
 
np.random.seed(0)
hours = list(range(24))
days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
data = pd.DataFrame(
    np.random.poisson(lam=20, size=(7, 24)),
    index=days,
    columns=hours
)
 
plt.figure(figsize=(14, 5))
sns.heatmap(data, cmap="YlOrRd", linewidths=0.3, annot=False)
plt.xlabel("Hour of Day")
plt.ylabel("Day of Week")
plt.title("Activity Heatmap by Day and Hour")
plt.tight_layout()
plt.show()

Carte de Chaleur Seaborn vs Matplotlib imshow

Vous pouvez également créer des visualisations de type carte de chaleur avec matplotlib.pyplot.imshow(). Voici comment les deux se comparent :

Conclusion : Utilisez sns.heatmap() lorsque vous voulez une carte de chaleur propre et bien étiquetée avec un code minimal. Revenez à imshow() lorsque vous avez besoin d'un contrôle au niveau du pixel ou que vous travaillez avec des données d'image plutôt que des données tabulaires.

Alternative Interactive : PyGWalker

Les cartes de chaleur statiques sont puissantes pour les rapports et les articles, mais pendant l'analyse exploratoire des données, vous voulez souvent interagir avec vos données - filtrer, pivoter, explorer en profondeur et basculer entre les types de graphiques sans réécrire le code.

PyGWalker (opens in a new tab) (liaison Python de Graphic Walker) transforme n'importe quel DataFrame pandas en une interface interactive de type Tableau directement dans Jupyter Notebook. Vous pouvez glisser-déposer des champs pour créer des cartes de chaleur, des graphiques de dispersion, des graphiques à barres et plus encore sans écrire de code de visualisation du tout.

pip install pygwalker

import pandas as pd
import pygwalker as pyg
 
df = pd.read_csv("your_data.csv")
walker = pyg.walk(df)

Une fois l'interface interactive lancée, vous pouvez :

• Glisser une variable catégorielle vers les lignes, une autre vers les colonnes et une mesure vers la couleur pour créer une carte de chaleur.
• Basculer instantanément vers d'autres types de graphiques (barres, ligne, dispersion).
• Filtrer et agréger sans écrire de code supplémentaire.

Ceci est particulièrement utile lorsque vous explorez encore quelles variables inclure dans votre carte de chaleur seaborn finale. Utilisez PyGWalker pour la phase d'exploration, puis verrouillez votre visualisation statique finale avec sns.heatmap() pour le partage.

Questions Fréquemment Posées

Comment changer la taille d'une carte de chaleur seaborn ?

Définissez la taille de la figure avant d'appeler sns.heatmap() en utilisant plt.figure(figsize=(width, height)). Par exemple, plt.figure(figsize=(12, 8)) crée une figure de 12x8 pouces. Vous pouvez également passer un paramètre ax si vous travaillez avec des sous-graphiques.

Comment annoter une carte de chaleur seaborn avec des valeurs ?

Passez annot=True à sns.heatmap(). Contrôlez le format des nombres avec le paramètre fmt (par ex., fmt=".2f" pour deux décimales). Personnalisez les propriétés de police en utilisant annot_kws, par exemple : annot_kws={"size": 12, "weight": "bold"}.

Quelle est la différence entre sns.heatmap et sns.clustermap ?

sns.heatmap() affiche les données dans l'ordre original des lignes et colonnes. sns.clustermap() applique un clustering hiérarchique pour réorganiser les lignes et colonnes afin que les valeurs similaires soient regroupées, et ajoute des dendrogrammes pour montrer la structure de clustering.

Comment masquer la moitié d'une carte de chaleur de corrélation ?

Utilisez NumPy pour créer un masque booléen. Pour le triangle supérieur : mask = np.triu(np.ones_like(corr, dtype=bool)). Ensuite, passez mask=mask à sns.heatmap(). Pour le triangle inférieur, utilisez np.tril() à la place.

Puis-je enregistrer une carte de chaleur seaborn en tant que fichier image ?

Oui. Après avoir créé la carte de chaleur, appelez plt.savefig("heatmap.png", dpi=300, bbox_inches="tight") avant plt.show(). Les cartes de chaleur Seaborn prennent en charge tous les formats de sortie matplotlib, y compris PNG, SVG, PDF et EPS.

Conclusion

La carte de chaleur seaborn est l'un des outils les plus polyvalents dans la boîte à outils de visualisation d'un data scientist. De l'analyse de corrélation aux matrices de confusion en passant par la détection de motifs de séries temporelles, sns.heatmap() gère tout cela avec une syntaxe propre et une sortie de qualité publication.

Commencez par les bases - passez vos données et choisissez une palette de couleurs. Ensuite, superposez des annotations, du masquage, des plages personnalisées et du clustering selon les besoins de votre analyse. Pour la phase d'exploration avant de verrouiller une visualisation finale, des outils comme PyGWalker (opens in a new tab) peuvent accélérer votre flux de travail avec des graphiques interactifs par glisser-déposer.

Les exemples de code dans ce guide sont tous prêts à copier-coller. Choisissez celui qui se rapproche le plus de votre cas d'usage, échangez vos données, et vous aurez une carte de chaleur claire et informative en moins d'une minute.