Ridge y lasso

💡En simple: lee esto primero

Regularizar = ponerle una «multa» al modelo cuando usa números muy grandes, para que no se vuelva exagerado ni memorice.

Imagínalo así

Es como darle a alguien un presupuesto limitado: si cada peso «cuesta», el modelo solo invierte en las variables que realmente valen la pena.

Lo que tienes que llevarte

• Ridge encoge todos los pesos un poco (ninguno llega a cero).
• Lasso puede dejar pesos exactamente en cero: elimina variables inútiles (sirve para elegir variables).
• λ (lambda) es el tamaño de la multa: 0 = sin multa; muy grande = todo se aplasta hacia cero.

Palabras raras de esta página

regularización

agregar una penalización para que el modelo sea más simple.

ℓ2 / ℓ1

dos formas de medir «qué tan grandes» son los pesos (suma de cuadrados vs. suma de valores absolutos).

λ (lambda)

la perilla que decide cuánto pesa la multa.

camino de coeficientes

un gráfico de cómo cambia cada peso a medida que subes λ.

Más abajo viene la versión completa, con fórmulas. Si una palabra aparece subrayada con puntos, pasa el mouse (o tócala) para ver qué significa.

¿Por qué los pesos grandes son un problema?

El lado derecho de la U es alta varianza: el ajuste oscila violentamente con los datos, y esa violencia viene de pesos enormes. Para pasar por cada punto ruidoso, la curva se dobla bruscamente, lo que requiere coeficientes gigantes ($|w_j|\sim10^9$ en grado 12) que casi se cancelan entre sí.

Pesos grandes = huella del overfitting. Mantenerlos pequeños ⇒ la curva no puede ondular tanto ⇒ menos varianza.

La idea: cobrar por pesos grandes

En vez de restringir la familia de modelos, agregamos una penalización:

$$J_\lambda(\mathbf{w}) = \underbrace{\|\mathbf{y}-\mathbf{X}\mathbf{w}\|_2^2}_{\text{ajustar los datos}} + \lambda\underbrace{\Omega(\mathbf{w})}_{\text{mantenerse simple}}$$

• $\lambda\ge0$ es la tasa de cambio: cuánto ajuste pagamos por pesos más chicos. $\lambda=0$ es OLS; $\lambda\to\infty$ aplasta todo a 0.
• Los dos términos tiran en direcciones opuestas: una cuerda. Cambiamos un poco de sesgo por una gran caída de varianza.
• $\lambda$ es un hiperparámetro: se elige, no se aprende (con validación cruzada).

Ridge ($\ell_2$) y lasso ($\ell_1$)

$$\Omega_\text{ridge}(\mathbf{w}) = \|\mathbf{w}\|_2^2 = \sum_j w_j^2,\qquad \Omega_\text{lasso}(\mathbf{w}) = \|\mathbf{w}\|_1 = \sum_j|w_j|$$

Ridge es suave ⇒ forma cerrada (solo sumar λ a la diagonal):

$$\mathbf{w}^\star_\lambda = (\mathbf{X}^\top\mathbf{X}+\lambda\mathbf{I})^{-1}\mathbf{X}^\top\mathbf{y}$$

$\mathbf{X}^\top\mathbf{X}+\lambda\mathbf{I}$ es definida positiva para todo $\lambda>0$: ridge es único aun con features colineales o $p>n$, justo donde OLS se rompe. Vía SVD, ridge escala el ajuste en la dirección $j$ por $\sigma_j^2/(\sigma_j^2+\lambda)$: direcciones fuertes pasan casi intactas; las débiles y ruidosas se encogen fuerte.

	Ridge (ℓ2): solo encoge	Lasso (ℓ1): encoge y selecciona
Pesos	todos bajan suave, ninguno llega a 0	muchos quedan exactamente en 0 (esparcidad)
Features correlacionadas	reparte el peso entre ellas (estable)	tiende a quedarse con una (elección inestable)
Optimización	suave ⇒ forma cerrada	convexo pero no derivable en 0 ⇒ sin forma cerrada
Cuándo	muchos efectos pequeños	pocas features hacen el trabajo

