Ipython: %matplotlib इनलाइन ipywidgets 6.0 इंटरैक्ट के साथ अच्छी तरह से काम नहीं करता है

ऐसा लगता है, लेकिन क्या किसी के पास बेहतर तरीके से समाधान है?

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 , जिन्होंने इनलाइन mpl बैकएंड पर काम किया।

मुझे नहीं लगता कि हम बहुत कुछ कर सकते हैं।

एक आकृति प्रदर्शित करने के लिए आप किस अनुमान का प्रयोग करेंगे? आप इसे सभी आंकड़ों पर अपडेट नहीं कर सकते क्योंकि कई कोड पुन: उपयोग के आंकड़े अपडेट करते हैं, लेकिन एनीमेशन होना आम बात है।

प्रत्येक ऑपरेशन के बाद फ्लश करने के लिए विशेष आवरण @interact ?

प्रत्येक ऑपरेशन के बाद फ्लश करने के लिए विशेष आवरण @interact ?

अच्छा बिंदु, सुझाव के लिए धन्यवाद। ऐसा करने के लिए यह बहुत साफ नहीं लगता है (विशेष मामले में matplotlib के लिए एक विशिष्ट बैकएंड)। हो सकता है कि मैं यह देखने के लिए प्रतीक्षा करूंगा कि क्या उपयोगकर्ताओं के लिए उपरोक्त उदाहरण की तरह स्पष्ट रूप से आउटपुट फ्लश करना एक बड़ी समस्या है। मेरा मतलब है, स्पष्ट निहित से बेहतर है और वह सब ...

संपादित करें: संक्षेप में, मुझे लगता है कि मैं मानता हूं कि हम इतना कुछ नहीं कर सकते (या करना चाहिए) ...

यह पता चला है कि यह सब मेरे विचार से कहीं अधिक आसान है - जब मैंने पहले इसका परीक्षण करने की कोशिश की तो मैंने कुछ गलत किया होगा। हमें फ्लश_फिगर को कॉल करने की आवश्यकता नहीं है, यह केवल मानक plt.show को कॉल करने के लिए पर्याप्त है:

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()

मुझे लगता है कि लोगों को उनकी बातचीत में शो() कमांड डालने के लिए कहना बिल्कुल उचित है, इसलिए मैं इसे बंद कर रहा हूं।

यदि हम इस व्यवहार (और अन्य संभावित पोस्ट-निष्पादित आउटपुट) को रखना चाहते हैं, तो आउटपुट कैप्चरिंग समाप्त होने से पहले पोस्ट-एक्स हुक को इंटरैक्ट में स्पष्ट रूप से लागू किया जा सकता है? सामान्य तौर पर, किसी फ़ंक्शन को बातचीत के माध्यम से कॉल करने की मेरी अपेक्षा यह है कि यह ठीक उसी तरह व्यवहार करता है जैसे कि मैंने सेल में एक बार फ़ंक्शन को कॉल किया था।

मैं उम्मीद करता हूं कि लोग सभी इंटरैक्ट-साथ-मैटप्लोटलिब उदाहरणों से आंकड़े दिखाना बंद कर दें, क्योंकि 'इंटरैक्टिव' मैटप्लोटलिब का आम तौर पर अर्थ है plt.show अनावश्यक है। इसे एक इंटरैक्टिव फ़ंक्शन में डालने से शायद इसे बदलना नहीं चाहिए।

IOThread पेश किए जाने से पहले, यह मुझे आउटपुट देखने के लिए sys.stdout.flush() की आवश्यकता की थोड़ी याद दिलाता है। यह समझ में आया कि इसकी आवश्यकता

मुझे नहीं लगता कि हमें सभी पोस्ट-निष्पादित हैंडलर स्वचालित रूप से निष्पादित करना चाहिए (जो जानता है कि वे क्या करेंगे - शायद बहुत सारी चीज़ें!)। flush_display हुक रखने के बारे में कैसे? हम बातचीत शुरू करने से पहले इसे फ्लश कर देंगे, और इसे समाप्त करने से ठीक पहले इसे फिर से फ्लश कर देंगे। इस तरह यह बिल्कुल stdout/stdin फ्लशिंग के समान है।

