Matplotlib Colormaps : Personnaliser vos schémas de couleurs

La visualisation des données est l'un des meilleurs moyens (si ce n'est le meilleur) pour les analystes et les scientifiques des données de représenter des informations complexes et de générer des informations significatives. Pour tirer le meilleur parti de votre opportunité de communiquer avec les parties prenantes, j'ai compilé des informations utiles sur les cartes de couleurs Matplotlib. 

Comme vous le verrez dans cet article, Matplotlib est une bibliothèque de visualisation en Python extrêmement polyvalente et extensible. Il offre toutes les options, des simples graphiques aux visuels entièrement interactifs. Si vous n'êtes pas familier avec Python, je vous encourage à vous inscrire à notre cours d'introduction à Python avant de commencer afin d'en comprendre les fondements. Personnellement, je garde le Python Cheat Sheet à portée de main, car il s'agit d'une référence utile pour les fonctions courantes.

Choisir la bonne carte des couleurs de Matplotlib

L'une des premières choses à faire est de choisir entre des cartes de couleurs séquentielles, divergentes ou catégorielles. D'autres facteurs importants à prendre en compte lors du choix des cartes de couleurs sont l'uniformité perceptive, c'est-à-dire que des différences égales dans les valeurs de données sont perçues comme des différences égales dans les couleurs, et l'utilisation d'options de cartes de couleurs adaptées aux daltoniens afin de rendre vos visuels accessibles à tous les publics.

Vous devez également tenir compte des différentes normes de domaine lorsque vous choisissez des cartes de couleurs. Par exemple, les différentes nuances de bleu représentent différentes profondeurs d'eau dans les études océanographiques. Si vous n'êtes pas sûr de la bonne carte de couleurs pour votre visualisation, différents outils et ressources sont disponibles pour vous guider. En particulier, notre propre cours Introduction à la visualisation de données avec Matplotlib vous aide à travailler sur de nombreux scénarios.

Différentes cartes de couleurs dans Matplotlib

En Python, le module matplotlib.colormaps permet d'accéder à des cartes de couleurs intégrées, qui vous aident à sélectionner le schéma le mieux adapté à votre projet. Les catégories d'options les plus courantes sont les suivantes :

Cartes de couleurs séquentielles

Les cartes de couleurs séquentielles représentent des données ordonnées qui vont des valeurs faibles aux valeurs élevées. Ils passent d'une teinte claire à une teinte foncée, montrant l'ampleur des données à différents niveaux. Un exemple de carte de couleurs séquentielle se trouve dans les cartes thermiques pour les données de température, où les couleurs plus claires représentent les températures plus fraîches et les nuances plus foncées les températures plus chaudes.

Supposons que vous disposiez d'un ensemble de données comportant des colonnes de date et de température. Le code suivant crée une carte thermique pour la température.

# Import required libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors

# Step 1: Extract month and day information from the date column
calendar_data = temperature_data.copy()   # Create a copy to work with
calendar_data['Month'] = calendar_data['Date'].dt.strftime('%B')
calendar_data['Day'] = calendar_data['Date'].dt.day

# Step 2: Define the order of months for a natural calendar sequence
month_names = ['January', 'February', 'March', 'April', 'May', 'June', 
               'July', 'August', 'September', 'October', 'November', 'December']

# Convert the 'Month' column to a categorical type with the specified order
calendar_data['Month'] = pd.Categorical(calendar_data['Month'], categories=month_names, ordered=True)

# Step 3: Pivot the data to create a structured table for the heatmap
monthly_temperature_table = calendar_data.pivot(index='Month', columns='Day', values='Temperature')

# Step 4: Set up the plot for the heatmap
plt.figure(figsize=(12, 8))

# Define a custom normalization for temperature range (optional)
norm = mcolors.Normalize(vmin=15, vmax=35)

# Create the heatmap with a sequential colormap
heatmap = plt.imshow(monthly_temperature_table, cmap='YlOrRd', aspect='auto', norm=norm)

