Tutorial Seaborn: Gráficos multivariantes

¿Qué son las gráficas multivariantes?

Las gráficas multivariantes son herramientas visuales que permiten explorar y analizar relaciones entre tres o más variables simultáneamente. En el análisis de datos, son fundamentales para identificar patrones complejos y entender cómo interactúan múltiples factores en conjunto.

En Seaborn, las gráficas multivariantes facilitan la comprensión de conjuntos de datos con múltiples dimensiones. Al representar varias variables en un solo gráfico, podemos apreciar cómo se relacionan y cómo influye cada una en el comportamiento general.

Antes de crear gráficas multivariantes, es común preparar el conjunto de datos adecuadamente. Por ejemplo:

import seaborn as sns
import pandas as pd

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

# Explorar los datos
print(datos.head())

En este ejemplo, utilizamos el conjunto de datos de pingüinos, que contiene información sobre diferentes especies y mediciones físicas. Este conjunto de datos es ideal para ilustrar cómo varias características están interrelacionadas.

Las gráficas multivariantes permiten incorporar elementos como colores, tamaños o formas para representar variables adicionales. Esto enriquece la visualización y ayuda a identificar tendencias que podrían pasar desapercibidas en gráficas univariantes o bivariantes.

Además, es importante considerar aspectos como la escalabilidad y la interpretabilidad al diseñar estas gráficas. Una buena práctica es utilizar paletas de colores y estilos consistentes para mejorar la claridad y facilitar la comunicación de los hallazgos.

Finalmente, las gráficas multivariantes son esenciales para profundizar en el análisis exploratorio de datos y son ampliamente utilizadas en diversas áreas, desde la economía hasta las ciencias naturales. Dominar su uso en Seaborn amplía nuestra capacidad para extraer conclusiones significativas de conjuntos de datos complejos.

Pares de Gráficas (Pairplots)

Los pairplots son una herramienta esencial en Seaborn para visualizar relaciones bivariadas entre cada par de variables en un conjunto de datos. Permiten explorar de forma rápida y eficaz cómo interactúan las variables numéricas entre sí.

Para crear un pairplot, se utiliza la función pairplot() de Seaborn. Esta función genera una matriz de gráficos donde cada celda representa un gráfico de dispersión para un par de variables, y las diagonales muestran la distribución univariante de cada variable.

Por ejemplo, con el conjunto de datos de los pingüinos:

import seaborn as sns
import matplotlib.pyplot as plt

# Cargar el conjunto de datos
datos = sns.load_dataset('penguins')

# Crear el pairplot
sns.pairplot(datos, hue='species')
plt.show()

En este ejemplo, el parámetro hue='species' añade colores para distinguir las diferentes especies de pingüinos, facilitando la identificación de patrones específicos según la categoría.

Es posible personalizar los pairplots para resaltar mejor la información. Si queremos mostrar solo la mitad inferior de la matriz y utilizar estimaciones de densidad en las diagonales, podemos hacerlo:

sns.pairplot(
    datos,
    hue='species',
    corner=True,
    diag_kind='kde'
)
plt.show()

El argumento corner=True muestra únicamente la parte inferior de la matriz, evitando duplicaciones y simplificando la visualización. El parámetro diag_kind='kde' cambia las gráficas diagonales a estimaciones de densidad de kernel, proporcionando una vista suavizada de la distribución de cada variable.

Para conjuntos de datos con muchas variables, es útil seleccionar un subconjunto específico:

variables_interes = ['bill_length_mm', 'bill_depth_mm', 'flipper_length_mm']

sns.pairplot(
    datos,
    vars=variables_interes,
    hue='species',
    corner=True,
    diag_kind='kde'
)
plt.show()

De esta manera, nos enfocamos en las variables más relevantes para nuestro análisis, facilitando la interpretación de los resultados.

Si queremos ajustar la estética de los gráficos, podemos modificar parámetros adicionales:

sns.pairplot(
    datos,
    hue='species',
    palette='Dark2',
    markers=['o', 's', 'D'],
    plot_kws={'alpha': 0.7}
)
plt.show()

