Arquivo de Python - Página 22 de 92

Previsões pontuais versus previsões com incerteza: escolhendo entre regressão ridge e processos gaussianos

19/12/202531/10/2025 Por antonino

Imagine que você está gerenciando os custos de uma rede de padarias. Para o orçamento do próximo trimestre, você precisa tanto de estimativas precisas quanto de entender os riscos. A Regressão Ridge com Kernel lhe dá números exatos, enquanto o Processo Gaussiano (GPR) fornece essas estimativas junto com uma medida de confiança. É a diferença entre receber apenas o preço previsto de uma ação versus receber o preço mais a volatilidade esperada – ambas são úteis, mas para decisões diferentes.

Como isso funciona na prática?

Ambos os métodos usam kernels para modelar relações não-lineares nos dados, mas com filosofias fundamentalmente diferentes. A Regressão Ridge com Kernel é um método frequentista que encontra uma única função ótima que minimiza erro mais regularização. Contudo, o GPR é bayesiano e modela uma distribuição sobre funções possíveis, fornecendo não apenas uma previsão mas toda uma distribuição de possibilidades. Enquanto Ridge dá uma resposta definitiva (“o custo será R$ X”), GPR responde (“o custo provavelmente será around R$ X, mas pode variar entre Y e Z”).

Mãos na massa: comparando previsões de custos

"""
Comparação prática entre GPR e Regressão Ridge com Kernel
Ambos usam kernels RBF, mas com abordagens fundamentalmente diferentes
"""

import numpy as np
import matplotlib.pyplot as plt
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF
from sklearn.kernel_ridge import KernelRidge
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, mean_absolute_error

# Dados de custos mensais de produção com sazonalidade
np.random.seed(42)
meses = np.linspace(0, 24, 50).reshape(-1, 1)
# Função base com sazonalidade + ruído
custos_base = 5000 + 200 * meses + 300 * np.sin(2 * np.pi * meses / 12)
custos = custos_base + np.random.normal(0, 150, meses.shape)

# Dividindo em treino e teste
X_treino, X_teste, y_treino, y_teste = train_test_split(
    meses, custos, test_size=0.3, random_state=42
)

print(f"Dados: {len(X_treino)} meses para treino, {len(X_teste)} para teste")

# Configurando ambos os modelos com kernel RBF similar
kernel_rbf = RBF(length_scale=1.0)

# Gaussian Process Regressor
gpr = GaussianProcessRegressor(
    kernel=kernel_rbf,
    alpha=100,  # Ruído nos dados
    n_restarts_optimizer=10
)

# Kernel Ridge Regression
krr = KernelRidge(
    kernel='rbf',
    alpha=1.0,    # Parâmetro de regularização
    gamma=0.5     # Parâmetro do kernel RBF
)

# Treinando ambos os modelos
gpr.fit(X_treino, y_treino.ravel())
krr.fit(X_treino, y_treino.ravel())

# Fazendo previsões
X_plot = np.linspace(0, 24, 100).reshape(-1, 1)

# GPR fornece média e incerteza
y_gpr, sigma_gpr = gpr.predict(X_plot, return_std=True)

# KRR fornece apenas previsão pontual
y_krr = krr.predict(X_plot)

# Avaliando no conjunto de teste
y_pred_gpr = gpr.predict(X_teste)
y_pred_krr = krr.predict(X_teste)

mse_gpr = mean_squared_error(y_teste, y_pred_gpr)
mse_krr = mean_squared_error(y_teste, y_pred_krr)

print(f"\nDesempenho nos dados de teste:")
print(f"GPR - Erro quadrático médio: {mse_gpr:.2f}")
print(f"KRR - Erro quadrático médio: {mse_krr:.2f}")

# Visualizando a comparação
plt.figure(figsize=(14, 10))

plt.subplot(2, 1, 1)
plt.scatter(X_treino, y_treino, c='blue', alpha=0.6, label='Dados de treino')
plt.scatter(X_teste, y_teste, c='red', alpha=0.6, label='Dados de teste')
plt.plot(X_plot, y_gpr, 'green', linewidth=2, label='GPR - Previsão média')
plt.fill_between(X_plot.ravel(), y_gpr - 1.96*sigma_gpr, y_gpr + 1.96*sigma_gpr, 
                alpha=0.2, color='green', label='GPR - 95% intervalo')
plt.title('Gaussian Process Regressor - Previsão com Incerteza')
plt.xlabel('Mês')
plt.ylabel('Custo (R$)')
plt.legend()
plt.grid(True, alpha=0.3)

