Bild vom Herausgeber
# Einführung
Ensemble-Methoden wie XGBoost (Excessive Gradient Boosting) sind leistungsstarke Implementierungen von Entscheidungsbäumen mit Gradientenverstärkung, die mehrere schwächere Schätzer zu einem starken Vorhersagemodell zusammenfassen. Diese Ensembles erfreuen sich aufgrund ihrer Genauigkeit, Effizienz und starken Leistung bei strukturierten (tabellenförmigen) Daten großer Beliebtheit. Während die weit verbreitete Bibliothek für maschinelles Lernen scikit-lernen keine native Implementierung von XGBoost bereitstellt, gibt es eine separate Bibliothek, passenderweise XGBoost genannt, die eine mit scikit-learn kompatible API bietet.
Sie müssen es lediglich wie folgt importieren:
from xgboost import XGBClassifier
Im Folgenden skizzieren wir 7 Python-Tips, die Ihnen dabei helfen können, diese eigenständige Implementierung von XGBoost optimum zu nutzen, insbesondere wenn Sie genauere Vorhersagemodelle erstellen möchten.
Um diese Tips zu veranschaulichen, verwenden wir den in scikit-learn frei verfügbaren Brustkrebs-Datensatz und definieren ein Basismodell mit weitgehend Standardeinstellungen. Stellen Sie sicher, dass Sie diesen Code zuerst ausführen, bevor Sie mit den folgenden sieben Tips experimentieren:
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.metrics import accuracy_score
from xgboost import XGBClassifier
# Knowledge
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
)
# Baseline mannequin
mannequin = XGBClassifier(eval_metric="logloss", random_state=42)
mannequin.match(X_train, y_train)
print("Baseline accuracy:", accuracy_score(y_test, mannequin.predict(X_test)))
# 1. Lernrate und Anzahl der Schätzer optimieren
Auch wenn dies keine universelle Regel ist, führt eine explizite Reduzierung der Lernrate bei gleichzeitiger Erhöhung der Anzahl der Schätzer (Bäume) in einem XGBoost-Ensemble häufig zu einer Verbesserung der Genauigkeit. Durch die geringere Lernrate kann das Modell schrittweise lernen, während zusätzliche Bäume die verringerte Schrittgröße ausgleichen.
Hier ist ein Beispiel. Probieren Sie es selbst aus und vergleichen Sie die resultierende Genauigkeit mit der ursprünglichen Basislinie:
mannequin = XGBClassifier(
learning_rate=0.01,
n_estimators=5000,
eval_metric="logloss",
random_state=42
)
mannequin.match(X_train, y_train)
print("Mannequin accuracy:", accuracy_score(y_test, mannequin.predict(X_test)))Der Klarheit halber das Finale print() Die Anweisung wird in den übrigen Beispielen weggelassen. Hängen Sie es einfach an eines der folgenden Snippets an, wenn Sie es selbst testen.
# 2. Anpassen der maximalen Baumtiefe
Der max_depth Argument ist ein entscheidender Hyperparameter, der von klassischen Entscheidungsbäumen übernommen wurde. Es begrenzt, wie tief jeder Baum im Ensemble wachsen kann. Die Beschränkung der Baumtiefe magazine simpel erscheinen, aber überraschenderweise lassen sich flache Bäume oft besser verallgemeinern als tiefere.
In diesem Beispiel werden die Bäume auf eine maximale Tiefe von 2 beschränkt:
mannequin = XGBClassifier(
max_depth=2,
eval_metric="logloss",
random_state=42
)
mannequin.match(X_train, y_train)# 3. Reduzierung der Überanpassung durch Unterabtastung
Der subsample Das Argument tastet zufällig einen Teil der Trainingsdaten (z. B. 80 %) ab, bevor jeder Baum im Ensemble wächst. Diese einfache Technik fungiert als wirksame Regularisierungsstrategie und hilft, eine Überanpassung zu verhindern.
Wenn nicht angegeben, ist dieser Hyperparameter standardmäßig auf 1,0 eingestellt, was bedeutet, dass 100 % der Trainingsbeispiele verwendet werden:
mannequin = XGBClassifier(
subsample=0.8,
colsample_bytree=0.8,
eval_metric="logloss",
random_state=42
)
mannequin.match(X_train, y_train)Bedenken Sie, dass dieser Ansatz für Datensätze angemessener Größe am effektivsten ist. Wenn der Datensatz bereits klein ist, kann eine aggressive Unterabtastung zu einer Unteranpassung führen.
# 4. Regularisierungsbedingungen hinzufügen
Um die Überanpassung weiter zu kontrollieren, können komplexe Bäume mithilfe traditioneller Regularisierungsstrategien wie L1 (Lasso) und L2 (Ridge) bestraft werden. In XGBoost werden diese durch gesteuert reg_alpha Und reg_lambda Parameter bzw.
mannequin = XGBClassifier(
reg_alpha=0.2, # L1
reg_lambda=0.5, # L2
eval_metric="logloss",
random_state=42
)
mannequin.match(X_train, y_train)# 5. Frühzeitiges Stoppen nutzen
Das frühe Stoppen ist ein effizienzorientierter Mechanismus, der das Coaching stoppt, wenn sich die Leistung eines Validierungssatzes über eine bestimmte Anzahl von Runden nicht mehr verbessert.
Abhängig von Ihrer Codierungsumgebung und der von Ihnen verwendeten Model der XGBoost-Bibliothek müssen Sie möglicherweise ein Improve auf eine neuere Model durchführen, um die unten gezeigte Implementierung verwenden zu können. Stellen Sie außerdem sicher, dass early_stopping_rounds wird während der Modellinitialisierung angegeben und nicht an übergeben match() Verfahren.
mannequin = XGBClassifier(
n_estimators=1000,
learning_rate=0.05,
eval_metric="logloss",
early_stopping_rounds=20,
random_state=42
)
mannequin.match(
X_train, y_train,
eval_set=((X_test, y_test)),
verbose=False
)Um die Bibliothek zu aktualisieren, führen Sie Folgendes aus:
!pip uninstall -y xgboost
!pip set up xgboost --upgrade# 6. Durchführen einer Hyperparametersuche
Für einen systematischeren Ansatz kann die Hyperparametersuche dabei helfen, Kombinationen von Einstellungen zu identifizieren, die die Modellleistung maximieren. Unten sehen Sie ein Beispiel für die Verwendung einer Rastersuche, um Kombinationen von drei zuvor eingeführten Schlüsselhyperparametern zu untersuchen:
param_grid = {
"max_depth": (3, 4, 5),
"learning_rate": (0.01, 0.05, 0.1),
"n_estimators": (200, 500)
}
grid = GridSearchCV(
XGBClassifier(eval_metric="logloss", random_state=42),
param_grid,
cv=3,
scoring="accuracy"
)
grid.match(X_train, y_train)
print("Finest params:", grid.best_params_)
best_model = XGBClassifier(
**grid.best_params_,
eval_metric="logloss",
random_state=42
)
best_model.match(X_train, y_train)
print("Tuned accuracy:", accuracy_score(y_test, best_model.predict(X_test)))# 7. Anpassung an das Klassenungleichgewicht
Dieser letzte Trick ist besonders nützlich, wenn Sie mit stark klassenunausgeglichenen Datensätzen arbeiten (der Brustkrebs-Datensatz ist relativ ausgeglichen, Sie müssen sich additionally keine Sorgen machen, wenn Sie minimale Änderungen beobachten). Der scale_pos_weight Der Parameter ist besonders hilfreich, wenn die Klassenverhältnisse stark verzerrt sind, z. B. 90/10, 95/5 oder 99/1.
Hier erfahren Sie, wie Sie es basierend auf den Trainingsdaten berechnen und anwenden:
ratio = np.sum(y_train == 0) / np.sum(y_train == 1)
mannequin = XGBClassifier(
scale_pos_weight=ratio,
eval_metric="logloss",
random_state=42
)
mannequin.match(X_train, y_train)# Zusammenfassung
In diesem Artikel haben wir sieben praktische Tips zur Verbesserung von XGBoost-Ensemblemodellen mithilfe der speziellen Python-Bibliothek untersucht. Eine durchdachte Abstimmung von Lernraten, Baumtiefe, Stichprobenstrategien, Regularisierung und Klassengewichtung – kombiniert mit einer systematischen Hyperparametersuche – macht oft den Unterschied zwischen einem anständigen und einem hochpräzisen Modell.
Iván Palomares Carrascosa ist ein führender Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.