Formación corporativa en Seaborn

Los gráficos relacionales son la herramienta principal para visualizar cómo se relacionan dos o más variables numéricas entre sí. Seaborn proporciona funciones dedicadas a este tipo de visualizaciones, tanto a nivel de ejes como a nivel de figura.

La función de nivel de figura para gráficos relacionales es relplot(), que actúa como punto de entrada unificado y permite crear tanto gráficos de dispersión como de líneas con faceting automático. Las funciones de nivel de ejes son scatterplot() y lineplot(), que se dibujan sobre un eje Matplotlib existente y ofrecen máxima integración con código personalizado.

Codificación visual de variables adicionales

Una de las fortalezas de Seaborn es la capacidad de codificar variables adicionales mediante atributos visuales como el color (hue), el tamaño (size) y la forma del marcador (style). Esto permite visualizar hasta cinco dimensiones en un único gráfico de dispersión sin necesidad de crear subgráficos:

import seaborn as sns
import matplotlib.pyplot as plt

tips = sns.load_dataset("tips")

sns.relplot(
    data=tips,
    x="total_bill",
    y="tip",
    hue="smoker",
    size="size",
    style="time",
    sizes=(20, 200)
)
plt.show()

Gráficos de líneas con intervalos de confianza

El lineplot() calcula automáticamente estadísticas de resumen cuando hay múltiples observaciones por valor de x, mostrando la media y un intervalo de confianza del 95%:

fmri = sns.load_dataset("fmri")

sns.lineplot(
    data=fmri,
    x="timepoint",
    y="signal",
    hue="region",
    style="event",
    errorbar="ci"
)
plt.show()

Faceting con relplot

relplot() acepta los parámetros col y row para crear cuadrículas de gráficos condicionados a variables categóricas, lo que facilita la comparación visual entre grupos sin necesidad de crear manualmente cada subgráfico.

La visualización de distribuciones es fundamental en el análisis exploratorio de datos. Seaborn proporciona un conjunto completo de herramientas para examinar cómo se distribuyen las variables de forma univariante, bivariante y multivariante.

Funciones axes-level vs figure-level

Al igual que en otras categorías de Seaborn, existe una distinción clave entre:

• Funciones axes-level: histplot(), kdeplot(), ecdfplot(), rugplot() - dibujan sobre un eje Matplotlib existente.
• Función figure-level: displot() - gestiona su propia figura y admite faceting mediante col y row.

Histogramas y estimación de densidad

histplot() permite crear histogramas con conteos o densidad, opcionalmente superponer una curva KDE, y trabajar tanto con datos univariantes como bivariantes:

import seaborn as sns
import matplotlib.pyplot as plt

penguins = sns.load_dataset("penguins")

sns.histplot(
    data=penguins,
    x="flipper_length_mm",
    hue="species",
    multiple="stack",
    kde=True
)
plt.show()

Distribuciones bivariantes

kdeplot() también admite dos variables para estimar densidades bidimensionales, mostrando contornos o relleno de densidad:

sns.kdeplot(
    data=penguins,
    x="bill_length_mm",
    y="bill_depth_mm",
    hue="species",
    fill=True
)
plt.show()

Los gráficos categóricos permiten analizar cómo se distribuye una variable numérica o cómo varían las frecuencias en función de una o más variables categóricas. Seaborn organiza estos gráficos en tres grupos principales según lo que muestran.

Tipos de gráficos categóricos

Gráficos de dispersión categórica

Muestran los puntos individuales de datos, permitiendo visualizar la distribución real sin resumen estadístico:

• stripplot(): puntos distribuidos a lo largo de la categoría con jitter opcional.
• swarmplot(): ajusta la posición de los puntos para evitar solapamientos.

Gráficos de distribución por categorías

Resumen la distribución de los datos por grupo:

• boxplot(): mediana, cuartiles y valores atípicos.
• violinplot(): combina boxplot con estimación de densidad KDE.
• boxenplot(): versión extendida del boxplot con más cuantiles visibles.

Gráficos de estimación estadística

Muestran una medida de tendencia central con barra de error:

• barplot(): media o función de estimación personalizada con intervalo de confianza.
• countplot(): frecuencia absoluta de cada categoría.
• pointplot(): como barplot pero con puntos y líneas, ideal para interacciones.

catplot como función figure-level

catplot() es la función figure-level que unifica todos los tipos anteriores mediante el parámetro kind. Admite además col y row para faceting, lo que la hace muy versátil para comparaciones multidimensionales:

import seaborn as sns
import matplotlib.pyplot as plt

tips = sns.load_dataset("tips")

sns.catplot(
    data=tips,
    x="day",
    y="total_bill",
    hue="smoker",
    kind="violin",
    split=True,
    col="time",
    height=5
)
plt.show()

