Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF for Python
  2. IronPDF für Python Blog
  3. Python-Hilfe
  4. XGBoost Python
PYTHON-HILFE

XGBoost Python (Wie es funktioniert: Ein Leitfaden für Entwickler)

Curtis Chau
Curtis Chau
Aktualisiert:

XGBoost steht für eXtreme Gradient Boosting, einen leistungsstarken und genauen Machine-Learning-Algorithmus. Es wird hauptsächlich in der Regressionsanalyse, Klassifikation und Rangordnungsproblemen angewendet. Es umfasst Funktionen wie Regulierung, die helfen, Überanpassung zu vermeiden, Parallelverarbeitung und Verarbeitung fehlender Daten.

IronPDF ist eine Python-Bibliothek zum Erstellen, Bearbeiten und Lesen von PDF-Dateien. Es macht es einfach, HTML, Bilder oder Text in PDFs umzuwandeln, und kann auch Kopfzeilen, Fußzeilen und Wasserzeichen hinzufügen. Obwohl es sich hauptsächlich um die Nutzung in Python dreht, ist es bemerkenswert, dass das .NET-Tool mit Hilfe von Interoperabilitätswerkzeugen wie Python.NET in dieser Programmiersprache implementiert werden kann.

Die Kombination aus XGBoost und IronPDF bietet breitere Anwendungen. Durch IronPDF kann das Prognoseergebnis mit der Erstellung interaktiver PDF-Dokumente kombiniert werden. Diese Kombination ist besonders nützlich bei der Erstellung präziser Geschäftsdokumente und -zahlen sowie der Ergebnisse aus angewandten Vorhersagemodellen.

Was ist XGBoost Python?

XGBoost ist eine leistungsstarke Machine-Learning-Bibliothek für Python, die auf Ensemble-Lernen basiert und sehr effizient und flexibel ist. XGBoost ist eine Implementierung eines Gradient-Boosting-Algorithmus von Tianqi Chen, die zusätzliche Optimierungen enthält. Die Wirksamkeit wurde in vielen Anwendungsbereichen mit entsprechenden Aufgaben bewiesen, die durch diese Methode gelöst werden können, wie Klassifikation, Regression, Rangaufgaben usw. XGBoost hat mehrere einzigartige Merkmale: Das Fehlen fehlender Werte ist kein Problem für es; es besteht die Möglichkeit, L1- und L2-Normen anzuwenden, um gegen Überanpassung zu kämpfen;

Das Training wird parallel durchgeführt, was den Trainingsprozess erheblich beschleunigt. Baumschnitt wird auch bei XGBoost tiefenzuerst durchgeführt, was hilft, die Modellspeicherkapazität zu verwalten. Ein Merkmal ist die Kreuzvalidierung von Hyperparametern und eingebaute Funktionen zur Bewertung der Modellleistung. Die Bibliothek interagiert gut mit anderen Data-Science-Utilities, die in einer Python-Umgebung gebaut sind, wie NumPy, SciPy und scikit-learn, was die Integration in eine bewährte Umgebung ermöglicht. Dennoch, wegen seiner Geschwindigkeit, Einfachheit und hohen Leistung hat XGBoost das wesentliche Werkzeug im ‚Arsenal‘ vieler Datenanalysten, Machine-Learning-Spezialisten und aufstrebender Datenwissenschaftler für neuronale Netze geworden.

Merkmale von XGBoost Python

XGBoost ist bekannt für seine vielen Funktionen, die es vorteilhaft für verschiedene Machine-Learning-Aufgaben und Machine-Learning-Algorithmen machen, sowie es einfacher zu implementieren. Hier sind die wichtigsten Merkmale von XGBoost in Python:

Regulierung:

Verwendet L1- und L2-Regulierungstechniken, um Überanpassung zu reduzieren und die Leistung des Modells zu erhöhen.

Parallele Verarbeitung

Das Vortrainingsmodell verwendet alle CPU-Kerne während des Trainings, was die Modellschulung enorm verbessert.

Umgang mit fehlenden Daten

Ein Algorithmus, der beim Training des Modells automatisch die beste Methode zur Bearbeitung fehlender Werte entscheidet.

Baumschnitt

Beim Baumschnitt wird in den Bäumen ein tiefenzuerst-Prinzip mit dem Parameter „max_depth“ erreicht, das Überanpassung reduziert.

Eingebaute Kreuzvalidierung

