Processos Gaussianos

Visão geral

Um Processo Gaussiano (Gaussian Process, GP) é um modelo bayesiano (Bayesian) e não paramétrico (nonparametric) para aprender funções desconhecidas a partir de dados. A ideia central é simples, mas poderosa:

  • Em vez de colocar uma distribuição de probabilidade sobre parâmetros (como pesos em regressão), um GP coloca uma distribuição sobre funções (f(\cdot)).
  • Isso produz previsões com incerteza calibrada, não apenas estimativas pontuais.
  • O viés indutivo (inductive bias) do modelo — suavidade, periodicidade, tendências lineares etc. — é codificado por uma função núcleo (kernel) de covariância (covariance).

Processos Gaussianos são amplamente usados para regressão probabilística (probabilistic regression), aprendizado ativo (active learning), otimização bayesiana (Bayesian optimization) e como priors flexíveis em Modelos Bayesianos.

Por que Processos Gaussianos?

Em comparação com muitos modelos comuns de ML, os GPs se destacam quando você precisa de:

  • Estimativas de incerteza em que dá para confiar (por exemplo, medição científica, robótica, tomada de decisão sob incerteza)
  • Forte desempenho com conjuntos de dados pequenos a médios
  • Uma forma interpretável de codificar suposições a priori via estrutura do kernel
  • Uma estrutura bayesiana principiada que equilibra ajuste e complexidade por meio da verossimilhança marginal (marginal likelihood)

Eles são menos ideais quando você tem conjuntos de dados massivos (sem aproximações) ou entradas brutas de dimensão extremamente alta (por exemplo, pixels), a menos que sejam combinados com aprendizado de representações (representation learning) (por exemplo, incorporações (embeddings) de Redes Neurais).

O Prior de GP: Uma Distribuição Sobre Funções

Um Processo Gaussiano é definido como:

