Previsões Probabilísticas com Classificação de Processos Gaussianos

Introdução

Neste laboratório, exploraremos a Classificação por Processo Gaussiano (GPC) com um kernel RBF e diferentes escolhas de hiperparâmetros. Geraremos dados, treinaremos o modelo GPC com hiperparâmetros fixos e otimizados, e plotaremos os posteriors e o panorama da verossimilhança marginal logarítmica. Também avaliaremos a precisão e a perda logarítmica do modelo.

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 de carregar. 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.

Importar Bibliotecas

Importaremos as bibliotecas necessárias para este laboratório.

import numpy as np
from matplotlib import pyplot as plt
from sklearn.metrics import accuracy_score, log_loss
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF

Gerar Dados

Geraremos dados usando o NumPy. Geraremos 100 pontos de dados com uma distribuição uniforme entre 0 e 5. Definiremos o limite em 2,5 e geraremos as etiquetas usando uma expressão booleana. Usaremos os primeiros 50 pontos de dados como dados de treino e o restante como dados de teste.

train_size = 50
rng = np.random.RandomState(0)
X = rng.uniform(0, 5, 100)[:, np.newaxis]
y = np.array(X[:, 0] > 2.5, dtype=int)

Treinar o Modelo

Treinaremos o modelo GPC usando hiperparâmetros fixos e otimizados. Imprimiremos o log-marginal-likelihood, a precisão e a log-loss dos modelos.

## Hiperparâmetros Fixos
gp_fix = GaussianProcessClassifier(kernel=1.0 * RBF(length_scale=1.0), optimizer=None)
gp_fix.fit(X[:train_size], y[:train_size])

## Hiperparâmetros Otimizados
gp_opt = GaussianProcessClassifier(kernel=1.0 * RBF(length_scale=1.0))
gp_opt.fit(X[:train_size], y[:train_size])

## Resultados
print("Log Marginal Likelihood (inicial): %.3f" % gp_fix.log_marginal_likelihood(gp_fix.kernel_.theta))
print("Log Marginal Likelihood (otimizado): %.3f" % gp_opt.log_marginal_likelihood(gp_opt.kernel_.theta))
print("Precisão: %.3f (inicial) %.3f (otimizado)" % (accuracy_score(y[:train_size], gp_fix.predict(X[:train_size])), accuracy_score(y[:train_size], gp_opt.predict(X[:train_size]))))
print("Log-loss: %.3f (inicial) %.3f (otimizado)" % (log_loss(y[:train_size], gp_fix.predict_proba(X[:train_size])[:, 1]), log_loss(y[:train_size], gp_opt.predict_proba(X[:train_size])[:, 1])))

Plotar Posteriores

Plotaremos os posteriors do modelo GPC usando hiperparâmetros fixos e otimizados. Plotaremos os dados de treino, os dados de teste e a probabilidade prevista da classe 1. Também rotularemos os gráficos.

## Plotar posteriors
plt.figure()
plt.scatter(X[:train_size, 0], y[:train_size], c="k", label="Dados de treino", edgecolors=(0, 0, 0))
plt.scatter(X[train_size:, 0], y[train_size:], c="g", label="Dados de teste", edgecolors=(0, 0, 0))
X_ = np.linspace(0, 5, 100)
plt.plot(X_, gp_fix.predict_proba(X_[:, np.newaxis])[:, 1], "r", label="Kernel inicial: %s" % gp_fix.kernel_)
plt.plot(X_, gp_opt.predict_proba(X_[:, np.newaxis])[:, 1], "b", label="Kernel otimizado: %s" % gp_opt.kernel_)
plt.xlabel("Característica")
plt.ylabel("Probabilidade da classe 1")
plt.xlim(0, 5)
plt.ylim(-0.25, 1.5)
plt.legend(loc="best")

Plotar o Paisagem do LML

Plotaremos a paisagem do log-marginal-likelihood do modelo GPC usando diferentes escolhas de hiperparâmetros. Destacaremos os hiperparâmetros usados no gráfico anterior. Também rotularemos os gráficos.

## Plotar o paisagem do LML
plt.figure()
theta0 = np.logspace(0, 8, 30)
theta1 = np.logspace(-1, 1, 29)
Theta0, Theta1 = np.meshgrid(theta0, theta1)
LML = [[gp_opt.log_marginal_likelihood(np.log([Theta0[i, j], Theta1[i, j]])) for i in range(Theta0.shape[0])] for j in range(Theta0.shape[1])]
LML = np.array(LML).T
plt.plot(np.exp(gp_fix.kernel_.theta)[0], np.exp(gp_fix.kernel_.theta)[1], "ko", zorder=10)
plt.plot(np.exp(gp_opt.kernel_.theta)[0], np.exp(gp_opt.kernel_.theta)[1], "ko", zorder=10)
plt.pcolor(Theta0, Theta1, LML)
plt.xscale("log")
plt.yscale("log")
plt.colorbar()
plt.xlabel("Magnitude")
plt.ylabel("Escala de comprimento")
plt.title("Log-marginal-likelihood")

Resumo

Neste laboratório, exploramos a Classificação de Processos Gaussianos (GPC) com um kernel RBF e diferentes escolhas de hiperparâmetros. Geramos dados, treinamos o modelo GPC com hiperparâmetros fixos e otimizados, e plotamos os posteriors e a paisagem do log-marginal-likelihood. Também avaliamos a precisão e a perda logarítmica do modelo.