Analogía de la slide

Ridge es una perilla de volumen: baja todo, nunca apaga. Lasso agrega un botón de mute. ¿Quieres ambos? Elastic net $=\lambda_1\|\mathbf{w}\|_1+\lambda_2\|\mathbf{w}\|_2^2$.

Siempre

Estandariza las features antes (la penalización depende de la escala) y no penalices el sesgo $b$ (no queremos encoger el nivel general del modelo).

De dónde sale la fórmula cerrada de ridge (y el soft-threshold del lasso)

1. Costo: $J_\lambda(\mathbf{w}) = \Vert\mathbf{y}-\mathbf{X}\mathbf{w}\Vert^2 + \lambda\,\mathbf{w}^\top\mathbf{w}$.
2. El primer término tiene gradiente $-2\mathbf{X}^\top(\mathbf{y}-\mathbf{X}\mathbf{w})$ (igual que OLS); el segundo, $2\lambda\mathbf{w}$.
3. Igualando a cero: $-\mathbf{X}^\top\mathbf{y} + \mathbf{X}^\top\mathbf{X}\mathbf{w} + \lambda\mathbf{w} = \mathbf{0} \;\Rightarrow\; (\mathbf{X}^\top\mathbf{X}+\lambda\mathbf{I})\mathbf{w} = \mathbf{X}^\top\mathbf{y}$.
4. $\mathbf{X}^\top\mathbf{X}$ es semidefinida positiva (autovalores $\ge 0$); sumarle $\lambda\mathbf{I}$ sube todos los autovalores en $\lambda$, así que con $\lambda>0$ son $>0$: la matriz siempre es invertible.
5. $\mathbf{w}^\star_\lambda = (\mathbf{X}^\top\mathbf{X}+\lambda\mathbf{I})^{-1}\mathbf{X}^\top\mathbf{y}$. Con $\mathbf{X}^\top\mathbf{X} = \mathbf{I}$ (features ortonormales) queda $\mathbf{w}_\lambda = \mathbf{w}_\text{OLS}/(1+\lambda)$: el encogimiento proporcional del gráfico de abajo.
6. Lasso en 1-D: $\min_w (w-a)^2 + \lambda\lvert w\rvert$. Para $w>0$ la derivada es $2(w-a)+\lambda = 0 \Rightarrow w = a-\lambda/2$, válido solo si $a > \lambda/2$; simétrico para $w<0$; si $\lvert a\rvert\le\lambda/2$ el mínimo está en el pico $w = 0$. Eso es el soft-threshold con $\gamma=\lambda/2$.

← AnteriorSiguiente paso →Ver todoReiniciar

¿Por qué el ℓ1 da ceros? La geometría

Penalizar equivale a imponer un presupuesto $\|\mathbf{w}\|_q\le t$ (λ grande ⇔ t chico). Las curvas de nivel de la pérdida son elipses alrededor del óptimo OLS; encogemos hasta que la elipse toca por primera vez la región permitida:

• Disco ℓ2: el contacto cae en un punto genérico, ambas coordenadas ≠ 0.
• Rombo ℓ1: tiene esquinas puntiagudas sobre los ejes; muy a menudo la elipse toca primero una esquina ⇒ una coordenada = 0.

¿Por qué el lasso produce ceros? La geometría

Arrastra β̂ (el óptimo sin penalización, en naranja). La solución penalizada es el punto donde la elipse de costo más pequeña toca por primera vez la región del presupuesto: el disco ℓ2 (ridge) o el rombo ℓ1 (lasso).

presupuesto t (t pequeño ⇔ λ grande) 1.2

Ridge · ‖β‖₂ ≤ t

Lasso · ‖β‖₁ ≤ t

β ridge(0.87, 0.82)

β lasso(0.59, 0.61)

ceros en lasso0