plt.subplot(2, 1, 2)
plt.scatter(X_treino, y_treino, c='blue', alpha=0.6, label='Dados de treino')
plt.scatter(X_teste, y_teste, c='red', alpha=0.6, label='Dados de teste')
plt.plot(X_plot, y_krr, 'purple', linewidth=2, label='Kernel Ridge - Previsão')
plt.title('Kernel Ridge Regression - Previsão Pontual')
plt.xlabel('Mês')
plt.ylabel('Custo (R$)')
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

print("\nPrincipais diferenças observadas:")
print("• GPR fornece intervalo de confiança junto com a previsão")
print("• KRR é computacionalmente mais eficiente para grandes datasets")
print("• GPR é probabilisticamente interpretável")
print("• KRR é mais simples de implementar e ajustar")

100

101

"""

Comparação prática entre GPR e Regressão Ridge com Kernel

Ambos usam kernels RBF, mas com abordagens fundamentalmente diferentes

"""

import numpy as np

import matplotlib.pyplot as plt

from sklearn.gaussian_process import GaussianProcessRegressor

from sklearn.gaussian_process.kernels import RBF

from sklearn.kernel_ridge import KernelRidge

from sklearn.model_selection import train_test_split

from sklearn.metrics import mean_squared_error, mean_absolute_error

# Dados de custos mensais de produção com sazonalidade

np.random.seed(42)

meses = np.linspace(0, 24, 50).reshape(-1, 1)

# Função base com sazonalidade + ruído

custos_base = 5000 + 200 * meses + 300 * np.sin(2 * np.pi * meses / 12)

custos = custos_base + np.random.normal(0, 150, meses.shape)

# Dividindo em treino e teste

X_treino, X_teste, y_treino, y_teste = train_test_split(

meses, custos, test_size=0.3, random_state=42

)

print(f"Dados: {len(X_treino)} meses para treino, {len(X_teste)} para teste")

# Configurando ambos os modelos com kernel RBF similar

kernel_rbf = RBF(length_scale=1.0)

# Gaussian Process Regressor

gpr = GaussianProcessRegressor(

kernel=kernel_rbf,

alpha=100, # Ruído nos dados

n_restarts_optimizer=10

)

# Kernel Ridge Regression

krr = KernelRidge(

kernel='rbf',

alpha=1.0, # Parâmetro de regularização

gamma=0.5 # Parâmetro do kernel RBF

)

# Treinando ambos os modelos

gpr.fit(X_treino, y_treino.ravel())

krr.fit(X_treino, y_treino.ravel())

# Fazendo previsões

X_plot = np.linspace(0, 24, 100).reshape(-1, 1)

# GPR fornece média e incerteza

y_gpr, sigma_gpr = gpr.predict(X_plot, return_std=True)

# KRR fornece apenas previsão pontual

y_krr = krr.predict(X_plot)

# Avaliando no conjunto de teste

y_pred_gpr = gpr.predict(X_teste)

y_pred_krr = krr.predict(X_teste)

mse_gpr = mean_squared_error(y_teste, y_pred_gpr)

mse_krr = mean_squared_error(y_teste, y_pred_krr)

print(f"\nDesempenho nos dados de teste:")

print(f"GPR - Erro quadrático médio: {mse_gpr:.2f}")

print(f"KRR - Erro quadrático médio: {mse_krr:.2f}")

# Visualizando a comparação

plt.figure(figsize=(14, 10))

plt.subplot(2, 1, 1)

plt.scatter(X_treino, y_treino, c='blue', alpha=0.6, label='Dados de treino')

plt.scatter(X_teste, y_teste, c='red', alpha=0.6, label='Dados de teste')

plt.plot(X_plot, y_gpr, 'green', linewidth=2, label='GPR - Previsão média')

plt.fill_between(X_plot.ravel(), y_gpr - 1.96*sigma_gpr, y_gpr + 1.96*sigma_gpr,

alpha=0.2, color='green', label='GPR - 95% intervalo')

plt.title('Gaussian Process Regressor - Previsão com Incerteza')

plt.xlabel('Mês')

plt.ylabel('Custo (R$)')

plt.legend()

plt.grid(True, alpha=0.3)

plt.subplot(2, 1, 2)

plt.scatter(X_treino, y_treino, c='blue', alpha=0.6, label='Dados de treino')

plt.scatter(X_teste, y_teste, c='red', alpha=0.6, label='Dados de teste')

plt.plot(X_plot, y_krr, 'purple', linewidth=2, label='Kernel Ridge - Previsão')

plt.title('Kernel Ridge Regression - Previsão Pontual')

