Icône de message
Passer au contenu du pied de page
  1. IronPDF pour Python
  2. Blog IronPDF pour Python
  3. Aide Python
  4. XGBoost Python
AIDE PYTHON

XGBoost Python (Comment ça marche : Un guide pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

XGBoost signifie eXtreme Gradient Boosting, un algorithme d'apprentissage automatique puissant et précis. Il a été principalement appliqué dans les problèmes d'analyse de régression, de classification et de classement. Il implique des fonctionnalités comme la régulation qui aident à éviter le surajustement, le parallélisme, et le traitement des données manquantes.

IronPDF est une bibliothèque Python pour créer, modifier et lire des fichiers PDF. Cela facilite la conversion de HTML, d'images ou de texte en PDF, et il peut également ajouter des en-têtes, des pieds de page et des filigranes. Bien que principalement concerné par son utilisation en Python, il est à noter que l'outil .NET peut être implémenté dans ce langage de programmation avec l'aide d'outils d'interopérabilité tels que Python.NET.

La combinaison de XGBoost et IronPDF offre des applications plus larges. Grâce à IronPDF, le résultat prévisionnel peut être combiné avec la création de documents PDF interactifs. Cette combinaison est particulièrement utile pour générer des documents d'entreprise et des chiffres précis et les résultats obtenus à partir des modèles prédictifs appliqués.

Qu'est-ce que XGBoost Python ?

XGBoost est une puissante bibliothèque d'apprentissage automatique pour Python basée sur l'apprentissage en ensemble, qui est très efficace et flexible. XGBoost est une implémentation d'un algorithme de boosting de gradient par Tianqi Chen qui inclut des optimisations supplémentaires. L'efficacité a été prouvée dans de nombreux domaines d'application avec des tâches correspondantes pouvant être résolues par cette méthode, telles que la classification, la régression, les tâches de classement, etc. XGBoost a plusieurs caractéristiques uniques : l'absence de valeurs manquantes n'est pas un problème pour lui ; il y a une opportunité d'utiliser les normes L1 et L2 pour lutter contre le surajustement ;

La formation est effectuée en parallèle, ce qui accélère considérablement le processus de formation. L'élagage des arbres est également effectué en profondeur d'abord dans XGBoost, ce qui aide à gérer la capacité du modèle. L'une de ses caractéristiques est la validation croisée des hyperparamètres et les fonctions intégrées pour évaluer les performances du modèle. La bibliothèque interagit bien avec d'autres utilitaires de science des données construits dans un environnement Python, tels que NumPy, SciPy et scikit-learn, ce qui permet de l'incorporer dans un environnement confirmé. Cependant, en raison de sa rapidité, de sa simplicité et de ses performances élevées, XGBoost est devenu l'outil essentiel dans l'« arsenal » de nombreux analystes de données, spécialistes de l'apprentissage automatique et scientifiques des données en réseaux neuronaux débutants.

Caractéristiques de XGBoost Python

XGBoost est célèbre pour ses nombreuses fonctionnalités qui le rendent avantageux dans diverses tâches d'apprentissage automatique et algorithmes d'apprentissage automatique, ainsi qu'en le rendant plus accessible à mettre en œuvre. Voici les principales caractéristiques de XGBoost en Python :

Régularisation :

Applique des techniques de régularisation L1 et L2 pour réduire le surajustement et augmenter les performances du modèle.

Traitement parallèle

Le modèle préentraîné utilise tous les cœurs de l'unité centrale lors de la formation, améliorant ainsi la formation des modèles de manière significative.

Traitement des données manquantes

Un algorithme qui, lorsque le modèle est entraîné, décide automatiquement de la meilleure manière de gérer les valeurs manquantes.

Élagage des arbres

Dans l'élagage des arbres, la recherche en profondeur sur les arbres est réalisée en utilisant le paramètre « max_depth », qui réduit le surajustement.

Validation croisée intégrée

Il inclut des méthodes de validation croisée intégrées pour l'évaluation du modèle et l'optimisation des hyperparamètres, car il prend en charge et réalise la validation croisée de manière native, la mise en œuvre est moins compliquée.

Scalabilité

Il est optimisé pour l'évolutivité ; par conséquent, il peut analyser de grandes quantités de données et gérer l'espace des fonctionnalités de manière appropriée.

Support pour plusieurs langages

XGBoost a été initialement développé en Python ; cependant, pour améliorer sa portée, il prend également en charge R, Julia et Java.

Calcul distribué

Le package est conçu pour être distribué, ce qui signifie qu'il peut être exécuté sur plusieurs ordinateurs pour traiter de grandes quantités de données.

Fonctions d'objectif et d'évaluation personnalisées

Il permet aux utilisateurs de configurer des fonctions d'objectif et des mesures de performance pour leurs besoins spécifiques. En outre, il prend en charge la classification binaire et multi-classes.

Importance des fonctionnalités

Il aide à identifier la valeur de diverses caractéristiques, peut aider à sélectionner des fonctionnalités pour un ensemble de données donné, et fournit des interprétations de plusieurs modèles.

Sparse Aware

Il fonctionne bien avec les formats de données rares, ce qui est très utile lorsque l'on travaille avec des données contenant de nombreuses valeurs NULL ou des zéros.

Intégration avec d'autres bibliothèques

Il complète les bibliothèques de science des données populaires telles que NumPy, SciPy et scikit-learn, qui s'intègrent facilement dans les flux de travail de science des données.

Créer et configurer XGBoost Python

En Python, il y a plusieurs processus impliqués dans la création et la configuration d'un modèle XGBoost : le processus de collecte et de prétraitement des données, la création du modèle, la gestion du modèle et l'évaluation du modèle. Ci-dessous se trouve un guide détaillé pour vous aider à démarrer :

Installer XGBoost

Tout d'abord, vérifiez si le package XGBoost est présent sur votre système. Vous pouvez l'installer sur votre ordinateur avec pip :

pip install xgboost
pip install xgboost
SHELL

Importer les bibliothèques

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

Préparer les données

Dans cet exemple, nous allons utiliser l'ensemble de données Boston housing :

# 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

Créer une DMatrix

XGBoost utilise une structure de données auto-définie appelée DMatrix pour la formation.

# 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

Définir les paramètres

Configurer les paramètres du modèle. Une configuration d'exemple est la suivante :

# 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

Entraîner le modèle

Utilisez la méthode d'entraînement pour entraîner un modèle XGBoost.

# 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

Faire des prédictions

Maintenant, utilisez ce modèle entraîné et faites des prédictions sur l'ensemble de test.

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

Évaluer le modèle

Vérifiez les performances du modèle d'apprentissage automatique à l'aide d'une mesure de métrique appropriée, par exemple l'erreur quadratique moyenne :

# 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

Enregistrer et charger le modèle

Vous pouvez enregistrer le modèle entraîné dans un fichier et le charger plus tard si nécessaire :

# 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

Démarrage

Ci-dessous se trouve l'installation de base des deux bibliothèques, avec un exemple de la façon de commencer à utiliser XGBoost pour l'analyse de données et IronPDF pour générer des rapports PDF.

Qu'est-ce qu'IronPDF ?

Utilisez le puissant package Python IronPDF pour générer, manipuler et lire des PDF. Cela permet aux programmeurs d'effectuer de nombreuses opérations basées sur la programmation sur les PDF, telles que travailler avec des PDF préexistants et convertir du HTML en fichiers PDF. IronPDF est une solution efficace pour les applications nécessitant la génération et le traitement dynamique de PDF, car elle fournit un moyen adaptable et convivial de générer des documents PDF de haute qualité.

Conversion HTML en PDF

IronPDF peut créer des documents PDF à partir de tout contenu HTML, nouveau ou existant. Il permet la création de belles publications artistiques PDF à partir de contenu Web qui capturent la puissance du HTML5 moderne, CSS3 et JavaScript sous toutes leurs formes.

Créer/éditer des PDF

Il peut ajouter du texte, des images, des tables et d'autres contenus dans de nouveaux documents PDF générés de manière programmatique. En utilisant IronPDF, les documents PDF existants peuvent être ouverts et édités pour apporter des modifications supplémentaires. Dans un PDF, vous pouvez éditer/ajouter du contenu et supprimer du contenu spécifique dans le document selon les besoins.

Mise en page complexe et style

Il utilise le CSS pour styliser le contenu dans les PDF. Il prend en charge les mises en page complexes, les polices, les couleurs et tous ces composants de design. De plus, les façons de rendre le matériel HTML qui peuvent être utilisées avec JavaScript permettent la création dynamique de contenu dans les PDF.

Installer IronPDF

IronPDF peut être installé via pip. Utilisez la commande suivante pour l'installer :

pip install ironpdf

Combiner XGBoost Python avec IronPDF

Importez toutes les bibliothèques pertinentes et chargez votre ensemble de données. Dans notre cas, nous utiliserons l'ensemble de données Boston housing :

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

Maintenant, vous allez créer des objets de classe DMatrix pour gérer efficacement vos données, puis configurer les paramètres du modèle concernant la fonction d'objectif et les hyperparamètres. Après avoir entraîné le modèle XGBoost, prédisez sur l'ensemble de test ; vous pouvez utiliser l'erreur quadratique moyenne ou des métriques similaires pour évaluer les performances. Ensuite, utilisez IronPDF pour créer un PDF avec tous les résultats.

Vous créez une représentation HTML avec tous vos résultats ; puis, vous utiliserez la classe ChromePdfRenderer d'IronPDF pour transformer ce contenu HTML en un document PDF. Enfin, vous pouvez enregistrer ce rapport PDF généré à un emplacement souhaité. Cette intégration vous permettra d'automatiser la création de rapports très élaborés et professionnels dans lesquels on encapsule les insights dérivés des modèles d'apprentissage automatique.

Conclusion

En résumé, XGBoost et IronPDF sont intégrés pour une analyse avancée des données et une génération de rapports professionnels. L'efficacité et l'évolutivité de XGBoost offrent la meilleure solution pour traiter des tâches d'apprentissage automatique compliquées avec des capacités prédictives robustes et d'excellents outils pour l'optimisation des modèles. Vous pouvez lier sans heurts ces outils en Python avec IronPDF, transformant les riches insights obtenus de XGBoost en rapports PDF très détaillés.

Ces intégrations permettront donc grandement la production de documents attrayants et riches en informations concernant les résultats, les rendant communicables aux parties prenantes ou adaptés pour une analyse ultérieure. L'analyse des affaires, la recherche académique ou tout projet basé sur les données bénéficierait grandement d'une synergie intégrée entre XGBoost et IronPDF pour traiter efficacement les données et communiquer les résultats avec facilité.

Integrate IronPDF and other Iron Software products to ensure your clients and end users get feature-rich, premium software solutions. Cela aidera également à optimiser vos projets et processus.

Documentation complète, communauté active et mises à jour fréquentes, tout va de pair avec la fonctionnalité IronPDF. Iron Software est le nom d'un partenaire fiable pour les projets de développement logiciel modernes. IronPDF est disponible pour un essai gratuit pour tous les développeurs. Ils peuvent essayer toutes ses fonctionnalités. Les tarifs de licence de $799 sont disponibles pour tirer le meilleur parti de ce produit.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit