Regressão por Processo Gaussiano: Kernels

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.