ठीक है, या दूसरी ओर, शायद पोस्ट-निष्पादन को कॉल करना समझ में आता है, अगर हम एक इंटरेक्शन के बारे में सोचते हैं जो वास्तव में एक एकल सेल की तरह काम करता है। लेकिन तब हम शायद पोस्ट-निष्पादन को कॉल करना चाहते हैं इससे पहले कि इंटरैक्ट चलाने के साथ-साथ बाद में भी, अगर बातचीत अन्य सामान के साथ सेल में थी।

फिर से खुल रहा है, क्योंकि बातचीत अभी बंद नहीं हुई है...

मुझे फ्लश_डिस्प्ले हुक का विचार पसंद है, और यह सिद्धांत रूप में काम करेगा, हालांकि इसे एक नए हुक को परिभाषित करने और बैकएंड को इसका उपयोग करने के लिए स्विच करने के लिए ipython और ipykernel और ipywidgets के समन्वित रिलीज की आवश्यकता होगी।

अगर हम एक ऐसे इंटरेक्शन के बारे में सोचते हैं जो वास्तव में एक एकल कोशिका की तरह काम कर रहा है,

मुझे लगता है कि यह वे कुंजी हैं, और यह एक बड़ा 'अगर' है। मैं इसके बारे में ऐसा ही सोचता

च हम एक ऐसी बातचीत के बारे में सोचते हैं जो वास्तव में एक एकल कोशिका की तरह काम करती है
मुझे लगता है कि यह वे कुंजी हैं, और यह एक बड़ा 'अगर' है। मैं इसके बारे में ऐसा ही सोचता हूं, लेकिन मैं हर कोई (अभी तक) नहीं हूं।

इसके बारे में एक भ्रमित करने वाली बात यह है कि यदि हमारे पास कोड वाला एक सेल था, तो एक इंटरैक्ट रन, फिर कुछ और कोड, सेल वास्तव में तीन सेल (यानी, पोस्ट-एक्ज़ीक्यूट रन तीन अलग-अलग बार) की तरह निष्पादित किया जाएगा। मुझे लगता है कि उस मामले में फ्लश_डिस्प्ले अधिक समझ में आता है।

अतिरिक्त प्रश्न: JLab काम में आउटपुट प्रदर्शित करेगा?

@willingc विजेट मिरर किए गए आउटपुट के साथ काम करते हैं।

@SylvainCorlay मुझे पता है कि वे अब काम करते हैं, और एन आर्बर में लोग इसे पसंद करते हैं। मेरा सवाल यह था कि अगर ऊपर चर्चा के अनुसार बदलाव किए जाते हैं तो क्या यह काम करेगा।

शोर के लिए खेद है।

लंबे समय में, मुझे लगता है कि एक दृष्टिकोण जो बेहतर काम करना चाहिए वह है ipympl विजेट matplotlib का बैकएंड।

हालाँकि, हमें इसे और अधिक आसानी से conf.d आदि के साथ स्थापित करने की आवश्यकता होगी ...

हां, प्रतिबिंबित आउटपुट को ऊपर चर्चा किए गए परिवर्तन के साथ काम करना चाहिए। सुनिश्चित करने के लिए धन्यवाद!

इसके बारे में एक भ्रमित करने वाली बात यह है कि यदि हमारे पास कोड वाला एक सेल था, तो एक इंटरैक्ट रन, फिर कुछ और कोड, सेल वास्तव में तीन सेल (यानी, पोस्ट-एक्ज़ीक्यूट रन तीन अलग-अलग बार) की तरह निष्पादित किया जाएगा।

