Guardar figuras interactivas de Matplotlib

¿Hay alguna forma de guardar una figura de Matplotlib de modo que se pueda volver a abrir y restaurar la interacción típica? (¿Como el formato .fig en MATLAB?)

Me encuentro ejecutando los mismos scripts muchas veces para generar estas figuras interactivas. O les envío a mis colegas varios archivos PNG estáticos para mostrar diferentes aspectos de un gráfico. Prefiero enviar el objeto figura y hacer que interactúen con él.

Esta sería una gran característica, pero AFAIK no está implementada en Matplotlib y probablemente sería difícil de implementar usted mismo debido a la forma en que se almacenan las cifras.

Sugeriría (a) procesar los datos por separado de la generación de la figura (que guarda los datos con un nombre único) y escribir un script de generación de figuras (cargando un archivo específico de los datos guardados) y editarlos como mejor le parezca o (b ) guarde como formato PDF / SVG / PostScript y edítelo en algún editor de figuras elegante como Adobe Illustrator (o Inkscape ).

EDITAR post Otoño de 2012 : como otros señalaron a continuación (aunque mencionaron aquí que esta es la respuesta aceptada), Matplotlib desde la versión 1.2 le permitió seleccionar cifras. Como indican las notas de la versión , es una función experimental y no admite guardar una figura en una versión de matplotlib y abrirla en otra. Por lo general, tampoco es seguro restaurar un pepinillo de una fuente que no sea de confianza.

Para compartir / editar gráficos posteriores (que primero requieren un procesamiento significativo de datos y es posible que deban modificarse meses después, por ejemplo, durante la revisión por pares para una publicación científica), todavía recomiendo el flujo de trabajo de (1) tener un script de procesamiento de datos que antes de generar un gráfico guarda los datos procesados ​​(que entran en su diagrama) en un archivo, y (2) tiene un script de generación de diagrama separado (que usted ajusta según sea necesario) para recrear el diagrama. De esta manera, para cada trama, puede ejecutar rápidamente un script y volver a generarlo (y copiar rápidamente la configuración de la trama con nuevos datos). Dicho esto, el decapado de una figura podría ser conveniente para el análisis de datos a corto plazo / interactivo / exploratorio.

Acabo de descubrir cómo hacer esto. El "soporte de pickle experimental" mencionado por @pelson funciona bastante bien.

Prueba esto:

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

Después de su ajuste interactivo, guarde el objeto de figura como un archivo binario:

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

Más tarde, abra la figura y los ajustes deben guardarse y la interactividad de la GUI debe estar presente:

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

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

Incluso puede extraer los datos de los gráficos:

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

(Funciona para líneas, pcolor e imshow; pcolormesh funciona con algunos trucos para reconstruir los datos aplanados ).

Obtuve el excelente consejo de Guardar figuras de Matplotlib usando Pickle .

A partir de Matplotlib 1.2, ahora tenemos soporte de pickle experimental . Pruébelo y vea si funciona bien para su caso. Si tiene algún problema, háganoslo saber en la lista de correo de Matplotlib o abriendo un problema en github.com/matplotlib/matplotlib .

¿Por qué no enviar el script de Python? Los archivos .fig de MATLAB requieren que el destinatario tenga MATLAB para mostrarlos, por lo que eso es equivalente a enviar un script de Python que requiere que se muestre Matplotlib.

Alternativamente (descargo de responsabilidad: aún no he probado esto), puede intentar encurtir la figura:

import pickle
output = open('interactive figure.pickle', 'wb')
pickle.dump(gcf(), output)
output.close()

Buena pregunta. Aquí está el texto del documento de pylab.save:

pylab ya no proporciona una función de guardado, aunque la antigua función de pylab todavía está disponible como matplotlib.mlab.save (todavía puede referirse a ella en pylab como "mlab.save"). Sin embargo, para archivos de texto sin formato, recomendamos numpy.savetxt. Para guardar matrices numpy, recomendamos numpy.save y su numpy.load analógico, que están disponibles en pylab como np.save y np.load.

Descubrí una forma relativamente simple (aunque un poco poco convencional) de guardar mis figuras de matplotlib. Funciona así:

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

con función save_plotdefinida así (versión simple para entender la lógica):

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'

o definir una función save_plotcomo esta (mejor versión que usa compresión zip para producir archivos de figuras más livianos):

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'

Esto hace que use un módulo libscriptpropio, que se basa principalmente en módulos inspecty ast. Puedo intentar compartirlo en Github si se expresa interés (primero requeriría una limpieza y yo comenzaría con Github).

La idea detrás de esta save_plotfunción y libscriptmódulo es buscar las instrucciones de Python que crean la figura (usando el módulo inspect), analizarlas (usando el módulo ast) para extraer todas las variables, funciones y módulos en los que se basa la importación, extraerlos del contexto de ejecución y serializarlos. como instrucciones de Python (el código para las variables será como t=[0.0,2.0,0.01]... y el código para los módulos será como import matplotlib.pyplot as plt...) antepuesto a las instrucciones de la figura. Las instrucciones de Python resultantes se guardan como un script de Python cuya ejecución reconstruirá la figura original de matplotlib.

Como puede imaginar, esto funciona bien para la mayoría (si no todas) las figuras de matplotlib.