# Add color bar to represent temperature
colorbar = plt.colorbar(heatmap, orientation='horizontal')
colorbar.set_label('Temperature (°C)', labelpad=10)

# Label the axes
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Set y-ticks to display month names instead of numbers
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Add a title to the heatmap
plt.title('Monthly Temperature Heatmap (Sequential Colormap)')

# Display the plot
plt.grid(False)
plt.show()

Exemple de visualisation de cartes de couleurs séquentielles dans Matplotlib. Image par l'auteur

Cartes de couleurs divergentes

Les cartes de couleurs divergentes mettent en évidence les données qui s'écartent d'une valeur centrale dans les deux sens. Les cartes de couleurs divergentes ont des couleurs contrastées pour les directions positives et négatives. Les cartes de couleurs divergentes sont couramment utilisées dans les données financières pour représenter les profits et les pertes.

# Set 'Month' as the index
monthly_profit_loss_data.set_index('Month', inplace=True)

# Set the figure size
plt.figure(figsize=(8, 4))

# Create a diverging heatmap using Seaborn
# Use 'RdYlGn' colormap for diverging colors (Red for loss, Green for profit)
sns.heatmap(monthly_profit_loss_data.T, cmap='RdYlGn', center=0, annot=True, fmt='.0f', cbar_kws={'label': 'Profit/Loss ($)'})

# Add labels for the axes
plt.xlabel('Month')
plt.ylabel('')

# Add a title
plt.title('Profit/Loss Heatmap (Diverging Colormap)')

# Display the plot
plt.show()

Exemple de visualisation d'une carte de couleurs divergentes avec Matplotlib. Image par l'auteur.

Cartes de couleurs cycliques

Les cartes de couleurs cycliques sont utiles pour visualiser des données représentant un modèle répétitif ou cyclique, comme des angles, des phases de vagues ou l'heure de la journée. Un exemple de carte de couleurs cyclique en action est la visualisation des phases d'une fonction périodique, telle qu'une onde sinusoïdale.

# Create data for a sine wave
x = np.linspace(0, 2 * np.pi, 100)  # X values from 0 to 2π (one complete cycle)
y = np.sin(x)  # Y values (sine of X)

# Create a figure and axis
plt.figure(figsize=(10, 6))

# Create a scatter plot with a cyclic colormap
# Color points by their position in the sine wave cycle
points = plt.scatter(x, y, c=x, cmap='twilight', edgecolor='black')

# Add a color bar to show the phase of the wave
cbar = plt.colorbar(points)
cbar.set_label('Wave Phase (Radians)', rotation=270, labelpad=15)

# Label the axes
plt.xlabel('Angle (Radians)')
plt.ylabel('Sine Value')

# Add a title
plt.title('Sine Wave with Cyclic Colormap (Twilight)')

# Display the plot
plt.grid(True)
plt.show()

Exemple de visualisation d'une carte de couleurs cyclique avec Matplotlib. Image par l'auteur.

Cartes de couleurs qualitatives

Les cartes de couleurs qualitatives sont idéales pour représenter des données catégorielles sans ordre particulier des catégories. Les cartes de couleurs qualitatives sont couramment utilisées dans les diagrammes circulaires où chaque segment représente une catégorie différente qui peut être facilement distinguée.

# Sample categorical data
categories = ['Category A', 'Category B', 'Category C', 'Category D', 'Category E']
values = [20, 35, 25, 10, 10]

# Set the figure size
plt.figure(figsize=(8, 8))

# Define a qualitative colormap manually (similar to 'Set3' in Seaborn)
colors = ['#8dd3c7', '#ffffb3', '#bebada', '#fb8072', '#80b1d3']  # Manually selected color hex codes

# Create a pie chart
plt.pie(values, labels=categories, autopct='%1.1f%%', startangle=90, colors=colors)