Aquí, palette='Dark2' cambia la paleta de colores, markers especifica diferentes marcas para cada especie, y plot_kws permite ajustar propiedades de los gráficos de dispersión, como la transparencia con alpha.

Es importante manejar los datos faltantes antes de crear el pairplot, ya que las filas con valores nulos se eliminan automáticamente:

# Eliminar filas con valores nulos
datos = datos.dropna()

# Crear el pairplot con datos limpios
sns.pairplot(datos, hue='species')
plt.show()

Los pairplots son ideales para detectar correlaciones, distribuciones atípicas y posibles agrupaciones en los datos. Su facilidad de uso y personalización los convierten en una herramienta indispensable en el análisis exploratorio.

Gráficos de Dispersión con Colores y Tamaños

Los gráficos de dispersión son esenciales para visualizar la relación entre dos variables numéricas. Con Seaborn, podemos enriquecer estos gráficos utilizando colores y tamaños para representar variables adicionales, lo que nos permite analizar patrones más complejos.

Para comenzar, importamos las bibliotecas necesarias y cargamos un conjunto de datos. Utilizaremos el dataset "tips" incluido en Seaborn:

import seaborn as sns
import matplotlib.pyplot as plt

# Cargar el conjunto de datos
datos = sns.load_dataset('tips')

Creemos un gráfico de dispersión básico para visualizar la relación entre la cuenta total y la propina:

sns.scatterplot(data=datos, x='total_bill', y='tip')
plt.show()

Para agregar una variable categórica como color, empleamos el parámetro hue. Por ejemplo, coloreamos los puntos según el día de la semana:

sns.scatterplot(data=datos, x='total_bill', y='tip', hue='day')
plt.show()

De esta forma, cada punto se colorea según el valor de day, facilitando la comparación entre distintos días.

Si queremos representar una variable numérica mediante el tamaño de los puntos, utilizamos el parámetro size. Ajustemos el tamaño según el número de comensales:

sns.scatterplot(data=datos, x='total_bill', y='tip', size='size')
plt.show()

Podemos combinar ambos parámetros para visualizar múltiples variables simultáneamente:

sns.scatterplot(data=datos, x='total_bill', y='tip', hue='day', size='size')
plt.show()

En este gráfico, el eje X representa la cuenta total, el eje Y muestra la propina, el color distingue el día y el tamaño del punto indica el número de comensales.

Es importante considerar la transparencia para mejorar la legibilidad cuando hay superposición de puntos. Podemos ajustar el parámetro alpha:

sns.scatterplot(data=datos, x='total_bill', y='tip', hue='day', size='size', alpha=0.7)
plt.show()

Para una mejor interpretación, es útil personalizar la paleta de colores y el rango de tamaños:

sns.scatterplot(
    data=datos,
    x='total_bill',
    y='tip',
    hue='day',
    size='size',
    palette='Set2',
    sizes=(20, 200),
    alpha=0.7
)
plt.show()

En este ejemplo, hemos seleccionado la paleta Set2 y definido los tamaños de los puntos entre 20 y 200 para destacar las diferencias.

Si la variable en size es categórica, Seaborn la manejará adecuadamente. Por ejemplo, distingamos por tamaño si el cliente es fumador o no:

sns.scatterplot(
    data=datos,
    x='total_bill',
    y='tip',
    hue='day',
    size='smoker',
    sizes=(50, 150),
    alpha=0.7
)
plt.show()

Aquí, los tamaños de los puntos reflejan si el cliente es fumador, permitiendo observar tendencias asociadas a este factor.

Es recomendable incluir una leyenda clara para evitar confusiones. Podemos ajustar su posición y título:

sns.scatterplot(
    data=datos,
    x='total_bill',
    y='tip',
    hue='day',
    size='smoker',
    sizes=(50, 150),
    alpha=0.7,
    legend='full'
)
plt.legend(title='Detalles', loc='upper left')
plt.show()

Cuando trabajamos con conjuntos de datos grandes, es útil utilizar relplot() para crear gráficos de dispersión en FacetGrid. Esto nos permite dividir el gráfico según categorías adicionales:

