0Pricing
R Academy · Lezione

Gradient boosting con xgboost

Configuri i parametri di xgboost, l'arresto anticipato e le pianificazioni del learning rate

Gradient boosting con xgboost è una lezione R Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento R Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso R Academy include 4 lezioni in totale.

Che cos'è il gradient boosting?

Il gradient boosting costruisce un ensemble in modo sequenziale. Ogni nuovo albero corregge gli errori residui dell'ensemble precedente adattandosi al gradiente negativo della funzione di perdita. A differenza delle random forest (con alberi costruiti in parallelo), il boosting costruisce gli alberi uno alla volta, imparando dagli errori dell'albero precedente.

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) è il formato interno ottimizzato dei dati di XGBoost. Memorizza insieme la matrice delle feature e il vettore delle etichette, consentendo calcoli rapidi ed efficienti in termini di memoria. Converta sempre i dati in DMatrix prima dell'addestramento.

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() — Addestramento di base

xgboost(data, nrounds, eta, max_depth, objective) addestra il modello. Parametri fondamentali: eta (tasso di apprendimento, più basso = maggiore robustezza ma minore velocità), max_depth (profondità degli alberi, controlla la complessità del modello) e nrounds (numero di alberi).

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 — Monitoraggio della perdita di validazione

L'argomento watchlist accetta una lista denominata di oggetti DMatrix. XGBoost valuta e stampa la perdita su ciascun dataset elencato dopo ogni iterazione di boosting. Lo utilizzi per monitorare la perdita di training rispetto a quella di validazione e rilevare l'inizio dell'overfitting.

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 l'addestramento se la metrica di validazione non migliora per 20 iterazioni consecutive. In questo modo individua automaticamente il numero ottimale di alberi, evitando sia l'underfitting sia l'overfitting senza un'ottimizzazione manuale esaustiva.

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)

Classificazione binaria

Per la classificazione binaria, utilizzi objective = 'binary:logistic', che restituisce probabilità previste. L'etichetta deve essere un valore numerico 0/1. Valuti il modello con AUC o log-loss usando il parametro 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
)

Previsioni

predict(model, dtest) restituisce valori previsti grezzi: probabilità per la classificazione oppure previsioni con valori reali per la regressione. Per i task di classificazione, applichi una soglia di 0.5 per convertire le probabilità in etichette di classe.

# 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() — Cross-validation

xgb.cv(params, data, nrounds, nfold) esegue la cross-validation k-fold all'interno di XGBoost. È più veloce dell'utilizzo di rsample perché XGBoost gestisce internamente i fold. L'output mostra la media e la deviazione standard della metrica per ogni iterazione.

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]])

Iperparametri fondamentali

Gli iperparametri di XGBoost con il maggiore impatto:

  • eta: tasso di apprendimento (0.01-0.3). Più basso = servono più alberi, maggiore robustezza.
  • max_depth: profondità degli alberi (3-10). Più alto = maggiore complessità e overfitting più rapido.
  • subsample: frazione di righe per albero (0.5-1.0). Riduce l'overfitting.
  • colsample_bytree: frazione di feature per albero (0.5-1.0).
  • lambda: regolarizzazione L2 sui pesi delle foglie.
  • alpha: regolarizzazione L1 sui pesi delle foglie.
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
)

Salvataggio e caricamento dei modelli

I modelli XGBoost possono essere salvati su disco in formato binario con xgb.save(model, 'model.xgb') e ricaricati con xgb.load('model.xgb'). Questo è il formato consigliato per la messa in produzione e garantisce la riproducibilità bit per 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

Classificazione multiclasse

Per i problemi multiclasse, utilizzi objective = 'multi:softprob' e imposti num_class sul numero di classi. Le etichette devono essere interi indicizzati a partire da 0. L'output è una matrice di probabilità per ogni 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 rapida

Qual è lo scopo di impostare early_stopping_rounds = 20 in xgb.train()?

Riepilogo di XGBoost

Concetti chiave del Gradient Boosting con XGBoost:

  • xgb.DMatrix(data, label) crea il formato di dati ottimizzato di XGBoost.
  • Parametri fondamentali: eta (tasso di apprendimento), max_depth, subsample e colsample_bytree.
  • watchlist monitora la perdita di training e validazione a ogni iterazione.
  • early_stopping_rounds individua automaticamente il numero ottimale di alberi.
  • xgb.cv() esegue la CV k-fold all'interno di XGBoost per una ricerca rapida degli iperparametri.
  • Utilizzi objective = 'binary:logistic' per la classificazione binaria e 'multi:softprob' per quella multiclasse.
  • Salvi e carichi i modelli 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)))

Domande Frequenti

La lezione «Gradient boosting con xgboost» è gratuita?

Sì — il testo completo di «Gradient boosting con xgboost» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso R Academy, passa a CoddyKit PRO. Il corso R Academy include 4 lezioni in totale.

Cosa imparerò in «Gradient boosting con xgboost»?

Configuri i parametri di xgboost, l'arresto anticipato e le pianificazioni del learning rate Eserciti R Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare R Academy?

Non è richiesta alcuna esperienza precedente. R Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Gradient boosting con xgboost»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione R Academy?

Sì. Ogni lezione R Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Alberi decisionali: la base degli ensemble
  2. Random forest con ranger
  3. Gradient boosting con xgboost
  4. Importanza delle feature e interpretazione dei modelli
← Torna a R Academy