Supervised Learning Models — Logistic Regression, Random Forest, XGBoost
Clasificación vs. regresión, los algoritmos clave y cómo evitar overfitting.
El aprendizaje supervisado es el paradigma donde el modelo aprende de ejemplos etiquetados: para cada entrada X existe una salida y conocida. El trabajo del algoritmo es aprender la función que mapea X → y de forma generalizable. Hay dos grandes familias: clasificación (la salida es una categoría discreta, como 'churn / no churn') y regresión (la salida es un número continuo, como el precio de una casa).
La regresión logística es el modelo más simple para clasificación binaria. Aprende un hiperplano que separa las clases y convierte la distancia a ese plano en una probabilidad vía la función sigmoide. Es interpretable, rápida y un excelente baseline: si un modelo más complejo no la supera, hay un problema en el pipeline o en los datos, no en el modelo.
Random Forest es un ensemble de árboles de decisión entrenados sobre subconjuntos aleatorios de datos y features (técnica llamada bagging). Al promediar las predicciones de muchos árboles decorrelacionados, reduce la varianza sin aumentar el sesgo. Maneja bien features categóricas, outliers y relaciones no lineales. Es robusto out-of-the-box y provee feature importances como subproducto.
XGBoost implementa gradient boosting: los árboles se construyen secuencialmente, cada uno corrigiendo los errores del anterior. Es más poderoso que Random Forest en la mayoría de tabular benchmarks, pero más sensible a hiperparámetros y más propenso a overfitting. Requiere tuning cuidadoso de n_estimators, learning_rate, max_depth y regularización (reg_alpha, reg_lambda).
El overfitting ocurre cuando el modelo aprende el ruido del train set en lugar de los patrones generalizables. Los síntomas clásicos: accuracy altísima en train, mucho más baja en val. Los remedios incluyen regularización (C en logistic regression, max_depth en árboles), más datos, early stopping en XGBoost, y validación cruzada para detectarlo temprano. Ver este enfoque aplicado al problema real de predicción de fuga bancaria en: https://churn.benjacode.com
Elegir el modelo correcto no es magia: empieza siempre con el más simple (logistic regression), mide el baseline, y agrega complejidad solo cuando los datos lo justifican. La complejidad innecesaria es deuda técnica disfrazada de sofisticación.
# Regresión Logística — baseline de clasificación
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(C=1.0, max_iter=1000, random_state=42)
lr.fit(X_train, y_train)
proba = lr.predict_proba(X_val)[:, 1] # probabilidad clase positiva
# Random Forest — ensemble de árboles
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=200,
max_depth=10,
min_samples_leaf=5,
random_state=42,
n_jobs=-1
)
rf.fit(X_train, y_train)
importances = rf.feature_importances_ # array de importancias
# XGBoost — gradient boosting
from xgboost import XGBClassifier
xgb = XGBClassifier(
n_estimators=500,
learning_rate=0.05,
max_depth=6,
subsample=0.8,
colsample_bytree=0.8,
reg_alpha=0.1,
eval_metric='logloss',
early_stopping_rounds=50,
random_state=42
)
xgb.fit(
X_train, y_train,
eval_set=[(X_val, y_val)],
verbose=False
)Debugging lab
Detecta y corrige el error en el código.
- 2.2.5.1
from sklearn.linear_model import LinearRegression model = LinearRegression() model.fit(X_train, y_train) preds = model.predict(X_test) # y_test contiene labels 0 y 1
- 2.2.5.2
xgb = XGBClassifier(n_estimators=1000, learning_rate=0.3) xgb.fit(X_train, y_train) print(xgb.score(X_train, y_train)) # 0.99 print(xgb.score(X_val, y_val)) # 0.71
- 2.2.5.3
rf = RandomForestClassifier(n_estimators=10) rf.fit(X_train, y_train) # El score de val fluctúa mucho entre runs aunque random_state está fijo
- 2.2.5.4
from sklearn.svm import SVC model = SVC() model.fit(X_train, y_train) # X_train tiene 500 000 filas — tarda horas
- 2.2.5.5
rf = RandomForestClassifier() rf.fit(X_train, y_train) importances = rf.feature_importances_ # Se elimina toda feature con importance < 0.01 sin más análisis