Arquivo de Python - Página 10 de 31

O que é inferência bayesiana?

Inferência bayesiana é o processo de atualizar crenças sobre parâmetros ou hipóteses com base em dados observados. Ela usa o teorema de Bayes como regra fundamental de atualização: P(θ|D) ∝ P(D|θ) * P(θ). Aqui, P(θ) é a crença prévia (prior) antes de ver os dados. P(D|θ) é a verossimilhança, que mede quão prováveis são os dados dado θ. O resultado P(θ|D) é a distribuição a posteriori, que combina prior e dados. Diferentemente da estatística frequentista, ela trata θ como uma variável aleatória. Isso permite quantificar a incerteza diretamente em intervalos de credibilidade. A inferência bayesiana é sequencial: a posterior de hoje é o prior de amanhã. Portanto, ela é naturalmente adaptativa e robusta a amostras pequenas.

Características fundamentais

A inferência bayesiana possui três pilares conceituais que a definem. Primeiro, a escolha do prior é subjetiva, mas pode ser não-informativa (uniforme). Segundo, a verossimilhança encapsula o modelo gerador dos dados observados. Terceiro, a posteriori é atualizada pela regra de Bayes quando novos dados chegam. A inferência exata é possível para modelos conjugados (prior e verossimilhança compatíveis). Para modelos complexos, usam-se métodos aproximados como MCMC ou variational inference. A inferência bayesiana também fornece predições através da distribuição preditiva. Ela integra a incerteza dos parâmetros ao fazer previsões para novos dados.

Vantagens e aplicações típicas

A principal vantagem é a quantificação completa da incerteza em todas as estimativas. Isso é crucial em áreas como medicina, finanças e engenharia de segurança. Além disso, ela permite incorporar conhecimento especialista através do prior. Ela é usada em aprendizado de máquina (regressão bayesiana, redes bayesianas). Também é aplicada em testes A/B, controle de qualidade e otimização bayesiana. Contudo, a escolha do prior pode ser controversa e influenciar os resultados.

A inferência bayesiana é uma das bases da estatística moderna e da IA. Ela contrasta com a abordagem frequentista, que usa apenas a verossimilhança. Na prática, a posteriori é frequentemente resumida por sua média e desvio-padrão. Intervalos de credibilidade de 95% são análogos aos intervalos de confiança, mas mais intuitivos. A inferência preditiva calcula P(D_novo | D) = ∫ P(D_novo | θ) P(θ|D) dθ. Isso naturalmente penaliza modelos complexos (princípio da navalha de Occam). A inferência bayesiana também lida com dados faltantes por imputação probabilística. Métodos de Monte Carlo via cadeias de Markov (MCMC) são amplamente usados. Eles amostram da posteriori sem precisar de formas analíticas fechadas. Bibliotecas como PyMC3 e Stan automatizam esse processo para usuários. A inferência variacional é uma alternativa mais rápida para grandes conjuntos. Ela aproxima a posteriori por uma família paramétrica simples (ex.: normal). A escolha do método depende do tamanho dos dados e da complexidade do modelo. Assim, a inferência bayesiana é flexível, poderosa e cada vez mais acessível.

Um exemplo clássico é estimar a probabilidade de uma moeda dar cara. Antes de jogar, acreditamos que a moeda é justa (prior Beta(1,1) uniforme). Jogamos 10 vezes e observamos 7 caras. A verossimilhança é binomial. A posteriori é Beta(1+7, 1+3) = Beta(8,4), com média 8/12 = 0.667. Esse exemplo ilustra como a crença é atualizada com dados observados.

Enunciado do exemplo clássico

Implemente a inferência bayesiana para estimar a taxa de conversão de um site. Prior: Beta(1,1) (uniforme). Dados: 50 visitantes, 15 conversões. Calcule a posteriori Beta(1+15, 1+35) e plote-a. Calcule a probabilidade de que a taxa de conversão seja > 0.25. Plote também a verossimilhança e o prior no mesmo gráfico para comparação. Use a biblioteca scipy.stats para as distribuições Beta.

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

