0Pricing
R Academy · Lección

Gradient boosting con xgboost

Configure los parámetros de xgboost, la detención temprana y los programas de tasa de aprendizaje.

Gradient boosting con xgboost es una lección gratuita de R Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

¿Qué es el gradient boosting?

El gradient boosting construye un ensamblado secuencialmente. Cada árbol nuevo corrige los errores residuales del ensamblado anterior ajustándose al gradiente negativo de la función de pérdida. A diferencia de los bosques aleatorios (árboles en paralelo), el boosting construye los árboles de uno en uno, y cada árbol aprende de los errores del anterior.

library(xgboost)

# XGBoost expects data in a special matrix format
# We'll build a simple example step by step
cat('XGBoost version:', packageVersion('xgboost'))

# Key concept: each tree reduces the ensemble error
# Final prediction = sum of all tree predictions

xgb.DMatrix()

xgb.DMatrix(data, label) es el formato de datos interno optimizado de XGBoost. Almacena conjuntamente la matriz de características y el vector de etiquetas, lo que permite realizar cálculos rápidos y eficientes en memoria. Convierta siempre sus datos a DMatrix antes del entrenamiento.

library(xgboost)
library(MASS)

X_train <- as.matrix(Boston[1:400, -14])  # features
y_train <- Boston[1:400, 14]              # medv (target)

X_test  <- as.matrix(Boston[401:506, -14])
y_test  <- Boston[401:506, 14]

dtrain <- xgb.DMatrix(data = X_train, label = y_train)
dtest  <- xgb.DMatrix(data = X_test,  label = y_test)

cat('DMatrix rows:', nrow(dtrain))

xgboost() — Entrenamiento básico

xgboost(data, nrounds, eta, max_depth, objective) entrena el modelo. Parámetros clave: eta (tasa de aprendizaje; un valor menor es más robusto, pero más lento), max_depth (profundidad de los árboles, controla la complejidad del modelo) y nrounds (número de árboles).

params <- list(
  objective  = 'reg:squarederror',
  eta        = 0.1,     # learning rate
  max_depth  = 6,       # tree depth
  subsample  = 0.8,     # row subsampling
  colsample_bytree = 0.8  # column subsampling
)

set.seed(42)
model <- xgboost(
  data    = dtrain,
  params  = params,
  nrounds = 100,
  verbose = 0
)

cat('Model trained with', model$niter, 'rounds')

Watchlist — Supervisar la pérdida de validación

El argumento watchlist acepta una lista con nombre de objetos DMatrix. XGBoost evalúa e imprime la pérdida en cada conjunto de datos incluido después de cada ronda de boosting. Utilícelo para seguir la pérdida de entrenamiento y de validación, y detectar cuándo comienza el sobreajuste.

watchlist <- list(train = dtrain, eval = dtest)

model <- xgb.train(
  params    = params,
  data      = dtrain,
  nrounds   = 200,
  watchlist = watchlist,
  verbose   = 1
)

# The log shows train-rmse and eval-rmse per round
# Watch for eval-rmse increasing (overfitting signal)

early_stopping_rounds

early_stopping_rounds = 20 detiene el entrenamiento si la métrica de validación no ha mejorado durante 20 rondas consecutivas. Esto encuentra automáticamente el número óptimo de árboles y evita tanto el subajuste como el sobreajuste sin necesidad de un ajuste manual exhaustivo.

model <- xgb.train(
  params              = params,
  data                = dtrain,
  nrounds             = 1000,      # max rounds
  watchlist           = list(train = dtrain, eval = dtest),
  early_stopping_rounds = 20,      # stop if no improvement
  print_every_n       = 50,
  verbose             = 1
)

cat('Best iteration:', model$best_iteration)
cat('Best eval RMSE:', model$best_score)

Clasificación binaria

Para clasificación binaria, utilice objective = 'binary:logistic', que genera probabilidades predichas. La etiqueta debe ser numérica, con valor 0 o 1. Evalúe el modelo con AUC o log-loss mediante el parámetro eval_metric.

# Binary classification example
library(MASS)
Pima <- MASS::Pima.tr

X_cl <- as.matrix(Pima[, -8])
y_cl <- as.numeric(Pima$type) - 1  # factor to 0/1

dt_cl <- xgb.DMatrix(data = X_cl, label = y_cl)

mod_cl <- xgboost(
  data       = dt_cl,
  objective  = 'binary:logistic',
  eval_metric = 'auc',
  eta        = 0.05,
  max_depth  = 4,
  nrounds    = 100,
  verbose    = 0
)

Predicciones

predict(model, dtest) devuelve valores predichos sin transformar: probabilidades en clasificación o predicciones de valores reales en regresión. Aplique un umbral de 0.5 para convertir las probabilidades en etiquetas de clase en tareas de clasificación.

# Regression predictions
reg_preds <- predict(model, dtest)
rmse <- sqrt(mean((reg_preds - y_test)^2))
cat('Test RMSE:', round(rmse, 3))

# Classification predictions
prob_preds  <- predict(mod_cl, dt_cl)
class_preds <- ifelse(prob_preds > 0.5, 1, 0)
accuracy <- mean(class_preds == y_cl)
cat('Training Accuracy:', round(accuracy, 3))

xgb.cv() — Validación cruzada

