Matplotlib का उपयोग करके प्रदर्शित करने के बजाय छवि फ़ाइल में प्लॉट सहेजें

Question

मैं मक्खी पर प्लॉट बनाने के लिए एक त्वरित और गंदी स्क्रिप्ट लिख रहा हूं। मैं एक प्रारंभिक बिंदु के रूप में नीचे दिए गए कोड ( Matplotlib प्रलेखन से) का उपयोग कर रहा हूं :

from pylab import figure, axes, pie, title, show

# Make a square figure and axes
figure(1, figsize=(6, 6))
ax = axes([0.1, 0.1, 0.8, 0.8])

labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
fracs = [15, 30, 45, 10]

explode = (0, 0.05, 0, 0)
pie(fracs, explode=explode, labels=labels, autopct='%1.1f%%', shadow=True)
title('Raining Hogs and Dogs', bbox={'facecolor': '0.8', 'pad': 5})

show()  # Actually, don't show, just save to foo.png

मैं GUI पर प्लॉट प्रदर्शित नहीं करना चाहता, इसके बजाय, मैं प्लॉट को एक फ़ाइल में सहेजना चाहता हूं (जैसे foo.png), ताकि उदाहरण के लिए, इसे बैच स्क्रिप्ट में उपयोग किया जा सके। मैं उसको कैसे करू?

Comments

ऐसा लगता है कि मुझे उत्तर मिला: इसका pylab.savefig ('foo.png')

— होम्युनकुलस रेटिकुल्ली

लिंक शायद matplotlib.org में कहीं से लिंक होना चाहिए?

— .एक

इसके अलावा अगर पाइलैब का उपयोग नहीं किया जा रहा है, तो आकृति ऑब्जेक्ट में एक savefigविधि भी है। तो आप fig = plt.figure()तब कॉल कर सकते हैं fig.savefig(...)।

— एक

बहुत से उत्तर पृष्ठ का उल्लेख कम करते हैं plt.close(fig)जो विशेष रूप से बड़े छोरों में महत्वपूर्ण है। अन्यथा आंकड़े खुले रहते हैं और स्मृति में प्रतीक्षा करते हैं और सभी खुले आंकड़े निष्पादित करने पर दिखाए जाएंगेplt.show()

— टाइमट्रान

nb: matplotlib.pyplot को प्राथमिकता दी जाती है: stackoverflow.com/questions/11469336/…

— ErichBSchulz

Answer 1

हालांकि इस प्रश्न का उत्तर दिया जा चुका है, मैं matplotlib.pyplot.savefig का उपयोग करते समय कुछ उपयोगी सुझाव जोड़ना चाहूंगा । फ़ाइल प्रारूप को एक्सटेंशन द्वारा निर्दिष्ट किया जा सकता है:

from matplotlib import pyplot as plt

plt.savefig('foo.png')
plt.savefig('foo.pdf')

क्रमशः एक rasterized या सदिश उत्पादन देगा, जो दोनों उपयोगी हो सकता है। इसके अलावा, आप पाएंगे कि pylabछवि के चारों ओर एक उदार, अक्सर अवांछनीय, व्हाट्सएप छोड़ देता है। इसे निकालें:

savefig('foo.png', bbox_inches='tight')

Comments

क्या परिणामस्वरूप छवि के आयामों को बदलना संभव है?

— लेलमेडेडॉन

@Asmageddon plt.savefigआप डीपीआई को बदल सकते हैं, उत्तर में लिंक देख सकते हैं। आकृति बनाते समय आयामों को नियंत्रित किया जा सकता है, matplotlib.org/api/figure_api.html#matplotlib.figurefigsize में देखें । कॉन्फ़िगर करें

— हुक किए गए

@MoTSCHIGGE को आप कॉल कर सकते हैं plt.ioff()जो matplotlib.pyplotकमांड में इंटरएक्टिवनेस को डिसेबल करना चाहिए ।

— रबनवब

@STMohammed foo.png है पथ। उदाहरण के लिए, आप इसे इस तरह एक निर्देशिका में रख सकते हैं savefig("mydir/foo.png")।

— हुक

bbox_inches = 'tight' एक आकर्षण की तरह काम करता है। आपने मेरा दिन बनाया

— कैटबाइट्स

Answer 2