# Dados  
n_visitas = 50  
n_conversoes = 15  
# Prior: Beta(1,1) -> uniforme em [0,1]  
alpha_prior = 1  
beta_prior = 1  

# Posterior: Beta(alpha_prior + conversoes, beta_prior + n_visitas - conversoes)  
alpha_post = alpha_prior + n_conversoes  
beta_post = beta_prior + n_visitas - n_conversoes  

# Gerar valores de taxa de conversão (0 a 1)  
x = np.linspace(0, 1, 500)  

# Calcular densidades  
prior_pdf = beta.pdf(x, alpha_prior, beta_prior)  
likelihood = beta.pdf(x, n_conversoes + 1, n_visitas - n_conversoes + 1)  # verossimilhança normalizada (Beta)  
posterior_pdf = beta.pdf(x, alpha_post, beta_post)  

# Calcular P(taxa > 0.25) a posteriori  
prob_maior_25 = 1 - beta.cdf(0.25, alpha_post, beta_post)  
print(f"Probabilidade (taxa > 0.25) = {prob_maior_25:.4f}")  

# Média e intervalo de credibilidade de 95%  
media = alpha_post / (alpha_post + beta_post)  
ic_inf, ic_sup = beta.ppf(0.025, alpha_post, beta_post), beta.ppf(0.975, alpha_post, beta_post)  
print(f"Média posterior: {media:.4f}")  
print(f"IC 95%: [{ic_inf:.4f}, {ic_sup:.4f}]")  

# Plotar  
plt.figure(figsize=(12, 5))  

plt.subplot(1, 2, 1)  
plt.plot(x, prior_pdf, 'g--', linewidth=2, label='Prior Beta(1,1)')  
plt.plot(x, likelihood, 'y--', linewidth=2, label='Verossimilhança (normalizada)')  
plt.plot(x, posterior_pdf, 'b-', linewidth=3, label='Posterior Beta(16,36)')  
plt.fill_between(x, 0, posterior_pdf, where=(x > 0.25), color='red', alpha=0.3, label='P(taxa>0.25)')  
plt.axvline(0.25, color='red', linestyle=':', label='Limiar 0.25')  
plt.xlabel('Taxa de conversão')  
plt.ylabel('Densidade de probabilidade')  
plt.title('Inferência Bayesiana - Taxa de Conversão')  
plt.legend()  
plt.grid(True)  

plt.subplot(1, 2, 2)  
# Mostrar resumo numérico  
texto = (f"Dados: {n_conversoes} conversões em {n_visitas} visitas\n"  
         f"Prior: Beta(1,1)\n"  
         f"Posterior: Beta({alpha_post}, {beta_post})\n"  
         f"Média: {media:.4f}\n"  
         f"IC 95%: [{ic_inf:.3f}, {ic_sup:.3f}]\n"  
         f"P(taxa > 0.25) = {prob_maior_25:.3f}")  
plt.text(0.1, 0.5, texto, fontsize=14, family='monospace',  
         bbox=dict(facecolor='lightyellow', alpha=0.9))  
plt.axis('off')  
plt.title('Resumo da Inferência')  

plt.tight_layout()  
plt.show()

import numpy as np

import matplotlib.pyplot as plt

from scipy.stats import beta

# Dados

n_visitas = 50

n_conversoes = 15

# Prior: Beta(1,1) -> uniforme em [0,1]

alpha_prior = 1

beta_prior = 1

# Posterior: Beta(alpha_prior + conversoes, beta_prior + n_visitas - conversoes)

alpha_post = alpha_prior + n_conversoes

beta_post = beta_prior + n_visitas - n_conversoes

# Gerar valores de taxa de conversão (0 a 1)

x = np.linspace(0, 1, 500)

# Calcular densidades

prior_pdf = beta.pdf(x, alpha_prior, beta_prior)

likelihood = beta.pdf(x, n_conversoes + 1, n_visitas - n_conversoes + 1) # verossimilhança normalizada (Beta)

posterior_pdf = beta.pdf(x, alpha_post, beta_post)

# Calcular P(taxa > 0.25) a posteriori

prob_maior_25 = 1 - beta.cdf(0.25, alpha_post, beta_post)

