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.
# Compilateur SageMaker de formation Amazon
**Important**
Amazon Web Services (AWS) annonce qu'il n'y aura aucune nouvelle version ou version de SageMaker Training Compiler. Vous pouvez continuer à utiliser SageMaker Training Compiler via les AWS Deep Learning Containers (DLCs) for SageMaker Training existants. Il est important de noter que tant que les versions existantes DLCs resteront accessibles, elles ne recevront plus de correctifs ni de mises à jour AWS, conformément à la [politique de support du AWS Deep Learning Containers Framework](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html).
Utilisez Amazon SageMaker Training Compiler pour entraîner des modèles d'apprentissage profond (DL) plus rapidement sur des instances de GPU évolutives gérées par l' SageMaker IA.
## Qu'est-ce que SageMaker Training Compiler ?
State-of-the-art les modèles d'apprentissage profond (DL) sont constitués de réseaux neuronaux multicouches complexes comportant des milliards de paramètres dont l'entraînement peut prendre des milliers d'heures de GPU. L’optimisation de tels modèles sur l’infrastructure d’entraînement nécessite une connaissance approfondie de la DL et de l’ingénierie des systèmes. Cela relève même du défi pour certains cas d’utilisation. Bien qu’il existe des implémentations open source de compilateurs qui optimisent le processus d’entraînement DL, ils peuvent manquer de flexibilité pour intégrer les cadres DL avec certains matériels tels que les instances GPU.
SageMaker Le compilateur d'entraînement est une fonctionnalité de l' SageMaker IA qui effectue ces hard-to-implement optimisations afin de réduire le temps d'entraînement sur les instances GPU. Le compilateur optimise les modèles DL pour accélérer l'entraînement en utilisant plus efficacement les instances de GPU d'apprentissage automatique (ML) basées sur l' SageMaker IA. SageMaker Le compilateur de formation est disponible sans frais supplémentaires dans SageMaker AI et peut aider à réduire le temps total facturable en accélérant la formation.
![\[Schéma conceptuel du fonctionnement de SageMaker Training Compiler avec SageMaker l'IA.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/training-compiler-marketing-diagram.png)
SageMaker Training Compiler est intégré aux AWS Deep Learning Containers (DLCs). À l'aide du compilateur d' SageMaker entraînement activé AWS DLCs, vous pouvez compiler et optimiser les tâches d'entraînement sur des instances de GPU en modifiant le moins possible votre code. Intégrez vos modèles d'apprentissage profond à l' SageMaker IA et permettez à SageMaker Training Compiler d'accélérer votre travail de formation sur des instances SageMaker AI ML pour accélérer le calcul.
## Comment ça marche
SageMaker Training Compiler convertit les modèles DL de leur représentation linguistique de haut niveau en instructions optimisées pour le matériel. Plus précisément, SageMaker Training Compiler applique des optimisations au niveau du graphe, des optimisations au niveau du flux de données et des optimisations du backend pour produire un modèle optimisé qui utilise efficacement les ressources matérielles. Par conséquent, vous pouvez entraîner vos modèles plus rapidement que lorsque vous les entraînez sans compilation.
Il s'agit d'un processus en deux étapes pour activer SageMaker Training Compiler pour votre tâche de formation :
1. Apportez votre propre script DL et, si nécessaire, adaptez-le pour compiler et entraîner avec SageMaker Training Compiler. Pour en savoir plus, veuillez consulter la section [Apporter votre propre modèle de deep learning](training-compiler-modify-scripts.md).
1. Créez un objet estimateur SageMaker AI avec le paramètre de configuration du compilateur à l'aide du SDK SageMaker Python.
1. Activez le compilateur d' SageMaker entraînement en l'ajoutant `compiler_config=TrainingCompilerConfig()` à la classe d'estimateur SageMaker AI.
1. Ajustez les hyperparamètres (`batch_size`et`learning_rate`) pour optimiser les avantages fournis par SageMaker Training Compiler.
La compilation via SageMaker Training Compiler modifie l'empreinte mémoire du modèle. Le plus souvent, cela se traduit par une réduction de l’utilisation de la mémoire et par une augmentation consécutive de la plus grande taille de lot pouvant être stockée sur le GPU. Dans certains cas, le compilateur favorise intelligemment la mise en cache, ce qui entraîne une diminution de la plus grande taille de lot pouvant être stockée sur le GPU. Notez que si vous souhaitez modifier la taille du lot, vous devez ajuster le taux d’entraînement de manière appropriée.
Pour connaître une référence de test de `batch_size` pour les modèles les plus populaires, consultez [Modèles testés](training-compiler-support.md#training-compiler-tested-models).
Lorsque vous ajustez la taille du lot, vous devez également ajuster le`learning_rate` de manière appropriée. Pour connaître les bonnes pratiques d’ajustement du taux d’apprentissage en fonction de la modification de la taille du lot, consultez [SageMaker Bonnes pratiques et considérations relatives à la formation des compilateurs](training-compiler-tips-pitfalls.md).
1. En exécutant la méthode `estimator.fit()` de classe, l' SageMaker IA compile votre modèle et lance le travail de formation.
Pour savoir comment lancer une tâche d’entraînement, consultez [Activer le compilateur SageMaker d'entraînement](training-compiler-enable.md).
SageMaker Training Compiler ne modifie pas le modèle entraîné final, tout en vous permettant d'accélérer le travail d'entraînement en utilisant plus efficacement la mémoire du GPU et en adaptant une taille de lot plus importante par itération. Le modèle entraîné final de la tâche d’entraînement accélérée par le compilateur est identique à celui de la tâche d’entraînement ordinaire.
**Astuce**
SageMaker Training Compiler compile uniquement les modèles DL pour l'entraînement sur des [instances GPU prises en charge](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-support.html#training-compiler-supported-instance-types) et gérées par l' SageMaker IA. Pour compiler votre modèle à des fins d'inférence et le déployer pour qu'il s'exécute n'importe où dans le cloud et à la périphérie, utilisez le [compilateur SageMaker Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).
**Topics**
+ [Qu'est-ce que SageMaker Training Compiler ?](#training-compiler-what-is)
+ [Comment ça marche](#training-compiler-how-it-works)
+ [Frameworks Régions AWS, types d'instances et modèles testés pris en charge](training-compiler-support.md)
+ [Apporter votre propre modèle de deep learning](training-compiler-modify-scripts.md)
+ [Activer le compilateur SageMaker d'entraînement](training-compiler-enable.md)
+ [SageMaker Compilateur de formation : exemples de blocs-notes et de blogs](training-compiler-examples-and-blogs.md)
+ [SageMaker Bonnes pratiques et considérations relatives à la formation des compilateurs](training-compiler-tips-pitfalls.md)
+ [SageMaker FAQ sur le compilateur de formation](training-compiler-faq.md)
+ [SageMaker Résolution des problèmes liés au compilateur](training-compiler-troubleshooting.md)
+ [Notes de mise à jour SageMaker d'Amazon Training Compiler](training-compiler-release-notes.md)
# Frameworks Régions AWS, types d'instances et modèles testés pris en charge
**Important**
Amazon Web Services (AWS) annonce qu'il n'y aura aucune nouvelle version ou version de SageMaker Training Compiler. Vous pouvez continuer à utiliser SageMaker Training Compiler via les AWS Deep Learning Containers (DLCs) for SageMaker Training existants. Il est important de noter que tant que les versions existantes DLCs resteront accessibles, elles ne recevront plus de correctifs ni de mises à jour AWS, conformément à la [politique de support du AWS Deep Learning Containers Framework](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html).
Avant d'utiliser SageMaker Training Compiler, vérifiez si le framework de votre choix est pris en charge, si les types d'instances sont disponibles dans votre AWS compte et si votre AWS compte est dans l'un des frameworks pris en charge Régions AWS.
**Note**
SageMaker Le compilateur d'entraînement est disponible dans le SDK SageMaker Python v2.70.0 ou version ultérieure.
## Cadres pris en charge
SageMaker Training Compiler prend en charge les frameworks de deep learning suivants et est disponible via AWS Deep Learning Containers.
**Topics**
+ [PyTorch](#training-compiler-supported-frameworks-pytorch)
+ [TensorFlow](#training-compiler-supported-frameworks-tensorflow)
### PyTorch
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/training-compiler-support.html)
### TensorFlow
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/training-compiler-support.html)
Pour plus d'informations, consultez la section [Images disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) dans le * GitHub référentiel AWS Deep Learning Containers*.
## Régions AWS
Les [conteneurs SageMaker Training Compiler](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-training-compiler-containers) sont disponibles dans les régions Régions AWS où les [AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) sont en service, à l'exception de la Chine.
## Types d’instance pris en charge
SageMaker Training Compiler est testé et prend en charge les types d'instances ML suivants.
+ Instances P4
+ instances P3
+ instances G4dn
+ Instances G5
Pour les spécifications des types d’instances, consultez la section **Calcul accéléré** sur la page [Types d’instances Amazon EC2](https://aws.amazon.com/ec2/instance-types/). Pour plus d'informations sur la tarification des instances, consultez [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).
Si vous avez rencontré un message d'erreur similaire au suivant, suivez les instructions de la section [Demander une augmentation du quota de service pour les ressources d' SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html#service-limit-increase-request-procedure).
```
ResourceLimitExceeded: An error occurred (ResourceLimitExceeded) when calling
the CreateTrainingJob operation: The account-level service limit 'ml.p3dn.24xlarge
for training job usage' is 0 Instances, with current utilization of 0 Instances
and a request delta of 1 Instances.
Please contact AWS support to request an increase for this limit.
```
## Modèles testés
Le tableau suivant inclut une liste des modèles qui ont été testés avec SageMaker Training Compiler. À titre de référence, la plus grande taille de lot capable de tenir en mémoire est également incluse aux côtés d'autres paramètres d'entraînement. SageMaker Le compilateur d'entraînement peut modifier l'empreinte mémoire du processus d'apprentissage du modèle ; par conséquent, une taille de lot plus importante peut souvent être utilisée pendant le processus d'apprentissage, ce qui réduit encore le temps total d'entraînement. Dans certains cas, SageMaker Training Compiler favorise intelligemment la mise en cache, ce qui entraîne une diminution de la plus grande taille de lot pouvant être installée sur le GPU. Vous devez réajuster les hyperparamètres de votre modèle et trouver la taille de lot optimale pour votre cas. Pour gagner du temps, utilisez les tableaux de référence suivants pour rechercher une taille de lot qui peut constituer un bon point de départ pour votre cas d’utilisation.
**Note**
Les tailles de lots sont des tailles de lots locales qui s’adaptent à chaque GPU individuel dans le type d’instance respectif. Vous devez également ajuster le taux d’apprentissage lorsque vous modifiez la taille du lot.
### PyTorch 1.13.1
**Modèles de traitement du langage naturel (NLP)**
Les modèles suivants sont testés pour les tâches d’entraînement pour toutes les combinaisons de nœuds uniques et multiples avec un ou plusieurs cœurs GPU et une précision mixte automatique (AMP), comme indiqué.
| GPU node/multi-node single-GPU/multi unique | Modèle | Jeu de données | Type d’instance | Précision | Durée de la séquence | Taille du lot pour les frameworks natifs | Taille du lot pour SageMaker Training Compiler |
| --- | --- | --- | --- | --- | --- | --- | --- |
| albert-base-v2 | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 128 | 80 | 192 |
| albert-base-v2 | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 128 | 332 |
| albert-base-v2 | wikitext-2-raw-v1 | p3.2xlarge | float16 | 128 | 80 | 224 |
| bert-base-uncased | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 160 | 288 |
| camembert-base | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 160 | 280 |
| distilbert-base-uncased | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 240 | 472 |
| distilgpt2 | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 128 | 77 | 128 |
| distilgpt2 | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 138 | 390 |
| distilgpt2 | wikitext-2-raw-v1 | p3.2xlarge | float16 | 128 | 96 | 256 |
| distilroberta-base | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 128 | 96 | 192 |
| distilroberta-base | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 171 | 380 |
| distilroberta-base | wikitext-2-raw-v1 | p3.2xlarge | float16 | 128 | 112 | 256 |
| gpt2 | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 128 | 52 | 152 |
| gpt2 | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 84 | 240 |
| gpt2 | wikitext-2-raw-v1 | p3.2xlarge | float16 | 128 | 58 | 164 |
| microsoft/deberta-base | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 128 | 48 | 128 |
| microsoft/deberta-base | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 84 | 207 |
| microsoft/deberta-base | wikitext-2-raw-v1 | p3.2xlarge | float16 | 128 | 53 | 133 |
| roberta-base | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 125 | 224 |
| xlm-roberta-base | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 128 | 16 | 31 |
| xlm-roberta-base | wikitext-2-raw-v1 | p3.2xlarge | float16 | 128 | 18 | 50 |
| xlnet-base-cased | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 128 | 240 |
| bert-base-uncased | wikitext-103-v1 | g5.48xlarge | float16 | 512 | 29 | 50 |
| distilbert-base-uncased | wikitext-103-v1 | g5.48xlarge | float16 | 512 | 45 | 64 |
| gpt2 | wikitext-103-v1 | g5.48xlarge | float16 | 512 | 18 | 45 |
| roberta-base | wikitext-103-v1 | g5.48xlarge | float16 | 512 | 23 | 44 |
| gpt2 | wikitext-103-v1 | p4d.24xlarge | float16 | 512 | 36 | 64 |
**Modèles de vision par ordinateur (CV)**
Testé avec [TensorFlowModel Garden](https://github.com/tensorflow/models) avec Automatic Mixed Precision (AMP) comme indiqué.
| Single/multi-node single/multi-GPU | Modèle | Jeu de données | Type d’instance | Précision | Taille du lot pour les frameworks natifs | Taille du lot pour SageMaker Training Compiler |
| --- | --- | --- | --- | --- | --- | --- |
| ResNet152 | food101 | g4dn.16xlarge | float16 | 128 | 144 |
| ResNet152 | food101 | g5.4xlarge | float16 | 128 | 192 |
| ResNet152 | food101 | p3.2xlarge | float16 | 152 | 156 |
| ViT | food101 | g4dn.16xlarge | float16 | 512 | 512 |
| ViT | food101 | g5.4xlarge | float16 | 992 | 768 |
| ViT | food101 | p3.2xlarge | float16 | 848 | 768 |
### PyTorch 1,12,0
**Modèles de traitement du langage naturel (NLP)**
Les modèles suivants sont testés pour les tâches d’entraînement pour toutes les combinaisons de nœuds uniques et multiples avec un ou plusieurs cœurs GPU et une précision mixte automatique (AMP), comme indiqué.
| GPU node/multi-node single-GPU/multi unique | Modèle | Jeu de données | Type d’instance | Précision | Durée de la séquence | Taille du lot pour les frameworks natifs | Taille du lot pour SageMaker Training Compiler |
| --- | --- | --- | --- | --- | --- | --- | --- |
| albert-base-v2 | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 128 | 128 | 248 |
| bert-base-uncased | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 128 | 160 | 288 |
| camembert-base | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 128 | 160 | 279 |
| camembert-base | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 128 | 105 | 164 |
| distilgpt2 | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 128 | 136 | 256 |
| distilgpt2 | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 128 | 80 | 118 |
| gpt2 | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 128 | 84 | 240 |
| gpt2 | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 128 | 80 | 119 |
| microsoft/deberta-base | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 128 | 93 | 197 |
| microsoft/deberta-base | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 128 | 113 | 130 |
| roberta-base | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 128 | 125 | 224 |
| roberta-base | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 128 | 78 | 112 |
| xlnet-base-cased | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 128 | 138 | 240 |
| bert-base-uncased | wikitext-103-v1 | ml.p4d.24xlarge | float16 | 512 | | 52 |
| distilbert-base-uncased | wikitext-103-v1 | ml.p4d.24xlarge | float16 | 512 | | 160 |
| gpt2 | wikitext-103-v1 | ml.p4d.24xlarge | float16 | 512 | | 25 |
| roberta-base | wikitext-103-v1 | ml.p4d.24xlarge | float16 | 512 | | 64 |
### TensorFlow 2,11.0
**Modèles de vision par ordinateur (CV)**
Testé avec [TensorFlowModel Garden](https://github.com/tensorflow/models) avec Automatic Mixed Precision (AMP) comme indiqué.
| Single/multi-node single/multi-GPU | Modèle | Jeu de données | Type d’instance | Précision | Taille du lot pour les frameworks natifs | Taille du lot pour SageMaker Training Compiler |
| --- | --- | --- | --- | --- | --- | --- |
| Masque RCNN- 50-FPN ResNet | COCO-2017 | ml.g5.2xlarge | float16 | 6 | 8 |
| Masque RCNN- 50-FPN ResNet | COCO-2017 | ml.p3.2xlarge | float16 | 4 | 6 |
| ResNet50 | ImageNet | ml.g5.2xlarge | float16 | 192 | 256 |
| ResNet50 | ImageNet | ml.p3.2xlarge | float16 | 256 | 256 |
| ResNet101 | ImageNet | ml.g5.2xlarge | float16 | 128 | 256 |
| ResNet101 | ImageNet | ml.p3.2xlarge | float16 | 128 | 128 |
| ResNet152 | ImageNet | ml.g5.2xlarge | float16 | 128 | 224 |
| ResNet152 | ImageNet | ml.p3.2xlarge | float16 | 128 | 128 |
| VisionTransformer | ImageNet | ml.g5.2xlarge | float16 | 112 | 144 |
| VisionTransformer | ImageNet | ml.p3.2xlarge | float16 | 96 | 128 |
**Modèles de traitement du langage naturel (NLP)**
Testé avec des [modèles de transformeur](https://github.com/huggingface/transformers) avec `Sequence_Len=128` et l’option Automatic Mixed Precision (AMP) comme indiqué.
| Single/multi-node single/multi-GPU | Modèle | Jeu de données | Type d’instance | Précision | Taille du lot pour les frameworks natifs | Taille du lot pour SageMaker Training Compiler |
| --- | --- | --- | --- | --- | --- | --- |
| albert-base-v2 | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 160 | 197 |
| albert-base-v2 | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 95 | 127 |
| bert-base-uncased | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 160 | 128 |
| bert-base-uncased | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 104 | 111 |
| bert-large-uncased | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 65 | 48 |
| bert-large-uncased | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 40 | 35 |
| camembert-base | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 128 | 162 |
| camembert-base | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 105 | 111 |
| distilbert-base-uncased | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 256 | 264 |
| distilbert-base-uncased | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 128 | 169 |
| gpt2 | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 128 | 120 |
| gpt2 | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 80 | 83 |
| jplu/ tf-xlm-roberta-base | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 32 | 32 |
| jplu/ tf-xlm-roberta-base | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 32 | 36 |
| microsoft/mpnet-base | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 144 | 160 |
| microsoft/mpnet-base | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 106 | 110 |
| roberta-base | wikitext-2-raw-v1 | ml.g5.2xlarge | float16 | 128 | 128 |
| roberta-base | wikitext-2-raw-v1 | ml.p3.2xlarge | float16 | 72 | 98 |
| albert-base-v2 | wikitext-2-raw-v1 | ml.g5.48xlarge | float16 | 128 | 192 |
| albert-base-v2 | wikitext-2-raw-v1 | ml.p3.16xlarge | float16 | 95 | 96 |
| distilbert-base-uncased | wikitext-2-raw-v1 | ml.g5.48xlarge | float16 | 256 | 256 |
| distilbert-base-uncased | wikitext-2-raw-v1 | ml.p3.16xlarge | float16 | 140 | 184 |
| google/ electra-small-discriminator | wikitext-2-raw-v1 | ml.g5.48xlarge | float16 | 256 | 384 |
| google/ electra-small-discriminator | wikitext-2-raw-v1 | ml.p3.16xlarge | float16 | 256 | 268 |
| gpt2 | wikitext-2-raw-v1 | ml.g5.48xlarge | float16 | 116 | 116 |
| gpt2 | wikitext-2-raw-v1 | ml.p3.16xlarge | float16 | 85 | 83 |
| gpt2 | wikitext-2-raw-v1 | ml.p4d.24xlarge | float16 | 94 | 110 |
| microsoft/mpnet-base | wikitext-2-raw-v1 | ml.g5.48xlarge | float16 | 187 | 164 |
| microsoft/mpnet-base | wikitext-2-raw-v1 | ml.p3.16xlarge | float16 | 106 | 111 |
### TensorFlow 2,1,0
**Modèles de vision par ordinateur (CV)**
Testé avec [TensorFlowModel Garden](https://github.com/tensorflow/models) avec Automatic Mixed Precision (AMP) comme indiqué.
| GPU unique à un seul nœud/multi-GPU | Modèle | Jeu de données | Type d’instance | Précision | Taille du lot pour les frameworks natifs | Taille du lot pour SageMaker Training Compiler |
| --- | --- | --- | --- | --- | --- | --- |
| DetectionTransformer- ResNet 50 | COCO-2017 | ml.g4dn.2xlarge | float32 | 2 | 4 |
| DetectionTransformer- ResNet 50 | COCO-2017 | ml.g5.2xlarge | float32 | 3 | 6 |
| DetectionTransformer- ResNet 50 | COCO-2017 | ml.p3.2xlarge | float32 | 2 | 4 |
| Masque RCNN- 50-FPN ResNet | COCO-2017 | ml.g4dn.2xlarge | float16 | 4 | 6 |
| Masque RCNN- 50-FPN ResNet | COCO-2017 | ml.g5.2xlarge | float16 | 6 | 8 |
| Masque RCNN- 50-FPN ResNet | COCO-2017 | ml.g5.48xlarge | float16 | 48 | 64 |
| Masque RCNN- 50-FPN ResNet | COCO-2017 | ml.p3.2xlarge | float16 | 4 | 6 |
| ResNet50 | ImageNet | ml.g4dn.2xlarge | float16 | 224 | 256 |
| ResNet50 | ImageNet | ml.g5.2xlarge | float16 | 192 | 160 |
| ResNet50 | ImageNet | ml.g5.48xlarge | float16 | 2048 | 2048 |
| ResNet50 | ImageNet | ml.p3.2xlarge | float16 | 224 | 160 |
| ResNet101 | ImageNet | ml.g4dn.2xlarge | float16 | 160 | 128 |
| ResNet101 | ImageNet | ml.g5.2xlarge | float16 | 192 | 256 |
| ResNet101 | ImageNet | ml.g5.48xlarge | float16 | 2048 | 2048 |
| ResNet101 | ImageNet | ml.p3.2xlarge | float16 | 160 | 224 |
| ResNet152 | ImageNet | ml.g4dn.2xlarge | float16 | 128 | 128 |
| ResNet152 | ImageNet | ml.g5.2xlarge | float16 | 192 | 224 |
| ResNet152 | ImageNet | ml.g5.48xlarge | float16 | 1536 | 1792 |
| ResNet152 | ImageNet | ml.p3.2xlarge | float16 | 128 | 160 |
| VisionTransformer | ImageNet | ml.g4dn.2xlarge | float16 | 80 | 128 |
| VisionTransformer | ImageNet | ml.g5.2xlarge | float16 | 112 | 144 |
| VisionTransformer | ImageNet | ml.g5.48xlarge | float16 | 896 | 1 152 |
| VisionTransformer | ImageNet | ml.p3.2xlarge | float16 | 80 | 128 |
**Modèles de traitement du langage naturel (NLP)**
Testé avec des [modèles de transformeur](https://github.com/huggingface/transformers) avec `Sequence_Len=128` et l’option Automatic Mixed Precision (AMP) comme indiqué.
| GPU unique à un seul nœud/multi-GPU | Modèle | Jeu de données | Type d’instance | Précision | Taille du lot pour les frameworks natifs | Taille du lot pour SageMaker Training Compiler |
| --- | --- | --- | --- | --- | --- | --- |
| albert-base-v2 | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 128 | 112 |
| albert-base-v2 | wikitext-2-raw-v1 | p3.2xlarge | float16 | 128 | 128 |
| albert-base-v2 | wikitext-2-raw-v1 | p3.8xlarge | float16 | 128 | 135 |
| albert-base-v2 | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 191 |
| bert-base-uncased | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 64 | 94 |
| bert-base-uncased | wikitext-2-raw-v1 | p3.2xlarge | float16 | 96 | 101 |
| bert-base-uncased | wikitext-2-raw-v1 | p3.8xlarge | float16 | 96 | 96 |
| bert-base-uncased | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 128 |
| bert-large-uncased | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 35 | 21 |
| bert-large-uncased | wikitext-2-raw-v1 | p3.2xlarge | float16 | 39 | 26 |
| bert-large-uncased | wikitext-2-raw-v1 | g5.4xlarge | float16 | 60 | 50 |
| camembert-base | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 96 | 90 |
| camembert-base | wikitext-2-raw-v1 | p3.2xlarge | float16 | 96 | 98 |
| camembert-base | wikitext-2-raw-v1 | p3.8xlarge | float16 | 96 | 96 |
| camembert-base | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 128 |
| distilbert-base-uncased | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 256 | 160 |
| distilbert-base-uncased | wikitext-2-raw-v1 | p3.2xlarge | float16 | 128 | 176 |
| distilbert-base-uncased | wikitext-2-raw-v1 | p3.8xlarge | float16 | 128 | 160 |
| distilbert-base-uncased | wikitext-2-raw-v1 | g5.4xlarge | float16 | 256 | 258 |
| google\$1 electra-small-discriminator | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 256 | 216 |
| google\$1 electra-small-discriminator | wikitext-2-raw-v1 | p3.2xlarge | float16 | 256 | 230 |
| google\$1 electra-small-discriminator | wikitext-2-raw-v1 | p3.8xlarge | float16 | 256 | 224 |
| google\$1 electra-small-discriminator | wikitext-2-raw-v1 | g5.4xlarge | float16 | 256 | 320 |
| gpt2 | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 80 | 64 |
| gpt2 | wikitext-2-raw-v1 | p3.2xlarge | float16 | 80 | 77 |
| gpt2 | wikitext-2-raw-v1 | p3.8xlarge | float16 | 80 | 72 |
| gpt2 | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 120 |
| jplu\$1 tf-xlm-roberta-base | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 28 | 24 |
| jplu\$1 tf-xlm-roberta-base | wikitext-2-raw-v1 | p3.2xlarge | float16 | 32 | 24 |
| jplu\$1 tf-xlm-roberta-base | wikitext-2-raw-v1 | p3.8xlarge | float16 | 32 | 26 |
| jplu\$1 tf-xlm-roberta-base | wikitext-2-raw-v1 | g5.4xlarge | float16 | 66 | 52 |
| microsoft\$1mpnet-base | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 96 | 92 |
| microsoft\$1mpnet-base | wikitext-2-raw-v1 | p3.2xlarge | float16 | 96 | 101 |
| microsoft\$1mpnet-base | wikitext-2-raw-v1 | p3.8xlarge | float16 | 96 | 101 |
| microsoft\$1mpnet-base | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 152 |
| roberta-base | wikitext-2-raw-v1 | g4dn.16xlarge | float16 | 64 | 72 |
| roberta-base | wikitext-2-raw-v1 | p3.2xlarge | float16 | 64 | 84 |
| roberta-base | wikitext-2-raw-v1 | p3.8xlarge | float16 | 64 | 86 |
| roberta-base | wikitext-2-raw-v1 | g5.4xlarge | float16 | 128 | 128 |
### TensorFlow 2.9.1
Testé avec [TensorFlowModel Garden](https://github.com/tensorflow/models) avec Automatic Mixed Precision (AMP).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/training-compiler-support.html)
\$1 Les tailles de lot marquées d'un astérisque (\$1) indiquent la plus grande taille de lot testée par l'équipe de développement de SageMaker Training Compiler. Pour les cellules marquées, l’instance peut éventuellement s’adapter à une taille de lot supérieure à celle indiquée.
### Transformers 4.21.1 avec 1.11.0 PyTorch
Testé avec `Sequence_Len=512` et l’option Automatic Mixed Precision (AMP).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/training-compiler-support.html)
### Transformers 4.17.0 avec 1.10.2 PyTorch
Testé avec `Sequence_Len=512` et l’option Automatic Mixed Precision (AMP).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/training-compiler-support.html)
### Transformers 4.11.0 avec 1.9.0 PyTorch
Testé avec `Sequence_Len=512` et l’option Automatic Mixed Precision (AMP).
| GPU à un seul nœud | Modèle | Type d’instance | Taille de lot pour natif | Taille du lot pour Training Compiler |
| --- | --- | --- | --- | --- |
| albert-base-v2 | ml.p3.2xlarge | 12 | 32 |
| bert-base-cased | ml.p3.2xlarge | 14 | 24 |
| bert-base-chinese | ml.p3.2xlarge | 16 | 24 |
| bert-base-multilingual-cased | ml.p3.2xlarge | 4 | 16 |
| bert-base-multilingual-uncased | ml.p3.2xlarge | 8 | 16 |
| bert-base-uncased | ml.p3.2xlarge | 12 | 24 |
| cl-tohoku/ -masquage de mots bert-base-japanese-whole | ml.p3.2xlarge | 12 | 24 |
| cl-tohoku/ bert-base-japanese | ml.p3.2xlarge | 12 | 24 |
| distilbert-base-uncased | ml.p3.2xlarge | 28 | 32 |
| distilbert-base-uncased-finetuned-sst-2-anglais | ml.p3.2xlarge | 28 | 32 |
| distilgpt2 | ml.p3.2xlarge | 16 | 32 |
| facebook/bart-base | ml.p3.2xlarge | 4 | 8 |
| gpt2 | ml.p3.2xlarge | 6 | 20 |
| Niemers/Mini -L6-H384- LMv2 distilled-from-RoBERTa-Large | ml.p3.2xlarge | 20 | 32 |
| roberta-base | ml.p3.2xlarge | 12 | 20 |
| Multi-GPU à nœud unique | Modèle | Type d’instance | Taille de lot pour natif | Taille du lot pour Training Compiler |
| --- | --- | --- | --- | --- |
| bert-base-chinese | ml.p3.8xlarge | 16 | 26 |
| bert-base-multilingual-cased | ml.p3.8xlarge | 6 | 16 |
| bert-base-multilingual-uncased | ml.p3.8xlarge | 6 | 16 |
| bert-base-uncased | ml.p3.8xlarge | 14 | 24 |
| distilbert-base-uncased | ml.p3.8xlarge | 14 | 32 |
| distilgpt2 | ml.p3.8xlarge | 6 | 32 |
| facebook/bart-base | ml.p3.8xlarge | 8 | 16 |
| gpt2 | ml.p3.8xlarge | 8 | 20 |
| roberta-base | ml.p3.8xlarge | 12 | 20 |
### Transformers 4.17.0 avec 2.6.3 TensorFlow
Testé avec `Sequence_Len=128` et l'option Automatic Mixed Precision (AMP).
| Modèle | Type d’instance | Taille du lot pour les frameworks natifs | Taille du lot pour Training Compiler |
| --- | --- | --- | --- |
| albert-base-v2 | ml.g4dn.16xlarge | 136 | 208 |
| albert-base-v2 | ml.g5.4xlarge | 219 | 312 |
| albert-base-v2 | ml.p3.2xlarge | 152 | 208 |
| albert-base-v2 | ml.p3.8xlarge | 152 | 192 |
| bert-base-uncased | ml.g4dn.16xlarge | 120 | 101 |
| bert-base-uncased | ml.g5.4xlarge | 184 | 160 |
| bert-base-uncased | ml.p3.2xlarge | 128 | 108 |
| bert-large-uncased | ml.g4dn.16xlarge | 37 | 28 |
| bert-large-uncased | ml.g5.4xlarge | 64 | 55 |
| bert-large-uncased | ml.p3.2xlarge | 40 | 32 |
| camembert-base | ml.g4dn.16xlarge | 96 | 100 |
| camembert-base | ml.g5.4xlarge | 190 | 160 |
| camembert-base | ml.p3.2xlarge | 129 | 108 |
| camembert-base | ml.p3.8xlarge | 128 | 104 |
| distilbert-base-uncased | ml.g4dn.16xlarge | 210 | 160 |
| distilbert-base-uncased | ml.g5.4xlarge | 327 | 288 |
| distilbert-base-uncased | ml.p3.2xlarge | 224 | 196 |
| distilbert-base-uncased | ml.p3.8xlarge | 192 | 182 |
| google\$1 electra-small-discriminator | ml.g4dn.16xlarge | 336 | 288 |
| google\$1 electra-small-discriminator | ml.g5.4xlarge | 504 | 384 |
| google\$1 electra-small-discriminator | ml.p3.2xlarge | 352 | 323 |
| gpt2 | ml.g4dn.16xlarge | 89 | 64 |
| gpt2 | ml.g5.4xlarge | 140 | 146 |
| gpt2 | ml.p3.2xlarge | 94 | 96 |
| gpt2 | ml.p3.8xlarge | 96 | 88 |
| jplu\$1 tf-xlm-roberta-base | ml.g4dn.16xlarge | 52 | 16 |
| jplu\$1 tf-xlm-roberta-base | ml.g5.4xlarge | 64 | 44 |
| microsoft\$1mpnet-base | ml.g4dn.16xlarge | 120 | 100 |
| microsoft\$1mpnet-base | ml.g5.4xlarge | 192 | 160 |
| microsoft\$1mpnet-base | ml.p3.2xlarge | 128 | 104 |
| microsoft\$1mpnet-base | ml.p3.8xlarge | 130 | 92 |
| roberta-base | ml.g4dn.16xlarge | 108 | 64 |
| roberta-base | ml.g5.4xlarge | 176 | 142 |
| roberta-base | ml.p3.2xlarge | 118 | 100 |
| roberta-base | ml.p3.8xlarge | 112 | 88 |
### Transformers 4.11.0 avec 2.5.1 TensorFlow
Testé avec `Sequence_Len=128` et l’option Automatic Mixed Precision (AMP).
| GPU à un seul nœud | Modèle | Type d’instance | Taille de lot pour natif | Taille du lot pour Training Compiler |
| --- | --- | --- | --- | --- |
| albert-base-v2 | ml.p3.2xlarge | 128 | 128 |
| bart-base | ml.p3.2xlarge | 12 | 64 |
| bart-large | ml.p3.2xlarge | 4 | 28 |
| bert-base-cased | ml.p3.2xlarge | 16 | 128 |
| bert-base-chinese | ml.p3.2xlarge | 16 | 128 |
| bert-base-multilingual-cased | ml.p3.2xlarge | 12 | 64 |
| bert-base-multilingual-uncased | ml.p3.2xlarge | 16 | 96 |
| bert-base-uncased | ml.p3.2xlarge | 16 | 96 |
| bert-large-uncased | ml.p3.2xlarge | 4 | 24 |
| cl-tohoku/ bert-base-japanese | ml.p3.2xlarge | 16 | 128 |
| cl-tohoku/ -masquage de mots bert-base-japanese-whole | ml.p3.2xlarge | 16 | 128 |
| distilbert-base-sst2 | ml.p3.2xlarge | 32 | 128 |
| distilbert-base-uncased | ml.p3.2xlarge | 32 | 128 |
| distilgpt2 | ml.p3.2xlarge | 32 | 128 |
| gpt2 | ml.p3.2xlarge | 12 | 64 |
| gpt2-large | ml.p3.2xlarge | 2 | 24 |
| jplu/ tf-xlm-roberta-base | ml.p3.2xlarge | 12 | 32 |
| roberta-base | ml.p3.2xlarge | 4 | 64 |
| roberta-large | ml.p3.2xlarge | 4 | 64 |
| t5-base | ml.p3.2xlarge | 64 | 64 |
| t5-small | ml.p3.2xlarge | 128 | 128 |
# Apporter votre propre modèle de deep learning
**Important**
Amazon Web Services (AWS) annonce qu'il n'y aura aucune nouvelle version ou version de SageMaker Training Compiler. Vous pouvez continuer à utiliser SageMaker Training Compiler via les AWS Deep Learning Containers (DLCs) for SageMaker Training existants. Il est important de noter que tant que les versions existantes DLCs resteront accessibles, elles ne recevront plus de correctifs ni de mises à jour AWS, conformément à la [politique de support du AWS Deep Learning Containers Framework](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html).
Ce guide vous explique comment adapter votre script d’entraînement pour une tâche d’entraînement accélérée par le compilateur. La préparation de votre script d’entraînement dépend des éléments suivants :
+ Les paramètres d’entraînement tels que l’entraînement à cœur unique ou distribué.
+ Les cadres et les bibliothèques que vous utilisez pour créer le script d’entraînement.
Choisissez l’un des sujets suivants en fonction du cadre que vous utilisez.
**Topics**
+ [PyTorch](training-compiler-pytorch-models.md)
+ [TensorFlow](training-compiler-tensorflow.md)
**Note**
Une fois que vous avez terminé de préparer votre script de formation, vous pouvez exécuter une tâche de SageMaker formation à l'aide des classes d'estimateur du framework SageMaker AI. Pour plus d’informations, consultez la rubrique précédente dans [Activer le compilateur SageMaker d'entraînement](training-compiler-enable.md).
# PyTorch
Intégrez votre propre PyTorch modèle à l' SageMaker IA et exécutez le travail de formation avec SageMaker Training Compiler.
**Topics**
+ [PyTorch Modèles avec Hugging Face Transformers](#training-compiler-pytorch-models-transformers)
## PyTorch Modèles avec Hugging Face Transformers
PyTorch [les modèles dotés de [Hugging Face](https://huggingface.co/docs/transformers/index) Transformers sont basés PyTorch sur l'API Torch.nn.Module.](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) Hugging Face Transformers [propose](https://huggingface.co/docs/transformers/main_classes/trainer) également des cours de formation et des cours de modèles préentraînés afin de réduire PyTorch les efforts liés à la configuration des modèles de traitement du langage naturel (NLP). Après avoir préparé votre script de formation, vous pouvez lancer une tâche de formation à l'aide de l' SageMaker IA `PyTorch` ou de l'`HuggingFace`estimateur avec la configuration SageMaker Training Compiler lorsque vous passerez à la rubrique suivante à l'adresse. [Activer le compilateur SageMaker d'entraînement](training-compiler-enable.md)
**Astuce**
Lorsque vous créez un créateur de jetons pour un modèle NLP en utilisant le type Transformers dans votre script d’entraînement, assurez-vous que vous utilisez une forme de tenseur d’entrée statique en spécifiant `padding='max_length'`. N’utilisez pas `padding='longest'`, car le remplissage à la séquence la plus longue du lot peut changer la forme du tenseur pour chaque lot d’entraînement. La forme dynamique des entrées peut déclencher une recompilation du modèle et augmenter le temps d’entraînement total. Pour obtenir plus d’informations sur les options de remplissage des créateurs de jetons de transformeur, consultez [Remplissage et troncature](https://huggingface.co/docs/transformers/pad_truncation) dans la *documentation des transformeurs Hugging Face*.
**Topics**
+ [Modèles linguistiques de grande taille utilisant la classe `Trainer` de Hugging Face Transformers](#training-compiler-pytorch-models-transformers-trainer)
+ [Utilisation PyTorch directe de grands modèles linguistiques (sans l'API Hugging Face Transformers Trainer)](#training-compiler-pytorch-models-non-trainer)
### Modèles linguistiques de grande taille utilisant la classe `Trainer` de Hugging Face Transformers
Si vous utilisez la classe Trainer de la bibliothèque Transformers, vous n'avez pas besoin d'apporter de modifications supplémentaires à votre script d'entraînement. SageMaker Training Compiler compile automatiquement votre modèle Trainer si vous l'activez via la classe d'estimateur. Le code suivant montre la forme de base d'un script d' PyTorch entraînement avec l'API Hugging Face Trainer.
```
from transformers import Trainer, TrainingArguments
training_args=TrainingArguments(**kwargs)
trainer=Trainer(args=training_args, **kwargs)
```
**Topics**
+ [Pour l’entraînement à GPU unique](#training-compiler-pytorch-models-transformers-trainer-single-gpu)
+ [Pour l’entraînement distribué](#training-compiler-pytorch-models-transformers-trainer-distributed)
+ [Bonnes pratiques d'utilisation du compilateur SageMaker d'entraînement avec `Trainer`](#training-compiler-pytorch-models-transformers-trainer-best-practices)
#### Pour l’entraînement à GPU unique
Vous n’avez pas besoin de modifier votre code lorsque vous utilisez cette classe [https://huggingface.co/docs/transformers/main_classes/trainer](https://huggingface.co/docs/transformers/main_classes/trainer).
#### Pour l’entraînement distribué
**PyTorch v1.11.0 et versions ultérieures**
Pour exécuter un entraînement distribué avec SageMaker Training Compiler, vous devez ajouter la `_mp_fn()` fonction suivante dans votre script d'entraînement et l'`main()`encapsuler. Il redirige les appels de `_mp_fn(index)` fonction de l'environnement d'exécution distribué SageMaker AI for PyTorch (`pytorchxla`) vers la `main()` fonction de votre script d'entraînement.
```
def _mp_fn(index):
main()
```
Cette fonction accepte l’argument `index` pour indiquer le rang du GPU actuel dans le cluster pour l’entraînement distribué. Pour trouver d’autres exemples de scripts, consultez les [exemples de scripts de modélisation de langage pour les transformeurs Hugging Face](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling).
**Pour Transformers v4.17 et avant avec PyTorch v1.10.2 et avant**
SageMaker Training Compiler utilise un autre mécanisme pour lancer une tâche de formation distribuée, et vous n'avez pas besoin d'apporter de modification à votre script de formation. SageMaker Training Compiler vous demande plutôt de transmettre un script de lancement d'entraînement distribué par SageMaker IA à l'`entry_point`argument et de transmettre votre script d'entraînement à l'`hyperparameters`argument dans l'estimateur SageMaker AI Hugging Face.
#### Bonnes pratiques d'utilisation du compilateur SageMaker d'entraînement avec `Trainer`
+ Assurez-vous d'utiliser des SyncFree optimiseurs en définissant l'`optim`argument sur `adamw_torch_xla` lors de la configuration des [transformateurs. TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments). Voir également [Optimizer](https://huggingface.co/docs/transformers/v4.23.1/en/perf_train_gpu_one#optimizer) (Optimiseur) dans la *documentation de Hugging Face Transformers*.
+ Assurez-vous que le débit du pipeline de traitement des données est supérieur au débit d’entraînement. Vous pouvez modifier les `preprocessing_num_workers` arguments `dataloader_num_workers` et des [transformateurs. TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments)classe pour y parvenir. En règle générale, ceux-ci doivent être supérieurs ou égaux au nombre de GPUs mais inférieurs au nombre de CPUs.
Une fois que vous avez terminé d’adapter votre scénario d’entraînement, passez à [Exécuter PyTorch des tâches de formation avec SageMaker Training Compiler](training-compiler-enable-pytorch.md).
### Utilisation PyTorch directe de grands modèles linguistiques (sans l'API Hugging Face Transformers Trainer)
Si vous avez un script d'entraînement qui utilise PyTorch directement, vous devez apporter des modifications supplémentaires à votre script d' PyTorch entraînement pour implémenter PyTorch /XLA. Suivez les instructions pour modifier votre script afin de configurer correctement les primatives PyTorch /XLA.
**Topics**
+ [Pour l’entraînement à GPU unique](#training-compiler-pytorch-models-non-trainer-single-gpu)
+ [Pour l’entraînement distribué](#training-compiler-pytorch-models-non-trainer-distributed)
+ [Bonnes pratiques pour utiliser le compilateur SageMaker d'entraînement avec PyTorch /XLA](#training-compiler-pytorch-models-best-practices)
#### Pour l’entraînement à GPU unique
1. Importez les bibliothèques d’optimisation.
```
import torch_xla
import torch_xla.core.xla_model as xm
```
1. Changez le périphérique cible et sélectionnez XLA au lieu de `torch.device("cuda")`
```
device=xm.xla_device()
```
1. Si vous utilisez PyTorch l'[Automatic Mixed Precision](https://pytorch.org/docs/stable/amp.html) (AMP), procédez comme suit :
1. Remplacez `torch.cuda.amp` par ce qui suit :
```
import torch_xla.amp
```
1. Remplacez `torch.optim.SGD` et `torch.optim.Adam` par les éléments suivants :
```
import torch_xla.amp.syncfree.Adam as adam
import torch_xla.amp.syncfree.SGD as SGD
```
1. Remplacez `torch.cuda.amp.GradScaler` par ce qui suit :
```
import torch_xla.amp.GradScaler as grad_scaler
```
1. Si vous n’utilisez pas AMP, remplacez `optimizer.step()` par les éléments suivants :
```
xm.optimizer_step(optimizer)
```
1. Si vous utilisez un chargeur de données distribué, insérez votre chargeur de données dans la classe /XLA PyTorch : `ParallelLoader`
```
import torch_xla.distributed.parallel_loader as pl
parallel_loader=pl.ParallelLoader(dataloader, [device]).per_device_loader(device)
```
1. Ajoutez `mark_step` à la fin de la boucle d’entraînement lorsque vous n’utilisez pas `parallel_loader` :
```
xm.mark_step()
```
1. Pour vérifier votre entraînement, utilisez la méthode du point de contrôle du modèle PyTorch /XLA :
```
xm.save(model.state_dict(), path_to_save)
```
Une fois que vous avez terminé d’adapter votre scénario d’entraînement, passez à [Exécuter PyTorch des tâches de formation avec SageMaker Training Compiler](training-compiler-enable-pytorch.md).
#### Pour l’entraînement distribué
Outre les modifications répertoriées dans la [Pour l’entraînement à GPU unique](#training-compiler-pytorch-models-non-trainer-single-gpu) section précédente, ajoutez les modifications suivantes pour répartir correctement la charge de travail GPUs.
1. Si vous utilisez AMP, ajoutez `all_reduce` après `scaler.scale(loss).backward()` :
```
gradients=xm._fetch_gradients(optimizer)
xm.all_reduce('sum', gradients, scale=1.0/xm.xrt_world_size())
```
1. Si vous devez définir des variables pour `local_ranks` et `world_size`, utilisez un code similaire à celui-ci :
```
local_rank=xm.get_local_ordinal()
world_size=xm.xrt_world_size()
```
1. Pour tout `world_size` (`num_gpus_per_node*num_nodes`) supérieur à `1`, vous devez définir un échantillonnage d’entraînement qui devrait ressembler à ce qui suit :
```
import torch_xla.core.xla_model as xm
if xm.xrt_world_size() > 1:
train_sampler=torch.utils.data.distributed.DistributedSampler(
train_dataset,
num_replicas=xm.xrt_world_size(),
rank=xm.get_ordinal(),
shuffle=True
)
train_loader=torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch_size,
sampler=train_sampler,
drop_last=args.drop_last,
shuffle=False if train_sampler else True,
num_workers=args.num_workers
)
```
1. Apportez les modifications suivantes pour vous assurer que vous utilisez le `parallel_loader` fourni par le module `torch_xla distributed`.
```
import torch_xla.distributed.parallel_loader as pl
train_device_loader=pl.MpDeviceLoader(train_loader, device)
```
Il `train_device_loader` fonctionne comme un PyTorch chargeur normal comme suit :
```
for step, (data, target) in enumerate(train_device_loader):
optimizer.zero_grad()
output=model(data)
loss=torch.nn.NLLLoss(output, target)
loss.backward()
```
Avec tous ces changements, vous devriez être en mesure de lancer une formation distribuée avec n'importe quel PyTorch modèle sans l'API Transformer Trainer. Notez que ces instructions peuvent être utilisées à la fois pour le multi-GPU à nœud unique et le multi-GPU multi-nœud.
1. **Pour PyTorch v1.11.0 et versions ultérieures**
Pour exécuter un entraînement distribué avec SageMaker Training Compiler, vous devez ajouter la `_mp_fn()` fonction suivante dans votre script d'entraînement et l'`main()`encapsuler. Il redirige les appels de `_mp_fn(index)` fonction de l'environnement d'exécution distribué SageMaker AI for PyTorch (`pytorchxla`) vers la `main()` fonction de votre script d'entraînement.
```
def _mp_fn(index):
main()
```
Cette fonction accepte l’argument `index` pour indiquer le rang du GPU actuel dans le cluster pour l’entraînement distribué. Pour trouver d’autres exemples de scripts, consultez les [exemples de scripts de modélisation de langage pour les transformeurs Hugging Face](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling).
**Pour Transformers v4.17 et avant avec PyTorch v1.10.2 et avant**
SageMaker Training Compiler utilise un autre mécanisme pour lancer une tâche de formation distribuée et vous oblige à transmettre un script de lancement d'entraînement distribué par SageMaker IA à l'`entry_point`argument et à transmettre votre script d'entraînement à l'`hyperparameters`argument dans l'estimateur SageMaker AI Hugging Face.
Une fois que vous avez terminé d’adapter votre scénario d’entraînement, passez à [Exécuter PyTorch des tâches de formation avec SageMaker Training Compiler](training-compiler-enable-pytorch.md).
#### Bonnes pratiques pour utiliser le compilateur SageMaker d'entraînement avec PyTorch /XLA
Si vous souhaitez utiliser le compilateur d' SageMaker entraînement sur votre script d' PyTorch entraînement natif, vous devez d'abord vous familiariser avec [PyTorch les appareils XLA](https://pytorch.org/xla/release/1.9/index.html). Les sections suivantes répertorient certaines des meilleures pratiques pour activer XLA pour PyTorch.
**Note**
Cette section consacrée aux meilleures pratiques part du principe que vous utilisez les PyTorch/XLA modules suivants :
```
import torch_xla.core.xla_model as xm
import torch_xla.distributed.parallel_loader as pl
```
##### Comprendre le mode paresseux dans PyTorch /XLA
Une différence significative entre le mode natif PyTorch/XLA et le mode natif PyTorch est que le PyTorch/XLA système fonctionne en mode paresseux tandis que le mode natif PyTorch fonctionne en mode rapide. Les tenseurs en mode paresseux sont des espaces réservés pour la construction du graphe de calcul jusqu’à ce qu’ils soient matérialisés une fois la compilation et l’évaluation terminées. Le PyTorch/XLA système crée le graphe de calcul à la volée lorsque vous appelez PyTorch APIs pour créer le calcul à l'aide de tenseurs et d'opérateurs. Le graphique de calcul est compilé et exécuté lorsque `xm.mark_step()` est appelé explicitement ou implicitement par `pl.MpDeviceLoader/pl.ParallelLoader`, ou lorsque vous demandez explicitement la valeur d’un tenseur, par exemple en appelant `loss.item()` ou `print(loss)`.
##### Minimiser le nombre d'*compilation-and-executions*utilisations `pl.MpDeviceLoader/pl.ParallelLoader` et `xm.step_closure`
Pour de meilleures performances, vous devez garder à l'esprit les méthodes d'initialisation possibles *compilation-and-executions*décrites dans la section [Comprendre le mode paresseux dans PyTorch /XLA](#training-compiler-pytorch-models-best-practices-lazy-mode) et essayer de minimiser le nombre de compilation-and-executions. Idéalement, un seul compilation-and-execution est nécessaire par itération d'entraînement et est lancé automatiquement par`pl.MpDeviceLoader/pl.ParallelLoader`. `MpDeviceLoader` est optimisé pour XLA et doit toujours être utilisé si possible pour obtenir de meilleures performances. Au cours de l’entraînement, vous devrez peut-être examiner certains résultats intermédiaires tels que les valeurs de perte. Dans ce cas, l'impression des tenseurs paresseux doit être enveloppée `xm.add_step_closure()` pour éviter toute utilisation inutile compilation-and-executions.
##### Utiliser AMP et les optimiseurs `syncfree`
L'entraînement en mode AMP (Automatic Mixed Precision) accélère considérablement votre vitesse d'entraînement en tirant parti des cœurs Tensor de NVIDIA GPUs. SageMaker Training Compiler fournit `syncfree` des optimiseurs optimisés pour XLA afin d'améliorer les performances AMP. Actuellement, les trois optimiseurs `syncfree` suivants sont disponibles et doivent être utilisés si possible pour garantir de meilleures performances.
```
torch_xla.amp.syncfree.SGD
torch_xla.amp.syncfree.Adam
torch_xla.amp.syncfree.AdamW
```
Ces optimiseurs `syncfree` doivent être associés à `torch_xla.amp.GradScaler` pour la mise à l’échelle croissante ou décroissante du gradient.
**Astuce**
À partir de la version PyTorch 1.13.1, SageMaker Training Compiler améliore les performances en permettant PyTorch/XLA de remplacer automatiquement les optimiseurs (tels que SGD, Adam, AdamW) dans `torch.optim` ou `transformers.optimization` avec leurs versions sans synchronisation (telles que,,). `torch_xla.amp.syncfree` `torch_xla.amp.syncfree.SGD` `torch_xla.amp.syncfree.Adam` `torch_xla.amp.syncfree.AdamW` Vous n’avez pas besoin de modifier les lignes de code dans lesquelles vous définissez les optimiseurs dans votre script d’entraînement.
# TensorFlow
Intégrez votre propre TensorFlow modèle à l' SageMaker IA et exécutez le travail de formation avec SageMaker Training Compiler.
## TensorFlow Modèles
SageMaker Training Compiler optimise automatiquement les charges de travail d'entraînement des modèles basées sur l' TensorFlow API native ou sur l'API Keras de haut niveau.
**Astuce**
Pour prétraiter votre jeu de données d’entrée, veillez à utiliser une forme d’entrée statique. La forme d’entrée dynamique peut déclencher une recompilation du modèle et augmenter la durée totale d’entraînement.
### Utilisation de Keras (recommandée)
Pour une accélération optimale du compilateur, nous recommandons d'utiliser des modèles qui sont des sous-classes de TensorFlow Keras ([tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)).
#### Pour l’entraînement à GPU unique
Vous n’avez pas besoin d’apporter de modification supplémentaire au script d’entraînement.
### Sans Keras
SageMaker Training Compiler ne prend pas en charge l'exécution rapide dans TensorFlow. Par conséquent, vous devez encapsuler votre modèle et vos boucles d'entraînement avec la TensorFlow fonction decorator (`@tf.function`) pour tirer parti de l'accélération du compilateur.
SageMaker [Training Compiler effectue une optimisation au niveau du graphe et utilise le décorateur pour s'assurer que vos TensorFlow fonctions sont configurées pour s'exécuter en mode graphique.](https://www.tensorflow.org/guide/intro_to_graphs)
#### Pour l’entraînement à GPU unique
TensorFlow L'exécution rapide est activée par défaut dans la version 2.0 ou ultérieure. Vous devez donc ajouter le `@tf.function` décorateur devant chaque fonction que vous utilisez pour construire un TensorFlow modèle.
## TensorFlow Modèles avec Hugging Face Transformers
TensorFlow [les modèles dotés de [Hugging Face](https://huggingface.co/docs/transformers/index) Transformers sont basés TensorFlow sur l'API tf.keras.model.](https://www.tensorflow.org/api_docs/python/tf/keras/Model) Hugging Face Transformers propose également des classes de modèles préentraînées afin de réduire TensorFlow les efforts liés à la configuration des modèles de traitement du langage naturel (NLP). Après avoir créé votre propre script d'entraînement à l'aide de la bibliothèque Transformers, vous pouvez exécuter le script d'entraînement à l'aide de l'`HuggingFace`estimateur SageMaker AI avec la classe de configuration SageMaker Training Compiler, comme indiqué dans la rubrique précédente à l'adresse. [Exécuter TensorFlow des tâches de formation avec SageMaker Training Compiler](training-compiler-enable-tensorflow.md)
SageMaker Training Compiler optimise automatiquement les charges de travail d'entraînement des modèles basées sur l' TensorFlow API native ou sur l'API Keras de haut niveau, telles que les TensorFlow modèles de transformateurs.
**Astuce**
Lorsque vous créez un créateur de jetons pour un modèle NLP en utilisant le type Transformers dans votre script d’entraînement, assurez-vous que vous utilisez une forme de tenseur d’entrée statique en spécifiant `padding='max_length'`. N’utilisez pas `padding='longest'`, car le remplissage à la séquence la plus longue du lot peut changer la forme du tenseur pour chaque lot d’entraînement. La forme d’entrée dynamique peut déclencher une recompilation du modèle et augmenter la durée totale d’entraînement. Pour obtenir plus d’informations sur les options de remplissage des créateurs de jetons de transformeur, consultez [Remplissage et troncature](https://huggingface.co/docs/transformers/pad_truncation) dans la *documentation des transformeurs Hugging Face*.
**Topics**
+ [Utilisation de Keras](#training-compiler-tensorflow-models-transformers-keras)
+ [Sans Keras](#training-compiler-tensorflow-models-transformers-no-keras)
### Utilisation de Keras
Pour une accélération optimale du compilateur, nous recommandons d'utiliser des modèles qui sont des sous-classes de TensorFlow Keras ([tf.keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)). Comme indiqué dans la page de [présentation rapide](https://huggingface.co/docs/transformers/quicktour) de la documentation de *Hugging Face Transformers*, vous pouvez utiliser les modèles comme des modèles Keras TensorFlow classiques.
#### Pour l’entraînement à GPU unique
Vous n'avez pas besoin d'apporter de modification supplémentaire au script d'entraînement.
#### Pour l’entraînement distribué
SageMaker L'accélération du compilateur d'entraînement fonctionne de manière transparente pour les charges de travail multi-GPU lorsque le modèle est construit et entraîné à l'aide de Keras APIs dans le cadre de l'appel. [https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy](https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy)
1. Choisissez la bonne stratégie d’entraînement distribué.
1. Pour le multi-GPU à nœud unique, utilisez `tf.distribute.MirroredStrategy` pour définir la stratégie.
```
strategy = tf.distribute.MirroredStrategy()
```
1. Pour les processeurs multi-nœuds et multi-GPU, ajoutez le code suivant pour définir correctement la configuration d'entraînement TensorFlow distribué avant de créer la stratégie.
```
def set_sm_dist_config():
DEFAULT_PORT = '8890'
DEFAULT_CONFIG_FILE = '/opt/ml/input/config/resourceconfig.json'
with open(DEFAULT_CONFIG_FILE) as f:
config = json.loads(f.read())
current_host = config['current_host']
tf_config = {
'cluster': {
'worker': []
},
'task': {'type': 'worker', 'index': -1}
}
for i, host in enumerate(config['hosts']):
tf_config['cluster']['worker'].append("%s:%s" % (host, DEFAULT_PORT))
if current_host == host:
tf_config['task']['index'] = i
os.environ['TF_CONFIG'] = json.dumps(tf_config)
set_sm_dist_config()
```
Utilisez `tf.distribute.MultiWorkerMirroredStrategy` pour définir la stratégie.
```
strategy = tf.distribute.MultiWorkerMirroredStrategy()
```
1. En utilisant la stratégie de votre choix, enveloppez le modèle.
```
with strategy.scope():
# create a model and do fit
```
### Sans Keras
Si vous souhaitez créer des modèles personnalisés avec des boucles d'entraînement personnalisées TensorFlow sans Keras, vous devez intégrer le modèle et la boucle d'entraînement à la TensorFlow fonction decorator (`@tf.function`) pour tirer parti de l'accélération du compilateur.
SageMaker Training Compiler effectue une optimisation au niveau du graphe et utilise le décorateur pour s'assurer que vos TensorFlow fonctions sont configurées pour s'exécuter en mode graphique.
#### Pour l’entraînement à GPU unique
TensorFlow L'exécution rapide est activée par défaut dans la version 2.0 ou ultérieure. Vous devez donc ajouter le `@tf.function` décorateur devant chaque fonction que vous utilisez pour construire un TensorFlow modèle.
#### Pour l’entraînement distribué
En plus des modifications nécessaires à l’[utilisation de Keras pour l’entraînement distribué](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-tensorflow-models.html#training-compiler-tensorflow-models-transformers-keras), vous devez vous assurer que les fonctions à exécuter sur chaque GPU sont annotées avec `@tf.function`, tandis que les fonctions de communication inter-GPU ne sont pas annotées. Par exemple, le code d’entraînement devrait ressembler à ce qui suit :
```
@tf.function()
def compiled_step(inputs, outputs):
with tf.GradientTape() as tape:
pred=model(inputs, training=True)
total_loss=loss_object(outputs, pred)/args.batch_size
gradients=tape.gradient(total_loss, model.trainable_variables)
return total_loss, pred, gradients
def train_step(inputs, outputs):
total_loss, pred, gradients=compiled_step(inputs, outputs)
if args.weight_decay > 0.:
gradients=[g+v*args.weight_decay for g,v in zip(gradients, model.trainable_variables)]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
train_loss.update_state(total_loss)
train_accuracy.update_state(outputs, pred)
@tf.function()
def train_step_dist(inputs, outputs):
strategy.run(train_step, args= (inputs, outputs))
```
Notez que cette instruction peut être utilisée à la fois pour le multi-GPU à nœud unique et le multi-GPU multi-nœud.
# Activer le compilateur SageMaker d'entraînement
**Important**
Amazon Web Services (AWS) annonce qu'il n'y aura aucune nouvelle version ou version de SageMaker Training Compiler. Vous pouvez continuer à utiliser SageMaker Training Compiler via les AWS Deep Learning Containers (DLCs) for SageMaker Training existants. Il est important de noter que tant que les versions existantes DLCs resteront accessibles, elles ne recevront plus de correctifs ni de mises à jour AWS, conformément à la [politique de support du AWS Deep Learning Containers Framework](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html).
SageMaker Training Compiler est intégré au SDK SageMaker Python et aux AWS Deep Learning Containers, de sorte que vous n'avez pas besoin de modifier vos flux de travail pour activer Training Compiler. Choisissez l’une des rubriques suivantes qui correspond à votre cas d’utilisation.
**Topics**
+ [Exécuter PyTorch des tâches de formation avec SageMaker Training Compiler](training-compiler-enable-pytorch.md)
+ [Exécuter TensorFlow des tâches de formation avec SageMaker Training Compiler](training-compiler-enable-tensorflow.md)
# Exécuter PyTorch des tâches de formation avec SageMaker Training Compiler
Vous pouvez utiliser n'importe laquelle des interfaces d' SageMaker IA pour exécuter une tâche de formation avec SageMaker Training Compiler : Amazon SageMaker Studio Classic, Amazon SageMaker Notebook instances AWS SDK pour Python (Boto3), et AWS Command Line Interface.
**Topics**
+ [Utilisation du SDK SageMaker Python](#training-compiler-enable-pytorch-pysdk)
+ [Utilisation de l'opération `CreateTrainingJob` d'API SageMaker AI](#training-compiler-enable-pytorch-api)
## Utilisation du SDK SageMaker Python
SageMaker Training Compiler for PyTorch est disponible via les SageMaker classes AI [https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)et [https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-estimator)framework estimator. Pour activer le compilateur SageMaker d'entraînement, ajoutez le `compiler_config` paramètre aux estimateurs de l' SageMaker IA. Importez la classe `TrainingCompilerConfig` et transmettez-en une instance au paramètre `compiler_config`. Les exemples de code suivants montrent la structure des classes d'estimateurs d' SageMaker IA lorsque le compilateur d' SageMaker entraînement est activé.
**Astuce**
Pour commencer avec les modèles préfabriqués fournis par PyTorch ou Transformers, essayez d'utiliser les tailles de lots fournies dans le tableau de référence à l'adresse. [Modèles testés](training-compiler-support.md#training-compiler-tested-models)
**Note**
Le PyTorch support natif est disponible dans le SDK SageMaker Python v2.121.0 et versions ultérieures. Assurez-vous de mettre à jour le SDK SageMaker Python en conséquence.
**Note**
À partir de la PyTorch version v1.12.0, les conteneurs SageMaker Training Compiler pour PyTorch sont disponibles. Notez que les conteneurs SageMaker Training Compiler pour ne PyTorch sont pas préemballés avec Hugging Face Transformers. Si vous devez installer la bibliothèque dans le conteneur, assurez-vous d’ajouter le fichier `requirements.txt` dans le répertoire source lorsque vous soumettez une tâche d’entraînement.
Pour la PyTorch version v1.11.0 et les versions antérieures, utilisez les versions précédentes des conteneurs SageMaker Training Compiler pour Hugging Face et. PyTorch
Pour obtenir la liste complète des versions de cadre et des informations sur les conteneurs correspondants, consultez [Cadres pris en charge](training-compiler-support.md#training-compiler-supported-frameworks).
Pour obtenir des informations adaptées à votre cas d’utilisation, consultez l’une des options suivantes.
### Pour l’entraînement à GPU unique
------
#### [ PyTorch v1.12.0 and later ]
Pour compiler et entraîner un PyTorch modèle, configurez un PyTorch estimateur SageMaker AI avec SageMaker Training Compiler, comme indiqué dans l'exemple de code suivant.
**Note**
Ce PyTorch support natif est disponible dans le SDK SageMaker AI Python v2.120.0 et versions ultérieures. Assurez-vous de mettre à jour le SDK SageMaker AI Python.
```
from sagemaker.pytorch import PyTorch, TrainingCompilerConfig
# the original max batch size that can fit into GPU memory without compiler
batch_size_native=12
learning_rate_native=float('5e-5')
# an updated max batch size that can fit into GPU memory with compiler
batch_size=64
# update learning rate
learning_rate=learning_rate_native/batch_size_native*batch_size
hyperparameters={
"n_gpus": 1,
"batch_size": batch_size,
"learning_rate": learning_rate
}
pytorch_estimator=PyTorch(
entry_point='train.py',
source_dir='path-to-requirements-file', # Optional. Add this if need to install additional packages.
instance_count=1,
instance_type='ml.p3.2xlarge',
framework_version='1.13.1',
py_version='py3',
hyperparameters=hyperparameters,
compiler_config=TrainingCompilerConfig(),
disable_profiler=True,
debugger_hook_config=False
)
pytorch_estimator.fit()
```
------
#### [ Hugging Face Transformers with PyTorch v1.11.0 and before ]
Pour compiler et entraîner un modèle de transformateur avec PyTorch, configurez un estimateur SageMaker AI Hugging Face SageMaker avec Training Compiler, comme indiqué dans l'exemple de code suivant.
```
from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig
# the original max batch size that can fit into GPU memory without compiler
batch_size_native=12
learning_rate_native=float('5e-5')
# an updated max batch size that can fit into GPU memory with compiler
batch_size=64
# update learning rate
learning_rate=learning_rate_native/batch_size_native*batch_size
hyperparameters={
"n_gpus": 1,
"batch_size": batch_size,
"learning_rate": learning_rate
}
pytorch_huggingface_estimator=HuggingFace(
entry_point='train.py',
instance_count=1,
instance_type='ml.p3.2xlarge',
transformers_version='4.21.1',
pytorch_version='1.11.0',
hyperparameters=hyperparameters,
compiler_config=TrainingCompilerConfig(),
disable_profiler=True,
debugger_hook_config=False
)
pytorch_huggingface_estimator.fit()
```
Pour préparer votre script d’entraînement, consultez les pages suivantes.
+ [Pour l’entraînement à GPU unique](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-single-gpu)d'un PyTorch modèle utilisant l'API Hugging Face [Transformers' Trainer](https://huggingface.co/docs/transformers/main_classes/trainer)
+ [Pour l’entraînement à GPU unique](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-single-gpu)d'un PyTorch modèle sans l'API Hugging Face [Transformers' Trainer](https://huggingface.co/transformers/main_classes/trainer.html)
Pour trouver des end-to-end exemples, consultez les blocs-notes suivants :
+ [Compilez et formez un modèle d'entraîneur Hugging Face Transformers pour les questions et réponses avec SQu le jeu de données AD](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/albert-base-v2/albert-base-v2.html)
+ [Compilez et entraînez un modèle de `BERT` transformateur Hugging Face avec le jeu de données SageMaker SST à l'aide du compilateur de formation](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/bert-base-cased/bert-base-cased-single-node-single-gpu.html)
+ [Compilez et entraînez un modèle d'entraînement de classification binaire avec le SST2 jeu de données pour l'entraînement à un seul nœud et à un seul GPU](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/roberta-base/roberta-base.html)
------
### Pour l’entraînement distribué
------
#### [ PyTorch v1.12 ]
Pour la PyTorch version v1.12, vous pouvez exécuter un entraînement distribué avec SageMaker Training Compiler en ajoutant l'`pytorch_xla`option spécifiée au `distribution` paramètre de la classe d' PyTorchestimateur SageMaker AI.
**Note**
Ce PyTorch support natif est disponible dans le SDK SageMaker AI Python v2.121.0 et versions ultérieures. Assurez-vous de mettre à jour le SDK SageMaker AI Python.
```
from sagemaker.pytorch import PyTorch, TrainingCompilerConfig
# choose an instance type, specify the number of instances you want to use,
# and set the num_gpus variable the number of GPUs per instance.
instance_count=1
instance_type='ml.p3.8xlarge'
num_gpus=4
# the original max batch size that can fit to GPU memory without compiler
batch_size_native=16
learning_rate_native=float('5e-5')
# an updated max batch size that can fit to GPU memory with compiler
batch_size=26
# update learning rate
learning_rate=learning_rate_native/batch_size_native*batch_size*num_gpus*instance_count
hyperparameters={
"n_gpus": num_gpus,
"batch_size": batch_size,
"learning_rate": learning_rate
}
pytorch_estimator=PyTorch(
entry_point='your_training_script.py',
source_dir='path-to-requirements-file', # Optional. Add this if need to install additional packages.
instance_count=instance_count,
instance_type=instance_type,
framework_version='1.13.1',
py_version='py3',
hyperparameters=hyperparameters,
compiler_config=TrainingCompilerConfig(),
distribution ={'pytorchxla' : { 'enabled': True }},
disable_profiler=True,
debugger_hook_config=False
)
pytorch_estimator.fit()
```
**Astuce**
Pour préparer votre script d’entraînement, consultez [PyTorch](training-compiler-pytorch-models.md)
------
#### [ Transformers v4.21 with PyTorch v1.11 ]
Pour la PyTorch version v1.11 et les versions ultérieures, SageMaker Training Compiler est disponible pour l'entraînement distribué avec l'`pytorch_xla`option spécifiée dans le `distribution` paramètre.
```
from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig
# choose an instance type, specify the number of instances you want to use,
# and set the num_gpus variable the number of GPUs per instance.
instance_count=1
instance_type='ml.p3.8xlarge'
num_gpus=4
# the original max batch size that can fit to GPU memory without compiler
batch_size_native=16
learning_rate_native=float('5e-5')
# an updated max batch size that can fit to GPU memory with compiler
batch_size=26
# update learning rate
learning_rate=learning_rate_native/batch_size_native*batch_size*num_gpus*instance_count
hyperparameters={
"n_gpus": num_gpus,
"batch_size": batch_size,
"learning_rate": learning_rate
}
pytorch_huggingface_estimator=HuggingFace(
entry_point='your_training_script.py',
instance_count=instance_count,
instance_type=instance_type,
transformers_version='4.21.1',
pytorch_version='1.11.0',
hyperparameters=hyperparameters,
compiler_config=TrainingCompilerConfig(),
distribution ={'pytorchxla' : { 'enabled': True }},
disable_profiler=True,
debugger_hook_config=False
)
pytorch_huggingface_estimator.fit()
```
**Astuce**
Pour préparer votre script d’entraînement, consultez les pages suivantes.
[Pour l’entraînement distribué](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-distributed)d'un PyTorch modèle utilisant l'API Hugging Face [Transformers' Trainer](https://huggingface.co/transformers/main_classes/trainer.html)
[Pour l’entraînement distribué](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-distributed)d'un PyTorch modèle sans l'API Hugging Face [Transformers' Trainer](https://huggingface.co/transformers/main_classes/trainer.html)
------
#### [ Transformers v4.17 with PyTorch v1.10.2 and before ]
Pour les versions prises en charge de la PyTorch v1.10.2 et antérieures, SageMaker Training Compiler nécessite un autre mécanisme pour lancer une tâche de formation distribuée. Pour exécuter un entraînement distribué, SageMaker Training Compiler vous demande de transmettre un script de lancement d'entraînement distribué SageMaker AI à l'`entry_point`argument, et de transmettre votre script d'entraînement à l'`hyperparameters`argument. L'exemple de code suivant montre comment configurer un estimateur SageMaker AI Hugging Face en appliquant les modifications requises.
```
from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig
# choose an instance type, specify the number of instances you want to use,
# and set the num_gpus variable the number of GPUs per instance.
instance_count=1
instance_type='ml.p3.8xlarge'
num_gpus=4
# the original max batch size that can fit to GPU memory without compiler
batch_size_native=16
learning_rate_native=float('5e-5')
# an updated max batch size that can fit to GPU memory with compiler
batch_size=26
# update learning rate
learning_rate=learning_rate_native/batch_size_native*batch_size*num_gpus*instance_count
training_script="your_training_script.py"
hyperparameters={
"n_gpus": num_gpus,
"batch_size": batch_size,
"learning_rate": learning_rate,
"training_script": training_script # Specify the file name of your training script.
}
pytorch_huggingface_estimator=HuggingFace(
entry_point='distributed_training_launcher.py', # Specify the distributed training launcher script.
instance_count=instance_count,
instance_type=instance_type,
transformers_version='4.17.0',
pytorch_version='1.10.2',
hyperparameters=hyperparameters,
compiler_config=TrainingCompilerConfig(),
disable_profiler=True,
debugger_hook_config=False
)
pytorch_huggingface_estimator.fit()
```
Le script de lancement devrait ressembler à l’exemple suivant. Il enveloppe votre script d’entraînement et configure l’environnement d’entraînement distribué en fonction de la taille de l’instance d’entraînement de votre choix.
```
# distributed_training_launcher.py
#!/bin/python
import subprocess
import sys
if __name__ == "__main__":
arguments_command = " ".join([arg for arg in sys.argv[1:]])
"""
The following line takes care of setting up an inter-node communication
as well as managing intra-node workers for each GPU.
"""
subprocess.check_call("python -m torch_xla.distributed.sm_dist " + arguments_command, shell=True)
```
**Astuce**
Pour préparer votre script d’entraînement, consultez les pages suivantes.
[Pour l’entraînement distribué](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-distributed)d'un PyTorch modèle utilisant l'API Hugging Face [Transformers' Trainer](https://huggingface.co/transformers/main_classes/trainer.html)
[Pour l’entraînement distribué](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-distributed)d'un PyTorch modèle sans l'API Hugging Face [Transformers' Trainer](https://huggingface.co/transformers/main_classes/trainer.html)
**Astuce**
Pour trouver des end-to-end exemples, consultez les blocs-notes suivants :
[Compilez et entraînez le GPT2 modèle à l'aide de l'API Transformers Trainer avec le SST2 jeu de données pour l'entraînement multi-GPU à nœud unique](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_single_node/language-modeling-multi-gpu-single-node.html)
[Compilez et entraînez le GPT2 modèle à l'aide de l'API Transformers Trainer avec le SST2 jeu de données pour l'entraînement multi-nœuds multi-GPU](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_multiple_node/language-modeling-multi-gpu-multi-node.html)
------
La liste suivante représente l'ensemble minimal de paramètres requis pour exécuter une tâche d' SageMaker entraînement avec le compilateur.
**Note**
Lorsque vous utilisez l'estimateur SageMaker AI Hugging Face, vous devez spécifier `transformers_version` les paramètres, `pytorch_version``hyperparameters`, `compiler_config` et pour activer Training Compiler SageMaker . Vous ne pouvez pas utiliser `image_uri` pour spécifier manuellement les conteneurs de deep learning intégrés à Training Compiler qui sont répertoriés dans [Cadres pris en charge](training-compiler-support.md#training-compiler-supported-frameworks).
+ `entry_point` (str) : obligatoire. Spécifiez le nom de fichier de votre script d’entraînement.
**Note**
Pour exécuter un entraînement distribué avec SageMaker Training Compiler et les PyTorch versions v1.10.2 et antérieures, spécifiez le nom de fichier d'un script de lancement dans ce paramètre. Le script de lancement doit être prêt à envelopper votre script d’entraînement et à configurer l’environnement d’entraînement distribué. Pour plus d’informations, consultez les exemples de blocs-notes suivants :
[Compilez et entraînez le GPT2 modèle à l'aide de l'API Transformers Trainer avec le SST2 jeu de données pour l'entraînement multi-GPU à nœud unique](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_single_node/language-modeling-multi-gpu-single-node.html)
[Compilez et entraînez le GPT2 modèle à l'aide de l'API Transformers Trainer avec le SST2 jeu de données pour l'entraînement multi-nœuds multi-GPU](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_multiple_node/language-modeling-multi-gpu-multi-node.html)
+ `source_dir` (str) : facultatif. Ajoutez-le si vous devez installer des packages supplémentaires. Pour installer des packages, vous devez préparer un fichier `requirements.txt` dans ce répertoire.
+ `instance_count` (int) : obligatoire. Spécifiez le nombre d’instances.
+ `instance_type` (str) : obligatoire. Spécifiez le type d’instance.
+ `transformers_version`(str) — Obligatoire uniquement lors de l'utilisation de l' SageMaker estimateur AI Hugging Face. Spécifiez la version de la bibliothèque Hugging Face Transformers prise en charge SageMaker par Training Compiler. Pour trouver les versions disponibles, consultez [Cadres pris en charge](training-compiler-support.md#training-compiler-supported-frameworks).
+ `framework_version` ou `pytorch_version` (str) : obligatoire. Spécifiez la PyTorch version prise en charge par SageMaker Training Compiler. Pour trouver les versions disponibles, consultez [Cadres pris en charge](training-compiler-support.md#training-compiler-supported-frameworks).
**Note**
Lorsque vous utilisez l'estimateur SageMaker AI Hugging Face, vous devez spécifier à la fois et. `transformers_version` `pytorch_version`
+ `hyperparameters` (dict) : facultatif. Spécifiez des hyperparamètres pour la tâche d’entraînement, tels que `n_gpus`, `batch_size` et `learning_rate`. Lorsque vous activez SageMaker Training Compiler, essayez des lots de plus grande taille et ajustez le taux d'apprentissage en conséquence. Pour trouver des études de cas sur l’utilisation du compilateur et l’ajustement de la taille des lots pour améliorer la vitesse d’entraînement, consultez [Modèles testés](training-compiler-support.md#training-compiler-tested-models) et [SageMaker Compilateur de formation : exemples de blocs-notes et de blogs](training-compiler-examples-and-blogs.md).
**Note**
Pour exécuter un entraînement distribué avec SageMaker Training Compiler et les versions PyTorch 1.10.2 et antérieures, vous devez ajouter un paramètre supplémentaire pour spécifier votre script d'entraînement, comme indiqué dans l'exemple de code précédent. `"training_script"`
+ `compiler_config`(TrainingCompilerConfig object) — Nécessaire pour activer le compilateur SageMaker d'entraînement. Incluez ce paramètre pour activer le compilateur SageMaker d'entraînement. Les paramètres suivants sont destinés à la classe `TrainingCompilerConfig`.
+ `enabled` (bool) : facultatif. Spécifiez `True` ou `False` activez ou désactivez le compilateur SageMaker d'entraînement. La valeur par défaut est `True`.
+ `debug` (bool) : facultatif. Pour recevoir des journaux d’entraînement plus détaillés de vos tâches d’entraînement accélérées par le compilateur, remplacez la valeur par `True`. Cependant, la journalisation supplémentaire peut ajouter une surcharge et ralentir la tâche d’entraînement compilé. La valeur par défaut est `False`.
+ `distribution` (dict) : facultatif. Pour exécuter une tâche de formation distribuée avec SageMaker Training Compiler, ajoutez`distribution = { 'pytorchxla' : { 'enabled': True }}`.
**Avertissement**
Si vous activez SageMaker Debugger, cela peut avoir un impact sur les performances de SageMaker Training Compiler. Nous vous recommandons de désactiver le débogueur lorsque vous exécutez SageMaker Training Compiler pour vous assurer que cela n'a aucun impact sur les performances. Pour de plus amples informations, veuillez consulter [Considérations](training-compiler-tips-pitfalls.md#training-compiler-tips-pitfalls-considerations). Pour désactiver les fonctionnalités de Debugger, ajoutez les deux arguments suivants à l’estimateur :
```
disable_profiler=True,
debugger_hook_config=False
```
Si la tâche d’entraînement avec le compilateur est lancée avec succès, vous recevez les journaux suivants lors de la phase d’initialisation de la tâche :
+ Avec `TrainingCompilerConfig(debug=False)`
```
Found configuration for Training Compiler
Configuring SM Training Compiler...
```
+ Avec `TrainingCompilerConfig(debug=True)`
```
Found configuration for Training Compiler
Configuring SM Training Compiler...
Training Compiler set to debug mode
```
## Utilisation de l'opération `CreateTrainingJob` d'API SageMaker AI
SageMaker Les options de configuration du compilateur de formation doivent être spécifiées via le `HyperParameters` champ `AlgorithmSpecification` et dans la syntaxe de la demande pour l'[opération `CreateTrainingJob` d'API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html).
```
"AlgorithmSpecification": {
"TrainingImage": ""
},
"HyperParameters": {
"sagemaker_training_compiler_enabled": "true",
"sagemaker_training_compiler_debug_mode": "false",
"sagemaker_pytorch_xla_multi_worker_enabled": "false" // set to "true" for distributed training
}
```
Pour trouver la liste complète des images de conteneurs de deep learning sur URIs lesquelles SageMaker Training Compiler est implémenté, consultez[Cadres pris en charge](training-compiler-support.md#training-compiler-supported-frameworks).
# Exécuter TensorFlow des tâches de formation avec SageMaker Training Compiler
Vous pouvez utiliser n'importe laquelle des interfaces d' SageMaker IA pour exécuter une tâche de formation avec SageMaker Training Compiler : Amazon SageMaker Studio Classic, Amazon SageMaker Notebook instances AWS SDK pour Python (Boto3), et AWS Command Line Interface.
**Topics**
+ [Utilisation du SDK SageMaker Python](#training-compiler-enable-tensorflow-pysdk)
+ [Utilisation du SDK SageMaker AI Python et extension du framework SageMaker AI (Deep Learning Containers)](#training-compiler-enable-tensorflow-sdk-extend-container)
+ [Activer le compilateur SageMaker d'entraînement à l'aide de l'opération `CreateTrainingJob` d'API SageMaker AI](#training-compiler-enable-tensorflow-api)
## Utilisation du SDK SageMaker Python
Pour activer SageMaker Training Compiler, ajoutez le `compiler_config` paramètre à l' SageMaker estimateur AI TensorFlow ou Hugging Face. Importez la classe `TrainingCompilerConfig` et transmettez-en une instance au paramètre `compiler_config`. Les exemples de code suivants montrent la structure des classes d' SageMaker estimateurs d'IA lorsque le compilateur d' SageMaker entraînement est activé.
**Astuce**
Pour commencer à utiliser les modèles prédéfinis fournis par les bibliothèques TensorFlow et Transformers, essayez d'utiliser les tailles de lots fournies dans le tableau de référence à l'adresse. [Modèles testés](training-compiler-support.md#training-compiler-tested-models)
**Note**
SageMaker Training Compiler for TensorFlow est disponible via les SageMaker [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)estimateurs du framework AI et [Hugging](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-estimator) Face.
Pour obtenir des informations adaptées à votre cas d’utilisation, consultez l’une des options suivantes.
### Pour l’entraînement à GPU unique
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow, TrainingCompilerConfig
# the original max batch size that can fit into GPU memory without compiler
batch_size_native=12
learning_rate_native=float('5e-5')
# an updated max batch size that can fit into GPU memory with compiler
batch_size=64
# update the global learning rate
learning_rate=learning_rate_native/batch_size_native*batch_size
hyperparameters={
"n_gpus": 1,
"batch_size": batch_size,
"learning_rate": learning_rate
}
tensorflow_estimator=TensorFlow(
entry_point='train.py',
instance_count=1,
instance_type='ml.p3.2xlarge',
framework_version='2.9.1',
hyperparameters=hyperparameters,
compiler_config=TrainingCompilerConfig(),
disable_profiler=True,
debugger_hook_config=False
)
tensorflow_estimator.fit()
```
Pour préparer votre script d’entraînement, consultez les pages suivantes.
+ [Pour l’entraînement à GPU unique](training-compiler-tensorflow.md#training-compiler-tensorflow-models-keras-single-gpu)d'un modèle construit à l'aide de TensorFlow Keras (`tf.keras.*`).
+ [Pour l’entraînement à GPU unique](training-compiler-tensorflow.md#training-compiler-tensorflow-models-no-keras-single-gpu)d'un modèle construit à l'aide de TensorFlow modules (`tf.*`à l'exception des modules TensorFlow Keras).
------
#### [ Hugging Face Estimator with TensorFlow ]
```
from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig
# the original max batch size that can fit into GPU memory without compiler
batch_size_native=12
learning_rate_native=float('5e-5')
# an updated max batch size that can fit into GPU memory with compiler
batch_size=64
# update the global learning rate
learning_rate=learning_rate_native/batch_size_native*batch_size
hyperparameters={
"n_gpus": 1,
"batch_size": batch_size,
"learning_rate": learning_rate
}
tensorflow_huggingface_estimator=HuggingFace(
entry_point='train.py',
instance_count=1,
instance_type='ml.p3.2xlarge',
transformers_version='4.21.1',
tensorflow_version='2.6.3',
hyperparameters=hyperparameters,
compiler_config=TrainingCompilerConfig(),
disable_profiler=True,
debugger_hook_config=False
)
tensorflow_huggingface_estimator.fit()
```
Pour préparer votre script d’entraînement, consultez les pages suivantes.
+ [Pour l’entraînement à GPU unique](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-keras-single-gpu)d'un modèle TensorFlow Keras avec Hugging Face Transformers
+ [Pour l’entraînement à GPU unique](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-no-keras-single-gpu)d'un TensorFlow modèle avec Hugging Face Transformers
------
### Pour l’entraînement distribué
------
#### [ Hugging Face Estimator with TensorFlow ]
```
from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig
# choose an instance type, specify the number of instances you want to use,
# and set the num_gpus variable the number of GPUs per instance.
instance_count=1
instance_type='ml.p3.8xlarge'
num_gpus=4
# the original max batch size that can fit to GPU memory without compiler
batch_size_native=16
learning_rate_native=float('5e-5')
# an updated max batch size that can fit to GPU memory with compiler
batch_size=26
# update learning rate
learning_rate=learning_rate_native/batch_size_native*batch_size*num_gpus*instance_count
hyperparameters={
"n_gpus": num_gpus,
"batch_size": batch_size,
"learning_rate": learning_rate
}
tensorflow_huggingface_estimator=HuggingFace(
entry_point='train.py',
instance_count=instance_count,
instance_type=instance_type,
transformers_version='4.21.1',
tensorflow_version='2.6.3',
hyperparameters=hyperparameters,
compiler_config=TrainingCompilerConfig(),
disable_profiler=True,
debugger_hook_config=False
)
tensorflow_huggingface_estimator.fit()
```
**Astuce**
Pour préparer votre script d’entraînement, consultez les pages suivantes.
[Pour l’entraînement distribué](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-keras-distributed)d'un modèle TensorFlow Keras avec Hugging Face Transformers
[Pour l’entraînement distribué](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-no-keras-distributed)d'un TensorFlow modèle avec Hugging Face Transformers
------
La liste suivante représente l'ensemble minimal de paramètres requis pour exécuter une tâche d' SageMaker entraînement avec le compilateur.
**Note**
Lorsque vous utilisez l'estimateur SageMaker AI Hugging Face, vous devez spécifier `transformers_version` les paramètres, `tensorflow_version``hyperparameters`, `compiler_config` et pour activer Training Compiler SageMaker . Vous ne pouvez pas utiliser `image_uri` pour spécifier manuellement les conteneurs de deep learning intégrés à Training Compiler qui sont répertoriés dans [Cadres pris en charge](training-compiler-support.md#training-compiler-supported-frameworks).
+ `entry_point` (str) : obligatoire. Spécifiez le nom de fichier de votre script d’entraînement.
+ `instance_count` (int) : obligatoire. Spécifiez le nombre d’instances.
+ `instance_type` (str) : obligatoire. Spécifiez le type d’instance.
+ `transformers_version`(str) — Obligatoire uniquement lors de l'utilisation de l' SageMaker estimateur AI Hugging Face. Spécifiez la version de la bibliothèque Hugging Face Transformers prise en charge SageMaker par Training Compiler. Pour trouver les versions disponibles, consultez [Cadres pris en charge](training-compiler-support.md#training-compiler-supported-frameworks).
+ `framework_version` ou `tensorflow_version` (str) : obligatoire. Spécifiez la TensorFlow version prise en charge par SageMaker Training Compiler. Pour trouver les versions disponibles, consultez [Cadres pris en charge](training-compiler-support.md#training-compiler-supported-frameworks).
**Note**
Lorsque vous utilisez l' TensorFlow estimateur SageMaker AI, vous devez spécifier. `framework_version`
Lorsque vous utilisez l'estimateur SageMaker AI Hugging Face, vous devez spécifier à la fois et. `transformers_version` `tensorflow_version`
+ `hyperparameters` (dict) : facultatif. Spécifiez des hyperparamètres pour la tâche d’entraînement, tels que `n_gpus`, `batch_size` et `learning_rate`. Lorsque vous activez SageMaker Training Compiler, essayez des lots de plus grande taille et ajustez le taux d'apprentissage en conséquence. Pour trouver des études de cas sur l’utilisation du compilateur et l’ajustement de la taille des lots pour améliorer la vitesse d’entraînement, consultez [Modèles testés](training-compiler-support.md#training-compiler-tested-models) et [SageMaker Compilateur de formation : exemples de blocs-notes et de blogs](training-compiler-examples-and-blogs.md).
+ `compiler_config`(TrainingCompilerConfig objet) — Obligatoire. Incluez ce paramètre pour activer le compilateur SageMaker d'entraînement. Les paramètres suivants sont destinés à la classe `TrainingCompilerConfig`.
+ `enabled` (bool) : facultatif. Spécifiez `True` ou `False` activez ou désactivez le compilateur SageMaker d'entraînement. La valeur par défaut est `True`.
+ `debug` (bool) : facultatif. Pour recevoir des journaux d’entraînement plus détaillés de vos tâches d’entraînement accélérées par le compilateur, remplacez la valeur par `True`. Cependant, la journalisation supplémentaire peut ajouter une surcharge et ralentir la tâche d’entraînement compilé. La valeur par défaut est `False`.
**Avertissement**
Si vous activez SageMaker Debugger, cela peut avoir un impact sur les performances de SageMaker Training Compiler. Nous vous recommandons de désactiver le débogueur lorsque vous exécutez SageMaker Training Compiler pour vous assurer que cela n'a aucun impact sur les performances. Pour de plus amples informations, veuillez consulter [Considérations](training-compiler-tips-pitfalls.md#training-compiler-tips-pitfalls-considerations). Pour désactiver les fonctionnalités de Debugger, ajoutez les deux arguments suivants à l’estimateur :
```
disable_profiler=True,
debugger_hook_config=False
```
Si la tâche d’entraînement avec le compilateur est lancée avec succès, vous recevez les journaux suivants lors de la phase d’initialisation de la tâche :
+ Avec `TrainingCompilerConfig(debug=False)`
```
Found configuration for Training Compiler
Configuring SM Training Compiler...
```
+ Avec `TrainingCompilerConfig(debug=True)`
```
Found configuration for Training Compiler
Configuring SM Training Compiler...
Training Compiler set to debug mode
```
## Utilisation du SDK SageMaker AI Python et extension du framework SageMaker AI (Deep Learning Containers)
AWS Deep Learning Containers (DLC) à TensorFlow utiliser des versions adaptées TensorFlow qui incluent des modifications en plus du framework open source TensorFlow . Les [Deep Learning Containers du framework SageMaker AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) sont optimisés pour l' AWS infrastructure sous-jacente et Amazon SageMaker AI. Avec l'avantage d'utiliser le DLCs, l'intégration du compilateur d' SageMaker entraînement améliore davantage les performances par rapport à la version native TensorFlow. En outre, vous pouvez créer un conteneur d’entraînement personnalisé en étendant l’image DLC.
**Note**
Cette fonctionnalité de personnalisation de Docker n'est actuellement disponible que pour TensorFlow.
Pour étendre et personnaliser l' SageMaker IA en fonction TensorFlow DLCs de votre cas d'utilisation, suivez les instructions suivantes.
### Création d’un fichier Dockerfile
Utilisez le modèle Dockerfile suivant pour étendre le DLC SageMaker AI TensorFlow . Vous devez utiliser l'image du TensorFlow DLC SageMaker AI comme image de base de votre conteneur Docker. Pour trouver l'image du TensorFlow DLC SageMaker AI URIs, consultez [Frameworks pris en charge](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-support.html#training-compiler-supported-frameworks).
```
# SageMaker AI TensorFlow Deep Learning Container image
FROM 763104351884.dkr.ecr..amazonaws.com/tensorflow-training:
ENV PATH="/opt/ml/code:${PATH}"
# This environment variable is used by the SageMaker AI container
# to determine user code directory.
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code
# Add more code lines to customize for your use-case
...
```
Pour plus d’informations, consultez [Étape 2 : créer et télécharger le fichier Dockerfile et les scripts d’entraînement Python](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step2).
Tenez compte des écueils suivants lorsque vous étendez le cadre DLCs d' SageMaker IA :
+ Ne désinstallez pas ou ne modifiez pas explicitement la version des TensorFlow packages dans les conteneurs SageMaker AI. Cela entraîne le remplacement des TensorFlow packages AWS optimisés par des packages open source TensorFlow , ce qui peut entraîner une dégradation des performances.
+ Faites attention aux packages qui ont une TensorFlow version ou une saveur particulière en tant que dépendance. Ces packages peuvent implicitement désinstaller les packages AWS optimisés TensorFlow et installer des packages open source TensorFlow .
[Par exemple, il existe un problème connu selon lequel les bibliothèques [tensorflow/models et [tensorflow/text](https://github.com/tensorflow/text)](https://github.com/tensorflow/models) tentent toujours de réinstaller l'open source. TensorFlow](https://github.com/tensorflow/models/issues/9267) Si vous devez installer ces bibliothèques pour choisir une version spécifique à votre cas d'utilisation, nous vous recommandons de consulter le TensorFlow DLC SageMaker AI Dockerfiles pour la version 2.9 ou ultérieure. Les chemins d’accès aux fichiers Dockerfile sont généralement au format suivant : `tensorflow/training/docker//py3//Dockerfile.gpu`. Dans les Dockerfiles, vous devriez trouver les lignes de code pour réinstaller le TensorFlow binaire AWS géré (spécifié dans la variable d'`TF_URL`environnement) et les autres dépendances dans l'ordre. La section de réinstallation doit ressembler à l’exemple suivant :
```
# tf-models does not respect existing installations of TensorFlow
# and always installs open source TensorFlow
RUN pip3 install --no-cache-dir -U \
tf-models-official==x.y.z
RUN pip3 uninstall -y tensorflow tensorflow-gpu \
; pip3 install --no-cache-dir -U \
${TF_URL} \
tensorflow-io==x.y.z \
tensorflow-datasets==x.y.z
```
### Génération et envoi (push) vers ECR
Pour générer et envoyer (push) votre conteneur Docker vers Amazon ECR, suivez les instructions des liens suivants :
+ [Étape 3 : créer le conteneur](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step3)
+ [Étape 4 : tester le conteneur](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step4)
+ [Étape 5 : pousser le conteneur vers Amazon ECR](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step5)
### Exécuter à l'aide de l' SageMaker estimateur du SDK Python
Utilisez l'estimateur TensorFlow du framework SageMaker AI comme d'habitude. Vous devez spécifier `image_uri` pour utiliser le nouveau conteneur que vous avez hébergé dans Amazon ECR.
```
import sagemaker, boto3
from sagemaker import get_execution_role
from sagemaker.tensorflow import TensorFlow, TrainingCompilerConfig
account_id = boto3.client('sts').get_caller_identity().get('Account')
ecr_repository = 'tf-custom-container-test'
tag = ':latest'
region = boto3.session.Session().region_name
uri_suffix = 'amazonaws.com'
byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format(
account_id, region, uri_suffix, ecr_repository + tag
)
byoc_image_uri
# This should return something like
# 111122223333.dkr.ecr.us-east-2.amazonaws.com/tf-custom-container-test:latest
estimator = TensorFlow(
image_uri=image_uri,
role=get_execution_role(),
base_job_name='tf-custom-container-test-job',
instance_count=1,
instance_type='ml.p3.8xlarge'
compiler_config=TrainingCompilerConfig(),
disable_profiler=True,
debugger_hook_config=False
)
# Start training
estimator.fit()
```
## Activer le compilateur SageMaker d'entraînement à l'aide de l'opération `CreateTrainingJob` d'API SageMaker AI
SageMaker Les options de configuration du compilateur de formation doivent être spécifiées via le `HyperParameters` champ `AlgorithmSpecification` et dans la syntaxe de la demande pour l'[opération `CreateTrainingJob` d'API](https://amazonaws.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html).
```
"AlgorithmSpecification": {
"TrainingImage": ""
},
"HyperParameters": {
"sagemaker_training_compiler_enabled": "true",
"sagemaker_training_compiler_debug_mode": "false"
}
```
Pour trouver la liste complète des images de conteneurs de deep learning sur URIs lesquelles SageMaker Training Compiler est implémenté, consultez[Cadres pris en charge](training-compiler-support.md#training-compiler-supported-frameworks).
# SageMaker Compilateur de formation : exemples de blocs-notes et de blogs
**Important**
Amazon Web Services (AWS) annonce qu'il n'y aura aucune nouvelle version ou version de SageMaker Training Compiler. Vous pouvez continuer à utiliser SageMaker Training Compiler via les AWS Deep Learning Containers (DLCs) for SageMaker Training existants. Il est important de noter que tant que les versions existantes DLCs resteront accessibles, elles ne recevront plus de correctifs ni de mises à jour AWS, conformément à la [politique de support du AWS Deep Learning Containers Framework](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html).
Les blogs, études de cas et carnets suivants fournissent des exemples de la manière d'implémenter SageMaker Training Compiler.
Des carnets d'exemples sont fournis dans le [ GitHub référentiel d'exemples d'SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-training-compiler), et vous pouvez également les parcourir sur le [site Web d'exemples d'SageMaker IA](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/index.html).
## Blogs et études de cas
Les blogs suivants présentent des études de cas sur l'utilisation de SageMaker Training Compiler.
+ [Nouveau — Présentation du compilateur SageMaker de formation](https://aws.amazon.com/blogs/aws/new-introducing-sagemaker-training-compiler/)
+ [Hugging Face Transformers BERT peaufiné à l'aide d'Amazon Training SageMaker Compiler](https://www.philschmid.de/huggingface-amazon-sagemaker-training-compiler)
+ [Accélérez jusqu'à 50 % les tâches d'entraînement AWS sur Hugging Face SageMaker avec Training Compiler](https://towardsdatascience.com/speed-up-hugging-face-training-jobs-on-aws-by-up-to-50-with-sagemaker-training-compiler-9ad2ac5b0eb)
## Exemples de blocs-notes
Pour trouver des exemples d'utilisation de SageMaker Training Compiler, consultez la [page Training Compiler sur](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/index.html) le *site Web Amazon SageMaker AI Example Read the Docs*.
# SageMaker Bonnes pratiques et considérations relatives à la formation des compilateurs
**Important**
Amazon Web Services (AWS) annonce qu'il n'y aura aucune nouvelle version ou version de SageMaker Training Compiler. Vous pouvez continuer à utiliser SageMaker Training Compiler via les AWS Deep Learning Containers (DLCs) for SageMaker Training existants. Il est important de noter que tant que les versions existantes DLCs resteront accessibles, elles ne recevront plus de correctifs ni de mises à jour AWS, conformément à la [politique de support du AWS Deep Learning Containers Framework](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html).
Consultez les meilleures pratiques et considérations suivantes lors de l'utilisation de SageMaker Training Compiler.
## Bonnes pratiques
Suivez les instructions suivantes pour obtenir les meilleurs résultats lorsque vous exécutez des tâches d'entraînement avec SageMaker Training Compiler.
**Bonnes pratiques d’ordre général**
+ Pensez à consulter [Types d’instance pris en charge](training-compiler-support.md#training-compiler-supported-instance-types) et [Modèles testés](training-compiler-support.md#training-compiler-tested-models).
+ Lorsque vous créez un générateur de jetons pour un modèle NLP en utilisant la bibliothèque des transformeurs Hugging Face dans votre script d’entraînement, veillez à utiliser une forme de tenseur d’entrée statique en spécifiant `padding='max_length'`. N’utilisez pas `padding='longest'`, car le remplissage à la séquence la plus longue du lot peut changer la forme du tenseur pour chaque lot d’entraînement. La forme d’entrée dynamique peut déclencher une recompilation du modèle et augmenter la durée totale d’entraînement. Pour obtenir plus d’informations sur les options de remplissage des créateurs de jetons de transformeur, consultez [Remplissage et troncature](https://huggingface.co/docs/transformers/pad_truncation) dans la *documentation des transformeurs Hugging Face*.
+ Mesurez l’utilisation de la mémoire du GPU pour vous assurer que vous utilisez la taille maximale de lot que peut contenir cette mémoire. Amazon SageMaker Training Compiler réduit l'empreinte mémoire de votre modèle pendant l'entraînement, ce qui vous permet généralement d'augmenter la `batch_size` capacité de mémoire du GPU. L’utilisation d’une `batch_size` plus importante permet une meilleure utilisation du GPU et réduit la durée totale de l’entraînement.
Lorsque vous ajustez la taille du lot, vous devez également ajuster `learning_rate` de manière appropriée. Par exemple, si vous avez augmenté la taille du lot d’un facteur de `k`, vous devez procéder à un ajustement linéaire de `learning_rate` (simple multiplication par `k`) ou multiplier par la racine carrée de `k`. Vous obtiendrez ainsi un comportement de convergence identique ou similaire avec un temps d’entraînement réduit. Pour connaître les références des tests de `batch_size` pour les modèles les plus populaires, consultez [Modèles testés](training-compiler-support.md#training-compiler-tested-models).
+ Pour déboguer la tâche d’entraînement accélérée par le compilateur, activez l’indicateur `debug` dans le paramètre `compiler_config`. Cela permet à SageMaker l'IA de placer les journaux de débogage dans les journaux des tâches de SageMaker formation.
```
huggingface_estimator=HuggingFace(
...
compiler_config=TrainingCompilerConfig(debug=True)
)
```
Notez que si vous activez le débogage complet de la tâche d’entraînement avec le compilateur, cela peut ajouter une surcharge.
**Bonnes pratiques pour PyTorch**
+ Si vous apportez un PyTorch modèle et que vous souhaitez le contrôler, assurez-vous d'utiliser la fonction de sauvegarde du modèle de PyTorch /XLA pour vérifier correctement votre modèle. Pour plus d'informations sur cette fonction, consultez [https://pytorch.org/xla/release/1.9/index.html#torch_xla.core.xla_model.save](https://pytorch.org/xla/release/1.9/index.html#torch_xla.core.xla_model.save)la *documentation PyTorch sur les appareils XLA*.
Pour savoir comment ajouter les modifications à votre PyTorch script, consultez[Utilisation PyTorch directe de grands modèles linguistiques (sans l'API Hugging Face Transformers Trainer)](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer).
Pour plus d'informations sur l'application réelle de l'utilisation de la fonction de sauvegarde du modèle, consultez le blog de formation [Checkpoint Writing and Loading](https://huggingface.co/blog/pytorch-xla#checkpoint-writing-and-loading) in the *Hugging Face on PyTorch/XLA TPUs : Faster and cheaper*.
+ Pour bénéficier d’une durée d’entraînement optimale pour l’entraînement distribué, considérez ce qui suit.
+ Utilisez des instances à plusieurs GPUs au lieu d'utiliser des instances à processeur graphique unique. Par exemple, une seule instance `ml.p3dn.24xlarge` présente une durée d’entraînement plus courte que 8 instances `ml.p3.2xlarge`.
+ Utilisez des instances avec prise en charge d’EFA, telles que `ml.p3dn.24xlarge` ou `ml.p4d.24xlarge`. Ces types d’instance présentent de plus grandes vitesses réseau et réduisent la durée d’entraînement.
+ Réglez le paramètre `preprocessing_num_workers` pour les jeux de données, afin que l’entraînement des modèles ne soit pas retardé par un prétraitement lent.
## Considérations
Tenez compte des points suivants lorsque vous utilisez SageMaker Training Compiler.
### Dégradation des performances en raison de la journalisation, des points de contrôle et du profilage
+ Évitez la journalisation, les points de contrôle et le profilage des tenseurs de modèles qui conduisent à des évaluations explicites. Pour comprendre ce qu’est une évaluation explicite, prenons l’exemple de compilation de code suivant.
```
a = b+c
e = a+d
```
Un compilateur interprète le code comme suit et réduit l’empreinte mémoire de la variable `a` :
```
e = b+c+d
```
Considérons maintenant le cas suivant où le code est modifié pour ajouter une fonction d’affichage de la variable `a`.
```
a = b+c
e = a+d
print(a)
```
Le compilateur effectue une évaluation explicite de la variable `a` comme suit.
```
e = b+c+d
a = b+c # Explicit evaluation
print(a)
```
Par exemple PyTorch, évitez d'utiliser [torch.tensor.items ()](https://pytorch.org/docs/stable/generated/torch.Tensor.item.html), qui pourrait introduire des évaluations explicites. Dans le cadre du deep learning, ces évaluations explicites peuvent entraîner une surcharge, car elles rompent les opérations fusionnées dans le graphe de compilation d’un modèle et conduisent à un nouveau calcul des tenseurs.
Si vous souhaitez toujours évaluer régulièrement le modèle pendant l'entraînement tout en utilisant SageMaker Training Compiler, nous vous recommandons d'enregistrer et de vérifier à une fréquence plus faible afin de réduire les frais liés aux évaluations explicites. Par exemple, effectuez une journalisation toutes les 10 époques plutôt qu’à chaque époque.
+ La compilation des graphes est exécutée durant les premières étapes de l’entraînement. Par conséquent, les premières étapes sont généralement très lentes. Cependant, il s’agit d’un coût de compilation unique qui peut être amorti par un entraînement de plus longue durée, car la compilation permet d’accélérer considérablement les prochaines étapes. La surcharge de compilation initiale dépend de la taille du modèle, de la taille des tenseurs d’entrée et de la distribution des formes des tenseurs d’entrée.
### Utilisation incorrecte du PyTorch/XLA APIs lors de l'utilisation PyTorch directe
PyTorch/XLA définit un ensemble de APIs pour remplacer une partie de la formation existante PyTorch. APIs Le fait de ne pas les utiliser correctement entraîne l'échec de la PyTorch formation.
+ L'une des erreurs les plus courantes lors de la compilation d'un PyTorch modèle est due à un type d'appareil incorrect pour les opérateurs et les tenseurs. Pour compiler correctement un PyTorch modèle, assurez-vous d'utiliser des périphériques XLA ([https://pytorch.org/xla/release/1.9/index.html](https://pytorch.org/xla/release/1.9/index.html)) au lieu d'utiliser CUDA ou de mélanger des périphériques CUDA et des périphériques XLA.
+ `mark_step()` est une barrière uniquement pour XLA. Si la tâche d’entraînement n’est pas correctement définie, cela entraînera son blocage.
+ PyTorch/XLA fournit une formation distribuée supplémentaire. APIs Le fait de ne pas les programmer APIs correctement entraîne une collecte incorrecte des dégradés, ce qui entraîne un échec de la convergence d'entraînement.
Pour configurer correctement votre PyTorch script et éviter les utilisations incorrectes de l'API susmentionnées, consultez[Utilisation PyTorch directe de grands modèles linguistiques (sans l'API Hugging Face Transformers Trainer)](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer).
# SageMaker FAQ sur le compilateur de formation
**Important**
Amazon Web Services (AWS) annonce qu'il n'y aura aucune nouvelle version ou version de SageMaker Training Compiler. Vous pouvez continuer à utiliser SageMaker Training Compiler via les AWS Deep Learning Containers (DLCs) for SageMaker Training existants. Il est important de noter que tant que les versions existantes DLCs resteront accessibles, elles ne recevront plus de correctifs ni de mises à jour AWS, conformément à la [politique de support du AWS Deep Learning Containers Framework](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html).
Utilisez les éléments de FAQ suivants pour trouver les réponses aux questions fréquemment posées sur SageMaker Training Compiler.
**Q. Comment savoir si SageMaker Training Compiler fonctionne ?**
Si vous avez lancé avec succès votre tâche de formation avec SageMaker Training Compiler, vous recevez les messages de journal suivants :
+ Avec `TrainingCompilerConfig(debug=False)`
```
Found configuration for Training Compiler
Configuring SM Training Compiler...
```
+ Avec `TrainingCompilerConfig(debug=True)`
```
Found configuration for Training Compiler
Configuring SM Training Compiler...
Training Compiler set to debug mode
```
**Q. Quels modèles sont accélérés par SageMaker Training Compiler ?**
SageMaker Training Compiler prend en charge les modèles d'apprentissage profond les plus populaires de la bibliothèque Hugging Face Transformers. Avec la plupart des opérateurs pris en charge par le compilateur, ces modèles peuvent être entraînés plus rapidement avec SageMaker Training Compiler. Les modèles compilables incluent, sans s’y limiter, les éléments suivants : `bert-base-cased`, `bert-base-chinese`, `bert-base-uncased`, `distilbert-base-uncased`, `distilbert-base-uncased-finetuned-sst-2-english`, `gpt2`, `roberta-base`, `roberta-large`, `t5-base` et `xlm-roberta-base`. Le compilateur fonctionne avec la plupart des opérateurs et structures de données de DL et peut accélérer de nombreux autres modèles de DL au-delà de ceux qui ont été testés.
**Q : Que se passe-t-il si j'active SageMaker Training Compiler avec un modèle qui n'a pas été testé ?**
Pour un modèle non testé, vous devrez peut-être d'abord modifier le script d'entraînement pour qu'il soit compatible avec SageMaker Training Compiler. Pour obtenir plus d’informations, consultez [Apporter votre propre modèle de deep learning](training-compiler-modify-scripts.md) et suivez les instructions de préparation de votre script d’entraînement.
Une fois que vous avez mis à jour votre script d’entraînement, vous pouvez démarrer la tâche d’entraînement. Le compilateur procède à la compilation du modèle. Cependant, la vitesse d’entraînement peut ne pas augmenter et peut même diminuer par rapport à la ligne de base avec un modèle non testé. Vous devrez peut-être réajuster les paramètres d’entraînement tels que `batch_size` et `learning_rate` pour obtenir des avantages d’accélération.
Si la compilation du modèle non testé échoue, le compilateur renvoie une erreur. Consultez [SageMaker Résolution des problèmes liés au compilateur](training-compiler-troubleshooting.md) pour obtenir des informations détaillées sur les types d’échec et les messages d’erreur.
**Q. Est-ce que j'obtiendrai toujours un poste de formation plus rapide avec SageMaker Training Compiler ?**
Non, pas nécessairement. Tout d'abord, SageMaker Training Compiler ajoute une certaine charge de compilation avant que le processus de formation en cours ne puisse être accéléré. La tâche d’entraînement optimisée doit s’exécuter suffisamment longtemps pour amortir et compenser cette surcharge de compilation incrémentielle au début de la tâche d’entraînement.
De plus, comme pour tout processus d'entraînement par modèle, l'entraînement avec des paramètres sous-optimaux peut augmenter le temps d'entraînement. SageMaker Training Compiler peut modifier les caractéristiques de la tâche d'entraînement, par exemple en modifiant l'empreinte mémoire de la tâche. En raison de ces différences, vous devrez peut-être réajuster les paramètres de votre tâche d’entraînement pour accélérer l’entraînement. Un tableau de référence spécifiant les paramètres les plus performants pour les tâches d’entraînement avec différents types d’instances et modèles est disponible depuis la page [Modèles testés](training-compiler-support.md#training-compiler-tested-models).
Enfin, du code dans un script d’entraînement peut ajouter une surcharge supplémentaire ou perturber le graphique de calcul compilé et ralentir l’entraînement. Si vous travaillez avec un modèle personnalisé ou non testé, consultez les instructions sur [Bonnes pratiques pour utiliser le compilateur SageMaker d'entraînement avec PyTorch /XLA](training-compiler-pytorch-models.md#training-compiler-pytorch-models-best-practices).
**Q : Puis-je toujours utiliser un lot de plus grande taille avec SageMaker Training Compiler ?**
La taille du lot augmente dans la plupart des cas, mais pas toujours. Les optimisations apportées par SageMaker Training Compiler peuvent modifier les caractéristiques de votre tâche d'entraînement, telles que l'empreinte mémoire. En règle générale, une tâche de compilateur d’entraînement occupe moins de mémoire qu’une tâche d’entraînement non compilée avec le cadre natif, ce qui permet une taille de lot supérieure pendant l’entraînement. Une taille de lot plus importante et un ajustement correspondant du taux d’entraînement augmentent le débit d’entraînement et peuvent réduire le temps total d’entraînement.
Cependant, dans certains cas, SageMaker Training Compiler peut réellement augmenter l'empreinte mémoire en fonction de son schéma d'optimisation. Le compilateur utilise un modèle de coût analytique pour prédire le calendrier d’exécution avec le coût d’exécution le plus bas pour tout opérateur de calcul intensif. Ce modèle pourrait trouver une planification optimale qui augmente l’utilisation de la mémoire. Dans ce cas, vous ne pourrez pas augmenter la taille des lots, mais votre débit d’échantillons est toujours plus élevé.
**Q. Le compilateur de SageMaker formation fonctionne-t-il avec d'autres fonctionnalités de SageMaker formation, telles que les bibliothèques de formation distribuées par l' SageMaker IA et le SageMaker Debugger ?**
SageMaker Training Compiler n'est actuellement pas compatible avec les bibliothèques de formation distribuées de l' SageMaker IA.
SageMaker Training Compiler est compatible avec SageMaker Debugger, mais Debugger peut dégrader les performances de calcul en ajoutant de la surcharge.
**Q. Est-ce que SageMaker Training Compiler prend en charge les conteneurs personnalisés (apportez votre propre conteneur) ?**
SageMaker Le compilateur de formation est fourni via AWS Deep Learning Containers, et vous pouvez étendre un sous-ensemble de conteneurs pour les personnaliser en fonction de votre cas d'utilisation. Les conteneurs étendus depuis AWS DLCs sont pris en charge par SageMaker Training Compiler. Pour plus d’informations, consultez [Frameworks pris en charge](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-support.html#training-compiler-supported-frameworks) et [Utilisation du SDK SageMaker AI Python et extension du framework SageMaker AI (Deep Learning Containers)](training-compiler-enable-tensorflow.md#training-compiler-enable-tensorflow-sdk-extend-container). Si vous avez besoin d'une assistance supplémentaire, contactez l'équipe SageMaker AI via le [AWS support](https://console.aws.amazon.com/support/) ou [les forums de AWS développeurs pour Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285).
# SageMaker Résolution des problèmes liés au compilateur
**Important**
Amazon Web Services (AWS) annonce qu'il n'y aura aucune nouvelle version ou version de SageMaker Training Compiler. Vous pouvez continuer à utiliser SageMaker Training Compiler via les AWS Deep Learning Containers (DLCs) for SageMaker Training existants. Il est important de noter que tant que les versions existantes DLCs resteront accessibles, elles ne recevront plus de correctifs ni de mises à jour AWS, conformément à la [politique de support du AWS Deep Learning Containers Framework](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html).
Si vous rencontrez une erreur, vous pouvez utiliser la liste suivante pour essayer de résoudre votre tâche d’entraînement. Si vous avez besoin d'une assistance supplémentaire, contactez l'équipe SageMaker AI via le [AWS support](https://console.aws.amazon.com/support/) ou [les forums de AWS développeurs pour Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285).
## La tâche d’entraînement ne converge pas comme prévu par rapport à la tâche d’entraînement du cadre natif
Les problèmes de convergence vont de « le modèle n'apprend pas lorsque le compilateur de SageMaker formation est activé » à « le modèle apprend mais plus lentement que le framework natif ». Dans ce guide de résolution des problèmes, nous partons du principe que votre convergence est satisfaisante sans SageMaker Training Compiler (dans le framework natif) et nous considérons cela comme une référence.
Face à de tels problèmes de convergence, la première étape consiste à déterminer si le problème se limite à l’entraînement distribué ou s’il provient d’un entraînement sur un seul GPU. La formation distribuée avec SageMaker Training Compiler est une extension de la formation avec un seul GPU avec des étapes supplémentaires.
1. Configurez un cluster avec plusieurs instances ou GPUs.
1. Distribuez les données d’entrée à tous les collaborateurs.
1. Synchronisez les mises à jour du modèle émanant de tous les collaborateurs.
Par conséquent, tout problème de convergence lié à l’entraînement sur un seul GPU se propage à l’entraînement distribué impliquant plusieurs collaborateurs.
![\[Un organigramme pour résoudre les problèmes de convergence dans les tâches de formation lors de l'utilisation de SageMaker Training Compiler.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/training-compiler-troubleshooting-convergence-flow.jpg)
### Problèmes de convergence survenant lors de l’entraînement sur un seul GPU
Si votre problème de convergence provient d'un entraînement avec un seul GPU, cela est probablement dû à des paramètres incorrects pour les hyperparamètres ou le. `torch_xla` APIs
**Vérifier les hyperparamètres**
L'entraînement avec SageMaker Training Compiler entraîne une modification de l'empreinte mémoire d'un modèle. Le compilateur arbitre intelligemment la réutilisation et le recalcul, ce qui entraîne une augmentation ou une diminution correspondante de la consommation de mémoire. Pour en tirer parti, il est essentiel de réajuster la taille du lot et les hyperparamètres associés lors de la migration d'une tâche de formation vers Training Compiler SageMaker . Cependant, de mauvais réglages des hyperparamètres provoquent souvent des oscillations dans la perte d’entraînement et, par conséquent, un ralentissement possible de la convergence. Dans de rares cas, des hyperparamètres agressifs peuvent empêcher le modèle d’apprendre (la métrique de perte d’entraînement ne diminue pas ou ne revient pas sur `NaN`). Pour déterminer si le problème de convergence est dû aux hyperparamètres, side-by-side testez deux tâches d'entraînement avec et sans SageMaker Training Compiler tout en conservant les mêmes hyperparamètres.
**Vérifiez s'ils `torch_xla` APIs sont correctement configurés pour l'entraînement avec un seul GPU**
Si le problème de convergence persiste avec les hyperparamètres de base, vous devez vérifier s'ils ne sont pas utilisés de manière incorrecte `torch_xla` APIs, en particulier ceux utilisés pour mettre à jour le modèle. Fondamentalement, `torch_xla` continue d’accumuler des instructions (en différant l’exécution) sous forme de graphe jusqu’à ce qu’il soit explicitement invité à exécuter le graphe accumulé. La fonction `torch_xla.core.xla_model.mark_step()` facilite l’exécution du graphe accumulé. L’exécution du graphe doit être synchronisée à l’aide de cette fonction ***après chaque mise à jour du modèle*** et ***avant d’imprimer et de journaliser des variables***. Sans étape de synchronisation, le modèle peut utiliser des valeurs périmées stockées en mémoire lors des impressions, des journaux et des transferts ultérieurs, au lieu d’utiliser les valeurs les plus récentes qui doivent être synchronisées après chaque itération et mise à jour du modèle.
Cela peut être plus compliqué lorsque vous utilisez SageMaker Training Compiler avec des techniques de mise à l'échelle du dégradé (éventuellement à l'aide d'AMP) ou de découpage en dégradé. L’ordre approprié de calcul du gradient avec AMP est le suivant.
1. Calcul du gradient avec mise à l’échelle
1. Mise à l’échelle décroissante du gradient, écrêtage de gradient, puis mise à l’échelle croissante
1. Mise à jour du modèle
1. Synchronisation de l’exécution du graphe avec `mark_step()`
Pour trouver la solution APIs adaptée aux opérations mentionnées dans la liste, consultez le guide de [migration de votre script d'entraînement vers SageMaker Training Compiler](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-pytorch-models.html).
**Envisagez d’utiliser le réglage de modèle automatique**
Si le problème de convergence survient lors du réajustement de la taille du lot et des hyperparamètres associés tels que le taux d'apprentissage lors de l'utilisation du compilateur d' SageMaker entraînement, envisagez d'utiliser le [réglage automatique du modèle](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning.html) pour ajuster vos hyperparamètres. Vous pouvez vous référer à l'[exemple de bloc-notes sur le réglage des hyperparamètres avec SageMaker Training Compiler](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-training-compiler/tensorflow/single_gpu_single_node/hyper-parameter-tuning.ipynb).
### Problèmes de convergence survenant lors de l’entraînement distribué
Si votre problème de convergence persiste lors de l'entraînement distribué, cela est probablement dû à des paramètres incorrects pour l'initialisation du poids ou à. `torch_xla` APIs
**Vérifier l’initialisation du poids chez les collaborateurs**
Si le problème de convergence survient lors de l’exécution d’une tâche d’entraînement distribué impliquant plusieurs collaborateurs, assurez-vous qu’il existe un comportement déterministe uniforme pour tous les collaborateurs en définissant une vitesse constante, le cas échéant. Méfiez-vous des techniques telles que l’initialisation du poids qui implique une randomisation. Chaque collaborateur peut finir par entraîner un modèle différent en l’absence d’une valeur constante.
**Vérifiez s'ils `torch_xla` APIs sont correctement configurés pour la formation distribuée**
Si le problème persiste, cela est probablement dû à une mauvaise utilisation du `torch_xla` APIs pour la formation distribuée. Assurez-vous d'ajouter les éléments suivants dans votre estimateur pour configurer un cluster pour l'entraînement distribué avec SageMaker Training Compiler.
```
distribution={'torchxla': {'enabled': True}}
```
Votre script d’entraînement doit également contenir une fonction `_mp_fn(index)`, qui est appelée une fois par collaborateur. Sans cette fonction `mp_fn(index)`, vous risquez de laisser chaque collaborateur entraîner le modèle de manière indépendante sans partager les mises à jour du modèle.
Ensuite, assurez-vous d'utiliser l'`torch_xla.distributed.parallel_loader.MpDeviceLoader`API avec l'échantillonneur de données distribué, comme indiqué dans la documentation sur la [migration de votre script d'entraînement vers SageMaker Training Compiler](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-pytorch-models.html), comme dans l'exemple suivant.
```
torch.utils.data.distributed.DistributedSampler()
```
Cela garantit que les données d’entrée sont correctement distribuées entre tous les collaborateurs.
Enfin, pour synchroniser les mises à jour du modèle provenant de tous les collaborateurs, utilisez `torch_xla.core.xla_model._fetch_gradients` pour rassembler les gradients de tous les collaborateurs et `torch_xla.core.xla_model.all_reduce` pour combiner tous les gradients collectés en une seule mise à jour.
Cela peut être plus compliqué lorsque vous utilisez SageMaker Training Compiler avec des techniques de mise à l'échelle du dégradé (éventuellement en utilisant l'AMP) ou des techniques de découpage en dégradé. L’ordre approprié de calcul du gradient avec AMP est le suivant.
1. Calcul du gradient avec mise à l'échelle
1. Synchronisation du gradient entre tous les collaborateurs
1. Mise à l’échelle décroissante du gradient, écrêtage de gradient, puis mise à l’échelle croissante du gradient
1. Mise à jour du modèle
1. Synchronisation de l'exécution du graphe avec `mark_step()`
Notez que cette liste de contrôle contient un élément supplémentaire pour la synchronisation de tous les collaborateurs par rapport à la liste de contrôle pour l’entraînement sur un seul GPU.
## La tâche de formation échoue en raison d'une PyTorch/XLA configuration manquante
Si une tâche de formation échoue avec le message `Missing XLA configuration` d'erreur, cela peut être dû à une mauvaise configuration du nombre de GPUs par instance que vous utilisez.
XLA nécessite des variables d’environnement supplémentaires pour compiler la tâche d’entraînement. La variable d’environnement manquante la plus courante est `GPU_NUM_DEVICES`. Pour que le compilateur fonctionne correctement, vous devez définir cette variable d'environnement égale au nombre de GPUs par instance.
Il existe trois approches pour définir la variable d’environnement `GPU_NUM_DEVICES` :
+ **Approche 1** — Utilisez l'`environment`argument de la classe d'estimateur SageMaker AI. Par exemple, si vous utilisez une `ml.p3.8xlarge` instance qui en possède quatre GPUs, procédez comme suit :
```
# Using the SageMaker Python SDK's HuggingFace estimator
hf_estimator=HuggingFace(
...
instance_type="ml.p3.8xlarge",
hyperparameters={...},
environment={
...
"GPU_NUM_DEVICES": "4" # corresponds to number of GPUs on the specified instance
},
)
```
+ **Approche 2** — Utilisez l'`hyperparameters`argument de la classe d'estimateur SageMaker AI et analysez-le dans votre script d'entraînement.
1. Pour spécifier le nombre de GPUs, ajoutez une paire clé-valeur à l'`hyperparameters`argument.
Par exemple, si vous utilisez une `ml.p3.8xlarge` instance qui en possède quatre GPUs, procédez comme suit :
```
# Using the SageMaker Python SDK's HuggingFace estimator
hf_estimator=HuggingFace(
...
entry_point = "train.py"
instance_type= "ml.p3.8xlarge",
hyperparameters = {
...
"n_gpus": 4 # corresponds to number of GPUs on specified instance
}
)
hf_estimator.fit()
```
1. Dans votre script d’entraînement, analysez l’hyperparamètre `n_gpus` et spécifiez-le en tant qu’entrée pour la variable d’environnement `GPU_NUM_DEVICES`.
```
# train.py
import os, argparse
if __name__ == "__main__":
parser = argparse.ArgumentParser()
...
# Data, model, and output directories
parser.add_argument("--output_data_dir", type=str, default=os.environ["SM_OUTPUT_DATA_DIR"])
parser.add_argument("--model_dir", type=str, default=os.environ["SM_MODEL_DIR"])
parser.add_argument("--training_dir", type=str, default=os.environ["SM_CHANNEL_TRAIN"])
parser.add_argument("--test_dir", type=str, default=os.environ["SM_CHANNEL_TEST"])
parser.add_argument("--n_gpus", type=str, default=os.environ["SM_NUM_GPUS"])
args, _ = parser.parse_known_args()
os.environ["GPU_NUM_DEVICES"] = args.n_gpus
```
+ **Approche 3** : codez en dur la variable d’environnement `GPU_NUM_DEVICES` dans votre script d’entraînement. Par exemple, ajoutez ce qui suit à votre script si vous utilisez une instance contenant quatre GPUs.
```
# train.py
import os
os.environ["GPU_NUM_DEVICES"] = 4
```
**Astuce**
Pour connaître le nombre de dispositifs GPU sur les instances de machine learning que vous souhaitez utiliser, consultez [Calcul accéléré](https://aws.amazon.com/ec2/instance-types/#Accelerated_Computing) sur la *page Types d’instance Amazon EC2*.
## SageMaker Le compilateur d'entraînement ne réduit pas le temps total d'entraînement
Si le temps d'entraînement total ne diminue pas avec SageMaker Training Compiler, nous vous recommandons vivement de consulter la [SageMaker Bonnes pratiques et considérations relatives à la formation des compilateurs](training-compiler-tips-pitfalls.md) page pour vérifier votre configuration d'entraînement, votre stratégie de remplissage pour la forme du tenseur d'entrée et les hyperparamètres.
# Notes de mise à jour SageMaker d'Amazon Training Compiler
**Important**
Amazon Web Services (AWS) annonce qu'il n'y aura aucune nouvelle version ou version de SageMaker Training Compiler. Vous pouvez continuer à utiliser SageMaker Training Compiler via les AWS Deep Learning Containers (DLCs) for SageMaker Training existants. Il est important de noter que tant que les versions existantes DLCs resteront accessibles, elles ne recevront plus de correctifs ni de mises à jour AWS, conformément à la [politique de support du AWS Deep Learning Containers Framework](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html).
Consultez les notes de publication suivantes pour suivre les dernières mises à jour d'Amazon SageMaker Training Compiler.
## SageMaker Notes de publication de Training Compiler : 13 février 2023
**Mises à jour des devises**
+ Ajout du support pour la PyTorch v1.13.1
**Correctifs de bogue**
+ Correction d’un problème lié aux conditions de concurrence sur le GPU qui entraînait une perte de NAN sur certains modèles, tels que les modèles de transformeur de vision (ViT).
**Autres modifications**
+ SageMaker Training Compiler améliore les performances en PyTorch/XLA permettant de remplacer automatiquement les optimiseurs (tels que SGD, Adam, AdamW) dans `torch.optim` ou `transformers.optimization` avec leurs versions sans synchronisation `torch_xla.amp.syncfree` (telles que,,). `torch_xla.amp.syncfree.SGD` `torch_xla.amp.syncfree.Adam` `torch_xla.amp.syncfree.AdamW` Vous n’avez pas besoin de modifier les lignes de code dans lesquelles vous définissez les optimiseurs dans votre script d’entraînement.
**Migration vers les AWS Deep Learning Containers**
Cette version a passé avec succès les tests de référence et a été migrée vers le conteneur de AWS Deep Learning suivant :
+ PyTorch v1.13.1
```
763104351884.dkr.ecr.us-west-2.amazonaws.com/pytorch-trcomp-training:1.13.1-gpu-py39-cu117-ubuntu20.04-sagemaker
```
Pour obtenir la liste complète des conteneurs prédéfinis avec Amazon SageMaker Training Compiler, consultez[Frameworks Régions AWS, types d'instances et modèles testés pris en charge](training-compiler-support.md).
## SageMaker Notes de publication de Training Compiler : 9 janvier 2023
**Évolutions**
+ `tf.keras.optimizers.Optimizer`pointe vers un nouvel optimiseur dans les versions TensorFlow 2.11.0 et ultérieures. Les anciens optimiseurs sont déplacés vers `tf.keras.optimizers.legacy`. Vous risquez de rencontrer un échec de tâche en raison de cette évolution lorsque vous effectuez les opérations suivantes.
+ Chargement de points de contrôle à partir d’un ancien optimiseur. Nous vous recommandons de passer aux optimiseurs hérités.
+ Utilisez la TensorFlow version 1. Nous vous recommandons de migrer vers la TensorFlow version v2 ou de passer aux optimiseurs existants si vous devez continuer à utiliser la version TensorFlow 1.
Pour une liste plus détaillée des principales modifications apportées par rapport aux modifications apportées à l'optimiseur, consultez les [notes de publication officielles de la TensorFlow version 2.11.0](https://github.com/tensorflow/tensorflow/releases/tag/v2.11.0) dans le référentiel. TensorFlow GitHub
**Migration vers les AWS Deep Learning Containers**
Cette version a passé avec succès les tests de référence et a été migrée vers le conteneur de AWS Deep Learning suivant :
+ TensorFlow v2.11.0
```
763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.11.0-gpu-py39-cu112-ubuntu20.04-sagemaker
```
Pour obtenir la liste complète des conteneurs prédéfinis avec Amazon SageMaker Training Compiler, consultez[Frameworks Régions AWS, types d'instances et modèles testés pris en charge](training-compiler-support.md).
## SageMaker Notes de mise à jour de Training Compiler : 8 décembre 2022
**Correctifs de bogue**
+ Correction du point de départ pour les tâches de PyTorch formation à partir de la PyTorch version 1.12 afin de garantir qu'il n'y ait aucune différence dans l'initialisation du modèle entre les différents processus. Voir également [PyTorchReproductibilité](https://pytorch.org/docs/stable/notes/randomness.html).
+ Correction d'un problème qui PyTorch empêchait les tâches de formation distribuées sur les instances G4dn et G5 de communiquer par défaut. [PCIe](https://en.wikipedia.org/wiki/PCI_Express)
**Problèmes connus**
+ Une mauvaise utilisation PyTorch/XLA APIs des transformateurs de vision de Hugging Face peut entraîner des problèmes de convergence.
**Autres modifications**
+ Lorsque vous utilisez la classe Hugging Face `Trainer` Transformers, assurez-vous d' SyncFree utiliser des optimiseurs en définissant `optim` l'argument sur. `adamw_torch_xla` Pour de plus amples informations, veuillez consulter [Modèles linguistiques de grande taille utilisant la classe `Trainer` de Hugging Face Transformers](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer). Voir également [Optimizer](https://huggingface.co/docs/transformers/v4.23.1/en/perf_train_gpu_one#optimizer) (Optimiseur) dans la *documentation de Hugging Face Transformers*.
**Migration vers les AWS Deep Learning Containers**
Cette version a passé avec succès les tests de référence et a été migrée vers le conteneur de AWS Deep Learning suivant :
+ PyTorch v1.12.0
```
763104351884.dkr.ecr..amazonaws.com/pytorch-trcomp-training:1.12.0-gpu-py38-cu113-ubuntu20.04-sagemaker
```
Pour obtenir la liste complète des conteneurs prédéfinis avec Amazon SageMaker Training Compiler, consultez[Frameworks Régions AWS, types d'instances et modèles testés pris en charge](training-compiler-support.md).
## SageMaker Notes de publication de Training Compiler : 4 octobre 2022
**Mises à jour des devises**
+ Ajout du support pour la version TensorFlow 2.10.0.
**Autres modifications**
+ Ajout de modèles Hugging Face NLP utilisant la bibliothèque TensorFlow Transformers pour les tests de framework. Pour trouver les modèles de transformateur testés, consultez la section [Modèles testés](training-compiler-support.md#training-compiler-tested-models).
**Migration vers les AWS Deep Learning Containers**
Cette version a passé avec succès les tests de référence et a été migrée vers le conteneur de AWS Deep Learning suivant :
+ TensorFlow v2.10.0
```
763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.10.0-gpu-py39-cu112-ubuntu20.04-sagemaker
```
Pour obtenir la liste complète des conteneurs prédéfinis avec Amazon SageMaker Training Compiler, consultez[Frameworks Régions AWS, types d'instances et modèles testés pris en charge](training-compiler-support.md).
## SageMaker Notes de mise à jour de Training Compiler : 1er septembre 2022
**Mises à jour des devises**
+ Ajout du support pour Hugging Face Transformers PyTorch v4.21.1 avec v1.11.0.
**Améliorations**
+ Mise en œuvre d'un nouveau mécanisme de lancement d'entraînement distribué pour activer le compilateur SageMaker d'entraînement pour les modèles Hugging Face Transformer avec. PyTorch Pour en savoir plus, voir [Exécuter des tâches d' PyTorchentraînement avec le compilateur d' SageMaker entraînement pour l'entraînement distribué](training-compiler-enable-pytorch.md#training-compiler-estimator-pytorch-distributed).
+ Intégration à EFA pour améliorer la communication collective dans le cadre de l’entraînement distribué.
+ Ajout du support pour les instances G5 pour les tâches PyTorch de formation. Pour de plus amples informations, veuillez consulter [Frameworks Régions AWS, types d'instances et modèles testés pris en charge](training-compiler-support.md).
**Migration vers les AWS Deep Learning Containers**
Cette version a passé avec succès les tests de référence et a été migrée vers le conteneur de AWS Deep Learning suivant :
+ [HuggingFace v4.21.1 avec v1.11.0 PyTorch ](https://github.com/aws/deep-learning-containers/releases/tag/v1.0-trcomp-hf-4.21.1-pt-1.11.0-tr-gpu-py38)
```
763104351884.dkr.ecr.us-west-2.amazonaws.com/huggingface-pytorch-trcomp-training:1.11.0-transformers4.21.1-gpu-py38-cu113-ubuntu20.04
```
Pour obtenir la liste complète des conteneurs prédéfinis avec Amazon SageMaker Training Compiler, consultez[Frameworks Régions AWS, types d'instances et modèles testés pris en charge](training-compiler-support.md).
## SageMaker Notes de mise à jour de Training Compiler : 14 juin 2022
**Nouvelles fonctionnalités**
+ Ajout du support pour la TensorFlow version 2.9.1. SageMaker Training Compiler prend entièrement en charge la compilation TensorFlow des modules (`tf.*`) et des modules TensorFlow Keras (`tf.keras.*`).
+ Ajout de la prise en charge des conteneurs personnalisés créés en étendant AWS Deep Learning Containers for TensorFlow. Pour plus d'informations, consultez [Activer le compilateur d' SageMaker entraînement à l'aide du SDK SageMaker Python et Extend SageMaker AI Framework Deep Learning Containers](training-compiler-enable-tensorflow.md#training-compiler-enable-tensorflow-sdk-extend-container).
+ Ajout du support pour les instances G5 pour les tâches TensorFlow de formation.
**Migration vers les AWS Deep Learning Containers**
Cette version a passé avec succès les tests de référence et a été migrée vers le conteneur de AWS Deep Learning suivant :
+ TensorFlow 2.9.1
```
763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.9.1-gpu-py39-cu112-ubuntu20.04-sagemaker
```
Pour obtenir la liste complète des conteneurs prédéfinis avec Amazon SageMaker Training Compiler, consultez[Frameworks Régions AWS, types d'instances et modèles testés pris en charge](training-compiler-support.md).
## SageMaker Notes de mise à jour de Training Compiler : 26 avril 2022
**Améliorations**
+ Ajout du support pour tous les sites Régions AWS où les [AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) sont en service, à l'exception des régions de Chine.
## SageMaker Notes de publication de Training Compiler : 12 avril 2022
**Mises à jour des devises**
+ Ajout du support pour Hugging Face Transformers v4.17.0 avec v2.6.3 TensorFlow et v1.10.2. PyTorch
## SageMaker Notes de mise à jour de Training Compiler : 21 février 2022
**Améliorations**
+ Test d’évaluation terminé et accélérations d’entraînement confirmées sur les types d’instances `ml.g4dn`. Pour une liste complète des instances `ml` testées, consultez [Types d’instance pris en charge](training-compiler-support.md#training-compiler-supported-instance-types).
## SageMaker Notes de mise à jour de Training Compiler : 1er décembre 2021
**Nouvelles fonctionnalités**
+ Nous avons lancé Amazon SageMaker Training Compiler à l'occasion AWS de re:Invent 2021.
**Migration vers les AWS Deep Learning Containers**
+ Amazon SageMaker Training Compiler a passé avec succès les tests de référence et a été migré vers AWS Deep Learning Containers. Pour obtenir la liste complète des conteneurs prédéfinis avec Amazon SageMaker Training Compiler, consultez[Frameworks Régions AWS, types d'instances et modèles testés pris en charge](training-compiler-support.md).