Хребет ядра и простой хребет с полиномиальными характеристиками

Question

В чем отличие Kernel Ridge (от sklearn.kernel_ridge) с полиномиальным ядром и использованием PolynomialFeatures + Ridge (от sklearn.linear_model)?

Answer 1

это пример, чтобы показать это:

    from sklearn.datasets import make_friedman1
    plt.figure()
    plt.title('Complex regression problem with one input variable')
    X_F1, y_F1 = make_friedman1(n_samples = 100,
                           n_features = 7, random_state=0)
    from sklearn.linear_model import LinearRegression
    from sklearn.linear_model import Ridge
    from sklearn.preprocessing import PolynomialFeatures 

    print('\nNow we transform the original input data to add\n\
    polynomial features up to degree 2 (quadratic)\n')
    poly = PolynomialFeatures(degree=2)
    X_F1_poly = poly.fit_transform(X_F1) 
    X_train, X_test, y_train, y_test = train_test_split(X_F1_poly, y_F1,
                                                       random_state = 0)
    linreg = Ridge().fit(X_train, y_train)

    print('(poly deg 2 + ridge) linear model coeff (w):\n{}'
         .format(linreg.coef_))
    print('(poly deg 2 + ridge) linear model intercept (b): {:.3f}'
         .format(linreg.intercept_))
    print('(poly deg 2 + ridge) R-squared score (training): {:.3f}'
         .format(linreg.score(X_train, y_train)))
    print('(poly deg 2 + ridge) R-squared score (test): {:.3f}'
         .format(linreg.score(X_test, y_test)))

(poly deg 2 + ridge) linear model coeff (w):
[ 0.    2.23  4.73 -3.15  3.86  1.61 -0.77 -0.15 -1.75  1.6   1.37  2.52
  2.72  0.49 -1.94 -1.63  1.51  0.89  0.26  2.05 -1.93  3.62 -0.72  0.63
 -3.16  1.29  3.55  1.73  0.94 -0.51  1.7  -1.98  1.81 -0.22  2.88 -0.89]
(poly deg 2 + ridge) linear model intercept (b): 5.418
(poly deg 2 + ridge) R-squared score (training): 0.826
(poly deg 2 + ridge) R-squared score (test): 0.825

Answer 2

Разница заключается в вычислении характеристик.PolynomialFeatures явно вычисляет полиномиальные комбинации между входными объектами до требуемой степени, в то время как KernelRidge(kernel='poly') рассматривает только ядро ​​полинома ( полиномиальное представление продуктов точечных элементов ) который будет выражен в терминах оригинальных функций. Этот документ в целом дает хороший обзор.

Что касается вычислений, мы можем проверить соответствующие части из исходного кода:

• Ридж-регрессия
  • Фактическое вычисление начинается здесь (для настроек по умолчанию);Вы можете сравнить с уравнением (5) в приведенном выше документе.Вычисление включает в себя вычисление точечного произведения между векторами признаков (ядром), затем двойными коэффициентами ( alpha ) и, наконец, точечным произведением с векторами признаков для получения весов.
• Kernel Ridge
  • Аналогично вычисляет двойные коэффициенты и сохраняет их (вместо вычисления некоторых весов).Это связано с тем, что при прогнозировании снова вычисляется ядро ​​между обучающей и прогнозирующей выборками .Результат затем усеивается двойными коэффициентами .

Вычисление (обучающего) ядра выполняется аналогичной процедурой: сравните Ridge и KernelRidge.Основное отличие состоит в том, что Ridge явно учитывает скалярное произведение между любыми (полиномиальными) признаками, которые он получил, в то время как для KernelRidge эти полиномиальные признаки генерируются неявно во время вычисления .Например, рассмотрим одну особенность x;с gamma = coef0 = 1 KernelRidge вычисляет (x**2 + 1)**2 == (x**4 + 2*x**2 + 1).Если вы рассмотрите теперь PolynomialFeatures, это обеспечит функции x**2, x, 1, а соответствующий точечный продукт будет x**4 + x**2 + 1.Следовательно, скалярное произведение отличается на член x**2.Конечно, мы могли бы изменить масштаб полифункциональности, чтобы иметь x**2, sqrt(2)*x, 1, тогда как с KernelRidge(kernel='poly') у нас нет такой гибкости.С другой стороны, разница, вероятно, не имеет значения (в большинстве случаев).