# Equal aspect ratio ensures the pie is drawn as a circle
plt.axis('equal')

# Add a title
plt.title('Pie Chart with Qualitative Colormap')

# Display the chart
plt.show()

Exemple de visualisation qualitative d'une carte des couleurs dans Matplotlib. Image par l'auteur.

Cartes de couleurs arc-en-ciel

Les cartes de couleurs arc-en-ciel telles que hsv sont utilisées lorsqu'une large gamme de teintes est nécessaire.

# Generate cyclic data
x = np.linspace(0, 2 * np.pi, 500)
y = np.sin(x)

# Create a plot with rainbow colormap
plt.scatter(x, y, c=x, cmap='hsv', s=50)

# Add a color bar
plt.colorbar(label='Phase')

# Add labels and title
plt.xlabel('Angle (radians)')
plt.ylabel('Sine Value')
plt.title('Cyclic Data Visualization using HSV Colormap')

# Display the plot
plt.show()

Exemple de visualisation d'une carte de couleurs arc-en-ciel avec Matplotlib. Image par l'auteur.

Cartes de couleurs uniformes sur le plan de la perception

Les cartes de couleurs telles que inferno et plasma offrent une meilleure visibilité sur différents supports d'affichage.

# Generate synthetic elevation data
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2)) * 100  # Elevation data

# Plot the elevation data using the 'plasma' colormap
plt.contourf(X, Y, Z, cmap='plasma')

# Add a color bar
plt.colorbar(label='Elevation (m)')

# Add title and labels
plt.title('Topographic Map (Plasma Colormap)')
plt.xlabel('X Coordinate')
plt.ylabel('Y Coordinate')

# Display the plot
plt.show()

Exemple de visualisation d'une carte de couleurs uniforme et perceptuelle dans Matplotlib. Image par l'auteur.

Création et modification des cartes de couleurs Matplotlib

Bien que Matplotlib dispose d'une grande variété de cartes de couleurs intégrées, il existe des scénarios dans lesquels vous souhaiteriez personnaliser vos couleurs. Les outils clés pour créer des cartes de couleurs personnalisées dans Matplotlib sont ListedColormap et LinearSegmentedColormap.

Création d'une carte de couleurs personnalisée avec ListedColormap

ListedColomap vous permet de créer une carte des couleurs à partir d'une liste de couleurs spécifiques. Cette méthode est utile pour attribuer des couleurs spécifiques à des catégories distinctes dans des données catégorielles. 

from matplotlib.colors import ListedColormap

# Categorical data
categories = ['Category A', 'Category B', 'Category C', 'Category D']
values = [25, 40, 35, 30]

# Custom color list for the colormap (e.g., shades of blue, green, red, and purple)
custom_colors = ['#1f77b4', '#2ca02c', '#d62728', '#9467bd']

# Create a ListedColormap using the custom colors
custom_cmap = ListedColormap(custom_colors)

# Set the figure size
plt.figure(figsize=(8, 6))

# Create a bar plot with the custom colormap
bars = plt.bar(categories, values, color=custom_cmap.colors)

# Add a title
plt.title('Bar Chart with Custom ListedColormap')

# Label the axes
plt.xlabel('Categories')
plt.ylabel('Values')

# Display the plot
plt.show()

Matplotlib custom colormap avec ListedColormap. Image par l'auteur.

Création d'une carte de couleurs personnalisée avec LinearSegmentedColormap

LinearSegmentedColormap vous permet de créer des cartes de couleurs qui assurent une transition harmonieuse entre les couleurs. Il est utile de le savoir, car les données continues nécessitent souvent des changements de couleur en dégradé. Ici, je spécifie également le nombre d'intervalles que je souhaite pour mon visuel.

from matplotlib.colors import LinearSegmentedColormap

# Create a grid of values for a 2D Gaussian function
x = np.linspace(-2, 2, 500)
y = np.linspace(-2, 2, 500)
X, Y = np.meshgrid(x, y)
Z = np.exp(- (X**2 + Y**2))

