Gráfico de Densidade em Python - Mapas de Calor (Heat Maps Graphics)

Neste tutorial de nosso curso Python Científico , vamos aprender o que é um gráfico de densidade (density plot), para que serve, quando usar, como funciona e como criar em Python.

O que é um gráfico de densidade

No tutorial passado, sobre gráficos de dispersão (scatter plots), mostramo seguinte gráfico:

Note que diversos pontos estão um por cima do outro. Muitas vezes é interessante saber quantos pontos desses estão sobrepostos, afinal devem ter regiões onde há maior sobreposição que outras.

Então essas regiões com mais pontos, são mais frequentes e certamente pode ser útil saber disso. Mas como ver isso? Numericamente é possível, mas obviamente é bem trabalhoso, pois estamos lidando com milhares e milhares de dados.

Uma possibilidade é através dos gráficos de densidade. Imagine que os pontos que ocorrem pouco tenham essa cor azulada, porém a medida que vamos sobrepondo um ponto acima do outro, este ponto vai mudando de cor, ficando mais vermelho, por exemplo.

Ou seja, um vermelho bem fraco sinalizaria uma poucas sobreposições, porém um vermelho bem forte nos diria que ali ocorreu uma grande sobreposição de pontos.

Então, através dessa densidade de cores e brilhos, podemos saber que região é ou menos densa. Assim, podemos analisar a distribuição de dados através de um gráfico.

Quando usar um gráfico de densidade

Nós já estudamos um tipo de visualização que é, de certo modo, semelhante aos density plots, que são os gráficos de histograma. Porém, o gráfico de densidade é algo contínuo, diferente do histograma que é algo discretizado (com valores fixos, nas barras).

Talvez você já tenha ouvido falar na expressão 'mapa de calor' (heat maps), onde as coisas menos densas (como temperatura) estão em azul e vão migrando até o vermelho mais 'quente' (regiões mais densas de dados). São gráficos de densidade.

Quando queremos plotar dados mais contínuos (ao invés dos pontos do scatter, linhas do plot() ou barras de histograma), devemos optar pelos gráficos de densidade para melhor representar e entender as informações que temos que analisar.

Como plotar um gráfico de densidade em Python

Vamos usar os dados do arquivo de texto abaixo (aproveite e nos siga no GitHub):

https://github.com/jarlissonmoreira/PythonProgressivo/blob/main/Grafico-Densidade-Density-Plot-in-Python/densidade.txt

Para carregar esse txt em nosso código Python, usamos a função loadtxt da NumPy. E para interpretar esses dados,vamos usar a função imshow() do Pyplot da Matplotlib. Salve o arquivo de texto acima como densidade.txt e deixe na mesma pasta do script:

import matplotlib.pyplot as plt import numpy as np dados = np.loadtxt("densidade.txt",float) plt.imshow(dados) plt.show()

O resultado será essa bela imagem:

A função loadtxt() colocous as informações do arquivo de texto em uma matriz 500 x 500, e passou para a imshow() plotar o gráfico de densidade.

Note que os eixos são diferentes do cartesiano que estamos habituados a ver desde a época da escola. Aqui, o eixo y cresce de cima para baixo. Ou seja, a origem está acima e na esquerda. Esse é um padrão na computação, de um modo geral.

Podemos mudar isso adicionando o argumento origin="lower" na função imshow():

import matplotlib.pyplot as plt import numpy as np dados = np.loadtxt("densidade.txt",float) plt.imshow(dados, origin="lower") plt.show()

E o resultado:

Se quiser usar um mapa de densidade do tipo mapa de calor, chame a função jet() do Matplotlib.Pyplot ou passe o argumento cmap='jet' na função imshow():

import matplotlib.pyplot as plt import numpy as np dados = np.loadtxt("densidade.txt",float) plt.imshow(dados, origin="lower") plt.jet() plt.show()

É muito comum, principalmente em trabalhos acadêmicos, como em revistas, artigos, teses etc, você usar apenas gráficos em preto e branco. Nesse caso, devemos usar a escola de cor gray():

