A representação visual de dados é uma ferramenta crucial para a compreensão e extração de informações relevantes e acionáveis. Uma visualização eficaz permite que o observador compreenda rapidamente as informações com um simples olhar.
Um método de visualização amplamente empregado é o mapa de calor. Neste artigo, exploraremos o conceito de mapa de calor e demonstraremos como criá-los usando Python, com o auxílio das bibliotecas Matplotlib, Seaborn e Plotly.
O que é um Mapa de Calor?
Fonte: seaborn.pydata.org
Um mapa de calor é uma representação gráfica bidimensional que utiliza uma matriz ou grade de pontos para exibir dados. Cada ponto de dado é representado por uma tonalidade de cor, onde tons mais escuros indicam valores mais altos e tons mais claros representam valores mais baixos.
Mapas de calor são valiosos na identificação de padrões, tendências e variações nos dados. Eles oferecem um resumo visual que permite aos usuários detectar rapidamente áreas de altos ou baixos valores, aglomerados ou valores discrepantes.
Onde os Mapas de Calor são Utilizados?
Mapas de calor são particularmente úteis para ilustrar como os valores variam em um determinado espaço. Exemplos de uso cotidiano incluem:
Clima
Um dos exemplos mais comuns de mapas de calor é a representação de temperaturas em diferentes regiões.
Este é um exemplo de previsão do tempo do Express Daily, mostrando as temperaturas esperadas como um mapa de calor. Isso torna fácil identificar rapidamente as áreas quentes, frias e de temperaturas intermediárias.
Análise do Uso de Sites e Aplicativos
Fonte: HotJar
Através do rastreamento de movimentos do mouse, cliques e padrões de rolagem, os mapas de calor auxiliam na identificação de áreas mais ou menos acessadas de uma página web. Essa informação é útil para otimizar a interface do usuário e aprimorar a experiência do usuário.
Imagens Médicas
Fonte: researchgate.net
Mapas de calor são utilizados para visualizar áreas de alta ou baixa atividade no corpo. Isso pode auxiliar na identificação de anomalias e doenças, além de avaliar a progressão ou resposta ao tratamento em condições como o câncer.
Bibliotecas Python para Criação de Mapas de Calor
Python é uma linguagem popular para análise e visualização de dados, devido à sua sintaxe intuitiva e vasto ecossistema de bibliotecas. Diversas bibliotecas podem ser usadas para gerar mapas de calor, incluindo:
- Matplotlib: Uma biblioteca amplamente utilizada para visualização de dados. É uma biblioteca de baixo nível que oferece opções de personalização avançadas, mas pode ser complexa para iniciantes.
- Seaborn: Esta biblioteca é construída sobre o Matplotlib e simplifica algumas de suas funcionalidades, ao mesmo tempo em que fornece visualizações mais atraentes.
- Plotly: Esta é uma biblioteca de visualização que oferece uma API fácil de usar para criar mapas de calor em Python, além de gráficos interativos.
Na seção seguinte, exploraremos a criação de mapas de calor utilizando cada uma dessas bibliotecas.
Como Gerar um Mapa de Calor?
Nesta seção, demonstraremos como criar mapas de calor usando Matplotlib, Seaborn e Plotly. Para o desenvolvimento do código, utilizaremos o Google Colab, uma instância gratuita de um Python Notebook que usa a infraestrutura do Google para executar o código. Não requer configuração, tornando-o ideal para seguir os exemplos. Inicialmente, abordaremos o Matplotlib.
Matplotlib
Para começar, importamos a biblioteca Matplotlib.
import matplotlib.pyplot as pltTambém precisaremos da biblioteca NumPy para gerar um conjunto de dados aleatórios.
import numpy as npO código abaixo gera o conjunto de dados:
# Criando uma seed para reprodução
np.random.seed(2)
# Gerando um array 10x10 de inteiros entre 1 e 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))Para exibir os dados, empregamos o método imshow, passando os dados como argumento. Podemos personalizar o gráfico com argumentos adicionais.
plt.imshow(data)Após executar o código, você deverá visualizar um mapa de calor básico.
A personalização do mapa de calor é possível através de diversos parâmetros. Por exemplo, a paleta de cores pode ser alterada utilizando o argumento `cmap`. Para criar um mapa de calor com tons de azul, utilize o seguinte código:
plt.imshow(data, cmap = 'Blues')A lista completa de paletas de cores disponíveis pode ser encontrada aqui. O resultado desse código seria:
Para tornar o mapa de calor mais informativo, podemos adicionar uma barra de cores que explique o significado de cada tom. Isso pode ser feito com o seguinte código:
plt.colorbar()O resultado seria semelhante a:
Em alguns casos, a anotação dos valores de cada célula pode ser útil para uma análise mais precisa. O código abaixo realiza a anotação:
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",
)
Finalmente, podemos adicionar rótulos aos eixos do mapa de calor. Para o eixo x utilizamos a função `plt.xticks`, e para o eixo y, a função `plt.yticks`. O primeiro argumento de ambas as funções é a lista de posições onde os rótulos serão inseridos, representados como um array de índices. O segundo argumento é a lista dos rótulos reais.
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)
E isso conclui a criação de um mapa de calor usando Matplotlib. O código completo é apresentado a seguir:
import numpy as np
import matplotlib.pyplot as plt
# Criando uma seed para reprodução
np.random.seed(2)
# Gerando um array 10x10 de inteiros entre 1 e 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))
# Criando o mapa de calor com a paleta de cor azul
plt.imshow(data, cmap = 'Blues')
# Exibindo a barra de cores
plt.colorbar()
# Anotando os valores
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",
)
# Criando listas de rótulos
x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
# Adicionando os rótulos
plt.xticks(np.arange(len(x_labels)), labels=x_labels)
plt.yticks(np.arange(len(y_labels)), labels=y_labels)Embora o Matplotlib seja funcional, ele pode não ser a solução mais prática. Como veremos adiante, bibliotecas como Seaborn e Plotly simplificam o processo de criação de mapas de calor.
Seaborn
Nesta seção, recriaremos o exemplo anterior usando a biblioteca Seaborn. Seaborn é construída sobre o Matplotlib, oferecendo abstrações que tornam o processo mais simples. Começamos importando as bibliotecas necessárias:
import matplotlib.pyplot as plt
import numpy as np
import seaborn as snImportamos o Matplotlib, pois Seaborn depende dele. Também importamos o NumPy para gerar um conjunto de dados aleatórios e, finalmente, o Seaborn.
Geramos o conjunto de dados usando NumPy:
# Criando uma seed para reprodução
np.random.seed(2)
# Gerando um array 10x10 de inteiros entre 1 e 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))Em seguida, definimos as listas de rótulos:
# Rótulos dos ticks
x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']Finalmente, criamos o mapa de calor chamando a função `heatmap` do módulo `sn`:
hm = sn.heatmap(data = data, cmap = 'Oranges', annot = True, yticklabels = y_labels, xticklabels = x_labels)Diversos argumentos são passados para esta função:
- `data`: Os dados que serão plotados.
- `cmap`: O esquema de cores que será usado no mapa de calor.
- `annot`: Booleano que indica se os valores dos pontos de dados devem ser mostrados no gráfico.
- `yticklabels`: A lista de rótulos para os ticks do eixo vertical.
- `xticklabels`: A lista de rótulos para os ticks do eixo horizontal.
Para exibir o gráfico, utilizamos o seguinte código:
plt.show()Isso gerará o seguinte mapa de calor:
Plotly
O processo de criação de um mapa de calor usando Plotly é similar ao Seaborn. O código para criar um mapa de calor é o seguinte:
import plotly.express as px
import numpy as np
# Criando uma seed para reprodução
np.random.seed(2)
# Gerando um array 10x10 de inteiros entre 1 e 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))
# Rótulos dos ticks
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")O mapa de calor é gerado através da função `px.imshow()`. Os argumentos utilizados são:
- `data`: Os dados a serem plotados, passado como um argumento posicional.
- `text_auto`: Um booleano que habilita a anotação dos valores, quando definido como `True`.
- `x`: A lista de rótulos dos ticks do eixo x.
- `y`: A lista de rótulos dos ticks do eixo y.
- `color_continuous_scale`: Define a paleta de cores utilizada no gráfico.
Plotly simplifica a criação de mapas de calor e, adicionalmente, gera gráficos interativos em comparação com imagens estáticas produzidas por outras bibliotecas.
Segue a captura de tela do mapa de calor gerado:
Considerações Finais
Neste artigo, exploramos o processo de criação de mapas de calor em Python utilizando as principais bibliotecas: Matplotlib, Seaborn e Plotly. Também observamos como Seaborn e Plotly oferecem abstrações simplificadas sobre o Matplotlib. Um uso crucial dos mapas de calor é o rastreamento do uso de sites pelos usuários.
Recomendamos a análise de ferramentas de mapas de calor que forneçam informações sobre onde seus usuários estão clicando, para otimizar a experiência do usuário.