Arquivo de Python - Página 4 de 31

Aprendizado Bayesiano

16/07/202618/06/2026 Por antonino

O que é aprendizado bayesiano?

Aprendizado bayesiano é o processo de atualizar crenças sobre parâmetros ou modelos usando dados observados. Ele combina conhecimento prévio (prior) com a verossimilhança dos dados para obter a distribuição a posteriori. Diferentemente do aprendizado frequencista, ele produz distribuições completas, não estimativas pontuais. O aprendizado é sequencial: a cada novo dado, a posteriori vira o novo prior. Isso permite adaptação contínua e online, sem necessidade de reprocessar todo o histórico. O aprendizado bayesiano também fornece medidas de incerteza (intervalos de credibilidade). Ele é usado em regressão, classificação, agrupamento e seleção de modelos. A abordagem é naturalmente regularizada, evitando overfitting em dados pequenos.

Características fundamentais do aprendizado bayesiano

O aprendizado bayesiano possui três características principais que o distinguem. Primeiro, ele trata todos os parâmetros como variáveis aleatórias com distribuições. Segundo, ele usa o teorema de Bayes como única regra de atualização. Terceiro, ele permite a comparação formal de modelos via fator de Bayes. O aprendizado é baseado em inferência, não em otimização de uma função de perda. Ele incorpora automaticamente o princípio da navalha de Occam (modelos mais simples têm prior maior).

Vantagens e aplicações típicas

A principal vantagem é a robustez a dados escassos e a incerteza quantificada. Ele é usado em medicina, finanças, climatologia e aprendizado de máquina. Também é aplicado em sistemas de recomendação e análise de sobrevivência. Contudo, o custo computacional pode ser alto para modelos complexos.

O aprendizado bayesiano é a base de métodos como regressão linear bayesiana e redes neurais bayesianas. Na regressão linear, a posteriori dos coeficientes é uma distribuição normal (com prior normal conjugado). A predição é feita integrando a incerteza dos coeficientes, resultando em intervalos de previsão. A seleção de modelos é feita por comparação de evidências (verossimilhança marginal). O fator de Bayes é a razão entre as evidências de dois modelos concorrentes. Ele penaliza modelos desnecessariamente complexos, evitando overfitting. O aprendizado bayesiano também é usado em otimização de hiperparâmetros (otimização bayesiana). A cada iteração, um modelo substituto (ex.: Gaussian Process) guia a busca. Em redes neurais, o aprendizado bayesiano (via MCMC ou variação) fornece incerteza nas previsões. Isso é crucial para sistemas de segurança críticos (ex.: veículos autônomos). O aprendizado bayesiano também permite aprendizado ativo: escolher quais dados rotular. A aquisição de dados é guiada pela redução esperada da incerteza. Ele também é usado em aprendizado por reforço para explorar com confiança. Assim, o aprendizado bayesiano é um paradigma flexível e poderoso para ciência de dados.

Um exemplo clássico é a regressão linear com dados de temperatura. Prior nos coeficientes é normal com média zero (regularização). Dados observados atualizam a posteriori, que prediz novas temperaturas com intervalo de credibilidade. O aprendizado bayesiano mostra como a incerteza diminui com mais dados.

Enunciado do exemplo clássico

Implemente a regressão linear bayesiana com prior normal conjugado para um conjunto sintético. Dados: y = 2*x + 1 + ruído N(0, 0.5) para x em [0, 5] com 30 pontos. Prior: coeficiente (inclinação) ~ N(0, 10), intercepto ~ N(0, 10). Calcule a distribuição a posteriori dos coeficientes e faça predições com intervalos de credibilidade. Plote os dados, a reta verdadeira, a predição média e a banda de 95% de credibilidade.

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

# Gerar dados sintéticos  
np.random.seed(42)  
n = 30  
x = np.linspace(0, 5, n)  
erro = np.random.normal(0, 0.5, n)  
y_real = 2 * x + 1  
y = y_real + erro  

# Regressão linear bayesiana com prior normal conjugado  
# Modelo: y = w0 + w1 * x + ruído, com precisão alpha = 1/sigma²  
# Prior: w ~ N(0, Sigma_prior) com Sigma_prior = diag(10, 10)  

