Seaborn Heatmap: Guía Completa para Crear Mapas de Calor en Python

Name

Soren Atelier

Updated on 9/2/2026

Tienes un conjunto de datos con docenas de variables. Necesitas entender qué características se correlacionan, dónde se ocultan los patrones o por qué tu modelo de aprendizaje automático sigue funcionando mal. Mirar filas y columnas de números no te dice casi nada. Este es exactamente el problema que resuelve un mapa de calor de seaborn: convierte una matriz densa de valores en una cuadrícula codificada por colores que tu cerebro puede analizar en segundos.

Los mapas de calor son uno de los tipos de visualización más utilizados en ciencia de datos, y la biblioteca seaborn de Python hace que crearlos sea notablemente sencillo. Ya sea que estés construyendo una matriz de correlación, analizando una matriz de confusión o visualizando patrones de series temporales, sns.heatmap() te proporciona un gráfico listo para publicación con solo unas pocas líneas de código.

Esta guía te lleva a través de todo: sintaxis básica, opciones de personalización, técnicas avanzadas como mapas de calor agrupados y una tabla de referencia completa de parámetros. Cada ejemplo de código está listo para copiar y pegar.

Sintaxis Básica del Mapa de Calor de Seaborn

La función principal es sns.heatmap(). Acepta un conjunto de datos 2D (típicamente un DataFrame de pandas o un array de NumPy) y lo renderiza como una cuadrícula de colores.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
# Create sample data
data = np.random.rand(5, 7)
ax = sns.heatmap(data)
plt.title("Basic Seaborn Heatmap")
plt.show()

Este es el mapa de calor más simple posible. El color de cada celda representa su valor numérico, y seaborn añade automáticamente una barra de color en el lado derecho. Pero el uso en el mundo real casi siempre implica más configuración, que cubriremos a continuación.

Crear un Mapa de Calor de Matriz de Correlación

El caso de uso más común para un mapa de calor de seaborn es visualizar una matriz de correlación. Esto te dice qué tan fuertemente está relacionado cada par de variables en tu conjunto de datos.

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
 
# Load a built-in dataset
df = sns.load_dataset("mpg").select_dtypes(include="number")
 
# Compute the correlation matrix
corr = df.corr()
 
# Plot the heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(
    corr,
    annot=True,
    fmt=".2f",
    cmap="coolwarm",
    center=0,
    square=True,
    linewidths=0.5
)
plt.title("Correlation Matrix - MPG Dataset")
plt.tight_layout()
plt.show()

Cosas clave que suceden aquí:

• annot=True imprime el coeficiente de correlación dentro de cada celda.
• fmt=".2f" formatea esos números a dos decimales.
• cmap="coolwarm" usa una paleta de colores divergente donde las correlaciones negativas son azules y las correlaciones positivas son rojas.
• center=0 asegura que la correlación cero se mapee al color del punto medio neutral.
• square=True fuerza que cada celda sea un cuadrado perfecto para visuales más limpios.

Opciones de Personalización

Paletas de Colores (parámetro cmap)

El parámetro cmap controla el esquema de colores. Elegir la paleta correcta depende de tu tipo de datos.

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.rand(6, 6)
fig, axes = plt.subplots(1, 3, figsize=(18, 5))
 
cmaps = ["viridis", "coolwarm", "YlOrRd"]
for ax, cmap in zip(axes, cmaps):
    sns.heatmap(data, cmap=cmap, ax=ax, annot=True, fmt=".2f")
    ax.set_title(f'cmap="{cmap}"')
 
plt.tight_layout()
plt.show()

Anotaciones (parámetros annot y fmt)

Las anotaciones muestran el valor numérico dentro de cada celda. Puedes controlar su formato:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
data = np.random.randint(0, 1000, size=(4, 5))
 
plt.figure(figsize=(8, 5))
sns.heatmap(
    data,
    annot=True,
    fmt="d",            # integer format
    cmap="Blues",
    annot_kws={"size": 14, "weight": "bold"}  # customize font
)
plt.title("Heatmap with Integer Annotations")
plt.show()

Valores comunes de fmt: ".2f" para dos decimales, "d" para enteros, ".1%" para porcentajes, ".1e" para notación científica.

Tamaño de Figura y Relación de Aspecto

Los mapas de calor de Seaborn heredan su tamaño de la figura de matplotlib. Configúralo antes de llamar a sns.heatmap():

