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 කියන්න), එබැවින් උදාහරණයක් ලෙස එය කණ්ඩායම් ස්ක්‍රිප්ට් වල භාවිතා කළ හැකිය. මම කොහොමද ඒක කරන්නේ?

ප්‍රශ්නයට පිළිතුරු ලැබී ඇති අතර, matplotlib.pyplot.savefig භාවිතා කරන විට ප්‍රයෝජනවත් උපදෙස් කිහිපයක් එක් කිරීමට මම කැමතියි . දිගුව මඟින් ගොනු ආකෘතිය නියම කළ හැකිය:

from matplotlib import pyplot as plt

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

පිළිවෙලින් රාස්ටරීකරණය කරන ලද හෝ දෛශිකකරණය කළ ප්‍රතිදානයක් ලබා දෙනු ඇත, දෙකම ප්‍රයෝජනවත් විය හැකිය. ඊට අමතරව, pylabරූපය වටා ත්‍යාගශීලී, බොහෝ විට නුසුදුසු, සුදු අවකාශයක් ඉතිරි වන බව ඔබට පෙනී යනු ඇත. මෙය සමඟ ඉවත් කරන්න:

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

අනෙක් අය පවසා ඇති පරිදි 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()(මා විසින්ම පරීක්‍ෂා නොකළේ).

විසඳුම:

pylab.savefig('foo.png')

මෙම ගැටළුව හරියටම ආමන්ත්‍රණය කරන 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')විධානය ඔබම ක්‍රියාත්මක කරන්න.

මෙම ඉඟි දෙකෙන්: එකක් , දෙකක්

"වත්මන්" රූපයේ සංකල්පයට ඔබ අකමැති නම්, කරන්න:

import matplotlib.image as mpimg

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

අනෙක් පිළිතුරු නිවැරදි ය. කෙසේ වෙතත්, සමහර විට මට පසුව රූප වස්තුව විවෘත කිරීමට අවශ්‍ය බව පෙනී යයි . උදාහරණයක් ලෙස, ලේබල් ප්‍රමාණය වෙනස් කිරීමට, ජාලයක් එක් කිරීමට හෝ වෙනත් සැකසුම් කිරීමට මට අවශ්‍ය විය හැකිය. පරිපූර්ණ ලෝකයක, මම හුදෙක් කුමන්ත්‍රණය ජනනය කරන කේතය නැවත ක්‍රියාත්මක කර සැකසුම් අනුවර්තනය කරමි. අහෝ, ලෝකය පරිපූර්ණ නොවේ. එබැවින්, PDF හෝ PNG වෙත සුරැකීමට අමතරව, මම එකතු කරන්නේ:

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

මේ ආකාරයට, මට පසුව රූප වස්තුව පූරණය කර මට කැමති පරිදි සැකසුම් හැසිරවිය හැකිය.

මම මූලාශ්‍ර කේතය සමඟ තොගයද ලියමි locals() එක් එක් ශ්‍රිතය / ක්‍රමය සඳහා ශබ්ද කෝෂය , එවිට රූපය ජනනය කළේ කුමක් දැයි මට පසුව පැවසිය හැකිය.

සැ.යු: ප්‍රවේශම් වන්න, සමහර විට මෙම ක්‍රමය මඟින් විශාල ලිපිගොනු ජනනය වේ.

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

ඔබට අවශ්‍ය අන්තර්ගතය නිර්මාණය කිරීම සඳහා කුමන්ත්‍රණය () සහ වෙනත් කාර්යයන් භාවිතා කිරීමෙන් පසුව, තිරයට කුමන්ත්‍රණය කිරීම හෝ ගොනු කිරීම අතර තෝරා ගැනීමට ඔබට මෙවැනි වගන්තියක් භාවිතා කළ හැකිය:

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

මම පහත සඳහන් දෑ භාවිතා කළෙමි:

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 වලින් අපනයනය කළ රූපය

ඔබට කළ හැක්කේ:

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

මා වැනි ඔබ ස්පයිඩර් IDE භාවිතා කරන්නේ නම්, ඔබ සමඟ අන්තර්ක්‍රියාකාරී මාදිලිය අක්‍රිය කළ යුතුය:

plt.ioff()

(මෙම විධානය විද්‍යාත්මක ආරම්භය සමඟ ස්වයංක්‍රීයව දියත් වේ)

ඔබට එය නැවත සක්‍රිය කිරීමට අවශ්‍ය නම්, භාවිතා කරන්න:

plt.ion()

විසඳුම:

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

ප්‍රශ්නයට අනුව මැට්ප්ලොට්ලිබ් (පයිප්ලොට්) සේව්ෆිග් හිස් රූපය ප්‍රතිදානය කරයි.

එක් දෙයක් සටහන් කළ යුතුය: ඔබ භාවිතා කරන්නේ නම් 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()

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

ජුපිටර් නෝට්බුක්හි ඔබට එක් කොටුවක ඇති අනෙක් පීඑල්ටී කේතය ඉවත් plt.show()කර එකතු plt.savefig()කළ යුතුය. රූපය තවමත් ඔබේ සටහන් පොතේ දිස්වනු ඇත.

භාවිතා කරන විට 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

අද (මෙම ප්රශ්නය ඉදිරිපත් වු විට නොව ලබාගත හැකි විය) මිනිසුන් බොහෝ පිඹුරා කොන්සෝලය ලෙස Jupyter නෝට්බුක් භාවිතා කරන ලෙස කුමන්ත්රණය බේරා ගැනීමට අතිශය පහසු ක්රමයක් පවතී ලබා .pngපමණක් අමතන්න, matplotlibගේ pylabJupyter නෝට්බුක් සිට පන්ති, එම සංඛ්යාව කුමන්ත්රණය 'පේළිගත ජුපිටර් සෛල, ඉන්පසු එම රූපය / රූපය දේශීය නාමාවලියකට ඇදගෙන යන්න. %matplotlib inlineපළමු පේළියේ අමතක නොකරන්න !

ඉහත අයට අමතරව, මම __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'

පෙර යෝජනා කළ පරිදි, ඔබට භාවිතා කළ හැකිය:

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

ඔබ පෙන්වන ඕනෑම IPhython අනුරුවක් සුරැකීම සඳහා. නැතහොත් වෙනත් සටහනක (වෙනත් කෝණයකින් බලන විට), ඔබ කවදා හෝ විවෘත සීවී සමඟ වැඩ කිරීමට ගියහොත් හෝ ඔබ විවෘත සීවී ආනයනය කර ඇත්නම්, ඔබට මේ සඳහා යා හැකිය:

cv2 ආනයනය කරන්න

cv2.imwrite ("myfig.png", රූපය)

නමුත් ඔබට විවෘත සීවී සමඟ වැඩ කිරීමට අවශ්‍ය නම් මෙය සිදු වේ. එසේ නොමැතිනම් plt.savefig () ප්‍රමාණවත් විය යුතුය.

ඕනෑම දිගුවකින් (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)

'fig_id' යනු ඔබේ රූපය සුරැකීමට අවශ්‍ය නමයි. එය උපකාරී වේ යැයි සිතමි :)

ඔබට එය මේ ආකාරයෙන් කළ හැකිය:

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