Обратите внимание, что вычисление двойных коэффициентов также выполняется аналогичным образом: Ridge и KernelRidge.Наконец, KernelRidge сохраняет двойные коэффициенты, в то время как Ridge напрямую вычисляет вес.

Давайте рассмотрим небольшой пример:

import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import Ridge
from sklearn.kernel_ridge import KernelRidge
from sklearn.preprocessing import PolynomialFeatures
from sklearn.utils.extmath import safe_sparse_dot

np.random.seed(20181001)

a, b = 1, 4
x = np.linspace(0, 2, 100).reshape(-1, 1)
y = a*x**2 + b*x + np.random.normal(scale=0.2, size=(100,1))

poly = PolynomialFeatures(degree=2, include_bias=True)
xp = poly.fit_transform(x)
print('We can see that the new features are now [1, x, x**2]:')
print(f'xp.shape: {xp.shape}')
print(f'xp[-5:]:\n{xp[-5:]}', end='\n\n')
# Scale the `x` columns so we obtain similar results.
xp[:, 1] *= np.sqrt(2)

ridge = Ridge(alpha=0, fit_intercept=False, solver='cholesky')
ridge.fit(xp, y)

krr = KernelRidge(alpha=0, kernel='poly', degree=2, gamma=1, coef0=1)
krr.fit(x, y)

# Let's try to reproduce some of the involved steps for the different models.
ridge_K = safe_sparse_dot(xp, xp.T)
krr_K = krr._get_kernel(x)
print('The computed kernels are (alomst) similar:')
print(f'Max. kernel difference: {np.abs(ridge_K - krr_K).max()}', end='\n\n')
print('Predictions slightly differ though:')
print(f'Max. difference: {np.abs(krr.predict(x) - ridge.predict(xp)).max()}', end='\n\n')

# Let's see if the fit changes if we provide `x**2, x, 1` instead of `x**2, sqrt(2)*x, 1`.
xp_2 = xp.copy()
xp_2[:, 1] /= np.sqrt(2)
ridge_2 = Ridge(alpha=0, fit_intercept=False, solver='cholesky')
ridge_2.fit(xp_2, y)
print('Using features "[x**2, x, 1]" instead of "[x**2, sqrt(2)*x, 1]" predictions are (almost) the same:')
print(f'Max. difference: {np.abs(ridge_2.predict(xp_2) - ridge.predict(xp)).max()}', end='\n\n')
print('Interpretability of the coefficients changes though:')
print(f'ridge.coef_[1:]: {ridge.coef_[0, 1:]}, ridge_2.coef_[1:]: {ridge_2.coef_[0, 1:]}')
print(f'ridge.coef_[1]*sqrt(2): {ridge.coef_[0, 1]*np.sqrt(2)}')
print(f'Compare with: a, b = ({a}, {b})')

plt.plot(x.ravel(), y.ravel(), 'o', color='skyblue', label='Data')
plt.plot(x.ravel(), ridge.predict(xp).ravel(), '-', label='Ridge', lw=3)
plt.plot(x.ravel(), krr.predict(x).ravel(), '--', label='KRR', lw=3)
plt.grid()
plt.legend()
plt.show()

Из которого мы получаем:

We can see that the new features are now [x, x**2]:
xp.shape: (100, 3)
xp[-5:]:
[[1.         1.91919192 3.68329762]
 [1.         1.93939394 3.76124885]
 [1.         1.95959596 3.84001632]
 [1.         1.97979798 3.91960004]
 [1.         2.         4.        ]]

The computed kernels are (alomst) similar:
Max. kernel difference: 1.0658141036401503e-14

Predictions slightly differ though:
Max. difference: 0.04244651134471766

Using features "[x**2, x, 1]" instead of "[x**2, sqrt(2)*x, 1]" predictions are (almost) the same:
Max. difference: 7.15642822779472e-14

Interpretability of the coefficients changes though:
ridge.coef_[1:]: [2.73232239 1.08868872], ridge_2.coef_[1:]: [3.86408737 1.08868872]
ridge.coef_[1]*sqrt(2): 3.86408737392841
Compare with: a, b = (1, 4)