El disco es redondo: el contacto cae en un punto genérico con ambas coordenadas ≠ 0. El rombo tiene esquinas sobre los ejes: con frecuencia la elipse toca primero una esquina y una coordenada queda exactamente en 0 (selección de features). Achica t y mira cómo el lasso pasa a una esquina.

---

El mecanismo en 1-D: encoger vs umbralizar

Con features no correlacionados cada peso resuelve min (w − a)² + λΩ(w), donde a = w_OLS.

λ 1

sin penalización w = aridge: w = a/(1+λ)lasso: soft-threshold, zona muerta |a| ≤ 0.50

Ridge escala cada peso (nunca llega a 0: es una perilla de volumen). Lasso resta un γ constante y recorta a 0 todo lo que cae en la zona muerta (un botón de mute): cerca de 0 la pendiente de |w| es constante y domina a los pesos pequeños.

El mecanismo: soft-threshold

Con features no correlacionadas cada peso resuelve un problema 1-D, $\min_w (w-a)^2 + \lambda\Omega(w)$, con $a = w_\text{OLS}$:

$$\text{ridge: } w = \frac{a}{1+\lambda}\qquad\qquad \text{lasso: } w = \operatorname{sign}(a)\max(|a|-\gamma,\,0),\ \ \gamma = \lambda/2$$

Ridge escala proporcionalmente (nunca 0). Lasso resta una cantidad fija y tiene una zona muerta $|a|\le\gamma$ que manda pesos pequeños a 0: cerca de 0 la pendiente de $|w|$ es constante y le gana a los pesos chicos. Esa torcedura es la esquina del rombo.

📈

Caso de uso · marketingMarketing con 500 variables: lasso como detector de lo que importa

Una cadena de retail predice las ventas semanales de cada tienda con 500 variables candidatas (clima, feriados, promociones de 40 categorías, precios de la competencia, tráfico web…) y solo 300 semanas de historia: más features que ejemplos.

• OLS es imposible ($\mathbf{X}^\top\mathbf{X}$ singular con $p > n$).
• Ridge funciona y predice bien, pero conserva las 500 variables con pesitos: difícil de explicar a gerencia.
• Lasso (con λ por CV) deja solo unas pocas decenas de variables con peso distinto de cero: algunas promociones, feriados, temperatura… Es un modelo que el negocio entiende y sobre el que puede actuar.
• Si dos variables están muy correlacionadas (precio propio y precio del competidor), lasso puede quedarse con una casi al azar: para estabilidad, elastic net.

Cómo se optimiza cada uno

• Ridge: suave y convexo ⇒ gradiente = 0 ⇒ forma cerrada (o descenso de gradiente para datos grandes).
• Lasso: convexo pero con una torcedura en 0 ⇒ se usa el subgradiente (cualquier pendiente en $[-1,1]$ en $w=0$). El caballo de batalla es el descenso por coordenadas: actualizar un peso a la vez con el soft-threshold (fórmula cerrada por coordenada); los ceros exactos salen solos. LARS traza todo el camino (lineal a trozos en λ) de una pasada.

Caminos de coeficientes

Graficando cada peso contra λ (escala log): en ridge todos se encogen suavemente, ninguno toca 0; en lasso van cayendo a 0 uno por uno: la firma de la selección de features.

Ridge en acción

Grado alto fijo; mueve λ: muy poco sigue sobreajustando, demasiado sobre-suaviza (sesgo), en medio sigue la señal. Mira cómo las barras de los pesos se encogen.

Sube el grado… y mira la validación

Datos de sin(2πx) + ruido. El modelo sigue siendo lineal en los pesos: solo añadimos columnas x², x³… a la matriz de diseño. Los puntos llenos entrenan; los huecos validan.

grado del polinomio 11λ (ridge) 0n de entrenamiento 14

Nuevos datosIr al mejor grado según validación

ajuste actualverdad sin(2πx)RMSE trainRMSE validaciónmínimo de validación

