Performance

Qu'il s'agisse d'explorer des données en mode interactif ou d'enregistrer de nombreux tracés par programmation, les performances de rendu peuvent constituer un goulot d'étranglement difficile dans votre pipeline. Matplotlib fournit plusieurs façons de réduire considérablement le temps de rendu au prix d'un léger changement (à une tolérance réglable) dans l'apparence de votre tracé. Les méthodes disponibles pour réduire le temps de rendu dépendent du type de tracé en cours de création.

Simplification de segment de ligne

Pour les tracés qui ont des segments de ligne (par exemple, des tracés linéaires typiques, des contours de polygones, etc.), les performances de rendu peuvent être contrôlées par rcParams["path.simplify"](par défaut : True) et rcParams["path.simplify_threshold"](par défaut : 0.111111111111), qui peuvent être définis par exemple dans le matplotlibrcfichier (voir Personnalisation de Matplotlib avec le style sheets et rcParams pour plus d'informations sur le matplotlibrcfichier). rcParams["path.simplify"](par défaut : True) est un booléen indiquant si les segments de ligne sont simplifiés ou non. rcParams["path.simplify_threshold"](par défaut : 0.111111111111) contrôle le nombre de segments de ligne simplifiés ; des seuils plus élevés entraînent un rendu plus rapide.

Le script suivant affichera d'abord les données sans aucune simplification, puis affichera les mêmes données avec une simplification. Essayez d'interagir avec les deux :

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl

# Setup, and create the data to plot
y = np.random.rand(100000)
y[50000:] *= 2
y[np.geomspace(10, 50000, 400).astype(int)] = -1
mpl.rcParams['path.simplify'] = True

mpl.rcParams['path.simplify_threshold'] = 0.0
plt.plot(y)
plt.show()

mpl.rcParams['path.simplify_threshold'] = 1.0
plt.plot(y)
plt.show()

Matplotlib utilise actuellement par défaut un seuil de simplification prudent de 1/9. Pour modifier les paramètres par défaut afin d'utiliser une valeur différente, modifiez le matplotlibrcfichier. Alternativement, les utilisateurs peuvent créer un nouveau style pour le traçage interactif (avec une simplification maximale) et un autre style pour un traçage de qualité de publication (avec une simplification minimale) et les activer si nécessaire. Voir Personnalisation de Matplotlib avec des feuilles de style et rcParams pour obtenir des instructions sur la façon d'effectuer ces actions.

La simplification fonctionne en fusionnant de manière itérative des segments de ligne en un seul vecteur jusqu'à ce que la distance perpendiculaire du segment de ligne suivant au vecteur (mesurée dans l'espace de coordonnées d'affichage) soit supérieure au path.simplify_thresholdparamètre.

Noter

Des modifications liées à la façon dont les segments de ligne sont simplifiés ont été apportées dans la version 2.1. Le temps de rendu sera toujours amélioré par ces paramètres avant la version 2.1, mais le temps de rendu pour certains types de données sera considérablement amélioré dans les versions 2.1 et supérieures.

Sous-échantillonnage de marqueur

Les marqueurs peuvent également être simplifiés, bien que de manière moins robuste que les segments de ligne. Le sous-échantillonnage de marqueur n'est disponible que pour les Line2Dobjets (via la markeverypropriété). Partout où Line2Dles paramètres de construction sont transmis, tels que pyplot.plotet Axes.plot, le markeveryparamètre peut être utilisé :

plt.plot(x, y, markevery=10)

L' markeveryargument permet un sous-échantillonnage naïf ou une tentative d'échantillonnage à intervalles réguliers (le long de l' axe des x ). Voir la démo Markevery pour plus d'informations.

Fractionnement des lignes en plus petits morceaux

Si vous utilisez le backend Agg (voir Qu'est-ce qu'un backend ? ), alors vous pouvez utiliser rcParams["agg.path.chunksize"](par défaut : 0) Cela permet aux utilisateurs de spécifier une taille de bloc, et toutes les lignes avec plus que ce nombre de sommets seront divisées en plusieurs lignes , dont chacun n'a pas plus de agg.path.chunksize plusieurs sommets. (Sauf si agg.path.chunksizevaut zéro, auquel cas il n'y a pas de segmentation.) Pour certains types de données, la segmentation de la ligne en tailles raisonnables peut réduire considérablement le temps de rendu.

Le script suivant affichera d'abord les données sans aucune restriction de taille de bloc, puis affichera les mêmes données avec une taille de bloc de 10 000. La différence est mieux visible lorsque les chiffres sont grands, essayez de maximiser l'interface graphique, puis d'interagir avec eux :

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.rcParams['path.simplify_threshold'] = 1.0

# Setup, and create the data to plot
y = np.random.rand(100000)
y[50000:] *= 2
y[np.geomspace(10, 50000, 400).astype(int)] = -1
mpl.rcParams['path.simplify'] = True

mpl.rcParams['agg.path.chunksize'] = 0
plt.plot(y)
plt.show()

mpl.rcParams['agg.path.chunksize'] = 10000
plt.plot(y)
plt.show()

Légendes

Le comportement de légende par défaut pour les axes tente de trouver l'emplacement qui couvre le moins de points de données ( loc='best'). Cela peut être un calcul très coûteux s'il y a beaucoup de points de données. Dans ce cas, vous voudrez peut-être fournir un emplacement spécifique.

Utilisation du style rapide

Le style rapide peut être utilisé pour définir automatiquement les paramètres de simplification et de segmentation sur des paramètres raisonnables afin d'accélérer le traçage de grandes quantités de données. Le code suivant l'exécute :

import matplotlib.style as mplstyle
mplstyle.use('fast')

Il est très léger, il fonctionne donc bien avec d'autres styles. Assurez-vous que le style rapide est appliqué en dernier afin que les autres styles n'écrasent pas les paramètres :

mplstyle.use(['dark_background', 'ggplot', 'fast'])