gnuplot frente a Matplotlib

Comencé con un proyecto que grafica los registros de Tomcat usando gnuplot-py , correlacionando específicamente solicitudes particulares con la asignación de memoria y la recolección de basura. ¿Cuál es la sabiduría colectiva sobre gnuplot-py vs Matplotlib para graficar en Python? ¿Hay mejores bibliotecas de gráficos de las que no haya oído hablar?

Mis consideraciones generales son:

• Si bien gnuplot tiene una gran cantidad de documentación, gnuplot-py no. ¿Qué tan buena es la comunidad de documentación para Matplotlib?
• ¿Hay cosas que gnuplot puede hacer, pero gnuplot-py no?
• ¿Matplotlib tiene una mejor compatibilidad con Python?
• ¿Hay algún gran espectáculo que frene errores en alguno de los dos? Molestias?
• Actualmente, gnuplot está graficando 100.000 puntos, planeo escalar esto a millones. ¿Debería esperar problemas? ¿Qué tan bien maneja Matplotlib esto?
• ¿Facilidad de uso, tiempo de respuesta para gnuplot vs Matplotlib?
• ¿Qué tan fácil sería portar el código gnuplot-py existente a Matplotlib?

¿Cómo abordaría esta tarea?

• Puede comprobar la documentación de matplotlib usted mismo. Lo encuentro bastante completo.
• Tengo muy poca experiencia con gnuplot-py, por lo que no puedo decir si puede hacer todo lo que puede hacer gnuplot.
• Matplotlib está escrito y diseñado específicamente para Python, por lo que encaja muy bien con los modismos de Python y demás.
• Matplotlib es un proyecto maduro. La NASA lo usa para algunas cosas.
• Tracé decenas de millones de puntos en Matplotlib, y todavía se veía hermoso y respondió rápidamente.
• Más allá de la forma orientada a objetos de usar Matplotlib está la interfaz pylab, que hace que trazar sea tan fácil como en MATLAB, es decir, muy fácil.
• En cuanto a la migración de gnuplot-py a matplotlib, no tengo idea.

Matplotlib = facilidad de uso, Gnuplot = rendimiento (ligeramente mejor)

Sé que esta publicación es antigua y está respondida pero estaba pasando y quería poner mi granito de arena. Aquí está mi conclusión: si tiene un conjunto de datos no tan grande, debe usar Matplotlib. Es más fácil y se ve mejor. Sin embargo, si realmente necesita rendimiento, puede usar Gnuplot. Agregué un código para probarlo en su máquina y ver por sí mismo si hace una diferencia real (este no es un punto de referencia de rendimiento real, pero debería dar una primera idea).

El siguiente gráfico representa el tiempo requerido (en segundos) para:

• Trazar un gráfico de dispersión aleatorio
• Guarde el gráfico en un archivo png

Configuración:

• gnuplot: 5.2.2
• gnuplot-py: 1.8
• matplotlib: 2.1.2

Recuerdo que la brecha de rendimiento es mucho mayor cuando se ejecuta en una computadora más antigua con versiones anteriores de las bibliotecas (~ 30 segundos de diferencia para un diagrama de dispersión grande).

Además, como se menciona en los comentarios, puede obtener una calidad equivalente de parcelas. Pero tendrás que sudar más para hacerlo con Gnuplot.

Aquí está el código para generar el gráfico si desea probarlo en su máquina:

# -*- coding: utf-8 -*-

from timeit import default_timer as timer
import matplotlib.pyplot as plt
import Gnuplot, Gnuplot.funcutils
import numpy as np
import sys
import os

def mPlotAndSave(x, y):
    plt.scatter(x, y)
    plt.savefig('mtmp.png')
    plt.clf()

def gPlotAndSave(data, g):
    g("set output 'gtmp.png'")
    g.plot(data)
    g("clear")

def cleanup():
    try:
        os.remove('gtmp.png')
    except OSError:
        pass
    try:
        os.remove('mtmp.png')
    except OSError:
        pass

begin = 2
end = 500000
step = 10000
numberOfPoints = range(begin, end, step)
n = len(numberOfPoints)
gnuplotTime = []
matplotlibTime = []
progressBarWidth = 30

# Init Gnuplot
g = Gnuplot.Gnuplot()
g("set terminal png size 640,480")

