[Explicado] Cómo crear un mapa de calor en Python

La visualización es una forma importante de dar sentido a los datos y extraer ideas informativas y procesables. Una buena visualización permite al lector hacerse una idea básica de la información con sólo un vistazo.

Una visualización popular utilizada para ver datos es un mapa de calor. En este artículo, explicaré un mapa de calor y cómo crear uno en Python utilizando Matplotlib, Seaborn y Plotly.

¿Qué es un mapa de calor?

Un mapa de calor es una imagen bidimensional que representa los datos como una matriz o cuadrícula de puntos. Cada punto de datos está representado por un tono de color. Los tonos más oscuros representan valores más altos que los tonos más claros.

Los mapas de calor facilitan la identificación de patrones, tendencias y variaciones en los datos. Proporcionan información resumida que permite a los usuarios ver rápidamente áreas de valores altos o bajos, agrupaciones o valores atípicos.

¿Dónde se utilizan los mapas de calor?

Los mapas de calor son útiles para mostrar cómo varían los valores en el espacio. Entre los casos de uso cotidiano se incluyen:

El tiempo

El mapa de calor más popular que la mayoría de la gente ha visto es un mapa de calor literal, que muestra cómo varía la temperatura en distintos lugares.

Este es un ejemplo de previsión meteorológica del Daily Express que muestra las temperaturas previstas como un mapa térmico. Esto facilita la visualización de los lugares en los que hará calor, frío o una temperatura intermedia.

Mostrar el uso de sitios web/aplicaciones

Mediante el seguimiento de los movimientos del ratón, los clics y los patrones de desplazamiento, los mapas de calor ayudan a identificar las zonas populares o descuidadas de una página web. Esto puede utilizarse después para optimizar las interfaces de usuario y mejorar la experiencia del usuario.

Imágenes médicas

Medical-Heatmap — Fuente: researchgate.net

Los mapas de calor visualizan zonas de alta o baja actividad en el organismo. Esto puede identificar anomalías y enfermedades y evaluar la progresión o la respuesta al tratamiento en afecciones como el cáncer.

Bibliotecas para crear mapas de calor en Python

Python es un lenguaje popular para el análisis y la visualización de datos. Esto se debe a su sencilla sintaxis y a su amplio ecosistema. Existen múltiples bibliotecas que puede utilizar para crear mapas de calor en Python. Entre ellas se incluyen:

Matplotlib – Una popular biblioteca de visualización de datos. Es una biblioteca de bajo nivel que proporciona más opciones de personalización, pero es complicada.
Seaborn – Esta biblioteca de visualización está construida sobre Matplotlib y simplifica algunas de sus funciones a la vez que proporciona visualizaciones de mejor aspecto.
Plotly – Esta es una biblioteca de visualización que proporciona una API fácil de usar para crear Heatmaps en Python.

En la siguiente sección, exploraremos cómo crear mapas de calor utilizando todas estas bibliotecas.

¿Cómo generar un mapa de calor?

En esta sección, voy a explorar cómo crear mapas de calor utilizando Matplotlib, Seaborn, y Plotly. Para codificar, voy a utilizar Google Colab. Se trata de una instancia gratuita de un cuaderno de Python que utiliza la infraestructura de Google para ejecutar su código. No requiere configuración, por lo que también se puede utilizar para seguir a lo largo. Para empezar, cubriremos primero Matplotlib.

Matplotlib

Para empezar, comenzaremos importando la biblioteca Matplotlib.

import matplotlib.pyplot as plt

También necesitaremos NumPy para generar un conjunto de datos aleatorios.

import numpy as np

Para generar el conjunto de datos, añadiremos el siguiente código:

# Creación de una semilla para la reproducibilidad
np.random.seed(2)

# Generar una matriz 10 x 10 de enteros entre 1 y 50
datos = np.random.randint(bajo = 1, alto = 50, tamaño = (10, 10))

Para trazar los datos, utilizamos el método imshow. Pasamos los datos como argumento. Podemos hacer más pasando argumentos adicionales en los que entraremos más adelante.

plt.imshow(datos)

Si ejecuta la celda, debería ver un mapa de calor.

Aunque esto está muy bien, tiene a su disposición muchas opciones de personalización. Para empezar, puede cambiar el color utilizado en la imagen utilizando el argumento cmap que pasa a imshow. Por ejemplo, si quisiera cambiar el color utilizado por el mapa de calor a diferentes tonos de azul, generaría el gráfico con lo siguiente.

plt.imshow(datos, cmap = 'Azules')

La lista completa de opciones de cmap se encuentra aquí. De todos modos, el resultado de lo anterior sería:

Un mapa de calor sería más útil si hubiera una clave que explicara lo que representan los colores. Para ello, añada el siguiente código

plt.colorbar()

Después de esto, debería obtener una figura con este aspecto:

Una barra de color es útil, pero en algunos casos, es posible que desee anotar los diferentes valores para que el espectador pueda ver con precisión lo que se representa. Para ello, escribiría texto en cada una de las celdas utilizando plt.text().

for i in range(datos.forma<x>[0]</x>):
   for j in range(datos.forma<x>[</x>1]):
      plt.text(j, i, '%d' % datos[i, j],
         horizontalalignment='center',
         verticalalignment='center',
      )

