PyTorch - Amazon SageMaker AI
Modèles PyTorch 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

Apportez votre propre modèle PyTorch à SageMaker AO et exécutez la tâche d’entraînement avec SageMaker Training Compiler.

Modèles PyTorch avec Hugging Face Transformers

Les modèles PyTorch avec les transformeurs Hugging Facehttps://huggingface.co/docs/transformers/index sont basés sur l’API torch.nn.Module de PyTorch. Les transformeurs Hugging Face fournissent également Trainer et des classes de modèles préentraînées pour PyTorch afin de réduire l’effort de configuration des modèles de traitement du langage naturel (NLP). Après avoir préparé votre script d’entraînement, vous pouvez lancer une tâche d’entraînement à l’aide de l’estimateur PyTorch ou HuggingFace de SageMaker AI avec la configuration SageMaker Training Compiler lorsque vous passerez à la rubrique suivante sur Activer SageMaker Training Compiler.

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 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 de l’estimateur. Le code suivant montre la forme de base d’un script d’entraînement PyTorch 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 ultérieures

Pour exécuter l’entraînement distribué avec SageMaker Training Compiler, vous devez ajouter la fonction _mp_fn() suivante dans votre script d’entraînement et envelopper la fonction main(). Elle redirige les appels de la fonction _mp_fn(index) depuis l’environnement d’exécution distribué SageMaker AI pour PyTorch (pytorchxla) vers la fonction main() 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 ou version antérieure avec PyTorch v1.10.2 ou version antérieure

SageMaker Training Compiler utilise un autre mécanisme pour lancer une tâche d’entraînement distribué, et vous n’avez pas besoin d’apporter de modification à votre script d’entraînement. À la place, SageMaker Training Compiler exige que vous transmettiez un script de lancement d’entraînement distribué SageMaker AI à l’argument entry_point et que vous transmettiez votre script d’entraînement à l’argument hyperparameters dans l’estimateur SageMaker AI Hugging Face.

Bonnes pratiques pour utiliser SageMaker Training Compiler avec Trainer

  • Assurez-vous d’utiliser les optimiseurs SyncFree en définissant l’argument optim sur adamw_torch_xla lors de la configuration de transformers.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 arguments dataloader_num_workers et preprocessing_num_workersde la classe transformers.TrainingArgument 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écution de tâches d’entraînement PyTorch avec SageMaker Training Compiler.

Modèles linguistiques de grande taille utilisant directement PyTorch (sans l’API Trainer des transformeurs Hugging Face)

Si vous avez un script d’entraînement qui utilise directement PyTorch, vous devez apporter des modifications supplémentaires à votre script d’entraînement PyTorch pour mettre en œuvre PyTorch/XLA. Suivez les instructions pour modifier votre script afin de configurer correctement les primitives 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 l’option Automatic Mixed Precision (AMP) de PyTorch, 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é, enveloppez votre chargeur de données dans la classe 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 contrôler votre entraînement, utilisez la méthode de point de contrôle du modèle de 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écution de tâches d’entraînement PyTorch 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)

    Le train_device_loader fonctionne comme un chargeur PyTorch standard 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 pouvoir lancer un entraînement distribué avec n’importe quel modèle PyTorch 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 ultérieures

    Pour exécuter l’entraînement distribué avec SageMaker Training Compiler, vous devez ajouter la fonction _mp_fn() suivante dans votre script d’entraînement et envelopper la fonction main(). Elle redirige les appels de la fonction _mp_fn(index) depuis l’environnement d’exécution distribué SageMaker AI pour PyTorch (pytorchxla) vers la fonction main() 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 ou version antérieure avec PyTorch v1.10.2 ou version antérieure

    SageMaker Training Compiler utilise un autre mécanisme pour lancer une tâche d’entraînement distribué et il exige que vous transmettiez un script de lancement d’entraînement distribué SageMaker AI à l’argument entry_point et que vous transmettiez votre script d’entraînement à l’argument hyperparameters dans l’estimateur SageMaker AI Hugging Face.

Une fois que vous avez terminé d’adapter votre scénario d’entraînement, passez à Exécution de tâches d’entraînement PyTorch avec SageMaker Training Compiler.

Bonnes pratiques pour utiliser SageMaker Training Compiler avec PyTorch/XLA

Si vous souhaitez tirer parti du compilateur d’entraînement SageMaker sur votre script d’entraînement PyTorch natif, vous aurez peut-être d’abord besoin de vous familiariser avec PyTorch sur les périphériques XLA. Les sections suivantes réunissent quelques bonnes pratiques pour l’activation de XLA pour PyTorch.

Note

Cette section consacrée aux bonnes 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

Il existe une différence significative entre PyTorch/XLA et PyTorch natif, à savoir que le système PyTorch/XLA fonctionne en mode paresseux tandis que le PyTorch natif 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 système PyTorch/XLA crée le graphique de calcul à la volée lorsque vous appelez les API PyTorch 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-and-executions 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 Comprendre 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.

Utiliser AMP et les 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 des optimiseurs syncfree qui sont optimisés pour XLA afin d’améliorer les performances d’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 PyTorch version 1.13.1, le compilateur d’entraînement SageMaker améliore les performances en permettant à PyTorch/XLA de remplacer automatiquement les optimiseurs (tels que SGD, Adam, AdamW) dans torch.optim ou transformers.optimization ou avec leurs versions sans synchronisation dans torch_xla.amp.syncfree (telles que torch_xla.amp.syncfree.SGD, torch_xla.amp.syncfree.Adam ou 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.