PyTorch - Amazon SageMaker KI
PyTorch-Modelle mit Hugging Face Transformers

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

PyTorch

Bringen Sie Ihr eigenes PyTorch-Modell in SageMaker AI und führen Sie den Trainingsjob mit dem SageMaker Training Compiler aus.

PyTorch-Modelle mit Hugging Face Transformers

PyTorch-Modelle mit Hugging Face Transformers basieren auf der PyTorch's torch.nn.Module-API. Hugging Face Transformers bietet auch Trainer und vortrainierte Modellklassen für PyTorch, um den Aufwand für die Konfiguration von Modellen der natürlichen Sprachverarbeitung (NLP) zu reduzieren. Nachdem Sie Ihr Trainingsskript vorbereitet haben, können Sie einen Trainingsjob mit dem PyTorch- oder HuggingFace-Schätzer von SageMaker AI mit der Konfiguration des SageMaker Training Compilers starten, wenn Sie mit dem nächsten Thema unter SageMaker Training Compiler aktivieren fortfahren.

Tipp

Wenn Sie mithilfe von Transformers in Ihrem Trainingsskript einen Tokenizer für ein NLP-Modell erstellen, stellen Sie sicher, dass Sie eine statische Eingabe-Tensorform verwenden, indem Sie padding='max_length' angeben. Verwenden Sie padding='longest' nicht, da das Auffüllen der längsten Sequenz im Stapel die Tensorform für jeden Trainingsstapel ändern kann. Die dynamische Eingabeform kann eine Neukompilierung des Modells auslösen und die Gesamttrainingszeit verlängern. Weitere Informationen zu den Auffülloptionen der Transformers-Tokenizer finden Sie unter Padding and Truncation in der Hugging Face Transformers Dokumentation.

Große Sprachmodelle, die die Hugging Face Transformers-Trainer Klasse verwenden

Wenn Sie die Trainer-Klasse der Transformers-Bibliothek verwenden, müssen Sie keine zusätzlichen Änderungen an Ihrem Trainingsskript vornehmen. Der SageMaker Training Compiler kompiliert Ihr Trainer-Modell automatisch, wenn Sie es über die Estimator-Klasse aktivieren. Der folgende Code zeigt die Grundform eines PyTorch-Trainingsskripts mit der Hugging Face Trainer-API.

from transformers import Trainer, TrainingArguments

training_args=TrainingArguments(**kwargs)
trainer=Trainer(args=training_args, **kwargs)

Für das Training mit einer einzelnen GPU

Sie müssen Ihren Code nicht ändern, wenn Sie die transformers.Trainer Klasse verwenden.

Für verteiltes Training

PyTorch v1.11.0 und höher

Um verteiltes Training mit dem SageMaker Training Compiler durchzuführen, müssen Sie Ihrem Trainingsskript die folgende _mp_fn() Funktion hinzufügen und die Funktion main() umschließen. Es leitet die _mp_fn(index) Funktionsaufrufe von der verteilten SageMaker-AI-Laufzeit für PyTorch (pytorchxla) an die main() Funktion Ihres Trainingsskripts weiter. 

def _mp_fn(index):
    main()

Diese Funktion akzeptiert das index Argument, um den Rang der aktuellen GPU im Cluster für verteiltes Training anzugeben. Weitere Beispielskripte finden Sie in den Beispielskripten für die Sprachmodellierung von Hugging Face Transformers.

Für Transformers v4.17 und früher mit PyTorch v1.10.2 und früher

Der SageMaker Training Compiler verwendet einen alternativen Mechanismus zum Starten eines verteilten Trainingsjobs, sodass Sie keine Änderungen an Ihrem Trainingsskript vornehmen müssen. Stattdessen verlangt der SageMaker Training Compiler, dass Sie ein von SageMaker AI verteiltes Trainings-Launcher-Skript an das entry_point-Argument übergeben und Ihr Trainingsskript an das hyperparameters-Argument im Hugging-Face-Schätzer von SageMaker AI übergeben.

Bewährte Methoden zur Verwendung des SageMaker Training Compilers mit Trainer

  • Stellen Sie sicher, dass Sie SyncFree-Optimizer verwenden, indem Sie das Argument optim bei der Einrichtung von Transformers.trainingArgument auf adamw_torch_xla setzen. Siehe auch Optimizer in der Hugging Face Transformers Dokumentation.

  • Stellen Sie sicher, dass der Durchsatz der Datenverarbeitungspipeline höher ist als der Trainingsdurchsatz. Um dies zu erreichen, können Sie die Argumente dataloader_num_workers und preprocessing_num_workers der Klasse transformers.TrainingArgument anpassen. In der Regel müssen diese größer oder gleich der Anzahl der GPUs, aber kleiner als die Anzahl der CPUs sein.

Nachdem Sie die Anpassung Ihres Trainingsskripts abgeschlossen haben, fahren Sie mit Führen Sie PyTorch-Trainingsjobs mit dem SageMaker Training Compiler aus fort.

