Enviar um café pro programador

Mostrando postagens com marcador Gráficos. Mostrar todas as postagens
Mostrando postagens com marcador Gráficos. Mostrar todas as postagens

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.

Gráficos em Python

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.

Tipos de gráfico do Matplotlib

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:

Como criar gráficos em Python

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()

Python para Físicos

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 é:

Como plotar a função trigonométrica seno em Python

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.

Histograma em Python - Como gerar e plotar gráficos

 Neste tutorial, vamos aprender como gerar um gráfico do tipo histograma, através da linguagem de programação Python.

O que é um Histograma

Histograma é um tipo de gráfico, com barras verticais, onde cada uma represente uma classe de valores, e a altura representa a frequência que essa classe aparece no seu conjunto de dados. Numa linguagem mais técnica, representa uma distribuição de frequências.

Por exemplo, um consultório médico criou um histograma, para melhor entender a distribuição de idades dos pacientes:

Como plotar gráficos do tipo Histograma

No eixo x, temos as idades dos pacientes. Cada barra dessas representa uma idade ou intervalo de idades. Já o eixo y representa quantas vezes cada intervalo desses apareceu.

Pelo gráfico, podemos ver que cada barra dessas tem um intervalo próximo de 5 anos. A maior parte dos pacientes, tem por volta dos 20-25 anos e 25-30, pois cada barra que representa esses intervalos apareceu (frequência) mais de 50 vezes. Ou seja, tem mais de 100 pacientes com idade entre 20 e 30 anos.

Pacientes com mais de 90 anos? Bem poucos.
Pacientes com 0-5 anos de idade? Quase 20.

O gráfico do tipo histograma é muito útil quando você tem uma grande quantidade de dados e quer, rápida e facilmente, identificar como está a distribuição de determinados valores desses dados. Por ser uma maneira visual de representar e classificar dados, é muito usada para exibir resultados, seja em trabalhos científicos como em reuniões, por exemplo.

Tipos de Histograma em Python

Como podem imaginar, existe uma infinidade de tipos de gráficos histograma, e cada um deles nos diz informações muito importante sobre os dados que estamos analisando.

E, obviamente, o Python pode nos ajudar muito, mas muito mesmo, nessa tarefa de plotar e analisar.

Experimento do Pêndulo Simples

No laboratório de Física da Universidade Federal do Ceará (UFC), realizei o famoso experimento do pêndulo simples:

Pêndulo simples em Python

Cuja fórmula do período é dada por:

Física com Python

Onde L é o comprimento da corda do pêndulo, e g o valor da gravidade no local, que é 9,78 m/s² dentro do Campus do Pici, local onde foi realizado a medição.

Logo, o valor teórico do período é: T = 2,009141114 s = 2,01s
Vamos usar o mesmo número de algarismos significativos do cronômetro usado, dois.

Os valores que calculei podem ser obtidos em:
https://github.com/jarlissonmoreira/PythonProgressivo/blob/main/Histograma/data.txt

Note que os valores obtidos experimentalmente estão bem próximos do valor teórico. Vamos colocar esses valores em um histograma e ver isso em um gráfico, para confirmar que a maioria das medições estão ali por volta desse valor 2.01s

O meu arquivo tem 135 linhas, divididas em 10 colunas. Mas o script que será apresentado é bem abrangente, você pode colocar seus dados em quaisquer números de linhas e colunas, que ele vai funcionar.

Vamos aprender como usar o script para plotar um histograma.


Como plotar um Histograma em Python

Vamos usar a biblioteca matplotlib e a função hist() dela, para plotar nosso histograma.
Mas, antes, precisamos tratar nossos dados, antes de passar os valores para essa função.

De onde o script vai puxar esses dados? Onde e como você vai armazenar eles? Eles tem vírgula ou ponto, como decimal? Se for vírgula, precisa trocar por ponto. Como estão formatados? Tudo junto? Numa matriz? Em txt ou csv?

Usar as funções é fácil, o que devemos ter cuidado é na hora de tratar os dados.

No script fornecido abaixo, você pode passar os dados de várias maneiras. Eu, por exemplo, coloquei todos os dados no arquivo txt acima mencionado e em seguida usei o endereço desse arquivo "data.txt" (pois o data.txt está na mesma pasta do script histograma.py) para o parâmetro path da minha função plot_histograma().

Se preferir, pode passar diretamente os dados através do parâmetro data (como não usei, coloquei o valor None nele), fornecendo uma string de valores. Obviamente, só é viável se tiver poucos dados.

Por fim, precisamos configurar o bins, que são os intervalos das barras, no eixo x. Eu passei o valor 'auto', para a função hist() fazer o melhor ajuste possível, mas você pode definir manualmente os intervalos que desejar.

