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. # Exécutez PyTorch des tâches de formation avec SageMaker Training Compiler **Important** **Avis d'obsolescence : le compilateur de ** SageMaker formation n'est pas pris en charge dans le SDK SageMaker Python v3. Si vous utilisez actuellement Training Compiler, continuez à utiliser SageMaker Python SDK v2. Pour les nouveaux projets, pensez à utiliser la `ModelTrainer` classe unifiée avec les frameworks pris en charge. Consultez la documentation du SDK [ SageMaker Python ](https://sagemaker.readthedocs.io/en/stable/) pour obtenir des conseils sur la migration. Vous pouvez utiliser n'importe quelle interface 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 de `CreateTrainingJob` l'API SageMaker AI](#training-compiler-enable-pytorch-api) ## Utilisation du SDK SageMaker Python SageMaker Training Compiler for PyTorch est disponible via les classes SageMaker AI [`PyTorch`](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_train.html) et [`HuggingFace`](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_train.html) Framework Estimator. Pour activer SageMaker Training Compiler, ajoutez le `compiler_config` paramètre aux estimateurs SageMaker AI. 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 SageMaker AI lorsque SageMaker Training Compiler est activé. **Astuce** Pour commencer à utiliser les modèles prédéfinis 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 1.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 1.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 PyTorch, configurez un estimateur SageMaker AI Hugging Face avec SageMaker 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 Trainer de Hugging Face Transformers [https://huggingface.co/docs/transformers/main_classes/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 Trainer de Hugging Face Transformers [https://huggingface.co/transformers/main_classes/trainer.html](https://huggingface.co/transformers/main_classes/trainer.html) Pour trouver des exemples de bout en bout, consultez les blocs-notes suivants : + [Compiler et entraîner un modèle Trainer de Hugging Face Transformers pour les questions et réponses avec le jeu de données SQuAD](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 `BERT` modèle de transformateur Hugging Face avec l'ensemble de données SST à l'aide SageMaker de Training Compiler ](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) + [Compiler et entraîner un modèle d'entraînement de classification binaire avec l'ensemble de données SST2 pour la formation Single-Node Single-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 1.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 1.11 et les versions ultérieures, SageMaker Training Compiler est disponible pour la formation distribuée 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 Trainer de Hugging Face Transformers [https://huggingface.co/transformers/main_classes/trainer.html](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 Trainer de Hugging Face Transformers [https://huggingface.co/transformers/main_classes/trainer.html](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 version 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é par SageMaker IA à 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 Trainer de Hugging Face Transformers [https://huggingface.co/transformers/main_classes/trainer.html](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 Trainer de Hugging Face Transformers [https://huggingface.co/transformers/main_classes/trainer.html](https://huggingface.co/transformers/main_classes/trainer.html) **Astuce** Pour trouver des exemples de bout en bout, consultez les blocs-notes suivants : [Compilez et entraînez le modèle GPT2 à l'aide de l'API Transformers Trainer avec le jeu de données SST2 pour la formation Single-Node Multi-GPU ](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 modèle GPT2 à l'aide de l'API Transformers Trainer avec le jeu de données SST2 pour la formation Multi-Node 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 de SageMaker formation avec le compilateur. **Note** Lorsque vous utilisez l'estimateur SageMaker AI Hugging Face, vous devez spécifier les `compiler_config` paramètres`transformers_version`, `pytorch_version``hyperparameters`, et pour activer SageMaker Training Compiler. 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 une formation distribuée avec SageMaker Training Compiler et les PyTorch versions 1.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 modèle GPT2 à l'aide de l'API Transformers Trainer avec le jeu de données SST2 pour la formation Single-Node Multi-GPU ](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 modèle GPT2 à l'aide de l'API Transformers Trainer avec le jeu de données SST2 pour la formation Multi-Node 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'estimateur SageMaker AI Hugging Face. Spécifiez la version de la bibliothèque Hugging Face Transformers 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). + `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 Exemples de compilateurs de formation, de carnets 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`"training_script"`, pour spécifier votre script d'entraînement, comme indiqué dans l'exemple de code précédent. + `compiler_config`(TrainingCompilerConfig objet) — Obligatoire pour activer SageMaker Training Compiler. Incluez ce paramètre pour activer SageMaker Training Compiler. Les paramètres suivants sont destinés à la classe `TrainingCompilerConfig`. + `enabled` (bool) : facultatif. Spécifiez `True` ou `False` activez ou désactivez SageMaker Training Compiler. 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 afin de 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 de `CreateTrainingJob` l'API SageMaker AI SageMaker Les options de configuration du compilateur de formation doivent être spécifiées via le `HyperParameters` champ `AlgorithmSpecification` et de la syntaxe de demande pour l'opération de l'[`CreateTrainingJob`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 obtenir la liste complète des URI d'images de conteneurs de deep learning qui ont été implémentés par SageMaker Training Compiler, consultez[Cadres pris en charge](training-compiler-support.md#training-compiler-supported-frameworks).