python इंटरैक्टिव Matplotlib आंकड़े सहेजा जा रहा है




(5)

यह एक महान विशेषता होगी, लेकिन AFAIK इसे Matplotlib में लागू नहीं किया गया है और आंकड़ों को संग्रहीत करने के तरीके के कारण स्वयं को लागू करना मुश्किल होगा।

मैं या तो सुझाव दूंगा (ए) आंकड़े उत्पन्न करने से डेटा को अलग-अलग प्रोसेस करना (जो एक अद्वितीय नाम वाले डेटा को सहेजता है) और एक आकृति उत्पन्न करने वाली स्क्रिप्ट (सहेजे गए डेटा की एक निर्दिष्ट फ़ाइल लोड करना) लिखना और संपादन के रूप में संपादन करना या बी ) पीडीएफ / SVG / PostScript प्रारूप के रूप में सहेजें और एडोब इलस्ट्रेटर (या Inkscape ) जैसे कुछ फैंसी आकृति संपादक में संपादित करें।

पोस्ट पतन 2012 संपादित करें : जैसा कि दूसरे ने नीचे बताया है (हालांकि यहां उल्लेख किया गया है क्योंकि यह स्वीकार्य उत्तर है), संस्करण 1.2 के बाद से मैटलप्लिब ने आपको आंकड़ों को चुनने की अनुमति दी है। रिलीज नोट्स के रूप में, यह एक प्रयोगात्मक विशेषता है और एक matplotlib संस्करण में एक आकृति को बचाने और दूसरे में खोलने का समर्थन नहीं करता है। अविश्वसनीय स्रोत से एक अचार को बहाल करना आम तौर पर असुरक्षित है।

साझा करने / बाद में संपादन भूखंडों के लिए (जिसके लिए महत्वपूर्ण डेटा प्रोसेसिंग की आवश्यकता होती है और बाद में महीनों में tweaked की आवश्यकता हो सकती है, एक वैज्ञानिक प्रकाशन के लिए सहकर्मी समीक्षा के दौरान), मैं अभी भी (1) के वर्कफ़्लो की एक डेटा प्रसंस्करण स्क्रिप्ट है जो साजिश उत्पन्न करने से पहले प्रसंस्कृत डेटा (जो आपकी साजिश में जाता है) को एक फ़ाइल में सहेजता है, और (2) साजिश को फिर से बनाने के लिए एक अलग साजिश पीढ़ी स्क्रिप्ट (जिसे आप आवश्यकतानुसार समायोजित करते हैं) रखते हैं। इस तरह के प्रत्येक प्लॉट के लिए आप जल्दी से एक स्क्रिप्ट चला सकते हैं और इसे फिर से उत्पन्न कर सकते हैं (और नए डेटा के साथ अपनी साजिश सेटिंग्स पर तुरंत कॉपी करें)। उस ने कहा, एक आंकड़ा चुनना अल्पकालिक / इंटरैक्टिव / अन्वेषक डेटा विश्लेषण के लिए सुविधाजनक हो सकता है।

क्या Matplotlib आकृति को सहेजने का कोई तरीका है कि इसे फिर से खोला जा सकता है और सामान्य बातचीत को बहाल किया जा सकता है? (MATLAB में .fig प्रारूप की तरह?)

मैं खुद को इन इंटरैक्टिव आंकड़ों को उत्पन्न करने के लिए कई बार एक ही स्क्रिप्ट चला रहा हूं। या मैं साजिश के विभिन्न पहलुओं को दिखाने के लिए अपने सहयोगियों को कई स्थिर पीएनजी फाइल भेज रहा हूं। मैं बजाय आकृति वस्तु भेजूंगा और उन्हें स्वयं से बातचीत करूँगा।


मुझे पता चला कि यह कैसे करें। @ पेल्सन द्वारा वर्णित "प्रयोगात्मक अचार समर्थन" काफी अच्छी तरह से काम करता है।

