Wie streamen Daten zu einem Bokeh-Plot in Jupyter mit einer hohen Bildwiederholfrequenz?

Question

Ich versuche Bokeh zu verwenden, um ein Streaming-Dataset innerhalb einer Jupyter notebook zu plotten. Hier ist was ich bisher habe.

in der Befehlszeile Ich starte den Bokeh-Server durch den

Hier ist der Code von meinem Jupyter Notebook

import numpy as np 
from IPython.display import clear_output 
# ------------------- new cell ---------------------# 

from bokeh.models.sources import ColumnDataSource 
from bokeh.client import push_session 
from bokeh.driving import linear 
from bokeh.plotting import figure 
from bokeh.io import curdoc, output_notebook, show 
# ------------------- new cell ---------------------# 

output_notebook() 
# ------------------- new cell ---------------------# 

my_figure = figure(plot_width=800, plot_height=400) 
test_data = ColumnDataSource(data=dict(x=[0], y=[0])) 
linea = my_figure.line("x", "y", source=test_data) 
# ------------------- new cell ---------------------# 

new_data=dict(x=[0], y=[0]) 
x = [] 
y = [] 

step_size = 0.1 # increment for increasing step 
@linear(m=step_size, b=0) 
def update(step): 
    x.append(step) 
    y.append(np.random.rand()) 
    new_data['x'] = x 
    new_data['y'] = y 

    test_data.stream(new_data, 10) 

    clear_output() 
    show(my_figure) 

    if step > 10: 
     session.close()  
# ------------------- new cell ---------------------# 

# open a session to keep our local document in sync with server 
session = push_session(curdoc()) 

period = 100 # in ms 
curdoc().add_periodic_callback(update, period) 

session.show() # open a new browser tab with the updating plot 

session.loop_until_closed() 

Derzeit

$> bokeh server 

Befehl ausgeführt wird, das Ergebnis, das ich bekomme, ist ein blinkendes Grundstück in das Jupyter-Notebook und auch ein schön aktualisierendes Plot in einem neuen Browser-Tab. Ich möchte eine der folgenden

• einem schön Aktualisierung Grundstück in Jupyter, ohne zu blinken
• nur dem Grundstück in der neuen Browser-Tab

Ich habe versucht, das Entfernen show(my_figure) aber jedes Update eröffnet eine neue Tab. Ich habe auch versucht, die Bildwiederholfrequenz auf 10 ms zu reduzieren, period = 10; session.show() funktioniert gut, aber das Notebook stürzt schließlich ab, weil es nicht so schnell auffrischen kann.

Wie bekomme ich eine gute Bildwiederholfrequenz des Bokeh Plot in Jupyter? Oder wie schalte ich das Jupyter-Plot aus und habe nur einen Tab, der das Update-Plot anzeigt? Hier

Answer 1

ist der Code für eine modifizierte Notebook, folgenden @ bigreddot Kommentar, die push_notebook verwendet ein viel sauberes Ergebnis im Notebook zu erzeugen (es nicht erforderlich, dass Sie laufen bokeh serve für das Plotten). Es verwendet keinen Rückruf; Ich bin mir nicht sicher, ob das ein Vorteil ist oder nicht. Wenn Sie möchten, dass der Plot aktualisiert wird, wenn ein neuer Datenpunkt kommt, können Sie eine if data_event:-Anweisung am Anfang der while-Schleife hinzufügen. Passen Sie dann die Ruhezeit entsprechend der Ereignisrate an.

This page aus der offiziellen Dokumentation bietet zusätzliche hilfreiche Informationen zur Verwendung von Bokeh in einem Jupyter Notebook.

import time 
import numpy as np 
# ------------------- new cell ---------------------# 

from bokeh.models.sources import ColumnDataSource 
from bokeh.plotting import figure 
from bokeh.io import output_notebook, show, push_notebook 
# ------------------- new cell ---------------------# 

output_notebook() 
# ------------------- new cell ---------------------# 

my_figure = figure(plot_width=800, plot_height=400) 
test_data = ColumnDataSource(data=dict(x=[0], y=[0])) 
line = my_figure.line("x", "y", source=test_data) 
handle = show(my_figure, notebook_handle=True) 

new_data=dict(x=[0], y=[0]) 
x = [] 
y = [] 

step = 0 
step_size = 0.1 # increment for increasing step 
max_step = 10 # arbitrary stop point for example 
period = .1 # in seconds (simulate waiting for new data) 
n_show = 10 # number of points to keep and show 
while step < max_step: 
    x.append(step) 
    y.append(np.random.rand()) 
    new_data['x'] = x = x[-n_show:] # prevent filling ram 
    new_data['y'] = y = y[-n_show:] # prevent filling ram 

    test_data.stream(new_data, n_show) 

    push_notebook(handle=handle) 
    step += step_size 
    time.sleep(period) 

Notiere die Zugabe von new_data['x'] = x = x[-n_show] (gleich für y) so ist dies in der Theorie auf unbestimmte Zeit ohne Füllung Ihr Gedächtnis laufen konnte. Auch wäre es nett zu eigentlich streamen Sie eine Art von Datenquelle (vielleicht aus dem Web), um dies zu einem realistischeren Beispiel zu machen. Zu guter Letzt werden Sie dies wahrscheinlich bemerken, aber nachdem Sie die Zelle mit dem Streaming-Plot ausgeführt haben, wird der Kernel gesperrt, bis er abgeschlossen ist oder unterbrochen wird. Sie können keine zusätzlichen Zellen/Code ausführen. Wenn Sie Analyse-/Steuerungsfunktionen haben möchten, sollten sie in die Schleife while gehen.