print(f"Probabilidade (taxa > 0.25) = {prob_maior_25:.4f}")

# Média e intervalo de credibilidade de 95%

media = alpha_post / (alpha_post + beta_post)

ic_inf, ic_sup = beta.ppf(0.025, alpha_post, beta_post), beta.ppf(0.975, alpha_post, beta_post)

print(f"Média posterior: {media:.4f}")

print(f"IC 95%: [{ic_inf:.4f}, {ic_sup:.4f}]")

# Plotar

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)

plt.plot(x, prior_pdf, 'g--', linewidth=2, label='Prior Beta(1,1)')

plt.plot(x, likelihood, 'y--', linewidth=2, label='Verossimilhança (normalizada)')

plt.plot(x, posterior_pdf, 'b-', linewidth=3, label='Posterior Beta(16,36)')

plt.fill_between(x, 0, posterior_pdf, where=(x > 0.25), color='red', alpha=0.3, label='P(taxa>0.25)')

plt.axvline(0.25, color='red', linestyle=':', label='Limiar 0.25')

plt.xlabel('Taxa de conversão')

plt.ylabel('Densidade de probabilidade')

plt.title('Inferência Bayesiana - Taxa de Conversão')

plt.legend()

plt.grid(True)

plt.subplot(1, 2, 2)

# Mostrar resumo numérico

texto = (f"Dados: {n_conversoes} conversões em {n_visitas} visitas\n"

f"Prior: Beta(1,1)\n"

f"Posterior: Beta({alpha_post}, {beta_post})\n"

f"Média: {media:.4f}\n"

f"IC 95%: [{ic_inf:.3f}, {ic_sup:.3f}]\n"

f"P(taxa > 0.25) = {prob_maior_25:.3f}")

plt.text(0.1, 0.5, texto, fontsize=14, family='monospace',

bbox=dict(facecolor='lightyellow', alpha=0.9))

plt.axis('off')

plt.title('Resumo da Inferência')

plt.tight_layout()

plt.show()

Este código demonstra a inferência bayesiana com prior conjugado Beta-Binomial. A posteriori combina o prior uniforme com a verossimilhança dos dados observados. A área sombreada em vermelho mostra a probabilidade de a taxa ser maior que 0.25. O intervalo de credibilidade fornece uma faixa plausível para a taxa real. Para iniciantes, este exemplo ilustra o poder da atualização de crenças. A inferência bayesiana é, portanto, uma ferramenta fundamental para decisão sob incerteza.

O que são redes bayesianas dinâmicas (DBN)?

Redes bayesianas dinâmicas (DBN) são modelos probabilísticos para dados sequenciais ou temporais. Elas estendem redes bayesianas estáticas com arestas que cruzam instantes de tempo. Cada fatia de tempo contém um conjunto de variáveis (estado) no instante t. Arestas dentro da mesma fatia representam dependências instantâneas. Arestas entre fatias consecutivas modelam transições de estado (Markovianas). A suposição básica é a de Markov de primeira ordem: o futuro depende apenas do presente. Além disso, as transições são estacionárias (invariantes no tempo) na maioria das aplicações. A distribuição conjunta é fatorada como: P(X₀) * ∏ P(Xₜ | Xₜ₋₁). DBNs são usadas em previsão, filtragem, suavização e reconhecimento de padrões.

Características fundamentais

As DBNs possuem três características principais que as definem. Primeiro, elas combinam modelos ocultos de Markov (HMM) com redes bayesianas. Segundo, a inferência é feita por algoritmos de propagação em árvores de junção. Terceiro, a aprendizagem pode ser feita por EM (expectation-maximization) para parâmetros. A estrutura pode ser aprendida com algoritmos de busca temporal. Além disso, DBNs suportam variáveis observadas e latentes (não observadas). Elas também lidam com dados com intervalos irregulares usando modelos contínuos.

Vantagens e aplicações típicas

A principal vantagem é a capacidade de modelar dependências temporais complexas. Elas são usadas em reconhecimento de fala, rastreamento de objetos e bioinformática. Também são aplicadas em análise de séries financeiras e monitoramento de pacientes. Outra vantagem é a interpretabilidade das transições de estado. Contudo, a complexidade computacional cresce com o horizonte temporal.

