Utilisez l'algorithme XGBoost avec Amazon SageMaker - Amazon SageMaker
Versions prises en chargeComment utiliser XGBoostInterface d'entrée/sortie pour l'algorithme XGBoostRecommandation d'instance EC2 pour l'algorithme XGBoostExemples de blocs-notes

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Utilisez l'algorithme XGBoost avec Amazon SageMaker

XGBoost (eXtreme Gradient Boosting) est une implémentation open source réputée et efficace de l'algorithme d'arbres de boosting de gradient. L'amplification du gradient est un algorithme d'apprentissage supervisé qui tente de prédire avec précision une variable cible en combinant plusieurs estimations issues d'un ensemble de modèles plus simples. L'algorithme XGBoost fonctionne bien dans les compétitions d'apprentissage automatique pour les raisons suivantes :

  • Sa gestion robuste d'une variété de types de données, de relations et de distributions.

  • La variété d'hyperparamètres que vous pouvez ajuster avec précision.

Vous pouvez utiliser XGBoost pour les problèmes de régression, de classification (binaire et multiclasse) et de classement.

Vous pouvez utiliser la nouvelle version de l'algorithme XGBoost comme suit :

  • Un algorithme SageMaker intégré à Amazon.

  • Un framework pour exécuter des scripts de formation dans vos environnements locaux.

Cette implémentation présente une empreinte mémoire réduite, une meilleure journalisation, une meilleure validation des hyperparamètres et un ensemble de métriques plus important que les versions d'origine. Il fournit un XGBoost estimator qui exécute un script d'entraînement dans un environnement XGBoost géré. La version actuelle de SageMaker XGBoost est basée sur les versions originales 1.0, 1.2, 1.3, 1.5 et 1.7 de XGBoost.

Versions prises en charge

  • Mode de framework (open source) : 1.0-1, 1.2-1, 1.2-2, 1.3-1, 1.5-1, 1.7-1

  • Mode d'algorithme : 1.0-1, 1.2-1, 1.2-2, 1.3-1, 1.5-1, 1.7-1

Avertissement

En raison de la capacité de calcul requise, la version 1.7-1 de SageMaker XGBoost n'est pas compatible avec les instances GPU de la famille d'instances P2 à des fins d'entraînement ou d'inférence.

Important

Lorsque vous récupérez l'URI de l'image SageMaker XGBoost, n'utilisez pas :latest ou :1 pour la balise URI de l'image. Vous devez spécifier l'un des Versions prises en charge pour choisir le conteneur XGBoost SageMaker géré avec la version native du package XGBoost que vous souhaitez utiliser. Pour trouver la version du package migrée dans les conteneurs SageMaker XGBoost, voir Chemins de registre Docker et exemple de code. Choisissez ensuite votre Région AWS et accédez à la section XGBoost (algorithme).

Avertissement

Les versions XGBoost 0.90 sont obsolètes. La prise en charge des mises à jour de sécurité et des corrections de bogues pour XGBoost 0.90 a été interrompue. Nous vous recommandons vivement de mettre à niveau la version XGBoost vers l'une des versions les plus récentes.

Note

XGBoost v1.1 n'est pas pris en charge sur. SageMaker XGBoost 1.1 n'a pas la capacité d'exécuter des prédictions lorsque l'entrée de test comporte moins de fonctionnalités que les données d'entraînement contenues dans les entrées LIBSVM. Cette capacité a été restaurée dans XGBoost 1.2. Envisagez d'utiliser SageMaker XGBoost 1.2-2 ou version ultérieure.

Comment utiliser SageMaker XGBoost

Avec SageMaker, vous pouvez utiliser XGBoost comme algorithme ou framework intégré. Avec XGBoost en tant que framework, vous bénéficiez d'une plus grande flexibilité et d'un accès à des scénarios plus avancés, car vous pouvez personnaliser vos propres scripts d'entraînement. Les sections suivantes décrivent comment utiliser XGBoost avec le SDK SageMaker Python. Pour plus d'informations sur l'utilisation de XGBoost depuis l'interface utilisateur Amazon SageMaker Studio Classic, consultez. Formez, déployez et évaluez des modèles préentraînés avec SageMaker JumpStart

  • Utilisation de XGBoost en tant qu'infrastructure

    Utilisez XGBoost en tant que framework pour exécuter des scripts d'entraînement qui peuvent intégrer un traitement de données supplémentaire dans vos tâches d'entraînement. Dans l'exemple de code suivant, le SDK SageMaker Python fournit l'API XGBoost en tant que framework. Cela fonctionne de la même manière SageMaker que les autres API de framework TensorFlow, telles que MXnet et. PyTorch

    import boto3
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.session import Session
from sagemaker.inputs import TrainingInput

