[IPython 3.xx] Matplotlib

Version imprimable

Bonjour,

Je veux renouveler un graphique dans une boucle while.
Mais les graphiques s'empilent l'un après l'autre.
Est ce possible ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 import matplotlib.pylab as plt %matplotlib inline import time global pulse pulse=[0] while True: t = time.strftime("%Hh%M") m = int(time.strftime("%M")) if m%5 ==0 : time.sleep(30) t = time.strftime("%Hh%M") file = !ls ./ima_train dd =t+' : '+str(len(file)) pulse.append(len(file)) print(dd) time.sleep(80) plt.plot(pulse) plt.show()
pulse compte des fichiers dans ima_train
c'est un traitement d'image que je veux suivre
avec une courbe de temps

@+

25/09/2018, 22h11
racine carrée

Il y a sûrement un moyen de fermer la fenêtre (je crois qu'il faudrait regarder du côté d'un module comme tkinter, ou encore pygame) et de rouvrir le nouveau graphique, et cela périodiquement, mais je ne crois pas que l'on puisse modifier un graphique déjà tracé (le module matplotlib n'a pas été conçu pour cela, à ce que je sache, mais je ne suis pas sûr à 100% !).
25/09/2018, 22h52
lg_53

Il faut voir le type de tracé que vous faites mais une bonne partie des objets matplotlib possèdent des setters (notamment set_data) pour modifier directement les données sous jacente sans avoir à retracer tout le graphique.

Citation:

Envoyé par lg_53

Il faut voir le type de tracé que vous faites mais une bonne partie des objets matplotlib possèdent des setters (notamment set_data) pour modifier directement les données sous jacente sans avoir à retracer tout le graphique.

Très juste, voici un exemple illustrant set_data
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 import time import numpy as np import matplotlib.pyplot as plt # Fait en sorte que le traçage soit interactif. Sinon la figure est affichée qu'à la toute fin. plt.ion() def gen_random_data(n): return np.random.random(n) x = np.linspace(0, 50, 50) # On crée un figure qui sera mise à jour au fur et à mesure fig, ax = plt.subplots() ax.grid(True) ax.set_ylim((0, 1)) # On crée un ligne "vide" dont les points seront mis à jours. l, = ax.plot(x, np.ones_like(x)) # Toutes les secondes de nouvelles données sont générées et le graph est # mis à jour for i in range(10): y = gen_random_data(50) l.set_data(x, y) # Là réside l'astuce. Il faut demander à retracer la figure, sinon # rien ne se passe. fig.canvas.draw() time.sleep(1)
A noter que dans cet exemple, la figure n'est pas recadrée à chaque update. Donc si les nouvelles valeurs sont en dehors des bornes initialement définies, on ne les voit pas.

J

26/09/2018, 10h59
racine carrée
Citation:
Code:

1 2 3 4 ... # Fait en sorte que le traçage soit interactif. Sinon la figure est affichée qu'à la toute fin. plt.ion() ...
Je ne sais pas ce que fait ce programme quand vous le testez, mais chez moi la fenêtre 'figure 1' s'ouvre mais rien ne s'y trace (elle ne répond pas), et au bout de 10 secondes, le tracé apparait d'un coup.
26/09/2018, 13h55
Julien N

Citation:

Envoyé par racine carrée

Je ne sais pas ce que fait ce programme quand vous le testez, mais chez moi la fenêtre 'figure 1' s'ouvre mais rien ne s'y trace (elle ne répond pas), et au bout de 10 secondes, le tracé apparait d'un coup.

Salut,

