Gráfico Comparativo de Regressão por Processo Gaussiano e Regressão Kernel Ridge

Introdução

Este laboratório ilustrará as diferenças entre uma regressão de ridge kernel e uma regressão de processo gaussiano e como elas são usadas para ajustar um conjunto de dados. Também nos concentraremos na afinação dos hiperparâmetros do kernel.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, 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 a aprendizagem, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos prontamente o problema para si.

Gerando um conjunto de dados

Criamos um conjunto de dados sintético. O verdadeiro processo gerador receberá um vetor 1-D e calculará seu seno.

import numpy as np

rng = np.random.RandomState(0)
data = np.linspace(0, 30, num=1_000).reshape(-1, 1)
target = np.sin(data).ravel()

training_sample_indices = rng.choice(np.arange(0, 400), size=40, replace=False)
training_data = data[training_sample_indices]
training_noisy_target = target[training_sample_indices] + 0.5 * rng.randn(
    len(training_sample_indices)
)

Limitações de um modelo linear simples

Ajustamos um modelo Ridge e verificamos as previsões deste modelo no nosso conjunto de dados.

from sklearn.linear_model import Ridge
import matplotlib.pyplot as plt

ridge = Ridge().fit(training_data, training_noisy_target)

plt.plot(data, target, label="Sinal verdadeiro", linewidth=2)
plt.scatter(
    training_data,
    training_noisy_target,
    color="black",
    label="Medições ruidosas",
)
plt.plot(data, ridge.predict(data), label="Regressão Ridge")
plt.legend()
plt.xlabel("Dados")
plt.ylabel("Alvo")
_ = plt.title("Limitação de um modelo linear como o ridge")

Métodos de Kernel: Kernel Ridge e Processo Gaussiano

Kernel Ridge

Utilizamos um KernelRidge com um kernel ExpSineSquared, que permite recuperar a periodicidade.

from sklearn.kernel_ridge import KernelRidge
from sklearn.gaussian_process.kernels import ExpSineSquared

kernel_ridge = KernelRidge(kernel=ExpSineSquared())

kernel_ridge.fit(training_data, training_noisy_target)

plt.plot(data, target, label="Sinal verdadeiro", linewidth=2, linestyle="dashed")
plt.scatter(
    training_data,
    training_noisy_target,
    color="black",
    label="Medições ruidosas",
)
plt.plot(
    data,
    kernel_ridge.predict(data),
    label="Kernel ridge",
    linewidth=2,
    linestyle="dashdot",
)
plt.legend(loc="lower right")
plt.xlabel("Dados")
plt.ylabel("Alvo")
_ = plt.title(
    "Regressão Kernel Ridge com um kernel exponencial seno ao quadrado\n "
    "usando hiperparâmetros padrão"
)

Regressão por Processo Gaussiano

Utilizamos um GaussianProcessRegressor para ajustar o mesmo conjunto de dados. Ao treinar um processo gaussiano, os hiperparâmetros do kernel são otimizados durante o processo de ajuste.

from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import WhiteKernel

kernel = 1.0 * ExpSineSquared(1.0, 5.0, periodicity_bounds=(1e-2, 1e1)) + WhiteKernel(
    1e-1
)
gaussian_process = GaussianProcessRegressor(kernel=kernel)

gaussian_process.fit(training_data, training_noisy_target)

mean_predictions_gpr, std_predictions_gpr = gaussian_process.predict(
    data, return_std=True,
)

plt.plot(data, target, label="Sinal verdadeiro", linewidth=2, linestyle="dashed")
plt.scatter(
    training_data,
    training_noisy_target,
    color="black",
    label="Medições ruidosas",
)
plt.plot(
    data,
    mean_predictions_gpr,
    label="Regressão por Processo Gaussiano",
    linewidth=2,
    linestyle="dotted",
)
plt.fill_between(
    data.ravel(),
    mean_predictions_gpr - std_predictions_gpr,
    mean_predictions_gpr + std_predictions_gpr,
    color="tab:green",
    alpha=0.2,
)
plt.legend(loc="lower right")
plt.xlabel("Dados")
plt.ylabel("Alvo")
_ = plt.title("Regressão por Processo Gaussiano")

Conclusão Final

Podemos dar uma palavra final sobre a possibilidade dos dois modelos extrapolarem. Observamos que os modelos continuarão a prever o padrão senoidal.

kernel = 1.0 * ExpSineSquared(1.0, 5.0, periodicity_bounds=(1e-2, 1e1)) * RBF(
    length_scale=15, length_scale_bounds="fixed"
) + WhiteKernel(1e-1)
gaussian_process = GaussianProcessRegressor(kernel=kernel)

gaussian_process.fit(training_data, training_noisy_target)

mean_predictions_gpr, std_predictions_gpr = gaussian_process.predict(
    data, return_std=True,
)

plt.plot(data, target, label="Sinal verdadeiro", linewidth=2, linestyle="dashed")
plt.scatter(
    training_data,
    training_noisy_target,
    color="black",
    label="Medições ruidosas",
)
plt.plot(
    data,
    mean_predictions_gpr,
    label="Regressão por Processo Gaussiano",
    linewidth=2,
    linestyle="dotted",
)
plt.fill_between(
    data.ravel(),
    mean_predictions_gpr - std_predictions_gpr,
    mean_predictions_gpr + std_predictions_gpr,
    color="tab:green",
    alpha=0.2,
)
plt.legend(loc="lower right")
plt.xlabel("Dados")
plt.ylabel("Alvo")
_ = plt.title("Comparação entre regressão Kernel Ridge e regressão por processo gaussiano")

Resumo

Neste laboratório, comparamos a regressão Kernel Ridge e a regressão por Processo Gaussiano. Aprendemos que o regressor por processo gaussiano fornece informações sobre incerteza que não estão disponíveis com a regressão Kernel Ridge. O processo gaussiano permite combinar kernels juntos.