Lo último que haremos con el mapa de calor es establecer las etiquetas de tick en los ejes. Utilizaremos la función plt.xticks para el eje x y la función plt.yticks para el eje y. Estos métodos se llaman de la misma forma; la única diferencia es el eje al que afecta cada método.

El primer argumento es la lista de lugares donde insertar los ticks. Se representa como una matriz de índices. El siguiente argumento es la lista real de etiquetas que se insertarían. He aquí un ejemplo de cómo insertaríamos las marcas:

x_etiquetas = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

plt.xticks(np.arange(len(x_etiquetas)), labels=x_etiquetas)
plt.yticks(np.arange(len(y_labels)), labels=y_labels)

¡Y ya está! Así es como se crea un mapa de calor en Matplotlib. El código completo de la solución se detalla a continuación.

importar numpy como np
import matplotlib.pyplot as plt

# Crear una semilla para la reproducibilidad
np.random.seed(2)

# Generación de una matriz 10 x 10 de enteros entre 1 y 50
data = np.random.randint(bajo = 1, alto = 50, tamaño = (10, 10))

# Creación de un gráfico con el azul como color
plt.imshow(datos, cmap = 'Azules')

# Visualización de una barra de color
plt.colorbar()

# Anotando valores
para i en rango(datos.forma<x>[</x>0])
   for j in range(datos.forma<x>[</x>1]):
      plt.text(j, i, '%d' % datos[i, j],
         horizontalalignment='center',
         verticalalignment='center',
      )

# Creación de listas de etiquetas de garrapatas
x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

# Añadir las etiquetas de las garrapatas
plt.xticks(np.arange(len(x_etiquetas)), labels=x_etiquetas)
plt.yticks(np.arange(len(y_labels)), labels=y_labels)

Sin embargo, utilizar Matplotlib no es la solución más sencilla. Como veremos a continuación, otras bibliotecas, como Seaborn y Matplotlib, simplifican el proceso de construcción de un mapa de calor.

Seaborn

En esta sección, recrearemos el ejemplo anterior utilizando Seaborn. Seaborn es una biblioteca que se construye sobre Matplotlib. Proporciona abstracciones que facilitan el trabajo con ella. Para crear un mapa de calor, empezamos importando las bibliotecas que vamos a utilizar.

import matplotlib.pyplot como plt
import numpy as np
import seaborn as sn

Importamos Matplotlib porque Seaborn lo requiere. A continuación, también tenemos que importar NumPy para generar un conjunto de datos aleatorios. Por último, tenemos que importar Seaborn.

A continuación, generamos el conjunto de datos utilizando NumPy.

# Crear una semilla para la reproducibilidad
np.random.seed(2)

# Generación de una matriz 10 x 10 de números enteros entre 1 y 50
datos = np.random.randint(bajo = 1, alto = 50, tamaño = (10, 10))

Después de hacer esto, creamos nuestras listas de etiquetas de tick.

# Etiquetas de tick
x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

Por último, creamos el mapa de calor real llamando a la función heatmap del módulo sn.

hm = sn.heatmap(data = datos, cmap = 'Naranjas', annot = True, yticklabels = y_labels, xticklabels = x_labels)

Como puede ver, pasamos varios argumentos. He aquí una explicación para cada uno:

data es el conjunto de datos que queremos trazar
cmap es el esquema de colores que queremos que utilice el mapa de calor
annot indica si queremos anotar los puntos de datos con su valor real
yticklabels es la lista de etiquetas que queremos para las marcas del eje vertical
xticklabels es la lista de etiquetas para los ticks del eje horizontal.

Por último, mostramos el gráfico utilizando el código

plt.show()

Esto generará el siguiente mapa de calor:

Plotly

Para Plotly, el proceso es similar al de Seaborn. He aquí el esquema de código para crear un mapa de calor en Plotly:

import plotly.express as px
import numpy as np

# Crear una semilla para la reproducibilidad
np.random.seed(2)

# Generación de una matriz 10 x 10 de enteros entre 1 y 50
data = np.random.randint(bajo = 1, alto = 50, tamaño = (10, 10))

# Etiquetas de las garrapatas
x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

px.imshow(data, text_auto = True, x = x_etiquetas, y = y_etiquetas, color_continuous_scale= 'grises')

Como puede ver, el mapa de calor se genera en la última línea utilizando la función px.imshow(). Esta función toma los datos a trazar como argumento posicional. Además, toma el argumento de palabra clave siguiente:

text_auto es un booleano que activa la anotación cuando se establece en true
x es una lista de etiquetas de tick en el eje x
y es una lista de etiquetas de tick en el eje y
color_continuous_scale determina el esquema de color utilizado para el gráfico.

Como puede ver, Plotly es más sencillo que Seaborn y Matplotlib. Además, el gráfico generado es interactivo en comparación con otras bibliotecas que producen imágenes estáticas.

Aquí está la captura de pantalla del resultado final:

Palabras finales

En este artículo, hemos cubierto cómo crear mapas de calor en Python. Cubrimos las principales bibliotecas – Matplotlib, Seaborn, y Plotly. También vimos cómo Seaborn y Plotly proporcionan abstracciones simplificadas sobre Matplotlib. Un uso crítico de los mapas de calor es el seguimiento de cómo la gente utiliza sus sitios web.

A continuación, eche un vistazo a las herramientas de mapas de calor que le indican dónde hacen clic sus usuarios.