pourquoi est-comploter avec Matplotlib-elle si lente?

Tout d'abord, (bien que cela ne changera pas la performance à tous) d'envisager le nettoyage de votre code, similaire à ceci:

import matplotlib.pyplot as plt
import numpy as np
import time
x = np.arange(0, 2*np.pi, 0.01)
y = np.sin(x)
fig, axes = plt.subplots(nrows=6)
styles = ['r-', 'g-', 'y-', 'm-', 'k-', 'c-']
lines = [ax.plot(x, y, style)[0] for ax, style in zip(axes, styles)]
fig.show()
tstart = time.time()
for i in xrange(1, 20):
for j, line in enumerate(lines, start=1):
line.set_ydata(np.sin(j*x + i/10.0))
fig.canvas.draw()
print 'FPS:' , 20/(time.time()-tstart)

Avec l'exemple ci-dessus, j'obtiens environ 10 images par seconde.

Juste une petite remarque, en fonction de votre cas d'utilisation, matplotlib peut-être pas un grand choix. Il est orienté vers la qualité publication des chiffres, pas d'affichage en temps réel.

Cependant, il y a beaucoup de choses que vous pouvez faire à la vitesse de cet exemple jusqu'.

Il y a deux principales raisons à cela est aussi lent que c'est.

1) en Appelant fig.canvas.draw() redessine tout. C'est votre goulot d'étranglement. Dans votre cas, vous n'avez pas besoin de re-dessiner des choses comme les axes de frontières, les étiquettes de graduation, etc.

2) Dans votre cas, il y a beaucoup de sous-intrigues avec un lot d'étiquettes de graduation. Ils prennent beaucoup de temps pour dessiner.

Ces deux peut être résolu par l'utilisation de blitting.

Faire blitting de manière efficace, vous aurez à utiliser backend-code spécifique. Dans la pratique, si vous êtes vraiment inquiet à propos des animations fluides, vous êtes habituellement l'incorporation de matplotlib parcelles dans une sorte de boite à outils graphique, de toute façon, donc ce n'est pas vraiment un problème.

Toutefois, sans le savoir un peu plus sur ce que vous êtes en train de faire, je ne peux pas vous aider là-bas.

Néanmoins, il existe un gui-neutre façon de faire qui est encore assez rapide.

import matplotlib.pyplot as plt
import numpy as np
import time
x = np.arange(0, 2*np.pi, 0.1)
y = np.sin(x)
fig, axes = plt.subplots(nrows=6)
fig.show()
# We need to draw the canvas before we start animating...
fig.canvas.draw()
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)]
# Let's capture the background of the figure
backgrounds = [fig.canvas.copy_from_bbox(ax.bbox) for ax in axes]
tstart = time.time()
for i in xrange(1, 2000):
items = enumerate(zip(lines, axes, backgrounds), start=1)
for j, (line, ax, background) in items:
fig.canvas.restore_region(background)
line.set_ydata(np.sin(j*x + i/10.0))
ax.draw_artist(line)
fig.canvas.blit(ax.bbox)
print 'FPS:' , 2000/(time.time()-tstart)

Cela me donne ~200fps.

Pour rendre cela un peu plus pratique, il y a un animations module dans les versions récentes de matplotlib.

Comme un exemple:

import matplotlib.pyplot as plt
import matplotlib.animation as animation
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)]
def animate(i):
for j, line in enumerate(lines, start=1):
line.set_ydata(np.sin(j*x + i/10.0))
return lines
# We'd normally specify a reasonable "interval" here...
ani = animation.FuncAnimation(fig, animate, xrange(1, 200), 
interval=0, blit=True)
plt.show()

Pour commencer, Joe kingston portant la réponse de donne de très bons conseils, à l'aide de l'interface approche neutre, et vous devriez certainement prendre ses conseils (notamment sur la Blitting) et la mettre en pratique. Plus d'infos sur cette approche, lire la Matplotlib Livre De Recettes

Cependant, la non-GUI-neutre (GUI-biaisée?) approche est essentielle pour accélérer le tracé. En d'autres termes, la backend est extrêmement important pour l'intrigue de la vitesse.

Mettre ces deux lignes avant d'importer quoi que ce soit d'autre de matplotlib:

import matplotlib
matplotlib.use('GTKAgg') 

Bien sûr, il y a plusieurs options pour utiliser à la place de GTKAgg, mais selon le livre mentionné avant, c'était le plus rapide. Voir le lien sur les backends pour plus d'options.

Cela peut ne pas s'appliquer à beaucoup d'entre vous, mais je suis en général d'exploitation de mon ordinateurs sous Linux, donc par défaut je enregistrer mon matplotlib parcelles PNG et SVG. Cela fonctionne très bien sous Linux, mais est insupportablement lent sur mon Windows 7 installations [MiKTeX sous Python(x,y) ou Anaconda], j'ai donc pris pour l'ajout de ce code, et les choses fonctionnent bien sur il y a de nouveau:

import platform     # Don't save as SVG if running under Windows.
#
# Plot code goes here.
#
fig.savefig('figure_name.png', dpi = 200)
if platform.system() != 'Windows':
# In my installations of Windows 7, it takes an inordinate amount of time to save
# graphs as .svg files, so on that platform I've disabled the call that does so.
# The first run of a script is still a little slow while everything is loaded in,
# but execution times of subsequent runs are improved immensely.
fig.savefig('figure_name.svg')