Ipython: %matplotlib inline funktioniert nicht gut mit ipywidgets 6.0 interagieren

Das scheint zu funktionieren, aber hat jemand eine Lösung für einen besseren Weg?

import matplotlib.pyplot as plt
from ipywidgets import interact
from ipykernel.pylab.backend_inline import flush_figures

%matplotlib inline
x = [1,2,5,4,3]
@interact(n=(2,5))
def f(n):
    plt.plot(x[:n])
    flush_figures()

CC @minrk , der am Inline-mpl-Backend gearbeitet hat.

Ich glaube nicht, dass wir viel tun können.

Welche Heuristik würden Sie für die Darstellung einer Figur verwenden? Sie können es überhaupt nicht tun, wenn Figuren so viele Code-Wiederverwendungsfiguren aktualisieren, aber es ist üblich, Animationen zu verwenden.

Sondergehäuse @interact zum Spülen nach jeder Operation ?

Spezielles Gehäuse @interact zum

Guter Punkt, danke für den Vorschlag. Es fühlt sich nicht sehr sauber an, dies zu tun (um ein bestimmtes Backend für Matplotlib zu spezialisieren). Vielleicht warte ich ab, ob es ein großes Problem für Benutzer ist, die Ausgabe wie im obigen Beispiel explizit zu leeren. Ich meine, explizit ist besser als implizit und so...

Edit: Zusammenfassend denke ich, dass ich nicht viel tun kann (oder sollte) ...

Es stellt sich heraus, dass das alles viel einfacher ist, als ich dachte - ich muss etwas falsch gemacht haben, als ich das vorhin getestet habe. Wir müssen flush_figures nicht aufrufen, es reicht, einfach die Standard-plt.show aufzurufen:

import matplotlib.pyplot as plt
from ipywidgets import interact

%matplotlib inline
x = [1,2,5,4,3]
@interact(n=(2,5))
def f(n):
    plt.plot(x[:n])
    plt.show()

Ich denke, es ist völlig vernünftig, Leute zu bitten, einen show()-Befehl in ihre Interaktion einzufügen, also schließe ich dies.

Wenn wir dieses Verhalten (und andere potenzielle Ausgaben nach der Ausführung) beibehalten möchten, könnten die Post-X-Hooks möglicherweise explizit in Interaktion aufgerufen werden, bevor die Ausgabeerfassung abgeschlossen ist? Im Allgemeinen erwarte ich beim Aufrufen einer Funktion über Interaktion, dass sie sich genau so verhält, als ob ich die Funktion einmal in einer Zelle aufgerufen hätte.

Ich würde erwarten, dass die Leute von all den Interact-with-matplotlib-Beispielen überrascht sind, dass sie keine Zahlen mehr anzeigen, da 'interactive' matplotlib im Allgemeinen bedeutet, dass plt.show unnötig ist. Das Einfügen in eine interaktive Funktion sollte das wahrscheinlich nicht ändern.

Es erinnert mich ein wenig daran, dass sys.stdout.flush() , um die Ausgabe zu sehen, bevor der IOThread eingeführt wurde. Es machte Sinn, warum es erforderlich war, wenn man darüber nachdachte, wie die Dinge funktionierten, aber das machte es nicht weniger überraschend, weil es sich nicht so verhielt, wie die Leute es erwartet hatten.

Ich denke nicht, dass wir alle Post-Execute-Handler automatisch ausführen sollten (wer weiß, was sie tun werden - vielleicht eine Menge Zeug!). Wie wäre es mit einem flush_display Hook? Wir spülen es, bevor wir mit der Interaktion beginnen, und spülen es erneut, bevor wir es beenden. Auf diese Weise ist es genau analog zum Spülen von stdout/stdin.

Nun, oder andererseits macht es vielleicht Sinn, Post-Execute aufzurufen, wenn wir uns eine Interaktion vorstellen, die sich wirklich wie eine einzelne Zelle für sich allein verhält. Aber dann würden wir wahrscheinlich post-execute aufrufen wollen, bevor die Interaktion ausgeführt wurde und auch danach, nur für den Fall, dass die Interaktion in einer Zelle mit anderen Dingen war.

