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.

# SageMaker Bonnes pratiques et considérations relatives à la formation des compilateurs
<a name="training-compiler-tips-pitfalls"></a>

**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 (DLC) existants pour la SageMaker formation. Il est important de noter que même si les DLC existants restent accessibles, ils 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
<a name="training-compiler-tips-pitfalls-best-practices"></a>

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.

**Meilleures pratiques pour PyTorch**
+ Si vous apportez un PyTorch modèle et que vous souhaitez le contrôler, assurez-vous d'utiliser PyTorch/XLA la fonction de sauvegarde du modèle 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 avec plusieurs GPU à la place d’instances à un seul GPU. 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
<a name="training-compiler-tips-pitfalls-considerations"></a>

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
<a name="training-compiler-considerations-performance-degradation"></a>
+ É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 des PyTorch/XLA API lors de l'utilisation PyTorch directe
<a name="training-compiler-considerations-incorrect-api-use"></a>

PyTorch/XLA définit un ensemble d'API pour remplacer certaines des API de PyTorch formation existantes. 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 des API de formation distribuées supplémentaires. La mauvaise programmation des API entraîne une collecte incorrecte des gradients, ce qui conduit à l’échec de la convergence de l’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).