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

La visualisation est un moyen important de donner un sens aux données et d'en tirer des informations informatives et exploitables. Un bon visuel permet au lecteur d'avoir une idée de base de l'information d'un simple coup d'œil.

Une visualisation populaire utilisée pour afficher les données est une carte thermique. Dans cet article, j'expliquerai une carte thermique et comment en créer une en Python à l'aide de Matplotlib, Seaborn et Plotly.

What Is a Heatmap?

Une carte thermique est une image bidimensionnelle représentant des données sous forme de matrice ou de grille de points. Une ombre d'un tracé de couleur représente chaque point de données. Les nuances plus foncées représentent des valeurs plus élevées que les nuances plus claires.

Les cartes thermiques facilitent l'identification des modèles, des tendances et des variations dans les données. Ils fournissent des informations résumées qui permettent aux utilisateurs de voir rapidement les zones de valeurs élevées ou faibles, les clusters ou les valeurs aberrantes.

Where Are Heatmaps Used?

Les cartes thermiques sont utiles pour montrer comment les valeurs varient dans l'espace. Les cas d'utilisation quotidiens incluent :

Météo

La carte thermique la plus populaire que la plupart des gens ont vue est une carte thermique littérale - montrant comment la température varie selon les endroits.

Ceci est un exemple de prévision météo de l'Express du Quotidien montrant les températures attendues sous forme de carte thermique. Cela facilite la visualisation des endroits qui seront chauds, froids ou intermédiaires.

Affichage de l'utilisation du site Web/de l'application

Grâce au suivi des mouvements de la souris, des clics et des modèles de défilement, les cartes thermiques aident à identifier les zones populaires ou négligées d'une page Web. Cela peut ensuite être utilisé pour optimiser les interfaces utilisateur et améliorer l'expérience utilisateur.

L'imagerie médicale

Les cartes thermiques visualisent les zones d'activité élevée ou faible dans le corps. Cela peut identifier les anomalies et les maladies et évaluer la progression ou la réponse au traitement dans des conditions telles que le cancer.

Libraries for Creating Heatmaps in Python

Python est un langage populaire pour l'analyse et la visualisation de données. Cela est dû à sa syntaxe simple et à son écosystème étendu. Il existe plusieurs bibliothèques que vous pouvez utiliser pour créer des cartes thermiques en Python. Ceux-ci inclus:

• matplotlib – Une bibliothèque de visualisation de données populaire. Il s'agit d'une bibliothèque de bas niveau qui offre plus d'options de personnalisation mais qui est compliquée.
• marin - Cette bibliothèque de visualisation est construite sur Matplotlib et simplifie certaines de ses fonctions tout en offrant des visualisations plus attrayantes.
• Plotly - Il s'agit d'une bibliothèque de visualisation qui fournit une API facile à utiliser pour créer des Heatmaps en Python.

Dans la section suivante, nous verrons comment créer des cartes thermiques à l'aide de toutes ces bibliothèques.

How to Generate a Heatmap?

Dans cette section, j'explorerai comment créer des cartes thermiques à l'aide de Matplotlib, Seaborn et Plotly. Pour coder, je vais utiliser Google Colab. Il s'agit d'une instance gratuite d'un Notebook Python qui utilise Google Infrastructure pour exécuter votre code. Il ne nécessite aucune configuration, vous pouvez donc également l'utiliser pour suivre. Pour commencer, nous couvrirons d'abord Matplotlib.

matplotlib

Pour commencer, nous commençons par importer 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

Pour générer le jeu de données, nous ajouterons le code suivant :

# Creating a seed for reproducibility
np.random.seed(2)

# Generating 10 x 10 array of integers between 1 and 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

Pour tracer les données, nous utilisons la méthode imshow. Nous passons des données comme argument. Nous pouvons faire plus en transmettant des arguments supplémentaires que nous aborderons plus tard.

plt.imshow(data)

Si vous exécutez la cellule, vous devriez voir une carte thermique.

Bien que ce soit formidable, de nombreuses options de personnalisation s'offrent à vous. Pour commencer, vous pouvez modifier la couleur utilisée dans l'image à l'aide de l'argument cmap que vous transmettez à imshow. Par exemple, si vous vouliez changer la couleur utilisée par la carte thermique en différentes nuances de bleu, vous généreriez le tracé avec ce qui suit.

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

La liste complète de cmap les options sont trouvées ici. Quoi qu'il en soit, le résultat de ce qui précède serait:

Une carte thermique serait plus utile s'il y avait une clé pour expliquer ce que les couleurs représentent. Pour ce faire, ajoutez le code suivant :

plt.colorbar()

Après cela, vous devriez obtenir une figure qui ressemble à ceci :

