Бинарная классификация гауссовского процесса: почему дисперсия с GPy намного меньше, чем с scikit-learn? ⇐ Python

[Anonymous]

Я изучаю двоичную классификацию с помощью гауссовских процессов и сравниваю GPy с scikit-learn для игрушечной 1D-задачи, вдохновленной сообщением в блоге Мартина Крассера. Обе реализации (GPy и scikit-learn), похоже, используют одинаковую настройку с ядром RBF. После оптимизации гиперпараметров ядра масштабы длин одинаковы, но различия сильно различаются. Отклонение ядра GPy кажется слишком маленьким.
Как я могу изменить свою реализацию GPy и получить результат, аналогичный результатам с scikit-learn? Я подозреваю, что это связано с внутренней реализацией каждого алгоритма, но я не могу сказать, что вызывает такую ​​резкую разницу. Ниже я объясню, почему я считаю, что мою реализацию GPy необходимо исправить.
Детали реализации: Python 3.9 с GPy 1.13.2 и scikit-learn 1.5.1. Воспроизводимый пример:

Код: Выделить всё

import numpy as np
from scipy.stats import bernoulli
from scipy.special import expit as sigmoid

##############################
# Part 1: toy dataset creation
##############################

np.random.seed(0)
X = np.arange(0, 5, 0.05).reshape(-1, 1)
X_test = np.arange(-2, 7, 0.1).reshape(-1, 1)

a = np.sin(X * np.pi * 0.5) * 2  # latent function
t = bernoulli.rvs(sigmoid(a))    # Bernoulli training data (0s and 1s)

#####################################
# Part 2: scikit-learn implementation
#####################################

from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import ConstantKernel, RBF

rbf = ConstantKernel(1.0, constant_value_bounds=(1e-3, 10)) \
* RBF(length_scale=1.0, length_scale_bounds=(1e-3, 10))
gpc = GaussianProcessClassifier(
kernel=rbf,
optimizer='fmin_l_bfgs_b',
n_restarts_optimizer=10)

gpc.fit(X_scaled, t.ravel())

print(gpc.kernel_)
# 1.5**2 * RBF(length_scale=0.858)

############################
# Part 3: GPy implementation
############################

import GPy

kern = GPy.kern.RBF(
input_dim=1,
variance=1.,
lengthscale=1.)
kern.lengthscale.unconstrain()
kern.variance.unconstrain()
kern.lengthscale.constrain_bounded(1e-3, 10)
kern.variance.constrain_bounded(1e-3, 10)

m = GPy.core.GP(
X=X,Y=t, kernel=kern,
inference_method=GPy.inference.latent_function_inference.laplace.Laplace(),
likelihood=GPy.likelihoods.Bernoulli())

m.optimize_restarts(
num_restarts=10, optimizer='lbfgs',
verbose=True, robust=True)

print(m.kern)
#  rbf.         |               value  |  constraints  |  priors
#  variance     |  0.8067562453940487  |  0.001,10.0   |
#  lengthscale  |  0.8365668826459536  |  0.001,10.0   |

Значения шкалы длины примерно одинаковы (0,858 против 0,836), но значения дисперсии сильно различаются (1,5**2 = 2,25 для scikit-learn и только 0,806 для GPy).
p>
Причина, по которой я считаю, что моя реализация GPy требует корректировок, заключается в том, что истинная скрытая функция (см. «a» в части 1 кода выше) не совсем соответствует предсказанной даже с +/- 2 границы стандартного отклонения. С другой стороны, реализация scikit-learn соответствует ему достаточно хорошо (можно получить среднее значение скрытой функции и стандартное отклонение с помощью scikit-learn, как показано здесь).

Слева: предсказанные вероятности аналогичны для обеих моделей (имеет смысл, поскольку они имеют схожий масштаб длины). ценности). Справа: предсказанная скрытая функция GPy не соответствует истинной скрытой функции так же хорошо, как модель scikit-learn.
То, что я пробовал до сих пор, без существенных изменений в результатах:

• < li>Нормализация входного объекта (X)
• Используйте GPy.inference.latent_function_inference.expectation_propagation.EP() в качестве метода вывода GPy вместо метода Лапласа
  < li>Добавьте компонент WhiteKernel в реализацию scikit-learn, как предложено здесь

Подробнее здесь: https://stackoverflow.com/questions/790 ... uch-smalle