Es beinhaltet Methoden der Kreuzvalidierung, die in das Modellbewertung und Hyperparameter-Optimierung eingearbeitet sind, da es nativ unterstützt und durchführt, ist die Implementierung weniger kompliziert.

Skalierbarkeit

Es ist optimiert für Skalierbarkeit; es kann somit große Datenmengen analysieren und Feature-Space-Daten angemessen handhaben.

Unterstützung für mehrere Sprachen

XGBoost wurde ursprünglich in Python entwickelt; jedoch unterstützt es auch R, Julia und Java, um seinen Umfang zu erweitern.

Verteiltes Rechnen

Das Paket ist so konzipiert, dass es verteilt ist, was bedeutet, dass es auf mehreren Computern ausgeführt werden kann, um große Datenmengen zu verarbeiten.

Benutzerdefinierte Ziel- und Bewertungsfunktionen

Es ermöglicht Benutzern, Ziel- und Leistungsbewertungsfunktionen für ihre spezifischen Anforderungen einzurichten. Außerdem unterstützt es sowohl binäre als auch multi-klassige Klassifikation.

Feature-Wichtigkeit

Es hilft, den Wert verschiedener Funktionen zu identifizieren, kann bei der Auswahl von Funktionen für einen bestimmten Datensatz helfen und bietet Interpretationen verschiedener Modelle.

Dünnbewusst

Es arbeitet gut mit dünn besetzten Datenformaten, was sehr nützlich ist, wenn man mit Daten arbeitet, die viele NULL-Werte oder Nullen enthalten.

Integration mit anderen Bibliotheken

Es ergänzt beliebte Data-Science-Bibliotheken wie NumPy, SciPy und scikit-learn, die leicht in Data-Science-Workflows integriert werden können.

Erstellen und Konfigurieren von XGBoost Python

In Python gibt es mehrere Prozesse, die bei der Erstellung und Konfiguration eines XGBoost-Modells beteiligt sind: der Prozess der Datenerfassung und Vorverarbeitung, Erstellung des Modells, Verwaltung des Modells und Bewertung des Modells. Nachfolgend finden Sie eine detaillierte Anleitung, die Ihnen den Einstieg erleichtert:

XGBoost installieren

Überprüfen Sie zunächst, ob das XGBoost-Paket auf Ihrem System vorhanden ist. Sie können es mit pip auf Ihrem Computer installieren:

pip install xgboost
pip install xgboost
SHELL

Bibliotheken importieren

import xgboost as xgb
import numpy as np
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import xgboost as xgb
import numpy as np
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
PYTHON

Daten vorbereiten

In diesem Beispiel verwenden wir den Boston Housing-Datensatz:

# Load the Boston housing dataset
boston = load_boston()
# Load data and target values
X = boston.data
y = boston.target
# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Load the Boston housing dataset
boston = load_boston()
# Load data and target values
X = boston.data
y = boston.target
# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
PYTHON

Erstellen Sie DMatrix

XGBoost verwendet eine selbsterstellte Datenstruktur namens DMatrix zum Training.

# Create DMatrix for training and testing sets
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)
# Create DMatrix for training and testing sets
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)
PYTHON

Parameter festlegen

Konfigurieren Sie die Modellparameter. Eine Musterkonfiguration ist wie folgt:

# Set parameters
params = {
    'objective': 'reg:squarederror',  # Objective function for regression
    'max_depth': 4,  # Maximum depth of a tree
    'eta': 0.1,  # Learning rate
    'subsample': 0.8,  # Subsample ratio of the training instances
    'colsample_bytree': 0.8,  # Subsample ratio of columns when constructing each tree
    'seed': 42  # Random seed for reproducibility
}
# Set parameters
params = {
    'objective': 'reg:squarederror',  # Objective function for regression
    'max_depth': 4,  # Maximum depth of a tree
    'eta': 0.1,  # Learning rate
    'subsample': 0.8,  # Subsample ratio of the training instances
    'colsample_bytree': 0.8,  # Subsample ratio of columns when constructing each tree
    'seed': 42  # Random seed for reproducibility
}
PYTHON

Modell trainieren

Verwenden Sie die train-Methode, um ein XGBoost-Modell zu trainieren.

# Number of boosting rounds
num_round = 100
# Train the model
bst = xgb.train(params, dtrain, num_round)
# Number of boosting rounds
num_round = 100
# Train the model
bst = xgb.train(params, dtrain, num_round)
PYTHON

Vorhersagen treffen