# initialize hyperparameters
hyperparameters = {
        "max_depth":"5",
        "eta":"0.2",
        "gamma":"4",
        "min_child_weight":"6",
        "subsample":"0.7",
        "verbosity":"1",
        "objective":"reg:squarederror",
        "num_round":"50"}

# set an output path where the trained model will be saved
bucket = sagemaker.Session().default_bucket()
prefix = 'DEMO-xgboost-as-a-framework'
output_path = 's3://{}/{}/{}/output'.format(bucket, prefix, 'abalone-xgb-framework')

# construct a SageMaker XGBoost estimator
# specify the entry_point to your xgboost training script
estimator = XGBoost(entry_point = "your_xgboost_abalone_script.py", 
                    framework_version='1.7-1',
                    hyperparameters=hyperparameters,
                    role=sagemaker.get_execution_role(),
                    instance_count=1,
                    instance_type='ml.m5.2xlarge',
                    output_path=output_path)

# define the data type and paths to the training and validation datasets
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)

# execute the XGBoost training job
estimator.fit({'train': train_input, 'validation': validation_input})

    Pour un end-to-end exemple d'utilisation de SageMaker XGBoost comme framework, consultez Régression avec Amazon XGBoost SageMaker

  • Utilisation de XGBoost en tant qu'algorithme intégré

    Utilisez l'algorithme intégré XGBoost pour créer un conteneur d'entraînement XGBoost comme indiqué dans l'exemple de code suivant. Vous pouvez détecter automatiquement l'URI de l'image de l'algorithme intégré à XGBoost à l'aide de l' SageMaker image_uris.retrieveAPI. Si vous utilisez le SDK Amazon SageMaker Python version 1, utilisez l'get_image_uriAPI. Pour vous assurer que l'image_uris.retrieveAPI trouve l'URI correct, consultez la section Paramètres communs pour les algorithmes intégrés. Recherchez ensuite dans la xgboost liste complète des URI d'images d'algorithmes intégrés et des régions disponibles.

    Après avoir spécifié l'URI de l'image XGBoost, utilisez le conteneur XGBoost pour créer un estimateur à l'aide de l'API Estimator et lancer une tâche de SageMaker formation. Ce mode d'algorithme intégré XGBoost n'intègre pas votre propre script d'entraînement XGBoost et s'exécute directement sur les jeux de données en entrée.

    Important

    Lorsque vous récupérez l'URI de l'image SageMaker XGBoost, n'utilisez pas :latest ou :1 pour la balise URI de l'image. Vous devez spécifier l'un des Versions prises en charge pour choisir le conteneur XGBoost SageMaker géré avec la version native du package XGBoost que vous souhaitez utiliser. Pour trouver la version du package migrée dans les conteneurs SageMaker XGBoost, voir Chemins de registre Docker et exemple de code. Choisissez ensuite votre Région AWS et accédez à la section XGBoost (algorithme).

    import sagemaker
import boto3
from sagemaker import image_uris
from sagemaker.session import Session
from sagemaker.inputs import TrainingInput

# initialize hyperparameters
hyperparameters = {
        "max_depth":"5",
        "eta":"0.2",
        "gamma":"4",
        "min_child_weight":"6",
        "subsample":"0.7",
        "objective":"reg:squarederror",
        "num_round":"50"}

# set an output path where the trained model will be saved
bucket = sagemaker.Session().default_bucket()
prefix = 'DEMO-xgboost-as-a-built-in-algo'
output_path = 's3://{}/{}/{}/output'.format(bucket, prefix, 'abalone-xgb-built-in-algo')

# this line automatically looks for the XGBoost image URI and builds an XGBoost container.
# specify the repo_version depending on your preference.
xgboost_container = sagemaker.image_uris.retrieve("xgboost", region, "1.7-1")

# construct a SageMaker estimator that calls the xgboost-container
estimator = sagemaker.estimator.Estimator(image_uri=xgboost_container, 
                                          hyperparameters=hyperparameters,
                                          role=sagemaker.get_execution_role(),
                                          instance_count=1, 
                                          instance_type='ml.m5.2xlarge', 
                                          volume_size=5, # 5 GB 
                                          output_path=output_path)