sns.relplot(
    data=datos,
    x='total_bill',
    y='tip',
    hue='day',
    size='size',
    col='time',
    kind='scatter',
    alpha=0.7
)
plt.show()

Este gráfico divide los datos según el momento del día (almuerzo o cena) utilizando el parámetro col, proporcionando una perspectiva más detallada y facilitando el análisis exploratorio.

En resumen, al utilizar colores y tamaños en los gráficos de dispersión con Seaborn, podemos representar múltiples variables simultáneamente. Esto enriquece nuestra comprensión de los datos y nos ayuda a descubrir relaciones complejas entre variables.

Diagramas de Calor (Heatmaps) para Múltiples Variables

Los diagramas de calor son una herramienta esencial para visualizar matrices de datos, especialmente cuando se desea identificar patrones, correlaciones y agrupaciones en conjuntos de datos con múltiples variables. En Seaborn, podemos crear diagramas de calor de forma sencilla utilizando la función heatmap(), lo que nos permite explorar relaciones complejas de manera intuitiva.

Para ilustrar su uso, emplearemos el conjunto de datos "flights" que viene incluido en Seaborn, el cual contiene información sobre el número de pasajeros de aerolínea por mes y año.

import seaborn as sns
import matplotlib.pyplot as plt

# Cargar el conjunto de datos
datos = sns.load_dataset('flights')

Antes de crear el diagrama de calor, es necesario pivotar el DataFrame para que las variables estén organizadas adecuadamente en filas y columnas.

# Reestructurar los datos en una tabla pivot
tabla_pivot = datos.pivot(index='month', columns='year', values='passengers')

Una vez tenemos los datos en el formato correcto, podemos generar el diagrama de calor:

# Crear el diagrama de calor
sns.heatmap(tabla_pivot)
plt.show()

Este gráfico muestra el número de pasajeros por mes y año, donde los colores representan los valores, facilitando la detección de tendencias y patrones estacionales.

Para mejorar la interpretación del gráfico, es útil ajustar parámetros como la paleta de colores y añadir anotaciones:

# Crear el diagrama de calor con personalización
sns.heatmap(
    tabla_pivot,
    cmap='YlGnBu',
    annot=True,
    fmt='d'
)
plt.show()

En este ejemplo, utilizamos la paleta YlGnBu para una gradación más suave de colores. El parámetro annot=True añade los valores numéricos en cada celda, y fmt='d' asegura que los números se muestren como enteros.

Los diagramas de calor son especialmente útiles para visualizar matrices de correlación. Analicemos el conjunto de datos "iris":

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

# Calcular la matriz de correlación
corr = iris.select_dtypes(include=['float64', 'int64']).corr()

Ahora, creamos el diagrama de calor de la matriz de correlación:

# Crear el diagrama de calor de correlación
sns.heatmap(
    corr,
    annot=True,
    cmap='coolwarm'
)
plt.show()

Este gráfico permite identificar qué variables están correlacionadas entre sí, lo que es invaluable en el análisis exploratorio de datos.

Podemos ajustar más detalles para mejorar la visualización, como establecer límites en el mapa de color y personalizar las etiquetas:

# Crear el diagrama de calor personalizado
sns.heatmap(
    corr,
    annot=True,
    cmap='coolwarm',
    vmin=-1,
    vmax=1,
    xticklabels=iris.columns,
    yticklabels=iris.columns
)
plt.xticks(rotation=45)
plt.yticks(rotation=0)
plt.show()

Aquí, vmin y vmax establecen los límites del mapa de color entre -1 y 1, correspondientes a los valores mínimos y máximos de correlación. Rotamos las etiquetas del eje X para mejorar la legibilidad.

Para conjuntos de datos más complejos, es posible que deseemos normalizar los datos antes de visualizarlos. Por ejemplo:

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

datos = sns.load_dataset('flights')

tabla_pivot = datos.pivot(index='month', columns='year', values='passengers')

# Normalizar los datos de la tabla pivot
tabla_normalizada = tabla_pivot.apply(lambda x: (x - np.mean(x)) / np.std(x), axis=1)