import matplotlib.pyplot as plt import numpy as np dados = np.loadtxt("densidade.txt",float) plt.imshow(dados, origin="lower") plt.gray() plt.show()

Veja alguns tipos de mapas de cores (colormaps) disponível no Python, através do módulo Pyplot da biblioteca Matplotlib:

Veja a documentação para saber de todas as possibilidades:

https://matplotlib.org/stable/users/explain/colors/colormaps.html

Gráficos de dispersão: scatter() plots em Python

 No tutorial passado, de nosso curso de programação científica em Python, demos início ao estudo da criação, geração e exibição de gráficos em Python, através da função plot(), da biblioteca Matplotlib e do módulo Pyplot.

Agora, vamos aprender sobre os gráficos de dispersão, o que são, para que serve, quando e como usá-los de maneira de correta em seus artigos, trabalhos e pesquisa.

Gráfico de Dispersão em Python: o que é e para que serve um gráfico de scatter

Nos gráficos anteriores, de linhas, através da função plot(), mostramos a relação do eixo y (vertical) em relação aos valores do eixo x (horizontal), ou seja, uma função, pois os valores de um eixo são dependentes dos valores do outro eixo.

Porém, nem sempre os valores dependem um do outro e precisamos analisar esses dados separadamente, para ver se ambos seguem algum padrão ou tendência.

Nesse tipo de dados, vamos plotar uma coleção de dados, geralmente um conjunto de pares ordenados, e cada par é representado simplesmente por um ponto. Veja, nos tutoriais anteriores também calculamos pontos através das funções, mas ligamos esses pontos com retas, o que gerou curvas aparentemente contínuas. Nos gráficos do tipo scatter, teremos uma dispersão de pontos:

Gráfico de dispersão 2D com dados da demora entre erupções de um vulcão e da duração dessas erupções. Note que os pontos se acumularam no início e no fim, ou seja, notamos um padrão

Gráfico em 3D mostrando a energia de moléculas de um gás, em função da temperatura

Função scatter(): como plotar gráfico de dispersão em Python

Vamos usar a função scatter(), do módulo Pyplot da biblioteca Matplotlib, para gerar os gráficos de dispersão. Seu uso é bem semelhante ao da plot() onde, basicamente, devemos fornecer duas coleções de valores, primeiro o do eixo x e depois o do eixo y.

Por exemplo, será que existe uma relação entre a temperatura de uma estrela e seu brilho emitido? Baixe o arquivo 'estrelas.txt' de nosso GitHub:
https://github.com/jarlissonmoreira/PythonProgressivo/blob/main/Grafico-Scatter-Dispersao/estrelas.txt

Nele, há informações de quase 8 mil estrelas, com as informações da temperatura na primeira coluna e do brilho na segunda.

O código para a criação do gráfico de dispersão é:

import matplotlib.pyplot as plt import numpy as np dados = np.loadtxt("estrelas.txt", float) x = dados[:, 0] y = dados[:, 1] plt.xlim(0, 14000) plt.ylim(-3, 20) plt.xlabel("Temperatura") plt.ylabel("Brilho") plt.scatter(x,y, s=10) plt.show()

E o gráfico:

O valor s=10 é pra definir o tamanho do ponto (dot). Experimente usar o valor 5 e veja como ele diminui, ou não coloque esse argumento e veja o tamanho padrão.

Gráficos em Python - Como ler arquivos, Definir tamanho dos eixos, Rótulos (labels), Cores, Tipos de linha e Legendas

 Neste tutorial de nosso curso de Programação Científica em Python, vamos continuar aprendendo como gerar gráficos em Python usando o módulo Pyplot da biblioteca Matplotlib, ferramentas nativas, gratuitas, flexíveis e extremamente poderosas da linguagem Python.

No tutorial anterior, aprendemos como plotar gráficos simples em Python, usando a função plot(). Agora, vamos aprender mais algumas técnicas e possibilidades, para incrementar nossas figuras.

Como gerar gráficos a partir de arquivos: loadtxt()

Nos exemplos do tutorial anterior, usamos apenas alguns poucos dados, mas o comum em Ciência de Dados é usar centenas, milhares e até milhões de informações, tanto para gerar gráficos como para encontrar padrões.