जैसा कि दूसरों ने कहा है, plt.savefig()या fig1.savefig()वास्तव में एक छवि को बचाने का तरीका है।

हालाँकि मैंने पाया है कि कुछ मामलों में आंकड़ा हमेशा दिखाया जाता है । (जैसे। स्पाइडर होने के साथ plt.ion(): इंटरेक्टिव मोड = ऑन।) मैं अपने विशाल लूप में फिगर विंडो को बंद करके plt.close(figure_object)( प्रलेखन देखें ) के साथ काम करके इसके आसपास काम करता हूं , इसलिए लूप के दौरान मेरे पास एक लाख खुले आंकड़े नहीं हैं:

import matplotlib.pyplot as plt
fig, ax = plt.subplots( nrows=1, ncols=1 )  # create figure & 1 axis
ax.plot([0,1,2], [10,20,3])
fig.savefig('path/to/save/image/to.png')   # save the figure to file
plt.close(fig)    # close the figure window

आपको बाद में यह आंकड़ा फिर से खोलने में सक्षम होना चाहिए fig.show()( यदि खुद का परीक्षण नहीं किया गया है)।

Comments

आप सेट भी कर सकते हैं plt.ioff() # turn of interactive plotting mode, लेकिन यह व्यवहार को अक्षम कर सकता है जिसका आप उपयोग करना चाहते हैं, आपको एक त्रुटि के साथ अपने कोड से बाहर निकलना चाहिए।

— डेमिस

आपको जुपिटर नोटबुक में भी यही समस्या दिखाई देगी। plt.close(fig)इसे हल किया गया

— intsco

Answer 3

समाधान है:

pylab.savefig('foo.png')

Answer 4

बस इस लिंक को इस मुद्दे को संबोधित करते हुए MatPlotLib प्रलेखन पर पाया गया: http://matplotlib.org/faq/howto_faq.html#generate-images-without-having-a-window-appear

वे कहते हैं कि फिगर को पॉप अप करने से रोकने का सबसे आसान तरीका गैर-संवादात्मक बैकेंड (जैसे। एग) का उपयोग करना है matplotib.use(<backend>), जैसे:।

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
plt.plot([1,2,3])
plt.savefig('myfig')

मैं अभी भी व्यक्तिगत रूप से उपयोग करना पसंद करता हूं plt.close( fig ), तब से आपके पास कुछ आंकड़ों (लूप के दौरान) को छिपाने का विकल्प है, लेकिन फिर भी पोस्ट-लूप डेटा प्रोसेसिंग के लिए आंकड़े प्रदर्शित करते हैं। यह शायद एक गैर-संवादात्मक बैकएंड चुनने की तुलना में धीमा है - अगर किसी ने परीक्षण किया तो यह दिलचस्प होगा।

अद्यतन : स्पाइडर के लिए, आप आमतौर पर बैकएंड को इस तरह से सेट नहीं कर सकते हैं (क्योंकि स्पाइडर आमतौर पर मैटलपोटलिब को जल्दी से लोड करता है, आपको उपयोग करने से रोकता है matplotlib.use())।

इसके बजाय, स्पाइडर प्रीफ़ में plt.switch_backend('Agg')" सक्षम समर्थन " को बंद करें या उसका उपयोग करें और matplotlib.use('Agg')कमांड को स्वयं चलाएं ।

इन दो संकेतों से: एक , दो

Comments

यह उन परिस्थितियों के लिए वास्तव में अच्छी तरह से काम करता है जहां आपके पास एक सेट डिस्प्ले नहीं है। .plot()यदि os.environ['DISPLAY']सही तरीके से सेट नहीं किया गया है, तो एक और बैकएंड का उपयोग करके एक त्रुटि होगी ।

— अर्थव्यवस्था

धन्यवाद। यह काम करता है और उत्पादन सर्वर के लिए बहुत उपयोगी है जहां कोई इंटरनेट कनेक्शन नहीं है और किसी भी पैकेज को स्थापित करने के लिए सिस्टम व्यवस्थापक की आवश्यकता है।

— लियोन

मुझे "बैकएंड" के वर्णन / परिभाषा के लिए matplotlib साइट के ट्यूटोरियल की तरह है: matplotlib.org/tutorials/introductory/…

— टेनर स्ट्रंक

Answer 5

यदि आपको "वर्तमान" आकृति की अवधारणा पसंद नहीं है, तो करें:

