Wykres dynamicznie zmieniający wykres przy użyciu matplotlib w Jupyter Notebook

Question

Mam tablicę M x N 2D: ith wiersz reprezentuje tę wartość N punktów w czasie i.

Chcę wizualizować punkty [1 wiersz tablicy] w postaci wykresu, w którym wartości są aktualizowane po niewielkiej przerwie. W ten sposób wykres pokazuje 1 wiersz na raz, a następnie aktualizuje wartości do następnego wiersza, i tak dalej.

Chcę to zrobić w notatniku Juwatera. Szukam kodów odniesienia.

Próbowałem następujące rzeczy, ale bez powodzenia:

• http://community.plot.ly/t/updating-graph-with-new-data-every-100-ms-or-so/812

• https://pythonprogramming.net/live-graphs-matplotlib-tutorial/

• Create dynamic updated graph with Python

• Update Lines in matplotlib

Answer 1

Utworzono ipython notebook with a couple of examples.

Answer 2

Nie wiem zbyt wiele na temat matplotlib lub jupyter. Jednak interesują mnie wykresy. Po prostu trochę googlowałem i natknąłem się na to post. Wygląda na to, że musisz renderować wykres jako wideo HTML, aby zobaczyć dynamiczny wykres.

Próbowałem tego posta. This to notebook, jeśli chcesz spróbować. Zauważ, że jądro (python 2) zajmuje trochę czasu, aby zbudować wideo. Możesz przeczytać więcej na ten temat here.

Teraz chcesz wyświetlić wiersz wykresu do wiersza. Próbowałem this. W tym notebooku mam dump_data z 10 rzędami. Ja losowo biorę jedną i kreślę je i wyświetlam jako wideo.

Ciekawie było zapoznać się z jowerem. Mam nadzieję że to pomoże.

Answer 3

Oprócz @ 0aslam0 użyłem kodu z here. Właśnie zmieniłem funkcję animacji, aby następnym razem uzyskać następny wiersz. Rysuje animowaną ewolucję (M kroków) wszystkich N punktów.

from IPython.display import HTML 
import numpy as np 
from matplotlib import animation 
N = 5 
M = 100 
points_evo_array = np.random.rand(M,N) 

# First set up the figure, the axis, and the plot element we want to animate 
fig = plt.figure() 
ax = plt.axes(xlim=(0, M), ylim=(0, np.max(points_evo_array))) 
lines = [] 

lines = [ax.plot([], [])[0] for _ in range(N)] 

def init():  
    for line in lines: 
     line.set_data([], []) 
    return lines 

def animate(i): 
    for j,line in enumerate(lines): 
     line.set_data(range(i), [points_evo_array[:i,j]]) 
    return lines 

# call the animator. blit=True means only re-draw the parts that have changed. 
anim = animation.FuncAnimation(fig, animate,np.arange(1, M), init_func=init, interval=10, blit=True) 

HTML(anim.to_html5_video()) 

nadzieję, że będzie użyteczny

Answer 4

Oto alternatywę, ewentualnie prostsze rozwiązanie:

%matplotlib notebook 
import numpy as np 
import matplotlib.pyplot as plt 

m = 100 
n = 100 
matrix = np.random.normal(0,1,m*n).reshape(m,n) 

fig = plt.figure() 
ax = fig.add_subplot(111) 
plt.ion() 

fig.show() 
fig.canvas.draw() 

for i in range(0,100): 
    ax.clear() 
    ax.plot(matrix[i,:]) 
    fig.canvas.draw() 

Answer 5

Tutaj jest biblioteką, która zajmuje się w czasie rzeczywistym kreślenia/dane logowania (joystick), chociaż Nie jestem pewien, czy działa z jowerem. Możesz zainstalować go przy użyciu zwykłego pip install joystick.

Trudne do stworzenia działającego rozwiązania bez dodatkowych szczegółów na temat danych. Oto opcja:

import joystick as jk 
import numpy as np 

class test(jk.Joystick): 
    # initialize the infinite loop decorator 
    _infinite_loop = jk.deco_infinite_loop() 

    def _init(self, *args, **kwargs): 
     """ 
     Function called at initialization, see the docs 
     """ 
     # INIT DATA HERE 
     self.shape = (10, 4) # M, N 
     self.data = np.random.random(self.shape) 
     self.xaxis = range(self.shape[1]) 
     ############ 
     # create a graph frame 
     self.mygraph = self.add_frame(
        jk.Graph(name="TheName", size=(500, 500), pos=(50, 50), 
          fmt="go-", xnpts=self.shape[1], freq_up=5, bgcol="w", 
          xylim=(0, self.shape[1]-1, None, None))) 

    @_infinite_loop(wait_time=0.5) 
    def _generate_fake_data(self): # function looped every 0.5 second 
     """ 
     Loop starting with the simulation start, getting data and 
     pushing it to the graph every 0.5 seconds 
     """ 
     # NEW (RANDOM) DATA 
     new_data = np.random.random(self.shape[1]) 
     # concatenate data 
     self.data = np.vstack((self.data, new_data)) 
     # push new data to the graph 
     self.mygraph.set_xydata(self.xaxis, self.data[-1]) 

t = test() 
t.start() 

t.stop() 
t.exit() 

Kod ten będzie utworzyć wykres, który jest automatyczne aktualizowanie 5 razy na sekundę (freq_up = 5), podczas gdy nowe dane (losowo) generowany co 0,5 sekundy (WAIT_TIME = 0,5) i wciśnięty do wykresu w celu wyświetlenia.

Jeśli nie chcesz, aby oś Y obracała się, wpisz t.mygraph.xylim = (0, t.shape[1]-1, 0, 1).