वाकई, यह थोड़ा अजीब होगा। हालांकि, यह दो बार नहीं होगा? एक समग्र रूप से सेल के लिए और एक बातचीत के पहले आह्वान के लिए? आप इसके बारे में कैसे सोचते हैं, इस पर निर्भर करते हुए, यह भी समझ में आता है: @interact , आपके पास दो निष्पादन हैं: एक घोषणा के लिए, और दूसरा निष्पादन इंटरेक्टेड-फ़ंक्शन के पहले आमंत्रण के लिए।

मुझे नहीं लगता कि आपके पास एक से अधिक होंगे यदि आपने @interact_manual , उदाहरण के लिए (मुझे यकीन नहीं है)।

हालांकि, यह दो बार नहीं होगा? एक समग्र रूप से सेल के लिए और एक बातचीत के पहले आह्वान के लिए?

इस कोड पर विचार करें:

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

चूंकि प्लॉटिंग संचयी है, और आप इंटरैक्ट को अपने आप में एक अलग सेल के रूप में मानना ​​​​चाहते हैं, आपको इंटरेक्शन चलने से पहले फिगर को फ्लश करना होगा, फिर इंटरेक्शन के अंदर फिगर को फ्लश करना होगा, और फिर एक बार सेल के अंत में। यही हम फ्लशिंग स्टडआउट के साथ भी करते हैं।

असल में, मुझे यकीन नहीं है कि उपयोगकर्ता उपरोक्त उदाहरण में क्या अपेक्षा करता है। आप क्या उम्मीद करेंगे?

बस एक विचार: ऊपर दिया गया उदाहरण बहुत तार्किक नहीं है; व्यक्तिगत रूप से मैं तीन भूखंडों की अपेक्षा करता हूं जहां केवल एक गतिशील रूप से बदलता है लेकिन अगर मुझे ऐसा कुछ करना है तो मैं सभी साजिश कॉल @interact अंदर करूंगा।

क्या प्रत्येक .plot() बाद flush_figures पर कॉल न करने का कोई कारण है?

@myyc यह व्यवहार का एक महत्वपूर्ण अर्थपूर्ण परिवर्तन है। plot प्लॉट पर आइटम जोड़ता है ....

मेरा मतलब विशिष्ट ipython इनलाइन व्यवहार में था, जैसा कि matplotlib के विपरीत था।

संपादित करें : मुझे यकीन है कि यह एक अधिक सामान्य उपयोग का मामला है जिसमें प्रति सेल एक "एकमात्र प्लॉटिंग फ़ंक्शन" के रूप में होता है, जैसा कि ऊपर वर्णित मामले के विपरीत है ...

में समज। हालांकि मुझे नहीं लगता कि इसका इतना अलग व्यवहार होना चाहिए।

भविष्य में उचित दृष्टिकोण शायद नोटबुक बैकएंड या आईपीआईएमपीएल का उपयोग करना और आंकड़े को संपादित करना होगा।

ipywidgets के इंटरेक्शन में इनलाइन बैकएंड के लिए matplotlib- विशिष्ट वर्कअराउंड को लागू करना सही नहीं लगता है।

जेसन द्वारा दिए गए कोड में:

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

अपेक्षित आउटपुट बहुत सारी लाइनों वाला एक आंकड़ा है ..

हाँ मैं पूर्णतः सहमत हूँ। मैंने अपने स्थानीय सेटअप में अस्थायी रूप से इसे इस तरह से तय किया (पंडों की साजिश रचने के तरीकों को ओवरराइड करना), "एक फिक्स की प्रतीक्षा कर रहा है" :)

मैंने देखा है कि इस मुद्दे को विभिन्न जीथब परियोजनाओं के आसपास बाउंस किया जा रहा है, इसलिए मैं सोच रहा हूं कि सबसे अच्छा संकल्प पथ क्या होना चाहिए।

संपादित करें : इसे इस तरह क्यों न लिखें, जिस तरह से और अधिक स्पष्ट है?

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