plt.figure(figsize=(12, 8))  # width=12, height=8 inches
sns.heatmap(data, cmap="viridis")
plt.show()

Para celdas cuadradas, pasa square=True a sns.heatmap(). Esto anula la relación de aspecto de la figura para hacer que cada celda tenga el mismo tamaño.

Enmascarar el Triángulo Superior o Inferior

Las matrices de correlación son simétricas. Mostrar ambas mitades es redundante. Usa triu o tril de NumPy para enmascarar una mitad:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
df = sns.load_dataset("mpg").select_dtypes(include="number")
corr = df.corr()
 
# Create a mask for the upper triangle
mask = np.triu(np.ones_like(corr, dtype=bool))
 
plt.figure(figsize=(10, 8))
sns.heatmap(
    corr,
    mask=mask,
    annot=True,
    fmt=".2f",
    cmap="coolwarm",
    center=0,
    square=True,
    linewidths=0.5
)
plt.title("Lower Triangle Correlation Heatmap")
plt.tight_layout()
plt.show()

El parámetro mask acepta un array booleano de la misma forma que los datos. Las celdas donde mask=True están ocultas.

Tabla de Referencia de Parámetros del Mapa de Calor

Ejemplos Avanzados

Mapa de Calor Agrupado con sns.clustermap

Cuando quieres agrupar filas y columnas similares, sns.clustermap() aplica clustering jerárquico y reordena los ejes automáticamente:

import seaborn as sns
import matplotlib.pyplot as plt
 
df = sns.load_dataset("mpg").select_dtypes(include="number").dropna()
corr = df.corr()
 
g = sns.clustermap(
    corr,
    annot=True,
    fmt=".2f",
    cmap="vlag",
    center=0,
    linewidths=0.5,
    figsize=(8, 8),
    dendrogram_ratio=0.15
)
g.ax_heatmap.set_title("Clustered Correlation Heatmap", pad=60)
plt.show()

Los dendrogramas a la izquierda y arriba muestran la jerarquía de agrupamiento. Las variables que están más estrechamente correlacionadas se colocan una al lado de la otra, haciendo que los patrones sean mucho más fáciles de detectar.

Rangos de Color Personalizados (vmin, vmax)

Por defecto, seaborn escala los colores al mínimo y máximo de tus datos. Puedes anular esto para comparar múltiples mapas de calor en la misma escala o para resaltar un rango específico:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
 
np.random.seed(42)
data = np.random.uniform(-1, 1, size=(8, 8))
 
plt.figure(figsize=(8, 6))
sns.heatmap(
    data,
    vmin=-1,
    vmax=1,
    center=0,
    cmap="RdBu_r",
    annot=True,
    fmt=".2f"
)
plt.title("Heatmap with Fixed Color Range (-1 to 1)")
plt.show()

Configurar vmin=-1 y vmax=1 es particularmente útil al graficar matrices de correlación o datos normalizados donde el rango teórico es conocido.

Mapa de Calor de Matriz de Confusión

Otra aplicación práctica es visualizar una matriz de confusión de un modelo de clasificación:

import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
from sklearn.metrics import confusion_matrix
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
 
# Train a quick model
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.3, random_state=42
)
clf = RandomForestClassifier(random_state=42)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)
 
# Build and plot the confusion matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(7, 5))
sns.heatmap(
    cm,
    annot=True,
    fmt="d",
    cmap="Blues",
    xticklabels=iris.target_names,
    yticklabels=iris.target_names
)
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.title("Confusion Matrix - Iris Classification")
plt.tight_layout()
plt.show()

La diagonal muestra predicciones correctas. Las celdas fuera de la diagonal revelan dónde el modelo confunde una clase con otra.

Mapa de Calor de Series Temporales

Los mapas de calor también funcionan bien para detectar patrones a través de dimensiones temporales. Aquí hay un ejemplo que muestra actividad por día de la semana y hora:

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
 
np.random.seed(0)
hours = list(range(24))
days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
data = pd.DataFrame(
    np.random.poisson(lam=20, size=(7, 24)),
    index=days,
    columns=hours
)
 
plt.figure(figsize=(14, 5))
sns.heatmap(data, cmap="YlOrRd", linewidths=0.3, annot=False)
plt.xlabel("Hour of Day")
plt.ylabel("Day of Week")
plt.title("Activity Heatmap by Day and Hour")
plt.tight_layout()
plt.show()