# Define a custom colormap that transitions from blue to white to red
colors = ['blue', 'white', 'red']
custom_cmap = LinearSegmentedColormap.from_list('blue_white_red', colors)

# Adjust the number of color classes (discrete levels)
# Specify the number of levels (e.g., 10 for 10 distinct color bands)
num_classes = 10
levels = np.linspace(Z.min(), Z.max(), num_classes)

# Set the figure size
plt.figure(figsize=(8, 6))

# Plot the 2D Gaussian function with the adjusted colormap
contour = plt.contourf(X, Y, Z, levels=levels, cmap=custom_cmap)

# Add a color bar to show the discrete color classes
plt.colorbar(contour, label='Gaussian Function Value')

# Add labels for the axes
plt.xlabel('X')
plt.ylabel('Y')

# Add a title
plt.title(f'2D Gaussian with {num_classes} Discrete Color Classes')

# Display the plot
plt.show()

Matplotlib ajuste le nombre de classes de couleurs. Image par l'auteur.

Personnalisation des gammes de couleurs et de l'intensité

Vous pouvez contrôler l'intensité ou la gamme de couleurs d'une carte des couleurs existante en manipulant sa normalisation ou en la découpant pour utiliser un sous-ensemble des couleurs disponibles. Dans l'exemple suivant, les gammes de couleurs sont découpées pour indiquer des températures comprises entre 16 et 40 degrés Celsius.

# Set up the plot for the heatmap
plt.figure(figsize=(12, 8))

# Define a custom normalization for temperature range
norm = mcolors.Normalize(vmin=16, vmax=40)

# Create the heatmap with a sequential colormap
heatmap = plt.imshow(monthly_temperature_table, cmap='YlOrRd', aspect='auto', norm=norm)

# Add color bar to represent temperature
colorbar = plt.colorbar(heatmap, orientation='horizontal')
colorbar.set_label('Temperature (°C)', labelpad=10)

# Label the axes
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Set y-ticks to display month names instead of numbers
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Add a title to the heatmap
plt.title('Monthly Temperature Heatmap (Sequential Colormap)')

# Display the plot
plt.grid(False)
plt.show()

Matplotlib : personnalisation des plages de couleurs et de l'intensité. Image par l'auteur.

Combinaison de cartes de couleurs existantes

Vous pouvez également combiner des cartes de couleurs existantes en mélangeant plusieurs cartes de couleurs pour créer des visualisations plus complexes.

from matplotlib.colors import LinearSegmentedColormap, Normalize

# Create synthetic elevation data
x = np.linspace(-180, 180, 500)  # Longitude
y = np.linspace(-90, 90, 250)    # Latitude
X, Y = np.meshgrid(x, y)
Z = 5000 * np.sin(np.sqrt(X**2 + Y**2) * np.pi / 180)  # Synthetic elevation data

# Define the base colormaps ('viridis' and 'cividis')
cmap1 = plt.get_cmap('viridis')
cmap2 = plt.get_cmap('cividis')

# Create a custom colormap by blending the two base colormaps
def blend_colormaps(cmap1, cmap2, blend_ratio=0.5):
    """Blend two colormaps together."""
    c1 = cmap1(np.linspace(0, 1, 256))
    c2 = cmap2(np.linspace(0, 1, 256))
    blended_colors = (1 - blend_ratio) * c1 + blend_ratio * c2
    return LinearSegmentedColormap.from_list('blended_cmap', blended_colors)

# Create the blended colormap
custom_cmap = blend_colormaps(cmap1, cmap2, blend_ratio=0.5)

# Normalize the data for visualization
norm = Normalize(vmin=-5000, vmax=5000)

# Set the figure size
plt.figure(figsize=(12, 6))

# Plot the synthetic elevation data with the blended colormap
contour = plt.contourf(X, Y, Z, levels=100, cmap=custom_cmap, norm=norm)

