Сравнение регрессии с ядром Риджа и Гауссовым процессом

Регрессия с ядром Риджа

Мы можем сделать предыдущую линейную модель более выразительной, используя так называемое ядро. Ядро — это отображение из исходного пространства признаков в другое. Проще говоря, оно используется для отображения наших исходных данных в новое и более сложное пространство признаков. Это новое пространство явно определяется выбором ядра.

В нашем случае мы знаем, что истинный генеративный процесс является периодической функцией. Мы можем использовать ядро ExpSineSquared, которое позволяет восстановить периодичность. Класс KernelRidge будет принимать такое ядро.

Использование этой модели вместе с ядром эквивалентно отображению данных с помощью функции отображения ядра и последующего применения регрессии Риджа. На практике данные не отображаются явно; вместо этого вычисляется скалярное произведение между образцами в пространстве признаков более высокой размерности, используя «трюк с ядром».

Таким образом, давайте воспользуемся KernelRidge.

import time

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

kernel_ridge = KernelRidge(kernel=ExpSineSquared())

start_time = time.time()
kernel_ridge.fit(training_data, training_noisy_target)
print(
    f"Fitting KernelRidge with default kernel: {time.time() - start_time:.3f} seconds"
)

Fitting KernelRidge with default kernel: 0.001 seconds

plt.plot(data, target, label="True signal", linewidth=2, linestyle="dashed")
plt.scatter(
    training_data,
    training_noisy_target,
    color="black",
    label="Noisy measurements",
)
plt.plot(
    data,
    kernel_ridge.predict(data),
    label="Kernel ridge",
    linewidth=2,
    linestyle="dashdot",
)
plt.legend(loc="lower right")
plt.xlabel("data")
plt.ylabel("target")
_ = plt.title(
    "Kernel ridge regression with an exponential sine squared\n "
    "kernel using default hyperparameters"
)

Полученная модель не точна. Действительно, мы не установили параметры ядра и вместо этого использовали значения по умолчанию. Мы можем их проверить.

kernel_ridge.kernel

ExpSineSquared(length_scale=1, periodicity=1)

У нашего ядра есть два параметра: масштаб длины и периодичность. Для нашего набора данных мы используем sin как генеративный процесс, предполагая периодичность сигнала \(2 \pi\). Значение параметра по умолчанию, равное \(1\), объясняет высокую частоту, наблюдаемую в прогнозах нашей модели. Аналогичные выводы можно сделать и с параметром масштаба длины. Таким образом, это говорит нам о необходимости настройки параметров ядра. Мы будем использовать случайный поиск для настройки различных параметров модели регрессии с ядром Риджа: параметр alpha и параметры ядра.

from scipy.stats import loguniform

from sklearn.model_selection import RandomizedSearchCV

param_distributions = {
    "alpha": loguniform(1e0, 1e3),
    "kernel__length_scale": loguniform(1e-2, 1e2),
    "kernel__periodicity": loguniform(1e0, 1e1),
}
kernel_ridge_tuned = RandomizedSearchCV(
    kernel_ridge,
    param_distributions=param_distributions,
    n_iter=500,
    random_state=0,
)
start_time = time.time()
kernel_ridge_tuned.fit(training_data, training_noisy_target)
print(f"Time for KernelRidge fitting: {time.time() - start_time:.3f} seconds")

Time for KernelRidge fitting: 4.294 seconds

Обучение модели теперь требует больше вычислительных ресурсов, так как нам необходимо перебрать несколько комбинаций гиперпараметров. Мы можем взглянуть на найденные гиперпараметры, чтобы получить некоторые интуиции.

kernel_ridge_tuned.best_params_

{'alpha': np.float64(1.991584977345022), 'kernel__length_scale': np.float64(0.7986499491396734), 'kernel__periodicity': np.float64(6.6072758064261095)}