xgb.cv(params, data, nrounds, nfold) ejecuta una validación cruzada de k particiones dentro de XGBoost. Es más rápido que utilizar rsample, porque XGBoost gestiona internamente las particiones. La salida muestra la media y la desviación estándar de la métrica en cada ronda.

cv_result <- xgb.cv(
  params    = params,
  data      = dtrain,
  nrounds   = 200,
  nfold     = 5,
  early_stopping_rounds = 15,
  print_every_n = 20,
  verbose   = 1
)

# Best nrounds from CV
best_nrounds <- cv_result$best_iteration
cat('Optimal nrounds:', best_nrounds)

# CV RMSE at best iteration
cat('CV RMSE:', cv_result$evaluation_log[best_nrounds, 'test_rmse_mean'][[1]])

Hiperparámetros clave

Los hiperparámetros de XGBoost con mayor impacto:

  • eta: Tasa de aprendizaje (0.01-0.3). Un valor menor requiere más árboles y es más robusto.
  • max_depth: Profundidad de los árboles (3-10). Un valor mayor implica más complejidad y provoca sobreajuste más rápido.
  • subsample: Fracción de filas por árbol (0.5-1.0). Reduce el sobreajuste.
  • colsample_bytree: Fracción de características por árbol (0.5-1.0).
  • lambda: Regularización L2 de los pesos de las hojas.
  • alpha: Regularización L1 de los pesos de las hojas.
params_tuned <- list(
  objective         = 'reg:squarederror',
  eta               = 0.05,
  max_depth         = 5,
  subsample         = 0.75,
  colsample_bytree  = 0.75,
  lambda            = 1.0,    # L2 regularization
  alpha             = 0.1,    # L1 regularization
  min_child_weight  = 3       # min samples in leaf
)

model_tuned <- xgboost(
  data = dtrain, params = params_tuned,
  nrounds = best_nrounds, verbose = 0
)

Guardar y cargar modelos

Los modelos de XGBoost se pueden guardar en el disco en formato binario con xgb.save(model, 'model.xgb') y volver a cargarse con xgb.load('model.xgb'). Este es el formato recomendado para la implementación en producción y garantiza una reproducibilidad exacta a nivel de bits.

# Save model
xgb.save(model, '/tmp/xgb_boston.xgb')

# Reload and predict
loaded_model <- xgb.load('/tmp/xgb_boston.xgb')
new_preds <- predict(loaded_model, dtest)

# Verify predictions match
all.equal(reg_preds, new_preds)  # TRUE

Clasificación multiclase

Para problemas multiclase, utilice objective = 'multi:softprob' y establezca num_class en el número de clases. Las etiquetas deben ser enteros indexados desde 0. La salida es una matriz de probabilidades para cada clase.

X_mc <- as.matrix(iris[, -5])
y_mc <- as.integer(iris$Species) - 1  # 0, 1, 2

dt_mc <- xgb.DMatrix(data = X_mc, label = y_mc)

params_mc <- list(
  objective  = 'multi:softprob',
  num_class  = 3,
  eta        = 0.1,
  max_depth  = 3
)

mod_mc <- xgboost(
  data = dt_mc, params = params_mc,
  nrounds = 50, verbose = 0
)

# Predictions: matrix of shape (n, num_class)
prob_matrix <- matrix(predict(mod_mc, dt_mc), ncol = 3, byrow = TRUE)
head(prob_matrix)

Comprobación rápida

¿Cuál es el propósito de establecer early_stopping_rounds = 20 en xgb.train()?

Repaso de XGBoost

Ideas clave de Gradient Boosting con XGBoost:

  • xgb.DMatrix(data, label) crea el formato de datos optimizado de XGBoost.
  • Parámetros clave: eta (tasa de aprendizaje), max_depth, subsample y colsample_bytree.
  • watchlist supervisa la pérdida de entrenamiento y validación en cada ronda.
  • early_stopping_rounds encuentra automáticamente el número óptimo de árboles.
  • xgb.cv() ejecuta una validación cruzada de k particiones dentro de XGBoost para buscar hiperparámetros rápidamente.
  • Utilice objective = 'binary:logistic' para problemas binarios y 'multi:softprob' para problemas multiclase.
  • Guarde y cargue modelos con xgb.save() / xgb.load().
# Production XGBoost pipeline
dtrain <- xgb.DMatrix(data = X_train, label = y_train)
dtest  <- xgb.DMatrix(data = X_test,  label = y_test)

params <- list(objective = 'reg:squarederror',
               eta = 0.05, max_depth = 5, subsample = 0.8)

cv  <- xgb.cv(params, dtrain, nrounds = 500, nfold = 5,
              early_stopping_rounds = 20, verbose = 0)

model <- xgboost(data = dtrain, params = params,
                 nrounds = cv$best_iteration, verbose = 0)

preds <- predict(model, dtest)
cat('RMSE:', sqrt(mean((preds - y_test)^2)))

Preguntas frecuentes

¿La lección «Gradient boosting con xgboost» es gratis?

Sí — el texto completo de «Gradient boosting con xgboost» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Gradient boosting con xgboost»?

Configure los parámetros de xgboost, la detención temprana y los programas de tasa de aprendizaje. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Gradient boosting con xgboost»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Árboles de decisión: base de los ensamblajes
  2. Bosques aleatorios con ranger
  3. Gradient boosting con xgboost
  4. Importancia de las características e interpretación de modelos
← Volver a R Academy