Tutorial Seaborn: Conceptos básicos de Seaborn

Datasets de Seaborn

Seaborn incluye una variedad de datasets integrados que facilitan la práctica y comprensión de sus funcionalidades sin necesidad de buscar datos externos. Estos conjuntos de datos están diseñados para ilustrar diversas técnicas de visualización y análisis estadístico.

Para visualizar los datasets disponibles, se puede utilizar la función seaborn.get_dataset_names(), la cual devuelve una lista con los nombres de todos los conjuntos de datos incluidos en la biblioteca:

import seaborn as sns

# Listar los datasets disponibles en Seaborn
print(sns.get_dataset_names())

Una vez identificado el dataset de interés, se puede cargar mediante la función seaborn.load_dataset(). Esta función devuelve un DataFrame de pandas, permitiendo manipular y analizar los datos con las herramientas de pandas:

# Cargar el dataset "tips"
datos = sns.load_dataset('tips')

# Mostrar las primeras cinco filas del dataset
print(datos.head())

El dataset "tips" contiene información sobre las propinas en un restaurante, incluyendo variables como el total de la cuenta, la propina, el sexo del camarero, si había fumadores, el día, la hora y el tamaño del grupo.

Estos datasets son ideales para practicar la creación de gráficos y exploración de datos. Por ejemplo, para visualizar la relación entre el total de la cuenta y la propina:

import matplotlib.pyplot as plt

# Crear un gráfico de dispersión
sns.scatterplot(data=datos, x='total_bill', y='tip')

# Mostrar el gráfico
plt.show()

Además de "tips", Seaborn ofrece otros datasets como "iris", "penguins", "flights" y "diamonds", cada uno adecuado para diferentes tipos de visualizaciones y análisis. Por ejemplo, el dataset "penguins" se utiliza comúnmente para ilustrar gráficos de distribución y comparación entre especies de pingüinos:

# Cargar el dataset "penguins"
datos_penguins = sns.load_dataset('penguins')

# Crear un histograma de la longitud del pico
sns.histplot(data=datos_penguins, x='bill_length_mm', hue='species', multiple='stack')

# Mostrar el gráfico
plt.show()

Es importante mencionar que los datasets se descargan la primera vez que se utilizan y se almacenan localmente para uso futuro. Si es necesario, se puede especificar un directorio diferente para almacenarlos utilizando el parámetro data_home en las funciones de carga.

Si se desea trabajar con datos propios, Seaborn es compatible con cualquier DataFrame de pandas. Esto permite cargar datasets desde archivos locales, como CSV o Excel, y aprovechar las capacidades de visualización de Seaborn:

import pandas as pd

# Cargar un dataset desde un archivo CSV
datos_propios = pd.read_csv('ruta/al/archivo.csv')

# Crear un gráfico de líneas utilizando datos propios
sns.lineplot(data=datos_propios, x='fecha', y='valor')

# Mostrar el gráfico
plt.show()

Los datasets integrados de Seaborn son una excelente herramienta para aprender y experimentar con diferentes tipos de gráficos y técnicas de análisis, facilitando el proceso de familiarización con la biblioteca.

¿Qué tipos de visualizaciones existen y cuándo se deben usar?

Seaborn ofrece una amplia gama de visualizaciones estadísticas diseñadas para facilitar la comprensión de datos complejos. A continuación, exploraremos los tipos de gráficos más comunes y sus usos recomendados.

• Gráficos de distribución: Son útiles para examinar cómo se distribuyen los datos de una variable individual. Entre ellos se encuentran los histogramas y los gráficos de densidad. El histograma muestra la frecuencia de los datos en intervalos específicos, mientras que el gráfico KDE (Kernel Density Estimate) proporciona una estimación suave de la distribución.

import seaborn as sns
import matplotlib.pyplot as plt

# Cargar un dataset de ejemplo
diamonds = sns.load_dataset('diamonds')

# Histograma de los precios de los diamantes
sns.histplot(data=diamonds, x='price', kde=True)
plt.show()

En este ejemplo, utilizamos sns.histplot para visualizar la distribución de los precios de los diamantes, añadiendo una curva de densidad con el parámetro kde=True.

• Gráficos relacionales: Son ideales para explorar relaciones entre dos variables numéricas. Los más comunes son los gráficos de dispersión y los gráficos de líneas. El gráfico de dispersión muestra cómo una variable cambia en función de otra, mientras que el gráfico de líneas es especialmente útil para datos temporales o secuenciales.

# Gráfico de dispersión entre el quilataje y el precio
sns.scatterplot(data=diamonds, x='carat', y='price')
plt.show()