Глядя на лучшие параметры, мы видим, что они отличаются от значений по умолчанию. Мы также видим, что периодичность ближе к ожидаемому значению: \(2 \pi\). Теперь мы можем проверить прогнозы нашей настроенной регрессии с ядром Риджа.

start_time = time.time()
predictions_kr = kernel_ridge_tuned.predict(data)
print(f"Time for KernelRidge predict: {time.time() - start_time:.3f} seconds")

Time for KernelRidge predict: 0.001 seconds

plt.plot(data, target, label="True signal", linewidth=2, linestyle="dashed")
plt.scatter(
    training_data,
    training_noisy_target,
    color="black",
    label="Noisy measurements",
)
plt.plot(
    data,
    predictions_kr,
    label="Kernel ridge",
    linewidth=2,
    linestyle="dashdot",
)
plt.legend(loc="lower right")
plt.xlabel("data")
plt.ylabel("target")
_ = plt.title(
    "Kernel ridge regression with an exponential sine squared\n "
    "kernel using tuned hyperparameters"
)

Мы получаем гораздо более точную модель. Мы по-прежнему наблюдаем некоторые ошибки, в основном из-за шума, добавленного в набор данных.

Регрессия с гауссовым процессом

Теперь мы будем использовать GaussianProcessRegressor для подгонки того же набора данных. При обучении гауссова процесса гиперпараметры ядра оптимизируются во время процесса обучения. Нет необходимости в дополнительном поиске гиперпараметров. Здесь мы создаем несколько более сложное ядро, чем для регрессора Риджа с ядром: мы добавляем WhiteKernel, используемый для оценки шума в наборе данных.

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)
start_time = time.time()
gaussian_process.fit(training_data, training_noisy_target)
print(
    f"Time for GaussianProcessRegressor fitting: {time.time() - start_time:.3f} seconds"
)

Time for GaussianProcessRegressor fitting: 0.031 seconds

Вычислительные затраты на обучение гауссова процесса намного меньше, чем у регрессии с ядром Риджа, использующей случайный поиск. Мы можем проверить параметры вычисленных ядер.

gaussian_process.kernel_

0.675**2 * ExpSineSquared(length_scale=1.34, periodicity=6.57) + WhiteKernel(noise_level=0.182)

Действительно, мы видим, что параметры были оптимизированы. Посмотрев на параметр periodicity, мы видим, что мы нашли период, близкий к теоретическому значению \(2 \pi\). Теперь мы можем посмотреть на прогнозы нашей модели.

start_time = time.time()
mean_predictions_gpr, std_predictions_gpr = gaussian_process.predict(
    data,
    return_std=True,
)
print(
    f"Time for GaussianProcessRegressor predict: {time.time() - start_time:.3f} seconds"
)

Time for GaussianProcessRegressor predict: 0.002 seconds

plt.plot(data, target, label="True signal", linewidth=2, linestyle="dashed")
plt.scatter(
    training_data,
    training_noisy_target,
    color="black",
    label="Noisy measurements",
)
# Plot the predictions of the kernel ridge
plt.plot(
    data,
    predictions_kr,
    label="Kernel ridge",
    linewidth=2,
    linestyle="dashdot",
)
# Plot the predictions of the gaussian process regressor
plt.plot(
    data,
    mean_predictions_gpr,
    label="Gaussian process regressor",
    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("data")
plt.ylabel("target")
_ = plt.title("Comparison between kernel ridge and gaussian process regressor")

Мы наблюдаем, что результаты регрессора с ядром Риджа и гауссова процесса близки. Однако регрессор с гауссовым процессом также предоставляет информацию об неопределенности, которая недоступна с регрессором с ядром Риджа. Благодаря вероятностной формулировке целевых функций, гауссов процесс может выводить стандартное отклонение (или ковариацию) вместе со средними прогнозами целевых функций.

Однако это имеет свою цену: время вычисления прогнозов выше с гауссовым процессом.