Сравнение гребневой регрессии с ядром и регрессии с помощью гауссовских процессов

Гребневая регрессия с ядром

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

В нашем случае мы знаем, что истинный процесс генерации данных является периодической функцией. Можно использовать ядро 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.956 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.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",
)
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.039 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.003 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")

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

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