Große Sprachmodelle, die PyTorch direkt verwenden (ohne die Hugging Face Transformers Trainer-API)

Wenn Sie ein Trainingsskript haben, das PyTorch direkt verwendet, müssen Sie zusätzliche Änderungen an Ihrem PyTorch-Trainingsskript vornehmen, um PyTorch/XLA zu implementieren. Folgen Sie den Anweisungen, um Ihr Skript so zu ändern, dass die PyTorch/XLA-Primativen richtig eingerichtet werden.

Für das Training mit einer einzelnen GPU

  1. Importieren Sie die Optimierungsbibliotheken.

    import torch_xla
import torch_xla.core.xla_model as xm

  2. Ändern Sie das Zielgerät auf XLA statt auf torch.device("cuda")

    device=xm.xla_device()

  3. Wenn Sie Automatic Mixed Precision (AMP) von PyTorch verwenden, gehen Sie wie folgt vor:

    1. Ersetzen Sie torch.cuda.amp durch Folgendes:

      import torch_xla.amp

    2. Ersetzen Sie torch.optim.SGD und torch.optim.Adam durch folgendes:

      import torch_xla.amp.syncfree.Adam as adam
import torch_xla.amp.syncfree.SGD as SGD

    3. Ersetzen Sie torch.cuda.amp.GradScaler durch Folgendes:

      import torch_xla.amp.GradScaler as grad_scaler

  4. Wenn Sie AMP nicht verwenden, ersetzen Sie optimizer.step() durch Folgendes:

    xm.optimizer_step(optimizer)

  5. Wenn Sie einen verteilten Dataloader verwenden, binden Sie Ihren Dataloader in die Klasse PyTorch/XLA ParallelLoader ein:

    import torch_xla.distributed.parallel_loader as pl
parallel_loader=pl.ParallelLoader(dataloader, [device]).per_device_loader(device)

  6. Fügen Sie mark_step am Ende der Trainingsschleife hinzu, wenn Sie parallel_loader nicht verwenden:

    xm.mark_step()

  7. Verwenden Sie die Modell-Checkpoint-Methode von PyTorch/XLA, um Ihr Training zu überprüfen:

    xm.save(model.state_dict(), path_to_save)

Nachdem Sie die Anpassung Ihres Trainingsskripts abgeschlossen haben, fahren Sie mit Führen Sie PyTorch-Trainingsjobs mit dem SageMaker Training Compiler aus fort.

Für verteiltes Training

Fügen Sie zusätzlich zu den im vorherigen Für das Training mit einer einzelnen GPU Abschnitt aufgeführten Änderungen die folgenden Änderungen hinzu, um den Workload ordnungsgemäß auf die GPUs zu verteilen.

  1. Wenn Sie AMP verwenden, füge all_reduce danach scaler.scale(loss).backward() hinzu:

    gradients=xm._fetch_gradients(optimizer)
xm.all_reduce('sum', gradients, scale=1.0/xm.xrt_world_size())

  2. Wenn Sie Variablen für local_ranks und world_size setzen müssen, verwende einen ähnlichen Code wie den folgenden:

    local_rank=xm.get_local_ordinal()
world_size=xm.xrt_world_size()

  3. Für alle world_size (num_gpus_per_node*num_nodes) größer als 1, müssen Sie einen Train Sampler definieren, der wie folgt aussehen sollte:

    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. Nehmen Sie die folgenden Änderungen vor, um sicherzustellen, dass Sie das vom torch_xla distributed-Modul bereitgestellte parallel_loader verwenden. 

    import torch_xla.distributed.parallel_loader as pl
train_device_loader=pl.MpDeviceLoader(train_loader, device)

    Die train_device_loader Funktion funktioniert wie ein regulärer PyTorch-Loader wie folgt: 

    for step, (data, target) in enumerate(train_device_loader):
    optimizer.zero_grad()
    output=model(data)
    loss=torch.nn.NLLLoss(output, target)
    loss.backward()

    Mit all diesen Änderungen sollten Sie in der Lage sein, verteiltes Training mit jedem PyTorch-Modell ohne die Transformer Trainer-API zu starten. Beachten Sie, dass diese Anweisungen sowohl für Einzelknoten-Multi-GPU als auch für Multi-GPU mit mehreren Knoten verwendet werden können.

  5. Für PyTorch v1.11.0 und später

    Um verteiltes Training mit dem SageMaker Training Compiler durchzuführen, müssen Sie Ihrem Trainingsskript die folgende _mp_fn() Funktion hinzufügen und die Funktion main() umschließen. Es leitet die _mp_fn(index) Funktionsaufrufe von der verteilten SageMaker-AI-Laufzeit für PyTorch (pytorchxla) an die main() Funktion Ihres Trainingsskripts weiter. 

    def _mp_fn(index):
    main()

    Diese Funktion akzeptiert das index Argument, um den Rang der aktuellen GPU im Cluster für verteiltes Training anzugeben. Weitere Beispielskripte finden Sie in den Beispielskripten für die Sprachmodellierung von Hugging Face Transformers.

    Für Transformers v4.17 und früher mit PyTorch v1.10.2 und früher

    Der SageMaker Training Compiler verwendet einen alternativen Mechanismus zum Starten eines verteilten Trainingsjobs und verlangt, dass Sie ein SageMaker-AI-Startskript für verteiltes Training an das entry_point Argument und Ihr Trainingsskript an das hyperparameters Argument im Hugging-Face-Schätzer von SageMaker AI übergeben.