Intéressant, chez moi ça marche bien (j'ai quand même testé avant de poster :)). J'ai matplotlib en version 2.2.2 pour info et j'execute mon code depuis une console.

J

Où placer plt.show() ?
C'est ce qui déclanche l'affichage dans la page Ipython

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import time
import numpy as np
import matplotlib.pyplot as plt
 
# Fait en sorte que le traçage soit interactif. Sinon la figure est affichée qu'à la toute fin.
plt.ion()
 
def gen_random_data(n):
    return np.random.random(n)
 
x = np.linspace(0, 50, 50)
 
# On crée un figure qui sera mise à jour au fur et à mesure
fig, ax = plt.subplots()
ax.grid(True)
ax.set_ylim((0, 1))
 
# On crée un ligne "vide" dont les points seront mis à jours.
l, = ax.plot(x, np.ones_like(x))
 
# Toutes les secondes de nouvelles données sont générées et le graph est
# mis à jour
for i in range(10):
    y = gen_random_data(50)
    l.set_data(x, y)
    # Là réside l'astuce. Il faut demander à retracer la figure, sinon
    # rien ne se passe.
    fig.canvas.draw()
    time.sleep(10)

Citation:

# Là réside l'astuce. Il faut demander à retracer la figure, sinon
# rien ne se passe.
fig.canvas.draw()
print(i)
plt.show()
time.sleep(10)

Ipython reste statique avec i=0
La page dynamique dans Ipython est impossible

Merci de votre apport sur ce sujet

Hors Ipython,je ne vois pas les points avec une boucle while :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import time
import os
import numpy as np
import matplotlib.pyplot as plt
 
# Fait en sorte que le traçage soit interactif. Sinon la figure est affichée qu'à la toute fin.
plt.ion()
 
x = np.linspace(0, 50, 50)
# On crée un figure qui sera mise à jour au fur et à mesure
fig, ax = plt.subplots()
ax.grid(True)
ax.set_ylim((0, 1))
 
# On crée un ligne "vide" dont les points seront mis à jours.
l, = ax.plot(x, np.ones_like(x)) 
 
while True:
 
    t = time.strftime("%Hh%M")
    m = int(time.strftime("%M"))
 
    if m%2 ==0 :
        time.sleep(10)
        t = time.strftime("%Hh%M")
        path = '/..../'
        file = os.listdir(path)
        l.set_data(x, len(file))       
        fig.canvas.draw()
        time.sleep(1)
        print(len(file))

J'ai pas fait attention au fait que vous utilisiez un notebook IPython. Je ne maitrise pas ce sujet. Je viens de trouver cette réponse sur stackoverflow qui pourrait répondre à votre problème. Je copie le code ci-après:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 %matplotlib notebook import numpy as np import matplotlib.pyplot as plt import time def pltsin(ax, colors=['b']): x = np.linspace(0,1,100) if ax.lines: for line in ax.lines: line.set_xdata(x) y = np.random.random(size=(100,1)) line.set_ydata(y) else: for color in colors: y = np.random.random(size=(100,1)) ax.plot(x, y, color) fig.canvas.draw() fig,ax = plt.subplots(1,1) ax.set_xlabel('X') ax.set_ylabel('Y') ax.set_xlim(0,1) ax.set_ylim(0,1) for f in range(5): pltsin(ax, ['b', 'r']) time.sleep(1)
Par contre, hors IPython, vous avez un problème avec le contenu de votre boucle while. Vous faites:

Code:

l.set_data(x, len(file))

Mais x est un array de 50 éléments alors que len(file) est un entier. C'est étonnant que vous n'ayez pas de message d'erreur. Que cherchez vous à tracer?

J

26/09/2018, 19h44
bm

len(file) c'est pour suivre une boucle while qui converti des images dans un dossier
1024x1024 pixels en 128x128 pixels

Cela va bien au début et ensuite python sature
C'est un mix avec PIL , savefig , os.systeme , -resize 128x128\!

Un pré-traitement avant passage dans un réseau de neurones
pour classifier les images

Je vais voir cette fonction set_data plus en détail ...

:mrgreen:

Ajouter 3 points n'est pas actif avec set_data(x,y) :
set_data est une fonction spéciale ...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import matplotlib.pyplot as plt
import numpy as np
import time
 
# Fait en sorte que le traçage soit interactif. 
# Sinon la figure est affichée qu'à la toute fin.
plt.ion()
 
fig = plt.figure()
 
x = np.array([ 1, 2, 3])
y = np.array([ 10, 20, 30])
 
line, = plt.plot(x, y, color='blue', lw=2)
 
 
def update_points(new_x, new_y):
    global x, y, fig, line1, ax
    x = np.append(x, new_x)
    y = np.append(y, new_y)
    print(x)
    print(y)
    line.set_data(x,y)
    fig.canvas.draw()
 
 
update_points(np.array([4, 5, 6]), np.array([4, 5, 3]))
plt.show()
time.sleep(10)

27/09/2018, 16h32
racine carrée

Citation:

Intéressant, chez moi ça marche bien (j'ai quand même testé avant de poster :)). J'ai matplotlib en version 2.2.2 pour info et j'execute mon code depuis une console.

En fait c'est assez étrange car si j'exécute "fig, a = plt.subplots()" dans la console, la fenêtre s'affiche. Si je fais ensuite "a.grid(True)" ça ce met à jour. Si je fais "a.plot(L1,L2)" ça marche aussi.
Par contre si j'exécute tous d'un coup en mettant un "time.sleep(1)" entre chacune de ces actions, la fenêtre ne répond pas et tout s'affiche d'un coup à la fin.
J'ai donc essayer d'exécuter "fig, a = plt.subplots(); time.sleep(1)" dans la console, et la fenêtre attend que le time.sleep soit finis pour se rafraichir.
Dites moi si c'est la même chose pour vous, car ça me parait vraiment étrange.
(remarque: en rajoutant des "fig.canvas.draw()" entre chaque commande, ça ne change rien !)

Citation:

Envoyé par Julien N

A noter que dans cet exemple, la figure n'est pas recadrée à chaque update. Donc si les nouvelles valeurs sont en dehors des bornes initialement définies, on ne les voit pas.

J

Si si, ca fonctionne très bien.
Mais comme on vous la dit précédemment, si les données ajouter sorte du cadre défini lors de la visualisation des toute premières données, alors vous ne voyez rien, car le cadre n'est pas réajusté. Et c'est exactement ce que vous faite ici. Au départ x varie de 0 à 3. Vous rajouter des valeurs 4 5 et 6, qui sont donc hors cadre. Pareil en ordonnée. Pourtant si vous faites un

Code:

print(line.get_data())

vous vous rendez bien compte que l'objet à été mis à jour. Et donc le fait que la visualisation ne suivent pas derrière est un autre problème.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 import matplotlib.pyplot as plt import numpy as np import time ## Fait en sorte que le traçage soit interactif. ## Sinon la figure est affichée qu'à la toute fin. plt.ion() fig = plt.figure('toto') fig.clf() ax = fig.add_subplot(111) x = np.array([ 1, 2, 3]) y = np.array([ 10, 20, 30]) line, = ax.plot(x, y, '+', color='blue') ax.set_ylim([0,40]) ax.set_xlim([0,6]) fig.canvas.draw() fig.canvas.flush_events() time.sleep(1) new_x, new_y = np.array([4, 5, 6]), np.array([4, 5, 3]) x = np.append(x, new_x) y = np.append(y, new_y) print(line.get_data()) line.set_data(x,y) print(line.get_data()) fig.canvas.draw() fig.canvas.flush_events()
Pour la visualisation ce qui se passe en effet sur la plupart des machines ce sont des "problèmes" de bufferisation. C'est à dire que l'ordinateur pour économiser ces ressources va faire les opérations mais n'afficher le résultat qu'à la fin. Ce sujet https://stackoverflow.com/questions/...-in-matplotlib en parle très bien, et aborde la fonction flush_events() qui justement oblige python à ne pas aller à l'économie et à afficher l'état dans lequel c'est.

Le code que je vous présente ci dessus, avec définition des bornes de l'axe dès le début + flush_events() fonctionne très bien.

27/09/2018, 16h57
lg_53

@racine_carrée : oui ca fait la même chose chez moi. Le sleep est bufferisé, voila pourquoi tout se fige jusqu'à la résolution complète du code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import matplotlib.pyplot as plt
import numpy as np
import time
import random 
 
## Fait en sorte que le traçage soit interactif. 
## Sinon la figure est affichée qu'à la toute fin.
plt.ion()
 
fig = plt.figure('toto')
fig.clf()
 
ax = fig.add_subplot(111)
 
x = np.array([ 1, 2, 3])
y = np.array([ 10, 20, 30])
 
line, = ax.plot(x, y, '-', color='blue',lw=8)
ax.set_ylim([0,40])
ax.set_xlim([0,100])
ax.grid()
 
fig.canvas.draw()
fig.canvas.flush_events()
 
time.sleep(1)
 
for i in range(50):
 
    new_x, new_y = x[-1]+2, random.randint(25, 35)
    x = np.append(x, new_x)
    y = np.append(y, new_y)
    print(line.get_data())
    line.set_data(x,y)
    print(line.get_data())
    fig.canvas.draw()
    fig.canvas.flush_events()
    time.sleep(1)

Voici la solution que je cherchais