Entrenar un modelo Lasso para distintos valores de α

Autor: | Última modificación: 9 de diciembre de 2022 | Tiempo de Lectura: 4 minutos
Temas en este post: ,

En este artículo veremos cómo entrenar un modelo Lasso para distintos valores de α.

Formulación Lasso

Recordemos que la regularización Lasso se refiere al modelo de regresión lineal con penalización (norma 1) sobre la magnitud de los coeficientes.

Entrenar un modelo Lasso para distintos valores de α 1

Donde llωll1 = lω1l + lω2l + … + lωDl, siendo D el número de atributos0 no se tiene en cuenta en esta penalización).

Con esta formulación el algoritmo Lasso permite activar o desactivar coeficientes, de forma que se desactivan primero los coeficientes asociados a los atributos que menos influyen en la función de coste (función a minimizar anterior). De este modo:

  1. Se previene el overfitting al poder utilizar modelos con menos variables (las desactivamos).
  2. Se gana interpretabilidad al poder ver cómo evolucionan las variables supervivientes.

La activación y desactivación de variables está determinada por el parámetro de regularización α, de la misma forma que sucede con el algoritmo Ridge:

  • Si α = 0, el resultado se asemeja a un modelo de regresión lineal. Pero cuidado, no será igual, ya que skleam trata de forma diferente Lasso con α = 0 y la regresión lineal. Puedes hacer pruebas y verás cómo Lasso aplica una regularización, incluso con alfas muy pequeños
  • Si α → ∞, el valor de todos los coeficientes será nulo.

Entrenar un modelo Lasso: ejercicio

Para entender mejor cómo funciona esto de entrenar un modelo Lasso, veamos un ejemplo:

#Entrenar un modelo Lasso
from sklearn. linear model import Lasso

alpha = 1e - 20
lasso = Lasso (alpha = alpha).fit (X_train, y_train)
w = lasso.coef
norm_w2 = np.dot (w, w.T)

#prediccion
y_hat = lasso.predict (X_test)

#error
error_test = np.mean (np.power (y - y_hat, 2))

plt.plot (x, g_x, 'r', label = '$y$')
plt.plot (x_i, y_i, 'b.', label = '$y_i$')
plt.plot (x, y_hat, 'g', label = '$\hat {y} $')
plt.title ('Grado: %i, MSE: %.2f\nalpha: %g, $ l l w l l_2 ^ 2$ ∞ %.2g' % (degree, error_test, alpha, norm_w2))
plt.legend ()
plt.xlim (0, 1))
plt.ylim ((-2, 2))
plt.show ()

coef_names = ['w' + str (i) + ' :  ' for i in range (1, degree + 1)]

for f, wi in zip (coef names, w):
print (f, wi)
Entrenar un modelo Lasso

w1: 0.0

w2: -4.7290695741439635

w3: -3.225278493297372

w4: 4.006113165814608

w5: 3.503938970691009

w6: 1.06506245474576

w7: -0.8029528036241889

w8: -1.446054850032147

w9: -0.9547476318503947

w10: 0.39623090019268065

#Entrenar un modelo Lasso
n_alphas = 20
alphas = np.logspace (-10, -3, n_alphas)

coefs = [ ]

norm2_coefs = [ ]
for a in alphas:
lasso = lasso (alpha = a).fit (x_train, y_train)

coefs.append (lasso.coef)
norm2_coefs.append (np.dot (lasso.coef_, lasso.coef_.T))

# Display results
plt.figure (figsize = (14, 5))

ax = plt.subplot (1, 2, 1)
ax.plot (alphas, coefs)
ax.set_xscale ('log')
ax.set_xlim (ax.get_xlim () [ : : - 1]) #reverse axis
plt.xlabel ('alpha')
plt.ylabel('$w_i$')
plt.title ('Coeficientes en función de la regularización')
plt.axis ('tight')