Este módulo cubre dos familias de gráficos especializados en Seaborn: los gráficos de regresión para visualizar modelos estadísticos y las matrices de calor para representar datos matriciales como correlaciones o tablas de contingencia.

Gráficos de regresión

Seaborn distingue entre dos funciones de regresión:

• regplot(): función axes-level que dibuja una nube de puntos con la línea de regresión y su intervalo de confianza sobre un eje existente.
• lmplot(): función figure-level que añade capacidad de faceting mediante col, row y hue.

Ambas admiten regresión lineal simple, polinómica, robusta (lowess) y regresión logística. residplot() complementa el análisis mostrando los residuos del modelo para diagnosticar su calidad:

import seaborn as sns
import matplotlib.pyplot as plt

tips = sns.load_dataset("tips")

sns.lmplot(
    data=tips,
    x="total_bill",
    y="tip",
    hue="smoker",
    col="time",
    height=5,
    order=1
)
plt.show()

Mapas de calor con heatmap

heatmap() visualiza matrices de datos numéricos con codificación de color. Su uso más común es representar matrices de correlación, pero acepta cualquier DataFrame bidimensional:

corr = tips.select_dtypes("number").corr()

sns.heatmap(
    corr,
    annot=True,
    fmt=".2f",
    cmap="coolwarm",
    vmin=-1,
    vmax=1,
    square=True,
    linewidths=0.5
)
plt.title("Matriz de correlación")
plt.show()

Clustering jerárquico con clustermap

clustermap() extiende heatmap() con agrupamiento jerárquico (dendrogramas) tanto en filas como en columnas, revelando grupos de variables o muestras con comportamientos similares.

Seaborn ofrece numerosas opciones para personalizar la apariencia de los gráficos, permitiendo adaptar cada visualización a necesidades específicas. A diferencia de Matplotlib, donde la personalización puede requerir mucho código, Seaborn proporciona funciones de alto nivel que simplifican este proceso sin sacrificar la flexibilidad.

La personalización en Seaborn se puede aplicar a distintos niveles: desde cambios globales que afectan a todos los gráficos hasta ajustes específicos para elementos individuales. Esta capacidad permite crear visualizaciones consistentes y profesionales con relativamente poco esfuerzo.

El sistema de temas es el punto de partida para personalizar gráficos en Seaborn. La función set_theme() permite aplicar cambios globales que afectarán a todos los gráficos subsiguientes:

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

## Establecer tema global
sns.set_theme(style="whitegrid", palette="deep")

## Cargar datos de ejemplo
tips = sns.load_dataset("tips")

Seaborn incluye varios estilos predefinidos que cambian el aspecto general de los gráficos. Estos incluyen elementos como el color de fondo, la presencia de líneas de cuadrícula y el estilo de los bordes:

## Estilos disponibles
estilos = ["whitegrid", "darkgrid", "white", "dark", "ticks"]

## Crear una figura para cada estilo
fig, axes = plt.subplots(len(estilos), 1, figsize=(10, 12), sharex=True, sharey=True)

for ax, estilo in zip(axes, estilos):
    # Aplicar estilo
    sns.set_style(estilo)
    
    # Crear gráfico
    sns.barplot(x="day", y="total_bill", data=tips, ax=ax)
    ax.set_title(f"Estilo: {estilo}")
    
plt.tight_layout()
plt.show()

## Restaurar estilo para siguientes ejemplos
sns.set_style("whitegrid")

El contexto de escala permite ajustar el tamaño de los elementos según el medio donde se presentará el gráfico:

## Contextos disponibles
contextos = ["paper", "notebook", "talk", "poster"]

## Crear una figura para cada contexto
fig, axes = plt.subplots(len(contextos), 1, figsize=(10, 12), sharex=True, sharey=True)

for ax, contexto in zip(axes, contextos):
    # Aplicar contexto
    sns.set_context(contexto)
    
    # Crear gráfico
    sns.boxplot(x="day", y="total_bill", data=tips, ax=ax)
    ax.set_title(f"Contexto: {contexto}")
    
plt.tight_layout()
plt.show()

## Restaurar contexto para siguientes ejemplos
sns.set_context("notebook")

Las paletas de colores son fundamentales para la personalización. Seaborn ofrece diversas paletas predefinidas y la capacidad de crear paletas personalizadas:

## Tipos de paletas
paletas = ["deep", "muted", "pastel", "bright", "dark", "colorblind"]

## Crear una figura para cada paleta
fig, axes = plt.subplots(len(paletas), 1, figsize=(10, 12), sharex=True, sharey=True)

for ax, paleta in zip(axes, paletas):
    # Aplicar paleta
    sns.set_palette(paleta)
    
    # Crear gráfico
    sns.barplot(x="day", y="total_bill", hue="sex", data=tips, ax=ax)
    ax.set_title(f"Paleta: {paleta}")
    
