Regularización

La regularización es un conjunto de técnicas para evitar que un modelo se aprenda de memoria los datos de entrenamiento. La receta es sencilla: penalizar la complejidad para que el modelo prefiera explicaciones simples, que suelen generalizar mejor a datos nuevos.

El enemigo: el sobreajuste

Un modelo con demasiada libertad puede ajustarse a la perfección a los datos que ya vio... incluido su ruido. Cuando llega un dato nuevo, falla. A esto se le llama sobreajuste (overfitting).

• Subajuste (underfitting): el modelo es demasiado simple y no captura ni siquiera el patrón real.
• Punto justo: captura el patrón, ignora el ruido.
• Sobreajuste: memoriza el ruido y generaliza mal.

La señal de alarma clásica: un error muy bajo en entrenamiento pero mucho más alto en prueba.

Sesgo y varianza

Detrás del sobreajuste está el compromiso sesgo-varianza:

• Sesgo alto → el modelo es rígido y se equivoca de forma sistemática (subajuste).
• Varianza alta → el modelo cambia demasiado según los datos que le tocaron (sobreajuste).

La regularización sacrifica un poco de sesgo para reducir mucho la varianza, y así baja el error total en datos no vistos.

La receta: penalizar la complejidad

En un modelo lineal, la complejidad se refleja en el tamaño de los coeficientes ${\beta }_j$: coeficientes enormes indican una recta que se retuerce para pasar por cada punto. La regularización añade a la función de costo un término que castiga coeficientes grandes:

$$\mathcal{L}=\underset{\text{ajuste}}{\underbrace{\text{MSE}}}+\underset{\text{simplicidad}}{\underbrace{\lambda \cdot \text{penalizacioˊn}(\mathbf{\beta })}}$$

El modelo ya no solo busca ajustar los datos, sino hacerlo con coeficientes pequeños. Según cómo midamos esa penalización, aparecen dos grandes familias.

Ridge (L2): encoger sin eliminar

Ridge penaliza la suma de los coeficientes al cuadrado:

$${\mathcal{L}}_{\text{Ridge}}=\text{MSE}+\lambda \sum _{j=1}^p{\beta }_j^2$$

Efecto: encoge todos los coeficientes hacia cero de forma suave, pero ninguno llega a valer exactamente cero. Es ideal cuando muchas variables aportan un poco.

Lasso (L1): encoger y seleccionar

Lasso penaliza la suma de los valores absolutos:

$${\mathcal{L}}_{\text{Lasso}}=\text{MSE}+\lambda \sum _{j=1}^p|{\beta }_j|$$

Efecto: puede llevar coeficientes exactamente a cero, eliminando variables. Hace selección de variables automática, útil cuando sospechas que solo unas pocas importan.

Elastic Net: lo mejor de ambos

Elastic Net combina las dos penalizaciones, útil cuando hay muchas variables correlacionadas:

$$\mathcal{L}=\text{MSE}+{\lambda }_1\sum _j|{\beta }_j|+{\lambda }_2\sum _j{\beta }_j^2$$

$\lambda$: el mando

El hiperparámetro $\lambda$ (en scikit-learn se llama alpha) controla cuánta simplicidad exigimos:

• $\lambda =0$: sin regularización, se recupera el modelo clásico (máximo riesgo de sobreajuste).
• $\lambda$ pequeño: apenas encoge, modelo casi libre.
• $\lambda$ grande: coeficientes muy pequeños, modelo simple (riesgo de subajuste).

¿Cómo elegirlo? Probando varios valores y quedándote con el que da mejor desempeño en validación cruzada.

Más allá de la regresión

La misma idea reaparece en casi todo el aprendizaje automático:

• En XGBoost, el término $\Omega$ penaliza árboles con muchas hojas.
• En las SVM, el parámetro $C$ regula la tolerancia a errores.
• En redes neuronales, el dropout apaga neuronas al azar y el early stopping detiene el entrenamiento antes de memorizar.

En código

from sklearn.linear_model import Ridge, Lasso
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline

# alpha es λ: 0 = sin regularización; más grande = modelo más simple.
# Siempre conviene escalar las variables antes de regularizar.
ridge = make_pipeline(StandardScaler(), Ridge(alpha=1.0)).fit(X_train, y_train)
lasso = make_pipeline(StandardScaler(), Lasso(alpha=0.1)).fit(X_train, y_train)

print(ridge[-1].coef_)  # coeficientes encogidos, ninguno es exactamente 0
print(lasso[-1].coef_)  # varios coeficientes valen 0 → selección de variables

Para elegir alpha sin adivinar, se prueba una rejilla de valores con validación cruzada:

from sklearn.linear_model import RidgeCV
import numpy as np

modelo = RidgeCV(alphas=np.logspace(-3, 3, 20)).fit(X_train, y_train)
print(modelo.alpha_)  # el mejor λ según validación cruzada

Para llevar

Regularizar es preferir lo simple: se añade a la función de costo una penalización por coeficientes grandes. Ridge (L2) los encoge, Lasso (L1) además los elimina, y Elastic Net combina ambos. El mando $\lambda$ dosifica cuánta simplicidad exigir, y se ajusta con validación cruzada. Es la defensa más común contra el sobreajuste en todo el aprendizaje automático.