import matplotlib.image as mpimg

img = mpimg.imread("src.png")
mpimg.imsave("out.png", img)

Comments

क्या यह सिर्फ नकल नहीं src.pngहै out.png?

— गेरिट

यह सिर्फ एक उदाहरण है, यह दर्शाता है कि यदि आपके पास एक छवि ऑब्जेक्ट ( img) है, तो आप इसे .imsave()विधि के साथ फाइल में सहेज सकते हैं ।

— आश्चर्य

@ wonder.mice यह दिखाने में मदद करेगा कि वर्तमान आकृति का उपयोग किए बिना छवि कैसे बनाई जाए।

— scry

@ wonder.mice इस उदाहरण के लिए धन्यवाद, यह पहला है जिसने मुझे दिखाया है कि कैसे एक छवि वस्तु को सहेजना है।

— आर्थर डेंट

@scry आपको हमेशा एक छवि बनाने की ज़रूरत नहीं है, कभी-कभी आप कुछ कोड आज़माते हैं और एक दृश्य आउटपुट चाहते हैं, यह ऐसे अवसरों में आसान है।

— Schütze

Answer 6

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

with open('some_file.pkl', "wb") as fp:
    pickle.dump(fig, fp, protocol=4)

इस तरह, मैं बाद में फिगर ऑब्जेक्ट को लोड कर सकता हूं और सेटिंग्स को मैनिपुलेट कर सकता हूं।

मैं स्टैक locals()के प्रत्येक फ़ंक्शन / विधि के लिए स्रोत-कोड और डिक्शनरी के साथ स्टैक को भी लिखता हूं , ताकि मैं बाद में यह बता सकूं कि क्या आंकड़ा उत्पन्न हुआ।

एनबी: सावधान रहें, क्योंकि कभी-कभी यह विधि बड़ी फ़ाइलों को उत्पन्न करती है।

Comments

क्या जूपिटर नोटबुक में विकास करना आसान नहीं होगा, आंकड़े इनलाइन के साथ? इस तरह आप बिल्कुल इतिहास को ट्रैक कर सकते हैं, और यहां तक ​​कि इसे फिर से जोड़ सकते हैं।

— साइप्रियन टोमोयाग डे

@CiprianTomoiaga मैं कभी भी एक इंटरैक्टिव पाइथन शेल (जुपिटर या अन्यथा) से उत्पादन भूखंडों को उत्पन्न नहीं करता है। मैं स्क्रिप्ट से सभी की साजिश।

— gerrit

Answer 7

import datetime
import numpy as np
from matplotlib.backends.backend_pdf import PdfPages
import matplotlib.pyplot as plt

# Create the PdfPages object to which we will save the pages:
# The with statement makes sure that the PdfPages object is closed properly at
# the end of the block, even if an Exception occurs.
with PdfPages('multipage_pdf.pdf') as pdf:
    plt.figure(figsize=(3, 3))
    plt.plot(range(7), [3, 1, 4, 1, 5, 9, 2], 'r-o')
    plt.title('Page One')
    pdf.savefig()  # saves the current figure into a pdf page
    plt.close()

    plt.rc('text', usetex=True)
    plt.figure(figsize=(8, 6))
    x = np.arange(0, 5, 0.1)
    plt.plot(x, np.sin(x), 'b-')
    plt.title('Page Two')
    pdf.savefig()
    plt.close()

    plt.rc('text', usetex=False)
    fig = plt.figure(figsize=(4, 5))
    plt.plot(x, x*x, 'ko')
    plt.title('Page Three')
    pdf.savefig(fig)  # or you can pass a Figure object to pdf.savefig
    plt.close()

    # We can also set the file's metadata via the PdfPages object:
    d = pdf.infodict()
    d['Title'] = 'Multipage PDF Example'
    d['Author'] = u'Jouni K. Sepp\xe4nen'
    d['Subject'] = 'How to create a multipage pdf file and set its metadata'
    d['Keywords'] = 'PdfPages multipage keywords author title subject'
    d['CreationDate'] = datetime.datetime(2009, 11, 13)
    d['ModDate'] = datetime.datetime.today()

Answer 8