plt.xlabel('Mês')

plt.ylabel('Custo (R$)')

plt.legend()

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

print("\nPrincipais diferenças observadas:")

print("• GPR fornece intervalo de confiança junto com a previsão")

print("• KRR é computacionalmente mais eficiente para grandes datasets")

print("• GPR é probabilisticamente interpretável")

print("• KRR é mais simples de implementar e ajustar")

Os detalhes que fazem diferença

A escolha entre GPR e Kernel Ridge depende crucialmente das suas necessidades específicas. GPR brilha quando a quantificação da incerteza é importante ou quando você tem dados limitados mas de alta qualidade. Contudo, para grandes conjuntos de dados (acima de ~10.000 pontos), Kernel Ridge se torna muito mais eficiente computacionalmente. Analogamente importante é a interpretabilidade: GPR fornece uma framework probabilística natural, enquanto Kernel Ridge é puramente baseado em otimização. O custo computacional do GPR ($O(n^3)$) versus Kernel Ridge ($O(n^2)$) frequentemente dita a escolha prática em aplicações do mundo real.

Escolha GPR quando: Incerteza é crucial, dados são limitados, interpretabilidade probabilística é importante
Escolha Kernel Ridge quando: Performance computacional é prioridade, dados são abundantes, apenas previsões pontuais são necessárias
Complexidade GPR: $O(n^3)$ para treinamento devido à inversão de matriz
Complexidade Kernel Ridge: $O(n^2)$ – mais escalável

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Se ambos usam kernels, por que os resultados são tão diferentes?” Excelente observação! A diferença está na filosofia: Kernel Ridge encontra a função que melhor se ajusta aos dados, enquanto GPR modela uma distribuição sobre funções possíveis. Uma confusão comum é pensar que GPR é sempre mais preciso – na verdade, em muitos casos práticos, Kernel Ridge pode ter erro similar com muito menos custo computacional. Outra dúvida frequente: “Posso usar os intervalos de confiança do GPR para tomada de decisão?” Sim! Eles são matematicamente fundamentados e podem guiar decisões de risco.

Para onde ir agora?

Experimente ambos os métodos em seus próprios dados de custos ou outros problemas de regressão. Comece com Kernel Ridge para uma solução rápida e eficiente, depois use GPR quando precisar entender a incerteza das previsões. Compare não apenas a precisão, mas também o tempo de treinamento e os insights que cada método proporciona. O momento “aha!” acontece quando você percebe que a “melhor” escolha depende do que você precisa: velocidade ou informação probabilística.

Assuntos relacionados

Para entender profundamente essas diferenças, estude:

Estatística frequentista vs bayesiana: filosofias fundamentais diferentes
Teoria de kernels: representação em espaços de características
Otimização convexa: como cada método encontra soluções
Teoria da decisão: usando incerteza para tomada de decisão
Complexidade computacional: trade-offs entre precisão e eficiência

Referências que valem a pena

Previsões realistas: como o GPR lida com dados imperfeitos do mundo real

19/12/202531/10/2025 Por antonino

Imagine que você está analisando os custos de produção de uma padaria. Alguns meses têm custos que parecem fora do padrão – talvez por causa de ingredientes com preços sazonais ou problemas operacionais. A Regressão por Processos Gaussianos (GPR) não só prevê custos futuros, mas também aprende automaticamente o quanto dessas variações são “ruído normal” versus padrões reais. É como ter um consultor financeiro que entende que nem toda flutuação significa uma mudança de tendência.

Como isso funciona na prática?

O GPR com estimativa de ruído modela explicitamente a incerteza nos seus dados. Enquanto métodos tradicionais tentam forçar uma linha perfeita através de pontos ruidosos, o GPR reconhece que os dados reais têm imperfeições. Ele separa o sinal verdadeiro (a tendência subjacente) do ruído (variações aleatórias). Quando você permite que o modelo estime o nível de ruído, ele se torna mais realista sobre o que pode e não pode prever com confiança. Diferentemente de métodos que assumem dados perfeitos, esta abordagem admite que o mundo real é barulhento e adapta-se accordingly.

Mãos na massa: GPR com estimativa automática de ruído

"""
Regressão por Processos Gaussianos com estimativa automática de ruído
Modela custos de produção considerando variações naturais e ruído de medição
"""

import numpy as np
import matplotlib.pyplot as plt
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, WhiteKernel

# Dados de custos mensais de produção com variações naturais
# Alguns meses têm flutuações maiores (ruído) devido a fatores sazonais
meses = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]).reshape(-1, 1)
custos = np.array([5200, 5100, 5800, 6200, 6500, 6300, 7200, 7800, 7500, 8200, 8500, 8400])