plt.tight_layout()
plt.show()

También podemos crear paletas personalizadas utilizando diferentes métodos:

## Paleta personalizada con color_palette
colores = ["#ff9999", "#66b3ff", "#99ff99", "#ffcc99", "#c2c2f0"]
sns.set_palette(sns.color_palette(colores))

## Visualizar la paleta
plt.figure(figsize=(10, 2))
sns.palplot(sns.color_palette())
plt.title("Paleta personalizada con colores específicos")
plt.show()

## Paleta secuencial
plt.figure(figsize=(10, 2))
sns.palplot(sns.color_palette("Blues", 10))
plt.title("Paleta secuencial 'Blues'")
plt.show()

## Paleta divergente
plt.figure(figsize=(10, 2))
sns.palplot(sns.color_palette("RdBu_r", 10))
plt.title("Paleta divergente 'RdBu_r'")
plt.show()

## Paleta circular (husl)
plt.figure(figsize=(10, 2))
sns.palplot(sns.color_palette("husl", 8))
plt.title("Paleta circular 'husl'")
plt.show()

Para personalizar elementos específicos de un gráfico, podemos utilizar parámetros en las funciones de visualización:

## Personalización de un gráfico de dispersión
plt.figure(figsize=(10, 6))
sns.scatterplot(
    data=tips,
    x="total_bill", 
    y="tip",
    hue="time",
    size="size",
    sizes=(20, 200),
    style="smoker",
    palette="viridis",
    alpha=0.7,
    edgecolor="black",
    linewidth=0.5,
    markers={"Yes": "X", "No": "o"}
)
plt.title("Relación entre cuenta total y propina", fontsize=16)
plt.xlabel("Importe total", fontsize=14)
plt.ylabel("Propina", fontsize=14)
plt.grid(True, linestyle="--", alpha=0.7)
plt.show()

La personalización de textos es esencial para mejorar la legibilidad y comprensión de los gráficos:

## Personalización de textos
plt.figure(figsize=(10, 6))
g = sns.barplot(x="day", y="total_bill", hue="sex", data=tips)

## Personalizar título y etiquetas de ejes
g.set_title("Gasto promedio por día y género", fontsize=16, fontweight="bold")
g.set_xlabel("Día de la semana", fontsize=14)
g.set_ylabel("Importe medio (€)", fontsize=14)

## Personalizar etiquetas de leyenda
g.legend(title="Género", title_fontsize=12, fontsize=10, loc="upper right")

## Personalizar etiquetas del eje x
g.set_xticklabels(g.get_xticklabels(), rotation=45, ha="right", fontsize=12)

## Personalizar etiquetas del eje y
g.set_yticklabels(g.get_yticklabels(), fontsize=12)

plt.tight_layout()
plt.show()

Para agregar anotaciones a un gráfico, podemos combinar Seaborn con funciones de Matplotlib:

## Gráfico con anotaciones
plt.figure(figsize=(10, 6))
scatter = sns.scatterplot(data=tips, x="total_bill", y="tip")

## Identificar puntos de interés
max_tip = tips.loc[tips["tip"].idxmax()]
min_ratio = tips.loc[(tips["tip"] / tips["total_bill"]).idxmin()]

## Añadir anotaciones
plt.annotate(
    "Propina máxima",
    xy=(max_tip["total_bill"], max_tip["tip"]),
    xytext=(max_tip["total_bill"] + 5, max_tip["tip"] + 1),
    arrowprops=dict(arrowstyle="->", color="red", lw=1.5),
    fontsize=12
)

plt.annotate(
    "Ratio mínimo",
    xy=(min_ratio["total_bill"], min_ratio["tip"]),
    xytext=(min_ratio["total_bill"] - 10, min_ratio["tip"] + 2),
    arrowprops=dict(arrowstyle="->", color="blue", lw=1.5),
    fontsize=12
)

plt.title("Relación entre cuenta total y propina con anotaciones", fontsize=16)
plt.show()

Los límites y escalas de los ejes pueden personalizarse para destacar aspectos específicos de los datos:

## Personalización de límites y escalas
plt.figure(figsize=(10, 6))
scatter = sns.scatterplot(data=tips, x="total_bill", y="tip")

## Ajustar límites de ejes
plt.xlim(0, 60)
plt.ylim(0, 10)

## Establecer marcas de eje
plt.xticks(np.arange(0, 61, 10))
plt.yticks(np.arange(0, 11, 2))

## Añadir líneas de referencia
plt.axhline(y=tips["tip"].mean(), color="red", linestyle="--", label=f"Propina media: {tips['tip'].mean():.2f}")
plt.axvline(x=tips["total_bill"].mean(), color="green", linestyle="--", label=f"Cuenta media: {tips['total_bill'].mean():.2f}")

plt.title("Relación entre cuenta total y propina con referencias", fontsize=16)
plt.legend()
plt.tight_layout()
plt.show()