Nachdem Sie die Anpassung Ihres Trainingsskripts abgeschlossen haben, fahren Sie mit Führen Sie PyTorch-Trainingsjobs mit dem SageMaker Training Compiler aus fort.

Bewährte Methoden zur Verwendung des SageMaker Training Compilers mit PyTorch/XLA

Wenn Sie den SageMaker Training Compiler in Ihrem nativen PyTorch-Trainingsskript nutzen möchten, sollten Sie sich zunächst mit PyTorch auf XLA-Geräten vertraut machen. In den folgenden Abschnitten werden einige bewährte Methoden zur Aktivierung von XLA für PyTorch aufgeführt.

Anmerkung

In diesem Abschnitt für bewährte Methoden wird davon ausgegangen, dass Sie die folgenden PyTorch/XLA-Module verwenden:

import torch_xla.core.xla_model as xm
import torch_xla.distributed.parallel_loader as pl
Verstehe den Lazy-Modus in PyTorch/XLA

Ein wesentlicher Unterschied zwischen PyTorch/XLA und nativem PyTorch besteht darin, dass das PyTorch/XLA-System im Lazy-Modus läuft, während das native PyTorch im Eager-Modus läuft. Tensoren im Lazy-Modus sind Platzhalter für die Erstellung des Rechengraphen, bis sie nach Abschluss der Kompilierung und Auswertung materialisiert werden. Das PyTorch/XLA-System erstellt den Rechengraphen im laufenden Betrieb, wenn Sie PyTorch-APIs aufrufen, um die Berechnung mithilfe von Tensoren und Operatoren zu erstellen. Der Berechnungsgraph wird kompiliert und ausgeführt, wenn xm.mark_step() explizit oder implizit durch pl.MpDeviceLoader/pl.ParallelLoader aufgerufen wird, oder wenn Sie explizit den Wert eines Tensors anfordern, z. B. durch den Aufruf von loss.item() oder print(loss).

Minimierung der Anzahl der Kompilierungs- und Ausführungsschritte mit pl.MpDeviceLoader/pl.ParallelLoader und xm.step_closure

Um eine optimale Leistung zu erzielen, sollten Sie die in Verstehe den Lazy-Modus in PyTorch/XLA beschriebenen Möglichkeiten zur Einleitung von compilation-and-executions berücksichtigen und versuchen, die Anzahl der compilation-and-executions zu minimieren. Idealerweise ist pro Trainingsiteration nur eine Kompilierung und Ausführung erforderlich, die automatisch von pl.MpDeviceLoader/pl.ParallelLoader initiiert wird. Das MpDeviceLoader ist für XLA optimiert und sollte nach Möglichkeit immer verwendet werden, um eine optimale Leistung zu erzielen. Während des Trainings möchten Sie vielleicht einige Zwischenergebnisse, wie z. B. die Verlustwerte, untersuchen. In einem solchen Fall sollte das Drucken von trägen Tensoren mit xm.add_step_closure() umhüllt werden, um unnötige Kompilierungs- und Ausführungsschritte zu vermeiden.

Verwenden Sie AMP und syncfree Optimierer

Das Training im AMP-Modus (Automatic Mixed Precision) beschleunigt Ihre Trainingsgeschwindigkeit erheblich, indem Sie die Tensor-Kerne der NVIDIA-GPUs nutzen. SageMaker Training Compiler bietet syncfree Optimierer, die für XLA optimiert sind, um die AMP-Leistung zu verbessern. Derzeit sind die folgenden drei syncfree Optimierer verfügbar und sollten nach Möglichkeit verwendet werden, um eine optimale Leistung zu erzielen.

torch_xla.amp.syncfree.SGD
torch_xla.amp.syncfree.Adam
torch_xla.amp.syncfree.AdamW

Diese syncfree Optimierer sollten für die Skalierung/Deskalierung mit torch_xla.amp.GradScaler Gradienten kombiniert werden.

Tipp

Ab PyTorch 1.13.1 verbessert der SageMaker Training Compiler die Leistung, indem er PyTorch/XLA automatisch die Optimierer (wie SGD, Adam, AdamW) in torch.optim oder transformers.optimization mit den syncfree-Versionen davon in torch_xla.amp.syncfree (wie torch_xla.amp.syncfree.SGD, torch_xla.amp.syncfree.Adam, torch_xla.amp.syncfree.AdamW) überschreiben lässt. Sie müssen die Codezeilen, in denen Sie Optimierer definieren, in Ihrem Trainingsskript nicht ändern.