अपनी इच्छित सामग्री बनाने के लिए प्लॉट () और अन्य कार्यों का उपयोग करने के बाद, आप स्क्रीन पर प्लॉटिंग या फाइल करने के बीच चयन करने के लिए इस तरह से एक क्लॉज का उपयोग कर सकते हैं:

import matplotlib.pyplot as plt

fig = plt.figure(figsize=(4, 5))       # size in inches
# use plot(), etc. to create your plot.

# Pick one of the following lines to uncomment
# save_file = None
# save_file = os.path.join(your_directory, your_file_name)  

if save_file:
    plt.savefig(save_file)
    plt.close(fig)
else:
    plt.show()

Comments

कुछ लोग कह fig = plt.figure(figuresize=4, 5)सकते हैंfig = plt.figure(figsize=(4, 5)) #figure sizes in inches

— उपयोगकर्ता

Answer 9

मैंने निम्नलिखित प्रयोग किया:

import matplotlib.pyplot as plt

p1 = plt.plot(dates, temp, 'r-', label="Temperature (celsius)")  
p2 = plt.plot(dates, psal, 'b-', label="Salinity (psu)")  
plt.legend(loc='upper center', numpoints=1, bbox_to_anchor=(0.5, -0.05),        ncol=2, fancybox=True, shadow=True)

plt.savefig('data.png')  
plt.show()  
f.close()
plt.close()

मुझे आंकड़ा बचाने के बाद plt.show का उपयोग करना बहुत महत्वपूर्ण लगा, अन्यथा यह काम नहीं करेगा। चित्र png में निर्यात किया गया

Comments

क्षमा करें, इस में क्या च? प्लॉट की गई इमेज फाइल? f= plt.savefig('data.png')

— मोर्स

Answer 10

आप या तो कर सकते हैं:

plt.show(hold=False)
plt.savefig('name.pdf')

और GUI प्लॉट को बंद करने से पहले savefig को खत्म करने के लिए याद रखें। इस तरह आप पहले से इमेज देख सकते हैं।

वैकल्पिक रूप से, आप इसे plt.show() तब GUI को बंद करने और स्क्रिप्ट को फिर से चलाने के साथ देख सकते हैं , लेकिन इस बार के plt.show()साथ बदल सकते हैं plt.savefig()।

वैकल्पिक रूप से, आप उपयोग कर सकते हैं

fig, ax = plt.figure(nrows=1, ncols=1)
plt.plot(...)
plt.show()
fig.savefig('out.pdf')

Comments

एक अप्रत्याशित खोजशब्द तर्क 'पकड़' मिला

— अमितदत्त

Answer 11

यदि मेरी तरह, आप स्पाइडर आईडीई का उपयोग करते हैं, तो आपको इंटरेक्टिव मोड को निष्क्रिय करना होगा:

plt.ioff()

(यह आदेश स्वचालित रूप से वैज्ञानिक स्टार्टअप के साथ लॉन्च किया गया है)

यदि आप इसे फिर से सक्षम करना चाहते हैं, तो उपयोग करें:

plt.ion()

Answer 12

समाधान :

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.style.use('ggplot')
ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))
ts = ts.cumsum()
plt.figure()
ts.plot()
plt.savefig("foo.png", bbox_inches='tight')

यदि आप छवि के उपयोग को सहेजने के साथ-साथ छवि को प्रदर्शित करना चाहते हैं:

%matplotlib inline

उपरांत import matplotlib

Answer 13

प्रश्न के अनुसार Matplotlib (pyplot) savefig आउटपुट खाली छवि देता है ।

एक बात पर ध्यान देना चाहिए: यदि आप उपयोग करते हैं plt.showऔर यह बाद में होना चाहिएplt.savefig , या आप एक खाली छवि देंगे।

एक विस्तृत उदाहरण:

import numpy as np
import matplotlib.pyplot as plt


def draw_result(lst_iter, lst_loss, lst_acc, title):
    plt.plot(lst_iter, lst_loss, '-b', label='loss')
    plt.plot(lst_iter, lst_acc, '-r', label='accuracy')

    plt.xlabel("n iteration")
    plt.legend(loc='upper left')
    plt.title(title)
    plt.savefig(title+".png")  # should before plt.show method

    plt.show()