Mapa de Calor de Seaborn vs Matplotlib imshow

También puedes crear visualizaciones similares a mapas de calor con matplotlib.pyplot.imshow(). Así es como se comparan los dos:

Conclusión: Usa sns.heatmap() cuando quieras un mapa de calor limpio y bien etiquetado con código mínimo. Recurre a imshow() cuando necesites control a nivel de píxel o estés trabajando con datos de imagen en lugar de datos tabulares.

Alternativa Interactiva: PyGWalker

Los mapas de calor estáticos son poderosos para informes y artículos, pero durante el análisis exploratorio de datos a menudo quieres interactuar con tus datos: filtrar, pivotar, profundizar y cambiar entre tipos de gráficos sin reescribir código.

PyGWalker (opens in a new tab) (enlace Python de Graphic Walker) convierte cualquier DataFrame de pandas en una interfaz interactiva similar a Tableau directamente dentro de Jupyter Notebook. Puedes arrastrar y soltar campos para construir mapas de calor, gráficos de dispersión, gráficos de barras y más sin escribir código de visualización en absoluto.

pip install pygwalker

import pandas as pd
import pygwalker as pyg
 
df = pd.read_csv("your_data.csv")
walker = pyg.walk(df)

Una vez que se inicia la interfaz interactiva, puedes:

• Arrastrar una variable categórica a filas, otra a columnas y una medida a color para crear un mapa de calor.
• Cambiar a otros tipos de gráficos (barra, línea, dispersión) instantáneamente.
• Filtrar y agregar sin escribir código adicional.

Esto es especialmente útil cuando todavía estás explorando qué variables incluir en tu mapa de calor final de seaborn. Usa PyGWalker para la fase de exploración, luego asegura tu visualización estática final con sns.heatmap() para compartir.

Preguntas Frecuentes

¿Cómo cambio el tamaño de un mapa de calor de seaborn?

Configura el tamaño de la figura antes de llamar a sns.heatmap() usando plt.figure(figsize=(width, height)). Por ejemplo, plt.figure(figsize=(12, 8)) crea una figura de 12x8 pulgadas. También puedes pasar un parámetro ax si estás trabajando con subgráficos.

¿Cómo anoto un mapa de calor de seaborn con valores?

Pasa annot=True a sns.heatmap(). Controla el formato de números con el parámetro fmt (p.ej., fmt=".2f" para dos decimales). Personaliza las propiedades de fuente usando annot_kws, por ejemplo: annot_kws={"size": 12, "weight": "bold"}.

¿Cuál es la diferencia entre sns.heatmap y sns.clustermap?

sns.heatmap() muestra datos en el orden original de filas y columnas. sns.clustermap() aplica clustering jerárquico para reordenar filas y columnas de modo que valores similares se agrupen juntos, y añade dendrogramas para mostrar la estructura de agrupamiento.

¿Cómo enmascaro la mitad de un mapa de calor de correlación?

Usa NumPy para crear una máscara booleana. Para el triángulo superior: mask = np.triu(np.ones_like(corr, dtype=bool)). Luego pasa mask=mask a sns.heatmap(). Para el triángulo inferior, usa np.tril() en su lugar.

¿Puedo guardar un mapa de calor de seaborn como archivo de imagen?

Sí. Después de crear el mapa de calor, llama a plt.savefig("heatmap.png", dpi=300, bbox_inches="tight") antes de plt.show(). Los mapas de calor de Seaborn soportan todos los formatos de salida de matplotlib incluyendo PNG, SVG, PDF y EPS.

Conclusión

El mapa de calor de seaborn es una de las herramientas más versátiles en el kit de herramientas de visualización de un científico de datos. Desde análisis de correlación hasta matrices de confusión hasta detección de patrones de series temporales, sns.heatmap() maneja todo esto con sintaxis limpia y salida de calidad de publicación.

Comienza con lo básico: pasa tus datos y elige un mapa de colores. Luego agrega capas de anotaciones, enmascaramiento, rangos personalizados y clustering según lo demande tu análisis. Para la fase de exploración antes de asegurar una visualización final, herramientas como PyGWalker (opens in a new tab) pueden acelerar tu flujo de trabajo con gráficos interactivos de arrastrar y soltar.

Los ejemplos de código en esta guía están todos listos para copiar y pegar. Elige el más cercano a tu caso de uso, intercambia tus datos, y tendrás un mapa de calor claro e informativo en menos de un minuto.