Creando gráficos con Matplotlib y Seaborn

Gráficos con Matplotlib y Seaborn

 

La visualización de datos es esencial en el trabajo de datos ya que ayuda a las personas a comprender lo que sucede con nuestros datos. Es difícil asimilar la información de los datos directamente en su forma cruda, pero la visualización despertaría el interés y la participación de las personas. Por eso es importante aprender visualización de datos para tener éxito en el campo de los datos.

Matplotlib es una de las bibliotecas de visualización de datos más populares de Python porque es muy versátil y se puede visualizar prácticamente cualquier cosa desde cero. Puedes controlar muchos aspectos de tu visualización con este paquete.

Por otro lado, Seaborn es un paquete de visualización de datos de Python que se construye sobre Matplotlib. Ofrece un código de alto nivel mucho más simple con varios temas integrados en el paquete. El paquete es excelente si deseas una visualización rápida de datos con un aspecto agradable.

• Cómo comenzar y hacer crecer un podcast con IA
• Patrones de Ingeniería de Software para Aprendizaje Automático
• Aprovechando los Modelos Generativos para Impulsar el Aprendizaje Semi-Supervisado

En este artículo, exploraremos ambos paquetes y aprenderemos cómo visualizar tus datos con estos paquetes. Vamos a ello.

 

Visualización con Matplotlib

 

Como se mencionó anteriormente, Matplotlib es un paquete de Python versátil donde podemos controlar varios aspectos de la visualización. El paquete se basa en el lenguaje de programación Matlab, pero lo aplicamos en Python.

La biblioteca Matplotlib generalmente ya está disponible en tu entorno, especialmente si usas Anaconda. Si no es así, puedes instalarlos con el siguiente código.

pip install matplotlib

 

Después de la instalación, importaremos el paquete Matplotlib para la visualización con el siguiente código.

import matplotlib.pyplot as plt

 

Comencemos con la trama básica con Matplotlib. Para empezar, crearé datos de muestra.

import numpy as np

x = np.linspace(0,5,21)
y = x**2

 

Con estos datos, crearemos un gráfico de línea con el paquete Matplotlib.

plt.plot(x, y, 'b')
plt.xlabel('Eje X')
plt.ylabel('Eje Y')
plt.title('Gráfico de muestra')

 

  En el código anterior, pasamos los datos a la función de matplotlib (x e y) para crear un gráfico de línea simple con una línea azul. Además, controlamos la etiqueta de los ejes y el título con el código anterior.

Intentemos crear una trama múltiple de matplotlib con la función subplot.

plt.subplot(1,2,1)
plt.plot(x, y, 'b--')
plt.title('Subtrama 1')
plt.subplot(1,2,2)
plt.plot(x, y, 'r')
plt.title('Subtrama 2')

 

 

En el código anterior, creamos dos gráficos uno al lado del otro. La función subplot controla la posición del gráfico; por ejemplo, plt.subplot(1,2,1) significa que tendríamos dos gráficos en una fila (primer parámetro) y dos columnas (segundo parámetro). El tercer parámetro sirve para controlar a qué gráfico nos estamos refiriendo en ese momento. Entonces, plt.subplot(1,2,1) significa el primer gráfico de los gráficos de una fila y dos columnas.

Esa es la base de las funciones de Matplotlib, pero si queremos tener más control sobre la visualización de Matplotlib, debemos usar el Método Orientado a Objetos (OOM). Con OOM, produciremos visualizaciones directamente desde el objeto figura y llamaremos a cualquier atributo del objeto especificado.

Permíteme darte un ejemplo de visualización con Matplotlib OOM.

#crear instancia de figura (Canvas)
fig = plt.figure()

#agregar los ejes al lienzo
ax = fig.add_axes([0.1, 0.1, 0.7, 0.7]) #izquierda, inferior, ancho, alto (rango del 0 al 1)