ax = plt.subplot (1, 2, 2)
ax.plot (alphas, norm2_coefs)
ax.set_xscale ('log')
ax.set_xlim (ax.get xlim () [ : : - 1]) #reverse axis 
plt.xlabel ('alpha)
plt.ylabel ('$ || \mathbf {w} || ^ 2_2$')
plt.title ('Norma de los coeffs en función de la regularización')
plt.axis ('tight")
plt.show ()
Entrenar un modelo Lasso para distintos valores de α 2

Si cambiamos el alphas = np.logspace (-10, -3, n_alphas) por alphas = np.logspace (-10, 3, n_alphas), para que la regularización suba hasta 10, 3, que es 1000, sí podemos observar cómo todos los coeficientes terminan con tendencia hacia 0:

Entrenar un modelo Lasso para distintos valores de α 3
#Entrenar un modelo Lasso
from sklearn.model_selection import GridSearchCV

alpha_vector= np. logspace (-10, 1, 25)

alpha_vector = np. logspace (-15, 1, 25)
param_grid = {'alpha': alpha_vector}
grid = GridSearchCV (Lasso (), scoring = 'neg_mean_squared_error', param_grid = param_grid, cv = 5)
grid.fit(x_train, y_train)
print ("best mean cross-validation score: {:.3f}".format (grid.best_score_))
print ("best parameters: {}".format (grid.best_params_))

scores =1 np.array (grid.cv_results_ ['mean_test_score'])
plt.semilogx (alpha_vector, scores, ' -o ')
plt.xlabel ('alpha, fontsize = 16)
plt.ylabel ('5-Fold MSE')
plt.ylim ((0, 1))
plt.show ()
Entrenar un modelo Lasso para distintos valores de α 4

Vemos que el alfa más bajo es 0.01. Si ejecutamos el modelo con este valor de alfa, el resultado que obtendríamos sería:

#Entrenar un modelo Lasso
alpha_optimo = grid.best_params_['alpha']
lasso = lasso (alpha = alpha_optimo).fit (X_train, y_train)

#predicción
y_hat = lasso.predict (x_test)
W = lasso.coef
norm_w2= np.dot (w, w.T)

#error
error_test = np.mean (np.power (y - y_hat, 2))

plt.plot (x, g_x, 'r', label = '$y$')
plt.plot (x_, y_i, 'b.', label = '$y_i$")
plt.plot (x, y_hat, 'g', label = '$\hat {y} $')
plt.title ('Grado: %i, MSE:%.2f\nalpha: %g, $ l | w l |_2 ^ 2$.2g'% (degree.error_test, alpha_optimo, norm_v2))
plt.legend ()
plt.xlim (0, 2))
plt.ylim ((-2, 2))
plt.show ()

coef names = ['w' + str (i) + ' :  ' for i in range (1, degree + 1)]

for f, wi in zip (coef names, w):
print (f, wi)
Entrenar un modelo Lasso para distintos valores de α 5

Como podemos observar, no es mucha la diferencia entre este modelo y el modelo sin regularizar.

¿Qué sigue?

Como hemos visto, entrenar un modelo Lasso es una tarea muy similar a entrenar un modelo Ridge. Si quieres seguir aprendiendo sobre estas temáticas, tenemos para ti una oportunidad única: el Big Data, Inteligencia Artificial & Machine Learning Full Stack Bootcamp, una formación de alta intensidad en donde adquirirás todos los conocimientos necesarios para incursionar en el mercado laboral en pocos meses. ¡Anímate a transformar tu vida y solicita más información!

👉 Descubre más del Big Data, Inteligencia Artificial & Machine Learning Full Stack Bootcamp ¡Descarga el temario!

👉 Prueba el Bootcamp Gratis por una Semana ¡Empieza ahora mismo!

👉 Conoce nuestros otros Bootcamps en Programación y Tecnología

[email protected]

¿Trabajo? Aprende a programar y consíguelo.

¡No te pierdas la próxima edición del Aprende a Programar desde Cero Full Stack Jr. Bootcamp!

 

Prepárate en 4 meses, aprende las últimas tecnologías y consigue trabajo desde ya. 

 

Solo en España hay más de 120.400 puestos tech sin cubrir, y con un sueldo 11.000€ por encima de la media nacional. ¡Es tu momento!

 

🗓️ Próxima edición: 13 de febrero

 

Reserva tu plaza descubre las becas disponibles.