Regressão e Classificação por Processos Gaussianos

Introdução

Neste laboratório, exploraremos os Processos Gaussianos (GP), um método de aprendizagem supervisionada utilizado para problemas de regressão e classificação probabilística. Os Processos Gaussianos são versáteis e podem interpolar observações, fornecer previsões probabilísticas e lidar com diferentes tipos de núcleos. Neste laboratório, focaremos na Regressão por Processos Gaussianos (GPR) e na Classificação por Processos Gaussianos (GPC) utilizando a biblioteca scikit-learn.

Dicas da Máquina Virtual

Após o arranque da VM, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar o carregamento. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Regressão por Processo Gaussiano (GPR)

A classe GaussianProcessRegressor implementa processos gaussianos para tarefas de regressão. Requer a especificação de uma prior para o GP, como as funções de média e covariância. Os hiperparâmetros do kernel são otimizados durante o processo de ajuste. Vejamos um exemplo de utilização de GPR para regressão.

from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF

## Cria um modelo GPR com um kernel RBF
kernel = RBF()
model = GaussianProcessRegressor(kernel=kernel)

## Ajusta o modelo aos dados de treino
model.fit(X_train, y_train)

## Prediz usando o modelo treinado
y_pred = model.predict(X_test)

Exemplos de GPR

GPR com estimativa de nível de ruído: Este exemplo ilustra GPR com um kernel soma incluindo um WhiteKernel para estimar o nível de ruído dos dados.

from sklearn.gaussian_process.kernels import WhiteKernel

## Cria um modelo GPR com um kernel RBF e um WhiteKernel
kernel = RBF() + WhiteKernel()
model = GaussianProcessRegressor(kernel=kernel)

## Ajusta o modelo aos dados de treino
model.fit(X_train, y_train)

## Prediz usando o modelo treinado
y_pred = model.predict(X_test)

Comparação de GPR e Regressão de Ridge com Kernel: Tanto a regressão de ridge com kernel (KRR) como o GPR aprendem uma função alvo usando o "truque do kernel". O GPR aprende um modelo probabilístico gerativo e pode fornecer intervalos de confiança, enquanto a KRR apenas fornece previsões.

from sklearn.kernel_ridge import KernelRidge

## Cria um modelo de Regressão de Ridge com Kernel
krr_model = KernelRidge(kernel='rbf')

## Ajusta o modelo KRR aos dados de treino
krr_model.fit(X_train, y_train)

## Prediz usando o modelo KRR
krr_y_pred = krr_model.predict(X_test)

## Compara os resultados com o GPR
gpr_model = GaussianProcessRegressor(kernel=RBF())
gpr_model.fit(X_train, y_train)
gpr_y_pred = gpr_model.predict(X_test)

GPR em dados de CO2 de Mauna Loa: Este exemplo demonstra a engenharia de kernel complexa e a otimização de hiperparâmetros usando ascensão de gradiente na verossimilhança marginal logarítmica. Os dados consistem em concentrações médias atmosféricas mensais de CO2 coletadas no Observatório de Mauna Loa no Havaí. O objetivo é modelar a concentração de CO2 como função do tempo.

from sklearn.gaussian_process.kernels import RBF, ExpSineSquared, RationalQuadratic, WhiteKernel

## Cria um modelo GPR com um kernel composto
kernel = 34.4**2 * RBF(length_scale=41.8) + 3.27**2 * RBF(length_scale=180) * ExpSineSquared(length_scale=1.44, periodicity=1) + 0.446**2 * RationalQuadratic(alpha=17.7, length_scale=0.957) + 0.197**2 * RBF(length_scale=0.138) + WhiteKernel(noise_level=0.0336)
model = GaussianProcessRegressor(kernel=kernel)

## Ajusta o modelo aos dados
model.fit(X_train, y_train)

## Prediz usando o modelo treinado
y_pred = model.predict(X_test)

Classificação por Processo Gaussiano (GPC)

A classe GaussianProcessClassifier implementa GPC para classificação probabilística. Ela coloca uma prior de GP em uma função latente, que é então comprimida por meio de uma função de ligação para obter as probabilidades de classe. O GPC suporta classificação multiclasse realizando treinamento e previsão baseados em um contra todos ou um contra um.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split

X = np.linspace(0, 10, 100).reshape(-1, 1)
y = np.sin(X).ravel() + np.random.normal(0, 0.1, X.shape[0])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

from sklearn.gaussian_process import GaussianProcessClassifier

## Cria um modelo GPC com um kernel RBF
kernel = RBF()
model = GaussianProcessClassifier(kernel=kernel)

## Ajusta o modelo aos dados de treino
model.fit(X_train, y_train)

## Prediz usando o modelo treinado
y_pred = model.predict(X_test)

Exemplos de GPC

Previsões probabilísticas com GPC: Este exemplo ilustra a probabilidade prevista de GPC com diferentes escolhas de hiperparâmetros.

## Cria um modelo GPC com um kernel RBF
kernel = RBF()
model = GaussianProcessClassifier(kernel=kernel)

## Ajusta o modelo aos dados de treino
model.fit(X_train, y_train)

## Prediz as probabilidades de classe dos dados de teste
y_prob = model.predict_proba(X_test)

Ilustração de GPC no conjunto de dados XOR: Este exemplo demonstra o uso de GPC no conjunto de dados XOR. Comparamos os resultados do uso de um kernel estacionário e isotrópico (RBF) e um kernel não estacionário (DotProduct).

## Cria modelos GPC com diferentes kernels
kernel_isotrópico = RBF(length_scale=1.0)
kernel_não_estacionário = DotProduct(sigma_0=1.0)

## Ajusta os modelos ao conjunto de dados XOR
modelo_isotrópico = GaussianProcessClassifier(kernel=kernel_isotrópico)
modelo_não_estacionário = GaussianProcessClassifier(kernel=kernel_não_estacionário)
modelo_isotrópico.fit(X_xor, y_xor)
modelo_não_estacionário.fit(X_xor, y_xor)

## Prediz usando os modelos treinados
pred_isotrópico = modelo_isotrópico.predict(X_test)
pred_não_estacionário = modelo_não_estacionário.predict(X_test)

GPC no conjunto de dados iris: Este exemplo ilustra o GPC no conjunto de dados iris usando um kernel RBF isotrópico e um kernel RBF anisotrópico. Mostra como diferentes escolhas de hiperparâmetros podem afetar a probabilidade prevista.

## Cria modelos GPC com diferentes kernels e ajusta-os ao conjunto de dados iris
kernel_isotrópico = RBF(length_scale=1.0)
kernel_anisotrópico = RBF(length_scale=[1.0, 2.0])
modelo_isotrópico = GaussianProcessClassifier(kernel=kernel_isotrópico)
modelo_anisotrópico = GaussianProcessClassifier(kernel=kernel_anisotrópico)
modelo_isotrópico.fit(X_train, y_train)
modelo_anisotrópico.fit(X_train, y_train)

## Prediz as probabilidades de classe
prob_isotrópico = modelo_isotrópico.predict_proba(X_test)
prob_anisotrópico = modelo_anisotrópico.predict_proba(X_test)

Resumo

Neste laboratório, exploramos Processos Gaussianos (GP) e suas aplicações em tarefas de regressão e classificação. Aprendemos como usar as classes GaussianProcessRegressor e GaussianProcessClassifier do scikit-learn, e como especificar diferentes tipos de kernels para GPs. Também vimos exemplos de GPR para tarefas de regressão e GPC para tarefas de classificação multiclasse, demonstrando a versatilidade e as capacidades dos Processos Gaussianos.