Gradient Boosting para clasificación

¿Qué es el Gradient Boosting?

El Gradient Boosting es un método de ensemble que construye modelos de forma secuencial: cada nuevo modelo se entrena para corregir los errores del modelo anterior. A diferencia del bagging (como Random Forest), donde los árboles se construyen en paralelo e independientemente, en boosting cada árbol depende de los resultados previos.

El algoritmo optimiza una función de pérdida añadiendo modelos débiles (normalmente árboles de decisión pequeños, llamados stumps o de poca profundidad) que apuntan en la dirección del gradiente negativo de la pérdida. Este proceso se repite durante n_estimators iteraciones.

GradientBoostingClassifier

La implementación clásica en Scikit-learn:

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

gbc = GradientBoostingClassifier(
    n_estimators=100,      # número de árboles
    learning_rate=0.1,     # tasa de aprendizaje (shrinkage)
    max_depth=3,           # profundidad máxima de cada árbol
    subsample=0.8,         # fracción de muestras por árbol (estocástico)
    random_state=42
)

gbc.fit(X_train, y_train)
y_pred = gbc.predict(X_test)

print(f"Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred))

Hiperparámetros clave

| Hiperparámetro | Descripción | Efecto en el modelo | |----------------|-------------|---------------------| | n_estimators | Número de árboles (iteraciones de boosting) | Más árboles = más complejidad; puede sobreajustar | | learning_rate | Peso de cada árbol nuevo (shrinkage) | Menor tasa = más robusto, necesita más árboles | | max_depth | Profundidad máxima de cada árbol | Valores entre 3 y 5 suelen funcionar bien | | subsample | Fracción de muestras para cada árbol | < 1.0 = gradient boosting estocástico; reduce varianza | | min_samples_leaf | Mínimo de muestras en hojas | Regularización; valores mayores reducen complejidad |

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split, GridSearchCV

X, y = load_wine(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

param_grid = {
    'n_estimators': [50, 100, 200],
    'learning_rate': [0.05, 0.1, 0.2],
    'max_depth': [2, 3, 4]
}

gbc = GradientBoostingClassifier(random_state=42)
grid = GridSearchCV(gbc, param_grid, cv=5, scoring='accuracy', n_jobs=-1)
grid.fit(X_train, y_train)

print(f"Mejores parámetros: {grid.best_params_}")
print(f"Accuracy test: {grid.score(X_test, y_test):.4f}")

Early stopping para evitar sobreajuste

GradientBoostingClassifier permite configurar un conjunto de validación para detener el entrenamiento cuando el rendimiento deja de mejorar:

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

gbc = GradientBoostingClassifier(
    n_estimators=500,
    learning_rate=0.05,
    max_depth=3,
    subsample=0.8,
    validation_fraction=0.1,  # usa el 10% del train para validar
    n_iter_no_change=10,       # para si no mejora en 10 rondas
    tol=1e-4,
    random_state=42
)

gbc.fit(X_train, y_train)
print(f"Árboles usados (con early stopping): {gbc.n_estimators_}")
print(f"Accuracy test: {accuracy_score(y_test, gbc.predict(X_test)):.4f}")

HistGradientBoostingClassifier: versión eficiente

Para datasets con más de 10 000 muestras, HistGradientBoostingClassifier es mucho más rápido que GradientBoostingClassifier. Utiliza histogramas de valores en lugar de valores exactos (similar a LightGBM):

from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import time

# Dataset más grande
X, y = make_classification(n_samples=50000, n_features=20, n_informative=10,
                             random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# HistGradientBoosting - rápido en datos grandes
t0 = time.time()
hgbc = HistGradientBoostingClassifier(
    max_iter=100,
    learning_rate=0.1,
    max_depth=4,
    early_stopping=True,
    random_state=42
)
hgbc.fit(X_train, y_train)
t_hgbc = time.time() - t0

print(f"HistGradientBoosting - Accuracy: {accuracy_score(y_test, hgbc.predict(X_test)):.4f}  Tiempo: {t_hgbc:.2f}s")
print(f"Iteraciones usadas: {hgbc.n_iter_}")

HistGradientBoostingClassifier también soporta valores faltantes de forma nativa, sin necesidad de imputación previa.

Importancia de características

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import load_breast_cancer
import numpy as np

X, y = load_breast_cancer(return_X_y=True)
feature_names = load_breast_cancer().feature_names

gbc = GradientBoostingClassifier(n_estimators=100, random_state=42)
gbc.fit(X, y)

# Ordenar características por importancia
importancias = gbc.feature_importances_
indices = np.argsort(importancias)[::-1]

print("Top 10 características más importantes:")
for i in range(10):
    print(f"  {i+1:2d}. {feature_names[indices[i]]:35s} {importancias[indices[i]]:.4f}")

Comparación con otros clasificadores de ensemble

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, AdaBoostClassifier
from sklearn.datasets import load_wine
from sklearn.model_selection import cross_val_score

X, y = load_wine(return_X_y=True)

modelos = {
    'RandomForest': RandomForestClassifier(n_estimators=100, random_state=42),
    'GradientBoosting': GradientBoostingClassifier(n_estimators=100, random_state=42),
    'AdaBoost': AdaBoostClassifier(n_estimators=100, random_state=42, algorithm='SAMME')
}

print(f"{'Modelo':20s}  {'Accuracy (CV 5)':>15}  {'Std':>8}")
for nombre, modelo in modelos.items():
    scores = cross_val_score(modelo, X, y, cv=5, scoring='accuracy')
    print(f"{nombre:20s}  {scores.mean():>15.4f}  {scores.std():>8.4f}")

Resumen

| Clase | Cuándo usar | |-------|-------------| | GradientBoostingClassifier | Dataset pequeño-mediano, máxima precisión | | HistGradientBoostingClassifier | Dataset grande (>10K), rapidez, valores nulos | | AdaBoostClassifier | Cuando los errores están en pocas muestras difíciles |

El Gradient Boosting suele ser uno de los algoritmos más potentes para clasificación en datos tabulares, especialmente con un buen ajuste de learning_rate y n_estimators mediante early stopping o validación cruzada.