# Crear el diagrama de calor de los datos normalizados
sns.heatmap(
    tabla_normalizada,
    cmap='RdBu_r',
    center=0
)
plt.show()

La normalización nos permite comparar más fácilmente los patrones entre diferentes filas, al eliminar el efecto de escalas distintas.

Además, si queremos resaltar únicamente ciertos valores, podemos utilizar una máscara:

# Crear una máscara para los valores inferiores a 500
mascara = tabla_pivot < 500

# Crear el diagrama de calor con la máscara
sns.heatmap(
    tabla_pivot,
    cmap='YlGnBu',
    mask=mascara,
    annot=True,
    fmt='d'
)
plt.show()

En este caso, los valores inferiores a 500 no se muestran, lo que permite enfocarnos en los datos más relevantes.

Finalmente, los diagramas de calor pueden combinarse con clústeres para agrupar variables similares, pero esto se aborda con mayor detalle en los clustermaps.

Clustermaps

Los clustermaps son gráficos que combinan diagramas de calor con agrupamientos jerárquicos, facilitando la identificación de patrones y estructuras en datos multivariantes. Utilizando la función clustermap() de Seaborn, podemos visualizar matrices de datos donde tanto las filas como las columnas están reorganizadas según similitudes encontradas en los datos.

Para comenzar, importamos las bibliotecas necesarias y cargamos el conjunto de datos "flights", que contiene información sobre el número de pasajeros de aerolíneas por mes y año.

import seaborn as sns
import matplotlib.pyplot as plt

# Cargar el conjunto de datos
datos = sns.load_dataset('flights')

Es necesario pivotar el DataFrame para obtener una matriz adecuada para el clustermap.

# Crear la tabla pivote
tabla_pivot = datos.pivot(index='month', columns='year', values='passengers')

Ahora, generamos el clustermap utilizando la función clustermap().

# Generar el clustermap básico
sns.clustermap(tabla_pivot)
plt.show()

Este gráfico muestra cómo los meses y años se agrupan según el número de pasajeros, permitiendo observar patrones estacionales y tendencias a lo largo del tiempo.

Podemos personalizar el método de enlace y la métrica de distancia para influir en la forma en que se agrupan los datos. Por ejemplo, para utilizar el método de enlace "promedio" y la métrica "correlación":

sns.clustermap(
    tabla_pivot,
    method='average',
    metric='correlation',
    cmap='YlGnBu'
)
plt.show()

Esto agrupa los meses y años basándose en la correlación de sus valores, lo que puede revelar relaciones más sutiles entre ellos.

Si deseamos normalizar los datos para centrarnos en las variaciones internas, podemos utilizar el parámetro standard_scale.

# Estandarizar los datos por columnas
sns.clustermap(
    tabla_pivot,
    standard_scale=1,
    cmap='mako'
)
plt.show()

Al estandarizar, cada columna tiene una media de cero y una desviación estándar de uno, resaltando las desviaciones respecto al comportamiento promedio.

Para analizar desviaciones respecto a la media de cada fila, empleamos el parámetro z_score.

# Aplicar z-score por filas
sns.clustermap(
    tabla_pivot,
    z_score=0,
    cmap='vlag'
)
plt.show()

Con el z-score, podemos identificar meses que se comportan de manera inusual en comparación con su media anual.

Es posible ajustar el tamaño de la figura y la proporción de las dendrogramas para mejorar la legibilidad.

sns.clustermap(
    tabla_pivot,
    figsize=(12, 8),
    dendrogram_ratio=0.2,
    cbar_pos=(0.9, 0.7, 0.03, 0.2)
)
plt.show()

Aquí, figsize modifica el tamaño del gráfico, dendrogram_ratio ajusta la proporción dedicada a las dendrogramas y cbar_pos cambia la posición de la barra de color.

Los clustermaps también son útiles para visualizar matrices de correlación. Por ejemplo, con el conjunto de datos "iris":

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

# Calcular la matriz de correlación
matriz_corr = iris.select_dtypes(include=['float64', 'int64']).corr()

# Generar el clustermap de correlación
sns.clustermap(
    matriz_corr,
    annot=True,
    cmap='coolwarm',
    center=0
)
plt.show()