Wiedereröffnung, da die Konversation noch nicht geschlossen ist...

Ich mag die Idee eines flush_display-Hooks, und es würde theoretisch funktionieren, obwohl es koordinierte Releases von ipython und ipykernel und ipywidgets erfordern würde, um einen neuen Hook zu definieren und das Backend auf seine Verwendung umzustellen.

wenn wir uns eine Interaktion vorstellen, die sich wirklich wie eine einzelne Zelle verhält

Ich denke, das ist der Schlüssel, und es ist ein großes „Wenn“. So stelle ich es mir vor, aber ich bin (noch) nicht jeder.

Wenn wir uns eine Interaktion vorstellen, die sich wirklich wie eine einzelne Zelle verhält
Ich denke, das ist der Schlüssel, und es ist ein großes „Wenn“. So stelle ich es mir vor, aber ich bin (noch) nicht jeder.

Eine verwirrende Sache dabei ist, dass, wenn wir eine Zelle mit Code hätten, dann eine Interaktionsausführung, dann noch etwas mehr Code, die Zelle tatsächlich wie drei Zellen ausgeführt würde (dh nach der Ausführung dreimal ausgeführt). Ich denke, das flush_display macht in diesem Fall mehr Sinn.

Zusätzliche Frage: Würde die gespiegelte Ausgabe in JLab funktionieren?

@willingc- Widgets arbeiten mit gespiegelter Ausgabe.

@SylvainCorlay Ich weiß, dass sie jetzt funktionieren, und die Leute in Ann Arbor lieben es. Meine Frage war, würde es funktionieren, wenn Änderungen wie oben beschrieben vorgenommen werden.

Entschuldigung für den Lärm.

Auf lange Sicht denke ich, dass ein Ansatz, der besser funktionieren sollte, das ipympl-Widgets-Backend für Matplotlib ist.

All dies müssen wir jedoch mit conf.d usw. einfacher installieren.

Ja, die gespiegelte Ausgabe sollte mit den oben besprochenen Änderungen funktionieren. Danke, dass Sie sich vergewissern!

Eine verwirrende Sache dabei ist, dass, wenn wir eine Zelle mit Code hätten, dann eine Interaktionsausführung, dann noch etwas mehr Code, die Zelle tatsächlich wie drei Zellen ausgeführt würde (dh nach der Ausführung dreimal ausgeführt).

Das wäre in der Tat etwas seltsam. Wäre es nicht zwei Mal? Eine für die Zelle als Ganzes und eine für den ersten Aufruf von interagieren? Je nachdem, wie Sie es sich vorstellen, macht dies auch Sinn: Mit @interact haben Sie zwei Ausführungen: eine für die Deklaration und eine weitere Ausführung für den ersten Aufruf der interagierten Funktion.

Ich glaube nicht, dass Sie mehr als einen haben würden, wenn Sie beispielsweise @interact_manual (ich bin mir nicht sicher).

Wäre es nicht zwei Mal? Eine für die Zelle als Ganzes und eine für den ersten Aufruf von interagieren?

Betrachten Sie diesen Code:

plt.plot([1,2,3])
@interact(n=(1,10))
def f(n):
    plt.plot([1,n])
plt.plot([4,5,6])

Da die Darstellung kumulativ ist und Sie die Interaktion als separate Zelle für sich behandeln möchten, müssen Sie die Figur vor der Ausführung der Interaktion spülen, dann die Figur innerhalb der Interaktion spülen und dann noch einmal am Ende der Zelle. Genau das machen wir auch mit der Spülung stdout.

Eigentlich bin ich mir nicht sicher, was der Benutzer im obigen Beispiel erwartet. Was würden Sie erwarten?

Nur ein Gedanke: Das obige Beispiel ist nicht sehr logisch; Persönlich würde ich drei Plots erwarten, von denen sich nur einer dynamisch ändert, aber wenn ich so etwas tun würde, würde ich alle Plotaufrufe innerhalb von @interact .

Gibt es einen Grund , nicht zu nennen flush_figures nach jedem .plot() ?

@myyc es ist eine signifikante semantische Änderung des Verhaltens. plot fügt Elemente zum Plot hinzu....

Ich meinte das spezifische Inline-Verhalten von ipython im Gegensatz zu Matplotlib.

Bearbeiten : Ich bin mir sicher, dass es ein häufigerer Anwendungsfall ist, eine Zelle pro Zelle als "die einzige Plotting-Funktion" zu verwenden, im Gegensatz zu dem oben beschriebenen Fall ...

Ich verstehe. Obwohl ich nicht denke, dass dies ein so anderes Verhalten haben sollte.

Der richtige Ansatz in Zukunft wird wahrscheinlich darin bestehen, das Notebook-Backend oder ipympl zu verwenden und die Figur zu bearbeiten.

Die Implementierung von matplotlib-spezifischen Problemumgehungen für das Inline-Backend in der Interaktion von ipywidgets scheint nicht richtig zu sein.

Im Code von Jason:

plt.plot([1,2,3])
@interact(n=(1,10))
def f(n):
    plt.plot([1,n])
plt.plot([4,5,6])

die erwartete Ausgabe ist eine Zahl mit vielen Zeilen..

Ja, ich stimme voll und ganz zu. Ich habe es in meinem lokalen Setup vorübergehend auf diese Weise behoben (wobei Pandas-Plot-Methoden überschrieben wurden), "auf eine Lösung warten" :) Ignorieren Sie das, es führt eine Reihe schrecklicher Nebenwirkungen ein.

Ich habe gesehen, dass dieses Problem in einer Vielzahl von Github-Projekten aufgetreten ist, daher frage ich mich, was der beste Auflösungspfad sein sollte.

edit : warum schreibst du es dann nicht so, viel expliziter?

@interact(n=(1,10))
def f(n):
    plt.plot([1,2,3])
    plt.plot([1,n])
    plt.plot([4,5,6])

Sie können das ipympl-Paket (https://github.com/matplotlib/jupyter-matplotlib) ausprobieren, das das Matplotlib-Widget ist. ipympl befindet sich noch in einem ziemlich frühen Stadium, sollte aber einen schnelleren Release-Zeitplan haben als der Matplotlib-Kern und eine frühere Unterstützung für Jupyterlab usw.

OK stellt sich heraus, dass die Überschreibung eine schreckliche Idee ist. Ich freue mich auf einen Fix Upstream :)

Nur um eine ungebildete Benutzersicht beizutragen: Nach dem Update auf ipywidgets 6.0 stellte ich fest, dass ein Großteil meines Widget-Codes nicht funktionierte (aufgrund des hier besprochenen Problems). Ich konnte das Problem beheben, indem ich plt.show() Anrufe hinzufügte, aber ich habe auch festgestellt, dass ich sehr vorsichtig sein muss, wo ich solche Anrufe hinzufüge; es scheint, dass dieser zu frühe Aufruf manchmal dazu führt, dass spätere Plots nicht angezeigt werden (auch wenn plt.show() erneut aufgerufen wird). Ich habe dies nicht genug aufgespürt, um ein minimales Beispiel zu erstellen, aber das aktuelle Verhalten scheint mir nicht intuitiv zu sein - ich programmiere durch Versuch und Irrtum, um es zu umgehen.

Welche genaue Änderung in ipywidgets hat das neue Verhalten tatsächlich verursacht? Werden die Post-Execute-Hooks überhaupt nicht aufgerufen oder werden sie immer noch aufgerufen, aber ihre Ausgabe wird jetzt verworfen, weil das Widget genau bestimmt, welche Ausgaben dem Widget gehören? Wenn letzteres der Fall ist, scheint es nicht richtig zu sein, die erfasste Ausgabe während des Hauptteils der Funktion zu isolieren.

Die Post-Execute-Hooks werden aufgerufen (ich bin mir ziemlich sicher) - Sie können dies sehen, indem Sie Folgendes tun:

import matplotlib.pyplot as plt
from ipywidgets import interact
%matplotlib inline

@interact(n=(0,10))
def f(n):
    plt.plot([0,n])

und Bewegen des Schiebers. Die Plots werden an die Zelle angehängt - die Post-Execute-Hooks senden die Anzeigedatennachrichten. Die Interaktionsausführungen sind in der Tat speziell darauf ausgerichtet, nur die Ausgabe zu erfassen, die während des Funktionsaufrufs erfolgt. Ich denke, das ist das Richtige. Beispielsweise können zwei verschiedene Interaktionen genau dieselbe Schiebereglerinstanz verwenden:

import matplotlib.pyplot as plt
from ipywidgets import interact, IntSlider
%matplotlib inline

x = IntSlider()
@interact(n=x)
def f(n):
    plt.plot([0,n])
    plt.show()
@interact(n=x)
def f(n):
    plt.plot([0,n,0,n])
    plt.show()

Wenn der einzelne Schieberegler (in einer der Benutzeroberflächen) optimiert wird, würden beide Interaktionen zeigen, dass sich der Schieberegler bewegt, und beide Interaktionsfunktionen würden im selben Ausführungsaufruf ausgeführt. Es wäre falsch, wenn beide Interaktionen versuchen, die Ausgabe eines Post-Execute-Hooks zu erfassen. Ich denke, der Fehler hier ist, dass wir Post-Execute verwenden, um eine Ausgabe zu generieren, und das ist einfach ein zu grober Hammer. Wir sollten eine feinkörnigere Methode zum Leeren der Ausgabe haben, die in einem Codeblock generiert wurde und der in einer einzigen Ausführung mehrmals aufgerufen werden kann.

Wir sollten eine feinkörnigere Methode zum Flushen der Ausgabe haben, die in einem Codeblock generiert wurde

Beim Plotten der Matplotlib geschieht dieses Leeren, wenn plt.show

Ich muss sehr vorsichtig sein, wo ich solche Anrufe hinzufüge; es scheint, dass wenn dies manchmal zu früh aufgerufen wird, spätere Plots nicht angezeigt werden

Ich bin wirklich daran interessiert, Beispiele zu sehen, wo dies passiert. Wir wollen das Verhalten intuitiv und verständlich machen.

Ich muss sehr vorsichtig sein, wo ich solche Anrufe hinzufüge; es scheint, dass wenn dies manchmal zu früh aufgerufen wird, spätere Plots nicht angezeigt werden

Ich bin wirklich daran interessiert, Beispiele zu sehen, wo dies passiert. Wir wollen das Verhalten intuitiv und verständlich machen.

Um das auszuarbeiten, ich denke, Sie sollten in der Lage sein, das Äquivalent des vorherigen Verhaltens zu erhalten, indem Sie einfach plt.show() als letzte Zeile jeder Interaktionsfunktion hinzufügen, die Plotten durchführt. Ich bin sehr daran interessiert, Beispiele zu sehen, bei denen dies nicht funktioniert.

@jasongrout Danke, dass

@jasongrout Nach etwas mehr gestoßen bin, nicht auf Widgets (aber es interagiert jetzt mit Widgets, da wir gezwungen sind, plt.show() aufzurufen).

Wenn man ein Diagramm in einer Notebookzelle erstellt und plt.show() aufruft, dann werden spätere Änderungen an der Figur nicht angezeigt. Hier ein Minimalbeispiel:

%matplotlib inline
import matplotlib.pyplot as plt

def plotfun(t):
    fig, ax = plt.subplots(1,1)
    ax.plot([0,t],[0,t])
    plt.show()
    ax.plot([t,0],[0,t])
    plt.show()

plotfun(2)

Nur das erste Liniendiagramm wird angezeigt.

Hier ist ein noch einfacheres Beispiel. Zwei Zellen, ohne das %matplotlib inline Backend. Vielleicht könnte @tacaswell etwas Licht ins Dunkel bringen, warum das zweite plt.show keine Handlung zeigt.

import matplotlib.pyplot as plt
fig, ax = plt.subplots(1,1)
ax.plot([0,1],[0,1])
plt.show()

zeigt Handlung

ax.plot([1,0],[0,1])
plt.show()

zeigt nichts an

Bestätigt auf meinem Computer mit dem neuesten stabilen Jupyter, Ipython, Ipywidgets, Matplotlib, Python 3.

Auch hier bestätigt.

@jasongrout Das ist das erwartete Verhalten, denn in der ersten Zelle erstellen Sie eine Figur (und Leinwand und Achsen) und zeigen sie dann an. In der zweiten Zelle fügen Sie dann eine Linie zu den vorhandenen Achsen (in der vorhandenen Abbildung) hinzu. Mit %matplotlib qt oder ipympl (oder einer der vollständigen GUIs) _sollte_ der Plot mit der zweiten Zeile aktualisiert werden. Ich erwarte nicht, dass dies mit Inline funktioniert, da Sie nur eine Chance haben, es zu aktualisieren (weshalb ich kein Fan von Inline bin, es wirft _alle_ interaktiven Funktionen ein).

@tacaswell Ist dieses Verhalten von Inline auch für das frühere Beispiel sinnvoll, das ich gegeben habe, das sich alles in einer Zelle befindet? Hier ist es wieder:

%matplotlib inline
import matplotlib.pyplot as plt

def plotfun(t):
    fig, ax = plt.subplots(1,1)
    ax.plot([0,t],[0,t])
    plt.show()
    ax.plot([t,0],[0,t])
    plt.show()

plotfun(2)

Ich denke, dass bei plt.show das Inline-Backend sich selbst in ein PNG rendert und dann die Figur von pyplot abmeldet, damit sie bei der nächsten Show nicht erneut gerendert wird, auch wenn sie sich in derselben Zelle befindet mehrere Aufrufe von Achsenmethoden ohne zusätzliche show s sollten funktionieren.

Um es klarzustellen, hier ist der Inline-Backend-Code: https://github.com/ipython/ipykernel/blob/master/ipykernel/pylab/backend_inline.py

Gibt es eine Version von ipywidgets und/oder matplotlib ich zurückkehren kann, damit meine interaktiven Widgets wieder funktionieren?

@jasongrout Es sieht so aus, als ob ich InlineBackend.close_figures auf False setzen möchte. Aber ich bin mir nicht sicher, wie ich dieses Attribut einstellen soll – muss ich irgendeine Art von Magie anwenden?

(die Frage klingt komisch, aber ich meine es wörtlich)

https://github.com/jupyter-widgets/ipywidgets/issues/1457 hat dieses Problem erneut aufgeworfen. @ellisonbg - Was ist, wenn wir die oben erwähnte Problemumgehung von flush_figures implementieren - rufen Sie flush_figures vor und nach dem Ausführen einer Interaktion auf, um alle Plots vor der Interaktion und alles, was während der Interaktion gezeichnet wurde, auszuspülen? Ich denke, wir müssen möglicherweise überprüfen, ob wir im Inline-mpl-Backend ausgeführt werden.

Es ist ein riesiger Fehler, aber vielleicht ist es wichtig genug, um es trotzdem zu tun. Vielleicht können wir auch erkennen, ob wir tatsächlich eine Zahl spülen und eine Warnung ausgeben, in der die Leute aufgefordert werden, einen expliziten show()-Aufruf zu tätigen?

Hallo zusammen, ich hatte die technischen Details nicht verfolgt, bin aber auf das Problem gestoßen. Unabhängig von Implementierungsdetails halte ich es für äußerst wichtig, dass matplotlib+interact so gut wie möglich "einfach funktioniert".

Mit plt.show() oder flush_figures() , wenn das Notebook aktualisiert wird (ohne den Kernel neu zu starten), ist die Zahl auch mit Save Notebook with Widgets verschwunden. Ohne diese Abschwächungen ist dies nicht der Fall, obwohl dann immer noch das Problem mehrerer Plotausgaben besteht. Ist das beabsichtigt? Gleiches gilt, wenn der Kernel heruntergefahren wird, während bei älteren Versionen von ipywidgets der Endzustand der Figur ähnlich einem nicht interaktiven Plot im Notebook gespeichert wurde, was recht praktisch war.

Entschuldigung, wenn dies außerhalb des Rahmens liegt oder ich etwas falsch mache. Ausführen von ipywidgets 6.0.0, Matplotlib 2.0.2, Notebook 5.0.0 und Python 3.6.1.