No exemplo a seguir, vamos usar a função loadtxt(), do NumPy, ideal para ler dados de arquivos txt de uma maneira bem simples. Basicamente, essa função recebe uma string com o endereço do arquivo de texto e o tipo de dado que queremos usar para gerar o array.

Baixe esse arquivo itub.txt e salve na mesma pasta do seu script em Python:
https://github.com/jarlissonmoreira/PythonProgressivo

Esse arquivo tem 250 colunas e duas colunas, representando os últimos 250 preços de fechamento da ação do Itaú (ITUB3), na bolsa de valores, que é minha ação favorita para receber dividendos.

Nosso código fica assim:

import matplotlib.pyplot as plt import numpy as np dados = np.loadtxt("itub.txt", float) x = dados[:, 0] y = dados[:, 1] plt.plot(x,y)

A função loadtxt() colocou esses dados em uma matriz 250 x 2.
Usamos nosso conhecimento de slicing de arrays para pegar a coluna 1 da matriz e usar como eixo x, e a coluna 2 como eixo y, para enfim usar a função plot() para gerar o gráfico de cotações:

Definindo os limites dos eixos X e Y: xlim() e ylim()

Veja que, em todos nossos gráficos, o Python automaticamente definiu a faixa de valores que é exibida nos eixos X e Y, de maneira automática.

Porém, como tudo na programação, isso é ajustável. E para tal, vamos usar as funções xlim() e ylim(), do módulo Pyplot.

Vamos gerar um gráfico da função 2*cosseno, no intervalo de 0 até 2pi, e deixar o Pyplot setar automaticamente os valores dos eixos:

import matplotlib.pyplot as plt import numpy as np x = np.linspace(0, 2*np.pi, 1000) y = 2 * np.cos(x) plt.plot(x,y)

Agora vamos definir o eixo x de 0 até 4pi e o eixo y de -2.5 até 2.5, veja como fica o código:

import matplotlib.pyplot as plt import numpy as np x = np.linspace(0, 2*np.pi, 1000) y = 2 * np.cos(x) plt.xlim(0, 4*np.pi) plt.ylim(-2.5, 2.5) plt.plot(x,y)

E o gráfico, como ficou mais 'de longe', pois os eixos agora são maiores:

Ou seja, basta fornecer o intervalo de valores nas funções xlim() e ylim()

Rótulos (labels) dos eixos: xlabel() e ylabel()

Se você olhar bem, todos os gráficos em livros, artigos científicos e até na internet, possuem descrições sobre o que representa cada eixo.

São os rótulos, ou labels, e basta usarmos as funções xlabel() e ylabel() do Pyplot, fornecendo a string que você quer que seja exibida nos respectivos eixos.

Veja como fica nosso código do gráfico do cosseno:

import matplotlib.pyplot as plt import numpy as np x = np.linspace(0, 2*np.pi, 1000) y = 2 * np.cos(x) plt.xlim(0, 4*np.pi) plt.ylim(-2.5, 2.5) plt.xlabel("Ângulo x, em radianos") plt.ylabel("2*cos(x)") plt.plot(x,y) plt.show()

Nosso gráfico ficou:

É sempre interessante você colocar o que é cada eixo, bem como as respectivas unidades que foi utilizado.

Plotando dois gráficos numa mesma imagem

Também é comum plotarmos duas ou mais funções em um mesmo gráfico, algo que é particularmente útil principalmente para compararmos valores, funções e padrões.

Por exemplo, no código abaixo, vamos plotar as funções seno e cosseno, com valores de x indo de 0 até 10pi:

import matplotlib.pyplot as plt import numpy as np x1 = np.linspace(0, 10*np.pi, 1000) x2 = np.linspace(0, 10*np.pi, 1000) y1 = np.cos(x1) y2 = np.sin(x2) plt.xlim(0, 10*np.pi) plt.ylim(-1.5, 1.5) plt.xlabel("Ângulo x, em radianos") plt.ylabel("cos(x) (azul) e sen(x) (em laranja)") plt.plot(x1,y1) plt.plot(x2,y2) plt.show()

