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 Transformers, consultez Padding and truncation (Remplissage et troncature) dans la documentation de Hugging Face Transformers.

Modèles linguistiques de grande taille utilisant la classe Trainer de 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 Hugging Face Transformers.

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. En règle générale, ceux-ci doivent être supérieurs ou égaux au nombre de GPUs mais inférieurs au nombre de CPUs.

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 utilise PyTorch directement, vous devez apporter des modifications supplémentaires à votre script d' PyTorch entraînement pour implémenter PyTorch /XLA. Suivez les instructions pour modifier votre script afin de configurer correctement les primatives PyTorch /XLA.

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 /XLA PyTorch : 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 du point de contrôle du modèle PyTorch /XLA :

    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é

Outre les modifications répertoriées dans la Pour l'entraînement à GPU unique section précédente, ajoutez les modifications suivantes pour répartir correctement la charge de travail GPUs.

  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 Hugging Face Transformers.

    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 pour utiliser le 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 modules PyTorch /XLA suivants :

import torch_xla.core.xla_model as xm
import torch_xla.distributed.parallel_loader as pl
Comprendre le mode paresseux dans PyTorch /XLA

Une différence significative entre PyTorch /XLA et native PyTorch est que le système PyTorch /XLA s'exécute en mode paresseux tandis que le système natif s' PyTorch exécute 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 système PyTorch /XLA crée le graphe de calcul à la volée lorsque vous appelez PyTorch APIs 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 d'compilation-and-executionsutilisations pl.MpDeviceLoader/pl.ParallelLoader et xm.step_closure

Pour de meilleures performances, vous devez garder à l'esprit les méthodes d'initialisation possibles compilation-and-executionsdécrites dans la section Comprendre le mode paresseux dans PyTorch /XLA et essayer de minimiser le nombre de compilation-and-executions. Idéalement, un seul compilation-and-execution est nécessaire par itération d'entraînement et est lancé automatiquement parpl.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 xm.add_step_closure() pour éviter toute utilisation inutile compilation-and-executions.

Utiliser AMP et les optimiseurs 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 de NVIDIA GPUs. 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 optimiseurs syncfree doivent être associés à torch_xla.amp.GradScaler pour la mise à l'échelle croissante ou décroissante du gradient.

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.