La personalización de mapas de calor incluye ajustes en las escalas de color y anotaciones:

## Datos de correlación
iris = sns.load_dataset("iris")
corr = iris.drop("species", axis=1).corr()

## Personalización de mapa de calor
plt.figure(figsize=(10, 8))
mask = np.triu(np.ones_like(corr, dtype=bool))
cmap = sns.diverging_palette(220, 10, as_cmap=True)

heatmap = sns.heatmap(
    corr,
    mask=mask,
    cmap=cmap,
    vmin=-1,
    vmax=1,
    center=0,
    square=True,
    linewidths=0.5,
    annot=True,
    fmt=".2f",
    annot_kws={"size": 10},
    cbar_kws={"shrink": 0.8, "label": "Coeficiente de correlación"}
)

plt.title("Matriz de correlación de características del iris", fontsize=16)
plt.tight_layout()
plt.show()

Para personalizar gráficos categóricos, Seaborn ofrece numerosas opciones:

## Personalización de gráfico de cajas
plt.figure(figsize=(12, 6))
boxplot = sns.boxplot(
    data=tips,
    x="day",
    y="total_bill",
    hue="time",
    palette="Set3",
    width=0.7,
    fliersize=5,
    linewidth=1.5
)

## Añadir puntos individuales (swarmplot)
swarmplot = sns.swarmplot(
    data=tips,
    x="day",
    y="total_bill",
    hue="time",
    dodge=True,
    size=4,
    edgecolor="black",
    linewidth=0.5,
    palette=["#000000", "#000000"]
)

## Personalizar leyenda para mantener solo una
handles, labels = boxplot.get_legend_handles_labels()
plt.legend(handles[:2], labels[:2], title="Horario", loc="upper right")

plt.title("Distribución de importes por día y horario", fontsize=16)
plt.tight_layout()
plt.show()

El control de facetas (subgráficos) permite crear paneles múltiples organizados por variables categóricas:

## Personalización de facetas
g = sns.FacetGrid(
    tips,
    col="time",
    row="smoker",
    height=4,
    aspect=1.2,
    sharex=True,
    sharey=True,
    margin_titles=True,
    despine=True
)

## Mapear función de visualización
g.map_dataframe(sns.scatterplot, x="total_bill", y="tip", hue="sex", 
               size="size", sizes=(20, 200), alpha=0.7)

## Personalizar títulos y etiquetas
g.set_axis_labels("Importe total", "Propina")
g.set_titles(col_template="{col_name}", row_template="{row_name}")
g.add_legend(title="Género", loc="upper right")
g.fig.suptitle("Relación entre importe y propina por categorías", y=1.05, fontsize=16)
plt.tight_layout()
plt.show()

Para gráficos de pares, la personalización puede incluir diferentes tipos de visualizaciones para las diagonales y fuera de la diagonal:

## Personalización de gráfico de pares
g = sns.PairGrid(
    iris,
    hue="species",
    diag_sharey=False,
    corner=True,
    height=3,
    aspect=1
)

## Mapear diferentes visualizaciones
g.map_upper(sns.scatterplot, size=4, alpha=0.7, edgecolor="white", linewidth=0.5)
g.map_lower(sns.kdeplot, fill=Tr

Este módulo aborda las integraciones de Seaborn con el ecosistema Python de análisis de datos y la puesta en producción de las visualizaciones, incluyendo la nueva interfaz declarativa seaborn.objects introducida a partir de la versión 0.12.

La interfaz seaborn.objects

seaborn.objects (también referenciada como so) es una API completamente nueva y declarativa basada en la gramática de gráficos. Se construye mediante la composición de objetos:

• Plot: el objeto principal que recibe los datos y las asignaciones estéticas.
• Mark: define cómo se representan los datos (Dot, Line, Bar, Area, etc.).
• Stat: aplica transformaciones estadísticas (Agg, Count, Hist, KDE, etc.).
• Move: ajusta la posición de las marcas (Jitter, Dodge, Stack, Shift).
• Scale: controla la escala de los ejes y del color.

import seaborn.objects as so
import seaborn as sns

tips = sns.load_dataset("tips")

(
    so.Plot(tips, x="total_bill", y="tip", color="time")
    .add(so.Dot(alpha=0.6))
    .add(so.Line(), so.PolyFit(order=1))
    .label(title="Regresión con objects API")
    .show()
)

Exportación y producción

Guardar gráficos de Seaborn en alta resolución, formatos vectoriales (SVG, PDF) y con dimensiones correctas para publicación es esencial para el trabajo profesional.

Jupyter y Streamlit

Seaborn se integra perfectamente con Jupyter Notebook y JupyterLab para análisis interactivo, y con Streamlit para crear aplicaciones de visualización de datos accesibles como dashboards web.