Vejamos o resultado:

Note que o Pyplot colocou, automaticamente, cada gráfico de uma função com uma cor diferente.

Como alterar Cores e Tipos de linhas dos gráficos

No exemplo anterior, vimos que os gráficos ficaram com as cores azul e laranja. Isso também pode ser alterado conforme seu gosto.

Se desejar que seu gráfico seja vermelho, fornece um argumento adicional na função plot(), com as string 'red' ou 'r': plot(x, y, 'r')

Se desejar que a linha seja pontilhada, ao invés de contínua, forneça a string '--':
plot(x, y, '--')

E se quiser que ela seja vermelha e pontilhada? Simples, use: 'r--'
Veja:

import matplotlib.pyplot as plt import numpy as np x = np.linspace(-2*np.pi, 2*np.pi, 1000) y = np.tan(x) plt.ylim(-2, 2) plt.xlabel("x, em rad") plt.ylabel("$tg(x)$") plt.grid() plt.plot(x,y, 'r--') plt.show()

Veja como ficou o gráfico:

Note que usamos a função grid() do Pyplot, para exibir as 'grades' (quadriculado).
As cores principais podem ser:

• b : blue
• g : green
• r : red
• c : cyan
• m : magenta
• y : yellow
• k : black
• w : white

Já os estilos de linha são:

Você pode fornecer esses argumento da seguinte maneira: color = 'green', linestyle='dotted'
Veja como ficou o código e gráfico:

import matplotlib.pyplot as plt import numpy as np x = np.linspace(-2*np.pi, 2*np.pi, 1000) y = np.tan(x) plt.ylim(-2, 2) plt.xlabel("x, em rad") plt.ylabel("$tg(x)$") plt.grid() plt.plot(x,y, color='green', linestyle='dotted') plt.show()

Outras possibilidades são alterar o tamanho das fontes, espessura das linhas, marcadores e estilos etc, veja:

https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html

Legendas dos gráficos: legend()

Muitas vezes é interessante fornecer informações sobre os gráficos não apenas nos eixos (labels), mas diretamente dentro do plot.

É especialmente útil quando plotamos várias funções em um imagem só. Para especificar cada gráfico do plot, colocamos o argumento label dentro de cada plot(), com a string que queremos exibir. Depois, chamamos a função legend() do pyplot:

import matplotlib.pyplot as plt import numpy as np x1 = np.linspace(0, 10, 11) x2 = np.linspace(0, 5, 11) y1 = x1 y2 = x2**2 plt.plot(x1,y1, label='Função linear y=x') plt.plot(x2,y2, label='Função quadrática y=x²') plt.legend() plt.show()

Veja o resultado:

Você pode inclusive definir onde quer que essas legendas apareçam. Por exemplo, para aparecer embaixo (lower) e no centro (center), basta colocar essas informações no argumento 'loc' da função legend():

import matplotlib.pyplot as plt import numpy as np x1 = np.linspace(0, 10, 11) x2 = np.linspace(0, 5, 11) y1 = x1 y2 = x2**2 plt.plot(x1,y1) plt.plot(x2,y2) plt.legend(['Função linear y=x', 'Função quadrática y=x²'], loc='lower center') plt.show()

Veja não usamos os argumentos label dentro das funções plot(). Ao invés disso, passamos uma lista com as strings, uma para cada plot, diretamente na função legend, e em seguida usamos o loc para dar a localização desejada da legenda.

Para ver mais variações e possibilidades, acesse:

https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.legend.html

Exercício de programação científica

Mostramos exemplos de gráficos seno, cosseno e tangente. Porém, o NumPy não tem, nativamente, as funções secante, cossecante e cotagente. Ou seja, você vai ter que implementar elas. Lembra das aulas de trigonometria?

Gere um gráfico, com intervalo de -2pi até +2pi, plotando essas três funções, com as cores vermelhas, verde e azul, respectivamente.

Como fazer gráficos simples em Python - Matplotlib.pyplot

Neste tutorial, vamos dar início aos nossos estudos de gráficos em Python, onde iremos esmiuçar, explicar e usar os mais variados de plots e visualizações de dados.

