Modelagem Preditiva Não Linear Usando Processo Gaussiano

Introdução

A regressão por processos gaussianos é uma técnica de modelagem estatística usada para prever o resultado de uma variável-alvo com base em variáveis de entrada. A técnica modela a distribuição da variável-alvo como um processo gaussiano, que é uma coleção de variáveis aleatórias, quaisquer que sejam o número finito delas que tenham uma distribuição gaussiana conjunta. A técnica é particularmente útil em casos onde a relação entre as variáveis de entrada e a variável-alvo é não-linear.

Neste laboratório, aprenderemos a usar a regressão por processos gaussianos com estimativa do nível de ruído em Python, utilizando a biblioteca scikit-learn.

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 o carregamento. 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.

Geração de Dados

Nesta etapa, geraremos alguns dados com um único recurso usando uma função seno.

import numpy as np

def target_generator(X, add_noise=False):
    target = 0.5 + np.sin(3 * X)
    if add_noise:
        rng = np.random.RandomState(1)
        target += rng.normal(0, 0.3, size=target.shape)
    return target.squeeze()

X = np.linspace(0, 5, num=30).reshape(-1, 1)
y = target_generator(X, add_noise=False)

Visualização de Dados

Nesta etapa, visualizaremos os dados gerados.

import matplotlib.pyplot as plt

plt.plot(X, y, label="Sinal esperado")
plt.legend()
plt.xlabel("X")
_ = plt.ylabel("y")

Adicionando Ruído

Nesta etapa, adicionaremos algum ruído aos dados gerados para criar um conjunto de dados de treinamento mais realista.

rng = np.random.RandomState(0)
X_train = rng.uniform(0, 5, size=20).reshape(-1, 1)
y_train = target_generator(X_train, add_noise=True)

Visualização de Dados

Nesta etapa, visualizaremos o conjunto de dados de treinamento ruidoso juntamente com o sinal esperado.

plt.plot(X, y, label="Sinal esperado")
plt.scatter(
    x=X_train[:, 0],
    y=y_train,
    color="black",
    alpha=0.4,
    label="Observações",
)
plt.legend()
plt.xlabel("X")
_ = plt.ylabel("y")

Regressão por Processo Gaussiano

Nesta etapa, criaremos um regressor de processo gaussiano usando um kernel aditivo que adiciona kernels RBF e WhiteKernel. O WhiteKernel é um kernel que será capaz de estimar a quantidade de ruído presente nos dados, enquanto o RBF servirá para ajustar a não-linearidade entre os dados e o alvo.

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

kernel = 1.0 * RBF(length_scale=1e-1, length_scale_bounds=(1e-2, 1e3)) + WhiteKernel(
    noise_level=1e-2, noise_level_bounds=(1e-10, 1e1)
)
gpr = GaussianProcessRegressor(kernel=kernel, alpha=0.0)
gpr.fit(X_train, y_train)
y_mean, y_std = gpr.predict(X, return_std=True)

Visualização de Dados

Nesta etapa, visualizaremos as previsões feitas pelo regressor de processo gaussiano.

plt.plot(X, y, label="Sinal esperado")
plt.scatter(x=X_train[:, 0], y=y_train, color="black", alpha=0.4, label="Observações")
plt.errorbar(X, y_mean, y_std)
plt.legend()
plt.xlabel("X")
plt.ylabel("y")
_ = plt.title(
    (
        f"Inicial: {kernel}\nÓptimo: {gpr.kernel_}\nLog-Verossimilhança-Marginal: "
        f"{gpr.log_marginal_likelihood(gpr.kernel_.theta)}"
    ),
    fontsize=8,
)

Log-Verossimilhança-Marginal

Nesta etapa, inspecionaremos a Log-Verossimilhança-Marginal (LML) do GaussianProcessRegressor para diferentes hiperparâmetros, a fim de obter uma ideia dos mínimos locais.

from matplotlib.colors import LogNorm

length_scale = np.logspace(-2, 4, num=50)
noise_level = np.logspace(-2, 1, num=50)
length_scale_grid, noise_level_grid = np.meshgrid(length_scale, noise_level)

log_marginal_likelihood = [
    gpr.log_marginal_likelihood(theta=np.log([0.36, scale, noise]))
    for scale, noise in zip(length_scale_grid.ravel(), noise_level_grid.ravel())
]
log_marginal_likelihood = np.reshape(
    log_marginal_likelihood, newshape=noise_level_grid.shape
)

vmin, vmax = (-log_marginal_likelihood).min(), 50
level = np.around(np.logspace(np.log10(vmin), np.log10(vmax), num=50), decimals=1)
plt.contour(
    length_scale_grid,
    noise_level_grid,
    -log_marginal_likelihood,
    levels=level,
    norm=LogNorm(vmin=vmin, vmax=vmax),
)
plt.colorbar()
plt.xscale("log")
plt.yscale("log")
plt.xlabel("Escala de comprimento")
plt.ylabel("Nível de ruído")
plt.title("Log-verossimilhança-marginal")
plt.show()

Conclusão

Neste laboratório, aprendemos a utilizar a regressão de processo gaussiano com estimativa do nível de ruído em Python, utilizando a biblioteca scikit-learn. Geramos alguns dados com um único recurso usando uma função seno, adicionamos algum ruído aos dados gerados para criar um conjunto de dados de treinamento mais realista e visualizamos os dados gerados. Criamos um regressor de processo gaussiano usando um kernel aditivo adicionando kernels RBF e WhiteKernel, e visualizamos as previsões feitas pelo regressor de processo gaussiano. Também inspecionamos a Log-Verossimilhança-Marginal (LML) do GaussianProcessRegressor para diferentes hiperparâmetros, a fim de obter uma ideia dos mínimos locais.

Resumo

Parabéns! Você concluiu o laboratório de Regressão de Processo Gaussiano. Você pode praticar mais laboratórios no LabEx para aprimorar suas habilidades.