# define the data type and paths to the training and validation datasets
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)

# execute the XGBoost training job
estimator.fit({'train': train_input, 'validation': validation_input})

    Pour plus d'informations sur la configuration de XGBoost en tant qu'algorithme intégré, consultez les exemples de bloc-notes suivants.

Interface d'entrée/sortie pour l'algorithme XGBoost

Le boosting de gradient fonctionne sur les données tabulaires, avec les lignes représentant les observations, une colonne représentant la variable ou l'étiquette cible, et les autres colonnes représentant les fonctions.

La SageMaker mise en œuvre de XGBoost prend en charge les formats de données suivants pour l'entraînement et l'inférence :

  • text/libsvm (par défaut)

  • text/csv

  • application/x-parquet

  • demande/ x-recordio-protobuf

Note

Il y a quelques points à prendre en compte concernant l'entrée d'entraînement et d'inférence :

  • Pour des performances accrues, nous vous recommandons d'utiliser le mode XGBoost avec fichier, dans lequel vos données d'Amazon S3 sont stockées sur les volumes de l'instance d'entraînement.

  • Pour l'entraînement avec une entrée sous forme de colonnes, l'algorithme suppose que la variable cible (étiquette) correspond à la première colonne. Pour l'inférence, l'algorithme suppose que l'entrée n'a pas de colonne d'étiquettes.

  • Pour des données CSV, l'entrée ne doit pas comporter d'enregistrement d'en-tête.

  • Pour l'entraînement LIBSVM, l'algorithme suppose que les colonnes suivantes, après la colonne d'étiquettes, contiennent les paires de valeurs d'index basé sur zéro pour les fonctionnalités. Par conséquent, chaque ligne a le format suivant : <label> <index0>:<value0> <index1>:<value1>.

  • Pour en savoir plus sur les types d'instance et l'entraînement distribué, consultez Recommandation d'instance EC2 pour l'algorithme XGBoost.

Pour le mode de saisie d'entraînement CSV, la mémoire totale disponible pour l'algorithme doit être capable de contenir le jeu de données d'entraînement. La mémoire totale disponible est calculée comme suitInstance Count * the memory available in the InstanceType. Pour le mode d'entrée de l'entraînement libsvm, ce n'est pas obligatoire, mais nous le recommandons.

Pour la version v1.3-1 et les versions ultérieures, SageMaker XGBoost enregistre le modèle dans le format binaire interne XGBoost, en utilisant. Booster.save_model Les versions précédentes utilisaient le module pickle Python pour sérialiser/désérialiser le modèle.

Note

Faites attention aux versions lorsque vous utilisez un modèle SageMaker XGBoost dans un XGBoost open source. Les versions 1.3-1 et ultérieures utilisent le format binaire interne XGBoost tandis que les versions précédentes utilisent le module pickle Python.

Pour utiliser un modèle entraîné avec SageMaker XGBoost v1.3-1 ou version ultérieure dans le logiciel libre XGBoost

  • Utilisez le code Python suivant :

    import xgboost as xgb

xgb_model = xgb.Booster()
xgb_model.load_model(model_file_path)
xgb_model.predict(dtest)
Pour utiliser un modèle entraîné avec les versions précédentes de SageMaker XGBoost dans l'open source XGBoost

  • Utilisez le code Python suivant :

    import pickle as pkl 
import tarfile

t = tarfile.open('model.tar.gz', 'r:gz')
t.extractall()

model = pkl.load(open(model_file_path, 'rb'))

# prediction with test data
pred = model.predict(dtest)
Pour différencier l'importance des points de données étiquetés, utilisez Instance Weight Supports

  • SageMaker XGBoost permet aux clients de différencier l'importance des points de données étiquetés en attribuant à chaque instance une valeur de pondération. Pour l'entrée text/libsvm, les clients peuvent attribuer des valeurs de pondération aux instances de données en les attachant après les étiquettes. Par exemple, label:weight idx_0:val_0 idx_1:val_1.... Pour l'entrée text/csv, les clients doivent activer l'indicateur csv_weights dans les paramètres et attacher les valeurs de pondération dans la colonne après les étiquettes. Par exemple : label,weight,val_0,val_1,...).

Recommandation d'instance EC2 pour l'algorithme XGBoost

SageMaker XGBoost prend en charge l'entraînement et l'inférence du processeur et du GPU. Les recommandations relatives aux instances dépendent des besoins d'entraînement et d'inférence, ainsi que de la version de l'algorithme XGBoost. Choisissez l'une des options suivantes pour plus d'informations :