आप ipympl पैकेज (https://github.com/matplotlib/jupyter-matplotlib) देख सकते हैं, जो कि matplotlib विजेट है। ipympl अभी भी बहुत प्रारंभिक चरण है, लेकिन matplotlib कोर की तुलना में तेज़ रिलीज़ शेड्यूल होना चाहिए, और jupyterlab आदि के लिए पहले का समर्थन होना चाहिए ...

ठीक है कि ओवरराइड एक भयानक विचार है। मैं एक फिक्स अपस्ट्रीम के लिए तत्पर रहूंगा :)

केवल एक अशिक्षित उपयोगकर्ता दृष्टिकोण में योगदान करने के लिए: ipywidgets 6.0 में अपडेट करने के बाद, मैंने पाया कि मेरा अधिकांश विजेट कोड काम नहीं कर रहा था (यहां चर्चा की गई समस्या के कारण)। मैं plt.show() कॉल जोड़कर इसे ठीक करने में सक्षम था, लेकिन मैंने यह भी पाया है कि मुझे इस बारे में बहुत सावधान रहना होगा कि मैं ऐसी कॉल कहां जोड़ूं; ऐसा लगता है कि कभी-कभी इसे बहुत जल्द कॉल करने से बाद के प्लॉट दिखाई नहीं देते हैं (भले ही plt.show() को फिर से कॉल किया जाए)। मैंने इसे न्यूनतम उदाहरण बनाने के लिए पर्याप्त रूप से शिकार नहीं किया है, लेकिन वर्तमान व्यवहार मेरे लिए अनजान लगता है - मैं इसे प्राप्त करने के लिए परीक्षण और त्रुटि से प्रोग्रामिंग कर रहा हूं।

वास्तव में नए व्यवहार के कारण ipywidgets में क्या सटीक परिवर्तन हुआ? क्या निष्पादन के बाद के हुक बिल्कुल भी नहीं लगाए जा रहे हैं, या क्या उन्हें अभी भी लागू किया जा रहा है लेकिन उनका आउटपुट अब खारिज कर दिया गया है क्योंकि विजेट विशेष रूप से विजेट के स्वामित्व वाले आउटपुट के बारे में है? यदि यह बाद वाला है, तो ऐसा लगता है कि फ़ंक्शन के शरीर के दौरान कैप्चर किए गए आउटपुट को अलग करना सही काम नहीं है।

निष्पादन के बाद के हुक लागू किए जा रहे हैं (मुझे पूरा यकीन है) - आप इसे करने से देख सकते हैं:

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

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

और स्लाइडर ले जा रहा है। भूखंडों को सेल में जोड़ा जाएगा - पोस्ट निष्पादन हुक प्रदर्शन-डेटा संदेश भेज रहे हैं। इंटरेक्शन निष्पादन वास्तव में फ़ंक्शन आमंत्रण के दौरान होने वाले आउटपुट को कैप्चर करने के बारे में विशेष रूप से विशेष रूप से किया जा रहा है। मुझे लगता है कि ऐसा करना सही है। उदाहरण के लिए, दो अलग-अलग इंटरैक्शन एक ही स्लाइडर उदाहरण साझा कर सकते हैं:

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()

जब एकल स्लाइडर को (किसी भी UI में) ट्वीक किया जाता है, तो दोनों इंटरेक्शन स्लाइडर को हिलते हुए दिखाएंगे और दोनों इंटरैक्ट फ़ंक्शन एक ही निष्पादन कॉल में चलेंगे। पोस्ट-निष्पादन हुक से किसी भी आउटपुट को कैप्चर करने का प्रयास करने के लिए दोनों इंटरैक्ट्स के लिए यह गलत होगा। मुझे लगता है कि यहां दोष यह है कि हम आउटपुट उत्पन्न करने के लिए पोस्ट-निष्पादन का उपयोग कर रहे हैं, और यह एक हथौड़ा का बहुत मोटा है। कोड के एक ब्लॉक में उत्पन्न फ्लशिंग आउटपुट के लिए हमारे पास एक महीन-दानेदार विधि होनी चाहिए, जिसे एक ही निष्पादन में कई बार कहा जा सकता है।

