Pourquoi Matplotlib est-il si lent ?

Lors de l'évaluation des bibliothèques de traçage Python, il est important de prendre en compte les performances. Matplotlib, une bibliothèque largement utilisée, peut sembler lente, ce qui soulève des questions quant à son accélération ou à l'exploration d'options alternatives. Examinons le problème et explorons les solutions possibles.

L'exemple fourni présente un tracé avec plusieurs sous-tracés et mises à jour de données. Avec Matplotlib, ce processus implique de tout redessiner, y compris les limites des axes et les étiquettes de graduation, ce qui entraîne un ralentissement des performances.

Comprendre les goulots d'étranglement

Deux facteurs clés contribuent à la lenteur :

1. Redessin excessif : La fonction fig.canvas.draw() de Matplotlib redessine la figure entière, même lorsque seule une petite partie doit être mise à jour.
2. Étiquettes de tiques abondantes : Un grand nombre d'étiquettes de tiques et de sous-traces peuvent considérablement alourdir le processus de dessin.

Optimisation avec Blitting

Pour résoudre ces goulots d'étranglement , pensez à utiliser le blitting. Le Blitting consiste à mettre à jour uniquement des parties spécifiques de la figure, réduisant ainsi le temps de rendu. Cependant, un code spécifique au backend est nécessaire pour une implémentation efficace, ce qui peut nécessiter l'intégration de tracés Matplotlib dans une boîte à outils GUI. La technique peut fournir des performances raisonnables sans dépendance au backend :

Capturer l'arrière-plan :

Avant l'animation, capturez l'arrière-plan de chaque sous-intrigue pour le restaurer plus tard.

Mettre à jour et Draw :
1. Pour chaque image, mettez à jour les données et l'artiste des lignes, en restaurant l'arrière-plan et en supprimant la partie mise à jour.
Évitez de redessiner :
2. Utilisez fig.canvas.blit( ax.bbox) au lieu de fig.canvas.draw() pour mettre à jour uniquement la zone nécessaire.
3. Exemple d'implémentation :

importer matplotlib. pyplot en tant que plt importer numpy en tant que np x = np.arange(0, 2*np.pi, 0.1) y = np.sin(x) fig, axes = plt.subplots(nrows=6) styles = ['r-', 'g-', 'y-', 'm-', 'k-', 'c-'] def plot(hache, style) : retourner ax.plot(x, y, style, animé=True)[0] lignes = [plot(ax, style) pour hache, style dans zip(axes, styles)] # Capturer l'arrière-plan backgrounds = [fig.canvas.copy_from_bbox(ax.bbox) pour hache en axes] pour moi dans xrange(1, 2000) : pour j, (ligne, hache, arrière-plan) dans enumerate(zip(lignes, axes, arrière-plans), start=1) : fig.canvas.restore_region (arrière-plan) line.set_ydata(np.sin(j*x i/10.0)) ax.draw_artist(ligne) fig.canvas.blit(ax.bbox)

Module d'animation

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(0, 2*np.pi, 0.1)
y = np.sin(x)

fig, axes = plt.subplots(nrows=6)

styles = ['r-', 'g-', 'y-', 'm-', 'k-', 'c-']
def plot(ax, style):
    return ax.plot(x, y, style, animated=True)[0]

lines = [plot(ax, style) for ax, style in zip(axes, styles)]

# Capture Background
backgrounds = [fig.canvas.copy_from_bbox(ax.bbox) for ax in axes]

for i in xrange(1, 2000):
    for j, (line, ax, background) in enumerate(zip(lines, axes, backgrounds), start=1):
        fig.canvas.restore_region(background)
        line.set_ydata(np.sin(j*x   i/10.0))
        ax.draw_artist(line)
        fig.canvas.blit(ax.bbox)

importer matplotlib.pyplot en tant que plt importer matplotlib.animation en tant qu'animation par défaut animer (i): pour j, ligne dans enumerate(lines, start=1) : line.set_ydata(np.sin(j*x i/10.0)) ani = animation.FuncAnimation(fig, animer, xrange(1, 200), interval=0, blit=True)