Tracer la régression ridge du noyau

Introduction

Dans ce tutoriel, nous comparerons la régression ridge du noyau (Kernel Ridge Regression - KRR) et la régression vectorielle de support (Support Vector Regression - SVR) à l'aide de Scikit-Learn, une bibliothèque populaire de machine learning en Python. Les deux modèles apprennent une fonction non linéaire en utilisant la technique du noyau. La KRR et la SVR diffèrent par leurs fonctions de perte et leurs méthodes d'ajustement. Nous utiliserons un ensemble de données artificielles composé d'une fonction cible sinusoïdale et de bruit fort ajouté à chaque cinquième point de données.

Conseils sur la VM

Une fois le démarrage de la VM terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limites de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Générer des données d'échantillonnage

Nous allons générer un ensemble de données composé d'une fonction cible sinusoïdale et de bruit fort ajouté à chaque cinquième point de données.

import numpy as np

## Générer des données d'échantillonnage
rng = np.random.RandomState(42)
X = 5 * rng.rand(10000, 1)
y = np.sin(X).ravel()

## Ajouter du bruit aux cibles
y[::5] += 3 * (0.5 - rng.rand(X.shape[0] // 5))

X_plot = np.linspace(0, 5, 100000)[:, None]

Construire les modèles de régression basés sur le noyau

Nous allons construire des modèles KRR et SVR en utilisant GridSearchCV de Scikit-Learn pour trouver les meilleurs hyperparamètres.

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

train_size = 100

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

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

Comparer les temps de SVR et de régression ridge du noyau

Nous allons comparer les temps d'ajustement et de prédiction des modèles SVR et KRR en utilisant les meilleurs hyperparamètres trouvés dans l'Étape 2.

import time

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

## Afficher les meilleurs paramètres et le score pour le modèle SVR
print(f"Meilleur SVR avec paramètres : {svr.best_params_} et score R2 : {svr.best_score_:.3f}")
print("Complexité et largeur de bande de SVR sélectionnées et modèle ajusté en %.3f s" % svr_fit)

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

## Afficher les meilleurs paramètres et le score pour le modèle KRR
print(f"Meilleur KRR avec paramètres : {kr.best_params_} et score R2 : {kr.best_score_:.3f}")
print("Complexité et largeur de bande de KRR sélectionnées et modèle ajusté en %.3f s" % kr_fit)

## Calculer le rapport de vecteurs de support pour SVR
sv_ratio = svr.best_estimator_.support_.shape[0] / train_size
print("Rapport de vecteurs de support : %.3f" % sv_ratio)

## Prédire à l'aide de SVR
t0 = time.time()
y_svr = svr.predict(X_plot)
svr_predict = time.time() - t0
print("Prédiction SVR pour %d entrées en %.3f s" % (X_plot.shape[0], svr_predict))

## Prédire à l'aide de KRR
t0 = time.time()
y_kr = kr.predict(X_plot)
kr_predict = time.time() - t0
print("Prédiction KRR pour %d entrées en %.3f s" % (X_plot.shape[0], kr_predict))

Considérez les résultats

Nous allons visualiser le modèle appris de KRR et de SVR lorsque la complexité/régularisation et la largeur de bande du noyau RBF sont optimisées à l'aide d'une recherche sur grille.

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="données", zorder=1, edgecolors=(0, 0, 0))
plt.plot(
    X_plot,
    y_svr,
    c="r",
    label="SVR (ajustement: %.3fs, prédiction: %.3fs)" % (svr_fit, svr_predict),
)
plt.plot(
    X_plot, y_kr, c="g", label="KRR (ajustement: %.3fs, prédiction: %.3fs)" % (kr_fit, kr_predict)
)
plt.xlabel("données")
plt.ylabel("cible")
plt.title("SVR versus Kernel Ridge")
_ = plt.legend()

Visualiser les temps d'entraînement et de prédiction

Nous allons visualiser le temps d'ajustement et de prédiction de KRR et SVR pour différents tailles de l'ensemble d'entraînement.

_, 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 (entraînement)" % 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("Taille de l'entraînement")
plt.ylabel("Temps (secondes)")
plt.title("Temps d'exécution")
_ = plt.legend(loc="best")

Visualiser les courbes d'apprentissage

Nous allons visualiser les courbes d'apprentissage de KRR et de 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",
    "std_display_style": None,
    "ax": ax,
}

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

plt.show()

Sommaire

Dans ce tutoriel, nous avons comparé la régression ridge du noyau (KRR) et la régression vectorielle de support (SVR) à l'aide de Scikit-Learn. Nous avons généré un ensemble de données composé d'une fonction cible sinusoïdale et de bruit important ajouté à chaque cinquième point de données. Nous avons construit des modèles KRR et SVR à l'aide de GridSearchCV de Scikit-Learn pour trouver les meilleurs hyperparamètres. Nous avons comparé les temps d'ajustement et de prédiction des modèles SVR et KRR en utilisant les meilleurs hyperparamètres trouvés. Nous avons visualisé le modèle appris de KRR et de SVR lorsque la complexité/régularisation et la largeur de bande du noyau RBF sont optimisées à l'aide d'une recherche sur grille. Nous avons également visualisé le temps d'ajustement et de prédiction de KRR et SVR pour différents tailles de l'ensemble d'entraînement. Enfin, nous avons visualisé les courbes d'apprentissage de KRR et de SVR.