# Init matplotlib to avoid a peak in the beginning
plt.clf()

for idx, val in enumerate(numberOfPoints):
    # Print a nice progress bar (crucial)
    sys.stdout.write('\r')
    progress = (idx+1)*progressBarWidth/n
    bar = "▕" + "▇"*progress + "▁"*(progressBarWidth-progress) + "▏" + str(idx) + "/" + str(n-1)
    sys.stdout.write(bar)
    sys.stdout.flush()

    # Generate random data
    x = np.random.randint(sys.maxint, size=val)  
    y = np.random.randint(sys.maxint, size=val)
    gdata = zip(x,y)

    # Generate string call to a matplotlib plot and save, call it and save execution time
    start = timer()
    mPlotAndSave(x, y)
    end = timer()
    matplotlibTime.append(end - start)

    # Generate string call to a gnuplot plot and save, call it and save execution time
    start = timer()
    gPlotAndSave(gdata, g)
    end = timer()
    gnuplotTime.append(end - start)

    # Clean up the files
    cleanup()

del g
sys.stdout.write('\n')
plt.plot(numberOfPoints, gnuplotTime, label="gnuplot")
plt.plot(numberOfPoints, matplotlibTime, label="matplotlib")
plt.legend(loc='upper right')
plt.xlabel('Number of points in the scatter graph')
plt.ylabel('Execution time (s)')
plt.savefig('execution.png')
plt.show()

matplotlibtiene bastante buena documentación y parece ser bastante estable. Las parcelas que produce son hermosas, "calidad de publicación" sin duda. Debido a la buena documentación y la cantidad de código de ejemplo disponible en línea, es fácil de aprender y usar, y no creo que tenga muchos problemas para traducir el gnuplotcódigo. Después de todo, los científicos están utilizando matplotlib para trazar datos y preparar informes, por lo que incluye todo lo que uno necesita.

Una marcada ventaja de matplotlib es que puede integrarlo con las GUI de Python ( wxPython y PyQt , al menos) y crear una aplicación GUI con gráficos agradables.

Después de usar GNUplot (con mi propio contenedor de Python) durante mucho tiempo (y realmente no me gustó la salida de aspecto de los 80), comencé a echar un vistazo a matplotlib. Debo decir que me gusta mucho, la salida se ve muy bien y los documentos son de alta calidad y extensos (aunque eso también se aplica a GNUplot). ¡Lo único que pasé mucho tiempo buscando en los documentos de matplotlib es cómo escribir en un archivo de imagen en lugar de en la pantalla! Afortunadamente, esta página lo explica bastante bien: http://www.dalkescientific.com/writings/diary/archive/2005/04/23/matplotlib_without_gui.html

He jugado con ambos y me gusta mucho más Matplotlib en términos de integración de Python, opciones y calidad de gráficos / diagramas.

Sobre el rendimiento y el trazado de una gran cantidad de puntos: comparé esto con un diagrama de dispersión de 500.000 puntos cargados desde un archivo de texto y guardados en un png, usando gnuplot * y matplotlib.

500.000 points scatterplot
gnuplot:      5.171 s
matplotlib: 230.693 s

Lo ejecuté solo una vez y los resultados no parecen idénticos, pero creo que la idea es clara: gnuplot gana en rendimiento.

* Utilicé gnuplot directamente ya que la demostración de gnuplotpy no funciona de fábrica para mí. Matplotlib gana en la integración de Python.

Lo que puede hacer Gnuplot Gnuplot-Py también lo puede hacer. Porque Gnuplot puede ser manejado por tubería (pgnuplot). Gnuplot-Py es solo una capa delgada para él. Así que no necesitas preocuparte por eso.

Por qué prefiero gnuplot, tal vez los muchos formatos de salida (PDF, PS y LaTex), que es muy útil en artículos, y la salida predeterminada parece más de estilo científico :)

Algunas gnuplotventajas de (todavía no me gusta matlibplot después de años de uso):

• trazar la función simplemente con sin(x)(no es necesario definir matrices y pensar en rangos)
• trazar archivos directamente (no es necesario importarlos a una matriz)
• trazar datos canalizados (ejecutar comandos de shell sobre la marcha "<echo 1 2 3")
• botón copiar al portapapeles
• trazado más rápido
• codificación más rápida

gplot.py es otro contenedor de gnuplot contenedor para python y jupyter.