Introdução
Este laboratório demonstra como usar diferentes núcleos para Regressão por Processo Gaussiano (GPR) na biblioteca Scikit-learn do Python. GPR é uma técnica de regressão não paramétrica que pode ajustar modelos complexos a dados com ruído. Uma função kernel é usada para determinar a similaridade entre quaisquer dois pontos de entrada. A escolha da função kernel é importante, pois determina a forma do modelo que é ajustado aos dados. Neste laboratório, abordaremos os núcleos mais usados em GPR.
Dicas da Máquina Virtual
Após o início da VM, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.
Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.
Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para você.
Importar bibliotecas
Começamos importando as bibliotecas necessárias.
import matplotlib.pyplot as plt
import numpy as np
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, RationalQuadratic, ExpSineSquared, ConstantKernel, DotProduct, Matern
Criar dados de treino
Em seguida, criamos um conjunto de dados de treino que usaremos nas diferentes seções.
rng = np.random.RandomState(4)
X_train = rng.uniform(0, 5, 10).reshape(-1, 1)
y_train = np.sin((X_train[:, 0] - 2.5) ** 2)
n_samples = 5
Função auxiliar
Antes de apresentar cada kernel individual disponível para processos gaussianos, definiremos uma função auxiliar que nos permitirá plotar amostras extraídas do processo gaussiano.
def plot_gpr_samples(gpr_model, n_samples, ax):
"""Plotar amostras extraídas do modelo de processo gaussiano.
Se o modelo de processo gaussiano não estiver treinado, as amostras extraídas serão
extraídas da distribuição a priori. Caso contrário, as amostras serão extraídas da
distribuição a posteriori. Note que uma amostra aqui corresponde a uma
função.
Parâmetros
----------
gpr_model : `GaussianProcessRegressor`
Um modelo :class:`~sklearn.gaussian_process.GaussianProcessRegressor`.
n_samples : int
O número de amostras a extrair da distribuição do processo gaussiano.
ax : matplotlib axis
O eixo matplotlib onde plotar as amostras.
"""
x = np.linspace(0, 5, 100)
X = x.reshape(-1, 1)
y_mean, y_std = gpr_model.predict(X, return_std=True)
y_samples = gpr_model.sample_y(X, n_samples)
for idx, single_prior in enumerate(y_samples.T):
ax.plot(
x,
single_prior,
linestyle="--",
alpha=0.7,
label=f"Função amostrada #{idx + 1}",
)
ax.plot(x, y_mean, color="black", label="Média")
ax.fill_between(
x,
y_mean - y_std,
y_mean + y_std,
alpha=0.1,
color="black",
label=r"$\pm$ 1 desvio padrão",
)
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_ylim([-3, 3])
Kernel de Função de Base Radial
O kernel de Função de Base Radial (RBF) é definido como:
$$ k(x_i, x_j) = \exp \left( -\frac{|x_i - x_j|^2}{2\ell^2} \right) $$
onde $\ell$ é o parâmetro de escala de comprimento.
kernel = 1.0 * RBF(length_scale=1.0, length_scale_bounds=(1e-1, 10.0))
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)
fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))
## plotar a priori
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Amostras da distribuição a priori")
## plotar a posteriori
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observações")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Amostras da distribuição a posteriori")
fig.suptitle("Kernel de Função de Base Radial", fontsize=18)
plt.tight_layout()
Kernel Racional Quadrático
O kernel Racional Quadrático é definido como:
$$ k(x_i, x_j) = \left( 1 + \frac{|x_i - x_j|^2}{2\alpha\ell^2} \right)^{-\alpha} $$
onde $\ell$ é o parâmetro de escala de comprimento e $\alpha$ controla o peso relativo de características de pequena e grande escala.
kernel = 1.0 * RationalQuadratic(length_scale=1.0, alpha=0.1, alpha_bounds=(1e-5, 1e15))
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)
fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))
## plotar a priori
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Amostras da distribuição a priori")
## plotar a posteriori
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observações")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Amostras da distribuição a posteriori")
fig.suptitle("Kernel Racional Quadrático", fontsize=18)
plt.tight_layout()
Kernel Exp-Sine-Squared
O kernel Exp-Sine-Squared é definido como:
$$ k(x_i, x_j) = \exp \left( -\frac{2\sin^2(\pi|x_i - x_j|/p)}{\ell^2} \right) $$
onde $\ell$ é o parâmetro de escala de comprimento e $p$ controla a periodicidade.
kernel = 1.0 * ExpSineSquared(
length_scale=1.0,
periodicity=3.0,
length_scale_bounds=(0.1, 10.0),
periodicity_bounds=(1.0, 10.0),
)
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)
fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))
## plotar a priori
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Amostras da distribuição a priori")
## plotar a posteriori
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observações")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Amostras da distribuição a posteriori")
fig.suptitle("Kernel Exp-Sine-Squared", fontsize=18)
plt.tight_layout()
Kernel Produto Escalar
O kernel Produto Escalar é definido como:
$$ k(x_i, x_j) = (\sigma_0 + x_i^T x_j)^2 $$
onde $\sigma_0$ é uma constante.
kernel = ConstantKernel(0.1, (0.01, 10.0)) * (
DotProduct(sigma_0=1.0, sigma_0_bounds=(0.1, 10.0)) ** 2
)
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)
fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))
## plotar a priori
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Amostras da distribuição a priori")
## plotar a posteriori
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observações")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Amostras da distribuição a posteriori")
fig.suptitle("Kernel Produto Escalar", fontsize=18)
plt.tight_layout()
Kernel Matérn
O kernel Matérn é definido como:
$$ k(x_i, x_j) = \frac{1}{\Gamma(\nu)2^{\nu-1}}\left(\frac{\sqrt{2\nu}}{\ell}|x_i - x_j|\right)^\nu K_\nu\left(\frac{\sqrt{2\nu}}{\ell}|x_i - x_j|\right) $$
onde $\ell$ é o parâmetro de escala de comprimento e $\nu$ controla a suavidade da função.
kernel = 1.0 * Matern(length_scale=1.0, length_scale_bounds=(1e-1, 10.0), nu=1.5)
gpr = GaussianProcessRegressor(kernel=kernel, random_state=0)
fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True, figsize=(10, 8))
## plotar a priori
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[0])
axs[0].set_title("Amostras da distribuição a priori")
## plotar a posteriori
gpr.fit(X_train, y_train)
plot_gpr_samples(gpr, n_samples=n_samples, ax=axs[1])
axs[1].scatter(X_train[:, 0], y_train, color="red", zorder=10, label="Observações")
axs[1].legend(bbox_to_anchor=(1.05, 1.5), loc="upper left")
axs[1].set_title("Amostras da distribuição a posteriori")
fig.suptitle("Kernel Matérn", fontsize=18)
plt.tight_layout()
Resumo
Neste laboratório, aprendemos como usar diferentes kernels para Regressão por Processo Gaussiano na biblioteca Scikit-learn do Python. Cobrimos os kernels mais comumente usados em RPG, incluindo o kernel de Função de Base Radial, o kernel Racional Quadrático, o kernel Exp-Sine-Squared, o kernel Produto Escalar e o kernel Matérn. Também aprendemos como plotar amostras extraídas do processo gaussiano usando uma função auxiliar.
Resumo
Parabéns! Você concluiu o laboratório Regressão por Processo Gaussiano: Kernels. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.