#agregar el gráfico a los ejes dentro del lienzo
ax.plot(x, y, 'b')
ax.set_xlabel('Etiqueta X')
ax.set_ylabel('Etiqueta Y')
ax.set_title('Gráfico con OOM')

 

 

El resultado es similar al gráfico que creamos, pero el código es más complejo. Al principio, parecía contraproducente, pero el uso de OOM nos permitió controlar virtualmente todo con nuestra visualización. Por ejemplo, en el gráfico de arriba, podemos controlar dónde se encuentran los ejes dentro del lienzo.

Para ver cómo vemos las diferencias en el uso de OOM en comparación con la función de trazado normal, pongamos dos gráficos con sus respectivos ejes superpuestos uno sobre otro.

#crear instancia de figura (lienzo)
fig = plt.figure()

#agregar dos ejes al lienzo
ax1 = fig.add_axes([0.1, 0.1, 0.7, 0.7]) 
ax2 = fig.add_axes([0.2, 0.35, 0.2, 0.4]) 

#agregar el gráfico a los ejes respectivos dentro del lienzo
ax1.plot(x, y, 'b')
ax1.set_xlabel('Etiqueta X Eje 1')
ax1.set_ylabel('Etiqueta Y Eje 1')
ax1.set_title('Gráfico con OOM Eje 1')

ax2.plot(x, y, 'r--')
ax2.set_xlabel('Etiqueta X Eje 2')
ax2.set_ylabel('Etiqueta Y Eje 2')
ax2.set_title('Gráfico con OOM Eje 2')

 

 

En el código anterior, especificamos un objeto lienzo con la función plt.figure y produjimos todos estos gráficos a partir del objeto figura. Podemos producir tantos ejes como sea posible dentro de un lienzo y colocar una visualización en ellos.

También es posible crear automáticamente la figura y el objeto de ejes con la función subplot.

fig, ax = plt.subplots(nrows = 1, ncols =2)

ax[0].plot(x, y, 'b--')
ax[0].set_xlabel('Etiqueta X')
ax[0].set_ylabel('Etiqueta Y')
ax[0].set_title('Gráfico con OOM subplot 1')

 

 

Usando la función subplots, creamos tanto figuras como una lista de objetos de ejes. En la función anterior, especificamos el número de gráficos y la posición de una fila con dos columnas de gráficos.

Para el objeto de ejes, es una lista de todos los ejes para los gráficos a los que podemos acceder. En el código anterior, accedemos al primer objeto de la lista para crear el gráfico. El resultado son dos gráficos, uno lleno con el gráfico de línea mientras que el otro solo tiene los ejes.

Debido a que subplots produce una lista de objetos de ejes, puedes iterarlos de manera similar al siguiente código.

fig, axes = plt.subplots(nrows = 1, ncols =2)

for ax in axes:

    ax.plot(x, y, 'b--')
    ax.set_xlabel('Etiqueta X')
    ax.set_ylabel('Etiqueta Y')
    ax.set_title('Gráfico con OOM')

plt.tight_layout()

 

 

Puedes jugar con el código para producir los gráficos necesarios. Además, usamos la función tight_layout porque existe la posibilidad de que los gráficos se superpongan.

Intentemos algunos parámetros básicos que podemos usar para controlar nuestro gráfico de Matplotlib. Primero, intentemos cambiar los tamaños del lienzo y de los píxeles.

fig = plt.figure(figsize = (8,4), dpi =100)

 

   

El parámetro figsize acepta una tupla de dos números (ancho, alto) donde el resultado es similar al gráfico de arriba.

A continuación, intentemos agregar una leyenda al gráfico.

fig = plt.figure(figsize = (8,4), dpi =100)

ax = fig.add_axes([0.1, 0.1, 0.7, 0.7])

ax.plot(x, y, 'b', label = 'Primera línea')
ax.plot(x, y/2, 'r', label = 'Segunda línea')
ax.set_xlabel('Etiqueta X')
ax.set_ylabel('Etiqueta Y')
ax.set_title('Gráfico con OOM y Leyenda')
plt.legend()

 

 

