Arquivo de processos-gaussianos - Página 4 de 4

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

Referências que valem a pena

Como isso funciona na prática?

Processos Gaussianos (Gaussian Processes) modelam funções como distribuições sobre funções possíveis. Pense nisso como ter múltiplas linhas de tendência possíveis para seus dados, onde algumas são mais prováveis que outras. Quando você faz uma previsão, o processo gaussiano fornece tanto uma estimativa média quanto uma medida de incerteza (variância). Diferentemente de outros métodos que dão apenas uma resposta pontual, processos gaussianos respondem: “Baseado nos dados, a função provavelmente passa por aqui, mas poderia variar tanto para mais quanto para menos.”

Mãos na massa: prevendo custos de produção com incerteza

"""
Previsão de custos de produção usando Processos Gaussianos
Modela não apenas valores esperados, mas também a incerteza das previsões
"""

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

# Dados históricos de custos de produção de uma padaria
# [mês, custo_total] - meses consecutivos
X_treino = np.array([[1], [2], [3], [4], [5], [7], [8], [10]]).reshape(-1, 1)
y_treino = np.array([5200, 5400, 5800, 6200, 6500, 7200, 7800, 8500])

print("Dados históricos de custos:")
for i, (mes, custo) in enumerate(zip(X_treino, y_treino)):
    print(f"Mês {mes[0]}: R$ {custo}")

# Definindo o kernel (função de covariância)
# RBF (Radial Basis Function) + constante para modelar tendências
kernel = C(1.0, (1e-3, 1e3)) * RBF(1.0, (1e-2, 1e2))

# Criando e treinando o processo gaussiano
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)
gp.fit(X_treino, y_treino)

# Fazendo previsões para meses futuros
meses_futuros = np.array([[6], [9], [11], [12]]).reshape(-1, 1)
y_pred, sigma = gp.predict(meses_futuros, return_std=True)

print("\nPrevisões para meses futuros:")
for i, (mes, pred, std) in enumerate(zip(meses_futuros, y_pred, sigma)):
    intervalo_confianca = 1.96 * std  # 95% intervalo de confiança
    print(f"Mês {mes[0]}: R$ {pred:.0f} ± {intervalo_confianca:.0f}")
    print(f"   Faixa provável: R$ {pred - intervalo_confianca:.0f} - R$ {pred + intervalo_confianca:.0f}")

# Visualizando as previsões com incerteza
X_plot = np.linspace(1, 12, 100).reshape(-1, 1)
y_mean, y_std = gp.predict(X_plot, return_std=True)

plt.figure(figsize=(12, 6))
plt.plot(X_treino, y_treino, 'ro', markersize=8, label='Dados históricos')
plt.plot(X_plot, y_mean, 'b-', label='Previsão média')
plt.fill_between(X_plot.ravel(), 
                y_mean - 1.96*y_std, 
                y_mean + 1.96*y_std, 
                alpha=0.2, color='blue', label='95% intervalo de confiança')
plt.xlabel('Mês')
plt.ylabel('Custo de Produção (R$)')
plt.title('Previsão de Custos com Processo Gaussiano')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

"""

Previsão de custos de produção usando Processos Gaussianos

Modela não apenas valores esperados, mas também a incerteza das previsões

"""

import numpy as np

import matplotlib.pyplot as plt

from sklearn.gaussian_process import GaussianProcessRegressor

from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C

# Dados históricos de custos de produção de uma padaria

# [mês, custo_total] - meses consecutivos

X_treino = np.array([[1], [2], [3], [4], [5], [7], [8], [10]]).reshape(-1, 1)

y_treino = np.array([5200, 5400, 5800, 6200, 6500, 7200, 7800, 8500])

print("Dados históricos de custos:")

for i, (mes, custo) in enumerate(zip(X_treino, y_treino)):

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

# Definindo o kernel (função de covariância)

# RBF (Radial Basis Function) + constante para modelar tendências

kernel = C(1.0, (1e-3, 1e3)) * RBF(1.0, (1e-2, 1e2))

# Criando e treinando o processo gaussiano

gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)

gp.fit(X_treino, y_treino)