Vamos plotar três gráficos. O primeiro, é o histograma da matriz original, com todos os dados, bastando fazer:

  • ax1.hist(array, bins)

Onde array são os dados e bins os intervalos.

No segundo gráfico, vamos calcular as médias de cada linha da matriz. Nossa matriz tem 135 linhas com 10 elementos em cada. Logo, nosso segundo gráfico vai ter 135 elementos. Isso é muito usado em Física Experimental, a média das médias, pois fornecem valores mais confiáveis e próximos do teórico, pois 'amenizam' os resultados muito discrepantes.

Por fim, ploetei os dois gráficos juntos, um na frente do outro, para vermos a diferença.

O resultado ficou:

Script para fazer histograma em Python

Nosso script, usado para gerar esses plots de histogramas, é:

import numpy as np
from matplotlib import pyplot


def plot_histograma(path: str = None, data: str = None, bins: float | str = None) -> None:
    #path: caminho do arquivo .txt com os dados "caminho/do/data.txt"
    #bins: se nao fornecido retorna o histograma dos valores individuais,
    #ele pode ser tamanho (float), ou uma string com valores: 'auto', 'fd', 'doane', 'scott', 'stone', 'rice', 'sturges', or 'sqrt'
    #return: printa na tela o histograma
    
    if path is not None:
        with open(path, "r") as file:
            content = file.read().replace(',', '.')
            values: list[float] = [float(i) for i in content.split()]
    else:
        content = data.replace(',', '.')
        values: list[float] = [float(i) for i in content.split(';')]
   
    array = np.array(values)
    
    if bins is None:
        bins=sorted(values)
       
    if type(bins) is str:
        bins=bins
       
    if type(bins) is float:
        bins = np.arange(array.min(), array.max() + bins, bins)
    
    #Transforma o array/lista de valores em uma matriz com 10 colunas
    col = 10
    lin = int(len(array)/col)
    array2 = array.reshape(lin,col)
    
    #Cria um array, onde cada elemento é uma média de 10 valores,
    #de cada linha da matriz anterior
    median=np.mean(array2, axis=1)
    
    #Novo código para imprimir os três gráficos, com mesmo eixo x
    fig, (ax1, ax2, ax3) = pyplot.subplots(3, 1, sharex=True)

    #Primeiro gráfico, de 1350 medições
    ax1.hist(array, bins)
    ax1.xaxis.set_tick_params(labelbottom=True)
    leg1 = str(lin*col)
    ax1.set_xlabel(leg1+' medições')

    #Segundo gráfico, das 135 médias
    ax2.hist(median,bins)
    ax2.xaxis.set_tick_params(labelbottom=True)
    leg2 = str(len(median))
    ax2.set_xlabel(leg2+' médias')
    
    #Sobrepondo os dois, para efeitos de comparação
    ax3.hist(array, bins, alpha=0.5, label=leg1)
    ax3.hist(median, bins, alpha=0.5, label=leg2)
    ax3.set_xlabel('Gráficos sobrepostos')
    ax3.legend(loc='upper right')
    
    pyplot.tight_layout()
    pyplot.show()

path="data.txt"
data=None
bins='auto'
plot_histograma(path,data,bins)

Regressão Linear em Python - O método dos mínimos quadrados

 Neste tutorial, vamos aprender como aplicar o método dos mínimos quadrados para fazer uma regressão linear em seus dados experimentais.

O que é Regressão Linear

Como o nome pode sugerir, é uma técnica onde tentaremos transformar uma série de dados em uma    linha.

Ela é muito útil para tentarmos estimarmos ou prevermos novos valores, sem precisarmos realizar novamente o experimento.

Por exemplo, vamos supor que os pontos azuis abaixo sejam referente aos experimentos que você realizou em laboratório:

Método dos mínimos quadrados

No exemplo que fizemos, usamos uma mola e várias massas. Para cada massa m, temos um tamanho de mola l. Colocamos a massa no eixo X e o comprimento no eixo Y.

Note na imagem acima, que a maioria dos pontos ficarem mais ou menos alinhados. O que a regressão linear faz é tentar achar uma reta 'ótima', mais próxima desses pontos.

Assim, você pode estimar qual seria o valor de uma mola para uma determinada massa, sem precisar fazer o experimento. Obviamente, é uma aproximação.

Método dos mínimos quadrados

Existem vários métodos e maneiras de se fazer regressão, inclusive de qualquer tipo de curva que você imaginar, não somente de retas.

O método mais conhecido, é o do mínimos quadrados. Veja que existe uma distância de cada bolinha (experimento que você fez) até nossa reta otimizada por regressão linear:

Teoria dos erros método dos mínimos quadrados

O nosso objetivo é pegar essa distância, que  é o erro e minimizar o máximo possível eles, e gerar a reta de equação: 

  • y = A + B.x