Aquí, el sns.scatterplot nos permite observar la relación entre el quilataje de un diamante y su precio.

• Gráficos categóricos: Son útiles para comparar distribuciones entre diferentes categorías. Incluyen gráficos como el box plot, violin plot, bar plot y strip plot. Estos gráficos ayudan a visualizar cómo varía una variable numérica en función de una variable categórica.

# Box plot del precio según la calidad de corte
sns.boxplot(data=diamonds, x='cut', y='price')
plt.show()

El sns.boxplot muestra la distribución del precio para cada categoría de calidad de corte, permitiendo identificar medianas, cuartiles y posibles valores atípicos.

• Gráficos de regresión: Se utilizan para ajustar y visualizar modelos de regresión lineal entre dos variables. El regplot y el lmplot de Seaborn permiten añadir una línea de regresión y un intervalo de confianza.

# Gráfico de regresión entre el quilataje y el precio
sns.regplot(data=diamonds, x='carat', y='price')
plt.show()

Con sns.regplot, no solo vemos la dispersión de los datos, sino también la tendencia general representada por la línea de regresión.

• Gráficos de distribución conjunta: Permiten analizar simultáneamente la distribución univariante y bivariante de dos variables. El jointplot es especialmente útil para este propósito.

# Gráfico conjunto del quilataje y el precio
sns.jointplot(data=diamonds, x='carat', y='price', kind='hex')
plt.show()

El sns.jointplot con kind='hex' muestra la densidad de puntos en un gráfico hexbin, ofreciendo una visión detallada de cómo se distribuyen los datos.

• Facetas y grids: Se utilizan para crear múltiples gráficos basados en subgrupos de datos, facilitando la comparación entre categorías. El FacetGrid y las funciones de nivel fig como catplot y relplot permiten crear gráficos complejos.

# Gráfico de dispersión con facetas por calidad de corte
sns.relplot(data=diamonds, x='carat', y='price', col='cut', kind='scatter')
plt.show()

Con sns.relplot, generamos una serie de gráficos de dispersión separados por cada categoría de calidad de corte, lo que facilita el análisis comparativo.

Cuándo usar cada tipo de visualización:

• Gráficos de distribución: Para entender la forma, dispersión y sesgo de una variable numérica.
• Gráficos relacionales: Al explorar relaciones lineales o no lineales entre dos variables numéricas.
• Gráficos categóricos: Cuando se comparan distribuciones o medias entre grupos categóricos.
• Gráficos de regresión: Para analizar tendencias y hacer predicciones basadas en modelos lineales.
• Gráficos de distribución conjunta: Para estudiar la relación conjunta y las distribuciones marginales de dos variables.
• Facetas y grids: Cuando se necesita comparar patrones o relaciones a través de múltiples subgrupos.

Es esencial seleccionar el tipo de gráfico adecuado en función de las características de los datos y las preguntas que se desean responder. Una elección apropiada mejora la interpretación y comunicación de los resultados.

Guardar gráficos en diferentes formatos

Un aspecto fundamental al trabajar con visualizaciones es poder guardar los gráficos generados para su posterior uso en informes, presentaciones o publicaciones. Seaborn, al estar basado en Matplotlib, ofrece diversas opciones para exportar gráficos en diferentes formatos como PNG, JPEG, SVG y PDF.

Para guardar un gráfico, es necesario utilizar las funciones de Matplotlib, específicamente plt.savefig(). A continuación, se muestra cómo crear y guardar un gráfico simple:

import seaborn as sns
import matplotlib.pyplot as plt

# Cargar un dataset de ejemplo
datos = sns.load_dataset('penguins')

# Crear un gráfico de dispersión
sns.scatterplot(data=datos, x='bill_length_mm', y='bill_depth_mm', hue='species')

# Guardar el gráfico en formato PNG
plt.savefig('grafico_penguins.png', dpi=300)

# Mostrar el gráfico en pantalla
plt.show()

En este ejemplo, después de crear el gráfico con Seaborn, utilizamos plt.savefig() antes de plt.show() para exportar el gráfico a un archivo llamado grafico_penguins.png con una resolución de 300 dpi.

Es importante mencionar que el orden de las funciones es relevante: plt.savefig() debe ser llamado antes de plt.show(), ya que una vez que se muestra el gráfico, el objeto figura se vacía y no se puede guardar.

El parámetro dpi (dots per inch) controla la calidad y resolución de la imagen guardada. Una mayor cantidad de dpi resulta en una imagen más detallada, lo cual es útil para impresiones o ampliaciones. Si no se especifica, se utiliza el valor por defecto.