Entraînement

L'algorithme SageMaker XGBoost prend en charge l'entraînement du processeur et du GPU.

Entraînement CPU

SageMaker XGBoost 1.0-1 ou version antérieure ne s'entraîne qu'à l'aide de processeurs. Il s'agit d'un algorithme dépendant de la mémoire (par opposition à un algorithme dépendant du calcul). Par conséquent, une instance de calcul à usage général (par exemple, M5) constitue un meilleur choix qu'une instance optimisée pour le calcul (par exemple, C4). De plus, nous vous recommandons d'avoir suffisamment de mémoire totale dans les instances sélectionnées pour contenir les données d'entraînement. Il prend en charge l'utilisation de l'espace disque pour gérer les données qui ne rentrent pas dans la mémoire principale. Cela est dû à la out-of-core fonctionnalité disponible avec le mode de saisie libsvm. Malgré tout, l'écriture des fichiers de cache sur le disque ralentit le temps de traitement de l'algorithme.

Entraînement GPU

SageMaker La version 1.2-2 ou ultérieure de XGBoost prend en charge l'entraînement du GPU. Malgré des coûts par instance plus élevés, les GPU entraînent plus rapidement, ce qui les rend plus rentables.

SageMaker La version 1.2-2 ou ultérieure de XGBoost prend en charge les familles d'instances GPU P2, P3, G4dn et G5.

SageMaker La version 1.7-1 ou ultérieure de XGBoost prend en charge les familles d'instances GPU P3, G4dn et G5. Notez qu'en raison des exigences en matière de capacité de calcul, la version 1.7-1 ou ultérieure ne prend pas en charge la famille d'instances P2.

Pour tirer parti de l'entraînement au GPU :

  • Spécifiez le type d'instance comme l'une des instances du GPU (par exemple, P3)

  • Définissez l'tree_methodhyperparamètre sur gpu_hist dans votre script XGBoost existant

Entraînement distribué

SageMaker XGBoost prend en charge les instances de CPU et de GPU pour l'entraînement distribué.

Entraînement CPU distribué

Pour exécuter l'entraînement CPU sur plusieurs instances, définissez le paramètre instance_count de l'estimateur sur une valeur supérieure à un. Les données d'entrée doivent être divisées entre le nombre total d'instances.

Division des données d'entrée entre les instances

Divisez les données d'entrée en procédant comme suit :

  1. Décomposez les données d'entrée en fichiers plus petits. Le nombre de fichiers doit être au moins égal au nombre d'instances utilisées pour l'entraînement distribué. L'utilisation de plusieurs fichiers plus petits au lieu d'un seul fichier volumineux réduit également le temps de téléchargement des données pour la tâche d'entraînement.

  2. Lorsque vous créez votre TrainingInput, définissez le paramètre de distribution surShardedByS3Key. Ainsi, chaque instance obtient environ 1/n du nombre de fichiers dans S3 si n instances sont spécifiées dans la tâche de formation.

Entraînement GPU distribué

Vous pouvez utiliser l'entraînement distribué avec des instances à un seul GPU ou multi-GPU.

Entraînement distribué avec des instances à un seul GPU

SageMaker Les versions 1.2-2 à 1.3-1 de XGBoost ne prennent en charge que l'entraînement des instances avec un seul GPU. Cela signifie que même si vous sélectionnez une instance multi-GPU, un seul GPU est utilisé par instance.

Vous devez diviser vos données d'entrée entre le nombre total d'instances si :

  • Vous utilisez les versions 1.2-2 à 1.3-1 de XGBoost.

  • Il n'est pas nécessaire d'utiliser des instances multi-GPU.

Pour plus d’informations, consultez Division des données d'entrée entre les instances.

Note

Les versions 1.2-2 à 1.3-1 de SageMaker XGBoost n'utilisent qu'un seul GPU par instance, même si vous choisissez une instance multi-GPU.

Entraînement distribué avec des instances multi-GPU

À partir de la version 1.5-1, SageMaker XGBoost propose un entraînement GPU distribué avec Dask. Avec Dask, vous pouvez utiliser tous les GPU lorsque vous utilisez une ou plusieurs instances multi-GPU. Dask fonctionne également lors de l'utilisation d'instances à un seul GPU.

Effectuez l'entraînement avec Dask en procédant comme suit :

  1. Vous pouvez omettre le distribution paramètre dans votre TrainingInputou le définir surFullyReplicated.

  2. Lorsque vous définissez vos hyperparamètres, définissez use_dask_gpu_training sur "true".

