Примечание
Перейти к концу для загрузки полного примера кода. или для запуска этого примера в вашем браузере через JupyterLite или Binder
Сравнение регрессии с ядром и SVR
Как регрессия с ядром (KRR), так и SVR обучают нелинейную функцию с помощью трюка ядра, т. е. они обучают линейную функцию в пространстве, индуцированном соответствующим ядром, что соответствует нелинейной функции в исходном пространстве. Они различаются функциями потерь (регрессия против ε-нечувствительных потерь). В отличие от SVR, подгонку KRR можно выполнить в замкнутой форме и она обычно быстрее для наборов данных среднего размера. С другой стороны, обученная модель не является разреженной и, следовательно, медленнее, чем SVR, во время прогнозирования.
В этом примере оба метода проиллюстрированы на искусственном наборе данных, который состоит из синусоидальной целевой функции и сильного шума, добавленного к каждому пятому значению данных.
Авторы: разработчики scikit-learn SPDX-License-Identifier: BSD-3-Clause
Генерация примера данных
import numpy as np rng = np.random.RandomState(42) X = 5 * rng.rand(10000, 1) y = np.sin(X).ravel() # Add noise to targets y[::5] += 3 * (0.5 - rng.rand(X.shape[0] // 5)) X_plot = np.linspace(0, 5, 100000)[:, None]
Построение моделей регрессии с ядром
from sklearn.kernel_ridge import KernelRidge
from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVR
train_size = 100
svr = GridSearchCV(
SVR(kernel="rbf", gamma=0.1),
param_grid={"C": [1e0, 1e1, 1e2, 1e3], "gamma": np.logspace(-2, 2, 5)},
)
kr = GridSearchCV(
KernelRidge(kernel="rbf", gamma=0.1),
param_grid={"alpha": [1e0, 0.1, 1e-2, 1e-3], "gamma": np.logspace(-2, 2, 5)},
)
Сравнение времени SVR и регрессии с ядром
import time
t0 = time.time()
svr.fit(X[:train_size], y[:train_size])
svr_fit = time.time() - t0
print(f"Best SVR with params: {svr.best_params_} and R2 score: {svr.best_score_:.3f}")
print("SVR complexity and bandwidth selected and model fitted in %.3f s" % svr_fit)
t0 = time.time()
kr.fit(X[:train_size], y[:train_size])
kr_fit = time.time() - t0
print(f"Best KRR with params: {kr.best_params_} and R2 score: {kr.best_score_:.3f}")
print("KRR complexity and bandwidth selected and model fitted in %.3f s" % kr_fit)
sv_ratio = svr.best_estimator_.support_.shape[0] / train_size
print("Support vector ratio: %.3f" % sv_ratio)
t0 = time.time()
y_svr = svr.predict(X_plot)
svr_predict = time.time() - t0
print("SVR prediction for %d inputs in %.3f s" % (X_plot.shape[0], svr_predict))
t0 = time.time()
y_kr = kr.predict(X_plot)
kr_predict = time.time() - t0
print("KRR prediction for %d inputs in %.3f s" % (X_plot.shape[0], kr_predict))
Best SVR with params: {'C': 1.0, 'gamma': np.float64(0.1)} and R2 score: 0.737
SVR complexity and bandwidth selected and model fitted in 0.610 s
Best KRR with params: {'alpha': 0.1, 'gamma': np.float64(0.1)} and R2 score: 0.723
KRR complexity and bandwidth selected and model fitted in 0.228 s
Support vector ratio: 0.340
SVR prediction for 100000 inputs in 0.151 s
KRR prediction for 100000 inputs in 0.100 s
Просмотр результатов
import matplotlib.pyplot as plt
sv_ind = svr.best_estimator_.support_
plt.scatter(
X[sv_ind],
y[sv_ind],
c="r",
s=50,
label="SVR support vectors",
zorder=2,
edgecolors=(0, 0, 0),
)
plt.scatter(X[:100], y[:100], c="k", label="data", zorder=1, edgecolors=(0, 0, 0))
plt.plot(
X_plot,
y_svr,
c="r",
label="SVR (fit: %.3fs, predict: %.3fs)" % (svr_fit, svr_predict),
)
plt.plot(
X_plot, y_kr, c="g", label="KRR (fit: %.3fs, predict: %.3fs)" % (kr_fit, kr_predict)
)
plt.xlabel("data")
plt.ylabel("target")
plt.title("SVR versus Kernel Ridge")
_ = plt.legend()
На предыдущем рисунке сравнивается обученная модель KRR и SVR, когда и сложность/регуляризация, и ширина RBF-ядра оптимизированы с помощью поиска по сетке. Обученные функции очень похожи; однако подгонка KRR примерно в 3-4 раза быстрее, чем подгонка SVR (обе с использованием поиска по сетке).
Прогнозирование 100000 значений целевой переменной теоретически может быть примерно в три раза быстрее с SVR, так как она обучила разреженную модель, используя только примерно 1/3 точек обучающего набора в качестве опорных векторов. Однако на практике это необязательно, из-за особенностей реализации, связанных с вычислением функции ядра для каждой модели, что может сделать модель KRR такой же быстрой или даже быстрее, несмотря на вычисление большего количества арифметических операций.
Визуализация времени обучения и прогнозирования
plt.figure()
sizes = np.logspace(1, 3.8, 7).astype(int)
for name, estimator in {
"KRR": KernelRidge(kernel="rbf", alpha=0.01, gamma=10),
"SVR": SVR(kernel="rbf", C=1e2, gamma=10),
}.items():
train_time = []
test_time = []
for train_test_size in sizes:
t0 = time.time()
estimator.fit(X[:train_test_size], y[:train_test_size])
train_time.append(time.time() - t0)
t0 = time.time()
estimator.predict(X_plot[:1000])
test_time.append(time.time() - t0)
plt.plot(
sizes,
train_time,
"o-",
color="r" if name == "SVR" else "g",
label="%s (train)" % name,
)
plt.plot(
sizes,
test_time,
"o--",
color="r" if name == "SVR" else "g",
label="%s (test)" % name,
)
plt.xscale("log")
plt.yscale("log")
plt.xlabel("Train size")
plt.ylabel("Time (seconds)")
plt.title("Execution Time")
_ = plt.legend(loc="best")
На этом рисунке сравнивается время обучения и прогнозирования для KRR и SVR для различных размеров набора обучающих данных. Подгонка KRR быстрее, чем SVR, для наборов обучающих данных среднего размера (менее нескольких тысяч образцов); однако для больших обучающих наборов SVR масштабируется лучше. Что касается времени прогнозирования, SVR должен быть быстрее, чем KRR, для всех размеров набора обучающих данных из-за обученной разреженной модели, однако это не обязательно так на практике из-за особенностей реализации. Обратите внимание, что степень разреженности и, следовательно, время прогнозирования зависит от параметров ε и C SVR.
Визуализация кривых обучения
from sklearn.model_selection import LearningCurveDisplay
_, ax = plt.subplots()
svr = SVR(kernel="rbf", C=1e1, gamma=0.1)
kr = KernelRidge(kernel="rbf", alpha=0.1, gamma=0.1)
common_params = {
"X": X[:100],
"y": y[:100],
"train_sizes": np.linspace(0.1, 1, 10),
"scoring": "neg_mean_squared_error",
"negate_score": True,
"score_name": "Mean Squared Error",
"score_type": "test",
"std_display_style": None,
"ax": ax,
}
LearningCurveDisplay.from_estimator(svr, **common_params)
LearningCurveDisplay.from_estimator(kr, **common_params)
ax.set_title("Learning curves")
ax.legend(handles=ax.get_legend_handles_labels()[0], labels=["SVR", "KRR"])
plt.show()
Общее время выполнения скрипта: (0 минут 8,696 секунд)
Связанные примеры
© 2007–2025 The scikit-learn developers
Licensed under the 3-clause BSD License.
https://scikit-learn.org/1.6/auto_examples/miscellaneous/plot_kernel_ridge_regression.html
