View a markdown version of this page

PyTorch - Amazon SageMaker AI
PyTorch Modèles avec Hugging Face Transformers

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.

PyTorch Modèles avec Hugging Face Transformers

PyTorch les modèles dotés de Hugging Face Transformers sont basés PyTorch sur l'API Torch.nn.Module. Hugging Face Transformers propose é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'HuggingFaceestimateur avec la configuration SageMaker Training Compiler lorsque vous passerez à la rubrique suivante à l'adresse. Activer le compilateur SageMaker d'entraînement

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 dans la documentation des transformeurs Hugging Face.

Grands modèles linguistiques utilisant le cours 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 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)

Pour l’entraînement à GPU unique

Vous n’avez pas besoin de modifier votre code lorsque vous utilisez cette classe transformers.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.

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_pointargument et de transmettre votre script d'entraînement à l'hyperparametersargument 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'optimargument sur adamw_torch_xla lors de la configuration des transformateurs. TrainingArgument. Voir également 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. TrainingArgumentclasse 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écuter PyTorch des tâches de formation avec SageMaker Training Compiler.

Utilisation PyTorch directe de grands modèles linguistiques (sans l'API Hugging Face Transformers Trainer)

Si vous avez un script d'entraînement qui s'utilise PyTorch directement, vous devez apporter des modifications supplémentaires à votre script d' PyTorch entraînement pour l'implémenter PyTorch/XLA. Suivez les instructions pour modifier votre script afin de configurer correctement les PyTorch/XLA primatives.

Pour l’entraînement à GPU unique

  1. Importez les bibliothèques d’optimisation.

    import torch_xla
import torch_xla.core.xla_model as xm

  2. Changez le périphérique cible et sélectionnez XLA au lieu de torch.device("cuda")

    device=xm.xla_device()

  3. Si vous utilisez PyTorch l'Automatic Mixed Precision (AMP), procédez comme suit :

    1. Remplacez torch.cuda.amp par ce qui suit :

      import torch_xla.amp

    2. 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

    3. Remplacez torch.cuda.amp.GradScaler par ce qui suit :

      import torch_xla.amp.GradScaler as grad_scaler

  4. Si vous n’utilisez pas AMP, remplacez optimizer.step() par les éléments suivants :

    xm.optimizer_step(optimizer)

  5. Si vous utilisez un chargeur de données distribué, insérez 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)

  6. Ajoutez mark_step à la fin de la boucle d’entraînement lorsque vous n’utilisez pas parallel_loader :

    xm.mark_step()

  7. Pour vérifier votre entraînement, utilisez la méthode des points PyTorch/XLA de contrôle du modèle :

    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.

Pour l’entraînement distribué

En plus des modifications répertoriées dans la section Pour l’entraînement à GPU unique 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())

  2. 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()

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

  4. 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.

  5. 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.

    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_pointargument et à transmettre votre script d'entraînement à l'hyperparametersargument 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.

Bonnes pratiques d'utilisation du 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. 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
Comprenez 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 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).

Minimiser le nombre de compilation et exécutions en utilisant pl. MpDeviceLoader/pl.ParallelLoaderet 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 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 les optimiseurs AMP et 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 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 à ces optimiseurs torch_xla.amp.GradScaler pour le dégradé 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 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.