# Construir matriz de design (coluna de 1s para intercepto)  
X = np.vstack([np.ones(n), x]).T  

# Parâmetros  
alpha = 1.0 / (0.5**2)  # precisão do ruído (conhecida)  
Sigma_prior = np.diag([10.0, 10.0])  
mu_prior = np.array([0.0, 0.0])  

# Posteriori: w | dados ~ N(mu_post, Sigma_post)  
Sigma_post = np.linalg.inv(Sigma_prior + alpha * X.T @ X)  
mu_post = Sigma_post @ (np.linalg.inv(Sigma_prior) @ mu_prior + alpha * X.T @ y)  

print("Média a posteriori dos coeficientes:")  
print(f"  Intercepto: {mu_post[0]:.3f}")  
print(f"  Inclinação: {mu_post[1]:.3f}")  
print("\nMatriz de covariância a posteriori:")  
print(Sigma_post)  

# Predição para novos pontos (x_test)  
x_test = np.linspace(-0.5, 5.5, 100)  
X_test = np.vstack([np.ones(len(x_test)), x_test]).T  

# Média preditiva  
y_pred_mean = X_test @ mu_post  

# Variância preditiva: var(y_pred) = X_test @ Sigma_post @ X_test.T + 1/alpha  
# (inclui incerteza dos coeficientes + ruído)  
var_pred = np.diag(X_test @ Sigma_post @ X_test.T) + 1/alpha  
std_pred = np.sqrt(var_pred)  

# Intervalos de credibilidade de 95%  
lim_inf = y_pred_mean - 1.96 * std_pred  
lim_sup = y_pred_mean + 1.96 * std_pred  

# Gráficos  
plt.figure(figsize=(12, 5))  

plt.subplot(1, 2, 1)  
plt.scatter(x, y, color='blue', label='Dados observados')  
plt.plot(x_test, 2*x_test + 1, 'g-', linewidth=2, label='Verdade: y=2x+1')  
plt.plot(x_test, y_pred_mean, 'r-', linewidth=2, label='Predição bayesiana (média)')  
plt.fill_between(x_test, lim_inf, lim_sup, color='red', alpha=0.2, label='IC 95%')  
plt.xlabel('x')  
plt.ylabel('y')  
plt.title('Regressão Linear Bayesiana')  
plt.legend()  
plt.grid(True)  

plt.subplot(1, 2, 2)  
# Mostrar a distribuição a posteriori dos coeficientes  
# Amostrar da posteriori para visualização  
amostras = multivariate_normal.rvs(mu_post, Sigma_post, size=200)  
plt.scatter(amostras[:,0], amostras[:,1], alpha=0.3, s=10, label='Amostras da posteriori')  
plt.scatter(mu_post[0], mu_post[1], color='red', s=80, label='Média posteriori')  
plt.scatter(0, 2, color='green', s=80, marker='*', label='Valor verdadeiro (1,2)')  
plt.xlabel('Intercepto (w0)')  
plt.ylabel('Inclinação (w1)')  
plt.title('Distribuição a Posteriori dos Coeficientes')  
plt.legend()  
plt.grid(True)  

plt.tight_layout()  
plt.show()  

# Predição para um novo ponto x=3.5  
x_novo = 3.5  
X_novo = np.array([1, x_novo])  
y_pred_novo = X_novo @ mu_post  
var_novo = X_novo @ Sigma_post @ X_novo.T + 1/alpha  
std_novo = np.sqrt(var_novo)  
print(f"\nPredição para x = {x_novo}:")  
print(f"  y = {y_pred_novo:.3f} ± {1.96*std_novo:.3f} (95% IC)")

import numpy as np

import matplotlib.pyplot as plt

from scipy.stats import multivariate_normal

# Gerar dados sintéticos

np.random.seed(42)

n = 30

x = np.linspace(0, 5, n)

erro = np.random.normal(0, 0.5, n)

y_real = 2 * x + 1

y = y_real + erro

# Regressão linear bayesiana com prior normal conjugado

# Modelo: y = w0 + w1 * x + ruído, com precisão alpha = 1/sigma²

# Prior: w ~ N(0, Sigma_prior) com Sigma_prior = diag(10, 10)

# Construir matriz de design (coluna de 1s para intercepto)