DBNs generalizam modelos como HMMs e filtros de Kalman. Em um HMM, a variável latente é discreta e a observação pode ser contínua. Em uma DBN, múltiplas variáveis latentes podem interagir dentro de cada fatia. Por exemplo, em um sistema de navegação, posição e velocidade são latentes. A observação pode ser GPS ruidoso, e a transição segue leis da física. A inferência em DBNs é frequentemente feita por filtragem de partículas. Isso é especialmente útil quando as distribuições não são gaussianas. Para DBNs lineares-gaussianas, o filtro de Kalman é a solução exata. A suavização (estimar estados passados com dados futuros) é feita por retrocesso. Algoritmos como forward-backward para HMMs são casos especiais. A aprendizagem de estrutura em DBNs é mais desafiadora que em redes estáticas. Ela requer considerar todas as possíveis conexões entre fatias. Heurísticas como restrição de espessura (apenas arestas entre t-1 e t) são comuns. Assim, DBNs são ferramentas versáteis para dados que evoluem no tempo.

Um exemplo clássico é o modelo de chuva diária com duas variáveis latentes: Chuva (Rₜ) e Irrigação (Iₜ), e uma observação: Gramado Molhado (Gₜ). A chuva no dia t depende da chuva no dia anterior (transição Markoviana). A irrigação é independente da chuva, mas ambas influenciam o gramado. A DBN permite prever Gₜ₊₁ dado observações passadas de G.

Enunciado do exemplo clássico

Implemente uma DBN para o problema do clima com 2 variáveis latentes binárias: Nuvem (Nₜ) e Chuva (Rₜ), e uma observação: Temperatura (Tₜ – contínua). Transições: Nₜ depende de Nₜ₋₁; Rₜ depende de Nₜ e Rₜ₋₁. Observação: Tₜ ~ N(10 + 5*Nₜ + 10*Rₜ, 2). Use 50 passos de tempo, com N₀ e R₀ com priores uniformes. Calcule a filtragem (P(Nₜ, Rₜ | T₁..Tₜ)) e plote a probabilidade de chuva ao longo do tempo.

import numpy as np  
import matplotlib.pyplot as plt  

# Parâmetros da DBN (discretos para N e R, contínuo para T)  
# Estados: N e R binários (0/1)  
# Priores iniciais  
P_N0 = {0: 0.5, 1: 0.5}  
P_R0_dado_N0 = {  
    (0,0): 0.8, (0,1): 0.2,  # N0=0, R0=0/1  
    (1,0): 0.3, (1,1): 0.7   # N0=1, R0=0/1  
}  

# Transições: P(Nₜ | Nₜ₋₁)  
P_N_dado_N_ant = {  
    (0,0): 0.7, (0,1): 0.3,  # N_ant=0, N=0/1  
    (1,0): 0.2, (1,1): 0.8   # N_ant=1, N=0/1  
}  
# P(Rₜ | Nₜ, Rₜ₋₁)  
P_R_dado_N_Rant = {  
    (0,0,0): 0.6, (0,0,1): 0.4,  # N=0, R_ant=0  
    (0,1,0): 0.9, (0,1,1): 0.1,  # N=0, R_ant=1  
    (1,0,0): 0.3, (1,0,1): 0.7,  # N=1, R_ant=0  
    (1,1,0): 0.2, (1,1,1): 0.8   # N=1, R_ant=1  
}  

# Observação: T ~ N(10 + 5*N + 10*R, sigma²=2)  
def obs_likelihood(t, n, r):  
    mu = 10 + 5*n + 10*r  
    sigma = np.sqrt(2)  
    return (1/(np.sqrt(2*np.pi)*sigma)) * np.exp(-0.5*((t-mu)/sigma)**2)  

# Gerar sequência sintética de 50 passos  
np.random.seed(42)  
T = 50  
N = np.zeros(T, dtype=int)  
R = np.zeros(T, dtype=int)  
Temp = np.zeros(T)  