print("Dados de custos com variações naturais:")
for mes, custo in zip(meses, custos):
    print(f"Mês {mes[0]}: R$ {custo}")

# Kernel composto: RBF para tendência + WhiteKernel para ruído
kernel = RBF(length_scale=2.0) + WhiteKernel(noise_level=1000)

# GPR com estimativa automática de nível de ruído
gp = GaussianProcessRegressor(
    kernel=kernel,
    alpha=0.0,  # Zero porque o ruído já está no kernel
    n_restarts_optimizer=10
)

# Treinando o modelo
gp.fit(meses, custos)

print(f"\nKernel otimizado: {gp.kernel_}")
print(f"Nível de ruído estimado: {gp.kernel_.k2.noise_level:.2f}")

# Fazendo previsões
meses_futuros = np.array([[13], [14], [15]]).reshape(-1, 1)
custos_pred, sigma = gp.predict(meses_futuros, return_std=True)

print("\nPrevisões para próximos meses:")
for mes, pred, std in zip(meses_futuros, custos_pred, sigma):
    intervalo = 1.96 * std
    print(f"Mês {mes[0]}: R$ {pred:.0f} ± {intervalo:.0f}")

# Comparando com GPR sem estimativa de ruído
kernel_sem_ruido = RBF(length_scale=2.0)
gp_sem_ruido = GaussianProcessRegressor(kernel=kernel_sem_ruido)
gp_sem_ruido.fit(meses, custos)

# Visualizando a diferença
X_plot = np.linspace(1, 15, 100).reshape(-1, 1)
y_com_ruido, std_com_ruido = gp.predict(X_plot, return_std=True)
y_sem_ruido, std_sem_ruido = gp_sem_ruido.predict(X_plot, return_std=True)

plt.figure(figsize=(14, 8))

# Plot com estimativa de ruído
plt.subplot(1, 2, 1)
plt.plot(meses, custos, 'ro', markersize=8, label='Dados reais')
plt.plot(X_plot, y_com_ruido, 'b-', label='Previsão GPR')
plt.fill_between(X_plot.ravel(), y_com_ruido - 1.96*std_com_ruido, 
                y_com_ruido + 1.96*std_com_ruido, alpha=0.2, label='95% confiança')
plt.title('GPR com Estimativa de Ruído')
plt.xlabel('Mês')
plt.ylabel('Custo (R$)')
plt.legend()
plt.grid(True, alpha=0.3)

# Plot sem estimativa de ruído
plt.subplot(1, 2, 2)
plt.plot(meses, custos, 'ro', markersize=8, label='Dados reais')
plt.plot(X_plot, y_sem_ruido, 'g-', label='Previsão GPR')
plt.fill_between(X_plot.ravel(), y_sem_ruido - 1.96*std_sem_ruido, 
                y_sem_ruido + 1.96*std_sem_ruido, alpha=0.2, label='95% confiança')
plt.title('GPR sem Estimativa de Ruído')
plt.xlabel('Mês')
plt.ylabel('Custo (R$)')
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

"""

Regressão por Processos Gaussianos com estimativa automática de ruído

Modela custos de produção considerando variações naturais e ruído de medição

"""

import numpy as np

import matplotlib.pyplot as plt

from sklearn.gaussian_process import GaussianProcessRegressor

from sklearn.gaussian_process.kernels import RBF, WhiteKernel

# Dados de custos mensais de produção com variações naturais

# Alguns meses têm flutuações maiores (ruído) devido a fatores sazonais

meses = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]).reshape(-1, 1)

custos = np.array([5200, 5100, 5800, 6200, 6500, 6300, 7200, 7800, 7500, 8200, 8500, 8400])

print("Dados de custos com variações naturais:")

for mes, custo in zip(meses, custos):

print(f"Mês {mes[0]}: R$ {custo}")

# Kernel composto: RBF para tendência + WhiteKernel para ruído

kernel = RBF(length_scale=2.0) + WhiteKernel(noise_level=1000)

# GPR com estimativa automática de nível de ruído

gp = GaussianProcessRegressor(

kernel=kernel,

alpha=0.0, # Zero porque o ruído já está no kernel

n_restarts_optimizer=10

)

# Treinando o modelo

gp.fit(meses, custos)

print(f"\nKernel otimizado: {gp.kernel_}")

print(f"Nível de ruído estimado: {gp.kernel_.k2.noise_level:.2f}")

# Fazendo previsões

meses_futuros = np.array([[13], [14], [15]]).reshape(-1, 1)

