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 die SageMaker KI ein und führen Sie den Trainingsjob mit SageMaker Training Compiler aus.
**Topics**
+ [PyTorch Modelle mit Hugging Face Transformers](#training-compiler-pytorch-models-transformers)
## PyTorch Modelle mit Hugging Face Transformers
PyTorch Modelle mit [Hugging Face Transformers](https://huggingface.co/docs/transformers/index) basieren auf der PyTorch [Torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) API. Hugging Face Transformers bietet auch [Trainer](https://huggingface.co/docs/transformers/main_classes/trainer) - und vortrainierte Modellkurse an, PyTorch um den Aufwand für die Konfiguration von NLP-Modellen (Natural Language Processing) zu reduzieren. Nachdem Sie Ihr Trainingsskript vorbereitet haben, können Sie mithilfe der SageMaker KI `PyTorch` oder des `HuggingFace` Estimators mit der Konfiguration des SageMaker Training Compilers einen Trainingsjob starten, wenn Sie mit dem nächsten Thema unter fortfahren. [Aktivieren Sie den SageMaker Training Compiler](training-compiler-enable.md)
**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](https://huggingface.co/docs/transformers/pad_truncation) in der *Hugging Face Transformers Dokumentation*.
**Topics**
+ [`Große Sprachmodelle, die die Trainerklasse Hugging Face Transformers nutzen`](#training-compiler-pytorch-models-transformers-trainer)
+ [PyTorch Direkte Verwendung großer Sprachmodelle (ohne die Hugging Face Transformers Trainer-API)](#training-compiler-pytorch-models-non-trainer)
### `Große Sprachmodelle, die die Trainerklasse Hugging Face Transformers nutzen`
Wenn Sie die Trainer-Klasse der Transformers-Bibliothek verwenden, müssen Sie keine zusätzlichen Änderungen an Ihrem Trainingsskript vornehmen. SageMaker Der 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)
```
**Topics**
+ [Für das Training mit einer einzelnen GPU](#training-compiler-pytorch-models-transformers-trainer-single-gpu)
+ [Für verteiltes Training](#training-compiler-pytorch-models-transformers-trainer-distributed)
+ [`Bewährte Methoden zur Verwendung SageMaker des Training Compilers mit Trainer`](#training-compiler-pytorch-models-transformers-trainer-best-practices)
#### Für das Training mit einer einzelnen GPU
Sie müssen Ihren Code nicht ändern, wenn Sie die [https://huggingface.co/docs/transformers/main_classes/trainer](https://huggingface.co/docs/transformers/main_classes/trainer) Klasse verwenden.
#### Für verteiltes Training
**PyTorch v1.11.0 und höher**
Um verteiltes Training mit SageMaker Training Compiler auszuführen, müssen Sie Ihrem Trainingsskript die folgende `_mp_fn()` Funktion hinzufügen und die Funktion umschließen. `main()` Sie leitet die `_mp_fn(index)` Funktionsaufrufen 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](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling).
**Für Transformers v4.17 und früher mit PyTorch v1.10.2 und früher**
SageMaker Training Compiler verwendet einen alternativen Mechanismus zum Starten eines verteilten Trainingsjobs, sodass Sie keine Änderungen an Ihrem Trainingsskript vornehmen müssen. Stattdessen verlangt SageMaker Training Compiler, dass Sie ein SageMaker AI-Distributed-Trainings-Launcher-Skript an das `entry_point` Argument übergeben und Ihr Trainingsskript an das `hyperparameters` Argument im SageMaker AI Hugging Face Face-Schätzer übergeben.
#### `Bewährte Methoden zur Verwendung SageMaker des Training Compilers mit Trainer`
+ [Stellen Sie sicher, dass Sie SyncFree Optimierer verwenden, indem Sie das `optim` Argument `adamw_torch_xla` beim Einrichten von Transformatoren auf setzen. TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments). Siehe auch [Optimizer](https://huggingface.co/docs/transformers/v4.23.1/en/perf_train_gpu_one#optimizer) in der *Hugging Face Transformers Dokumentation*.
+ Stellen Sie sicher, dass der Durchsatz der Datenverarbeitungspipeline höher ist als der Trainingsdurchsatz. Sie können die `preprocessing_num_workers` Argumente `dataloader_num_workers` und die Argumente der [Transformatoren anpassen. TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments)Klasse, um das zu erreichen. 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 [PyTorch Trainingsjobs mit dem SageMaker Training Compiler ausführen](training-compiler-enable-pytorch.md) fort.
### PyTorch Direkte Verwendung großer Sprachmodelle (ohne die Hugging Face Transformers Trainer-API)
Wenn Sie über ein Trainingsskript verfügen, das PyTorch direkt verwendet wird, müssen Sie zur Implementierung zusätzliche Änderungen an Ihrem PyTorch Trainingsskript vornehmen. PyTorch/XLA Folgen Sie den Anweisungen, um Ihr Skript so zu ändern, dass die PyTorch/XLA Primatives korrekt eingerichtet werden.
**Topics**
+ [Für das Training mit einer einzelnen GPU](#training-compiler-pytorch-models-non-trainer-single-gpu)
+ [Für verteiltes Training](#training-compiler-pytorch-models-non-trainer-distributed)
+ [Bewährte Methoden zur Verwendung von Training Compiler mit SageMaker PyTorch/XLA](#training-compiler-pytorch-models-best-practices)
#### Für das Training mit einer einzelnen GPU
1. Importieren Sie die Optimierungsbibliotheken.
```
import torch_xla
import torch_xla.core.xla_model as xm
```
1. Ändern Sie das Zielgerät auf XLA statt auf `torch.device("cuda")`
```
device=xm.xla_device()
```
1. Wenn Sie [Automatic Mixed Precision](https://pytorch.org/docs/stable/amp.html) (AMP) verwenden PyTorch, gehen Sie wie folgt vor:
1. Ersetzen Sie `torch.cuda.amp` durch Folgendes:
```
import torch_xla.amp
```
1. 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
```
1. Ersetzen Sie `torch.cuda.amp.GradScaler` durch Folgendes:
```
import torch_xla.amp.GradScaler as grad_scaler
```
1. Wenn Sie AMP nicht verwenden, ersetzen Sie `optimizer.step()` durch Folgendes:
```
xm.optimizer_step(optimizer)
```
1. Wenn Sie einen verteilten Dataloader verwenden, schließen Sie Ihren Dataloader in die s-Klasse ein: PyTorch/XLA `ParallelLoader`
```
import torch_xla.distributed.parallel_loader as pl
parallel_loader=pl.ParallelLoader(dataloader, [device]).per_device_loader(device)
```
1. Fügen Sie `mark_step` am Ende der Trainingsschleife hinzu, wenn Sie `parallel_loader` nicht verwenden:
```
xm.mark_step()
```
1. Um dein Training zu überprüfen, verwende die Checkpoint-Methode des PyTorch/XLA Modells:
```
xm.save(model.state_dict(), path_to_save)
```
Nachdem Sie die Anpassung Ihres Trainingsskripts abgeschlossen haben, fahren Sie mit [PyTorch Trainingsjobs mit dem SageMaker Training Compiler ausführen](training-compiler-enable-pytorch.md) fort.
#### Für verteiltes Training
Fügen Sie zusätzlich zu den im vorherigen [Für das Training mit einer einzelnen GPU](#training-compiler-pytorch-models-non-trainer-single-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())
```
1. 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()
```
1. 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
)
```
1. 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)
```
Sie `train_device_loader` funktioniert wie ein normaler 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.
1. **Für PyTorch v1.11.0 und höher**
Um verteiltes Training mit SageMaker Training Compiler auszuführen, müssen Sie Ihrem Trainingsskript die folgende `_mp_fn()` Funktion hinzufügen und die Funktion umschließen. `main()` Sie leitet die `_mp_fn(index)` Funktionsaufrufen 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](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling).
**Für Transformers v4.17 und früher mit PyTorch v1.10.2 und früher**
SageMaker Der Training Compiler verwendet einen alternativen Mechanismus zum Starten eines verteilten Trainingsjobs und verlangt, dass Sie dem `entry_point` Argument ein Skript für den Start von verteiltem Training von SageMaker KI übergeben und Ihr Trainingsskript an das `hyperparameters` Argument im SageMaker AI Hugging Face Face-Schätzer übergeben.
Nachdem Sie die Anpassung Ihres Trainingsskripts abgeschlossen haben, fahren Sie mit [PyTorch Trainingsjobs mit dem SageMaker Training Compiler ausführen](training-compiler-enable-pytorch.md) fort.
#### Bewährte Methoden zur Verwendung von Training Compiler mit SageMaker PyTorch/XLA
Wenn Sie den SageMaker Training Compiler in Ihrem nativen PyTorch Trainingsskript nutzen möchten, sollten Sie sich zunächst mit [PyTorch XLA-Geräten](https://pytorch.org/xla/release/1.9/index.html) vertraut machen. In den folgenden Abschnitten werden einige bewährte Methoden zur Aktivierung von XLA aufgeführt. PyTorch
**Anmerkung**
In diesem Abschnitt mit bewährten 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
```
##### Verstehen Sie den Lazy-Modus in PyTorch/XLA
Ein wesentlicher Unterschied zwischen dem systemeigenen Modus PyTorch/XLA und dem nativen Modus PyTorch besteht darin, dass das PyTorch/XLA System im Lazy-Modus PyTorch läuft, während das native System 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)`.
##### Minimiere die Anzahl von *Kompilierung und Ausführung* `mit pl. MpDeviceLoader/pl.ParallelLoader`und `xm.step_closure`
Um eine optimale Leistung zu erzielen, sollten Sie die in [Verstehen Sie den Lazy-Modus in PyTorch/XLA](#training-compiler-pytorch-models-best-practices-lazy-mode) 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 Gradient mit diesen Optimierern kombiniert werden. `torch_xla.amp.GradScaler` scaling/unscaling
**Tipp**
Ab Version PyTorch 1.13.1 verbessert SageMaker Training Compiler die Leistung, indem er es PyTorch/XLA ermöglicht, die Optimierer (wie SGD, Adam, AdamW) in `torch.optim` oder `transformers.optimization` mit ihren syncfree-Versionen (wie,,) automatisch zu überschreiben. `torch_xla.amp.syncfree` `torch_xla.amp.syncfree.SGD` `torch_xla.amp.syncfree.Adam` `torch_xla.amp.syncfree.AdamW` Sie müssen die Codezeilen, in denen Sie Optimierer definieren, in Ihrem Trainingsskript nicht ändern.