# Inicializar  
N[0] = 1 if np.random.random() < P_N0[1] else 0  
R[0] = 1 if np.random.random() < P_R0_dado_N0[(N[0],1)] else 0  
Temp[0] = 10 + 5*N[0] + 10*R[0] + np.random.normal(0, np.sqrt(2))  

for t in range(1, T):  
    # Transição de N  
    prob = P_N_dado_N_ant[(N[t-1], 1)]  
    N[t] = 1 if np.random.random() < prob else 0  
    # Transição de R  
    prob_r = P_R_dado_N_Rant[(N[t], R[t-1], 1)]  
    R[t] = 1 if np.random.random() < prob_r else 0  
    # Observação  
    Temp[t] = 10 + 5*N[t] + 10*R[t] + np.random.normal(0, np.sqrt(2))  

# Filtragem por enumeracao (forward) para estados discretos  
# Mantemos distribuição P(N_t, R_t | obs 1..t)  
filtro = np.zeros((T, 2, 2))  # [tempo][N][R]  

# Inicialização  
for n in (0,1):  
    for r in (0,1):  
        filtro[0, n, r] = P_N0[n] * P_R0_dado_N0[(n,r)] * obs_likelihood(Temp[0], n, r)  
# Normalizar  
filtro[0] /= filtro[0].sum()  

# Passo recursivo  
for t in range(1, T):  
    for n in (0,1):  
        for r in (0,1):  
            soma = 0.0  
            for n_ant in (0,1):  
                for r_ant in (0,1):  
                    # P(N_t=n, R_t=r | N_{t-1}=n_ant, R_{t-1}=r_ant)  
                    # = P(N_t | N_ant) * P(R_t | N_t, R_ant)  
                    trans = P_N_dado_N_ant[(n_ant, n)] * P_R_dado_N_Rant[(n, r_ant, r)]  
                    soma += filtro[t-1, n_ant, r_ant] * trans  
            filtro[t, n, r] = soma * obs_likelihood(Temp[t], n, r)  
    filtro[t] /= filtro[t].sum()  

# Probabilidade marginal de chuva R_t = 1  
P_chuva = filtro[:, :, 1].sum(axis=1)  

# Plotar  
plt.figure(figsize=(12, 4))  
plt.subplot(1, 2, 1)  
plt.plot(range(T), P_chuva, 'b-', linewidth=2, label='P(R_t=1 | obs)')  
plt.plot(range(T), R, 'r--', linewidth=1.5, label='Chuva real (latente)')  
plt.xlabel('Tempo')  
plt.ylabel('Probabilidade de chuva')  
plt.title('Filtragem - Probabilidade de Chuva')  
plt.legend()  
plt.grid(True)  

plt.subplot(1, 2, 2)  
plt.plot(range(T), Temp, 'g-', linewidth=1.5, label='Temperatura observada')  
plt.xlabel('Tempo')  
plt.ylabel('Temperatura')  
plt.title('Série Temporal Observada')  
plt.legend()  
plt.grid(True)  
plt.tight_layout()  
plt.show()  

print("Probabilidade média de chuva (filtrada):", np.mean(P_chuva))  
print("Frequência real de chuva:", np.mean(R))

100

101

102

103

104

import numpy as np

import matplotlib.pyplot as plt

# Parâmetros da DBN (discretos para N e R, contínuo para T)

# Estados: N e R binários (0/1)

# Priores iniciais

P_N0 = {0: 0.5, 1: 0.5}

P_R0_dado_N0 = {

(0,0): 0.8, (0,1): 0.2, # N0=0, R0=0/1

(1,0): 0.3, (1,1): 0.7 # N0=1, R0=0/1

}

# Transições: P(Nₜ | Nₜ₋₁)

P_N_dado_N_ant = {

(0,0): 0.7, (0,1): 0.3, # N_ant=0, N=0/1

(1,0): 0.2, (1,1): 0.8 # N_ant=1, N=0/1

}

# P(Rₜ | Nₜ, Rₜ₋₁)