custos_pred, sigma = gp.predict(meses_futuros, return_std=True)

print("\nPrevisões para próximos meses:")

for mes, pred, std in zip(meses_futuros, custos_pred, sigma):

intervalo = 1.96 * std

print(f"Mês {mes[0]}: R$ {pred:.0f} ± {intervalo:.0f}")

# Comparando com GPR sem estimativa de ruído

kernel_sem_ruido = RBF(length_scale=2.0)

gp_sem_ruido = GaussianProcessRegressor(kernel=kernel_sem_ruido)

gp_sem_ruido.fit(meses, custos)

# Visualizando a diferença

X_plot = np.linspace(1, 15, 100).reshape(-1, 1)

y_com_ruido, std_com_ruido = gp.predict(X_plot, return_std=True)

y_sem_ruido, std_sem_ruido = gp_sem_ruido.predict(X_plot, return_std=True)

plt.figure(figsize=(14, 8))

# Plot com estimativa de ruído

plt.subplot(1, 2, 1)

plt.plot(meses, custos, 'ro', markersize=8, label='Dados reais')

plt.plot(X_plot, y_com_ruido, 'b-', label='Previsão GPR')

plt.fill_between(X_plot.ravel(), y_com_ruido - 1.96*std_com_ruido,

y_com_ruido + 1.96*std_com_ruido, alpha=0.2, label='95% confiança')

plt.title('GPR com Estimativa de Ruído')

plt.xlabel('Mês')

plt.ylabel('Custo (R$)')

plt.legend()

plt.grid(True, alpha=0.3)

# Plot sem estimativa de ruído

plt.subplot(1, 2, 2)

plt.plot(meses, custos, 'ro', markersize=8, label='Dados reais')

plt.plot(X_plot, y_sem_ruido, 'g-', label='Previsão GPR')

plt.fill_between(X_plot.ravel(), y_sem_ruido - 1.96*std_sem_ruido,

y_sem_ruido + 1.96*std_sem_ruido, alpha=0.2, label='95% confiança')

plt.title('GPR sem Estimativa de Ruído')

plt.xlabel('Mês')

plt.ylabel('Custo (R$)')

plt.legend()

plt.grid(True, alpha=0.3)

plt.tight_layout()

plt.show()

Os detalhes que fazem diferença

A estimativa automática de ruído no GPR é implementada através do WhiteKernel, que adiciona um componente diagonal à matriz de covariância. Este componente representa variações não explicadas pelo padrão subjacente. Contudo, o balanceamento entre o kernel de ruído e o kernel principal (como RBF) é crucial – muito ruído e o modelo ignora padrões reais, pouco ruído e ele superestima sua capacidade preditiva. Analogamente importante é entender que o ruído estimado captura tanto erro de medição quanto variações genuínas não modeladas. A escolha de alpha=0.0 quando se usa WhiteKernel é essencial, pois você já está modelando o ruído explicitamente.

WhiteKernel: Modela ruído independente e identicamente distribuído
Balanceamento: Encontre o trade-off entre flexibilidade e generalização
Interpretação: Ruído alto sugere dados muito variáveis ou modelo inadequado
Validação: Use log-likelihood marginal para comparar configurações

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Por que não usar sempre estimativa de ruído?” Excelente questão! Em dados muito limpos ou quando você sabe o nível de ruído experimental, especificá-lo manualmente pode ser melhor. Uma confusão comum é entre o parâmetro alpha e o WhiteKernel – eles são abordagens diferentes para o mesmo problema. Outra dúvida frequente: “Como interpretar o nível de ruído estimado?” Pense nele como a “granularidade” dos seus dados – valores altos significam que observações próximas podem ter valores muito diferentes, valores baixos sugerem dados mais suaves.

Para onde ir agora?

Experimente GPR com estimativa de ruído em seus próprios dados empresariais ou científicos. Compare resultados com e sem WhiteKernel, observando como as faixas de confiança mudam. Use a log-verossimilhança marginal para selecionar o melhor kernel. O momento “aha!” acontece quando você percebe que modelar o ruído explicitamente torna suas previsões não apenas mais precisas, mas também mais honestas sobre suas limitações.

Assuntos relacionados

Para dominar GPR com estimativa de ruído, estude estes conceitos:

Estatística bayesiana: inferência sobre parâmetros de ruído
Teoria de estimação: máxima verossimilhança e métodos bayesianos
Processos estocásticos: decomposição sinal-ruído
Otimização: maximização da verossimilhança marginal
Teoria da decisão: tomada de decisão sob incerteza