Además del formato PNG, es posible guardar gráficos en otros formatos de archivo simplemente cambiando la extensión en el nombre del archivo:

# Guardar en formato PDF
plt.savefig('grafico_penguins.pdf')

# Guardar en formato SVG
plt.savefig('grafico_penguins.svg')

El formato PDF es ideal para documentos impresos o vectoriales, mientras que el SVG es útil para gráficos escalables en páginas web. De esta manera, se puede elegir el formato más adecuado según las necesidades.

Es posible también ajustar los tamaños y dimensiones del gráfico antes de guardarlo. Utilizando la función plt.figure() se pueden establecer el ancho y alto en pulgadas:

import seaborn as sns
import matplotlib.pyplot as plt

# Definir el tamaño del gráfico
plt.figure(figsize=(8, 6))

# Crear el gráfico
sns.histplot(data=datos, x='flipper_length_mm', kde=True)

# Guardar el gráfico con el tamaño especificado
plt.savefig('histograma_penguins.png')

# Mostrar el gráfico
plt.show()

En este caso, figsize=(8, 6) define un gráfico de 8 pulgadas de ancho por 6 pulgadas de alto. De esta forma, se controla el tamaño de salida según el espacio disponible en el documento o presentación donde se va a utilizar el gráfico.

Para gráficos con elementos adicionales como títulos, etiquetas o leyendas personalizadas, es recomendable asegurarse de que todos los elementos se rendericen correctamente al guardar el gráfico. Puede ser útil ajustar los márgenes y espacios utilizando plt.tight_layout():

import seaborn as sns
import matplotlib.pyplot as plt

# Crear el gráfico con etiquetas y título
sns.boxplot(data=datos, x='species', y='body_mass_g')
plt.title('Masa corporal de especies de pingüinos')
plt.xlabel('Especie')
plt.ylabel('Masa corporal (g)')

# Ajustar el layout para evitar superposiciones
plt.tight_layout()

# Guardar el gráfico
plt.savefig('boxplot_penguins.png')

# Mostrar el gráfico
plt.show()

El uso de plt.tight_layout() optimiza automáticamente la disposición de los elementos del gráfico, evitando que las etiquetas o títulos se corten al guardar la imagen.

Para guardar gráficos con fondo transparente, se puede utilizar el parámetro transparent=True en la función plt.savefig():

# Guardar el gráfico con fondo transparente
plt.savefig('grafico_transparente.png', transparent=True)

Esto es especialmente útil cuando se desea superponer el gráfico sobre otros elementos gráficos o fondos de color.

Si se requiere un control más preciso sobre el backend de renderizado o las opciones de guardado, Matplotlib ofrece parámetros adicionales en plt.savefig(), como bbox_inches, pad_inches y format. Por ejemplo:

# Guardar el gráfico ajustando los márgenes
plt.savefig('grafico_ajustado.png', bbox_inches='tight', pad_inches=0.1)

El parámetro bbox_inches='tight' recorta los márgenes innecesarios alrededor del gráfico, mientras que pad_inches añade un pequeño espacio de relleno.

En entornos donde se generan múltiples gráficos, es recomendable cerrar las figuras después de guardarlas para liberar memoria y evitar conflictos:

# Guardar y cerrar el gráfico
plt.savefig('grafico_multiple.png')
plt.close()

Finalmente, se destaca que al trabajar en notebooks de Jupyter, se puede utilizar la magia %matplotlib inline o %matplotlib notebook para controlar cómo se muestran los gráficos, pero al guardar los gráficos con plt.savefig(), se sigue el mismo procedimiento.

Mediante estas prácticas, es posible guardar gráficos de Seaborn en diversos formatos y con configuraciones personalizadas, asegurando que las visualizaciones sean aptas para diferentes medios y propósitos.

Relación de Seaborn con Matplotlib

Seaborn es una biblioteca de visualización de datos construida sobre Matplotlib, que proporciona una interfaz de alto nivel para crear gráficos estadísticos atractivos y complejos con menos código. Aunque Seaborn simplifica muchas tareas de visualización, en el fondo sigue utilizando las funcionalidades de Matplotlib para renderizar los gráficos.

La estrecha relación entre Seaborn y Matplotlib permite combinar las ventajas de ambas herramientas. Seaborn facilita la creación de gráficos estadísticos sofisticados, mientras que Matplotlib ofrece un control detallado sobre cada elemento del gráfico. Esto significa que se pueden utilizar funciones y métodos de Matplotlib para personalizar aún más los gráficos generados con Seaborn.