Une barre de couleur est utile, mais dans certains cas, vous souhaiterez peut-être annoter les différentes valeurs afin que le spectateur puisse voir précisément ce qui est représenté. Pour ce faire, vous écririez du texte dans chacune des cellules 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',
      )

La dernière chose que nous ferons avec la carte thermique est de définir les étiquettes de graduation sur les axes. Nous utiliserons le plt.xticks fonction pour l'axe des x et plt.yticks fonction pour l'axe y. Ces méthodes sont appelées de la même manière ; la seule différence est l'axe que chaque méthode affecte.

Le premier argument est la liste des endroits où insérer les ticks. Ceci est représenté sous la forme d'un tableau d'indices. L'argument suivant est la liste réelle des étiquettes qui seraient insérées. Voici un exemple de la façon dont nous insérerions des ticks :

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 c'est tout! C'est ainsi que vous créez une carte thermique dans Matplotlib. La solution de code complète est détaillée ci-dessous.

import numpy as np
import matplotlib.pyplot as plt

# Creating a seed for reproducibility
np.random.seed(2)

# Generating 10 x 10 array of integers between 1 and 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

# Creating a plot with blue as a color
plt.imshow(data, cmap = 'Blues')

# Displaying a color bar
plt.colorbar()

# Annotating values
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',
      )

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

# Adding the tick labels
plt.xticks(np.arange(len(x_labels)), labels=x_labels)
plt.yticks(np.arange(len(y_labels)), labels=y_labels)

Cependant, utiliser Matplotlib n'est pas la solution la plus simple. Comme nous le verrons ensuite, d'autres bibliothèques, telles que Seaborn et Matplotlib, simplifient le processus de création d'une carte thermique.

marin

Dans cette section, nous allons recréer l'exemple précédent en utilisant Seaborn. Seaborn est une bibliothèque qui s'appuie sur Matplotlib. Il fournit des abstractions qui facilitent le travail. Pour créer une carte thermique, nous commençons par importer les bibliothèques que nous allons utiliser.

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

Nous avons importé Matplotlib car Seaborn l'exige. Ensuite, nous devons également importer NumPy pour générer un ensemble de données aléatoire. Enfin, nous devons importer Seaborn.

Ensuite, nous générons le jeu de données à l'aide de NumPy.

# Creating a seed for reproducibility
np.random.seed(2)

# Generating 10 x 10 array of integers between 1 and 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

Après cela, nous créons nos listes d'étiquettes de tiques.

# Tick labels
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, nous créons la carte thermique réelle en appelant la fonction heatmap du module sn.

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

Comme vous pouvez le voir, nous avons passé plusieurs arguments. Voici une explication pour chacun :

• data est le jeu de données que nous voulons tracer
• cmap est le jeu de couleurs que nous voulons que la carte thermique soit créée en utilisant
• annot indique si nous voulons annoter les points de données avec leur valeur réelle
• yticklabels est la liste des étiquettes que nous voulons pour les graduations de l'axe vertical
• xticklabels est la liste des étiquettes pour les graduations de l'axe horizontal.

Enfin, nous montrons l'intrigue en utilisant le code :

plt.show()

Cela générera la carte thermique suivante :

Plotly

Pour Plotly, le processus est similaire à Seaborn. Voici le schéma de code pour créer une carte thermique dans Plotly :

import plotly.express as px
import numpy as np

# Creating a seed for reproducibility
np.random.seed(2)

# Generating 10 x 10 array of integers between 1 and 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

# Tick labels
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')

Comme vous pouvez le voir, la heatmap est générée dans la dernière ligne en utilisant le px.imshow() fonction. Cette fonction prend les données à tracer comme argument positionnel. De plus, il prend l'argument de mot-clé comme suit :

• text_auto est un booléen qui active l'annotation lorsqu'il est défini sur true
• x est une liste d'étiquettes de graduation sur l'axe des x
• y est une liste d'étiquettes de graduation sur l'axe y
• color_continuous_scale détermine le jeu de couleurs utilisé pour le graphique.

Comme vous pouvez le voir, Plotly est plus simple que Seaborn et Matplotlib. De plus, le graphe généré est interactif par rapport aux autres bibliothèques qui produisent des images statiques.

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

Mot de la fin

Dans cet article, nous avons expliqué comment créer des cartes thermiques en Python. Nous avons couvert les principales bibliothèques - Matplotlib, Seaborn et Plotly. Nous avons également vu comment Seaborn et Plotly fournissent des abstractions simplifiées sur Matplotlib. Une utilisation essentielle des Heatmaps consiste à suivre la façon dont les gens utilisent vos sites Web.

Ensuite, consultez outils de carte thermique qui vous indiquent où vos utilisateurs cliquent.