[Explained] Comment créer une carte thermique en Python

La représentation visuelle joue un rôle crucial dans l'interprétation des données, permettant d'en extraire des informations pertinentes et exploitables. Une visualisation efficace permet à l'observateur de saisir rapidement l'essence d'une information, d'un simple coup d'œil.

Parmi les nombreuses méthodes de visualisation de données, la carte thermique se distingue par son utilité. Cet article explore le concept de carte thermique et vous guide à travers sa création en Python, en utilisant les bibliothèques Matplotlib, Seaborn et Plotly.

Qu'est-ce qu'une carte thermique ?

Source: seaborn.pydata.org

Une carte thermique est une représentation graphique bidimensionnelle de données, présentées sous la forme d'une matrice ou d'une grille de points. Chaque point de donnée est symbolisé par une nuance de couleur, les teintes les plus foncées représentant les valeurs les plus élevées, et inversement, les teintes plus claires, les valeurs les plus faibles.

Les cartes thermiques simplifient l'identification des schémas, des tendances et des variations au sein des données. Elles offrent une vue synthétique qui permet de distinguer rapidement les zones de fortes ou de faibles valeurs, les regroupements ou les valeurs aberrantes.

Dans quels contextes les cartes thermiques sont-elles utilisées ?

Les cartes thermiques se révèlent particulièrement pertinentes pour illustrer la variation des valeurs dans l'espace. Voici quelques exemples d'applications courantes :

Météo

La carte thermique la plus familière au grand public est sans doute celle utilisée pour représenter les variations de température selon les régions.

Par exemple, cette prévision météo du Daily Express montre les températures attendues sous forme de carte thermique, permettant de distinguer clairement les zones chaudes, froides ou tempérées.

Analyse de l'utilisation de sites Web/applications

Source: HotJar

Grâce au suivi des mouvements de la souris, des clics et des schémas de défilement, les cartes thermiques révèlent les zones les plus consultées ou les plus ignorées d'une page web. Ces informations peuvent être utilisées pour optimiser les interfaces utilisateurs et améliorer l'expérience utilisateur.

Imagerie médicale

Source: researchgate.net

Les cartes thermiques sont utilisées pour visualiser les zones d'activité intense ou faible dans le corps, facilitant ainsi l'identification d'anomalies, le diagnostic de maladies, ou encore l'évaluation de la progression ou de la réponse au traitement de pathologies telles que le cancer.

Bibliothèques Python pour la création de cartes thermiques

Python est un langage de programmation très prisé pour l'analyse et la visualisation de données, en raison de sa syntaxe intuitive et de son écosystème riche. Plusieurs bibliothèques permettent de créer des cartes thermiques en Python, notamment :

Matplotlib : Une bibliothèque de visualisation de données largement utilisée, offrant une grande flexibilité mais requérant parfois une configuration plus complexe.
Seaborn : Une bibliothèque construite sur Matplotlib, qui simplifie certaines fonctionnalités et propose des visualisations esthétiquement plus abouties.
Plotly : Une bibliothèque de visualisation qui fournit une API facile à utiliser pour créer des cartes thermiques en Python.

La section suivante détaillera la création de cartes thermiques à l'aide de ces trois bibliothèques.

Comment générer une carte thermique ?

Nous allons maintenant explorer la création de cartes thermiques à l'aide de Matplotlib, Seaborn et Plotly. Pour le codage, nous utiliserons Google Colab, un environnement de notebook Python gratuit qui utilise l'infrastructure de Google. Vous pouvez ainsi suivre les étapes sans nécessiter de configuration supplémentaire. Commençons par Matplotlib.

Matplotlib

Pour commencer, importez la bibliothèque Matplotlib :

import matplotlib.pyplot as plt

Nous aurons également besoin de NumPy pour générer un jeu de données aléatoire :

import numpy as np

Le code suivant génère le jeu de données :

# Initialisation du générateur de nombres aléatoires pour la reproductibilité
np.random.seed(2)

# Génération d'une matrice 10 x 10 d'entiers entre 1 et 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

Pour tracer les données, nous utilisons la méthode `imshow`, à laquelle nous passons les données. Nous pouvons personnaliser le tracé à l'aide d'arguments supplémentaires, comme nous le verrons plus loin.

plt.imshow(data)

L'exécution de cette cellule devrait afficher une carte thermique.

De nombreuses options de personnalisation sont disponibles. Par exemple, vous pouvez modifier la palette de couleurs en utilisant l'argument `cmap` de la fonction `imshow`. Pour obtenir des nuances de bleu, utilisez le code suivant :

plt.imshow(data, cmap = 'Blues')

Vous trouverez la liste complète des options `cmap` ici. Le résultat de ce code sera :

Une carte thermique est plus informative si elle est accompagnée d'une légende expliquant la signification des couleurs. Pour ce faire, ajoutez le code suivant :

plt.colorbar()

Vous devriez obtenir le résultat suivant :