Você pode achar a demonstração desse método em livros universitários que falam sobre Teoria dos Erros. As fórmulas para A e B são:

Análise de erros

Dados coletados e fórmula

No laboratório de Física da Universidade Federal do Ceará, pegamos uma mola menor e uma maior (apropriadas para as experiências), colocamos elas pendurada na vertical, e calculamos o tamanho final dela, para cada massa. Fizemos 7 experimentos em cada mola, e o resultado foi:
Experimento de Hooke da mola

Para nosso tutorial, vamos gerar o gráfico para a mola menor. Queremos provar que a lei de Hooke para o sistema massa-mola é obedecido.

Equilíbrio do sistema massa-mola:

  • −k∆x + mg = 0

Nos experimentos, medimos o tamanho l final da mola, que é obtido pela expressão acima:

  • L = Lo + (k/g)*m

Vamos fazer a regressão linear dessa fórmula, através do método dos mínimos quadrados, com a reta:

  • y = A + Bx
Onde:

y ⇔ l

x ⇔ m

Regressão Linear: Fazendo os Cálculos e gráficos

Obviamente, existe tudo isso (e muito mais) prontinho em Python, para ser usado. Bastando só inserir seus dados e ele vai fazer tudo. Mas, provavelmente seu professor vai pedir que você faça isso 'na mão', pelo menos a primeira vez.

E isso é o correto. Implementar, na unha, as coisas vai te fazer um cientista ou engenheiro bem mais capacitado, vai te fazer entender melhor como as coisas funcionam e caso precise mudar algo, vai poder mexer no código e na matemática.

É muito importante, principalmente para TCC, mestrado, doutorado etc, entender bem o que está ocorrendo, pois você pode ter que fazer algo novo, para seu trabalho.

Então vamos, lá.

Primeiro, importamos a biblioteca numpy (para os cálculos) e a matplotlib.pyplot (para gerar o gráfico). 

Depois, criamos dois arrays, um com as massas (massa,em gramas) e outro com o valor das distensões da mola (delta_x, em centímetros), medidos no laboratório. 

Seja L0 o comprimento inicial da mola, então os comprimentos finais serão dados por L0 + delta_x

Como fizemos 7 medições, N=7. E agora é só fazer os cálculos das fórmulas de A e B.
Fizemos cada uma separadamente, para melhor entender, e depois jogamos tudo para ter as variáveis A e B. Por fim, geramos o array y com os novos dos comprimentos estimados, parar gerar a reta.

Colocamos, para aqueles que desejarem, o cálculo das incertezas de A, B, y e da constante da mola. Lembrando que o parâmetro A fica em centímetros e B fica com cm/gramas.

Como a gravidade usada é 9.8 m/s², não se esqueça de passar as outras unidades para o SI.

Nossos dados experimentais, os pontos, foram plotados com a scatter (dispersão), depois usamos uma reta pontilhada para plotar a linha da regressão, e por fim um gráfico de erros.


Note que, ao final do script, coloquei vários prints, para ir exibindo os valores das variáveis e cálculos realizados, uma etapa importante para você ir acompanhando e conferindo se está tudo ok. É muito fácil e comum cometermos erros ao longo do desenvolvimento de scripts para assuntos científicos.

Nosso script fica:

import numpy as np
import matplotlib.pyplot as plt

# Massas(em gramas) e respectivas Distensões da mola deltax (em centímetros)
massa = np.array([10.7, 20.6, 30.8, 41.1, 50.9, 60.8, 71.2])
delta_x = np.array([6.4, 8.0, 8.8, 10.0, 11.0, 12.8, 13.5])

#Comprimentos totais da mola
L0 = 5.0
L = L0 + delta_x

# Seja: l = l0 + Bm a equação da reta que relaciona o tamanho
# final da mola (l), com seu tamanho inicial (l0) e o valor da massa (m)
# B representa a constante g/k (onde g é a acelaração da gravidade) e k
# a constante da mola

## Regressão linear: y = A + Bx
# x é a massa e y é o l

# Número de experimentos
N = 7

# Somatório de x[i] (massas)
S_m = massa.sum()

# Somatório de l[i] (comprimentos)
S_l = L.sum()

# Somatório dos quadrados x²[i] das massas
S_m2 = sum(i*i for i in massa)

# Somatório dos quadrados dos comprimentos l²[i]
S_l2 = sum(i*i for i in L)

# Somatório dos produtos de cada massa pelo seu respectivo comprimento final m[i]*l[i]
S_ml = 0.0
for i in range(N):
  S_ml = S_ml + massa[i]*L[i]

# Colocando tudo na fórmula
delta = N*S_m2 - (S_m*S_m)
A = ((S_m2 * S_l) - S_m * S_ml)/(delta)
B = ((N*S_ml) - S_m * S_l)/(delta)

