Vergleich von Kernel Ridge Regression mit SVR

Einführung

In diesem Tutorial werden wir Kernel Ridge Regression (KRR) und Support Vector Regression (SVR) mithilfe von Scikit-Learn, einer beliebten Machine-Learning-Bibliothek in Python, vergleichen. Beide Modelle lernen eine nicht-lineare Funktion, indem sie den Kernel-Trick anwenden. KRR und SVR unterscheiden sich in ihren Verlustfunktionen und Anpassungsmethoden. Wir werden einen künstlichen Datensatz verwenden, der aus einer sinusförmigen Zielfunktion und starkem Rauschen besteht, das jedem fünften Datapunkt hinzugefügt wird.

Tipps für die VM

Nachdem der Start der VM abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Beispiel-Daten generieren

Wir werden einen Datensatz generieren, der aus einer sinusförmigen Zielfunktion und starkem Rauschen besteht, das jedem fünften Datapunkt hinzugefügt wird.

import numpy as np

## Generate sample data
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]

Die kernelbasierten Regressionsmodelle erstellen

Wir werden KRR- und SVR-Modelle mit Hilfe von Scikit-Learn's GridSearchCV erstellen, um die besten Hyperparameter zu finden.

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVR
from sklearn.kernel_ridge import KernelRidge

train_size = 100

## SVR-Modell
svr = GridSearchCV(
    SVR(kernel="rbf", gamma=0.1),
    param_grid={"C": [1e0, 1e1, 1e2, 1e3], "gamma": np.logspace(-2, 2, 5)},
)

## KRR-Modell
kr = GridSearchCV(
    KernelRidge(kernel="rbf", gamma=0.1),
    param_grid={"alpha": [1e0, 0.1, 1e-2, 1e-3], "gamma": np.logspace(-2, 2, 5)},
)

Vergleiche die Zeiten von SVR und Kernel Ridge Regression

Wir werden die Anpassungs- und Vorhersagezeiten von SVR- und KRR-Modellen mit den besten Hyperparametern vergleichen, die in Schritt 2 gefunden wurden.

import time

## Fit SVR
t0 = time.time()
svr.fit(X[:train_size], y[:train_size])
svr_fit = time.time() - t0

## Drucke die besten Parameter und den Score für das SVR-Modell
print(f"Bestes SVR mit Parametern: {svr.best_params_} und R2-Score: {svr.best_score_:.3f}")
print("SVR-Komplexität und Bandbreite ausgewählt und Modell in %.3f s angepasst" % svr_fit)

## Fit KRR
t0 = time.time()
kr.fit(X[:train_size], y[:train_size])
kr_fit = time.time() - t0

## Drucke die besten Parameter und den Score für das KRR-Modell
print(f"Bestes KRR mit Parametern: {kr.best_params_} und R2-Score: {kr.best_score_:.3f}")
print("KRR-Komplexität und Bandbreite ausgewählt und Modell in %.3f s angepasst" % kr_fit)

## Berechne das Support-Vektor-Verhältnis für SVR
sv_ratio = svr.best_estimator_.support_.shape[0] / train_size
print("Support-Vektor-Verhältnis: %.3f" % sv_ratio)

## Vorhersage mit SVR
t0 = time.time()
y_svr = svr.predict(X_plot)
svr_predict = time.time() - t0
print("SVR-Vorhersage für %d Eingaben in %.3f s" % (X_plot.shape[0], svr_predict))

## Vorhersage mit KRR
t0 = time.time()
y_kr = kr.predict(X_plot)
kr_predict = time.time() - t0
print("KRR-Vorhersage für %d Eingaben in %.3f s" % (X_plot.shape[0], kr_predict))

Schau dir die Ergebnisse an

Wir werden das gelerntes Modell von KRR und SVR visualisieren, wenn sowohl die Komplexität/Regularisierung als auch die Bandbreite des RBF-Kernels mithilfe von Grid-Search optimiert werden.

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()

Visualisiere die Trainings- und Vorhersagezeiten

Wir werden die Zeit für die Anpassung und Vorhersage von KRR und SVR für verschiedene Größen des Trainingssets visualisieren.

_, ax = plt.subplots()

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")

Visualisiere die Lernkurven

Wir werden die Lernkurven von KRR und SVR visualisieren.

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",
    "std_display_style": None,
    "ax": ax,
}

LearningCurveDisplay.from_estimator(svr, **common_params)
LearningCurveDisplay.from_estimator(kr, **common_params)
ax.set_title("Lernkurven")
ax.legend(handles=ax.get_legend_handles_labels()[0], labels=["SVR", "KRR"])

plt.show()

Zusammenfassung

In diesem Tutorial haben wir Kernel Ridge Regression (KRR) und Support Vector Regression (SVR) mithilfe von Scikit-Learn verglichen. Wir haben einen Datensatz erzeugt, der aus einer sinusförmigen Zielfunktion und starkem Rauschen besteht, das zu jedem fünften Datapunkt hinzugefügt wurde. Wir haben KRR- und SVR-Modelle mit Hilfe von Scikit-Learn's GridSearchCV konstruiert, um die besten Hyperparameter zu finden. Wir haben die Anpassungs- und Vorhersagezeiten von SVR- und KRR-Modellen mit den besten gefundenen Hyperparametern verglichen. Wir haben das gelerntes Modell von KRR und SVR visualisiert, wenn sowohl die Komplexität/Regularisierung als auch die Bandbreite des RBF-Kernels mithilfe von Grid-Search optimiert werden. Wir haben auch die Zeit für die Anpassung und Vorhersage von KRR und SVR für verschiedene Größen des Trainingssets visualisiert. Schließlich haben wir die Lernkurven von KRR und SVR visualisiert.

Kernel Ridge Regression plotten