X = np.vstack([np.ones(n), x]).T

# Parâmetros

alpha = 1.0 / (0.5**2) # precisão do ruído (conhecida)

Sigma_prior = np.diag([10.0, 10.0])

mu_prior = np.array([0.0, 0.0])

# Posteriori: w | dados ~ N(mu_post, Sigma_post)

Sigma_post = np.linalg.inv(Sigma_prior + alpha * X.T @ X)

mu_post = Sigma_post @ (np.linalg.inv(Sigma_prior) @ mu_prior + alpha * X.T @ y)

print("Média a posteriori dos coeficientes:")

print(f" Intercepto: {mu_post[0]:.3f}")

print(f" Inclinação: {mu_post[1]:.3f}")

print("\nMatriz de covariância a posteriori:")

print(Sigma_post)

# Predição para novos pontos (x_test)

x_test = np.linspace(-0.5, 5.5, 100)

X_test = np.vstack([np.ones(len(x_test)), x_test]).T

# Média preditiva

y_pred_mean = X_test @ mu_post

# Variância preditiva: var(y_pred) = X_test @ Sigma_post @ X_test.T + 1/alpha

# (inclui incerteza dos coeficientes + ruído)

var_pred = np.diag(X_test @ Sigma_post @ X_test.T) + 1/alpha

std_pred = np.sqrt(var_pred)

# Intervalos de credibilidade de 95%

lim_inf = y_pred_mean - 1.96 * std_pred

lim_sup = y_pred_mean + 1.96 * std_pred

# Gráficos

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

plt.subplot(1, 2, 1)

plt.scatter(x, y, color='blue', label='Dados observados')

plt.plot(x_test, 2*x_test + 1, 'g-', linewidth=2, label='Verdade: y=2x+1')

plt.plot(x_test, y_pred_mean, 'r-', linewidth=2, label='Predição bayesiana (média)')

plt.fill_between(x_test, lim_inf, lim_sup, color='red', alpha=0.2, label='IC 95%')

plt.xlabel('x')

plt.ylabel('y')

plt.title('Regressão Linear Bayesiana')

plt.legend()

plt.grid(True)

plt.subplot(1, 2, 2)

# Mostrar a distribuição a posteriori dos coeficientes

# Amostrar da posteriori para visualização

amostras = multivariate_normal.rvs(mu_post, Sigma_post, size=200)

plt.scatter(amostras[:,0], amostras[:,1], alpha=0.3, s=10, label='Amostras da posteriori')

plt.scatter(mu_post[0], mu_post[1], color='red', s=80, label='Média posteriori')

plt.scatter(0, 2, color='green', s=80, marker='*', label='Valor verdadeiro (1,2)')

plt.xlabel('Intercepto (w0)')

plt.ylabel('Inclinação (w1)')

plt.title('Distribuição a Posteriori dos Coeficientes')

plt.legend()

plt.grid(True)

plt.tight_layout()

plt.show()

# Predição para um novo ponto x=3.5

x_novo = 3.5

X_novo = np.array([1, x_novo])

y_pred_novo = X_novo @ mu_post

var_novo = X_novo @ Sigma_post @ X_novo.T + 1/alpha

std_novo = np.sqrt(var_novo)

print(f"\nPredição para x = {x_novo}:")

print(f" y = {y_pred_novo:.3f} ± {1.96*std_novo:.3f} (95% IC)")

Este código implementa a regressão linear bayesiana com prior conjugado. A média a posteriori dos coeficientes se aproxima dos valores verdadeiros (1,2). A banda de 95% de credibilidade captura a incerteza tanto dos coeficientes quanto do ruído. O gráfico de dispersão dos coeficientes mostra a correlação entre intercepto e inclinação. Para iniciantes, este exemplo demonstra o aprendizado bayesiano prático. O aprendizado bayesiano é, portanto, uma ferramenta poderosa para modelagem preditiva.

Decisão com Perdas

16/07/202618/06/2026 Por antonino

O que é decisão com perdas?

