[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 solo un vistazo.

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

¿Qué es un mapa de calor?

Un mapa térmico es una imagen bidimensional que representa los datos como una matriz o cuadrícula de puntos. Un tono de un gráfico de color representa cada punto de datos. 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. Los casos de uso cotidiano incluyen:

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 de el Daily Express que muestra las temperaturas previstas en forma de mapa térmico. Esto facilita la visualización de los lugares en los que hará calor, frío o temperaturas intermedias.

Mostrar el uso de la página web/aplicación

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 para optimizar las interfaces de usuario y mejorar su experiencia.

Imágenes médicas

Los mapas de calor visualizan zonas de alta o baja actividad en el organismo. Esto permite 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 muy 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 librerías que puedes utilizar para crear mapas de calor en Python. Estas incluyen:

• Matplotlib - Una popular biblioteca de visualización de datos. Es una biblioteca de bajo nivel que ofrece 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 más atractivas.
• Plotly - Se trata de 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. Es una instancia gratuita de un cuaderno de Python que utiliza Google Infrastructure para ejecutar tu código. No requiere configuración, por lo que también se puede utilizar para seguir adelante. Para empezar, cubriremos primero Matplotlib.

Matplotlib

Para empezar, comenzaremos importando la librería 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:

# Creating a seed for reproducibility
np.random.seed(2)

# Generating 10 x 10 array of integers between 1 and 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

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

plt.imshow(data)

Si ejecutas la celda, deberías ver un mapa de calor.

Aunque esto está muy bien, hay muchas opciones de personalización a tu disposición. Para empezar, puedes cambiar el color utilizado en la imagen utilizando el argumento cmap que pasas 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(data, cmap = 'Blues')

La lista completa de cmap opciones 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 qué representan los colores. Para ello, añada el siguiente código:

plt.colorbar()

Después de esto, deberías obtener una cifra parecida a esta:

Una barra de color es útil, pero en algunos casos, puede que desee anotar los diferentes valores para que el espectador pueda ver con precisión lo que está representado. Para ello, escriba texto en cada una de las celdas utilizando plt.text().

for i in range(data.shape[0]):
   for j in range(data.shape[1]):
      plt.text(j, i, '%d' % data[i, j],
         horizontalalignment='center',
         verticalalignment='center',
      )

La última cosa 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 plt.yticks para el eje y. Estos métodos se llaman de la misma manera; la única diferencia es el eje al que afecta cada método.

El primer argumento es la lista de lugares donde insertar las marcas. 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_labels = ['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_labels)), labels=x_labels)
plt.yticks(np.arange(len(y_labels)), labels=y_labels)

Y ya está. Así es como se crea un mapa de calor en Matplotlib. La solución de código completa se detalla a continuación.

import numpy as np
import matplotlib.pyplot as plt

# Creating a seed for reproducibility
np.random.seed(2)

# Generating 10 x 10 array of integers between 1 and 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

# Creating a plot with blue as a color
plt.imshow(data, cmap = 'Blues')

# Displaying a color bar
plt.colorbar()

# Annotating values
for i in range(data.shape[0]):
   for j in range(data.shape[1]):
      plt.text(j, i, '%d' % data[i, j],
         horizontalalignment='center',
         verticalalignment='center',
      )

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

# Adding the tick labels
plt.xticks(np.arange(len(x_labels)), labels=x_labels)
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 librería que se construye sobre Matplotlib. Proporciona abstracciones que facilitan el trabajo. Para crear un mapa de calor, empezamos importando las librerías que vamos a utilizar.

import matplotlib.pyplot as 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.

# Creating a seed for reproducibility
np.random.seed(2)

# Generating 10 x 10 array of integers between 1 and 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

Una vez hecho esto, creamos nuestras listas de etiquetas de garrapatas.

# Tick labels
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 llamando a la función heatmap del módulo sn.

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

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

• data es el conjunto de datos que queremos representar
• cmap es el esquema de colores con el que queremos crear 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 a Seaborn. Aquí está el esquema de código para crear un mapa de calor en Plotly:

import plotly.express as px
import numpy as np

# Creating a seed for reproducibility
np.random.seed(2)

# Generating 10 x 10 array of integers between 1 and 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

# Tick labels
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_labels, y = y_labels, color_continuous_scale= 'greys')

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

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

Como puede ver, Plotly es más simple 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, cubrimos 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 Heatmaps es el seguimiento de cómo la gente utiliza sus sitios web.

A continuación, consulte herramientas de mapa de calor que le indican dónde hacen clic sus usuarios.