[ f(x) \sim \mathcal{GP}(m(x), k(x, x')) ]

  • (m(x) = \mathbb{E}[f(x)]) é a função média (mean function) (frequentemente definida como 0 após normalização).
  • (k(x, x') = \text{Cov}(f(x), f(x'))) é a função núcleo/de covariância.

A propriedade definidora:

Para qualquer conjunto finito de entradas (X = {x_1,\dots,x_n}), o vetor de valores da função
(\mathbf{f} = [f(x_1),\dots,f(x_n)]^\top) segue uma distribuição normal multivariada (multivariate normal distribution).

[ \mathbf{f} \sim \mathcal{N}(\mathbf{m}, \mathbf{K}) ] onde (\mathbf{m}i = m(x_i)) e (\mathbf{K}{ij} = k(x_i, x_j)).

Intuição

  • O kernel diz o quanto duas entradas “deveriam” ter saídas semelhantes.
  • Se (k(x, x')) é grande, então (f(x)) e (f(x')) são fortemente correlacionadas.
  • É assim que GPs generalizam de pontos observados para pontos não vistos.

Kernels: Codificando Estrutura e Suposições a Priori

O kernel é o coração de um GP. Escolher um kernel é como escolher o espaço de funções que seu modelo considera plausível.

Kernels comuns

Kernel Exponencial Quadrático / RBF (funções muito suaves)
[ k(x,x') = \sigma_f^2 \exp\left(-\frac{|x-x'|^2}{2\ell^2}\right) ]

  • (\ell): escala de comprimento (length-scale) (quão rapidamente a função varia)
  • (\sigma_f^2): variância do sinal

Kernel de Matérn (mais “rugoso”, muitas vezes mais realista)
Popular em otimização bayesiana. Matérn-(\nu) controla a diferenciabilidade:

  • (\nu=1/2): muito rugoso
  • (\nu=3/2, 5/2): comumente usados (menos suave do que RBF)

Kernel linear (tendências lineares)
Equivalente à regressão linear bayesiana sob certos priors.

Kernel periódico (sazonalidade / padrões repetitivos)
Útil em Previsão de Séries Temporais.

Compondo kernels

Kernels podem ser somados e multiplicados para expressar estrutura mais rica:

  • (k = k_{\text{RBF}} + k_{\text{Linear}}): variação suave + tendência global
  • (k = k_{\text{RBF}} \times k_{\text{Periodic}}): funções localmente periódicas

Essa composicionalidade é um dos motivos pelos quais GPs são atraentes para modelagem científica: termos do kernel podem corresponder a fenômenos interpretáveis.

Regressão por Processo Gaussiano (GPR)

Em regressão, observamos alvos ruidosos:

[ y_i = f(x_i) + \epsilon_i,\quad \epsilon_i \sim \mathcal{N}(0, \sigma_n^2) ]

Sejam:

  • (X \in \mathbb{R}^{n \times d}) as entradas de treino
  • (\mathbf{y} \in \mathbb{R}^{n}) as saídas observadas
  • (X_* \in \mathbb{R}^{n_* \times d}) as entradas de teste

Defina as matrizes de kernel:

  • (\mathbf{K} = k(X, X))
  • (\mathbf{K}* = k(X, X*))
  • (\mathbf{K}{**} = k(X, X_))

Com ruído Gaussiano, a distribuição preditiva a posteriori (posterior predictive distribution) é analiticamente tratável (analytically tractable):

[ \mathbf{f}* \mid X,\mathbf{y},X* \sim \mathcal{N}(\boldsymbol{\mu}*, \boldsymbol{\Sigma}*) ]

onde:

[ \boldsymbol{\mu}* = \mathbf{K}*^\top(\mathbf{K} + \sigma_n^2\mathbf{I})^{-1}\mathbf{y} ]

[ \boldsymbol{\Sigma}* = \mathbf{K}{**} - \mathbf{K}*^\top(\mathbf{K} + \sigma_n^2\mathbf{I})^{-1}\mathbf{K}* ]

O que a posteriori fornece

  • Previsão de média: (\boldsymbol{\mu}_*)
  • Incerteza (variância/covariância): (\boldsymbol{\Sigma}_*)

A incerteza, naturalmente:

  • cresce longe dos dados,
  • diminui perto de pontos observados,
  • reflete a suavidade assumida via kernel.

Exemplo Prático: Regressão 1D com Incerteza (scikit-learn)

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

# Training data: noisy samples of a function
rng = np.random.default_rng(0)
X = rng.uniform(0, 10, size=(20, 1))
y = np.sin(X[:, 0]) + 0.2 * rng.normal(size=20)

# Kernel: signal amplitude * RBF(length_scale) + noise
kernel = ConstantKernel(1.0) * RBF(length_scale=1.0) + WhiteKernel(noise_level=0.1)

gpr = GaussianProcessRegressor(kernel=kernel, normalize_y=True, random_state=0)
gpr.fit(X, y)

# Predictions
X_test = np.linspace(0, 10, 400).reshape(-1, 1)
mean, std = gpr.predict(X_test, return_std=True)

plt.scatter(X[:, 0], y, label="data")
plt.plot(X_test[:, 0], mean, label="GP mean")
plt.fill_between(X_test[:, 0], mean - 2*std, mean + 2*std, alpha=0.2, label="95% interval")
plt.legend()
plt.show()

print("Learned kernel:", gpr.kernel_)

Principais pontos:

  • A faixa de confiança é um artefato imediato e acionável.
  • Os hiperparâmetros aprendidos (escala de comprimento, ruído) refletem a suavidade e o ruído inferidos.

Aprendendo Hiperparâmetros via Verossimilhança Marginal

GPs normalmente aprendem hiperparâmetros do kernel (\theta) (por exemplo, escala de comprimento (\ell), variâncias, ruído) maximizando a log-verossimilhança marginal (log marginal likelihood):

[ \log p(\mathbf{y}\mid X, \theta) = -\frac{1}{2}\mathbf{y}^\top(\mathbf{K}\theta + \sigma_n^2\mathbf{I})^{-1}\mathbf{y} -\frac{1}{2}\log|\mathbf{K}\theta + \sigma_n^2\mathbf{I}| -\frac{n}{2}\log(2\pi) ]

Esse objetivo automaticamente faz o trade-off entre:

  • ajuste aos dados (primeiro termo),
  • complexidade do modelo (termo do log do determinante),
  • constante de normalização.

Esse é um dos motivos pelos quais GPs costumam ser fortes baselines em comparação com métodos de kernel ajustados manualmente, ou até mesmo alguns modelos flexíveis como Árvores de Decisão e Conjuntos quando os dados são limitados.

Notas práticas

  • Sempre dimensione as entradas (por exemplo, padronize as características). Escalas de comprimento ficam mais fáceis de interpretar e otimizar.
  • Se as saídas tiverem uma tendência, considere uma função média diferente de zero ou inclua um termo de kernel linear.

Classificação por Processo Gaussiano (GPC)

Para classificação, as saídas são discretas (por exemplo, (y \in {0,1})), então usamos uma função latente (f(x)) passada por uma verossimilhança de compressão (squashing):

[ p(y=1 \mid f) = \sigma(f) \quad \text{(logistic)} \quad \text{or} \quad \Phi(f)\ \text{(probit)} ]

O prior em (f) ainda é um GP, mas a posteriori deixa de ser Gaussiana porque a verossimilhança é não Gaussiana. Portanto, a inferência tipicamente usa aproximações como:

  • aproximação de Laplace (Laplace approximation)
  • Propagação de Expectativa (Expectation Propagation, EP)
  • inferência variacional (variational inference)

A classificação com GP pode ser competitiva com classificadores com kernel como Máquinas de Vetores de Suporte, com uma diferença-chave: um GP produz previsões probabilísticas com incerteza, enquanto SVMs não são bayesianas por padrão.

Complexidade Computacional e Escalonamento

Um passo padrão de treino de regressão com GP requer:

  • construir uma matriz de kernel (n \times n),
  • realizar uma decomposição de Cholesky (Cholesky decomposition),

o que custa:

  • Tempo: (O(n^3))
  • Memória: (O(n^2))

Essa é a principal limitação dos GPs clássicos.

Aproximações de GP escaláveis (comuns na prática moderna)

  • Métodos esparsos/de pontos indutores (inducing points): aproximam o GP usando (m \ll n) pontos indutores (por exemplo, FITC, GPs indutores variacionais). Muitas vezes (O(nm^2)).
  • GPs variacionais estocásticos (stochastic variational GPs): treinamento com minilotes (minibatch) usando pontos indutores (popular em bibliotecas como GPyTorch).
  • interpolação estruturada de kernel (Structured Kernel Interpolation, SKI/KISS-GP): explora estrutura para operações rápidas com matrizes.
  • Características de Fourier Aleatórias (Random Fourier Features): aproximam kernels invariantes a deslocamento com características de dimensão finita (fazendo a ponte em direção a modelos lineares).

Esses métodos estendem GPs para conjuntos de dados muito maiores, preservando estimativas de incerteza (em diferentes graus).

Conexões com Outros Modelos de ML

Relação com regressão linear bayesiana

Com um kernel linear, a regressão por GP se torna equivalente à regressão linear bayesiana com um prior Gaussiano nos pesos. Isso fornece intuição: kernels podem ser vistos como definindo um espaço de características (feature space) (frequentemente de dimensão infinita) com um prior bayesiano.

Isso também conecta GPs a Regressão Linear/Logística (como uma generalização bayesiana) e a métodos de kernel (como máquinas de kernel probabilísticas).

Relação com máquinas de kernel e SVMs

  • Ambas dependem de kernels para representar similaridade.
  • SVMs otimizam um objetivo baseado em margem; GPs otimizam um objetivo probabilístico de evidência.
  • GPs fornecem distribuições preditivas, não apenas fronteiras de decisão.

Relação com redes neurais

Certas redes neurais de largura infinita convergem para processos Gaussianos (a perspectiva “NN-GP”). Na prática, muitos fluxos de trabalho modernos combinam extratores profundos de características com GPs para incerteza calibrada (“aprendizado profundo de kernel (deep kernel learning)”).

Aplicações Práticas

1) Otimização bayesiana