Dans certains cas, vous souhaiterez peut-être annoter les différentes cellules avec leurs valeurs correspondantes, afin de faciliter la lecture. Pour cela, vous devrez écrire du texte dans chaque cellule en utilisant `plt.text()`.

for i in range(data.shape[0]):
   for j in range(data.shape[1]):
      plt.text(j, i, '%d' % data[i, j],
         horizontalalignment="center",
         verticalalignment="center",
      )

Enfin, pour définir les étiquettes des axes, utilisez les fonctions `plt.xticks` pour l'axe des x et `plt.yticks` pour l'axe des y. Le premier argument est une liste des emplacements où insérer les graduations, représentée par un tableau d'indices, tandis que le second argument contient la liste des étiquettes correspondantes. Voici un exemple :

x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

plt.xticks(np.arange(len(x_labels)), labels=x_labels)
plt.yticks(np.arange(len(y_labels)), labels=y_labels)

Et voilà ! C'est ainsi que l'on crée une carte thermique avec Matplotlib. Voici le code complet :

import numpy as np
import matplotlib.pyplot as plt

# Initialisation du générateur de nombres aléatoires pour la reproductibilité
np.random.seed(2)

# Génération d'une matrice 10 x 10 d'entiers entre 1 et 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

# Création d'un graphique avec une palette de couleurs bleue
plt.imshow(data, cmap = 'Blues')

# Affichage de la barre de couleurs
plt.colorbar()

# Annotation des valeurs
for i in range(data.shape[0]):
   for j in range(data.shape[1]):
      plt.text(j, i, '%d' % data[i, j],
         horizontalalignment="center",
         verticalalignment="center",
      )

# Création des listes d'étiquettes
x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

# Ajout des étiquettes
plt.xticks(np.arange(len(x_labels)), labels=x_labels)
plt.yticks(np.arange(len(y_labels)), labels=y_labels)

Cependant, Matplotlib n'est pas la solution la plus simple. Les bibliothèques telles que Seaborn et Plotly simplifient considérablement le processus, comme nous allons le voir maintenant.

Seaborn

Nous allons maintenant recréer l'exemple précédent en utilisant Seaborn. Seaborn est une bibliothèque construite sur Matplotlib qui fournit des abstractions pour simplifier le travail. Pour créer une carte thermique, commencez par importer les bibliothèques nécessaires :

import matplotlib.pyplot as plt
import numpy as np
import seaborn as sn

Nous importons Matplotlib car Seaborn en dépend. Ensuite, importez NumPy pour générer un jeu de données aléatoire et enfin, Seaborn.

Générez ensuite le jeu de données à l'aide de NumPy :

# Initialisation du générateur de nombres aléatoires pour la reproductibilité
np.random.seed(2)

# Génération d'une matrice 10 x 10 d'entiers entre 1 et 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

Après cela, créez des listes d'étiquettes :

# Étiquettes
x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

Enfin, créez la carte thermique en utilisant la fonction `heatmap` du module `sn` :

hm = sn.heatmap(data = data, cmap = 'Oranges', annot = True, yticklabels = y_labels, xticklabels = x_labels)

Voici une explication des arguments utilisés :

`data` est le jeu de données à représenter.
`cmap` est la palette de couleurs utilisée pour la carte thermique.
`annot` indique si les points de données doivent être annotés avec leurs valeurs.
`yticklabels` est la liste des étiquettes pour l'axe vertical.
`xticklabels` est la liste des étiquettes pour l'axe horizontal.

Enfin, affichez le graphique avec :

plt.show()

Cela générera la carte thermique suivante :

Plotly

Le processus de création d'une carte thermique avec Plotly est similaire à celui de Seaborn. Voici le code :

import plotly.express as px
import numpy as np

# Initialisation du générateur de nombres aléatoires pour la reproductibilité
np.random.seed(2)

# Génération d'une matrice 10 x 10 d'entiers entre 1 et 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

# Étiquettes
x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

px.imshow(data, text_auto = True, x = x_labels, y = y_labels, color_continuous_scale="greys")

La carte thermique est générée à la dernière ligne avec la fonction `px.imshow()`. Cette fonction prend les données à tracer comme argument positionnel, et les arguments suivants :

`text_auto` est un booléen qui active l'annotation lorsque défini sur `True`.
`x` est la liste des étiquettes pour l'axe des x.
`y` est la liste des étiquettes pour l'axe des y.
`color_continuous_scale` définit la palette de couleurs.

Comme vous pouvez le constater, Plotly est plus simple que Seaborn et Matplotlib. De plus, le graphique généré est interactif, contrairement aux images statiques produites par les autres bibliothèques.

Voici une capture d'écran du résultat final :

Conclusion

Cet article a détaillé la création de cartes thermiques en Python, en utilisant les bibliothèques Matplotlib, Seaborn et Plotly. Nous avons vu comment Seaborn et Plotly simplifient le processus par rapport à Matplotlib. Une application importante des cartes thermiques est l'analyse de l'utilisation des sites Web.

Dans un prochain article, nous explorerons les outils de cartes thermiques qui permettent de visualiser les zones où cliquent vos utilisateurs.