Validación cruzada de Lasso

Question

Quiero realizar una validación cruzada para encontrar el parámetro de regularización para Lasso. Estoy utilizando la biblioteca scikit-learn en python. Primero genero el conjunto de datos y luego realizo la validación cruzada k-fold. Aquí está mi código (la mayor parte de un ejemplo en el sitio web de scikit-learn):

# generate some sparse data to play with
import numpy as np
n_samples, n_features = 5000, 200
X = np.random.randn(n_samples, n_features)
coef = 3 * np.random.randn(n_features)
coef[10:] = 0  # sparsify coef
y = np.dot(X, coef)

# add noise
y += 0.01 * np.random.normal((n_samples,))

# Split data in train set and test set
n_samples = X.shape[0]
X_train, y_train = X[:n_samples / 2], y[:n_samples / 2]
X_test, y_test = X[n_samples / 2:], y[n_samples / 2:]

###############################################################################
# Lasso
from sklearn.linear_model import Lasso
from sklearn.cross_validation import KFold
from matplotlib import pyplot as plt

kf = KFold(X_train.shape[0], n_folds = 10,)

alphas = np.logspace(-16, 3, num = 50, base = 2)

e_alphas = list()
e_alphas_r = list()  #holds average r2 error
for alpha in alphas:
    lasso = Lasso(alpha=alpha)
    err = list()
    err_2 = list()
    for tr_idx, tt_idx in kf:
        X_tr , X_tt = X_train[tr_idx], X_test[tt_idx]
        y_tr, y_tt = y_train[tr_idx], y_test[tt_idx]
        lasso.fit(X_tr, y_tr)
        y_hat = lasso.predict(X_tt)
        err_2.append(lasso.score(X_tt,y_tt))
        err.append(np.average((y_hat - y_tt)**2))
    e_alphas.append(np.average(err))
    e_alphas_r.append(np.average(err_2))

plt.figsize = (15,10)
fig = plt.figure()     
ax = fig.add_subplot(111)
ax.plot(alphas, e_alphas, 'b-')
ax.plot(alphas, e_alphas_r, 'g--')
ax.set_xlabel("alpha")
plt.show()

El gráfico del error se muestra en la figura de abajo:

Sé que hay otras formas en scikit-learn de hacer un lassoCV pero sólo quiero saber cómo se selecciona el parámetro dado el tipo de gráfico que estoy obteniendo. Gracias por su respuesta.

Answer 1

Básicamente, se selecciona cualquier $\alpha$ le da la tasa de error más baja (en un conjunto de validación). Por lo tanto, para completar la validación cruzada, hay que seguir los siguientes pasos:

1. Divida sus datos en tres partes: entrenamiento, validación y prueba.
2. Entrenar un modelo con un determinado $\alpha$ en el conjunto de entrenamiento y probarlo en el conjunto de validación y repetirlo para toda la gama de posibles $\alpha$ valores en su cuadrícula.
3. Elige lo mejor $\alpha$ (es decir, el que da el menor error)
4. Una vez que haya completado esto, vuelva a entrenar un nuevo modelo utilizando este valor óptimo de $\alpha$ en (trainet+validationset).
5. Ahora puede evaluar su modelo en el conjunto de pruebas.

No he revisado su código, pero su gráfico sugiere buscar también valores aún más bajos de $\alpha$ . Sin embargo, hay que tener en cuenta que las curvas de aprendizaje suelen tener este aspecto cuando se evalúan en el conjunto de validación:

Es decir, su error debe ser alto al principio, bajar a un mínimo y luego volver a subir un poco.

El comentario de @frank-harrell se refiere al hecho de que probablemente deberías repetir este experimento unas cuantas veces para obtener estimaciones robustas de tu $\alpha$ valores. Para ello, también puede utilizar validación cruzada k-fold como lo hiciste, así que deberías estar bien.

Answer 2

Antes de ir tan lejos, ejecute 5 réplicas bootstrap del procedimiento de lazo para asegurarse de que las características seleccionadas son estables. De lo contrario, su interpretación final del resultado del lazo será sospechosa.