कोड के एक ब्लॉक में उत्पन्न फ्लशिंग आउटपुट के लिए हमारे पास एक महीन-दानेदार विधि होनी चाहिए

Matplotlib प्लॉटिंग के लिए, यह फ्लशिंग plt.show

मुझे इस बारे में बहुत सावधान रहना होगा कि मैं ऐसी कॉल कहाँ जोड़ूँ; ऐसा लगता है कि कभी-कभी इसे बहुत जल्द कॉल करने से बाद के प्लॉट दिखाई नहीं देते हैं

मुझे वास्तव में ऐसे उदाहरण देखने

मुझे इस बारे में बहुत सावधान रहना होगा कि मैं ऐसी कॉल कहाँ जोड़ूँ; ऐसा लगता है कि कभी-कभी इसे बहुत जल्द कॉल करने से बाद के प्लॉट दिखाई नहीं देते हैं

मुझे वास्तव में ऐसे उदाहरण देखने में दिलचस्पी है जहां ऐसा होता है। हम व्यवहार को सहज और समझने योग्य बनाना चाहते हैं।

विस्तृत करने के लिए, मुझे लगता है कि आपको पिछले व्यवहार के बराबर प्राप्त करने में सक्षम होना चाहिए plt.show() किसी भी इंटरैक्ट फ़ंक्शन की अंतिम पंक्ति के रूप में जो प्लॉटिंग कर रहा है। मुझे ऐसे उदाहरण देखने में बहुत दिलचस्पी है जहां यह काम नहीं करता है।

@jasongrout इसे देखने के लिए धन्यवाद। जिस कोड पर मैं इसे मार रहा था वह जटिल है, और यह संभव है कि मैं कुछ और गलत कर रहा था। अगर मैं इसे फिर से देखता हूं तो मैं इसे अलग करने और एक उदाहरण प्रदान करने का प्रयास करूंगा।

@jasongrout थोड़ी और खुदाई के बाद, मुझे लगता है कि मैं जो चल रहा हूं वह जुपिटर नोटबुक की एक संपत्ति है, न कि विजेट्स की (लेकिन यह अब विजेट्स के साथ इंटरैक्ट करता है क्योंकि हमें plt.show() पर कॉल करने के लिए मजबूर होना पड़ता है)।

यदि कोई नोटबुक सेल में प्लॉट बनाता है और कॉल करता है plt.show() , तो बाद में आंकड़े में संशोधन दिखाई नहीं देते हैं। यहां एक न्यूनतम उदाहरण दिया गया है:

%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)

केवल पहली पंक्ति का प्लॉट दिखाई देता है।

यहाँ एक और भी सरल उदाहरण है। %matplotlib inline बैकएंड के बिना दो सेल। शायद @tacaswell कुछ प्रकाश plt.show प्लॉट क्यों नहीं दिखाता है।

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

प्लॉट दिखाता है

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

कुछ नहीं दिखाता

नवीनतम स्थिर ज्यूपिटर, ipython, ipywidgets, matplotlib, python3 के साथ मेरी मशीन पर पुष्टि की गई है।

यहां भी पुष्टि की।

@jasongrout यह अपेक्षित व्यवहार है क्योंकि पहले सेल में आप एक आकृति (और कैनवास और कुल्हाड़ियों) बनाते हैं और फिर इसे प्रदर्शित करते हैं। दूसरी सेल में आप फिर मौजूदा अक्षों (मौजूदा आकृति में) में एक रेखा जोड़ते हैं। %matplotlib qt या ipympl (या पूर्ण GUI में से कोई भी) के साथ प्लॉट _ should_ दूसरी पंक्ति के साथ अपडेट होना चाहिए। मैं इनलाइन के साथ काम करने की उम्मीद नहीं करता क्योंकि आपको इसे अपडेट करने के लिए केवल एक शॉट मिलता है (यही कारण है कि मैं इनलाइन का प्रशंसक नहीं हूं, यह इंटरैक्टिव कार्यक्षमता के _all_ को फेंक देता है)।

