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.
# 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 transformateurs Hugging Face](#training-compiler-pytorch-models-transformers)
## PyTorch Modèles avec transformateurs Hugging Face
PyTorch les modèles dotés de [ Hugging Face Transformers ](https://huggingface.co/docs/transformers/index) sont basés sur l'API PyTorch [https://pytorch.org/docs/stable/nn.html#torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) Torch.nn.Module. Hugging Face Transformers propose également des classes de modèles d'[entraînement ](https://huggingface.co/docs/transformers/main_classes/trainer) et des classes de modèles préentraînés PyTorch afin de réduire les efforts de 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 `HuggingFace` ModelTrainer de la configuration du SageMaker Training Compiler lorsque vous passerez à la rubrique suivante sur[Activer le compilateur SageMaker de formation](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 de langage de grande taille utilisant la classe de formation Hugging Face Transformers ``](#training-compiler-pytorch-models-transformers-trainer)
+ [Modèles de langage volumineux utilisant PyTorch directement (sans l'API Hugging Face Transformers Trainer)](#training-compiler-pytorch-models-non-trainer)
### Modèles de langage de grande taille utilisant la classe de formation 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 dans le ModelTrainer cours. 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)
+ [Meilleures pratiques pour utiliser SageMaker Training Compiler 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 [`transformers.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 encapsuler la `main()` fonction. Il redirige les appels de `_mp_fn(index)` fonction depuis le runtime 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 versions antérieures avec PyTorch v1.10.2 et versions antérieures **
SageMaker Training Compiler utilise un autre mécanisme pour lancer une tâche de formation distribuée, et vous n'avez pas besoin de modifier votre script de formation. Au lieu de cela, 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 dans SageMaker AI Hugging Face ModelTrainer.
#### Meilleures pratiques pour utiliser SageMaker Training Compiler 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. Ces nombres doivent être généralement supérieurs ou égaux au nombre de GPU, mais inférieurs au nombre d’UC.
Une fois que vous avez terminé d’adapter votre scénario d’entraînement, passez à [Exécutez PyTorch des tâches de formation avec SageMaker Training Compiler](training-compiler-enable-pytorch.md).
### Modèles de langage volumineux utilisant PyTorch directement (sans l'API Hugging Face Transformers Trainer)
Si vous disposez d'un script de formation qui l'utilise PyTorch directement, vous devez apporter des modifications supplémentaires à votre script de PyTorch formation pour l'implémenter PyTorch/XLA. Suivez les instructions pour modifier votre script afin de configurer correctement les PyTorch/XLA primatives.
**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)
+ [Meilleures pratiques pour utiliser SageMaker Training Compiler 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 la précision mixte [ automatique ](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é, encapsulez votre chargeur de données dans la classe s : PyTorch/XLA `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 des points PyTorch/XLA de contrôle modèles :
```
xm.save(model.state_dict(), path_to_save)
```
Une fois que vous avez terminé d’adapter votre scénario d’entraînement, passez à [Exécutez PyTorch des tâches de formation avec SageMaker Training Compiler](training-compiler-enable-pytorch.md).
#### Pour l’entraînement distribué
En plus des modifications répertoriées dans la section [Pour l’entraînement à GPU unique](#training-compiler-pytorch-models-non-trainer-single-gpu) précédente, ajoutez les modifications suivantes pour répartir correctement la charge de travail entre les GPU.
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 toutes ces modifications, 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 la PyTorch version 1.11.0 et les 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 encapsuler la `main()` fonction. Il redirige les appels de `_mp_fn(index)` fonction depuis le runtime 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 versions antérieures avec PyTorch v1.10.2 et versions antérieures **
SageMaker Training Compiler utilise un autre mécanisme pour lancer une tâche d'entraînement 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 SageMaker AI Hugging Face ModelTrainer.
Une fois que vous avez terminé d’adapter votre scénario d’entraînement, passez à [Exécutez PyTorch des tâches de formation avec SageMaker Training Compiler](training-compiler-enable-pytorch.md).
#### Meilleures pratiques pour utiliser SageMaker Training Compiler avec PyTorch/XLA
Si vous souhaitez utiliser le compilateur de SageMaker formation sur votre script d' PyTorch entraînement natif, vous devriez d'abord vous familiariser avec [ PyTorch les appareils ](https://pytorch.org/xla/release/1.9/index.html) XLA. Les sections suivantes répertorient certaines des meilleures pratiques permettant d'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
```
##### Comprenez le mode paresseux dans PyTorch/XLA
Une différence significative entre PyTorch/XLA et natif PyTorch est que le PyTorch/XLA système fonctionne en mode paresseux tandis que le système natif PyTorch fonctionne en mode impatient. 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 des PyTorch API 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)`.
##### Minimisez le nombre de *compilation et exécutions* en utilisant `pl. MpDeviceLoader/pl.ParallelLoader`et `xm.step_closure`
Pour de meilleures performances, vous devez garder à l’esprit les manières possibles de lancer des *compilation-and-executions* comme décrit dans [Comprenez 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, une seule compilation et exécution est nécessaire par itération d’entraînement et est lancée 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 à l’aide de `xm.add_step_closure()` pour éviter les compilation-and-executions inutiles.
##### Utilisez AMP et des optimiseurs `syncfree`
L'entraînement en mode Automatic Mixed Precision (AMP) accélère considérablement votre vitesse d'entraînement en tirant parti des cœurs Tensor des GPU NVIDIA. 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 `syncfree` optimiseurs doivent être associés à `torch_xla.amp.GradScaler` pour le gradient scaling/unscaling.
**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 par leurs versions `transformers.optimization` non synchronisées dans (tels 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.