Verwenden Sie nun dieses trainierte Modell und treffen Sie Vorhersagen auf dem Testsatz.

# Make predictions
preds = bst.predict(dtest)
# Make predictions
preds = bst.predict(dtest)
PYTHON

Modell bewerten

Überprüfen Sie die Leistung des Machine-Learning-Modells mit einem geeigneten Metrikmaß — zum Beispiel das Root Mean Squared Error:

# Calculate mean squared error
mse = mean_squared_error(y_test, preds)
print(f"Mean Squared Error: {mse}")
# Calculate mean squared error
mse = mean_squared_error(y_test, preds)
print(f"Mean Squared Error: {mse}")
PYTHON

Modell speichern und laden

Sie können das trainierte Modell in einer Datei speichern und später bei Bedarf laden:

# Save the model
bst.save_model('xgboost_model.json')
# Load the model 
bst_loaded = xgb.Booster()
bst_loaded.load_model('xgboost_model.json')
# Save the model
bst.save_model('xgboost_model.json')
# Load the model 
bst_loaded = xgb.Booster()
bst_loaded.load_model('xgboost_model.json')
PYTHON

Einstieg

Nachfolgend ist die Basisinstallation beider Bibliotheken mit einem Beispiel, wie man mit XGBoost für die Datenanalyse und IronPDF zum Generieren von PDF-Berichten beginnt.

Was ist IronPDF?

Nutzen Sie das leistungsstarke Python-Paket IronPDF, um PDFs zu generieren, zu manipulieren und zu lesen. Dadurch können Programmierer viele programmierbasierte Operationen an PDFs durchführen, wie das Arbeiten mit bereits vorhandenen PDFs und das Konvertieren von HTML in PDF-Dateien. IronPDF ist eine effiziente Lösung für Anwendungen, die eine dynamische Generierung und Verarbeitung von PDFs erfordern, da es eine anpassungsfähige und benutzerfreundliche Methode zur Erstellung von hochwertigen PDF-Dokumenten bietet.

HTML zu PDF Konvertierung

IronPDF kann PDF-Dokumente aus jedem HTML-Inhalt erstellen, neu oder bestehend. Es ermöglicht die Erstellung wunderschöner, künstlerischer PDF-Publikationen aus Webinhalten, die die Leistung moderner HTML5-, CSS3- und JavaScript-Inhalte in all ihren Formen erfassen.

PDFs erstellen/bearbeiten

Es kann Text, Bilder, Tabellen und andere Inhalte in neu programmgenerierten PDF-Dokumenten hinzufügen. Mit IronPDF können bestehende PDF-Dokumente geöffnet und zum weiteren Bearbeiten bearbeitet werden. In einem PDF können Sie Inhalte bearbeiten/hinzufügen und bei Bedarf bestimmte Inhalte im Dokument löschen.

Komplexes Layout und Styling

Es verwendet CSS, um den Inhalt in PDFs zu stilisieren. Es unterstützt komplexe Layouts, Schriften, Farben und all diese Designkomponenten. Außerdem ermöglichen die Methoden zum Rendern von HTML-Materialien, die mit JavaScript verwendet werden können, dynamische Inhaltserstellung in PDFs.

Installieren Sie IronPDF

IronPDF kann über pip installiert werden. Verwenden Sie den folgenden Befehl, um es zu installieren:

pip install ironpdf

Verknüpfen Sie XGBoost Python mit IronPDF

Importieren Sie alle relevanten Bibliotheken und laden Sie Ihren Datensatz. In unserem Fall verwenden wir den Boston Housing-Datensatz:

import xgboost as xgb
import numpy as np
from ironpdf import *     
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# Load data
boston = load_boston()
X = boston.data
y = boston.target

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Create DMatrix
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)

# Set parameters
params = {
    'objective': 'reg:squarederror',
    'max_depth': 4,
    'eta': 0.1,
    'subsample': 0.8,
    'colsample_bytree': 0.8,
    'seed': 42
}

# Train model
num_round = 100
bst = xgb.train(params, dtrain, num_round)

# Make predictions
preds = bst.predict(dtest)
mse = mean_squared_error(y_test, preds)

# Create a PDF document using IronPDF
iron_pdf = ChromePdfRenderer()

# Create HTML content
html_content = f"""
<html>
<head>
    <title>XGBoost Model Report</title>
</head>
<body>
    <h1>XGBoost Model Report</h1>
    <p>Mean Squared Error: {mse}</p>
    <h2>Predictions</h2>
    <ul>
        {''.join([f'<li>{pred}</li>' for pred in preds])}
    </ul>
</body>
</html>
"""