Decisão com perdas é um arcabouço onde cada ação possível tem um custo associado ao erro. A função de perda L(θ, a) quantifica o prejuízo de tomar ação a quando o estado verdadeiro é θ. Diferentemente da classificação padrão (perda 0-1), as perdas podem ser assimétricas. Por exemplo, um falso negativo pode custar muito mais que um falso positivo. A decisão ótima minimiza a perda esperada (risco) sob a distribuição de incerteza. Essa abordagem é central em diagnósticos, controle de qualidade e finanças. Ela também é usada em aprendizado de máquina com custos desiguais. A perda pode ser quadrática, absoluta, logarítmica ou personalizada.

Características fundamentais da decisão com perdas

A decisão com perdas possui três características principais que a definem. Primeiro, a perda é uma função que mapeia (estado, ação) para um número real. Segundo, a perda esperada é calculada como E[L(θ, a) | dados]. Terceiro, a ação escolhida é a que minimiza essa expectativa. Perdas quadráticas levam a estimadores de média (mínimo erro quadrático). Perdas absolutas levam à mediana (mínimo erro absoluto). Perdas 0-1 levam à moda (classificação MAP). Perdas assimétricas podem ser representadas por matrizes de custo.

Vantagens e aplicações típicas

A principal vantagem é alinhar a decisão com as consequências reais. Ela é usada em diagnósticos médicos para evitar mortes por falso negativo. Também em sistemas de detecção de intrusão (custo de alarme falso vs. ataque real). Contudo, a especificação correta da perda requer conhecimento do domínio.

A decisão com perdas generaliza a teoria da decisão bayesiana. A perda pode ser dependente de parâmetros desconhecidos e de dados. Em problemas de estimação, a perda quadrática produz o estimador de Bayes. Esse estimador minimiza o erro quadrático médio condicional. Para perda absoluta, o estimador é a mediana a posteriori. A perda 0-1 é usada em classificação e produz a regra MAP. Perdas personalizadas são comuns em problemas de precificação e alocação. Por exemplo, em estoques, o custo de falta pode ser maior que o de excesso. A decisão com perdas também é usada em testes de hipóteses (perdas de Neyman-Pearson). Ela permite construir regiões de decisão com riscos controlados. Em aprendizado por reforço, a perda é o custo de uma ação em um estado. A política ótima minimiza a perda acumulada ao longo do tempo. A função de perda pode ser aprendida a partir de dados (aprendizado de preferências). Assim, a decisão com perdas é um conceito unificador em otimização e estatística.

Um exemplo clássico é o problema do vendedor de jornais (newsvendor). Ele deve decidir quantos jornais comprar para revender no dia. Custo de compra: c, preço de venda: p, valor de reciclagem: s. Perda por falta: (p – c) por unidade não vendida (oportunidade perdida). Perda por excesso: (c – s) por unidade não vendida (prejuízo). A decisão ótima balanceia esses dois custos.

Enunciado do exemplo clássico

Implemente a decisão com perdas para o problema do vendedor de jornais. Demanda D segue uma normal com média 100 e desvio 20 (unidades). Custo de compra c=2, preço de venda p=5, valor residual s=1. Calcule a perda esperada para cada quantidade q (de 50 a 150). Encontre a quantidade ótima que minimiza a perda esperada. Plote a perda esperada em função de q e destaque o ponto ótimo.

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

# Parâmetros  
c = 2.0   # custo por unidade  
p = 5.0   # preço de venda  
s = 1.0   # valor residual  
mu_demanda = 100.0  
sigma_demanda = 20.0  

# Função de perda para uma quantidade q e demanda d  
def perda(q, d):  
    # Se demanda >= q, vendemos tudo  
    if d >= q:  
        return - (p - c) * q  # lucro (perda negativa)  
    else:  
        # Vendemos d unidades a p, reciclamos (q-d) a s, pagamos c*q  
        lucro = p * d + s * (q - d) - c * q  
        return -lucro  # perda = -lucro  

# Calcular perda esperada para cada q via integração numérica  
q_range = np.arange(50, 151, 1)  
perda_esperada = []  
for q in q_range:  
    # Integral sobre d: E[perda(q, D)]  
    # Usamos quadratura gaussiana com 100 pontos  
    d_vals = np.linspace(mu_demanda - 4*sigma_demanda,  
                         mu_demanda + 4*sigma_demanda, 200)  
    pesos = norm.pdf(d_vals, mu_demanda, sigma_demanda)  
    perdas = np.array([perda(q, d) for d in d_vals])  
    # Aproximar integral (trapézio)  
    integral = np.trapz(perdas * pesos, d_vals)  
    perda_esperada.append(integral)  