def test_draw():
    lst_iter = range(100)
    lst_loss = [0.01 * i + 0.01 * i ** 2 for i in xrange(100)]
    # lst_loss = np.random.randn(1, 100).reshape((100, ))
    lst_acc = [0.01 * i - 0.01 * i ** 2 for i in xrange(100)]
    # lst_acc = np.random.randn(1, 100).reshape((100, ))
    draw_result(lst_iter, lst_loss, lst_acc, "sgd_method")


if __name__ == '__main__':
    test_draw()

Answer 14

import matplotlib.pyplot as plt
plt.savefig("image.png")

Jupyter नोटबुक में आपको एक सेल में बाकी plt-code को एक साथ plt.show()जोड़ना और जोड़ना है plt.savefig()। छवि अभी भी आपकी नोटबुक में दिखाई देगी।

Comments

"निकालें plt.show ()" .. इससे मेरा दिन बच गया ...

— गुरु

Answer 15

यह देखते हुए कि आज (जब यह प्रश्न किया गया था तब उपलब्ध नहीं था) बहुत से लोग ज्यूपिटर नोटबुक को पाइथन कंसोल के रूप में उपयोग करते हैं, भूखंडों को बचाने के लिए एक बहुत ही आसान तरीका है .png, बस matplotlib' pylabबृहस्पति नोटबुक से वर्ग को कॉल करें , आंकड़ा इनलाइन करें' 'ज्यूपिटर कोशिकाएं, और फिर उस आकृति / छवि को एक स्थानीय निर्देशिका में खींचें। %matplotlib inlineपहली पंक्ति में मत भूलना !

Comments

यह एक अच्छा विचार है, बस फाइल पर प्रभाव का ध्यान रखने की जरूरत है अगर छवि को नोटबुक में एम्बेड किया गया है ..

— prusswan

Answer 16

इसके अतिरिक्त उन लोगों के लिए, मैंने __file__नाम के लिए जोड़ा इसलिए चित्र और पायथन फ़ाइल को समान नाम मिलते हैं। मैंने इसे बेहतर बनाने के लिए कुछ तर्क भी जोड़े:

# Saves a PNG file of the current graph to the folder and updates it every time
# (nameOfimage, dpi=(sizeOfimage),Keeps_Labels_From_Disappearing)
plt.savefig(__file__+".png",dpi=(250), bbox_inches='tight')
# Hard coded name: './test.png'

Answer 17

उपयोग करते समय matplotlib.pyplot, आपको पहले अपना प्लॉट बचाना होगा और फिर इन 2 लाइनों का उपयोग करके इसे बंद करना होगा:

fig.savefig('plot.png') # save the plot, place the path you want to save the figure in quotation
plt.close(fig) # close the figure window

Answer 18

जैसा कि पहले सुझाव दिया गया है, आप या तो उपयोग कर सकते हैं:

import matplotlib.pyplot as plt
plt.savefig("myfig.png")

जो कुछ भी आप देख रहे हैं, उसके लिए आइप्लोन इमेज को सेव करने के लिए। या एक अलग नोट पर (एक अलग कोण से देखते हुए), यदि आपको कभी भी खुले cv के साथ काम करने के लिए मिलता है, या यदि आपके पास खुला cv आयातित है, तो आप इसके लिए जा सकते हैं:

आयात cv2

cv2.imwrite ( "myfig.png", छवि)

लेकिन यह केवल मामले में है यदि आपको ओपन सीवी के साथ काम करने की आवश्यकता है। अन्यथा plt.savefig () पर्याप्त होना चाहिए।

Answer 19

आप अपनी छवि को किसी भी एक्सटेंशन (png, jpg, इत्यादि) और उस संकल्प के साथ सहेज सकते हैं जिसे आप चाहते हैं। अपने फिगर को बचाने के लिए यहां एक फंक्शन है।

import os

def save_fig(fig_id, tight_layout=True, fig_extension="png", resolution=300):
    path = os.path.join(IMAGES_PATH, fig_id + "." + fig_extension)
    print("Saving figure", fig_id)
    if tight_layout:
        plt.tight_layout()
    plt.savefig(path, format=fig_extension, dpi=resolution)

id fig_id ’वह नाम है जिसके द्वारा आप अपनी आकृति को बचाना चाहते हैं। आशा है ये मदद करेगा:)

Answer 20

आप इसे इस तरह से कर सकते हैं:

def plotAFig():
  plt.figure()
  plt.plot(x,y,'b-')
  plt.savefig("figurename.png")
  plt.close()