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.