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.
# LightGBM
[LightGBM](https://lightgbm.readthedocs.io/en/latest/) est une implémentation open source populaire et efficace de l'algorithme d'arbre de décision avec renforcement de gradient (algorithme GBDT). L'algorithme GBDT est un algorithme d'apprentissage supervisé qui tente de prédire avec précision une variable cible en combinant un ensemble d'estimations à partir d'un jeu de modèles plus simples et plus faibles. LightGBM utilise des techniques supplémentaires pour améliorer considérablement l'efficacité et la capacité de mise à l’échelle de l'algorithme GBDT conventionnel. Cette page contient des informations sur les recommandations relatives aux instances Amazon EC2 et des exemples de blocs-notes pour LightGBM.
# Comment utiliser SageMaker AI LightGBM
Vous pouvez utiliser LightGBM comme algorithme intégré d'Amazon SageMaker AI. La section suivante décrit comment utiliser LightGBM avec le SDK SageMaker Python. Pour plus d'informations sur l'utilisation de LightGBM depuis l'interface utilisateur Amazon SageMaker Studio Classic, consultez. [SageMaker JumpStart modèles préentraînés](studio-jumpstart.md)
+ **Utilisation de LightGBM en tant qu'algorithme intégré**
Utilisez l'algorithme intégré LightGBM pour créer un conteneur d'entraînement LightGBM comme indiqué dans l'exemple de code suivant. Vous pouvez détecter automatiquement l'URI de l'image de l'algorithme intégré à LightGBM à l'aide de l'`image_uris.retrieve`API SageMaker AI (ou de l'`get_image_uri`API si vous utilisez le [SDK Amazon SageMaker Python version 2](https://sagemaker.readthedocs.io/en/stable)).
Après avoir spécifié l'URI de l'image LightGBM, vous pouvez utiliser le conteneur LightGBM pour créer un estimateur à l'aide de l'API SageMaker AI Estimator et lancer une tâche de formation. L'algorithme intégré LightGBM s'exécute en mode script, mais le script d'entraînement vous est fourni et n'a pas besoin d'être remplacé. Si vous avez une vaste expérience de l'utilisation du mode script pour créer une tâche de SageMaker formation, vous pouvez intégrer vos propres scripts de formation LightGBM.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "lightgbm-classification-model", "*", "training"
training_instance_type = "ml.m5.xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_multiclass/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"num_boost_round"
] = "500"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_estimator = Estimator(
role=aws_role,
image_uri=train_image_uri,
source_dir=train_source_uri,
model_uri=train_model_uri,
entry_point="transfer_learning.py",
instance_count=1, # for distributed training, specify an instance_count greater than 1
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location
)
# Launch a SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"train": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Pour plus d'informations sur la configuration de LightGBM en tant qu'algorithme intégré, consultez les exemples de bloc-notes suivants.
+ [Classification tabulaire avec Amazon SageMaker AI LightGBM et algorithme CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb)
+ [Régression tabulaire avec Amazon SageMaker AI LightGBM et algorithme CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb)
# Interface d'entrée/sortie de l'algorithme LightGBM
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 SageMaker AI de LightGBM prend en charge le format CSV pour la formation et l'inférence :
+ Pour la **formation ContentType**, les entrées valides doivent être au format *text/csv*.
+ Pour l'**inférence ContentType**, les entrées valides doivent être du type *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.
**Format d'entrée pour les données d'entraînement, les données de validation et les caractéristiques catégorielles**
Soyez conscient de la façon de formater vos données d'entraînement pour les entrer dans le modèle LightGBM. Vous devez fournir le chemin d'accès à un compartiment Amazon S3 contenant vos données d'entraînement et de validation. Vous pouvez également inclure une liste de caractéristiques catégorielles. Utilisez à la fois les canaux `train` et `validation` pour fournir vos données d'entrée. Vous pouvez également utiliser uniquement le canal `train`.
**Note**
`train` et `training` sont tous les deux des noms de canaux valides pour l'entraînement LightGBM.
**Utilisation des deux canaux `train` et `validation`**
Vous pouvez fournir vos données d'entrée par le biais de deux chemins S3, l'un pour le canal `train` et l'autre pour le canal `validation`. Chaque chemin S3 peut être soit un préfixe S3 pointant vers un ou plusieurs fichiers CSV, soit un chemin S3 complet pointant vers un fichier CSV spécifique. Les variables cibles doivent figurer dans la première colonne de votre fichier CSV. Les variables prédictives (caractéristiques) doivent figurer dans les autres colonnes. Si plusieurs fichiers CSV sont fournis pour les canaux `train` ou `validation`, l'algorithme LightGBM concatène les fichiers. Les données de validation sont utilisées pour calculer un score de validation à la fin de chaque itération de renforcement. Un arrêt précoce intervient lorsque le score de validation cesse de s'améliorer.
Si vos prédicteurs incluent des caractéristiques catégorielles, vous pouvez fournir un fichier JSON nommé `categorical_index.json` au même emplacement que votre ou vos fichiers de données d'entraînement. Si vous fournissez un fichier JSON pour les caractéristiques catégorielles, votre canal `train` doit pointer vers un préfixe S3 et non vers un fichier CSV spécifique. Ce fichier doit contenir un dictionnaire Python dans lequel la clé est la chaîne `"cat_index_list"` et la valeur est une liste d'entiers uniques. Chaque entier de la liste de valeurs doit indiquer l'indice de colonne des caractéristiques catégorielles correspondantes dans votre fichier CSV de données d'entraînement. Chaque valeur doit être un entier positif (supérieur à zéro car zéro représente la valeur cible), inférieur à `Int32.MaxValue` (2147483647) et inférieur au nombre total de colonnes. Il ne doit y avoir qu'un seul fichier JSON d'indices catégoriels.
**Utilisation du seul canal `train`** :
Vous pouvez également fournir vos données d'entrée par le biais d'un seul chemin S3 pour le canal `train`. Ce chemin S3 doit pointer vers un répertoire dont le sous-répertoire nommé `train/` contient un ou plusieurs fichiers CSV. Vous pouvez éventuellement inclure un autre sous-répertoire dans le même emplacement appelé `validation/` qui contient également un ou plusieurs fichiers CSV. Si les données de validation ne sont pas fournies, 20 % de vos données d'entraînement sont échantillonnées de façon aléatoire pour servir de données de validation. Si vos prédicteurs incluent des caractéristiques catégorielles, vous pouvez fournir un fichier JSON nommé `categorical_index.json` au même emplacement que vos sous-répertoires de données.
**Note**
Pour le mode d'entrée de l'entraînement CSV, la mémoire totale disponible pour l'algorithme (nombre d'instances multiplié par la mémoire disponible dans `InstanceType`) doit pouvoir contenir le jeu de données d'entraînement.
SageMaker AI LightGBM utilise le module Python Joblib pour sérialiser ou désérialiser le modèle, qui peut être utilisé pour enregistrer ou charger le modèle.
**Pour utiliser un modèle entraîné avec SageMaker AI LightGBM avec le module JobLib**
+ Utilisez le code Python suivant :
```
import joblib
import tarfile
t = tarfile.open('model.tar.gz', 'r:gz')
t.extractall()
model = joblib.load(model_file_path)
# prediction with test data
# dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
pred = model.predict(dtest)
```
## Recommandation d'instances Amazon EC2 pour l'algorithme LightGBM
SageMaker AI LightGBM prend actuellement en charge l'entraînement des processeurs en instance unique et en instance multiple. Pour l'entraînement de processeur à plusieurs instances (entraînement distribué), spécifiez une valeur `instance_count` supérieure à 1 lorsque vous définissez votre estimateur. Pour plus d'informations sur la formation distribuée avec LightGBM, consultez [Amazon SageMaker AI LightGBM Distributed](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/sagemaker_lightgbm_distributed_training_dask/sagemaker-lightgbm-distributed-training-dask.html) training using Dask.
LightGBM est 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, C5). 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.
## Exemples de blocs-notes LightGBM
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 AI LightGBM.
****
| **Titre du bloc-notes** | **Description** |
| --- | --- |
| [Classification tabulaire avec Amazon SageMaker AI LightGBM et algorithme CatBoost ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.html) | Ce carnet explique l'utilisation de l'algorithme Amazon SageMaker AI LightGBM pour entraîner et héberger un modèle de classification tabulaire. |
| [Régression tabulaire avec Amazon SageMaker AI LightGBM et algorithme CatBoost ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.html) | Ce carnet explique l'utilisation de l'algorithme Amazon SageMaker AI LightGBM pour entraîner et héberger un modèle de régression tabulaire. |
| [Formation distribuée Amazon SageMaker AI LightGBM à l'aide de Dask](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/sagemaker_lightgbm_distributed_training_dask/sagemaker-lightgbm-distributed-training-dask.html) | Ce bloc-notes décrit la formation distribuée avec l'algorithme Amazon SageMaker AI LightGBM à l'aide du framework Dask. |
Pour obtenir des instructions sur la façon de créer et d'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) Après avoir créé une instance de bloc-notes et l'avoir ouverte, choisissez l'onglet **Exemples d'SageMaker IA** pour voir la liste de tous les exemples d' SageMaker IA. Pour ouvrir un bloc-notes, choisissez son onglet **Use** (Utiliser), puis **Create copy** (Créer une copie).
# Fonctionnement de LightGBM
LightGBM implémente un algorithme d'arbre de décision avec renforcement de gradient (algorithme GBDT) conventionnel auquel s'ajoutent deux nouvelles techniques : l'échantillonnage d'un côté en dégradé (GOSS, Gradient-based One-Side Sampling) et l'offre groupée de fonctionnalités exclusives (EFB, Exclusive Feature Bundling). Ces techniques sont conçues pour améliorer considérablement l'efficacité et la capacité de mise à l’échelle de l'algorithme GBDT.
L'algorithme LightGBM fonctionne bien dans les compétitions de Machine Learning en raison de son traitement robuste de divers types de données, de relations et de distributions, et de la variété d'hyperparamètres que vous pouvez affiner. Vous pouvez utiliser LightGBM pour les problèmes de régression, de classification (binaire et multi-classes) et de classement.
Pour plus d'informations sur le renforcement de gradient, consultez [Comment fonctionne l' XGBoost algorithme d' SageMaker IA](xgboost-HowItWorks.md). Pour plus de détails sur les techniques GOSS et EFB supplémentaires utilisées dans la méthode LightGBM, consultez *[LightGBM : un arbre de décision avec renforcement de gradient hautement efficace](https://proceedings.neurips.cc/paper/2017/file/6449f44a102fde848669bdd9eb6b76fa-Paper.pdf)* (Français non garanti).
# Hyperparamètres de LightGBM
Le tableau suivant contient le sous-ensemble d'hyperparamètres requis ou les plus couramment utilisés pour l'algorithme Amazon SageMaker AI LightGBM. Les utilisateurs définissent ces paramètres pour faciliter l'estimation des paramètres du modèle à partir des données. [L'algorithme SageMaker AI LightGBM est une implémentation du package open-source LightGBM.](https://github.com/microsoft/LightGBM)
**Note**
Les hyperparamètres par défaut sont basés sur des exemples de jeux de données dans le [Exemples de blocs-notes LightGBM](lightgbm.md#lightgbm-sample-notebooks).
Par défaut, l'algorithme SageMaker AI LightGBM choisit automatiquement une métrique d'évaluation et une fonction objective en fonction du type de problème de classification. L'algorithme LightGBM détecte le type de problème de classification en fonction du nombre d'étiquettes contenues dans vos données. Pour les problèmes de régression, la métrique d'évaluation correspond à la racine carrée de l'erreur quadratique moyenne et la fonction objective correspond à la perte L2. Pour les problèmes de classification binaire, la métrique d'évaluation et la fonction objective correspondent toutes deux à l'entropie croisée binaire. Pour les problèmes de classification multi-classes, la métrique d'évaluation correspond à l'entropie croisée multi-classes et la fonction objective à softmax. Vous pouvez utiliser l'hyperparamètre `metric` pour modifier la métrique d'évaluation par défaut. Reportez-vous au tableau suivant pour plus d'informations sur les hyperparamètres LightGBM, y compris les descriptions, les valeurs valides et les valeurs par défaut.
| Nom du paramètre | Description |
| --- | --- |
| num\$1boost\$1round | Nombre maximal d'itérations de renforcement. **Remarque :** En interne, LightGBM construit `num_class * num_boost_round` arbres pour les problèmes de classification multi-classes. Valeurs valides : nombre entier, plage : nombre entier positif. Valeur par défaut : `100`. |
| early\$1stopping\$1rounds | L'entraînement s'arrête si une métrique d'un point de données de validation ne s'améliore pas au cours du dernier cycle `early_stopping_rounds`. Si `early_stopping_rounds` est inférieur ou égal à zéro, cet hyperparamètre est ignoré. Valeurs valides : entier Valeur par défaut : `10`. |
| metric | Métrique d'évaluation des données de validation. Si `metric` est défini sur la valeur `"auto"` par défaut, l'algorithme choisit automatiquement une métrique d'évaluation en fonction du type de problème de classification : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/lightgbm-hyperparameters.html) Valeurs valides : chaîne, l'une des valeurs suivantes : (`"auto"`, `"rmse"`, `"l1"`, `"l2"`, `"huber"`, `"fair"`, `"binary_logloss"`, `"binary_error"`, `"auc"`, `"average_precision"`, `"multi_logloss"`, `"multi_error"`, `"auc_mu"` ou `"cross_entropy"`). Valeur par défaut : `"auto"`. |
| learning\$1rate | Taux auquel les pondérations du modèle sont mises à jour après que chaque lot d'exemples d'entraînement a été parcouru. Valeurs valides : float, plage : (`0.0`, `1.0`). Valeur par défaut : `0.1`. |
| num\$1leaves | Nombre maximal de feuilles dans un arbre. Valeurs valides : entier, plage : (`1`, `131072`). Valeur par défaut : `64`. |
| feature\$1fraction | Sous-ensemble de caractéristiques à sélectionner à chaque itération (arbre). Il doit être inférieur à 1,0. Valeurs valides : float, plage : (`0.0`, `1.0`). Valeur par défaut : `0.9`. |
| bagging\$1fraction | Sous-ensemble de caractéristiques similaires à `feature_fraction`, mais `bagging_fraction` sélectionne de façon aléatoire une partie des données sans rééchantillonnage. Valeurs valides : valeur à virgule flottante, plage : (`0.0`, `1.0`). Valeur par défaut : `0.9`. |
| bagging\$1freq | Fréquence de bagging. À chaque itération `bagging_freq`, LightGBM sélectionne de façon aléatoire un pourcentage des données à utiliser pour la prochaine itération `bagging_freq`. Ce pourcentage est déterminé par l'hyperparamètre `bagging_fraction`. Si `bagging_freq` est zéro, le bagging est désactivé. Valeurs valides : nombre, plage : nombre entier non négatif. Valeur par défaut : `1`. |
| max\$1depth | Profondeur maximale pour un modèle d'arbre. Elle est utilisée pour traiter le surajustement lorsque la quantité de données est faible. Si `max_depth` est inférieure ou égale à zéro, cela signifie qu'il n'y a pas de limite pour la profondeur maximale. Valeurs valides : entier Valeur par défaut : `6`. |
| min\$1data\$1in\$1leaf | Quantité minimale de données dans une feuille. Peut être utilisée pour traiter le surajustement. Valeurs valides : nombre, plage : nombre entier non négatif. Valeur par défaut : `3`. |
| max\$1delta\$1step | Utilisé pour limiter le nombre maximal de feuilles d'arborescence obtenues en sortie. Si `max_delta_step` est inférieur ou égal à 0, il n'y a pas de contrainte. Le nombre maximal de feuilles obtenues en sortie est `learning_rate * max_delta_step`. Valeurs valides : valeur flottante. Valeur par défaut : `0.0`. |
| lambda\$1l1 | Régularisation L1. Valeurs valides : valeur à virgule flottante, plage : valeur à virgule flottante non négative. Valeur par défaut : `0.0`. |
| lambda\$1l2 | Régularisation L2. Valeurs valides : valeur à virgule flottante, plage : valeur à virgule flottante non négative. Valeur par défaut : `0.0`. |
| boosting | Type de renforcement Valeurs valides : chaîne, l'une des valeurs suivantes : (`"gbdt"`, `"rf"`, `"dart"` ou `"goss"`). Valeur par défaut : `"gbdt"`. |
| min\$1gain\$1to\$1split | Gain minimal pour effectuer une division. Peut être utilisé pour accélérer l'entraînement. Valeurs valides : entier, valeur à virgule flottante : valeur à virgule flottante non négative. Valeur par défaut : `0.0`. |
| scale\$1pos\$1weight | Pondération des étiquettes avec une classe positive. Utilisé uniquement pour les tâches de classification binaire. `scale_pos_weight` ne peut pas être utilisé si `is_unbalance` a pour valeur `"True"`. Valeurs valides : valeur à virgule flottante, plage : valeur à virgule flottante positive. Valeur par défaut : `1.0`. |
| tree\$1learner | Type d'apprenant d'arborescence. Valeurs valides : chaîne, l'une des valeurs suivantes : (`"serial"`, `"feature"`, `"data"` ou `"voting"`). Valeur par défaut : `"serial"`. |
| feature\$1fraction\$1bynode | Sélectionne un sous-ensemble de caractéristiques aléatoires sur chaque nœud de l'arborescence. Par exemple, si `feature_fraction_bynode` est `0.8`, 80 % des caractéristiques sont sélectionnées. Peut être utilisée pour traiter le surajustement. Valeurs valides : entier, plage : (`0.0`, `1.0`]. Valeur par défaut : `1.0`. |
| is\$1unbalance | Définissez sur `"True"` si les données d'entraînement ne sont pas équilibrées. Utilisé uniquement pour les tâches de classification binaire. `is_unbalance` ne peut pas être utilisé avec `scale_pos_weight`. Valeurs valides : chaîne, valeur : (`"True"` ou `"False"`). Valeur par défaut : `"False"`. |
| max\$1bin | Nombre maximal de casiers utilisés pour regrouper les valeurs des caractéristiques. Un petit nombre de casiers peut réduire la précision de l'entraînement, mais peut améliorer les performances générales. Peut être utilisée pour traiter le surajustement. Valeurs valides : entier, plage : (1, ∞). Valeur par défaut : `255`. |
| tweedie\$1variance\$1power | Contrôle la variance de la distribution Tweedie. Définissez-le plus près de `2.0` pour passer à une distribution Gamma. Définissez-le plus près de `1.0` pour passer à une distribution de Poisson. Utilisé uniquement pour les tâches de régression. Valeurs valides : valeur à virgule flottante, plage : [`1.0`, `2.0`). Valeur par défaut : `1.5`. |
| num\$1threads | Nombre de threads parallèles utilisés pour exécuter LightGBM. La valeur 0 signifie le nombre de threads par défaut dans OpenMP. Valeurs valides : nombre, plage : nombre entier non négatif. Valeur par défaut : `0`. |
| verbosity | Niveau de détail des messages d'impression. Si `verbosity` est inférieur à `0`, les messages d'impression montrent uniquement les erreurs fatales. Si `verbosity` a pour valeur `0`, les messages d'impression incluent les erreurs et les avertissements. Si `verbosity` a pour valeur `1`, les messages d'impression affichent plus d'informations. Si `verbosity` est supérieur à `1`, les messages d'impression affichent le plus d'informations et peuvent être utilisés pour le débogage. Valeurs valides : entier Valeur par défaut : `1`. |
# Réglage d'un modèle LightGBM
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. Le réglage du modèle se concentre sur les hyperparamètres suivants :
**Note**
La fonction objective d'apprentissage est attribuée automatiquement en fonction du type de la tâche de classification, qui est déterminé par le nombre d'entiers uniques dans la colonne d'étiquette. Pour de plus amples informations, veuillez consulter [Hyperparamètres de LightGBM](lightgbm-hyperparameters.md).
+ une fonction objective d'apprentissage à optimiser pendant l'entraînement du modèle ;
+ une métrique d'évaluation utilisée pour évaluer les performances du modèle lors de la validation ;
+ un jeu d'hyperparamètres et une plage de valeurs pour chacun d'eux, à utiliser lors du réglage automatique du modèle.
Le réglage de modèle automatique recherche dans les hyperparamètres que vous avez spécifiés la combinaison de valeurs qui produira un modèle permettant d'optimiser la métrique d'évaluation choisie.
**Note**
Le réglage automatique des modèles pour LightGBM n'est disponible que sur Amazon SageMaker SDKs, et non sur la console SageMaker AI.
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 d'évaluation calculées par l'algorithme LightGBM
L'algorithme SageMaker AI LightGBM calcule les métriques suivantes à utiliser pour la validation du modèle. La métrique d'évaluation est attribuée automatiquement en fonction du type de tâche de classification, qui est déterminé par le nombre d'entiers uniques dans la colonne d'étiquettes.
| Nom de la métrique | Description | Orientation de l'optimisation | Motif Regex |
| --- | --- | --- | --- |
| rmse | racine carrée de l'erreur quadratique moyenne | réduire | "rmse: ([0-9\$1\$1.]\$1)" |
| l1 | erreur absolue moyenne | réduire | "l1: ([0-9\$1\$1.]\$1)" |
| l2 | erreur quadratique moyenne | réduire | "l2: ([0-9\$1\$1.]\$1)" |
| huber | perte Huber | réduire | "huber: ([0-9\$1\$1.]\$1)" |
| fair | perte équitable | réduire | "fair: ([0-9\$1\$1.]\$1)" |
| binary\$1logloss | entropie croisée binaire | agrandir | "binary\$1logloss: ([0-9\$1\$1.]\$1)" |
| binary\$1error | erreur binaire | réduire | "binary\$1error: ([0-9\$1\$1.]\$1)" |
| auc | AUC | agrandir | "auc: ([0-9\$1\$1.]\$1)" |
| average\$1precision | score de précision moyenne | agrandir | "average\$1precision: ([0-9\$1\$1.]\$1)" |
| multi\$1logloss | entropie croisée multi-classes | agrandir | "multi\$1logloss: ([0-9\$1\$1.]\$1)" |
| multi\$1error | score d'erreur multiclasse | réduire | "multi\$1error: ([0-9\$1\$1.]\$1)" |
| auc\$1mu | AUC-mu | agrandir | "auc\$1mu: ([0-9\$1\$1.]\$1)" |
| cross\$1entropy | entropie croisée | réduire | "cross\$1entropy: ([0-9\$1\$1.]\$1)" |
## Hyperparamètres réglables de LightGBM
Réglez le modèle LightGBM avec les hyperparamètres suivants. Les hyperparamètres ayant le plus d'impact sur l'optimisation des métriques d'évaluation de CatBoost sont : `learning_rate`, `num_leaves`, `feature_fraction`, `bagging_fraction`, `bagging_freq`, `max_depth` et `min_data_in_leaf`. Pour obtenir la liste de tous les hyperparamètres de LightGBM, consultez [Hyperparamètres de LightGBM](lightgbm-hyperparameters.md).
| Nom du paramètre | Type de paramètre | Plages recommandées |
| --- | --- | --- |
| learning\$1rate | ContinuousParameterRanges | MinValue: 0,001, MaxValue 0,01 |
| num\$1leaves | IntegerParameterRanges | MinValue: 10, MaxValue 10 |
| feature\$1fraction | ContinuousParameterRanges | MinValue: 0,1, MaxValue 1,0 |
| bagging\$1fraction | ContinuousParameterRanges | MinValue: 0,1, MaxValue 1,0 |
| bagging\$1freq | IntegerParameterRanges | MinValue: 0, MaxValue 10 |
| max\$1depth | IntegerParameterRanges | MinValue: 15, MaxValue 100 |
| min\$1data\$1in\$1leaf | IntegerParameterRanges | MinValue: 10, MaxValue 20 |