Important

L'entraînement distribué avec Dask ne prend en charge que les formats d'entrée CSV et Parquet. Si vous utilisez d'autres formats de données tels que LIBSVM ou PROTOBUF, la tâche d'entraînement échoue.

Pour les données Parquet, assurez-vous que les noms des colonnes sont enregistrés sous forme de chaînes. Les colonnes dotées de noms d'un autre type de données ne seront pas chargées.

Important

L'entraînement distribué avec Dask ne prend pas en charge le mode Pipe. Si le mode Pipe est spécifié, la tâche d'entraînement échoue.

Il y a quelques considérations à prendre en compte lors de l'entraînement de SageMaker XGBoost avec Dask. Veillez à diviser vos données en fichiers plus petits. Dask lit chaque fichier Parquet comme une partition. Il existe un Dask Worker pour chaque GPU. Par conséquent, le nombre de fichiers doit être supérieur au nombre total de GPU (nombre d'instances * nombre de GPU par instance). Le fait d'avoir un très grand nombre de fichiers peut également dégrader les performances. Pour plus d'informations, consultez Bonnes pratiques relatives à Dask (langue française non garantie).

Variations en sortie

L'hyperparamètre tree_method spécifié détermine l'algorithme utilisé pour l'entraînement XGBoost. Les méthodes arborescentes approx, hist et gpu_hist sont toutes des méthodes approximatives qui utilisent le traçage de croquis (sketching) pour le calcul des quantiles. Pour plus d'informations, consultez Méthodes arborescentes (langue française non garantie) dans la documentation sur XGBoost. Le traçage de croquis est un algorithme approximatif. Par conséquent, vous pouvez vous attendre à des variations dans le modèle en fonction de facteurs tels que le nombre d'applications de travail choisies pour l'entraînement distribué. L'importance de la variation dépend des données.

Inférence

SageMaker XGBoost prend en charge les instances de CPU et de GPU à des fins d'inférence. Pour plus d'informations sur les types d'instances à inférer, consultez Amazon SageMaker ML Instance Types.

Exemples de blocs-notes XGBoost

Le tableau suivant présente une variété d'exemples de blocs-notes qui répondent à différents cas d'utilisation de l'algorithme Amazon SageMaker XGBoost.

Titre du bloc-notes Description

Comment créer un conteneur XGBoost personnalisé ?

Ce carnet vous explique comment créer un conteneur XGBoost personnalisé avec Amazon SageMaker Batch Transform.

Régression avec XGBoost à l'aide de Parquet

Ce bloc-notes vous explique comment utiliser le jeu de données Abalone dans Parquet pour entraîner un modèle XGBoost.

Comment entraîner et héberger un modèle de classification multiclasse ?

Ce bloc-notes explique comment utiliser le jeu de données MNIST pour entraîner et héberger un modèle de classification multiclasse.

Comment entraîner un modèle pour la prédiction de perte de clients ?

Ce bloc-notes vous montre comment entraîner un modèle à prédire le départ de clients mobiles afin d'identifier les clients insatisfaits.

Présentation de l'infrastructure Amazon SageMaker Managed Spot pour la formation XGBoost

Ce bloc-notes vous explique comment utiliser les instances Spot pour l'entraînement avec un conteneur XGBoost.

Comment utiliser Amazon SageMaker Debugger pour déboguer les tâches de formation XGBoost ?

Ce bloc-notes explique comment utiliser Amazon SageMaker Debugger pour surveiller les tâches de formation afin de détecter les incohérences à l'aide de règles de débogage intégrées.

Pour obtenir des instructions sur la création et l'accès aux instances de bloc-notes Jupyter dans lesquelles vous pouvez exécuter l'exemple SageMaker, consultez. Instances Amazon SageMaker Notebook Après avoir créé une instance de bloc-notes et l'avoir ouverte, cliquez sur l'onglet SageMakerExemples pour afficher la liste de tous les SageMaker exemples. Les exemples de blocs-notes de modélisation de rubrique utilisant les algorithmes NTM se trouvent dans la section Introduction to Amazon algorithms (Présentation des algorithmes Amazon). Pour ouvrir un bloc-notes, choisissez son onglet Use (Utiliser), puis Create copy (Créer une copie).

Pour plus d'informations sur l'algorithme Amazon SageMaker XGBoost, consultez les articles de blog suivants :