# Add a color bar to show the blended color mapping
plt.colorbar(contour, label='Elevation (meters)')

# Add labels for the axes
plt.xlabel('Longitude')
plt.ylabel('Latitude')

# Add a title
plt.title('Geographical Elevation Data with Blended Colormap (Viridis + Cividis)')

# Display the plot
plt.show()

Matplotlib Combinaison de cartes de couleurs existantes. Image par l'auteur.

Inversion des cartes de couleurs à l'aide du suffixe _r

Vous pouvez inverser n'importe quelle carte de couleurs dans Matplotlib en ajoutant le suffixe _r à son nom.

# Import required libraries
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors

# Set up the plot for the heatmap
plt.figure(figsize=(12, 8))

# Create a custom normalization for the color range
norm = mcolors.Normalize(vmin=16, vmax=40)

# Set the figure size
plt.figure(figsize=(12, 8))

# Create a heatmap with a sequential colormap
ax = sns.heatmap(temperature_pivot, cmap='YlOrRd_r', cbar=True, square=True, norm=norm, cbar_kws={'orientation': 'horizontal'})

# Add labels for the axes
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Add a color bar label (temperature in °C)
colorbar = ax.collections[0].colorbar
colorbar.set_label('Temperature (°C)', labelpad=10)

# Add a title
plt.title('Temperature Heatmap (Sequential Colormap)')

# Display the plot
plt.show()

Matplotlib Inverser les cartes de couleurs en utilisant le suffixe _r. Image par l'auteur.

Gestion des erreurs courantes dans les cartes de couleurs de Matplotlib

Lorsque vous travaillez avec des cartes de couleurs dans Matplotlib, vous pouvez rencontrer des erreurs qui affectent votre flux de travail. Vous trouverez ci-dessous quelques-unes des erreurs et la manière de les résoudre.

AttributeError : le module 'matplotlib' n'a pas d'attribut 'colormaps'.

Cette erreur se produit lorsque vous utilisez des versions de Matplotlib antérieures à 3.4.0 pour accéder à matplotlib.colormaps. L'attribut colormaps a été introduit dans Matplotlib 3.4.0. Tout d'abord, vérifiez votre version de Matplotlib en utilisant le code ci-dessous pour résoudre cette erreur.

import matplotlib
print(matplotlib.__version__)

Mettez à jour en utilisant la commande pip suivante.

pip install --upgrade matplotlib

Si vous rencontrez des problèmes lors de la mise à jour de votre version de Matplotlib, essayez la méthode suivante pour accéder aux cartes de couleurs.

plt.get_cmap('viridis')  # instead of matplotlib.colormaps['viridis']

Affectation incorrecte des couleurs

Il se peut que l'attribution des couleurs soit incorrecte lorsque vous passez une valeur en dehors de la plage attendue ou lorsque la carte des couleurs est appliquée de manière incorrecte. L'attribution de couleurs incorrectes peut également survenir si la carte des couleurs est destinée à des données continues mais est appliquée à des données catégorielles ou vice versa.

Pour vous assurer que vos données se situent dans la fourchette prévue, normalisez-les ou mettez-les à l'échelle à l'aide des paramètres vmax et vmin.

import matplotlib.colors as mcolors

# Create a sample temperature dataset
data = np.random.rand(10, 10) * 100  # Adjust the range to match your data

# Create a color normalization instance to scale the data to the colormap's range
norm = mcolors.Normalize(vmin=0, vmax=100)

# Create a heatmap using the 'viridis' colormap and the specified normalization
plt.imshow(data, cmap='viridis', norm=norm, interpolation='nearest')
plt.colorbar()
plt.show()

Pour un contrôle plus fin, vous pouvez définir explicitement les limites de la couleur à l'aide des paramètres boundaries ou norm dans les fonctions de traçage.

Artéfacts visuels et résultats inattendus