Asignando el parámetro de etiqueta al gráfico y utilizando la función de leyenda, podemos mostrar la etiqueta como una leyenda.

Por último, podemos utilizar el siguiente código para guardar nuestro gráfico.

fig.savefig('visualizacion.jpg')

 

Hay muchos gráficos especiales diferentes al gráfico de líneas mostrado arriba. Podemos acceder a estos gráficos utilizando estas funciones. Intentemos varios gráficos que podrían ayudar en su trabajo.

Gráfico de dispersión

En lugar de un gráfico de líneas, podemos crear un gráfico de dispersión para visualizar la relación entre las características utilizando el siguiente código.

plt.scatter(x,y)

 

 

Gráfico de histograma

Un gráfico de histograma visualiza la distribución de datos representada en los intervalos. 

plt.hist(y, bins = 5)

 

 

Diagrama de caja

El diagrama de caja es una técnica de visualización que representa la distribución de datos en cuartiles.

plt.boxplot(x)

 

 

Gráfico de pastel

El gráfico de pastel es un gráfico de forma circular que representa las proporciones numéricas del gráfico categórico, por ejemplo, la frecuencia de los valores categóricos en los datos.

freq = [2,4,1,3]
fruit = ['Manzana', 'Plátano', 'Uva', 'Pera']
plt.pie(freq, labels = fruit)

 

 

Todavía hay muchos gráficos especiales de la biblioteca Matplotlib que se pueden consultar aquí.

 

Visualización con Seaborn

 

Seaborn es un paquete de Python para visualización estadística construido sobre Matplotlib. Lo que hace que Seaborn se destaque es que simplifica la creación de visualizaciones con un excelente estilo. El paquete también funciona con Matplotlib, ya que muchas de las API de Seaborn están vinculadas a Matplotlib.

Probemos el paquete de Seaborn. Si no ha instalado el paquete, puede hacerlo utilizando el siguiente código.

pip install seaborn

 

Seaborn tiene una API incorporada para obtener conjuntos de datos de muestra que podemos utilizar para probar el paquete. Utilizaremos este conjunto de datos para crear diversas visualizaciones con Seaborn.

import seaborn as sns

tips = sns.load_dataset('tips')
tips.head()

 

 

Utilizando los datos anteriores, exploraremos los gráficos de Seaborn, incluyendo gráficos de distribución, categóricos, de relación y de matriz.

Gráficos de distribución

El primer gráfico que probaremos con Seaborn es el gráfico de distribución para visualizar la distribución de características numéricas. Podemos hacer eso con el siguiente código.

sns.displot(data = tips, x = 'tip')

 

 

De forma predeterminada, la función displot producirá un gráfico de histograma. Si queremos suavizar el gráfico, podemos utilizar el parámetro KDE.

sns.displot(data = tips, x = 'tip', kind = 'kde')

 

 

El gráfico distribucional también se puede dividir según los valores categóricos en el DataFrame utilizando el parámetro “hue”.

sns.displot(data = tips, x = 'tip', kind = 'kde', hue = 'smoker')

 

 

Incluso podemos dividir aún más el gráfico con el parámetro “row” o “col”. Con este parámetro, producimos varios gráficos divididos con una combinación de valores categóricos.

sns.displot(data = tips, x = 'tip', kind = 'kde', hue = 'smoker', row = 'time', col = 'sex')

 

 

Otra forma de mostrar la distribución de datos es utilizando el diagrama de cajas. Seabron puede facilitar la visualización fácilmente con el siguiente código.

sns.boxplot(data = tips, x = 'time', y = 'tip')

 

 

Usando el gráfico de violín, podemos mostrar la distribución de datos que combina el diagrama de cajas con KDE.

 

Por último, podemos mostrar el punto de datos en el gráfico combinando los gráficos de violín y enjambre.