इसे इस्तेमाल करे:

# Plot something
import matplotlib.pyplot as plt
fig,ax = plt.subplots()
ax.plot([1,2,3],[10,-10,30])

अपने इंटरैक्टिव ट्वीविंग के बाद, आकृति ऑब्जेक्ट को बाइनरी फ़ाइल के रूप में सहेजें:

import pickle
pickle.dump(fig, open('FigureObject.fig.pickle', 'wb')) # This is for Python 3 - py2 may need `file` instead of `open`

बाद में, आकृति खोलें और tweaks को बचाया जाना चाहिए और जीयूआई अंतःक्रियाशीलता मौजूद होना चाहिए:

import pickle
figx = pickle.load(open('FigureObject.fig.pickle', 'rb'))

figx.show() # Show the figure, edit it, etc.!

आप प्लॉट से डेटा निकाल सकते हैं:

data = figx.axes[0].lines[0].get_data()

(यह लाइनों, रंग और imshow के लिए काम करता है - pcolormesh flattened डेटा का पुनर्निर्माण करने के लिए कुछ चाल के साथ काम करता है ।)

मुझे अचार का उपयोग करके Matplotlib आंकड़े सहेजने से उत्कृष्ट युक्ति मिली।


मैंने अपने matplotlib आंकड़ों को बचाने के लिए एक अपेक्षाकृत सरल तरीका (अभी तक थोड़ा अपरंपरागत) पता लगाया। यह इस तरह काम करता है:

import libscript

import matplotlib.pyplot as plt
import numpy as np

t = np.arange(0.0, 2.0, 0.01)
s = 1 + np.sin(2*np.pi*t)

#<plot>
plt.plot(t, s)
plt.xlabel('time (s)')
plt.ylabel('voltage (mV)')
plt.title('About as simple as it gets, folks')
plt.grid(True)
plt.show()
#</plot>

save_plot(fileName='plot_01.py',obj=sys.argv[0],sel='plot',ctx=libscript.get_ctx(ctx_global=globals(),ctx_local=locals()))

इस तरह परिभाषित function save_plot साथ (तर्क को समझने के लिए सरल संस्करण):

def save_plot(fileName='',obj=None,sel='',ctx={}):
    """
    Save of matplolib plot to a stand alone python script containing all the data and configuration instructions to regenerate the interactive matplotlib figure.

    Parameters
    ----------
    fileName : [string] Path of the python script file to be created.
    obj : [object] Function or python object containing the lines of code to create and configure the plot to be saved.
    sel : [string] Name of the tag enclosing the lines of code to create and configure the plot to be saved.
    ctx : [dict] Dictionary containing the execution context. Values for variables not defined in the lines of code for the plot will be fetched from the context.

    Returns
    -------
    Return ``'done'`` once the plot has been saved to a python script file. This file contains all the input data and configuration to re-create the original interactive matplotlib figure.
    """
    import os
    import libscript

    N_indent=4

    src=libscript.get_src(obj=obj,sel=sel)
    src=libscript.prepend_ctx(src=src,ctx=ctx,debug=False)
    src='\n'.join([' '*N_indent+line for line in src.split('\n')])

    if(os.path.isfile(fileName)): os.remove(fileName)
    with open(fileName,'w') as f:
        f.write('import sys\n')
        f.write('sys.dont_write_bytecode=True\n')
        f.write('def main():\n')
        f.write(src+'\n')

        f.write('if(__name__=="__main__"):\n')
        f.write(' '*N_indent+'main()\n')

return 'done'

या परिभाषित समारोह save_plot इस तरह (लाइटर आकृति फ़ाइलों का उत्पादन करने के लिए ज़िप संपीड़न का उपयोग कर बेहतर संस्करण):