# Encontrar q ótimo  
idx_otimo = np.argmin(perda_esperada)  
q_otimo = q_range[idx_otimo]  
perda_min = perda_esperada[idx_otimo]  

print(f"Quantidade ótima: {q_otimo} unidades")  
print(f"Perda esperada mínima: {perda_min:.2f}")  

# Calcular o ponto crítico via fórmula de fractil  
# Para demanda normal, q* = F^{-1}( (p-c) / (p-s) )  
fractil = (p - c) / (p - s)  
q_critico = norm.ppf(fractil, mu_demanda, sigma_demanda)  
print(f"Ponto crítico teórico (fractil): {q_critico:.1f}")  

# Gráficos  
plt.figure(figsize=(12, 5))  

plt.subplot(1, 2, 1)  
plt.plot(q_range, perda_esperada, 'b-', linewidth=2)  
plt.axvline(q_otimo, color='red', linestyle='--', label=f'Ótimo = {q_otimo}')  
plt.axhline(perda_min, color='green', linestyle=':', label=f'Mínimo = {perda_min:.2f}')  
plt.xlabel('Quantidade comprada (q)')  
plt.ylabel('Perda esperada')  
plt.title('Perda Esperada vs. Quantidade - Newsvendor')  
plt.legend()  
plt.grid(True)  

plt.subplot(1, 2, 2)  
# Mostrar distribuição da demanda e indicar o ponto ótimo  
x = np.linspace(mu_demanda - 4*sigma_demanda, mu_demanda + 4*sigma_demanda, 200)  
pdf = norm.pdf(x, mu_demanda, sigma_demanda)  
plt.plot(x, pdf, 'b-', linewidth=2, label='Distribuição da demanda')  
plt.axvline(q_otimo, color='red', linestyle='--', label=f'q* = {q_otimo}')  
# Preencher área de demanda < q*  
x_fill = np.linspace(mu_demanda - 4*sigma_demanda, q_otimo, 100)  
plt.fill_between(x_fill, 0, norm.pdf(x_fill, mu_demanda, sigma_demanda),  
                 color='red', alpha=0.3, label='Excesso (sobra)')  
x_fill2 = np.linspace(q_otimo, mu_demanda + 4*sigma_demanda, 100)  
plt.fill_between(x_fill2, 0, norm.pdf(x_fill2, mu_demanda, sigma_demanda),  
                 color='green', alpha=0.3, label='Falta (venda perdida)')  
plt.xlabel('Demanda (d)')  
plt.ylabel('Densidade de probabilidade')  
plt.title('Distribuição da Demanda e Ponto Ótimo')  
plt.legend()  
plt.grid(True)  

plt.tight_layout()  
plt.show()  

# Análise de sensibilidade: perda esperada para diferentes preços  
precos = np.linspace(3, 8, 6)  
q_otimos = []  
for p_aux in precos:  
    # Recalcular o fractil para cada preço  
    fractil_aux = (p_aux - c) / (p_aux - s)  
    q_aux = norm.ppf(min(fractil_aux, 0.999), mu_demanda, sigma_demanda)  
    q_otimos.append(q_aux)  
print("\nSensibilidade ao preço de venda:")  
for p_aux, q_aux in zip(precos, q_otimos):  
    print(f"  p = {p_aux:.1f} -> q* = {q_aux:.1f}")

import numpy as np

import matplotlib.pyplot as plt

from scipy.stats import norm

# Parâmetros

c = 2.0 # custo por unidade

p = 5.0 # preço de venda

s = 1.0 # valor residual

mu_demanda = 100.0

sigma_demanda = 20.0

# Função de perda para uma quantidade q e demanda d

def perda(q, d):

# Se demanda >= q, vendemos tudo

if d >= q:

return - (p - c) * q # lucro (perda negativa)

else:

# Vendemos d unidades a p, reciclamos (q-d) a s, pagamos c*q

lucro = p * d + s * (q - d) - c * q

return -lucro # perda = -lucro

# Calcular perda esperada para cada q via integração numérica