GPs são um modelo substituto padrão para otimizar funções de caixa-preta caras (ajuste de hiperparâmetros, design de materiais, robótica). O GP fornece:

  • uma estimativa da média do objetivo,
  • incerteza usada por funções de aquisição (por exemplo, Expected Improvement, UCB).

Isso dá suporte diretamente a exploração vs. exploração.

2) Aprendizado ativo / planejamento experimental

Quando rótulos são caros, um GP pode quantificar onde a incerteza é maior e consultar rótulos de forma estratégica. Isso é valioso em contextos científicos e médicos.

3) Séries temporais e modelagem espacial

Com kernels periódicos, aproximações em espaço de estados (state-space) ou kernels estruturados, GPs são usados para:

  • modelagem de sazonalidade e tendência,
  • geoestatística (krigagem (kriging)),
  • fusão de sensores.

Para fluxos de trabalho dedicados de previsão, veja Previsão de Séries Temporais, mas GPs frequentemente são uma excelente alternativa probabilística quando você quer priors flexíveis e intervalos credíveis (credible intervals).

4) Detecção de anomalias e monitoramento de incerteza

GPs podem sinalizar anomalias quando observações ficam muito fora da distribuição preditiva, ou quando a incerteza preditiva dispara. Isso se conecta naturalmente à Detecção de Anomalias, especialmente em cenários de monitoramento e industriais.

