ostrzeżenie o zbyt wielu otwartych postaciach

W skrypcie, w którym tworzę wiele figurek fix, ax = plt.subplots(...), otrzymuję ostrzeżenie RuntimeWarning: Otwarto ponad 20 figurek. Figury utworzone za pomocą interfejsu pyplot ( matplotlib.pyplot.figure) są przechowywane do momentu jawnego zamknięcia i mogą zajmować zbyt dużo pamięci.

Nie rozumiem jednak, dlaczego otrzymuję to ostrzeżenie, bo po zapisaniu figury za pomocą fig.savefig(...), kasuję ją za pomocą fig.clear(); del fig. W żadnym momencie w moim kodzie nie mam otwartych więcej niż jednej cyfry naraz. Mimo to otrzymuję ostrzeżenie o zbyt wielu otwartych liczbach. Co to oznacza / jak mogę uniknąć ostrzeżenia?

Użyj .clflub .clana swoim obiekcie figury zamiast tworzyć nową figurę. Od @DavidZwicker

Zakładając, że zaimportowałeś pyplotjako

import matplotlib.pyplot as plt

plt.cla()czyści oś , tj. aktualnie aktywną oś na bieżącej figurze. Pozostawia pozostałe osie nietknięte.

plt.clf()czyści całą bieżącą figurę ze wszystkimi jej osiami, ale pozostawia otwarte okno, aby można było je ponownie wykorzystać na innych wykresach.

plt.close()zamyka okno , które będzie oknem bieżącym, jeśli nie określono inaczej. plt.close('all')zamknie wszystkie otwarte figury.

Przyczyną, del figktóra nie działa, jest to, że pyplotmaszyna stanu zachowuje odniesienie do figury wokół (tak jak musi, jeśli chce wiedzieć, jaka jest „bieżąca liczba”). Oznacza to, że nawet jeśli usuniesz swój odnośnik do figury, istnieje co najmniej jeden odnośnik na żywo, więc nigdy nie zostanie on usunięty .

Ponieważ sonduję tutaj zbiorową mądrość dla tej odpowiedzi, @JoeKington wspomina w komentarzach, plt.close(fig)które usuwają konkretną instancję figury z maszyny stanu pylab ( plt._pylab_helpers.Gcf ) i pozwalają na zbieranie śmieci.

Oto nieco więcej szczegółów, aby rozwinąć odpowiedź Hookeda . Kiedy po raz pierwszy przeczytałem tę odpowiedź, przegapiłem instrukcję, aby zadzwonić clf() zamiast tworzyć nową figurę . clf()samo w sobie nie pomoże, jeśli potem pójdziesz i stworzysz kolejną figurę.

Oto trywialny przykład, który powoduje ostrzeżenie:

from matplotlib import pyplot as plt, patches
import os


def main():
    path = 'figures'
    for i in range(21):
        _fig, ax = plt.subplots()
        x = range(3*i)
        y = [n*n for n in x]
        ax.add_patch(patches.Rectangle(xy=(i, 1), width=i, height=10))
        plt.step(x, y, linewidth=2, where='mid')
        figname = 'fig_{}.png'.format(i)
        dest = os.path.join(path, figname)
        plt.savefig(dest)  # write image to file
        plt.clf()
    print('Done.')

main()

Aby uniknąć ostrzeżenia, muszę wyciągnąć połączenie subplots()poza pętlę. Aby nadal widzieć prostokąty, muszę przełączyć się clf()na cla(). To czyści oś bez usuwania samej osi.

from matplotlib import pyplot as plt, patches
import os


def main():
    path = 'figures'
    _fig, ax = plt.subplots()
    for i in range(21):
        x = range(3*i)
        y = [n*n for n in x]
        ax.add_patch(patches.Rectangle(xy=(i, 1), width=i, height=10))
        plt.step(x, y, linewidth=2, where='mid')
        figname = 'fig_{}.png'.format(i)
        dest = os.path.join(path, figname)
        plt.savefig(dest)  # write image to file
        plt.cla()
    print('Done.')

main()

Jeśli generujesz wykresy partiami, może być konieczne użycie obu cla()i close(). Napotkałem problem polegający na tym, że partia mogła mieć więcej niż 20 działek bez narzekania, ale po 20 partiach narzekała. Naprawiłem to, używając cla()po każdym wykresie i close()po każdej partii.

from matplotlib import pyplot as plt, patches
import os


def main():
    for i in range(21):
        print('Batch {}'.format(i))
        make_plots('figures')
    print('Done.')


def make_plots(path):
    fig, ax = plt.subplots()
    for i in range(21):
        x = range(3 * i)
        y = [n * n for n in x]
        ax.add_patch(patches.Rectangle(xy=(i, 1), width=i, height=10))
        plt.step(x, y, linewidth=2, where='mid')
        figname = 'fig_{}.png'.format(i)
        dest = os.path.join(path, figname)
        plt.savefig(dest)  # write image to file
        plt.cla()
    plt.close(fig)


main()

Zmierzyłem wydajność, aby sprawdzić, czy warto ponownie użyć liczby w partii, a ten mały przykładowy program zwolnił z 41 s do 49 s (20% wolniej), gdy dzwoniłem close()po każdym wykresie.

Jeśli zamierzasz świadomie przechowywać wiele wykresów w pamięci, ale nie chcesz być o tym ostrzegany, możesz zaktualizować swoje opcje przed wygenerowaniem liczb.

import matplotlib.pyplot as plt
plt.rcParams.update({'figure.max_open_warning': 0})

Zapobiegnie to wysyłaniu ostrzeżenia bez zmiany sposobu zarządzania pamięcią.

Poniższy fragment kodu rozwiązał problem za mnie:

class FigureWrapper(object):
    '''Frees underlying figure when it goes out of scope. 
    '''

    def __init__(self, figure):
        self._figure = figure

    def __del__(self):
        plt.close(self._figure)
        print("Figure removed")


# .....
    f, ax = plt.subplots(1, figsize=(20, 20))
    _wrapped_figure = FigureWrapper(f)

    ax.plot(...
    plt.savefig(...
# .....

Kiedy _wrapped_figurewychodzi poza zakres, środowisko wykonawcze wywołuje naszą __del__()metodę z plt.close()inside. Dzieje się tak, nawet jeśli wyjątek jest uruchamiany po _wrapped_figurekonstruktorze.

Jest to również przydatne, jeśli chcesz tylko tymczasowo wyłączyć ostrzeżenie:

    import matplotlib.pyplot as plt
       
    with plt.rc_context(rc={'figure.max_open_warning': 0}):
        lots_of_plots()