P_R_dado_N_Rant = {

(0,0,0): 0.6, (0,0,1): 0.4, # N=0, R_ant=0

(0,1,0): 0.9, (0,1,1): 0.1, # N=0, R_ant=1

(1,0,0): 0.3, (1,0,1): 0.7, # N=1, R_ant=0

(1,1,0): 0.2, (1,1,1): 0.8 # N=1, R_ant=1

}

# Observação: T ~ N(10 + 5*N + 10*R, sigma²=2)

def obs_likelihood(t, n, r):

mu = 10 + 5*n + 10*r

sigma = np.sqrt(2)

return (1/(np.sqrt(2*np.pi)*sigma)) * np.exp(-0.5*((t-mu)/sigma)**2)

# Gerar sequência sintética de 50 passos

np.random.seed(42)

T = 50

N = np.zeros(T, dtype=int)

R = np.zeros(T, dtype=int)

Temp = np.zeros(T)

# Inicializar

N[0] = 1 if np.random.random() < P_N0[1] else 0

R[0] = 1 if np.random.random() < P_R0_dado_N0[(N[0],1)] else 0

Temp[0] = 10 + 5*N[0] + 10*R[0] + np.random.normal(0, np.sqrt(2))

for t in range(1, T):

# Transição de N

prob = P_N_dado_N_ant[(N[t-1], 1)]

N[t] = 1 if np.random.random() < prob else 0

# Transição de R

prob_r = P_R_dado_N_Rant[(N[t], R[t-1], 1)]

R[t] = 1 if np.random.random() < prob_r else 0

# Observação

Temp[t] = 10 + 5*N[t] + 10*R[t] + np.random.normal(0, np.sqrt(2))

# Filtragem por enumeracao (forward) para estados discretos

# Mantemos distribuição P(N_t, R_t | obs 1..t)

filtro = np.zeros((T, 2, 2)) # [tempo][N][R]

# Inicialização

for n in (0,1):

for r in (0,1):

filtro[0, n, r] = P_N0[n] * P_R0_dado_N0[(n,r)] * obs_likelihood(Temp[0], n, r)

# Normalizar

filtro[0] /= filtro[0].sum()

# Passo recursivo

for t in range(1, T):

for n in (0,1):

for r in (0,1):

soma = 0.0

for n_ant in (0,1):

for r_ant in (0,1):

# P(N_t=n, R_t=r | N_{t-1}=n_ant, R_{t-1}=r_ant)

# = P(N_t | N_ant) * P(R_t | N_t, R_ant)

trans = P_N_dado_N_ant[(n_ant, n)] * P_R_dado_N_Rant[(n, r_ant, r)]

soma += filtro[t-1, n_ant, r_ant] * trans

filtro[t, n, r] = soma * obs_likelihood(Temp[t], n, r)

filtro[t] /= filtro[t].sum()

# Probabilidade marginal de chuva R_t = 1

P_chuva = filtro[:, :, 1].sum(axis=1)

# Plotar

plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)

plt.plot(range(T), P_chuva, 'b-', linewidth=2, label='P(R_t=1 | obs)')

plt.plot(range(T), R, 'r--', linewidth=1.5, label='Chuva real (latente)')

plt.xlabel('Tempo')

plt.ylabel('Probabilidade de chuva')

plt.title('Filtragem - Probabilidade de Chuva')

plt.legend()

plt.grid(True)

plt.subplot(1, 2, 2)

plt.plot(range(T), Temp, 'g-', linewidth=1.5, label='Temperatura observada')

plt.xlabel('Tempo')

plt.ylabel('Temperatura')

plt.title('Série Temporal Observada')

plt.legend()

plt.grid(True)

plt.tight_layout()

plt.show()

print("Probabilidade média de chuva (filtrada):", np.mean(P_chuva))

print("Frequência real de chuva:", np.mean(R))

Este código implementa uma DBN com filtragem por enumeração exata. A probabilidade de chuva filtrada acompanha bem a chuva real latente. A temperatura observada é a única entrada disponível para o modelo. A estrutura Markoviana permite atualizar crenças a cada novo dado. Para iniciantes, este exemplo mostra o poder das DBNs em séries temporais. Redes bayesianas dinâmicas são, portanto, essenciais para dados sequenciais.