q_range = np.arange(50, 151, 1)

perda_esperada = []

for q in q_range:

# Integral sobre d: E[perda(q, D)]

# Usamos quadratura gaussiana com 100 pontos

d_vals = np.linspace(mu_demanda - 4*sigma_demanda,

mu_demanda + 4*sigma_demanda, 200)

pesos = norm.pdf(d_vals, mu_demanda, sigma_demanda)

perdas = np.array([perda(q, d) for d in d_vals])

# Aproximar integral (trapézio)

integral = np.trapz(perdas * pesos, d_vals)

perda_esperada.append(integral)

# Encontrar q ótimo

idx_otimo = np.argmin(perda_esperada)

q_otimo = q_range[idx_otimo]

perda_min = perda_esperada[idx_otimo]

print(f"Quantidade ótima: {q_otimo} unidades")

print(f"Perda esperada mínima: {perda_min:.2f}")

# Calcular o ponto crítico via fórmula de fractil

# Para demanda normal, q* = F^{-1}( (p-c) / (p-s) )

fractil = (p - c) / (p - s)

q_critico = norm.ppf(fractil, mu_demanda, sigma_demanda)

print(f"Ponto crítico teórico (fractil): {q_critico:.1f}")

# Gráficos

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

plt.subplot(1, 2, 1)

plt.plot(q_range, perda_esperada, 'b-', linewidth=2)

plt.axvline(q_otimo, color='red', linestyle='--', label=f'Ótimo = {q_otimo}')

plt.axhline(perda_min, color='green', linestyle=':', label=f'Mínimo = {perda_min:.2f}')

plt.xlabel('Quantidade comprada (q)')

plt.ylabel('Perda esperada')

plt.title('Perda Esperada vs. Quantidade - Newsvendor')

plt.legend()

plt.grid(True)

plt.subplot(1, 2, 2)

# Mostrar distribuição da demanda e indicar o ponto ótimo

x = np.linspace(mu_demanda - 4*sigma_demanda, mu_demanda + 4*sigma_demanda, 200)

pdf = norm.pdf(x, mu_demanda, sigma_demanda)

plt.plot(x, pdf, 'b-', linewidth=2, label='Distribuição da demanda')

plt.axvline(q_otimo, color='red', linestyle='--', label=f'q* = {q_otimo}')

# Preencher área de demanda < q*

x_fill = np.linspace(mu_demanda - 4*sigma_demanda, q_otimo, 100)

plt.fill_between(x_fill, 0, norm.pdf(x_fill, mu_demanda, sigma_demanda),

color='red', alpha=0.3, label='Excesso (sobra)')

x_fill2 = np.linspace(q_otimo, mu_demanda + 4*sigma_demanda, 100)

plt.fill_between(x_fill2, 0, norm.pdf(x_fill2, mu_demanda, sigma_demanda),

color='green', alpha=0.3, label='Falta (venda perdida)')

plt.xlabel('Demanda (d)')

plt.ylabel('Densidade de probabilidade')

plt.title('Distribuição da Demanda e Ponto Ótimo')

plt.legend()

plt.grid(True)

plt.tight_layout()

plt.show()

# Análise de sensibilidade: perda esperada para diferentes preços

precos = np.linspace(3, 8, 6)

q_otimos = []

for p_aux in precos:

# Recalcular o fractil para cada preço

fractil_aux = (p_aux - c) / (p_aux - s)

q_aux = norm.ppf(min(fractil_aux, 0.999), mu_demanda, sigma_demanda)

q_otimos.append(q_aux)

print("\nSensibilidade ao preço de venda:")

for p_aux, q_aux in zip(precos, q_otimos):

print(f" p = {p_aux:.1f} -> q* = {q_aux:.1f}")

Este código implementa a decisão com perdas para o problema do vendedor. A perda esperada é calculada numericamente integrando sobre a distribuição da demanda. A quantidade ótima minimiza a perda, equilibrando excesso e falta. O ponto crítico teórico coincide com o mínimo numérico. As áreas coloridas mostram as regiões de excesso (sobra) e falta (oportunidade perdida). Para iniciantes, este exemplo mostra como perdas assimétricas guiam decisões práticas. Decisão com perdas é, portanto, uma ferramenta essencial para gestão de risco.