Por ejemplo, al crear un gráfico con Seaborn, es posible ajustar propiedades específicas utilizando métodos de Matplotlib:

import seaborn as sns
import matplotlib.pyplot as plt

# Cargar un conjunto de datos de ejemplo
datos = sns.load_dataset('iris')

# Crear un gráfico de dispersión con Seaborn
grafico = sns.scatterplot(data=datos, x='sepal_length', y='sepal_width', hue='species')

# Personalizar el gráfico utilizando Matplotlib
grafico.set_title('Relación entre longitud y ancho de sépalo')
grafico.set_xlabel('Longitud del sépalo (cm)')
grafico.set_ylabel('Ancho del sépalo (cm)')

# Mostrar el gráfico
plt.show()

En este ejemplo, Seaborn genera el gráfico de dispersión, y luego se utilizan métodos de Matplotlib para añadir un título y etiquetas a los ejes. La variable grafico es un objeto Axes de Matplotlib, lo que permite acceder a todas sus propiedades y métodos.

Además, es posible ajustar aspectos globales de los gráficos utilizando las configuraciones de Matplotlib. Por ejemplo, para cambiar el tamaño de fuente o el estilo de las líneas:

import seaborn as sns
import matplotlib.pyplot as plt

# Configurar parámetros globales de Matplotlib
plt.rcParams['font.size'] = 12
plt.rcParams['lines.linewidth'] = 2

# Crear un gráfico de líneas con Seaborn
sns.lineplot(data=datos, x='sepal_length', y='petal_length', hue='species')

# Mostrar el gráfico
plt.show()

Aquí, los parámetros de Matplotlib se establecen antes de crear el gráfico, afectando así a todos los elementos dibujados posteriormente. Esto permite mantener un estilo coherente en todas las visualizaciones.

Seaborn también facilita la creación de figuras con múltiples subgráficos, integrándose perfectamente con las funcionalidades de Matplotlib. Por ejemplo, para crear una figura con varios ejes:

import seaborn as sns
import matplotlib.pyplot as plt

# Crear una figura y una cuadrícula de ejes
fig, axs = plt.subplots(1, 2, figsize=(12, 6))

# Gráfico de violín en el primer eje
sns.violinplot(data=datos, x='species', y='sepal_length', ax=axs[0])
axs[0].set_title('Distribución de la longitud del sépalo')

# Gráfico de caja en el segundo eje
sns.boxplot(data=datos, x='species', y='petal_length', ax=axs[1])
axs[1].set_title('Distribución de la longitud del pétalo')

# Ajustar el diseño y mostrar la figura
plt.tight_layout()
plt.show()

En este caso, se utilizan las funcionalidades de Matplotlib para crear una figura con dos subgráficos, y Seaborn para generar los gráficos específicos en cada eje. Esto permite combinar diferentes tipos de gráficos en una sola figura de manera organizada.

Otra ventaja de la integración es la posibilidad de utilizar paletas de colores y estilos de Seaborn en gráficos de Matplotlib. Por ejemplo:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

# Generar datos de ejemplo
x = np.linspace(0, 10, 100)
y = np.sin(x)

# Establecer una paleta de colores de Seaborn
sns.set_palette('bright')

# Crear un gráfico con Matplotlib utilizando colores de Seaborn
plt.plot(x, y, label='Seno')

# Añadir leyendas y etiquetas
plt.title('Función seno')
plt.xlabel('Ángulo (rad)')
plt.ylabel('Valor')
plt.legend()

# Mostrar el gráfico
plt.show()

Aquí, la paleta de colores definida por Seaborn se aplica al gráfico creado con Matplotlib, gracias a la compatibilidad entre ambas bibliotecas.

Además, al utilizar Seaborn, se pueden aprovechar las configuraciones estéticas predeterminadas que mejoran la apariencia de los gráficos. Seaborn ofrece diferentes temas que se pueden aplicar fácilmente:

import seaborn as sns
import matplotlib.pyplot as plt

# Establecer el tema oscuro de Seaborn
sns.set_theme(style='darkgrid')

# Crear un histograma con Seaborn
sns.histplot(data=datos, x='petal_width', kde=True)

# Mostrar el gráfico
plt.show()

El uso de sns.set_theme() permite cambiar el estilo de los gráficos, afectando tanto a los gráficos de Seaborn como a los de Matplotlib creados posteriormente.

Es crucial recordar que, aunque Seaborn simplifica muchas tareas, algunas personalizaciones avanzadas pueden requerir el uso directo de Matplotlib. Conocer cómo operan conjuntamente ambas bibliotecas amplía las posibilidades de personalización y mejora la calidad de las visualizaciones.