0Pricing
R Academy · Aula

Boosting de gradiente com xgboost

Configure parâmetros do xgboost, parada antecipada e programações da taxa de aprendizado.

Boosting de gradiente com xgboost é uma aula grátis de R Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

O que é o boosting por gradiente

O boosting por gradiente constrói um conjunto sequencialmente. Cada nova árvore corrige os erros residuais do conjunto anterior ao ser ajustada ao gradiente negativo da função de perda. Diferentemente das florestas aleatórias (árvores em paralelo), o boosting constrói as árvores uma por vez, e cada uma aprende com os erros da 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) é o formato interno de dados otimizado do XGBoost. Ele armazena juntos a matriz de características e o vetor de rótulos, permitindo uma computação rápida e eficiente em termos de memória. Sempre converta seus dados para DMatrix antes do treinamento.

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() — Treinamento básico

xgboost(data, nrounds, eta, max_depth, objective) treina o modelo. Parâmetros principais: eta (taxa de aprendizado, valor menor = mais robusto, porém mais lento), max_depth (profundidade da árvore, controla a complexidade do modelo) e nrounds (número de árvores).

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 — Monitorar a perda de validação

O argumento watchlist aceita uma lista nomeada de objetos DMatrix. O XGBoost avalia e imprime a perda em cada conjunto de dados listado após cada rodada de boosting. Use-o para acompanhar a perda de treinamento e de validação e detectar quando o sobreajuste começa.

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 interrompe o treinamento se a métrica de validação não melhorar por 20 rodadas consecutivas. Isso encontra automaticamente o número ideal de árvores, evitando tanto o subajuste quanto o sobreajuste sem um ajuste manual exaustivo.

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)

Classificação binária

Para classificação binária, use objective = 'binary:logistic', que produz probabilidades previstas. O rótulo deve ser numérico, com valor 0 ou 1. Avalie usando AUC ou log-loss com o 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
)

Previsões

predict(model, dtest) retorna valores previstos brutos — probabilidades para classificação ou previsões de valores reais para regressão. Aplique um limiar de 0,5 para converter probabilidades em rótulos de classe nas tarefas de classificação.

# 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() — Validação cruzada

xgb.cv(params, data, nrounds, nfold) executa validação cruzada em k partes dentro do XGBoost. Isso é mais rápido do que usar rsample, pois o XGBoost gerencia as partes internamente. A saída mostra a média e o SD da métrica por rodada.

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 principais

Os hiperparâmetros do XGBoost que mais influenciam o modelo:

  • eta: Taxa de aprendizado (0,01–0,3). Valor menor = mais árvores necessárias e maior robustez.
  • max_depth: Profundidade da árvore (3–10). Valor maior = mais complexidade e sobreajuste mais rápido.
  • subsample: Fração de linhas por árvore (0,5–1,0). Reduz o sobreajuste.
  • colsample_bytree: Fração de características por árvore (0,5–1,0).
  • lambda: Regularização L2 nos pesos das folhas.
  • alpha: Regularização L1 nos pesos das folhas.
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
)

Salvar e carregar modelos

Os modelos do XGBoost podem ser salvos em disco em formato binário com xgb.save(model, 'model.xgb') e carregados novamente com xgb.load('model.xgb'). Esse é o formato recomendado para implantação em produção e garante reprodutibilidade exata bit a bit.

# 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

Classificação multiclasse

Para problemas multiclasse, use objective = 'multi:softprob' e defina num_class como o número de classes. Os rótulos devem ser inteiros indexados a partir de 0. A saída é uma matriz de probabilidades para cada classe.

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)

Verificação rápida

Qual é a finalidade de definir early_stopping_rounds = 20 em xgb.train()?

Recapitulação sobre XGBoost

Principais conclusões sobre Boosting por Gradiente com XGBoost:

  • xgb.DMatrix(data, label) cria o formato de dados otimizado do XGBoost.
  • Parâmetros principais: eta (taxa de aprendizado), max_depth, subsample e colsample_bytree.
  • watchlist monitora a perda de treinamento e de validação a cada rodada.
  • early_stopping_rounds encontra automaticamente o número ideal de árvores.
  • xgb.cv() executa validação cruzada em k partes dentro do XGBoost para uma busca rápida de hiperparâmetros.
  • Use objective = 'binary:logistic' para problemas binários e 'multi:softprob' para problemas multiclasse.
  • Salve e carregue modelos com 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)))

Perguntas Frequentes

A aula “Boosting de gradiente com xgboost” é grátis?

Sim — o texto completo de “Boosting de gradiente com xgboost” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Boosting de gradiente com xgboost”?

Configure parâmetros do xgboost, parada antecipada e programações da taxa de aprendizado. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Boosting de gradiente com xgboost”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Árvores de decisão: base dos conjuntos
  2. Florestas aleatórias com ranger
  3. Boosting de gradiente com xgboost
  4. Importância de atributos e interpretação de modelos
← Voltar para R Academy