avvertimento su troppe figure aperte

In una sceneggiatura in cui creo molte figure fix, ax = plt.subplots(...), ricevo l'avvertimento RuntimeWarning: sono state aperte più di 20 figure. Le figure create tramite l'interfaccia pyplot ( matplotlib.pyplot.figure) vengono mantenute fino a quando non vengono esplicitamente chiuse e possono consumare troppa memoria.

Tuttavia, non capisco perché ricevo questo avviso, perché dopo aver salvato la figura con fig.savefig(...), la cancello con fig.clear(); del fig. In nessun punto del mio codice, ho più di una cifra aperta alla volta. Tuttavia, ricevo l'avvertimento su troppe figure aperte. Cosa significa / come posso evitare di ricevere l'avviso?

Usa .clfo .clasul tuo oggetto figura invece di creare una nuova figura. Da @DavidZwicker

Supponendo che tu abbia importato pyplotcome

import matplotlib.pyplot as plt

plt.cla()cancella un asse , ovvero l'asse attualmente attivo nella figura corrente. Lascia intatti gli altri assi.

plt.clf()cancella l'intera figura corrente con tutti i suoi assi, ma lascia aperta la finestra, in modo che possa essere riutilizzata per altri grafici.

plt.close()chiude una finestra , che sarà la finestra corrente, se non diversamente specificato. plt.close('all')chiuderà tutte le figure aperte.

La ragione per cui del fignon funziona è che la pyplotmacchina a stati mantiene un riferimento alla figura intorno (come deve sapere se sta per conoscere la "figura attuale"). Ciò significa che anche se elimini il tuo riferimento alla figura, c'è almeno un riferimento attivo, quindi non sarà mai raccolto.

Dal momento che sto sondando la saggezza collettiva qui per questa risposta, @JoeKington menziona nei commenti che plt.close(fig)rimuoveranno un'istanza di figura specifica dalla macchina a stati pylab ( plt._pylab_helpers.Gcf ) e consentirò di essere spazzatura raccolta.

Ecco un po 'più di dettaglio per espandere la risposta di Hooked . Quando ho letto per la prima volta quella risposta, ho perso l'istruzione di chiamare clf() invece di creare una nuova figura . clf()da solo non aiuta se poi vai a creare un'altra figura.

Ecco un esempio banale che provoca l'avvertimento:

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

Per evitare l'avvertimento, devo trasferire la chiamata subplots()all'esterno del loop. Per continuare a vedere i rettangoli, devo passare clf()a cla(). Ciò cancella l'asse senza rimuovere l'asse stesso.

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

Se stai generando grafici in lotti, potresti dover utilizzare sia cla()e close(). Ho riscontrato un problema in cui un batch poteva avere più di 20 grafici senza lamentarsi, ma si sarebbe lamentato dopo 20 batch. L'ho risolto usando cla()dopo ogni trama e close()dopo ogni partita.

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

Ho misurato le prestazioni per vedere se valeva la pena riutilizzare la cifra all'interno di un batch, e questo piccolo programma di esempio è rallentato da 41 a 49 secondi (20% più lento) quando ho appena chiamato close()dopo ogni trama.

Se hai intenzione di mantenere consapevolmente molti grafici in memoria, ma non vuoi essere avvisato, puoi aggiornare le tue opzioni prima di generare cifre.

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

Ciò impedirà l'emissione dell'avviso senza modificare nulla sul modo in cui viene gestita la memoria.

Il frammento seguente ha risolto il problema per me:

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(...
# .....

Quando _wrapped_figureesce dal campo di applicazione, il runtime chiama il nostro __del__()metodo con plt.close()inside. Succede anche se l'eccezione si attiva dopo il _wrapped_figurecostruttore.

Ciò è utile anche se si desidera solo eliminare temporaneamente l'avviso:

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