5) Modelos substitutos em engenharia

Simulações por elementos finitos e experimentos físicos podem ser caros; GPs fornecem substitutos eficientes em amostras, com incerteza usada para decisões de projeto sensíveis a risco.

Dicas de Projeto de Modelo (O que Geralmente Importa na Prática)

Escolha kernels com base na estrutura do domínio

Pergunte que tipo de funções fazem sentido:

  • Suaves? Use RBF ou Matérn.
  • Periódicas? Adicione um termo periódico.
  • Tendência + variação local? Linear + Matérn.
  • Múltiplas taxas de variação? Use escalas de comprimento ARD (determinação automática de relevância (Automatic Relevance Determination, ARD)) (uma escala de comprimento por característica).

Normalize seus dados

  • Padronize características.
  • Centralize/escale os alvos ou use normalize_y=True em ferramentas como scikit-learn.

Seja explícito sobre ruído

Se medições forem ruidosas, inclua um termo explícito de ruído (por exemplo, WhiteKernel) e considere variantes heteroscedásticas (heteroscedastic) se o ruído variar ao longo das entradas.

Cuidado em alta dimensionalidade

Kernels baseados em distância (RBF/Matérn) podem ter dificuldades conforme a dimensão cresce, porque as distâncias se concentram. Mitigações comuns:

  • redução de dimensionalidade (veja Redução de Dimensionalidade),
  • incorporações aprendidas (características profundas),
  • kernels aditivos (soma de kernels 1D/baixa dimensão).

Limitações e Modos de Falha

  • Escalonamento cúbico em (n) sem aproximações.
  • Especificação incorreta do kernel: a incerteza pode ser enganosa se o kernel codificar suposições erradas (por exemplo, RBF excessivamente suave para uma função rugosa).
  • Armadilhas na otimização de hiperparâmetros: a verossimilhança marginal pode ter ótimos locais; a inicialização importa.
  • Não estacionariedade (nonstationarity): muitos kernels assumem estacionariedade (stationarity) (as estatísticas não mudam com a localização). Sistemas reais podem exigir kernels não estacionários ou distorção de entrada (input warping).
  • Classificação exige aproximação: a posteriori não é exata para verossimilhanças não Gaussianas.

Glossário Mínimo

  • Kernel / função de covariância: Codifica similaridade e suposições a priori sobre a forma da função.
  • Escala de comprimento: Controla quão rapidamente a função pode mudar.
  • Verossimilhança marginal (evidência): Probabilidade dos dados sob o modelo; usada para aprender hiperparâmetros.
  • Distribuição preditiva a posteriori: A distribuição do GP sobre saídas em novas entradas, fornecendo média e incerteza.

Quando Usar Processos Gaussianos

Processos Gaussianos são uma escolha forte quando:

  • você tem dados limitados e quer um viés indutivo forte,
  • quantificação de incerteza é importante,
  • você consegue codificar estrutura significativa via kernels,
  • interpretabilidade e inferência bayesiana principiada importam.

Se seu conjunto de dados é enorme ou as entradas são dados brutos não estruturados (imagens/áudio), considere usar GPs sobre representações aprendidas ou usar aproximações escaláveis — ou compare com baselines fortes como Árvores de Decisão e Conjuntos e modelos profundos.

Prática Adicional: Um Próximo Passo Comum

Depois que você entende regressão por GP, um próximo passo prático é implementar otimização bayesiana com um GP substituto, porque isso obriga você a usar incerteza em um ciclo de decisão (não apenas plotar barras de erro). Essa é uma das aplicações mais “nativas de GP” e destaca por que o aprendizado probabilístico de funções é tão útil.