pdf = iron_pdf.RenderHtmlAsPdf(html_content)

# Save the PDF document
pdf.SaveAs("XGBoost_Report.pdf")
print("PDF document generated successfully.")
import xgboost as xgb
import numpy as np
from ironpdf import *     
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# Load data
boston = load_boston()
X = boston.data
y = boston.target

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Create DMatrix
dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)

# Set parameters
params = {
    'objective': 'reg:squarederror',
    'max_depth': 4,
    'eta': 0.1,
    'subsample': 0.8,
    'colsample_bytree': 0.8,
    'seed': 42
}

# Train model
num_round = 100
bst = xgb.train(params, dtrain, num_round)

# Make predictions
preds = bst.predict(dtest)
mse = mean_squared_error(y_test, preds)

# Create a PDF document using IronPDF
iron_pdf = ChromePdfRenderer()

# Create HTML content
html_content = f"""
<html>
<head>
    <title>XGBoost Model Report</title>
</head>
<body>
    <h1>XGBoost Model Report</h1>
    <p>Mean Squared Error: {mse}</p>
    <h2>Predictions</h2>
    <ul>
        {''.join([f'<li>{pred}</li>' for pred in preds])}
    </ul>
</body>
</html>
"""

pdf = iron_pdf.RenderHtmlAsPdf(html_content)

# Save the PDF document
pdf.SaveAs("XGBoost_Report.pdf")
print("PDF document generated successfully.")
PYTHON

Nun werden Sie Objekte der Klasse DMatrix erstellen, um Ihre Daten effizient zu bearbeiten, dann die Modellparameter hinsichtlich der Zielfunktion und der Hyperparameter einstellen. Nach dem Trainieren des XGBoost-Modells Vorhersagen auf dem Testsatz treffen; Sie können Mean Squared Error oder ähnliche Metriken verwenden, um die Leistung zu bewerten. Verwenden Sie dann IronPDF, um ein PDF mit allen Ergebnissen zu erstellen.

Sie erstellen eine HTML-Darstellung mit allen Ihren Ergebnissen; dann verwenden Sie IronPDF's ChromePdfRenderer-Klasse, um diesen HTML-Inhalt in ein PDF-Dokument umzuwandeln. Schließlich können Sie diesen generierten PDF-Bericht an einem gewünschten Ort speichern. Diese Integration ermöglicht es Ihnen, die Erstellung sehr detaillierter, professioneller Berichte zu automatisieren, in denen die aus Machine-Learning-Modellen gewonnenen Erkenntnisse zusammengefasst werden.

Abschluss

Zusammenfassend sind XGBoost und IronPDF für fortschrittliche Datenanalyse und professionelle Berichtserstellung integriert. Die Effizienz und Skalierbarkeit von XGBoost bieten die beste Lösung für das Streaming durch komplizierte Machine-Learning-Aufgaben mit robusten Vorhersagefähigkeiten und exzellenten Werkzeugen zur Modelloptimierung. Sie können diese nahtlos in Python mit IronPDF verknüpfen und die gewonnenen Erkenntnisse aus XGBoost in hochdetaillierte PDF-Berichte umwandeln.

Diese Integration wird somit die Produktion attraktiver und informationsreicher Dokumente im Hinblick auf die Ergebnisse erheblich ermöglichen, was sie den Stakeholdern kommunizierbar oder für weitere Analysen geeignet macht. Geschäftsanalysen, akademische Forschung oder jedes datengetriebene Projekt würden erheblich von einer integrierten Synergie zwischen XGBoost und IronPDF profitieren, um Daten effizient zu verarbeiten und die Ergebnisse einfach zu kommunizieren.

Integrate IronPDF and other Iron Software products to ensure your clients and end users get feature-rich, premium software solutions. Dies wird auch dazu beitragen, Ihre Projekte und Prozesse zu optimieren.

Umfassende Dokumentation, aktive Community und häufige Updates – all dies geht Hand in Hand mit der Funktionalität von IronPDF. Iron Software ist der Name eines vertrauenswürdigen Partners für moderne Softwareentwicklungsprojekte. IronPDF ist für eine kostenlose Testphase für alle Entwickler verfügbar. Sie können all seine Funktionen ausprobieren. Lizenzraten von $799 sind verfügbar, um den maximalen Wert aus diesem Produkt zu ziehen.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Testversion