# Reta com os novos valores, Yi
y = np.array(A + B*massa)

# Incerteza de y, A e B, com uma unidade de incerteza
residuo=0.0
y=y.round(1)
A=round(A,1)
B=round(B,1)

for i in range(N):
  residuo = residuo + np.power(y[i] - A - B*massa[i], 2)

dy = round(np.sqrt(residuo/(N-2)),1)
dA = round(dy * np.sqrt(S_m2/delta),1)
dB = round(dy * np.sqrt(N/delta),1)

# B e seu erro dB estão em centimetros/gramas = 10 metros/kilogramas
B_kgm = B*10.0
dB_kgm = dB*10.0

# Constante da mola, e seu erro propagado de B
# pois B = g/k
K = 9.8/B_kgm
dK = dB_kgm * ( 9.8/(B_kgm*B_kgm) )

# Gerando o gráfico
fig, ax = plt.subplots()
fig.suptitle('Massa(g) x Tamanho da mola (cm)')
plt.rcParams.update({'font.size': 12})

ax.title.set_text('Curso Python Progressivo')
ax.scatter(massa, L, marker='.', s=1)
ax.plot(massa, y, color='red', linestyle='--', label='reta mmq')
ax.errorbar(massa, L, yerr=dy, fmt='.k', label='dados experimentais')
ax.legend(loc="lower right")
plt.show()


print("Somatorio das massas: ", S_m)
print("Somatorio quadrado das massas: ", S_m2)
print("Somatorio comprimento: ", S_l)
print("Somatorio quadrado do scomprimentos: ", S_l2)
print("Somatorio massa pelo comprimento menores: ", S_ml)
print("Delta: ", delta)
print("A: %.2f cm"% A)
print("B: %.2f cm/g"% B)
print("Reta da mola: y = %.1f + %.1f*m" % (A, B))
print("Erro y: ", dy)
print("Erro A: ", dA)
print("Erro B: ", dB)
print("Constante: ", K)
print("Erro de k: ", dK)
print("K = %.1f +- %.1f" %(K, dK))

Gráfico da regressão linear:

Método dos mínimos quadrados em Python


Código no github:

https://github.com/jarlissonmoreira/PythonProgressivo/blob/main/Regressao%20Linear/RegressaoLinear.py


Regressão Linear usando a biblioteca SciPy

Agora vamos deixar o Python fazer (quase) tudo por nós. Para isso, importamos a biblioteca SciPy, e desde o conjunto de funções stats, onde iremos uar a função linregress para fazer a regressão linear de nossos dados.

Lembre-se: você vai precisar de dois conjuntos de valores de mesmo tamanho, para passar para a linregress. Essa função retorna um conjunto de parâmetros, como o A e B (intercept e slope), previamente calculados, além de outros, como erros padrões.

Nosso código fica:

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats

def func(x):
  return result.slope * x + result.intercept

# Massas(g) e respectivas Distensões da mola (cm)
massa = np.array([10.7, 20.6, 30.8, 41.1, 50.9, 60.8, 71.2])
delta_x = np.array([6.4, 8.0, 8.8, 10.0, 11.0, 12.8, 13.5])

# Comprimento total da mola
L0=5.0
L = np.array(L0 + delta_x)

# Armazenando os parametros
# Retorna a tupla com: B(coefieciente angular da reta), intercept (A, onde toca o eixo x), 
# rvalue (coeficiente Pearson de correlação), pvalue (valor-p da probabilidade), 
# stderr (erro padrão do parâmetro slope), intercept_stderr (erro padrão do parâmetro intercept)
result = stats.linregress(massa, L)

modelo = list(map(func, massa))

# Gerando o gráfico
fig, ax = plt.subplots()
fig.suptitle('Massa(g) x Tamanho da mola (cm), com SciPy')
plt.rcParams.update({'font.size': 12})
ax.title.set_text('Curso Python Progressivo')
ax.scatter(massa, L, marker='.')
ax.plot(massa, modelo, color='red', linestyle='--', label='reta mmq')
plt.show()

## Imprimindo os dados
print("B (coeficiente angular): ",result.slope)
print("A (onde incercepta o eixo x): ", result.intercept)
print("rvalue : ", result.rvalue)
print("pvalue : ", result.pvalue)
print("stderr (erro padrão do slope, B): ", result.stderr)
print("intercept_stderr (erro padrão do incercept, A): ",result.intercept_stderr)

E o gráfico:

SciPy, stats e linregress

Ao final, imprimimos os valores calculados pela linregress(). Veja que os valores de A e B realmente bateram com aqueles que calculamos antes. Porém, não deu exato, pois em nossos cálculos tivemos o cuidado de arredondar para uma casa decimal, pois nossas medições tinham apenas uma casa decimal. Sempre tomem cuidado com os algoritmos significativos.