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.
# Training mit gemischter Präzision
Die SageMaker Modellparallelismus-Bibliothek (SMP) v2 unterstützt standardmäßig gemischtes Präzisionstraining, indem sie in Open-Source-Frameworks wie FSDP und Transformer Engine integriert wird. PyTorch Weitere Informationen finden Sie unter den folgenden Themen.
**Topics**
+ [Training mit gemischter Präzision mit FP8 auf P5-Instances mithilfe der Transformer Engine](#model-parallel-core-features-v2-mixed-precision-fp8-training-on-p5)
+ [Gemischtes Präzisionstraining mit Datentypen mit halber Genauigkeit unter Verwendung von FSDP PyTorch](#model-parallel-core-features-v2-mixed-precision-half-precision)
## Training mit gemischter Präzision mit FP8 auf P5-Instances mithilfe der Transformer Engine
[Ausgehend von der SageMaker Modellparallelismus-Bibliothek (SMP) v2.2.0 ist die SMP-Bibliothek in die [Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/index.html) integriert und unterstützt [FP8-Mixed-Precision-Training](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/examples/fp8_primer.html) von Haus aus, wobei die Kompatibilität mit FSDP gewahrt bleibt. PyTorch `MixedPrecision`](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.MixedPrecision) Das bedeutet, dass Sie sowohl PyTorch FSDP für gemischtes Präzisionstraining als auch Transformer Engine für FP8-Training verwenden können. Für Modellebenen, die nicht von der FP8-Trainingsfunktion der Transformer Engine unterstützt werden, greifen diese Schichten auf PyTorch FSDP Mixed Precision zurück.
**Anmerkung**
SMP v2 bietet FP8-Unterstützung für die folgenden Transformer-Modelle von Hugging Face:
GPT-NeoX (verfügbar in SMP v2.2.0 und höher)
Llama 2 (verfügbar in SMP v2.2.0 und höher)
Mixtral 8x7b und Mixtral 8x22b (verfügbar in SMP v2.5.0 und höher)
**Anmerkung**
Diese FP8-Schulung zur P5-Funktion ist in der folgenden Kombination aus Bibliotheken von und der Bibliothek verfügbar: SageMaker PyTorch
Das SageMaker Python SDK v2.212.0 und höher
PyTorch v2.2.0 und höher
*FP8* (8-Bit-Gleitkomma-Präzision) ist ein Datentyp, der sich als weiteres Paradigma zur Beschleunigung des Deep-Learning-Trainings von LLM-Modellen herausgestellt hat. Mit der Veröffentlichung von NVIDIA-H100-GPUs, die FP8-Datentypen unterstützen, können Sie von den Leistungsverbesserungen auf P5-Instances profitieren, die mit den H100-GPUs ausgestattet sind, und gleichzeitig das verteilte Training durch das FP8-Training mit gemischter Präzision beschleunigen.
Der FP8-Datentyp unterteilt sich weiter in die Formate E4M3 und E5M2. *E4M3* bietet eine bessere Präzision, hat einen begrenzten Dynamikbereich und ist ideal für den Vorwärtsdurchlauf beim Modelltraining. *E5M2* hat einen größeren Dynamikbereich, aber auch eine geringere Präzision und eignet sich besser für den Rückwärtsdurchlauf, bei dem Präzision weniger wichtig ist und ein größerer Dynamikbereich von Vorteil ist. Daher empfehlen wir Ihnen, das [Rezept für die hybride FP8-Strategie](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/examples/fp8_primer.html#FP8-recipe) zu verwenden, um diese Eigenschaften effektiv zu nutzen.
Bei Datentypen mit halber Präzision (FP16 und BF16) beheben globale Verlustskalierungstechniken wie statische Verlustskalierung oder dynamische Verlustskalierung Konvergenzprobleme, die sich aus Informationsverlusten aufgrund von Rundungsgradienten bei halber Präzision ergeben. Der Dynamikbereich von FP8 ist jedoch noch enger und die Techniken zur globalen Verlustskalierung reichen nicht aus. An diesem Punkt benötigen wir eine detailliertere Skalierungstechnik pro Tensor. Die *verzögerte Skalierung* ist eine Strategie, bei der ein Skalierungsfaktor auf der Grundlage der maximalen absoluten Werte ausgewählt wird, die in einer Reihe von Tensoren aus früheren Iterationen beobachtet wurden. Diese Strategie birgt einen Nachteil: Sie nutzt die vollen Leistungsvorteile der FP8-Berechnungen, benötigt aber Speicher für die Speicherung des Maximalwertverlaufs der Tensoren. Weitere allgemeine Informationen zur Strategie der verzögerten Skalierung finden Sie im Dokument [https://arxiv.org/pdf/2209.05433.pdf](https://arxiv.org/pdf/2209.05433.pdf).
In der Praxis ist die Verwendung von FP8 in allen Trainingsszenarien auf P5-Instances hilfreich. Wir empfehlen dringend, FP8 wann immer möglich zu aktivieren, um die Trainingsleistung zu verbessern.
SMP v2 unterstützt standardmäßig Transformer Engine. Wenn Sie das FP8-Training mit SMP v2 auf P5-Instanzen von SageMaker AI (`ml.p5.48xlarge`) ausführen, müssen Sie daher nur `torch.sagemaker` in Ihr Trainingsskript importieren und weiterhin das native Python-Paket Transformer Engine verwenden. Weitere Informationen zur Verwendung der Transformer Engine für FP8-Training im Allgemeinen finden Sie unter [Verwendung von FP8 mit Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/examples/fp8_primer.html) in der *Dokumentation zu NVIDIA Transformer Engine*. Der folgende Codeausschnitt zeigt, wie die Codezeilen für den Import der SMP-Bibliothek und die Einrichtung von FP8 in Ihrem Trainingsskript aussehen sollten.
```
import torch.sagemaker as tsm
import transformer_engine.pytorch as te
from transformer_engine.common.recipe import DelayedScaling, Format
# Initialize the SMP torch.sagemaker API.
tsm.init()
# Define a transformer model and wrap it with the torch.sagemaker.transform API.
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_config({{ModelConfig}})
model = tsm.transform(model)
# Enable E4M3 during forward pass, E5M2 during backward pass.
fp8_format = Format.HYBRID
# Create an FP8 recipe.
fp8_recipe = DelayedScaling(fp8_format=fp8_format, amax_history_len=32, amax_compute_algo="max")
# Enable FP8 autocasting.
with te.fp8_autocast(enabled=True, fp8_recipe=fp8_recipe, fp8_group=tsm.state.world_process_group):
out = model(inp)
loss = out.sum()
loss.backward()
```
Ein praktisches Beispiel für ein FP8-Training mit SMP v2 auf P5-Instanzen finden Sie im Beispiel-Notizbuch unter [Accelerate SageMaker PyTorch FSDP Training of Llama-v2 (oder GPT-NeoX)](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/llama_v2/smp-train-llama-fsdp-tp-fp8.ipynb) mit FP8 auf P5-Instanzen.
## Gemischtes Präzisionstraining mit Datentypen mit halber Genauigkeit unter Verwendung von FSDP PyTorch
SMP v2 unterstützt [PyTorch FSDP `MixedPrecision`](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.MixedPrecision) für Trainingsjobs auf P4- und P5-Instances. PyTorch FSDP bietet verschiedene Konfigurationen für gemischte Präzision, sowohl zur Leistungsverbesserung als auch zur Speicherreduzierung.
**Anmerkung**
Dieses Training mit gemischter Präzision und der PyTorch FSDP-Funktion ist in der folgenden Kombination aus Bibliotheken von SageMaker und der PyTorch Bibliothek verfügbar.
SMP v2.0.0 und höher
das SageMaker Python SDK v2.200.0 und höher
PyTorch v2.0.1 und höher
Die Standardmethode, ein Modell für gemischte Präzision zu konfigurieren, besteht darin, das Modell in `float32` zu erstellen und dann FSDP zu erlauben, die Parameter durch Übergabe einer `MixedPrecision`-Richtlinie im laufenden Betrieb in `float16` oder `bfloat16` umzuwandeln, wie im folgenden Codeausschnitt gezeigt. *Weitere Informationen zu den Optionen zum Ändern der Parameter, der `dtype` Reduzierung oder der Puffer für gemischte Genauigkeit in finden Sie in der Dokumentation PyTorch unter [PyTorch `MixedPrecision`FSDP-API](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.MixedPrecision). PyTorch*
```
# Native PyTorch API
from torch.distributed.fsdp import MixedPrecision
dtype = torch.bfloat16
mixed_precision_policy = MixedPrecision(
param_dtype=dtype, reduce_dtype=dtype, buffer_dtype=dtype
)
model = FSDP(
model,
...,
mixed_precision=mixed_precision_policy
)
```
Beachten Sie, dass bei bestimmten Modellen (wie dem Llama-Modell von Hugging Face Transformers) Puffer als `float32` erwartet werden. Um `float32` zu verwenden, ersetzen Sie `torch.bfloat16` durch `torch.float32` in der Zeile, die das `dtype`-Objekt definiert.