View a markdown version of this page

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

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 transformateurs Hugging Face

PyTorch les modèles dotés de Hugging Face Transformers sont basés sur l'API PyTorch 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 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 surActiver le compilateur SageMaker de formation.

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.

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)

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

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_pointargument et de transmettre votre script d'entraînement à l'hyperparametersargument 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'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écutez PyTorch des tâches de formation avec SageMaker Training Compiler.

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.

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 la précision mixte automatique (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é, 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)

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

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

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

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

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