sns.violinplot(data = tips, x = 'time', y = 'tip')
sns.swarmplot(data = tips, x = 'time', y = 'tip', palette = 'Set1')

 

 

Gráficos Categóricos

Un gráfico categórico es una API de Seaborn que se aplica para producir la visualización con datos categóricos. Vamos a explorar algunos de los gráficos disponibles.

Primero, intentaremos crear un gráfico de conteo.

sns.countplot(data = tips, x = 'time')

 

 

El gráfico de conteo mostrará una barra con la frecuencia de los valores categóricos. Si queremos mostrar el número de conteo en el gráfico, necesitamos combinar la función Matplotlib en la API de Seaborn.

p = sns.countplot(data = tips, x = 'time')
p.bar_label(p.containers[0])

 

 

Podemos ampliar aún más el gráfico con el parámetro “hue” y mostrar los valores de frecuencia con el siguiente código.

p = sns.countplot(data = tips, x = 'time', hue = 'sex')
for container in p.containers:
    ax.bar_label(container)

 

 

A continuación, intentaremos desarrollar un gráfico de barras. El gráfico de barras es un gráfico categórico que muestra la agregación de datos con una barra de error.

sns.barplot(data = tips, x = 'time', y = 'tip')

 

 

El gráfico de barras utiliza una combinación de características categóricas y numéricas para proporcionar la estadística de agregación. Por defecto, el gráfico de barras utiliza una función de agregación promedio con una barra de error de intervalo de confianza del 95%.

Si queremos cambiar la función de agregación, podemos pasar la función al parámetro estimador.

import numpy as np
sns.barplot(data = tips, x = 'time', y = 'tip', estimator = np.median)

 

 

Gráficos Relacionales

Un gráfico relacional es una técnica de visualización para mostrar la relación entre características. Se utiliza principalmente para identificar cualquier tipo de patrón que exista dentro del conjunto de datos.

Primero, usaríamos un gráfico de dispersión para mostrar la relación entre ciertas características numéricas.

sns.scatterplot(data = tips, x = 'tip', y = 'total_bill')

 

 

Podemos combinar el gráfico de dispersión con el gráfico de distribución utilizando un gráfico conjunto.

sns.jointplot(data = tips, x = 'tip', y = 'total_bill')

 

 

Por último, podemos trazar automáticamente relaciones de pares entre características en el DataFrame utilizando el pairplot.

sns.pairplot(data = tips)

 

 

Gráficos de Matriz

El gráfico de matriz se utiliza para visualizar los datos como una matriz codificada por colores. Se utiliza para ver la relación entre las características o para ayudar a reconocer los grupos dentro de los datos.

Por ejemplo, tenemos una matriz de datos de correlación de nuestro conjunto de datos.

tips.corr()

 

 

Podríamos entender mejor el conjunto de datos anterior si los representáramos en un gráfico codificado por colores. Por eso usaríamos un gráfico de mapa de calor.

sns.heatmap(tips.corr(), annot = True)

 

 

El gráfico de matriz también podría producir un gráfico de agrupamiento jerárquico que infiere los valores dentro de nuestro conjunto de datos y los agrupa según la similitud existente.

sns.clustermap(tips.pivot_table(values = 'tip', index = 'size', columns = 'day').fillna(0))

 

Conclusión

 

La visualización de datos es una parte crucial del mundo de los datos, ya que ayuda al público a comprender rápidamente qué sucede con nuestros datos. Los paquetes estándar de Python para visualización de datos son Matplotlib y Seaborn. En este artículo, hemos aprendido el uso principal de los paquetes y hemos presentado varias visualizaciones que podrían ayudar en nuestro trabajo.     Cornellius Yudha Wijaya es un asistente de gerente de ciencia de datos y escritor de datos. Mientras trabaja a tiempo completo en Allianz Indonesia, le encanta compartir consejos de Python y datos a través de las redes sociales y los medios de comunicación escritos.  

We will continue to update Zepes; if you have any questions or suggestions, please contact us!