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.

# Versions obsolètes de XGBoost et leurs mises à niveau
<a name="xgboost-previous-versions"></a>

Cette rubrique contient de la documentation pour les versions précédentes d'Amazon SageMaker AI XGBoost qui sont toujours disponibles mais obsolètes. Il fournit également des instructions sur la manière de mettre à niveau les versions obsolètes de, dans la mesure du possible XGBoost, vers des versions plus récentes.

**Topics**
+ [Mise à niveau de XGBoost la version 0.90 vers la version 1.5](xgboost-version-0.90.md)
+ [XGBoost La version 0.72](xgboost-72.md)

# Mise à niveau de XGBoost la version 0.90 vers la version 1.5
<a name="xgboost-version-0.90"></a>

Si vous utilisez le SDK SageMaker Python, pour mettre à niveau les tâches XGBoost 0.90 existantes vers la version 1.5, la version 2.x du SDK doit être installée et les paramètres et doivent être remplacés par 1.5-1 XGBoost`version`. `framework_version` Si vous utilisez Boto3, vous devez mettre à jour l'image Docker, ainsi que quelques hyperparamètres et objectifs d'apprentissage.

**Topics**
+ [Mise à niveau de la version 1.x du SDK SageMaker AI Python vers la version 2.x](#upgrade-xgboost-version-0.90-sagemaker-python-sdk)
+ [Modifier la balise d'image à 1.5-1](#upgrade-xgboost-version-0.90-change-image-tag)
+ [Modifier l'image Docker pour Boto3](#upgrade-xgboost-version-0.90-boto3)
+ [Mettre à jour les hyperparamètres et les objectifs d'apprentissage](#upgrade-xgboost-version-0.90-hyperparameters)

## Mise à niveau de la version 1.x du SDK SageMaker AI Python vers la version 2.x
<a name="upgrade-xgboost-version-0.90-sagemaker-python-sdk"></a>

Si vous utilisez toujours la version 1.x du SDK SageMaker Python, vous devez mettre à niveau la version 2.x du SDK Python SageMaker . Pour plus d'informations sur la dernière version du SDK SageMaker Python, voir [Utiliser la version 2.x du SDK SageMaker Python](https://sagemaker.readthedocs.io/en/stable/v2.html). Pour installer la dernière version, exécutez :

```
python -m pip install --upgrade sagemaker
```

## Modifier la balise d'image à 1.5-1
<a name="upgrade-xgboost-version-0.90-change-image-tag"></a>

Si vous utilisez le SDK SageMaker Python et l'algorithme XGBoost intégré, modifiez le paramètre de version dans. `image_uris.retrive`

```
from sagemaker import image_uris
image_uris.retrieve(framework="xgboost", region="us-west-2", version="1.5-1")

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

Si vous utilisez le SDK SageMaker Python et que vous l'utilisez XGBoost comme framework pour exécuter vos scripts d'entraînement personnalisés, modifiez le `framework_version` paramètre dans l' XGBoost API.

```
estimator = XGBoost(entry_point = "your_xgboost_abalone_script.py", 
                    framework_version='1.5-1',
                    hyperparameters=hyperparameters,
                    role=sagemaker.get_execution_role(),
                    instance_count=1,
                    instance_type='ml.m5.2xlarge',
                    output_path=output_path)
```

`sagemaker.session.s3_input`dans le SDK SageMaker Python, la version 1.x a été renommée en. `sagemaker.inputs.TrainingInput` Vous devez utiliser `sagemaker.inputs.TrainingInput` comme dans l'exemple suivant.

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

 Pour la liste complète des modifications apportées à la version 2.x du SDK SageMaker Python, voir [Utiliser la version 2.x du SDK Python SageMaker ](https://sagemaker.readthedocs.io/en/stable/v2.html). 

## Modifier l'image Docker pour Boto3
<a name="upgrade-xgboost-version-0.90-boto3"></a>

Si vous utilisez Boto3 pour entraîner ou déployer votre modèle, remplacez la balise d'image Docker (1, 0.72, 0.90-1 or 0.90-2) par 1.5-1.

```
{
    "AlgorithmSpecification":: {
        "TrainingImage": "746614075791.dkr.ecr.us-west-1.amazonaws.com/sagemaker-xgboost:1.5-1"
    }
    ...
}
```

Si vous utilisez le SDK SageMaker Python pour récupérer le chemin du registre, modifiez le `version` paramètre dans`image_uris.retrieve`.

```
from sagemaker import image_uris
image_uris.retrieve(framework="xgboost", region="us-west-2", version="1.5-1")
```

## Mettre à jour les hyperparamètres et les objectifs d'apprentissage
<a name="upgrade-xgboost-version-0.90-hyperparameters"></a>

Le paramètre silent est devenu obsolète et n'est plus disponible dans les versions XGBoost 1.5 et ultérieures. Utilisez `verbosity` à la place. Si vous utilisiez l'objectif d'apprentissage `reg:linear`, il est également obsolète et a été remplacé par ` reg:squarederror`. Utilisez `reg:squarederror` à la place.

```
hyperparameters = {
    "verbosity": "2",
    "objective": "reg:squarederror",
    "num_round": "50",
    ...
}

estimator = sagemaker.estimator.Estimator(image_uri=xgboost_container, 
                                          hyperparameters=hyperparameters,
                                          ...)
```

# XGBoost La version 0.72
<a name="xgboost-72"></a>

**Important**  
Le XGBoost 0.72 est obsolète par Amazon AI. SageMaker Vous pouvez toujours utiliser cette ancienne version de XGBoost (en tant qu'algorithme intégré) en extrayant l'URI de son image, comme indiqué dans l'exemple de code suivant. Car XGBoost l'URI de l'image se terminant par `:1` correspond à l'ancienne version.  

```
import boto3
from sagemaker.amazon.amazon_estimator import get_image_uri

xgb_image_uri = get_image_uri(boto3.Session().region_name, "xgboost", repo_version="1")
```

```
import boto3
from sagemaker import image_uris

xgb_image_uri = image_uris.retrieve("xgboost", boto3.Session().region_name, "1")
```
Si vous souhaitez utiliser des versions plus récentes, vous devez spécifier explicitement les balises d'URI d'image (voir [Versions prises en charge](xgboost.md#xgboost-supported-versions)).

Cette version précédente de l' XGBoost algorithme Amazon SageMaker AI est basée sur la version 0.72. [XGBoost](https://github.com/dmlc/xgboost)(eXtreme Gradient Boosting) est une implémentation open source populaire et efficace de l'algorithme des arbres boostés par le gradient. L'amplification du gradient est un algorithme d'apprentissage supervisé qui tente de prédire avec précision une variable cible en combinant les estimations d'un ensemble de modèles plus simples et plus faibles. XGBoost s'est remarquablement bien comporté dans les concours d'apprentissage automatique, car il gère de manière robuste une variété de types de données, de relations et de distributions, et en raison du grand nombre d'hyperparamètres qui peuvent être ajustés et ajustés pour de meilleurs ajustements. Cette flexibilité constitue XGBoost un choix judicieux pour les problèmes de régression, de classification (binaire et multiclasse) et de classement.

Les clients doivent envisager d'utiliser la nouvelle version de l'[XGBoost algorithme avec Amazon SageMaker AI](xgboost.md). Ils peuvent l'utiliser comme algorithme intégré à l' SageMaker IA ou comme framework pour exécuter des scripts dans leurs environnements locaux, comme ils le feraient généralement, par exemple, avec un framework d'apprentissage en profondeur Tensorflow. Cette nouvelle implémentation présente une empreinte mémoire plus petite, une meilleure journalisation, une meilleure validation des hyperparamètres et un ensemble étendu de métriques. L'implémentation antérieure de XGBoost reste disponible pour les clients s'ils doivent reporter la migration vers la nouvelle version. Mais cette implémentation précédente restera liée à la version 0.72 de XGBoost.

## Interface d'entrée/sortie pour la version 0.72 XGBoost
<a name="xgboost-72-InputOutput"></a>

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. 

L'implémentation de l' SageMaker IA prend en XGBoost charge les formats CSV et libsvm pour la formation et l'inférence :
+ *Pour Training ContentType, les entrées valides sont *text/libsvm* (par défaut) ou text/csv.*
+ *Pour Inference ContentType, les entrées valides sont *text/libsvm* ou (par défaut) text/csv.*

**Note**  
Pour l'entraînement CSV, l'algorithme suppose que la variable cible est dans la première colonne et que le CSV n'a pas d'enregistrement d'en-tête. Pour l'inférence CSV, l'algorithme suppose que l'entrée CSV ne dispose pas de la colonne d'étiquette.   
Pour l'entraînement libsvm, l'algorithme suppose que l'étiquette se trouve dans la première colonne. Les colonnes suivantes contiennent les paires de valeur d'index des caractéristiques. Par conséquent, chaque ligne a le format suivant : <label> <index0>:<value0> <index1>:<value1> ... Les demandes d'inférence pour libsvm peuvent avoir ou nom les étiquettes au format libsvm.

Cela diffère des autres algorithmes d' SageMaker IA, qui utilisent le format d'entrée d'entraînement protobuf pour maintenir une plus grande cohérence avec les formats de XGBoost données standard.

Pour le mode d'entrée de l'entraînement CSV, la mémoire totale disponible pour l'algorithme (Nombre d'instances \$1 la mémoire disponible dans l'objet `InstanceType`) doit être en mesure de contenir le jeu de données de l'entraînement. Pour le mode d'entrée de l'entraînement libsvm, ce n'est pas obligatoire, mais nous le recommandons.

SageMaker L'IA XGBoost utilise le module Python pickle pour serialize/deserialize le modèle, qui peut être utilisé pour saving/loading le modèle.

**Pour utiliser un modèle formé à l' SageMaker IA XGBoost en open source XGBoost**
+ Utilisez le code Python suivant :

  ```
  import pickle as pkl 
  import tarfile
  import xgboost
  
  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 L'IA XGBoost permet aux clients de différencier l'importance des points de données étiquetés en attribuant une valeur de pondération à chaque instance. 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 la XGBoost version 0.72
<a name="xgboost-72-Instance"></a>

SageMaker XGBoost Actuellement, seuls les trains utilisent l'IA CPUs. 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, M4) est 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. Bien qu'il prenne en charge l'utilisation de l'espace disque pour traiter les données qui ne rentrent pas dans la mémoire principale ( out-of-corefonctionnalité disponible avec le mode d'entrée libsvm), l'écriture de fichiers de cache sur le disque ralentit le temps de traitement de l'algorithme.

## XGBoost Exemples de carnets de notes de la version 0.72
<a name="xgboost-72-sample-notebooks"></a>

Pour un exemple de bloc-notes expliquant comment utiliser la dernière version d' SageMaker AI en XGBoost tant qu'algorithme intégré pour entraîner et héberger un modèle de régression, consultez la section [Régression avec l' XGBoost algorithme Amazon SageMaker AI](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_abalone.html). Pour utiliser la version 0.72 de XGBoost, vous devez remplacer la version de l'exemple de code par 0.72. Pour savoir comment créer et accéder à des instances de bloc-notes Jupyter que vous pouvez utiliser pour exécuter l'exemple dans SageMaker AI, consultez. [Instances de SageMaker blocs-notes Amazon](nbi.md) Une fois que vous avez créé une instance de bloc-notes et que vous l'avez ouverte, sélectionnez l'onglet **Exemples d'SageMaker IA** pour voir la liste de tous les exemples d' SageMaker IA. La rubrique consacrée à la modélisation d'exemples de blocs-notes à l'aide XGBoost des algorithmes se trouve dans la section **Introduction aux algorithmes d'Amazon**. Pour ouvrir un bloc-notes, cliquez sur son onglet **Use (Utiliser)** et sélectionnez **Create copy (Créer une copie)**.

## XGBoost Hyperparamètres de la version 0.72
<a name="xgboost-72-hyperparameters"></a>

Le tableau suivant contient les hyperparamètres de l' XGBoost algorithme. Il s'agit des paramètres qui sont définis par les utilisateurs pour faciliter l'estimation des paramètres modèles issus des données. Les hyperparamètres requis qui doivent être définies sont les premiers répertoriés, dans l'ordre alphabétique. Les hyperparamètres facultatifs qui peuvent être définis sont répertoriés ensuite, également dans l'ordre alphabétique. L' XGBoost algorithme SageMaker AI est une implémentation du XGBoost package open source. Actuellement, SageMaker AI prend en charge la version 0.72. Pour plus de détails sur la configuration des hyperparamètres pour cette version de XGBoost, consultez la section [ XGBoostParamètres](https://xgboost.readthedocs.io/en/release_0.72/parameter.html).


| Nom du paramètre | Description | 
| --- | --- | 
| num\$1class | Nombre de classes. **Obligatoire** si `objective` a la valeur *multi:softmax* ou *multi:softprob*. Valeurs valides : nombre entier  | 
| num\$1round | Le nombre de séries pour exécuter l'entraînement. **Obligatoire** Valeurs valides : nombre entier  | 
| alpha | Condition de régularisation L1 sur les pondérations. L'augmentation de cette valeur rend les modèles plus prudents. **Facultatif** Valeurs valides : float Valeur par défaut : 0  | 
| base\$1score | Score de prédiction initiale de toutes les instances, biais global. **Facultatif** Valeurs valides : float Valeur par défaut : 0.5  | 
| booster | Quel booster utiliser. Les valeurs `gbtree` et `dart` utilisent un modèle basé sur un arbre, tandis que `gblinear` utilise une fonction linéaire. **Facultatif** Valeurs valides : string. `gbtree`, `gblinear` ou `dart`. Valeur par défaut : `gbtree`  | 
| colsample\$1bylevel | Ration de sous-échantillon des colonnes pour chaque fractionnement, dans chaque niveau. **Facultatif** Valeurs valides : float. Plage : [0,1]. Valeur par défaut : 1  | 
| colsample\$1bytree | Ratio de sous-échantillon des colonnes lors de la construction de chaque arbre. **Facultatif** Valeurs valides : float. Plage : [0,1]. Valeur par défaut : 1 | 
| csv\$1weights | Lorsque cet indicateur est activé, il XGBoost différencie l'importance des instances pour la saisie au format CSV en utilisant la deuxième colonne (la colonne après les étiquettes) des données d'entraînement comme pondération des instances. **Facultatif** Valeurs valides : 0 ou 1 Valeur par défaut : 0  | 
| early\$1stopping\$1rounds | Le modèle entraîne jusqu'à ce que le score de validation arrête l'amélioration. L'erreur de validation doit diminuer au moins chaque `early_stopping_rounds` pour poursuivre l'entraînement. SageMaker L'hébergement AI utilise le meilleur modèle d'inférence. **Facultatif** Valeurs valides : nombre entier Valeur par défaut: -  | 
| eta | Réduction de la taille de l'étape utilisée dans les mises à jour pour empêcher le surajustement. Après chaque étape du renforcement, vous pouvez obtenir directement les poids des nouvelles caractéristiques. Le paramètre `eta` diminue réellement les pondérations des caractéristiques pour rendre le processus de renforcement plus prudent. **Facultatif** Valeurs valides : float. Plage : [0,1]. Valeur par défaut : 0.3  | 
| eval\$1metric | Métriques d'évaluation pour les données de validation. Une métrique est attribué par défaut en fonction de l'objectif :[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/xgboost-72.html) Pour obtenir la liste des entrées valides, consultez la section [XGBoost Paramètres](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst#learning-task-parameters). **Facultatif** Valeurs valides : chaîne Valeur par défaut : valeur par défaut selon l'objectif.  | 
| gamma | Diminution de perte minimale requise pour effectuer une partition supplémentaire sur un nœud terminal de l'arbre. Plus la valeur est grande, plus l'algorithme est prudent. **Facultatif** Valeurs valides : float. Plage : [0,∞). Valeur par défaut : 0  | 
| grow\$1policy | Contrôle la façon dont les nouveaux nœuds sont ajoutés à l'arbre. Actuellement pris en charge uniquement si `tree_method` a la valeur `hist`. **Facultatif** Valeurs valides : string. `depthwise` ou `lossguide`. Valeur par défaut : `depthwise`  | 
| lambda | Condition de régularisation L2 sur les pondérations. L'augmentation de cette valeur rend les modèles plus prudents. **Facultatif** Valeurs valides : float Valeur par défaut : 1  | 
| lambda\$1bias | Condition de régularisation L2 sur un biais. **Facultatif** Valeurs valides : float. Plage : [0.0, 1.0]. Valeur par défaut : 0  | 
| max\$1bin | Nombre maximal de compartiments distincts pour compartimenter les fonctions continues. Utilisé uniquement si `tree_method` a la valeur `hist`.  **Facultatif** Valeurs valides : nombre entier Valeur par défaut : 256  | 
| max\$1delta\$1step | Étape delta maximale autorisée pour chaque estimation de pondération d'arbre. Quand un nombre entier positif est utilisé, il permet que la mise à jour soit encore plus prudente. L'option privilégiée consiste à l'utiliser dans une régression logistique. Définissez-la entre 1-10 pour aider à contrôler la mise à jour.  **Facultatif** Valeurs valides : nombre entier. Plage : [0,∞). Valeur par défaut : 0  | 
| max\$1depth | Profondeur maximale d'un arbre. L'augmentation de cette valeur rend le modèle plus complexe et susceptible d'être surajusté. 0 indique l'absence de limite. Une limite est requise quand `grow_policy`=`depth-wise`. **Facultatif** Valeurs valides : nombre entier. Plage : [0,∞) Valeur par défaut : 6  | 
| max\$1leaves | Nombre maximal de nœuds à ajouter. Pertinent uniquement si `grow_policy` a la valeur `lossguide`. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : 0  | 
| min\$1child\$1weight | Somme minimale de la pondération (Hessian) d'instance nécessaire dans un enfant. Si l'étape de partition de l'arbre se traduit par un nœud terminal avec la somme de pondération d'instance inférieure à `min_child_weight`, le processus de développement abandonne tout partitionnement supplémentaire. Dans les modèles de régression linéaire, cela correspond simplement à un nombre minimal d'instances requis dans chaque nœud. Plus la valeur est grande, plus l'algorithme est prudent. **Facultatif** Valeurs valides : float. Plage : [0,∞). Valeur par défaut : 1  | 
| normalize\$1type | Type d'algorithme de normalisation. **Facultatif** Valeurs valides : *tree* ou *forest*. Valeur par défaut : *tree*  | 
| nthread | Nombre de threads parallèles utilisés pour exécuter *xgboost*. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : nombre maximal de threads.  | 
| objective | Spécifie la tâche d'apprentissage et l'objectif d'apprentissage correspondant. Exemples : `reg:logistic`, `reg:softmax`, `multi:squarederror`. Pour obtenir la liste complète des entrées valides, reportez-vous à la section [XGBoost Paramètres](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst#learning-task-parameters). **Facultatif** Valeurs valides : chaîne Valeur par défaut : `reg:squarederror`  | 
| one\$1drop | Lorsque cet indicateur est activé, au moins un arbre est toujours supprimé pendant l'opération de dropout. **Facultatif** Valeurs valides : 0 ou 1 Valeur par défaut : 0  | 
| process\$1type | Type de processus de renforcement à exécuter. **Facultatif** Valeurs valides : string. `default` ou `update`. Valeur par défaut : `default`  | 
| rate\$1drop | Taux de dropout qui spécifie la fraction des arbres précédents à supprimer pendant le dropout. **Facultatif** Valeurs valides : float. Plage : [0.0, 1.0]. Valeur par défaut : 0.0  | 
| refresh\$1leaf | Il s'agit d'un paramètre du plug-in de mise à jour « refresh ». Lorsque ce paramètre est défini sur`true` (1), les feuilles de l'arbre et les statistiques des nœuds de l'arbre sont mises à jour. Lorsque la valeur est définie sur `false`(0), seules les statistiques des nœuds de l'arbre sont mises à jour. **Facultatif** Valeurs valides : 0 \$1 1 Valeur par défaut : 1  | 
| sample\$1type | Type d'algorithme d'échantillonnage. **Facultatif** Valeurs valides : `uniform` ou `weighted`. Valeur par défaut : `uniform`  | 
| scale\$1pos\$1weight | Contrôle le solde de pondérations positives et négatives. Utile pour les classes non équilibrées. Valeur typique à prendre en compte : `sum(negative cases)` / `sum(positive cases)`. **Facultatif** Valeurs valides : float Valeur par défaut : 1  | 
| seed | Nombre d'amorçage aléatoire. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : 0  | 
| silent | 0 signifie l'impression des messages d'exécution, 1 signifie le mode silencieux. Valeurs valides : 0 ou 1 **Facultatif** Valeur par défaut : 0  | 
| sketch\$1eps | Utilisé uniquement pour l'algorithme gourmand (glouton) approximatif. Cela se traduit en O(1/ `sketch_eps`) nombre de compartiments. Par comparaison avec la sélection directe du nombre de compartiments, celui-ci s'accompagne d'une garantie théorique avec précision d'esquisse. **Facultatif** Valeurs valides : Float, Plage : [0, 1]. Valeur par défaut : 0.03  | 
| skip\$1drop | Probabilité d’ignorer la procédure de dropout pendant une itération de renforcement. **Facultatif** Valeurs valides : float. Plage : [0.0, 1.0]. Valeur par défaut : 0.0  | 
| subsample | Ratio de sous-échantillon de l'instance d'entraînement. Le définir sur 0,5 signifie que la moitié des instances de données sont collectées de XGBoost manière aléatoire pour faire pousser des arbres. Cela empêche le surajustement. **Facultatif** Valeurs valides : float. Plage : [0,1]. Valeur par défaut : 1  | 
| tree\$1method | L'algorithme de construction d'arbres utilisé dans XGBoost. **Facultatif** Valeurs valides : `auto`, `exact`, `approx` ou `hist`. Valeur par défaut : `auto`  | 
| tweedie\$1variance\$1power | Paramètre qui contrôle la variance de la distribution Tweedie. **Facultatif** Valeurs valides : float. Plage : (1, 2). Valeur par défaut : 1.5  | 
| updater | Chaîne séparée par des virgules qui définit la séquence des programmes de mise à jour des arbres à exécuter. Cela fournit une solution modulaire pour créer et modifier les arbres. Pour une liste complète des entrées valides, reportez-vous à la section [XGBoost Paramètres](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst). **Facultatif** Valeurs valides : chaîne séparée par des virgules. Valeur par défaut : `grow_colmaker`, prune.  | 

## Tune and XGBoost Release 0.72 Model
<a name="xgboost-72-tuning"></a>

Le *réglage de modèle automatique*, ou réglage d'hyperparamètre, détecte la meilleure version d'un modèle en exécutant plusieurs tâches qui testent une plage d'hyperparamètres sur vos jeu de données d'entraînement et de valisation. Vous choisissez trois types d'hyperparamètres :
+ une fonction `objective` d'apprentissage à optimiser pendant l'entraînement du modèle ;
+ une métrique `eval_metric` à utiliser pour évaluer les performances du modèle lors de la validation ;
+ un ensemble d'hyperparamètres et une plage de valeurs à utiliser pour régler automatiquement le modèle.

Vous choisissez la métrique d'évaluation parmi un ensemble de métriques d'évaluation que l'algorithme calcule. Le réglage de modèle automatique recherche parmi les hyperparamètres choisis la combinaison de valeurs qui produira un modèle permettant d'optimiser la métrique d'évaluation. 

Pour plus d'informations sur le réglage de modèle, consultez [Réglage automatique du modèle grâce à l' SageMaker IA](automatic-model-tuning.md).

### Métriques calculées par l'algorithme de la XGBoost version 0.72
<a name="xgboost-72-metrics"></a>

L' XGBoost algorithme basé sur la version 0.72 calcule les neuf métriques suivantes à utiliser pour la validation du modèle. Lors du réglage du modèle, choisissez l'une de ces métriques pour évaluer le modèle. Pour obtenir la liste complète des `eval_metric` valeurs valides, reportez-vous à la section [Paramètres des tâches XGBoost d'apprentissage](https://github.com/dmlc/xgboost/blob/master/doc/parameter.rst#learning-task-parameters)


| Nom de la métrique | Description | Orientation de l'optimisation | 
| --- | --- | --- | 
| validation:auc |  Aire sous une courbe (AUC, Area Under a Curve).  |  Agrandir  | 
| validation:error |  Taux d'erreurs de classification binaire, calculé comme Nbre cas erronés/Nbre total de cas.  |  Réduire  | 
| validation:logloss |  Probabilité de journalisation négative.  |  Réduire  | 
| validation:mae |  Erreur absolue moyenne.  |  Réduire  | 
| validation:map |  Précision moyenne.  |  Agrandir  | 
| validation:merror |  Taux d’erreurs de classification multi-classes, calculé comme \$1(Nbre cas erronés)/\$1(Nbre total de cas).  |  Réduire  | 
| validation:mlogloss |  Probabilité de journalisation négative pour la classification multi-classes.  |  Réduire  | 
| validation:ndcg |  NDCG (Normalized Discounted Cumulative Gain).  |  Agrandir  | 
| validation:rmse |  Racine carrée de l'erreur quadratique moyenne (RMSE)  |  Réduire  | 

### Hyperparamètres de la XGBoost version 0.72 réglable
<a name="xgboost-72-tunable-hyperparameters"></a>

Réglez le XGBoost modèle avec les hyperparamètres suivants. Les hyperparamètres qui ont le plus d'effet sur l'optimisation des métriques XGBoost d'évaluation sont les suivants : `alpha``min_child_weight`,`subsample`,`eta`, et`num_round`. 


| Nom du paramètre | Type de paramètre | Plages recommandées | 
| --- | --- | --- | 
| alpha |  ContinuousParameterRanges  |  MinValue: 0, MaxValue 100  | 
| colsample\$1bylevel |  ContinuousParameterRanges  |  MinValue: 0,1, MaxValue 1  | 
| colsample\$1bytree |  ContinuousParameterRanges  |  MinValue: 0,5, MaxValue : 1  | 
| eta |  ContinuousParameterRanges  |  MinValue: 0,1, MaxValue 0,5  | 
| gamma |  ContinuousParameterRanges  |  MinValue: 0, MaxValue 5  | 
| lambda |  ContinuousParameterRanges  |  MinValue: 0, MaxValue 100  | 
| max\$1delta\$1step |  IntegerParameterRanges  |  [0, 10]  | 
| max\$1depth |  IntegerParameterRanges  |  [0, 10]  | 
| min\$1child\$1weight |  ContinuousParameterRanges  |  MinValue: 0, MaxValue 120  | 
| num\$1round |  IntegerParameterRanges  |  [1, 4000]  | 
| subsample |  ContinuousParameterRanges  |  MinValue: 0,5, MaxValue : 1  |