RMSE train0.051

RMSE validación38.884

mayor |wⱼ|4264.67

diagnósticooverfit

Train muy bajo y validación alto: una brecha grande = memorizó el ruido (alta varianza). Mira las barras: los pesos crecen (escala log). Sube λ para encogerlos sin bajar el grado.

Ejemplo real: diabetes

Con λ elegido por CV: OLS 56.4, ridge 56.5, lasso 56.6 de RMSE de test: casi iguales. Ridge encoge pero conserva todo; lasso pone en 0 age, s4 y s6. A igual precisión, prefiere el modelo más simple y esparso.

Ejercicio

Con features no correlacionadas, $w_\text{OLS} = (3,\ 0.4,\ -1.2)$ y $\lambda = 1$. Calcula ridge y lasso.

Ver solución

• Ridge: $w = a/(1+\lambda) = a/2 = (1.5,\ 0.2,\ -0.6)$. Nada es cero.
• Lasso con $\gamma=\lambda/2=0.5$: $\operatorname{sign}(a)\max(|a|-0.5,0) = (2.5,\ 0,\ -0.7)$. El segundo peso ($|0.4|\le0.5$) cae en la zona muerta: feature eliminada.

Autoevaluación

0/5 correctas · 0 respondidas Reiniciar

1. Lasso, que penaliza $\|\mathbf{w}\|_1$, tiende a llevar varios pesos exactamente a cero.

a) Verdaderob) Falso

2. ¿Qué hace ridge con features perfectamente colineales?

a) falla como OLSb) sigue teniendo solución única porque $X^\top X + \lambda I$ es definida positivac) elimina una de ellasd) duplica su peso

3. Con $\lambda \to \infty$ en ridge, los pesos…

a) divergenb) tienden a 0 (salvo el sesgo, que no se penaliza)c) igualan a OLSd) se vuelven esparsos exactamente

4. Geométricamente, lasso produce ceros porque…

a) el disco ℓ2 es más pequeñob) el rombo ℓ1 tiene esquinas sobre los ejesc) las elipses son círculosd) usa descenso de gradiente

5. ¿Qué algoritmo se usa típicamente para lasso?

a) ecuaciones normalesb) descenso por coordenadas con soft-thresholdc) SMOd) CART

En código

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import RidgeCV, LassoCV
import numpy as np

alphas = np.logspace(-4, 3, 50)            # en scikit-learn, λ se llama alpha
ridge = make_pipeline(StandardScaler(), RidgeCV(alphas=alphas, cv=5)).fit(X_tr, y_tr)
lasso = make_pipeline(StandardScaler(), LassoCV(alphas=alphas, cv=5)).fit(X_tr, y_tr)

coef = lasso[-1].coef_
print('λ elegido:', lasso[-1].alpha_, '· features con peso ≠ 0:', np.sum(coef != 0))
# el intercepto no se penaliza (fit_intercept=True)

↔ Conexiones con otros temas

Logística regularizadaEl mismo λ‖w‖² evita que w → ∞ con clases separables.SVM = hinge + L2El ½‖w‖² del SVM es un ridge; C juega el papel de 1/λ.MAP y priorsRidge = MAP con prior gaussiano en w; Laplace smoothing = prior de conteos.Poda de árbolesR(T) + α|T|: la misma receta, penalizando hojas en vez de pesos.

Para profundizar

docsscikit-learn · Linear modelsOLS, Ridge, Lasso, LogisticRegression: fórmulas y parámetros reales.libroISLR / ISLP (James et al.)Libro gratis, citado en las slides. Cap. 3, 4, 5, 6, 8 y 9 cubren todo el parcial.videoStatQuest · índice de videosJosh Starmer explica cada tema del curso con dibujos; busca el tema en el índice.

Fuente ·ML_Course_regularization_and_model_selection.pdf (slides 19–26, 33) · ML_Course_Linear_Regression.pdf (slides 40–44) · ML_Course/session-03b-ridge-lasso.ipynb