# Fazendo previsões para meses futuros

meses_futuros = np.array([[6], [9], [11], [12]]).reshape(-1, 1)

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

print("\nPrevisões para meses futuros:")

for i, (mes, pred, std) in enumerate(zip(meses_futuros, y_pred, sigma)):

intervalo_confianca = 1.96 * std # 95% intervalo de confiança

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

print(f" Faixa provável: R$ {pred - intervalo_confianca:.0f} - R$ {pred + intervalo_confianca:.0f}")

# Visualizando as previsões com incerteza

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

y_mean, y_std = gp.predict(X_plot, return_std=True)

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

plt.plot(X_treino, y_treino, 'ro', markersize=8, label='Dados históricos')

plt.plot(X_plot, y_mean, 'b-', label='Previsão média')

plt.fill_between(X_plot.ravel(),

y_mean - 1.96*y_std,

y_mean + 1.96*y_std,

alpha=0.2, color='blue', label='95% intervalo de confiança')

plt.xlabel('Mês')

plt.ylabel('Custo de Produção (R$)')

plt.title('Previsão de Custos com Processo Gaussiano')

plt.legend()

plt.grid(True, alpha=0.3)

plt.show()

Os detalhes que fazem diferença

A escolha do kernel é o aspecto mais importante dos processos gaussianos, pois ele define como o modelo entende similaridade entre pontos de dados. O kernel RBF é comum e assume que pontos próximos têm valores similares, mas existem dezenas de opções para diferentes tipos de dados. Contudo, processos gaussianos podem ser computacionalmente caros para grandes conjuntos de dados (complexidade $O(n^3)$), tornando-se impraticáveis acima de alguns milhares de pontos. Analogamente importante é entender que a incerteza capturada pelo modelo reflete apenas a incerteza devido à escassez de dados, não erros de medição ou variabilidade não modelada.

Kernel RBF: Bom para funções suaves e contínuas

Kernel Matérn: Mais flexível que RBF, controla suavidade

Escalabilidade: Limite prático around 1.000-10.000 pontos

Interpretação: Incerteza alta indica necessidade de mais dados

Perguntas que os iniciantes fazem

Você deve estar se perguntando: “Quando devo usar processos gaussianos em vez de regressão linear ou random forest?” Excelente questão! Use processos gaussianos quando a quantificação da incerteza for crucial para sua aplicação, ou quando você tiver poucos dados mas de alta qualidade. Uma confusão comum é pensar que a incerteza do processo gaussiano captura todos os tipos de erro – na verdade, ela só modela incerteza devido à escassez de dados. Outra dúvida frequente: “Por que a complexidade computacional é tão alta?” Porque o método envolve inverter matrizes de covariância que crescem com o quadrado do número de pontos.

Para onde ir agora?

Experimente processos gaussianos em problemas onde a incerteza é importante, como previsão de custos, análise de experimentos ou otimização de parâmetros. Comece com o kernel RBF padrão e depois explore outros kernels para diferentes tipos de padrões nos dados. Use a visualização da incerteza para identificar onde coletar mais dados. O momento “aha!” acontece quando você percebe o poder de tomar decisões considerando não apenas o que é mais provável, mas também o que poderia acontecer.

Assuntos relacionados

Para dominar processos gaussianos, estude estes conceitos matemáticos:

Estatística multivariada: distribuições normais multivariadas e covariância

Teoria de probabilidade: processos estocásticos e funções aleatórias

Álgebra linear: matrizes de covariância e decomposição espectral

Teoria de kernels: funções de covariância e espaços de Hilbert

Inferência bayesiana: atualização de crenças com novos dados

Referências que valem a pena

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

Como isso funciona na prática?

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

Os detalhes que fazem diferença

Perguntas que os iniciantes fazem

Para onde ir agora?

Assuntos relacionados

Referências que valem a pena

Previsões com incerteza: como processos gaussianos nos ajudam a tomar decisões melhores

Como isso funciona na prática?

Mãos na massa: prevendo custos de produção com incerteza

Os detalhes que fazem diferença

Perguntas que os iniciantes fazem

Para onde ir agora?

Assuntos relacionados

Referências que valem a pena