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.

# Activer le compilateur SageMaker d'entraînement
Activer 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).

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
Exécuter PyTorch des tâches de formation avec 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
Découvrez comment activer SageMaker Training Compiler à l'aide 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
Découvrez comment activer le compilateur SageMaker d'entraînement à l'aide de l'opération `CreateTrainingJob` 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": "<sagemaker-training-compiler-enabled-dlc-image>"
},

"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
Exécuter TensorFlow des tâches de formation avec 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
Découvrez comment activer SageMaker Training Compiler à l'aide 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)
Utilisation du SDK SageMaker 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.<aws-region>.amazonaws.com/tensorflow-training:<image-tag>

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/<tensorflow-version>/py3/<cuda-version>/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
Découvrez comment activer le compilateur d' SageMaker entraînement à l'aide 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 dans la syntaxe de la demande pour l'[opération `CreateTrainingJob` d'API](https://amazonaws.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html).

```
"AlgorithmSpecification": {
    "TrainingImage": "<sagemaker-training-compiler-enabled-dlc-image>"
},

"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).