Lorsque vous travaillez avec des données discrètes ou à faible résolution, vous pouvez observer des bandes de couleur involontaires, un contraste excessif ou des saignements de couleur. Le problème se pose lorsque vos données ont une portée limitée mais sont affichées avec une carte de couleurs continue.

Pour résoudre ce problème, utilisez davantage de points de données ou ajustez le nombre de niveaux de couleur afin d'atténuer les transitions.

# Increase the number of bins in the colormap
cmap = plt.get_cmap('viridis', 256)
plt.imshow(data, cmap=cmap)

Vous pouvez diviser la carte des couleurs en niveaux fixes pour traiter les données discrètes, le cas échéant.

cmap = plt.get_cmap('inferno', 10)  # Divide colormap into 10 discrete levels
plt.imshow(data, cmap=cmap)

Vous pouvez également vérifier les paramètres d'affichage et ajuster la résolution, en particulier lors de l'enregistrement des visualisations, afin d'éviter les graphiques à faible résolution.

plt.savefig('plot.png', dpi=300)  # Save the figure with a higher resolution

Distorsion des couleurs due à l'écrêtage

La distorsion des couleurs se produit lorsque les données contiennent des valeurs extrêmes en dehors de la gamme de couleurs attendue. Des parties des données sont alors coupées et la couleur minimale ou maximale de la carte des couleurs leur est attribuée.

Pour éviter la distorsion des couleurs, réglez les limites de couleur à l'aide de vmin et vmax pour qu'elles correspondent à la plage de vos données, afin d'éviter l'écrêtage.

plt.imshow(data, cmap='plasma', vmin=0, vmax=100)

Vous devez également utiliser une mise à l'échelle robuste pour traiter les valeurs aberrantes en définissant des limites personnalisées qui excluent les valeurs extrêmes.

import numpy as np
robust_vmin, robust_vmax = np.percentile(data, [2, 98])  # Use percentiles to remove extreme outliers
plt.imshow(data, cmap='inferno', vmin=robust_vmin, vmax=robust_vmax)

La carte des couleurs ne s'affiche pas correctement dans les tracés 3D

S'il y a un problème avec la façon dont les données sont cartographiées dans la surface 3D, les cartes de couleurs peuvent ne pas s'afficher correctement dans les visualisations 3D. Pour résoudre ce problème, assurez-vous que les données de l'axe des z sont normalisées de manière à ce qu'elles s'inscrivent dans l'intervalle prévu pour la carte des couleurs. Utilisez également les limites appropriées de la carte des couleurs pour capturer toute la gamme des valeurs z.

from mpl_toolkits.mplot3d import Axes3D

# Generate sample data for a 3D surface plot
X, Y = np.meshgrid(np.linspace(-5, 5, 50), np.linspace(-5, 5, 50))
Z = np.sin(np.sqrt(X**2 + Y**2))

# Create a 3D axes object
ax = plt.axes(projection='3d')

# Plot the surface using the 'viridis' colormap and adjusting the color limits
ax.plot_surface(X, Y, Z, cmap='viridis', vmin=np.min(Z), vmax=np.max(Z))
plt.show()

Conclusion

Le choix de la bonne carte des couleurs est une étape importante, car elle affecte réellement la façon dont les utilisateurs visualisent et comprennent vos données. À mon avis, consacrer beaucoup de temps à l'analyse des données tout en négligeant l'étape finale, qui consiste à communiquer vos résultats, est une grave erreur.

Heureusement, Matplotlib offre de nombreuses options pour s'assurer que vos visuels racontent une histoire convaincante. Inscrivez-vous à notre cours, Introduction à la visualisation de données avec Matplotlib, pour devenir un expert. De plus, si vous êtes un utilisateur de Python qui utilise également Seaborn pour la visualisation (il est bon de connaître les deux), lisez notre Quick Guide to Picking Colors in Seaborn et suivez-le avec notre cours Introduction to Data Visualization with Seaborn (Introduction à la visualisation de données avec Seaborn ).