@tacaswell क्या इनलाइन का यह व्यवहार मेरे द्वारा दिए गए पहले उदाहरण के लिए भी समझ में आता है, जो सभी एक सेल में है? यहाँ यह फिर से है:

%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)

मुझे लगता है कि plt.show पर इनलाइन बैकएंड अपने आप को एक पीएनजी में प्रस्तुत करता है और फिर पाइप्लॉट से आंकड़े को डी-पंजीकृत करता है, इसलिए इसे अगले शो में फिर से प्रस्तुत नहीं किया जाएगा, भले ही यह उसी सेल में हो, हालांकि अतिरिक्त show s के बिना कुल्हाड़ियों के तरीकों के लिए कई कॉल काम करना चाहिए।

स्पष्ट होने के लिए, यहाँ इनलाइन बैकएंड कोड है: https://github.com/ipython/ipykernel/blob/master/ipykernel/pylab/backend_inline.py

क्या ipywidgets और/या matplotlib का कोई संस्करण है जिसे मैं अपने इंटरैक्टिव विजेट्स को फिर से काम करने के लिए वापस रोल कर सकता हूं?

@jasongrout यह कोड से दिखता है जैसे मैं InlineBackend.close_figures से False पर सेट करना चाहता हूं। लेकिन मुझे यकीन नहीं है कि उस विशेषता को कैसे सेट किया जाए - क्या मुझे किसी प्रकार के जादू का उपयोग करने की ज़रूरत है?

(वह सवाल अजीब लगता है लेकिन मेरा मतलब सचमुच है)

https://github.com/jupyter-widgets/ipywidgets/issues/1457 ने इस मुद्दे को फिर से उठाया। @ellisonbg - क्या होगा यदि हम फ्लश_फिगर्स वर्कअराउंड को लागू करते हैं जिसका मैंने ऊपर उल्लेख किया है - बातचीत के पहले और बाद में फ्लश_फिगर को कॉल करें, बातचीत से पहले किसी भी प्लॉट को फ्लश करने के लिए, और बातचीत के दौरान प्लॉट की गई किसी भी चीज़ को फ्लश करें? मुझे लगता है कि हमें यह देखने के लिए जांचना पड़ सकता है कि हम इनलाइन एमपीएल बैकएंड में चल रहे हैं या नहीं।

यह एक बहुत बड़ा कीचड़ है, लेकिन हो सकता है कि इसे वैसे भी करना काफी महत्वपूर्ण हो। शायद हम यह भी पता लगा सकते हैं कि क्या हम वास्तव में एक आंकड़ा फ्लश कर रहे हैं और लोगों को एक स्पष्ट शो() कॉल करने के लिए चेतावनी जारी कर रहे हैं?

हाय सब, मैं इसके तकनीकी विवरण का पालन नहीं कर रहा था, लेकिन समस्या में चला गया। कार्यान्वयन विवरण के बावजूद मुझे लगता है कि यह अत्यंत महत्वपूर्ण है कि matplotlib + जितना संभव हो सके "बस काम करता है" बातचीत करें।

plt.show() या flush_figures() , यदि नोटबुक को ताज़ा किया जाता है (कर्नेल को पुनरारंभ किए बिना), तो विजेट के साथ नोटबुक सहेजें के साथ भी आंकड़ा समाप्त हो गया है। इन शमन के बिना, यह मामला नहीं है, हालांकि तब भी कई प्लॉट आउटपुट का मुद्दा है। क्या यह इरादा है? कर्नेल बंद होने पर भी यही लागू होता है, जबकि ipywidgets के पुराने संस्करणों के साथ आंकड़े की अंतिम स्थिति एक गैर-संवादात्मक भूखंड के समान नोटबुक में सहेजी जाएगी, जो काफी आसान थी।

क्षमा करें यदि यह दायरे से बाहर है, या यदि मैं कुछ गलत कर रहा हूँ। ipywidgets 6.0.0, matplotlib 2.0.2, नोटबुक 5.0.0, और पायथन 3.6.1 चल रहा है।