0Pricing
R Academy · Lektion

Gradient Boosting mit xgboost

Konfigurieren Sie xgboost-Parameter, Early Stopping und Lernratenpläne

Gradient Boosting mit xgboost ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Gradient Boosting?

Gradient Boosting erstellt ein Ensemble schrittweise. Jeder neue Baum korrigiert die Residuenfehler des bisherigen Ensembles, indem er auf den negativen Gradienten der Verlustfunktion angepasst wird. Im Gegensatz zu Random Forests mit parallel erstellten Bäumen erstellt Boosting die Bäume nacheinander, wobei jeder aus den Fehlern des vorherigen lernt.

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) ist das optimierte interne Datenformat von XGBoost. Es speichert die Feature-Matrix und den Label-Vektor gemeinsam und ermöglicht dadurch eine schnelle und speichereffiziente Berechnung. Konvertieren Sie Ihre Daten vor dem Training immer in eine DMatrix.

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() — Grundlegendes Training

xgboost(data, nrounds, eta, max_depth, objective) trainiert das Modell. Wichtige Parameter sind: eta (Lernrate, kleiner = robuster, aber langsamer), max_depth (Baumtiefe, steuert die Modellkomplexität) und nrounds (Anzahl der Bäume).

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 — Validierungsverlust überwachen

Das Argument watchlist akzeptiert eine benannte Liste von DMatrix-Objekten. XGBoost wertet den Verlust für jeden aufgeführten Datensatz nach jeder Boosting-Runde aus und gibt ihn aus. Verwenden Sie die Watchlist, um den Trainings- und Validierungsverlust zu verfolgen und den Beginn von Overfitting zu erkennen.

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 beendet das Training, wenn sich die Validierungsmetrik 20 Runden in Folge nicht verbessert hat. Dadurch wird automatisch die optimale Anzahl von Bäumen ermittelt, sodass Underfitting und Overfitting ohne aufwendige manuelle Abstimmung vermieden werden.

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)

Binäre Klassifikation

Verwenden Sie für die binäre Klassifikation objective = 'binary:logistic', das vorhergesagte Wahrscheinlichkeiten ausgibt. Das Label muss numerisch 0/1 sein. Bewerten Sie das Modell mit AUC oder Log-Loss über den Parameter 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
)

Vorhersagen

predict(model, dtest) gibt rohe vorhergesagte Werte zurück — Wahrscheinlichkeiten bei der Klassifikation oder reelle Vorhersagewerte bei der Regression. Wenden Sie bei Klassifikationsaufgaben einen Schwellenwert von 0,5 an, um Wahrscheinlichkeiten in Klassenlabels umzuwandeln.

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

xgb.cv(params, data, nrounds, nfold) führt eine k-fache Kreuzvalidierung innerhalb von XGBoost durch. Dies ist schneller als die Verwendung von rsample, da XGBoost die Folds intern verarbeitet. Die Ausgabe zeigt Mittelwert und Standardabweichung der Metrik pro Runde.

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

Wichtige Hyperparameter

Die wichtigsten Hyperparameter von XGBoost:

  • eta: Lernrate (0,01–0,3). Niedriger = mehr benötigte Bäume, robuster.
  • max_depth: Baumtiefe (3–10). Größer = komplexer, schnelleres Overfitting.
  • subsample: Zeilenanteil pro Baum (0,5–1,0). Reduziert Overfitting.
  • colsample_bytree: Feature-Anteil pro Baum (0,5–1,0).
  • lambda: L2-Regularisierung der Blattgewichte.
  • alpha: L1-Regularisierung der Blattgewichte.
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
)

Modelle speichern und laden

XGBoost-Modelle können mit xgb.save(model, 'model.xgb') in einem binären Format auf der Festplatte gespeichert und mit xgb.load('model.xgb') wieder geladen werden. Dies ist das empfohlene Format für die Bereitstellung in der Produktion und gewährleistet eine bitgenaue Reproduzierbarkeit.

# 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

Mehrklassenklassifikation

Verwenden Sie für Probleme mit mehreren Klassen objective = 'multi:softprob' und setzen Sie num_class auf die Anzahl der Klassen. Die Labels müssen ganzzahlig und bei 0 beginnend indiziert sein. Die Ausgabe ist eine Matrix mit den Wahrscheinlichkeiten für jede Klasse.

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)

Kurztest

Welchen Zweck hat die Einstellung early_stopping_rounds = 20 in xgb.train()?

Zusammenfassung: XGBoost

Die wichtigsten Erkenntnisse aus „Gradient Boosting mit XGBoost“:

  • xgb.DMatrix(data, label) erstellt das optimierte Datenformat von XGBoost.
  • Wichtige Parameter: eta (Lernrate), max_depth, subsample, colsample_bytree.
  • watchlist überwacht den Trainings- und Validierungsverlust pro Runde.
  • early_stopping_rounds ermittelt automatisch die optimale Anzahl von Bäumen.
  • xgb.cv() führt eine k-fache CV innerhalb von XGBoost für eine schnelle Hyperparametersuche durch.
  • Verwenden Sie objective = 'binary:logistic' für binäre Klassifikation und 'multi:softprob' für Mehrklassenklassifikation.
  • Speichern und laden Sie Modelle mit 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)))

Häufig gestellte Fragen

Ist die Lektion „Gradient Boosting mit xgboost“ kostenlos?

Ja — der vollständige Text von „Gradient Boosting mit xgboost“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Gradient Boosting mit xgboost“?

Konfigurieren Sie xgboost-Parameter, Early Stopping und Lernratenpläne Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um R Academy zu starten?

Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Gradient Boosting mit xgboost“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?

Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Entscheidungsbäume: Grundlage von Ensembles
  2. Random Forests mit ranger
  3. Gradient Boosting mit xgboost
  4. Feature-Wichtigkeit und Modellinterpretation
← Zurück zu R Academy