Este gráfico agrupa las variables que tienen correlaciones similares, facilitando la identificación de relaciones clave entre las características.

Podemos limitar los valores del mapa de color para resaltar rangos específicos.

sns.clustermap(
    tabla_pivot,
    cmap='rocket',
    vmin=100,
    vmax=700
)
plt.show()

Al establecer vmin y vmax, controlamos el rango de datos mostrado, enfocándonos en valores de interés particular.

Los clustermaps son herramientas valiosas para descubrir estructuras ocultas en los datos, siendo ampliamente utilizados en campos como la bioinformática, análisis de mercados y ciencias sociales. Su capacidad para combinar análisis estadístico y visualización los convierte en un recurso esencial para el análisis exploratorio de datos.

Gráficas en 3D

Aunque Seaborn está especializado en gráficos estadísticos en 2D, es posible crear gráficas en 3D combinando Seaborn con las capacidades de Matplotlib. Al utilizar el módulo mpl_toolkits.mplot3d de Matplotlib junto con el estilo de Seaborn, podemos generar visualizaciones tridimensionales manteniendo una estética cohesiva.

Para comenzar, importamos las bibliotecas necesarias y configuramos el estilo de Seaborn para que se aplique a los gráficos de Matplotlib:

import seaborn as sns
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Configurar el estilo de Seaborn
sns.set_theme(style='whitegrid')

Tomaremos como ejemplo el conjunto de datos "iris", que está incluido en Seaborn:

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

Creamos una gráfica de dispersión en 3D para visualizar tres variables del conjunto de datos:

# Crear la figura y el eje 3D
fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(projection='3d')

# Definir las variables para los ejes
x = iris['sepal_length']
y = iris['sepal_width']
z = iris['petal_length']

# Mapear las especies a colores
from matplotlib.colors import ListedColormap
import pandas as pd

# Convertir las especies a números
especies = pd.Categorical(iris['species']).codes

# Obtener una paleta de colores de Seaborn
paleta = sns.color_palette('bright', len(iris['species'].unique()))
colormap = ListedColormap(paleta)

# Graficar los datos
scatter = ax.scatter(x, y, z, c=especies, cmap=colormap)

# Añadir una leyenda
legend = ax.legend(*scatter.legend_elements(),
                   title='Especies',
                   loc='upper left',
                   bbox_to_anchor=(1, 0.5))

# Etiquetas de los ejes
ax.set_xlabel('Longitud del sépalo')
ax.set_ylabel('Ancho del sépalo')
ax.set_zlabel('Longitud del pétalo')

# Mostrar la gráfica con leyenda
ax.add_artist(legend)
plt.show()

En este ejemplo, cada punto representa una flor y las especies están diferenciadas por colores. Los ejes X, Y y Z corresponden a las medidas de los sépalos y pétalos.

Para visualizar superficies en 3D, como una función matemática o una superficie de regresión, podemos utilizar plot_surface:

import numpy as np

# Crear una cuadrícula de puntos
X = np.linspace(-5, 5, 100)
Y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(X, Y)
Z = np.sin(np.sqrt(X**2 + Y**2))

# Crear la figura y el eje 3D
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(projection='3d')

# Graficar la superficie
surf = ax.plot_surface(X, Y, Z, cmap='viridis', edgecolor='none')

# Añadir una barra de color
fig.colorbar(surf, ax=ax, shrink=0.5, aspect=5)

# Etiquetas de los ejes
ax.set_xlabel('Eje X')
ax.set_ylabel('Eje Y')
ax.set_zlabel('Eje Z')

# Título
ax.set_title('Superficie 3D de función matemática')

# Mostrar la gráfica
plt.show()

Esta gráfica muestra una superficie tridimensional generada a partir de una función matemática, utilizando una paleta de colores para representar los valores de Z.

Es relevante mencionar que al integrar Seaborn con otras herramientas, mantenemos una coherencia visual en nuestros análisis y aprovechamos las fortalezas de cada biblioteca. De esta manera, las gráficas en 3D se convierten en una extensión natural de nuestras capacidades de visualización.