Graficar la regresión de Ridge Kernel

Introducción

En este tutorial, compararemos la regresión de Ridge Kernel (KRR) y la regresión de vectores de soporte (SVR) utilizando Scikit-Learn, una popular biblioteca de aprendizaje automático en Python. Ambos modelos aprenden una función no lineal mediante el uso del truco del kernel. La KRR y la SVR difieren en sus funciones de pérdida y métodos de ajuste. Utilizaremos un conjunto de datos artificial que consta de una función objetivo senoidal y ruido fuerte agregado a cada quinto dato.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos para que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Generar datos de muestra

Generaremos un conjunto de datos que consta de una función objetivo senoidal y ruido fuerte agregado a cada quinto dato.

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]

Construir los modelos de regresión basados en kernel

Construiremos los modelos de KRR y SVR utilizando GridSearchCV de Scikit-Learn para encontrar los mejores hiperparámetros.

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

train_size = 100

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

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

Comparar los tiempos de SVR y regresión de Ridge Kernel

Compararemos los tiempos de ajuste y predicción de los modelos de SVR y KRR utilizando los mejores hiperparámetros encontrados en el Paso 2.

import time

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

## Print the best params and score for SVR model
print(f"Mejor SVR con parámetros: {svr.best_params_} y puntuación R2: {svr.best_score_:.3f}")
print("Se seleccionó la complejidad y la anchura de banda de SVR y se ajustó el modelo en %.3f s" % svr_fit)

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

## Print the best params and score for KRR model
print(f"Mejor KRR con parámetros: {kr.best_params_} y puntuación R2: {kr.best_score_:.3f}")
print("Se seleccionó la complejidad y la anchura de banda de KRR y se ajustó el modelo en %.3f s" % kr_fit)

## Compute the support vector ratio for SVR
sv_ratio = svr.best_estimator_.support_.shape[0] / train_size
print("Ratio de vectores de soporte: %.3f" % sv_ratio)

## Predict using SVR
t0 = time.time()
y_svr = svr.predict(X_plot)
svr_predict = time.time() - t0
print("Predicción de SVR para %d entradas en %.3f s" % (X_plot.shape[0], svr_predict))

## Predict using KRR
t0 = time.time()
y_kr = kr.predict(X_plot)
kr_predict = time.time() - t0
print("Predicción de KRR para %d entradas en %.3f s" % (X_plot.shape[0], kr_predict))

Observe los resultados

Visualizaremos el modelo aprendido de KRR y SVR cuando se optimizan tanto la complejidad/regularización como la anchura de banda del kernel RBF mediante búsqueda en cuadrícula.

import matplotlib.pyplot as plt

sv_ind = svr.best_estimator_.support_
plt.scatter(
    X[sv_ind],
    y[sv_ind],
    c="r",
    s=50,
    label="Vectores de soporte de SVR",
    zorder=2,
    edgecolors=(0, 0, 0),
)
plt.scatter(X[:100], y[:100], c="k", label="datos", zorder=1, edgecolors=(0, 0, 0))
plt.plot(
    X_plot,
    y_svr,
    c="r",
    label="SVR (ajuste: %.3fs, predicción: %.3fs)" % (svr_fit, svr_predict),
)
plt.plot(
    X_plot, y_kr, c="g", label="KRR (ajuste: %.3fs, predicción: %.3fs)" % (kr_fit, kr_predict)
)
plt.xlabel("datos")
plt.ylabel("objetivo")
plt.title("SVR versus Ridge Kernel")
_ = plt.legend()

Visualizar los tiempos de entrenamiento y predicción

Visualizaremos el tiempo de ajuste y predicción de KRR y SVR para diferentes tamaños del conjunto de entrenamiento.

_, 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 (entrenamiento)" % name,
    )
    plt.plot(
        sizes,
        test_time,
        "o--",
        color="r" if name == "SVR" else "g",
        label="%s (prueba)" % name,
    )

plt.xscale("log")
plt.yscale("log")
plt.xlabel("Tamaño del entrenamiento")
plt.ylabel("Tiempo (segundos)")
plt.title("Tiempo de ejecución")
_ = plt.legend(loc="best")

Visualizar las curvas de aprendizaje

Visualizaremos las curvas de aprendizaje de KRR y 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("Curvas de aprendizaje")
ax.legend(handles=ax.get_legend_handles_labels()[0], labels=["SVR", "KRR"])

plt.show()

Resumen

En este tutorial, comparamos la regresión de Ridge Kernel (KRR) y la regresión de vectores de soporte (SVR) utilizando Scikit-Learn. Generamos un conjunto de datos que consistía en una función objetivo senoidal y ruido fuerte agregado a cada quinto dato. Construimos los modelos de KRR y SVR utilizando GridSearchCV de Scikit-Learn para encontrar los mejores hiperparámetros. Comparamos los tiempos de ajuste y predicción de los modelos de SVR y KRR utilizando los mejores hiperparámetros encontrados. Visualizamos el modelo aprendido de KRR y SVR cuando tanto la complejidad/regularización como la anchura de banda del kernel RBF se optimizan utilizando búsqueda en cuadrícula. También visualizamos el tiempo de ajuste y predicción de KRR y SVR para diferentes tamaños del conjunto de entrenamiento. Finalmente, visualizamos las curvas de aprendizaje de KRR y SVR.