def save_plot(fileName='',obj=None,sel='',ctx={}):

    import os
    import json
    import zlib
    import base64
    import libscript

    N_indent=4
    level=9#0 to 9, default: 6
    src=libscript.get_src(obj=obj,sel=sel)
    obj=libscript.load_obj(src=src,ctx=ctx,debug=False)
    bin=base64.b64encode(zlib.compress(json.dumps(obj),level))

    if(os.path.isfile(fileName)): os.remove(fileName)
    with open(fileName,'w') as f:
        f.write('import sys\n')
        f.write('sys.dont_write_bytecode=True\n')
        f.write('def main():\n')
        f.write(' '*N_indent+'import base64\n')
        f.write(' '*N_indent+'import zlib\n')
        f.write(' '*N_indent+'import json\n')
        f.write(' '*N_indent+'import libscript\n')
        f.write(' '*N_indent+'bin="'+str(bin)+'"\n')
        f.write(' '*N_indent+'obj=json.loads(zlib.decompress(base64.b64decode(bin)))\n')
        f.write(' '*N_indent+'libscript.exec_obj(obj=obj,tempfile=False)\n')

        f.write('if(__name__=="__main__"):\n')
        f.write(' '*N_indent+'main()\n')

return 'done'

यह मेरे स्वयं के मॉड्यूल libscript का उपयोग करता है, जो ज्यादातर मॉड्यूल inspect और libscript पर निर्भर करता है। यदि दिलचस्पी व्यक्त की जाती है तो मैं इसे गीथूब पर साझा करने का प्रयास कर सकता हूं (इसे पहले कुछ सफाई और मुझे गितब के साथ शुरू करने की आवश्यकता होगी)।

इस save_plot फ़ंक्शन और libscript मॉड्यूल के पीछे का विचार पाइथन निर्देशों को लाने के लिए है जो आंकड़ा (मॉड्यूल inspect का उपयोग करके) बनाते हैं, उन सभी चर, कार्यों और मॉड्यूल को निकालने के लिए उनका विश्लेषण करें (मॉड्यूल अस्थिर का उपयोग करके) इसे निष्पादित करने से इन्हें निष्पादित करते हैं संदर्भ और उन्हें पायथन निर्देशों के रूप में क्रमबद्ध करें (चर के लिए कोड t=[0.0,2.0,0.01] जैसा होगा ... और मॉड्यूल के लिए कोड import matplotlib.pyplot as plt ...) आकृति निर्देशों के लिए तैयार किया गया। परिणामी पायथन निर्देश एक पायथन लिपि के रूप में सहेजे जाते हैं जिनके निष्पादन मूल matplotlib आकृति को फिर से निर्मित करेगा।

जैसा कि आप कल्पना कर सकते हैं, यह अधिकांश (यदि नहीं सभी) matplotlib आंकड़ों के लिए अच्छी तरह से काम करता है।


Matplotlib 1.2 के रूप में, अब हमारे पास प्रयोगात्मक pickle समर्थन है। इसे जाने दो और देखें कि यह आपके मामले के लिए अच्छा काम करता है या नहीं। यदि आपके पास कोई समस्या है, तो कृपया हमें Matplotlib मेलिंग सूची पर या github.com/matplotlib/matplotlib पर कोई समस्या खोलकर बताएं


अच्छा प्रश्न। pylab.save से दस्तावेज़ टेक्स्ट यहां दिया गया है:

pylab अब एक सेव फ़ंक्शन प्रदान नहीं करता है, हालांकि पुराना पिलैब फ़ंक्शन अभी भी matplotlib.mlab.save के रूप में उपलब्ध है (आप अभी भी इसे "mlab.save" के रूप में pylab में देख सकते हैं)। हालांकि, सादे पाठ फ़ाइलों के लिए, हम numpy.savetxt की सलाह देते हैं। Numpy arrays को सहेजने के लिए, हम numpy.save, और इसके एनालॉग numpy.load की सलाह देते हैं, जो pylab में np.save और np.load के रूप में उपलब्ध हैं।





matplotlib