Biblioteca Matplotlib e Módulo Pyplot

Até o momento, em nosso Curso de Programação Científica em Python, trabalhamos exaustivamente com números, arrays, matrizes e dados. Mas, em ciência, é também interessante visualizar esses dados, e a melhor e mais intuitiva maneira de fazer isso, é através dos gráficos.

Se, por acaso, já tiver tido experiência com o MATLAB, saiba que o Pyplot, um módulo do matplotlib, é extremamente semelhante e compatível com o famoso software privado.

O Matplotlib.pyplot, porém, nos fornece uma flexibilidade bem maior, pois o Python é uma linguagem bem mais poderosa e flexível, além de ser tudo gratuito e de código aberto.

Como plotar um gráfico simples: plot() e show()

Para postar um gráfico, precisamos no mínimo de um valor, um número. Porém, um único valor vai ser representado apenas por um ponto, o que não é muito útil.

Vamos, então, criar um gráfico com o conjunto de valores dessa lista: [5, 10, 21, 42 ]
Para isso, usamos o seguinte código:

import matplotlib.pyplot as plt distancias = [5, 10, 21, 42] plt.plot(distancias) plt.show()

Primeiro, importamos o módulo pyplot do matplotlib. Porém, é muito demorado ficar digitando 'matplotlib.pyplot', então vamos apelidar esse comando por plt.

Em seguida, criamos uma lista com 4 valores numéricos, que representam as distâncias de corridas de rua mais comuns.

Depois, usamos a função mais simples para se criar uma figura, o plot(), que é extremamente versátil e poderosa. Vamos começar devagar, primeiro vamos só passar a lista para ela. Pronto, o plot já foi gerado.

Para exibir, invocamos a função show(), agora é só rodar e vemos o gráfico abaixo:

Ele pegou os pontos de coordenadas: (0.0, 5), (1.0, 10), (2.0, 21) e (3.0, 42)
E uniu os pontos com uma linha. Bem simples, não?

Note que no eixo x, ele começou a contagem a partir do 0. E se quisermos que apareça, no eixo x, os valores 1, 2, 3 e 4? Basta criarmos um conjunto de valores para o eixo x:

import matplotlib.pyplot as plt y = [5, 10, 21, 42] x = [1, 2, 3, 4] plt.plot(x,y) plt.show()

Renomeamos os eixos para y e x para melhor entenderem a ordem correta que vai no plot.
Esses valores, inclusive, podem até ser strings:

import matplotlib.pyplot as plt y = [5, 10, 21, 42] x = ['Cinco', 'Dez', 'Meia-maratona', 'Maratona'] plt.plot(x,y) plt.show()

Mas, lembre-se: para cada valor de y, devemos ter um valor de x. Ou seja, são lista ou arrays de mesma dimensão.

Se quiser o plot apenas com os pontos, sem a linha ligando-os, passe 'o' como argumento:

import matplotlib.pyplot as plt y = [5, 10, 21, 42] x = ['Cinco', 'Dez', 'Meia-maratona', 'Maratona'] plt.plot(x,y, 'o') plt.show()

Você pode até substituir esse ponto (dot) por outro caractere, como asterisco:

plt.plot(x,y, '*')

Como plotar uma função trigonométrica

O gráfico anterior tem, tecnicamente, um problema: são poucos pontos. O gráfico fico 'pobre' de informações. O ideal é ter, no mínimo, dezenas de pontos para visualizarmos melhor um gráfico de verdade.

Por exemplo, vamos criar um array com mil números, que vão de 0 até 4pi. Vamos colocar esses valores no eixo x. Fizemos isso através da função linspace()
Para cada valor desse, vamos calcular seu seno. Por fim, plotamos esses valores:

import matplotlib.pyplot as plt import numpy as np x = np.linspace(0, 4*np.pi, 1000) y = np.sin(x) plt.plot(x,y)

E o resultado é:

Ou seja, essa é a função seno, no intervalo de 0 até 4pi (dois ciclos). Esse gráfico é bem mais realista, pois utilizamos muitos pontos.