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.
# (Archiviert) SageMaker-Modellparallelitätsbibliothek v1.x
**Wichtig**
Am 19. Dezember 2023 wurde die SageMaker-Modellparallelitätsibliothek (SMP) v2 veröffentlicht. Zugunsten der SMP-Bibliothek v2 werden die Funktionen von SMP v1 in zukünftigen Versionen nicht mehr unterstützt. Die folgenden Abschnitte und Themen sind archiviert und beziehen sich auf die Verwendung der SMP-Bibliothek v1. Weitere Informationen zur Verwendung der SMP-Bibliothek v2 finden Sie unter [SageMaker Modellparallelitätsbibliothek v2](model-parallel-v2.md).
Verwenden Sie die Modellparallelbibliothek von Amazon SageMaker AI, um große Deep-Learning-Modelle (DL) zu trainieren, die aufgrund von GPU-Speicherbeschränkungen schwierig zu trainieren sind. Die Bibliothek teilt ein Modell automatisch und effizient auf mehrere GPUs und Instances auf. Mithilfe der Bibliothek können Sie schneller eine Zielvorhersagegenauigkeit erreichen, indem Sie größere DL-Modelle mit Milliarden oder Billionen von Parametern effizient trainieren.
Sie können die Bibliothek verwenden, um Ihre eigenen TensorFlow- und PyTorch-Modelle mit minimalen Codeänderungen automatisch auf mehrere GPUs und mehrere Knoten zu partitionieren. Sie können über das SageMaker Python SDK auf die API der Bibliothek zugreifen.
In den folgenden Abschnitten erfahren Sie mehr über Modellparallelität und die Modellparallelbibliothek von SageMaker. Die API-Dokumentation dieser Bibliothek befindet sich unter [Distributed Training APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) in der *Dokumentation zu SageMaker Python SDK v2.199.0*.
**Topics**
+ [Einführung in die Modell-Parallelität](model-parallel-intro.md)
+ [Unterstützte Frameworks und AWS-Regionen](distributed-model-parallel-support.md)
+ [Kernfunktionen der SageMaker Model Parallelism Library](model-parallel-core-features.md)
+ [Führen Sie einen SageMaker verteilten Trainingsjob mit Modellparallelität aus](model-parallel-use-api.md)
+ [Überprüfung und Feinabstimmung eines Modells mit Modellparallelität](distributed-model-parallel-checkpointing-and-finetuning.md)
+ [Beispiele für die Amazon SageMaker AI-Modellparallelismusbibliothek v1](distributed-model-parallel-examples.md)
+ [SageMaker Bewährte Methoden für verteilte Modellparallelität](model-parallel-best-practices.md)
+ [Tipps und Fallstricke zur Konfiguration der SageMaker Distributed Model Parallelism Library](model-parallel-customize-tips-pitfalls.md)
+ [Parallele Problembehebung bei Modellen](distributed-troubleshooting-model-parallel.md)
# Einführung in die Modell-Parallelität
Modellparallelität ist eine verteilte Trainingsmethode, bei der das Deep-Learning-Modell auf mehrere Geräte, innerhalb oder zwischen Instances, aufgeteilt wird. Diese Einführungsseite bietet einen allgemeinen Überblick über Modellparallelität, eine Beschreibung, wie sie helfen kann, Probleme zu lösen, die beim Training von DL-Modellen auftreten, die normalerweise sehr groß sind, und Beispiele dafür, was die SageMaker Modellparallel-Bibliothek bietet, um modellparallele Strategien sowie den Speicherverbrauch zu verwalten.
## Was ist Modellparallelität?
Eine Erhöhung der Größe von Deep-Learning-Modellen (Ebenen und Parameter) führt zu einer besseren Genauigkeit bei komplexen Aufgaben wie Computer Vision und Verarbeitung natürlicher Sprache. Die maximale Modellgröße, die Sie in den Speicher einer einzelnen GPU passen können, ist jedoch begrenzt. Beim Training von DL-Modellen können GPU-Speicherbeschränkungen auf folgende Weise zu Engpässen führen:
+ Sie begrenzen die Größe des Modells, das Sie trainieren können, da der Speicherbedarf eines Modells proportional zur Anzahl der Parameter skaliert.
+ Sie begrenzen die Batchgröße pro GPU während des Trainings und verringern so die GPU-Auslastung und die Trainingseffizienz.
Um die Einschränkungen zu überwinden, die mit dem Training eines Modells auf einer einzelnen GPU verbunden sind, SageMaker bietet die Modellparallelbibliothek, mit der DL-Modelle effizient auf mehreren Rechenknoten verteilt und trainiert werden können. Darüber hinaus können Sie mit der Bibliothek ein optimiertes verteiltes Training mit EFA-unterstützten Geräten erreichen, die die Leistung der Kommunikation zwischen den Knoten mit geringer Latenz, hohem Durchsatz und Betriebssystem-Bypass verbessern.
## Schätzen Sie den Speicherbedarf ab, bevor Sie Modellparallelismus verwenden
Bevor Sie die SageMaker Modellparallelbibliothek verwenden, sollten Sie Folgendes berücksichtigen, um sich ein Bild von den Speicheranforderungen beim Training großer DL-Modelle zu machen.
Für einen Trainingsjob, der AMP (FP16) - und Adam-Optimierer verwendet, beträgt der erforderliche GPU-Speicher pro Parameter etwa 20 Byte, die wir wie folgt aufschlüsseln können:
+ Ein FP16 Parameter \$1 2 Byte
+ Ein FP16 Gradient \$1 2 Byte
+ Ein FP32 Optimierungsstatus von \$1 8 Byte, der auf den Adam-Optimierern basiert
+ Eine FP32 Kopie des Parameters \$1 4 Byte (wird für den `optimizer apply` (OA-) Vorgang benötigt)
+ Eine FP32 Kopie von Gradient \$1 4 Byte (wird für die OA-Operation benötigt)
Selbst für ein relativ kleines DL-Modell mit 10 Milliarden Parametern kann es mindestens 200 GB Arbeitsspeicher benötigen, was viel größer ist als der typische GPU-Speicher (z. B. NVIDIA A100 mit 40 GB/80 GB Speicher und V100 mit 16/32 GB), der auf einer einzelnen GPU verfügbar ist. Beachten Sie, dass zusätzlich zu den Speicheranforderungen für Modell- und Optimiererstatus weitere Speicherverbraucher hinzukommen, wie z. B. Aktivierungen, die im Forward-Pass generiert werden. Der benötigte Speicher kann deutlich mehr als 200 GB betragen.
Für verteilte Schulungen empfehlen wir die Verwendung von Amazon EC2 P3- und P4-Instances mit NVIDIA V100 bzw. A100 Tensor Core. GPUs Weitere Informationen zu Spezifikationen wie CPU-Kernen, RAM, angeschlossenem Speichervolumen und Netzwerkbandbreite finden Sie im Abschnitt *Beschleunigtes Rechnen* auf der Seite [Amazon-EC2-Instance-Typen](https://aws.amazon.com/ec2/instance-types/).
Selbst bei den beschleunigte Computing-Instances ist es offensichtlich, dass Modelle mit etwa 10 Milliarden Parametern wie Megatron-LM und T5 und noch größere Modelle mit Hunderten von Milliarden von Parametern wie GPT-3 nicht in jedes GPU-Gerät passen können.
## Wie die Bibliothek Modellparallelität und Speicherspartechniken einsetzt
Die Bibliothek besteht aus verschiedenen Arten von Modellparallelitäts-Features und Features zur Speichereinsparung, z. B. Optimierungszustand-Sharding, Aktivierungsprüfpunkte und Aktivierungs-Offloading. All diese Techniken können kombiniert werden, um große Modelle, die aus Hunderten von Milliarden von Parametern bestehen, effizient zu trainieren.
**Topics**
+ [Sharded Data Parallelität (verfügbar für) PyTorch](#model-parallel-intro-sdp)
+ [PyTorch TensorFlowPipeline-Parallelität (verfügbar für und)](#model-parallel-intro-pp)
+ [Tensorparallelität (verfügbar für) PyTorch](#model-parallel-intro-tp)
+ [PyTorchState-Sharding im Optimizer (verfügbar für)](#model-parallel-intro-oss)
+ [Aktivierung, Offloading und Checkpointing (verfügbar für) PyTorch](#model-parallel-intro-activation-offloading-checkpointing)
+ [Auswahl der richtigen Techniken für Ihr Modell](#model-parallel-intro-choosing-techniques)
### Sharded Data Parallelität (verfügbar für) PyTorch
*Sharded Data Parallelism* ist eine speichersparende verteilte Trainingstechnik, die den Status eines Modells (Modellparameter, Gradienten und Optimiererzustände) innerhalb einer datenparallelen Gruppe aufteilt. GPUs
SageMaker **[KI implementiert Sharded Data Parallelität durch die Implementierung von MICs. Dabei handelt es sich um eine Bibliothek, die die Kommunikation im Maßstab minimiert und im Blogbeitrag Nahezu lineare **Skalierung** des Trainings mit **gigantischen** Modellen erörtert wird. AWS](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws)**
Sie können die Parallelität von Sharded-Daten als eigenständige Strategie auf Ihr Modell anwenden. Wenn Sie die leistungsstärksten GPU-Instanzen verwenden, die mit NVIDIA A100 Tensor Core ausgestattet sind, können Sie außerdem die Vorteile der verbesserten Trainingsgeschwindigkeit nutzen GPUs`ml.p4d.24xlarge`, die sich aus dem von SMDDP Collectives angebotenen Betrieb ergibt. `AllGather`
Weitere Informationen zur Sharded-Datenparallelität und zu deren Einrichtung oder Verwendung einer Kombination aus Sharded-Datenparallelität und anderen Techniken wie Tensorparallelität und Training finden Sie unter. FP16 [Parallelität fragmentierter Daten](model-parallel-extended-features-pytorch-sharded-data-parallelism.md)
### PyTorch TensorFlowPipeline-Parallelität (verfügbar für und)
Die *Pipeline-Parallelität* partitioniert den Satz von Ebenen oder Operationen über die gesamte Gruppe von Geräten hinweg, sodass jeder Vorgang intakt bleibt. Wenn Sie einen Wert für die Anzahl der Modellpartitionen (`pipeline_parallel_degree`) angeben, muss die Gesamtzahl von GPUs (`processes_per_host`) durch die Anzahl der Modellpartitionen teilbar sein. Um dies richtig einzurichten, müssen Sie die richtigen Werte für die `pipeline_parallel_degree` und `processes_per_host` Parameter angeben. Die einfache Mathematik lautet wie folgt:
```
(pipeline_parallel_degree) x (data_parallel_degree) = processes_per_host
```
Die Bibliothek berechnet anhand der beiden von Ihnen angegebenen Eingabeparameter die Anzahl der Modellreplikate (auch `data_parallel_degree` genannt).
Wenn Sie beispielsweise eine ML-Instanz mit acht GPU-Workern einrichten `"pipeline_parallel_degree": 2` und `"processes_per_host": 8` verwenden`ml.p3.16xlarge`, richtet die Bibliothek automatisch das verteilte Modell über die Datenparallelität GPUs und die Vierwege-Datenparallelität ein. Die folgende Abbildung zeigt, wie ein Modell auf die acht Bereiche verteilt wird, wodurch eine vierseitige Datenparallelität und eine bidirektionale Pipeline-Parallelität GPUs erreicht wird. Jedes Modellreplikat, in dem wir es als *parallel Pipeline-Gruppe* definieren und es als bezeichnen`PP_GROUP`, ist zweigeteilt. GPUs Jede Partition des Modells ist vier Partitionen zugewiesen GPUs, wobei sich die vier Partitionsreplikate in einer *datenparallelen Gruppe* befinden und als `DP_GROUP` gekennzeichnet sind. Ohne Tensorparallelität ist die Pipeline-Parallelgruppe im Wesentlichen die Modellparallelgruppe.
![\[Wie ein Modell auf die acht Bereiche verteilt wird, sodass eine vierseitige Datenparallelität und eine bidirektionale Pipeline-Parallelität GPUs erreicht werden.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-pipeline-parallel-only.png)
Weitere Informationen zur Pipeline-Parallelität finden Sie unter [Kernfunktionen der SageMaker Model Parallelism Library](model-parallel-core-features.md).
Informationen zu den ersten Schritten beim Ausführen Ihres Modells mithilfe der Pipeline-Parallelität finden Sie unter [Ausführen eines SageMaker verteilten Trainingsjobs mit der SageMaker Model Parallel Library](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-use-api.html).
### Tensorparallelität (verfügbar für) PyTorch
Die *Tensorparallelität* teilt einzelne Schichten, oder `nn.Modules`, auf und kann geräteübergreifend parallel ausgeführt werden. Die folgende Abbildung zeigt das einfachste Beispiel dafür, wie die Bibliothek ein Modell in vier Schichten aufteilt, um eine bidirektionale Tensorparallelität zu erreichen (`"tensor_parallel_degree": 2`). Die Schichten jedes Modellreplikats werden halbiert und in zwei Teile aufgeteilt. GPUs In diesem Beispielfall umfasst die parallel Modellkonfiguration auch `"pipeline_parallel_degree": 1` und `"ddp": True` (verwendet das PyTorch DistributedDataParallel Paket im Hintergrund), sodass der Grad der Datenparallelität acht beträgt. Die Bibliothek verwaltet die Kommunikation zwischen den über Tensor verteilten Modellreplikaten.
![\[Das einfachste Beispiel dafür, wie die Bibliothek ein Modell in vier Schichten aufteilt, um eine bidirektionale Tensorparallelität zu erreichen ("tensor_parallel_degree": 2).\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-tensor-parallel-only.png)
Der Nutzen dieser Feature besteht darin, dass Sie bestimmte Ebenen oder eine Teilmenge von Schichten auswählen können, um die Tensorparallelität anzuwenden. Einen tiefen Einblick in die Tensorparallelität und andere speichersparende Funktionen für und um zu erfahren PyTorch, wie man eine Kombination aus Pipeline- und Tensorparallelität einstellt, finden Sie unter. [Tensor-Parallelität](model-parallel-extended-features-pytorch-tensor-parallelism.md)
### PyTorchState-Sharding im Optimizer (verfügbar für)
Um zu verstehen, wie die Bibliothek das *Optimierungszustand-Sharding* durchführt, betrachten Sie ein einfaches Beispielmodell mit vier Ebenen. Die wichtigste Idee bei der Optimierung des State-Shardings besteht darin, dass Sie Ihren Optimizer-Status nicht in allen Ihren Versionen replizieren müssen. GPUs Stattdessen wird ein einzelnes Replikat des Optimisierungsstatus über datenparallele Ränge verteilt, ohne dass Redundanz zwischen Geräten besteht. Beispielsweise enthält GPU 0 den Optimisierungsstatus für Ebene 1, die nächste GPU 1 den Optimisierungsstatus für L2 und so weiter. Die folgende animierte Abbildung zeigt eine Rückwärtsausbreitung mit der Optimierungszustand-Sharding-Technik. Am Ende der Rückwärtsverbreitung stehen Rechen- und Netzwerkzeit für die Operation `optimizer apply` (OA) zur Aktualisierung der Optimisierungszustände und die Operation `all-gather` (AG) zur Aktualisierung der Modellparameter für die nächste Iteration zur Verfügung. Am wichtigsten ist, dass sich der `reduce` Vorgang mit der Berechnung auf GPU 0 überschneiden kann, was zu einer speichereffizienteren und schnelleren Rückwärtsübertragung führt. In der aktuellen Implementierung überschneiden sich AG- und OA-Operationen nicht mit `compute`. Dies kann zu einer längeren Berechnung während des AG-Vorgangs führen, sodass es zu einem Kompromiss kommen kann.
![\[Eine Rückwärtsausbreitung mit der Optimierungszustand-Sharding-Technik.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-optimizer-state-sharding.gif)
Weitere Informationen zur Verwendung dieser Funktion finden Sie unter [Optimierungszustand-Sharding](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-optimizer-state-sharding.html).
### Aktivierung, Offloading und Checkpointing (verfügbar für) PyTorch
Um GPU-Speicher zu sparen, unterstützt die Bibliothek Aktivierungsprüfpunkte, um zu verhindern, dass interne Aktivierungen für benutzerdefinierte Module während des Forward-Durchlaufs im GPU-Speicher gespeichert werden. Die Bibliothek berechnet diese Aktivierungen während des Rückwärtsdurchlaufs neu. Darüber hinaus verlagert die Feature zum Ablagern der Aktivierung die gespeicherten Aktivierungen auf den CPU-Speicher und lädt sie während des Rücklaufs zurück auf die GPU, um den Speicherbedarf für die Aktivierung weiter zu reduzieren. Weitere Informationen zur Verwendung dieser Features finden Sie unter [Aktivierungsprüfpunkte](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-activation-checkpointing.html) und [Aktivierungsabladung](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-activation-offloading.html).
### Auswahl der richtigen Techniken für Ihr Modell
Weitere Informationen zur Auswahl der richtigen Techniken und Konfigurationen finden Sie unter [Bewährte Methoden für SageMaker Distributed Model Parallel](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-best-practices.html) sowie [Tipps und Fallstricke zur Konfiguration](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-customize-tips-pitfalls.html).
# Unterstützte Frameworks und AWS-Regionen
Bevor Sie die SageMaker Modellparallelismus-Bibliothek verwenden, überprüfen Sie die unterstützten Frameworks und Instanztypen und stellen Sie fest, ob in Ihrem Konto genügend Kontingente vorhanden sind und. AWS AWS-Region
**Anmerkung**
Die neuesten Updates und Versionshinweise der Bibliothek finden Sie in den [Versionshinweisen zu SageMaker Model Parallel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) in der *SageMaker Python SDK-Dokumentation*.
## Unterstützte Frameworks
Die SageMaker Modellparallelismus-Bibliothek unterstützt die folgenden Deep-Learning-Frameworks und ist in AWS Deep Learning Containers (DLC) verfügbar oder als Binärdatei herunterladbar.
PyTorch Versionen, die von SageMaker AI und der Modellparallelismus-Bibliothek unterstützt werden SageMaker
| PyTorch Version | SageMaker Version der Bibliothek für Modellparallelität | `smdistributed-modelparallel` integrierter DLC-Image-URI | URL der Binärdatei\$1\$1 |
| --- | --- | --- | --- |
| v2.0.0 | smdistributed-modelparallel==v1.15.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.0-gpu-py310-cu118-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-2.0.0/build-artifacts/2023-04-14-20-14/smdistributed\$1modelparallel-1.15.0-cp310-cp310-linux\$1x86\$164.whl |
| v1.13.1 | smdistributed-modelparallel==v1.15.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.13.1-gpu-py39-cu117-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.13.1/build-artifacts/2023-04-17-15-49/smdistributed\$1modelparallel-1.15.0-cp39-cp39-linux\$1x86\$164.whl |
| v1.12.1 | smdistributed-modelparallel==v1.13.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.1-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.12.1/Artefakte bauen/2021-12-08-21-34/smdistributed\$1modelparallel-1.13.0-cp38-cp38-linux\$1x86\$164.whl |
| v1.12.0 | smdistributed-modelparallel==v1.11.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.12.0/Artefakte bauen/2022-08-12-16-58/smdistributed\$1modelparallel-1.11.0-cp38-cp38-linux\$1x86\$164.whl |
| v1.11.0 | smdistributed-modelparallel==v1.10.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.11.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.11.0/Artefakte bauen/2022-07-11-19-23/smdistributed\$1modelparallel-1.10.0-cp38-cp38-linux\$1x86\$164.whl |
| v1.10.2 | smdistributed-modelparallel==v1.7.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.10.2-gpu-py38-cu113-ubuntu20.04-sagemaker` | - |
| v1.10.0 | smdistributed-modelparallel==v1.5.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.10.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | - |
| v1.9.1 | smdistributed-modelparallel==v1.4.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.9.1-gpu-py38-cu111-ubuntu20.04` | - |
| v1.8.1\$1 | smdistributed-modelparallel==v1.6.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.8.1-gpu-py36-cu111-ubuntu18.04` | - |
**Anmerkung**
Die Modellparallelismus-Bibliothek v1.6.0 und höher bietet erweiterte Funktionen für. SageMaker PyTorch Weitere Informationen finden Sie unter [Kernfunktionen der SageMaker Model Parallelism Library](model-parallel-core-features.md).
\$1\$1 Die Binärdateien dienen URLs der Installation der SageMaker Modellparallelismus-Bibliothek in benutzerdefinierten Containern. Weitere Informationen finden Sie unter [Erstellen Sie Ihren eigenen Docker-Container mit der SageMaker Distributed Model Parallel Library](model-parallel-sm-sdk.md#model-parallel-bring-your-own-container).
TensorFlow Versionen, die von SageMaker AI und der SageMaker Model Parallelism Library unterstützt werden
| TensorFlow Version | SageMaker Version der Bibliothek für Modellparallelität | `smdistributed-modelparallel` integrierter DLC-Image-URI |
| --- | --- | --- |
| v2.6.0 | smdistributed-modelparallel==v1.4.0 | 763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.6.0-gpu-py38-cu112-ubuntu20.04 |
| v2.5.1 | smdistributed-modelparallel==v1.4.0 | 763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.5.1-gpu-py37-cu112-ubuntu18.04 |
**Hugging Face Transformers-Versionen, die von SageMaker KI und der SageMaker Distributed Data Parallel Library unterstützt werden**
Die AWS Deep Learning Containers für Hugging Face verwenden die SageMaker Training Container für PyTorch und TensorFlow als Basisimages. Die Versionen der Hugging Face Transformers-Bibliothek und die zugehörigen Versionen finden Sie in PyTorch den neuesten [Hugging Face Containers und den [vorherigen Hugging](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#prior-hugging-face-container-versions) Face TensorFlow Container-Versionen](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers).
## AWS-Regionen
Die SageMaker Datenparallelbibliothek ist überall dort verfügbar AWS-Regionen , wo die [AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) im Einsatz SageMaker sind. Weitere Informationen finden Sie unter [Verfügbare Deep Learning Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#available-deep-learning-containers-images).
## Unterstützte Instance-Typen
Die SageMaker Modellparallelismus-Bibliothek erfordert einen der folgenden ML-Instanztypen.
| Instance-Typ |
| --- |
| ml.g4dn.12xlarge |
| ml.p3.16xlarge |
| ml.p3dn.24xlarge |
| ml.p4d.24xlarge |
| ml.p4de.24xlarge |
Die Spezifikationen der Instance-Typen finden Sie im Abschnitt **Accelerated Computing** auf der [Seite Amazon-EC2-Instance-Typen](https://aws.amazon.com/ec2/instance-types/). Informationen zu den Instance-Preisen finden Sie unter [Amazon SageMaker AI-Preise](https://aws.amazon.com/sagemaker/pricing/).
Wenn Sie auf eine Fehlermeldung gestoßen sind, die der folgenden ähnelt, folgen Sie den Anweisungen unter [Beantragen Sie eine Erhöhung des Servicekontingents für SageMaker KI-Ressourcen](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html#service-limit-increase-request-procedure).
```
ResourceLimitExceeded: An error occurred (ResourceLimitExceeded) when calling
the CreateTrainingJob operation: The account-level service limit 'ml.p3dn.24xlarge
for training job usage' is 0 Instances, with current utilization of 0 Instances
and a request delta of 1 Instances.
Please contact AWS support to request an increase for this limit.
```
# Kernfunktionen der SageMaker Model Parallelism Library
Die Modellparallelismus-Bibliothek von Amazon SageMaker AI bietet Verteilungsstrategien und Techniken zur Speichereinsparung, wie z. B. Shard-Datenparallelität, Tensorparallelität, Modellpartitionierung nach Ebenen für die Pipeline-Planung und Checkpointing. Die Strategien und Techniken zur Modellparallelität helfen dabei, große Modelle auf mehrere Geräte zu verteilen und dabei das Trainingsgeschwindigkeit und die Speichernutzung zu optimieren. Die Bibliothek bietet auch Python-Hilfsfunktionen, Kontextmanager und Wrapper-Funktionen, mit denen Sie Ihr Trainingsskript für die automatisierte oder manuelle Partitionierung Ihres Modells anpassen können.
Wenn Sie Modellparallelität in Ihren Trainingsjob implementieren, behalten Sie denselben zweistufigen Arbeitsablauf bei, der im Abschnitt [Einen SageMaker verteilten Trainingsjob mit Modellparallelität ausführen](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-use-api.html) beschrieben ist. Um Ihr Trainingsskript anzupassen, fügen Sie zu Ihrem Trainingsskript keine oder nur wenige zusätzliche Zeilen Code hinzu. Um anhand des angepassten Trainingsskripts einen Trainingsauftrag zu starten, müssen Sie die Konfigurationsparameter für die Verteilung festlegen, um die speichersparenden Funktionen zu aktivieren oder um Werte für den Parallelitätsgrad zu übergeben.
Beispiele für den Einstieg finden Sie in den folgenden Jupyter-Notebooks, in denen die Verwendung der Modellparallelismus-Bibliothek veranschaulicht wird. SageMaker
+ [PyTorch Beispiel-Notebooks](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel)
+ [TensorFlow Beispiel Notizbücher](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/tensorflow/model_parallel/mnist)
Weitere Informationen zu den Kernfunktionen der Bibliothek finden Sie in den folgenden Themen.
**Anmerkung**
Die SageMaker verteilten Schulungsbibliotheken sind über die AWS Deep-Learning-Container für PyTorch Hugging Face und TensorFlow innerhalb der SageMaker Trainingsplattform verfügbar. Um die Funktionen der verteilten Trainingsbibliotheken nutzen zu können, empfehlen wir die Verwendung des SageMaker Python-SDK. Sie können die Konfiguration auch manuell in der JSON-Anforderungssyntax vornehmen, wenn SageMaker APIs Sie das SDK for Python (Boto3) oder verwenden. AWS Command Line Interface In der gesamten Dokumentation konzentrieren sich Anweisungen und Beispiele auf die Verwendung der verteilten Trainingsbibliotheken mit dem SageMaker Python-SDK.
**Wichtig**
Die SageMaker Modellparallelitätsbibliothek unterstützt alle Kernfunktionen von und unterstützt Pipeline-Parallelität für PyTorch. TensorFlow
**Topics**
+ [Parallelität fragmentierter Daten](model-parallel-extended-features-pytorch-sharded-data-parallelism.md)
+ [Modell-Pipelining](model-parallel-core-features-pipieline-parallelism.md)
+ [Tensor-Parallelität](model-parallel-extended-features-pytorch-tensor-parallelism.md)
+ [Optimizer-Zustandsfragmentierung](model-parallel-extended-features-pytorch-optimizer-state-sharding.md)
+ [Aktivierungs-Prüfpunkte](model-parallel-extended-features-pytorch-activation-checkpointing.md)
+ [Aktivierungs-Entladung](model-parallel-extended-features-pytorch-activation-offloading.md)
+ [FP16 Training mit Modellparallelität](model-parallel-extended-features-pytorch-fp16.md)
+ [Support für FlashAttention](model-parallel-attention-head-size-for-flash-attention.md)
# Parallelität fragmentierter Daten
*Sharded Data Parallelism* ist eine speichersparende verteilte Trainingstechnik, die den Status eines Modells (Modellparameter, Gradienten und Optimiererzustände) in einer datenparallelen Gruppe aufteilt. GPUs
**Anmerkung**
Sharded Data Parallelism ist in der Modellparallelismus-Bibliothek v1.11.0 und höher verfügbar. PyTorch SageMaker
Wenn Sie Ihren Trainingsjob auf einen großen GPU-Cluster skalieren, können Sie den Speicherbedarf des Modells pro GPU reduzieren, indem Sie den Trainingsstatus des Modells auf mehrere verteilen. GPUs Dies hat zwei Vorteile: Sie können größere Modelle einsetzen, denen sonst bei standardmäßiger Datenparallelität der Speicher ausgehen würde, oder Sie können mithilfe des freigewordenen GPU-Speichers die Batch-Größe erhöhen.
Die Standardtechnik für Datenparallelität repliziert die Trainingszustände GPUs in der Gruppe der Datenparallelen und führt auf der Grundlage der Operation eine Gradientenaggregation durch. `AllReduce` Die Parallelität fragmentierter Daten modifiziert das Standard-Trainingsverfahren mit verteilten, parallelen Daten, um der fragmentierten Natur der Optimierer-Zustände Rechnung zu tragen. Eine Gruppe von Rängen, über die die Zustände des Modells und des Optimierers fragmentiert werden, wird als *Fragmentierungsgruppe* bezeichnet. *Bei der Technik der Datenparallelität werden die trainierbaren Parameter eines Modells und die entsprechenden Gradienten und Optimierungszustände in der Sharding-Gruppe aufgeteilt. GPUs *
SageMaker [KI erreicht Sharded Data Parallelität durch die Implementierung von MICs, was im Blogbeitrag Near-linear scaling of gigantic-model training on behandelt wird. AWSAWS](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws) In dieser Implementierung können Sie den Fragmentierungsgrad als konfigurierbaren Parameter festlegen, der geringer sein muss als Daten-Parallelitätsgrad. Bei jedem Vorwärts- und Rückwärtslauf kombiniert MICs die Modellparameter während des gesamten Vorgangs vorübergehend neu. GPUs `AllGather` Nach dem Vorwärts- oder Rückwärtsdurchlauf jeder Layer fragmentiert MICs die Parameter erneut, um GPU-Speicher zu sparen. Während des Rückwärtsdurchlaufs reduziert MICs die Gradienten und verteilt sie gleichzeitig während des gesamten Vorgangs. GPUs `ReduceScatter` Schließlich wendet MICs die lokalen reduzierten und fragmentierten Steigungen auf die entsprechenden lokalen Parameter-Fragmente an und verwendet dabei die lokalen Fragmente der Optimierer-Zustände. Um den Kommunikationsaufwand zu verringern, ruft die SageMaker Modellparallelitätsbibliothek die nächsten Schichten im Vorwärts- oder Rückwärtsgang vorab ab und überlagert die Netzwerkkommunikation mit der Berechnung.
Der Trainingszustand des Modells wird über alle Fragmentierungsgruppen repliziert. Das heißt, bevor auf die Parameter Steigungen angewendet werden, muss zusätzlich zu der `ReduceScatter` Operation, die innerhalb der Fragmentierungsgruppe stattfindet, in allen Fragmentierungsgruppen die `AllReduce` Operation erfolgen.
Tatsächlich führt die Parallelität fragmentierter Daten zu einem Kompromiss zwischen dem Kommunikationsaufwand und der GPU-Speichereffizienz. Die Verwendung paralleler fragmentierter Daten erhöht zwar die Kommunikationskosten, der Speicherbedarf je GPU (ohne die Speichernutzung aufgrund von Aktivierungen) wird aber durch den Grad der Parallelität der fragmentierten Daten fragmentiert, so dass größere Modelle in den GPU-Cluster passen.
**Wahl des Parallelitätsgrades fragmentierter Daten**
Wenn Sie einen Wert für den Daten-Parallelitätsgrad der fragmentierten Daten wählen, muss dieser Wert den Daten-Parallelitätsgrad gleichmäßig verteilen. Wählen Sie z. B. für einen Auftrag mit 8-Wege-Datenparallelität 2, 4 oder 8 als Parallelitätsgrad für die fragmentierten Daten aus. Wir empfehlen, bei der Auswahl des Parallelitätsgrades für die fragmentierten Daten mit einer kleinen Zahl zu beginnen und diese schrittweise zu erhöhen, bis das Modell zusammen mit der gewünschten Batch-Größe in den Speicher passt.
**Wahl der Batch-Größe**
Achten Sie nach der Einrichtung der Parallelität der fragmentierten Daten darauf, dass Sie die optimale Trainingskonfiguration finden, die auf dem GPU-Cluster erfolgreich laufen kann. Um Large Language Models (LLM) zu trainieren, beginnen Sie mit der Batchgröße 1 und erhöhen Sie diese schrittweise, bis Sie den Punkt erreichen, an dem der Fehler (OOM) angezeigt wird. out-of-memory Wenn der OOM-Fehler auch bei der kleinsten Batch-Größe auftritt, wenden Sie einen höheren Parallelitätsgrad der fragmentierten Daten oder eine Kombination aus der Parallelität der fragmentierten Daten und Tensor-Parallelität an.
**Topics**
+ [So können Sie die Parallelität fragmentierter Daten auf Ihren Trainingsauftrag anwenden](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use)
+ [Referenzkonfigurationen](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use-config-sample)
+ [Parallelität fragmentierter Daten mit SMDDP-Kollektiven](#model-parallel-extended-features-pytorch-sharded-data-parallelism-smddp-collectives)
+ [Gemischtes Präzisionstraining mit Parallelität fragmentierter Daten](#model-parallel-extended-features-pytorch-sharded-data-parallelism-16bits-training)
+ [Parallelität fragmentierter Daten mit Tensor-Parallelität](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism)
+ [Tipps und Überlegungen zur Verwendung der Parallelität fragmentierter Daten](#model-parallel-extended-features-pytorch-sharded-data-parallelism-considerations)
## So können Sie die Parallelität fragmentierter Daten auf Ihren Trainingsauftrag anwenden
Um mit Sharded Data Parallelism zu beginnen, nehmen Sie die erforderlichen Änderungen an Ihrem Trainingsskript vor und richten Sie den SageMaker PyTorch Schätzer mit den Parametern ein. sharded-data-parallelism-specific Erwägen Sie auch, Referenzwerte und Beispiel-Notebooks als Ausgangspunkt zu verwenden.
### Passen Sie Ihr Trainingsskript an PyTorch
Folgen Sie den Anweisungen unter [Schritt 1: Ein PyTorch Trainingsskript ändern](model-parallel-customize-training-script-pt.md), um die Modell- und Optimizer-Objekte mit den `smdistributed.modelparallel.torch` Wrappern der `torch.nn.parallel` Module und zu verbinden. `torch.distributed`
**(Optional) Zusätzliche Änderung zur Registrierung externer Modellparameter**
Wenn Ihr Modell mit `torch.nn.Module` erstellt wurde und Parameter verwendet, die innerhalb der Modulklasse nicht definiert sind, sollten Sie sie manuell im Modul registrieren, damit SMP die vollständigen Parameter erfassen kann, während . Verwenden Sie `smp.register_parameter(module, parameter)`, um Parameter für ein Modul zu registrieren.
```
class Module(torch.nn.Module):
def __init__(self, *args):
super().__init__(self, *args)
self.layer1 = Layer1()
self.layer2 = Layer2()
smp.register_parameter(self, self.layer1.weight)
def forward(self, input):
x = self.layer1(input)
# self.layer1.weight is required by self.layer2.forward
y = self.layer2(x, self.layer1.weight)
return y
```
### Richten Sie den Schätzer ein SageMaker PyTorch
Fügen Sie bei der Konfiguration eines SageMaker PyTorch Schätzers die Parameter für die Parallelität von Sharded Data hinzu. [Schritt 2: Starten Sie einen Trainingsjob mit dem SageMaker Python-SDK](model-parallel-sm-sdk.md)
Um die Sharded-Datenparallelität zu aktivieren, fügen Sie den Parameter zum Estimator hinzu. `sharded_data_parallel_degree` SageMaker PyTorch Dieser Parameter gibt die Zahl an, GPUs über die der Trainingsstatus aufgeteilt wird. Der Wert für `sharded_data_parallel_degree` muss eine Ganzzahl zwischen eins und dem Daten-Parallelitätsgrad sein und muss den Daten-Parallelitätsgrad gleichmäßig verteilen. Beachten Sie, dass die Bibliothek automatisch die Anzahl und GPUs somit den Grad der Datenparallelität erkennt. Für die Konfiguration der Parallelität der fragmentierten Daten stehen die folgenden zusätzlichen Parameter zur Verfügung.
+ `"sdp_reduce_bucket_size"`*(int, Standard: 5e8)* — Gibt die Größe von [PyTorch DDP-Gradienten-Buckets](https://pytorch.org/docs/stable/notes/ddp.html#internal-design) als Anzahl von Elementen mit dem Standard-Dtype an.
+ `"sdp_param_persistence_threshold"`*(int, Standard: 1e6)* – Gibt die Größe eines Parametertensors als Anzahl von Elementen an, die auf jeder GPU bestehen bleiben können. Sharded Data Parallelism teilt jeden Parametertensor auf eine Datenparallelgruppe auf GPUs . Wenn die Anzahl der Elemente im Parametertensor kleiner als dieser Schwellenwert ist, wird der Parametertensor nicht aufgeteilt. Dies trägt dazu bei, den Kommunikationsaufwand zu reduzieren, da der Parametertensor datenparallel repliziert wird. GPUs
+ `"sdp_max_live_parameters"`*(int, Standard: 1e9)* – Gibt die maximale Anzahl von Parametern an, die sich während des Vorwärts- und Rückwärtsdurchlaufs gleichzeitig in einem neu kombinierten Trainingszustand befinden können. Das Abrufen von Parametern mit dem `AllGather` Vorgang wird unterbrochen, wenn die Anzahl der aktiven Parameter den angegebenen Schwellenwert erreicht. Beachten Sie, dass eine Erhöhung dieses Parameters den Speicherbedarf erhöht.
+ `"sdp_hierarchical_allgather"`*(bool, Standard: True)* – Wenn dieser auf `True` gesetzt wird, wird der `AllGather` Vorgang hierarchisch ausgeführt: Er wird zuerst innerhalb jedes Knotens und dann knotenübergreifend ausgeführt. Bei verteilten Trainingsaufträgen mit mehreren Knoten wird die hierarchische `AllGather` Operation automatisch aktiviert.
+ `"sdp_gradient_clipping"`*(Gleitkomma, Standard: 1.0)* – Gibt einen Schwellenwert für die Gradientenbeschneidung der L2-Norm der Steigungen an, bevor sie durch die Modellparameter rückwärts verteilt werden. Wenn die Parallelität fragmentierter Daten aktiviert ist, ist auch die Gradientenbeschneidung aktiviert. Der Standardschwellenwert ist `1.0`. Passen Sie diesen Parameter an, wenn das Problem mit explodierenden Steigungen auftritt.
Der folgende Code zeigt ein Beispiel für die Konfiguration der Parallelität fragmentierter Daten.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled": True,
"parameters": {
# "pipeline_parallel_degree": 1, # Optional, default is 1
# "tensor_parallel_degree": 1, # Optional, default is 1
"ddp": True,
# parameters for sharded data parallelism
"sharded_data_parallel_degree": 2, # Add this to activate sharded data parallelism
"sdp_reduce_bucket_size": int(5e8), # Optional
"sdp_param_persistence_threshold": int(1e6), # Optional
"sdp_max_live_parameters": int(1e9), # Optional
"sdp_hierarchical_allgather": True, # Optional
"sdp_gradient_clipping": 1.0 # Optional
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
smp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.p3.16xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-job"
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Referenzkonfigurationen
Das SageMaker verteilte Schulungsteam stellt die folgenden Referenzkonfigurationen zur Verfügung, die Sie als Ausgangspunkt verwenden können. Sie können von den folgenden Konfigurationen extrapolieren, um zu experimentieren und die GPU-Speichernutzung für Ihre Modellkonfiguration abzuschätzen.
Parallelität fragmentierter Daten mit SMDDP-Kollektiven
| Modell/die Anzahl der Parameter | Num. Instances | Instance-Typ | Länge der Reihenfolge | Globale Batch-Größe | Mini-Batch-Größe | Parallelitätsgrad der fragmentierten Daten |
| --- | --- | --- | --- | --- | --- | --- |
| GPT-NEOX-20B | 2 | ml.p4d.24xlarge | 2048 | 64 | 4 | 16 |
| GPT-NEOX-20B | 8 | ml.p4d.24xlarge | 2048 | 768 | 12 | 32 |
Wenn Sie z. B. die Länge der Reihenfolge für ein Modell mit 20 Milliarden Parametern oder die Größe des Modells auf 65 Milliarden Parameter erhöhen, müssen Sie zunächst versuchen, die Batch-Größe zu reduzieren. Wenn das Modell dann immer noch nicht in die kleinste Batch-Größe (die Batch-Größe 1) passt, versuchen Sie, den Parallelitätsgrad des Modell zu erhöhen.
Parallelität fragmentierter Daten mit Tensor-Parallelität und NCCL-Kollektiven
| Modell/die Anzahl der Parameter | Num. Instances | Instance-Typ | Länge der Reihenfolge | Globale Batch-Größe | Mini-Batch-Größe | Parallelitätsgrad der fragmentierten Daten | Tensor-Parallelgrad | Aktivierung, Entladung |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| GPT-NEOX-65B | 64 | ml.p4d.24xlarge | 2048 | 512 | 8 | 16 | 8 | Y |
| GPT-NEOX-65B | 64 | ml.p4d.24xlarge | 4096 | 512 | 2 | 64 | 2 | Y |
Die kombinierte Verwendung von Datenparallelität und Tensorparallelität ist nützlich, wenn Sie ein großes Sprachmodell (LLM) in einen großen Cluster einpassen und gleichzeitig Textdaten mit einer längeren Sequenzlänge verwenden möchten, was zu einer geringeren Batchgröße führt, und folglich die GPU-Speicherauslastung für das Training mit längeren Textsequenzen bewältigen möchten. LLMs Weitere Informationen hierzu finden Sie unter [Parallelität fragmentierter Daten mit Tensor-Parallelität](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism).
Fallstudien, Benchmarks und weitere Konfigurationsbeispiele finden Sie im Blogbeitrag [Neue Leistungsverbesserungen in der Amazon SageMaker AI-Modellparallelbibliothek](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/).
## Parallelität fragmentierter Daten mit SMDDP-Kollektiven
Die SageMaker Datenparallelitätsbibliothek bietet kollektive Kommunikationsprimitive (SMDDP-Kollektive), die für die Infrastruktur optimiert sind. AWS Die Optimierung wird durch die Annahme eines all-to-all-type Kommunikationsmusters mithilfe des [Elastic Fabric Adapter (EFA) erreicht, was zu einem](https://aws.amazon.com/hpc/efa/) hohen Durchsatz und weniger latenzempfindlichen Kollektiven führt, die kommunikationsbezogene Verarbeitung auf die CPU auslagert und GPU-Zyklen für Berechnungen freigibt. In großen Clustern können SMDDP Kollektive die Leistung verteilter Trainings im Vergleich zu NCCL um bis zu 40 % verbessern. Fallstudien und Benchmark-Ergebnisse finden Sie im Blog [Neue Leistungsverbesserungen in der Amazon SageMaker AI-Modellparallelismus-Bibliothek](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/).
**Anmerkung**
Sharded Data Parallelism mit SMDDP Collectives ist in der SageMaker Modellparallelismus-Bibliothek v1.13.0 und höher sowie in der Datenparallelismus-Bibliothek v1.6.0 und höher verfügbar. SageMaker Weitere Informationen finden Sie unter So verwenden Sie Sharded Data [Supported configurations](#sharded-data-parallelism-smddp-collectives-supported-config) Parallelism mit SMDDP Kollektive.
Bei der Parallelität fragmentierter Daten, einer häufig verwendeten Technik für groß angelegtes verteiltes Training, wird das `AllGather` Kollektiv verwendet, um die Sharded-Layer-Parameter für Vorwärts- und Rückwärtspassberechnungen parallel zur GPU-Berechnung zu rekonstruieren. Bei großen Modellen ist eine effiziente Ausführung des `AllGather` Vorgangs entscheidend, um GPU-Engpässe und eine Verlangsamung der Trainingsgeschwindigkeit zu vermeiden. Wenn die Parallelität fragmentierter Daten aktiviert ist, wird SMDDP Kollektive in diese leistungskritischen `AllGather`-Kollektive fragmentiert, wodurch der Trainingsdurchsatz verbessert wird.
**Trainieren Sie mit SMDDP Kollektive**
Wenn in Ihrem Trainingsauftrag die Parallelität fragmentierter Daten aktiviert ist und die Anfrageen erfüllt sind[Supported configurations](#sharded-data-parallelism-smddp-collectives-supported-config), werden SMDDP Kollektive automatisch aktiviert. Intern optimieren SMDDP Collectives das Kollektiv so, dass es in der Infrastruktur performant ist, und greifen für alle anderen `AllGather` Kollektive auf NCCL zurück. AWS Darüber hinaus verwenden bei nicht unterstützten Konfigurationen alle Kollektive, einschließlich `AllGather`, automatisch das NCCL-Backend.
Seit Version 1.13.0 der SageMaker Modellparallelismus-Bibliothek wird der Parameter zu den Optionen hinzugefügt. `"ddp_dist_backend"` `modelparallel` Der Standardwert für diesen Konfigurationsparameter ist `"auto"`. Wann immer möglich verwendet dieser SMDDP-Kollektive. Andernfalls wird auf NCCL zurückgegriffen. Um zu erzwingen, dass die Bibliothek immer NCCL verwendet, geben Sie `"nccl"` im `"ddp_dist_backend"` Konfigurationsparameter an.
Das folgende Codebeispiel zeigt, wie ein PyTorch Schätzer unter Verwendung der Sharded-Datenparallelität mit dem `"ddp_dist_backend"` Parameter eingerichtet wird, der `"auto"` standardmäßig auf gesetzt ist und daher optional hinzugefügt werden kann.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled":True,
"parameters": {
"partitions": 1,
"ddp": True,
"sharded_data_parallel_degree": 64
"bf16": True,
"ddp_dist_backend": "auto" # Specify "nccl" to force to use NCCL.
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
smd_mp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=8,
instance_type='ml.p4d.24xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
**Unterstützte Konfigurationen**
Der `AllGather` Vorgang mit SMDDP-Kollektiven wird in Trainingsaufträgen aktiviert, wenn alle der folgenden Konfigurationsanforderungen erfüllt sind.
+ Der Parallelitätsgrad fragmentierter Daten ist größer als 1
+ `Instance_count` größer als 1
+ `Instance_type` gleich `ml.p4d.24xlarge`
+ SageMaker Trainingscontainer für v1.12.1 oder höher PyTorch
+ Die SageMaker Datenparallelitätsbibliothek v1.6.0 oder höher
+ Die SageMaker Modellparallelismus-Bibliothek v1.13.0 oder höher
**Leistungs- und Speicheroptimierung**
SMDDP-Kollektive nutzen zusätzlichen GPU-Speicher. Es gibt zwei Umgebungsvariablen zur Konfiguration der GPU-Speichernutzung in Abhängigkeit von verschiedenen Anwendungsfällen für das Modelltraining.
+ `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` – Während des SMDDP `AllGather`-Vorgangs wird der `AllGather` Eingabepuffer für die Kommunikation zwischen den Knoten in einen temporären Puffer kopiert. Die `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` Variable steuert die Größe dieses temporären Puffers (in Byte). Wenn die Größe des temporären Puffers kleiner ist als die Größe des `AllGather` Eingabepuffers, greift das `AllGather` Kollektiv auf NCCL zurück.
+ Standardwert: 16 \$1 1024 \$1 1024 (16 MB)
+ Zulässige Werte: alle Vielfachen von 8192
+ `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` – Die `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` Variable dient zur Anpassung der Größe des temporären Puffers (in Byte) für Daten, die bei der Kommunikation zwischen Knoten gesammelt wurden. Wenn die Größe dieses temporären Puffers kleiner ist als `1/8 * sharded_data_parallel_degree * AllGather input size`, greift das `AllGather` Kollektiv auf NCCL zurück.
+ Standardwert: 128 \$1 1024 \$1 1024 (128 MB)
+ Zulässige Werte: alle Vielfachen von 8192
**Optimierungsleitlinien zu den Variablen der Puffergröße**
Die Standardwerte für die Umgebungsvariablen sollten für die meisten Anwendungsfälle gut funktionieren. Wir empfehlen, diese Variablen nur zu optimieren, wenn beim Training der Fehler out-of-memory (OOM) auftritt.
In der folgenden Liste werden Tipps für die Optimierung beschrieben, um den GPU-Speicherbedarf von SMDDP-Kollektiven zu reduzieren und dabei den daraus resultierenden Leistungsgewinn beizubehalten.
+ Optimierung von `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES`
+ Die Größe des `AllGather` Eingabepuffers ist bei kleineren Modellen kleiner. Daher kann die erforderliche Größe für `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` für Modelle mit weniger Parametern geringer sein.
+ Die Größe des `AllGather` Eingabepuffers nimmt mit `sharded_data_parallel_degree` zunehmender Größe ab, da das Modell stärker GPUs fragmentiert wird. Daher kann die erforderliche Größe für `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` bei Trainingsaufträgen mit großen Werten für `sharded_data_parallel_degree` kleiner sein.
+ Optimierung von `SMDDP_AG_SORT_BUFFER_SIZE_BYTES`
+ Bei Modellen mit weniger Parametern ist die Datenmenge, die bei der Kommunikation zwischen den Knoten gesammelt wird, geringer. Daher kann die erforderliche Größe für `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` für solche Modelle mit weniger Parametern geringer sein.
Manche Kollektive greifen ggf. auf NCCL zurück. Daher erzielen Sie durch die optimierten SMDDP-Kollektive ggf. nicht die erwartete Leistungssteigerung. Wenn zusätzlicher GPU-Speicher zur Verfügung steht, können Sie erwägen, die Werte von `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` und `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` zu erhöhen, um von der Leistungssteigerung zu profitieren.
Der folgende Code zeigt, wie Sie die Umgebungsvariablen konfigurieren können, indem Sie sie an `mpi_options` den Verteilungsparameter für den PyTorch Schätzer anhängen.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
.... # All modelparallel configuration options go here
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
# Use the following two lines to tune values of the environment variables for buffer
mpioptions += " -x SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES=8192"
mpioptions += " -x SMDDP_AG_SORT_BUFFER_SIZE_BYTES=8192"
smd_mp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=8,
instance_type='ml.p4d.24xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-demo-with-tuning",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Gemischtes Präzisionstraining mit Parallelität fragmentierter Daten
Um GPU-Speicher mit halbpräzisen Fließkommazahlen und Shard-Datenparallelität weiter zu sparen, können Sie das 16-Bit-Fließkommaformat (FP16) oder das [Brain-Fließkommaformat](https://en.wikichip.org/wiki/brain_floating-point_format) () aktivieren, indem Sie der verteilten BF16 Trainingskonfiguration einen zusätzlichen Parameter hinzufügen.
**Anmerkung**
Das Training mit gemischter Präzision und Sharded-Datenparallelität ist in der Modellparallelismus-Bibliothek v1.11.0 und höher verfügbar. SageMaker
**Für FP16 das Training mit Sharded Data Parallelism**
Um ein FP16 Training mit Sharded Data Parallelism durchzuführen, fügen Sie es dem Konfigurationswörterbuch hinzu. `"fp16": True"` `smp_options` In Ihrem Trainingsskript können Sie mit Hilfe des `smp.DistributedOptimizer` Moduls zwischen den statischen und dynamischen Verlustskalierungsoptionen wählen. Weitere Informationen finden Sie unter [FP16 Training mit Modellparallelität](model-parallel-extended-features-pytorch-fp16.md).
```
smp_options = {
"enabled": True,
"parameters": {
"ddp": True,
"sharded_data_parallel_degree": 2,
"fp16": True
}
}
```
**Für das BF16 Training mit Sharded Data Parallelism**
Die SageMaker KI-Funktion zur Parallelität von Sharded Data unterstützt das Training nach Datentypen. BF16 Der BF16 Datentyp verwendet 8 Bit, um den Exponenten einer Fließkommazahl darzustellen, während der FP16 Datentyp 5 Bit verwendet. Wenn die 8 Bit für den Exponenten beibehalten werden, kann dieselbe Darstellung des Exponenten einer 32-Bit-Gleitkommazahl () FP32 mit einfacher Genauigkeit beibehalten werden. Dadurch wird die Konvertierung zwischen FP32 und BF16 einfacher und es ist deutlich weniger anfällig für Überlauf- und Unterlaufprobleme, die häufig beim Training auftreten, insbesondere beim FP16 Training größerer Modelle. Beide Datentypen verwenden zwar insgesamt 16 Bit, aber dieser vergrößerte Darstellungsbereich für den Exponenten im BF16 Format geht zu Lasten einer geringeren Genauigkeit. Beim Training großer Modelle wird diese geringere Genauigkeit oft als akzeptabler Kompromiss für den Bereich und die Stabilität des Trainings angesehen.
**Anmerkung**
Derzeit funktioniert das BF16 Training nur, wenn die Shard-Datenparallelität aktiviert ist.
Um ein BF16 Training mit Sharded-Datenparallelität durchzuführen, fügen Sie es dem Konfigurationswörterbuch hinzu. `"bf16": True` `smp_options`
```
smp_options = {
"enabled": True,
"parameters": {
"ddp": True,
"sharded_data_parallel_degree": 2,
"bf16": True
}
}
```
## Parallelität fragmentierter Daten mit Tensor-Parallelität
Wenn Sie die Parallelität fragmentierter Daten nutzen und außerdem die globale Batch-Größe reduzieren müssen, sollten Sie die Verwendung von [Tensor-Parallelität](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-tensor-parallelism.html) mit der Parallelität fragmentierter Daten in Betracht ziehen. Wenn Sie ein großes Modell mit Parallelität fragmentierter Daten auf einem sehr großen Datenverarbeitungscluster (typischerweise 128 Knoten oder mehr) trainieren, führt selbst eine kleine Batch-Größe pro GPU zu einer sehr großen globalen Batch-Größe. Dies kann zu Konvergenzproblemen oder Problemen mit geringer Datenverarbeitungsleistung führen. Die Batch-Größe pro GPU kann manchmal mit der Parallelität fragmentierter Daten allein nicht reduziert werden, wenn ein einzelnes Batch bereits sehr umfangreich ist und nicht weiter reduziert werden kann. In solchen Fällen trägt die Verwendung der Parallelität fragmentierter Daten in Kombination mit Tensor-Parallelität dazu bei, die globale Batch-Größe zu reduzieren.
Die Wahl des optimalen Grades für die Parallelität fragmentierter Daten und die Tensor-Parallelität hängt von der Größe des Modells, dem Instance-Typ und von der globalen Batch-Größe ab, die angemessen ist, damit das Modell konvergieren kann. Wir empfehlen, dass Sie mit einem niedrigen Tensorparallelgrad beginnen, um die globale Batchgröße an den Rechencluster anzupassen, um out-of-memory CUDA-Fehler zu beheben und die beste Leistung zu erzielen. In den folgenden beiden Beispielfällen erfahren Sie, wie die Kombination aus Tensorparallelität und Sharded-Datenparallelität Ihnen hilft, die globale Batchgröße durch Gruppierung GPUs nach Modellparallelität anzupassen, was zu einer geringeren Anzahl von Modellreplikaten und einer kleineren globalen Batchgröße führt.
**Anmerkung**
Diese Funktion ist in der Modellparallelismus-Bibliothek v1.15 verfügbar und unterstützt Version 1.13.1. SageMaker PyTorch
**Anmerkung**
Diese Funktion steht für die durch die Tensor-Parallelitätsfunktionalität der Bibliothek unterstützten Modelle zur Verfügung. Eine Liste der unterstützten Modelle finden Sie unter [Support für Hugging Face Transformator-Modelle](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-hugging-face.html). Beachten Sie auch, dass Sie bei der Änderung Ihres Trainingsskripts `tensor_parallelism=True` an das `smp.model_creation` Argument übergehen müssen. *Weitere Informationen finden Sie im Trainingsskript [https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L793](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L793)im AI Examples Repository. SageMaker GitHub *
### Beispiel 1
Nehmen wir an, wir möchten ein Modell über einen Cluster von 1536 GPUs (192 Knoten mit jeweils 8 Knoten) trainieren und GPUs dabei den Grad der Sharded-Datenparallelität auf 32 (`sharded_data_parallel_degree=32`) und die Batchgröße pro GPU auf 1 setzen, wobei jeder Stapel eine Sequenzlänge von 4096 Token hat. In diesem Fall gibt es 1536 Modellrepliken, die globale Batch-Größe beträgt 1536 und jedes globale Batch enthält etwa 6 Millionen Token.
```
(1536 GPUs) * (1 batch per GPU) = (1536 global batches)
(1536 batches) * (4096 tokens per batch) = (6,291,456 tokens)
```
Durch Hinzufügen von Tensor-Parallelität kann die globale Batch-Größe verringert werden. Ein Konfigurationsbeispiel kann darin bestehen, den Grad der Tensor-Parallelität auf 8 und die Batch-Größe pro GPU auf 4 festzulegen. Dies bildet 192 parallel Tensorgruppen oder 192 Modellreplikate, wobei jedes Modellreplikat auf 8 verteilt ist. GPUs Die Batch-Größe von 4 ist die Menge an Trainingsdaten je Iteration und Tensorparallelgruppe, d. h. jede Modellreplik verbraucht 4 Batches pro Iteration. In diesem Fall beträgt die globale Batch-Größe 768, und jedes globale Batch enthält etwa 3 Millionen Token. Daher wird die globale Batch-Größe im Vergleich zum vorangehenden Fall um die Hälfte reduziert, wo nur die Parallelität fragmentierter Daten verwendet wurde.
```
(1536 GPUs) / (8 tensor parallel degree) = (192 tensor parallelism groups)
(192 tensor parallelism groups) * (4 batches per tensor parallelism group) = (768 global batches)
(768 batches) * (4096 tokens per batch) = (3,145,728 tokens)
```
### Beispiel 2
Wenn sowohl die Parallelität fragmentierter Daten als auch die Tensor-Parallelität aktiviert sind, wendet die Bibliothek zunächst die Tensor-Parallelität an und fragmentiert das Modell über diese Dimension. Für jeden Tensorparallelrang wird die Datenparallelität gem. `sharded_data_parallel_degree` angewendet.
Nehmen wir zum Beispiel an, dass wir 32 GPUs mit einem Tensorparallelgrad von 4 setzen möchten (wobei Gruppen von 4 gebildet werden GPUs), einem parallel Grad für zerteilte Daten von 4, was zu einem Replikationsgrad von 2 führt. Durch die Zuweisung werden anhand des Grades der Tensor-Parallelität acht GPU-Gruppen wie folgt erstellt: `(0,1,2,3)`, `(4,5,6,7)`, `(8,9,10,11)`, `(12,13,14,15)`, `(16,17,18,19)`, `(20,21,22,23)`, `(24,25,26,27)`, `(28,29,30,31)`. Das heißt, vier GPUs bilden eine tensorparallele Gruppe. In diesem Fall wäre die reduzierte Datenparallelgruppe für den 0. Rang GPUs der tensorparallelen Gruppen. `(0,4,8,12,16,20,24,28)` Die reduzierte Datenparallelgruppe wird auf der Grundlage des Parallelgrads von 4 aufgeteilt, was zu zwei Replikationsgruppen für Datenparallelität führt. GPUs`(0,4,8,12)`bilden eine Sharding-Gruppe, die zusammen eine vollständige Kopie aller Parameter für den 0ten tensorparallelen Rang enthält, und GPUs `(16,20,24,28)` bilden eine weitere solche Gruppe. Auch andere Tensorparallelränge haben ähnliche Fragmentierungs- und Replikationsgruppen.
![\[Abbildung 1: Tensorparallelitätsgruppen.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/model-parallel/sdp_tp_group_tp.jpg)
Abbildung 1: Tensorparallelitätsgruppen für (Knoten, Parallelitätsgrad der fragmentierten Daten, Tensorparallelgrad) = (4, 4, 4), wobei jedes Rechteck eine GPU mit Indizes von 0 bis 31 darstellt. Sie GPUs bilden Tensorparallelitätsgruppen von TPG zu TPG. 0 7 Replikationsgruppen sind (\$1TPG0, TPG4\$1, \$1TPG1, TPG5\$1, \$1TPG2, TPG6\$1 und \$1TPG3, TPG7\$1); jedes Replikationsgruppenpaar hat dieselbe Farbe, ist aber unterschiedlich gefüllt.
![\[Abbildung 2: Parallelitätsgruppen fragmentierter Daten.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/model-parallel/sdp_tp_group_sdp.jpg)
Abbildung 2: Parallelitätsgruppen fragmentierter Daten für (Knoten, Parallelitätsgrad der fragmentierten Daten, Tensorparallelgrad) = (4, 4, 4), wobei jedes Rechteck eine GPU mit Indizes von 0 bis 31 darstellt. Das GPUs Formular gruppiert Datenparallelitätsgruppen von SDPG bis SDPG. 0 7 Replikationsgruppen sind (\$1SDPG0, SDPG4\$1, \$1SDPG1, SDPG5\$1, \$1SDPG2, SDPG6\$1 und \$1SDPG3, SDPG7\$1). Jedes Replikationsgruppenpaar hat dieselbe Farbe, ist aber unterschiedlich gefüllt.
### So aktivieren Sie die Parallelität fragmentierter Daten mit Tensor-Parallelität
Um Sharded Data Parallelism mit Tensor Parallelism zu verwenden, müssen Sie sowohl als auch `tensor_parallel_degree` in der Konfiguration angeben, während Sie ein Objekt der `sharded_data_parallel_degree` Estimator-Klasse erstellen. `distribution` SageMaker PyTorch
Und Sie müssen auch `prescaled_batch` aktivieren. Das bedeutet, dass nicht jede GPU ihren eigenen Daten-Batch liest, sondern jede parallel Tensorparallelgruppe gemeinsam ein kombiniertes Batch der ausgewählten Batch-Größe liest. Anstatt den Datensatz in Teile zu unterteilen, die der Anzahl von GPUs (oder der parallel Datengröße`smp.dp_size()`) entsprechen, wird er in Teile aufgeteilt, die der Anzahl von GPUs geteilt durch `tensor_parallel_degree` (auch als reduzierte Datenparallelgröße bezeichnet`smp.rdp_size()`) entsprechen. *Weitere Informationen zu Prescaled Batch finden Sie unter [Prescaled Batch](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#prescaled-batch) in der SageMaker Python SDK-Dokumentation.* *Siehe auch das Beispiel-Trainingsskript [https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L164](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L164)für GPT-2 im AI Examples Repository. SageMaker GitHub *
Der folgende Codeausschnitt zeigt ein Beispiel für die Erstellung eines PyTorch Schätzobjekts auf der Grundlage des oben genannten Szenarios in. [Beispiel 2](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism-ex2)
```
mpi_options = "-verbose --mca orte_base_help_aggregate 0 "
smp_parameters = {
"ddp": True,
"fp16": True,
"prescaled_batch": True,
"sharded_data_parallel_degree": 4,
"tensor_parallel_degree": 4
}
pytorch_estimator = PyTorch(
entry_point="your_training_script.py",
role=role,
instance_type="ml.p4d.24xlarge",
volume_size=200,
instance_count=4,
sagemaker_session=sagemaker_session,
py_version="py3",
framework_version="1.13.1",
distribution={
"smdistributed": {
"modelparallel": {
"enabled": True,
"parameters": smp_parameters,
}
},
"mpi": {
"enabled": True,
"processes_per_host": 8,
"custom_mpi_options": mpi_options,
},
},
source_dir="source_directory_of_your_code",
output_path=s3_output_location
)
```
## Tipps und Überlegungen zur Verwendung der Parallelität fragmentierter Daten
Beachten Sie Folgendes, wenn Sie die Sharded-Datenparallelität der SageMaker Modellparallelismus-Bibliothek verwenden.
+ Die Parallelität von Sharded Data ist mit Training kompatibel. FP16 Informationen zur Durchführung von FP16 Schulungen finden Sie im Abschnitt. [FP16 Training mit Modellparallelität](model-parallel-extended-features-pytorch-fp16.md)
+ Die Parallelität fragmentierter Daten ist mit der Tensor-Parallelität kompatibel. Sie müssen ggf. die folgenden Punkte berücksichtigen, wenn Sie die Parallelität fragmentierter Daten mit Tensor-Parallelität verwenden möchten.
+ Bei Verwendung der Parallelität fragmentierter Daten mit der Tensor-Parallelität werden auch die Einbettungs-Layers automatisch über die Tensorparallelgruppe verteilt. Mit anderen Worten, der `distribute_embedding` Parameter wird automatisch auf `True` gesetzt. Weitere Informationen zur Tensor-Parallelität finden Sie unter [Tensor-Parallelität](model-parallel-extended-features-pytorch-tensor-parallelism.md).
+ Beachten Sie, dass die Parallelität fragmentierter Daten und die Tensor-Parallelität derzeit die NCCL-Kollektive als Backend der verteilten Trainingsstrategie verwendet.
Weitere Informationen finden Sie im [Parallelität fragmentierter Daten mit Tensor-Parallelität](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism) Abschnitt.
+ Die Parallelität fragmentierter Daten ist derzeit nicht mit der [Pipeline-Parallelität](model-parallel-intro.md#model-parallel-intro-pp) oder der [Optimierer-Zustands-Fragmentierung](model-parallel-extended-features-pytorch-optimizer-state-sharding.md) kompatibel. Um die Parallelität fragmentierter Daten zu aktivieren, deaktivieren Sie die Optimierer-Zustands-Fragmentierung und setzen Sie den Grad der Pipeline-Parallelität auf 1.
+ Die Funktionen zur [Aktivierung von Prüfpunkten](model-parallel-extended-features-pytorch-activation-checkpointing.md) und zum [Entladen der Aktivierung](model-parallel-extended-features-pytorch-activation-offloading.md) sind mit der Parallelität fragmentierter Daten kompatibel.
+ Um die Parallelität fragmentierter Daten mit der Steigungsakkumulation zu verwenden, setzen Sie das `backward_passes_per_step` Argument auf die Anzahl der Akkumulationsschritte und wickeln Sie dabei Ihr Modell in das [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel) Modul. Dadurch wird sichergestellt, dass die `AllReduce` Steigungsoperation zwischen den Modellreplikationsgruppen (Fragmentierungsgruppen) an der Grenze der Steigungsakkumulation stattfindet.
+ Sie können Ihre mit Sharded Data Parallelism trainierten Modelle überprüfen, indem Sie die Checkpoint-Funktion der Bibliothek verwenden, und. APIs `smp.save_checkpoint` `smp.resume_from_checkpoint` Weitere Informationen finden Sie unter [Checkpointing für ein verteiltes PyTorch Modell (für die SageMaker Modellparallelismus-Bibliothek v1.10.0 und höher)](distributed-model-parallel-checkpointing-and-finetuning.md#model-parallel-extended-features-pytorch-checkpoint).
+ Das Verhalten des [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization) Konfigurationsparameters ändert sich bei Parallelität fragmentierter Daten. Wenn diese beiden Funktionen gleichzeitig aktiviert sind, werden die Parameter sofort nach der Modellerstellung fragmentiert initialisiert, anstatt die Parameterinitialisierung zu verzögern, damit jeder Rang seine eigenen fragmentierten Parameter initialisiert und speichert.
+ Wenn die Parallelität fragmentierter Daten aktiviert ist, beschneidet die Bibliothek bei der Ausführung des `optimizer.step()` Aufrufs intern die Steigungen. Sie müssen kein Hilfsprogramm APIs für Gradientenausschnitte verwenden, wie z. [https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html](https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html) Um den Schwellenwert für das Beschneiden von Farbverläufen anzupassen, können Sie ihn über den `sdp_gradient_clipping` Parameter für die Konfiguration der Verteilungsparameter festlegen, wenn Sie den SageMaker PyTorch Schätzer erstellen, wie im Abschnitt gezeigt. [So können Sie die Parallelität fragmentierter Daten auf Ihren Trainingsauftrag anwenden](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use)
# Modell-Pipelining
Eines der Hauptmerkmale der SageMaker Modellparallelitätsbibliothek ist die *Pipeline-Parallelität*. Sie bestimmt die Reihenfolge, in der Berechnungen durchgeführt und Daten während des Modelltrainings geräteübergreifend verarbeitet werden. Pipelining ist eine Technik, um eine echte Parallelisierung der Modellparallelität zu erreichen, indem die GPUs Berechnungen gleichzeitig auf verschiedenen Datenproben durchgeführt werden, und um den Leistungsverlust aufgrund sequentieller Berechnungen zu überwinden. Wenn Sie Pipeline-Parallelität verwenden, wird der Trainingsauftrag per Pipeline über Mikro-Batches ausgeführt, um die GPU-Auslastung zu maximieren.
**Anmerkung**
Pipeline-Parallelität, auch Modellpartitionierung genannt, ist sowohl für als auch verfügbar. PyTorch TensorFlow Die unterstützten Versionen der Frameworks finden Sie unter [Unterstützte Frameworks und AWS-Regionen](distributed-model-parallel-support.md).
## Zeitplan für die Pipeline-Ausführung
Pipelining basiert auf der Aufteilung eines Mini-Batches in Mikrobatches, die in die Trainingspipeline eingespeist werden one-by-one und einem durch die Bibliothekslaufzeit definierten Ausführungsplan folgen. Ein *Mikro-Batch* ist eine kleinere Teilmenge eines bestimmten Trainings-Minibatches. Der Pipeline-Zeitplan bestimmt für jedes Zeitfenster, welcher Mikro-Batch von welchem Gerät ausgeführt wird.
Je nach Pipeline-Zeitplan und Modellpartition `i` kann die GPU beispielsweise Berechnungen (vorwärts oder rückwärts) für Microbatch durchführen, `b` während die GPU Berechnungen für Microbatch `i+1` durchführt, wodurch beide gleichzeitig aktiv bleiben`b+1`. GPUs Während eines einzelnen Vorwärts- oder Rückwärtsdurchlaufs kann bei der Ausführung eines einzelnen Mikro-Batchs je nach Partitionierungsentscheidung dasselbe Gerät mehrmals aufgerufen werden. Eine Operation, die sich am Anfang des Modells befindet, kann z. B. auf demselben Gerät ausgeführt werden wie eine Operation am Ende des Modells, während die Operationen dazwischen auf verschiedenen Geräten ausgeführt werden. Das bedeutet, dass dieses Gerät zweimal aufgerufen wird.
Die Bibliothek bietet zwei verschiedene Pipeline-Zeitpläne, *Simple* und *Interleaved*, die mit dem `pipeline` Parameter im SageMaker Python-SDK konfiguriert werden können. In den meisten Fällen kann mit Interleaved-Pipelines eine bessere Leistung erzielt werden, wenn sie effizienter genutzt wird. GPUs
### Überlappende Pipeline
In einer überlappenden Pipeline wird der Rückwärtsausführung der Mikro-Batches nach Möglichkeit Priorität eingeräumt. Dies erlaubt eine schnellere Freigabe des für Aktivierungen verwendeten Speichers. So wird der Speicher effizienter genutzt. Es ermöglicht auch, die Anzahl der Mikrobatches höher zu skalieren und so die Leerlaufzeit von zu reduzieren. GPUs Im Steady-State wechselt jedes Gerät zwischen Vorwärts- und Rückwärtsläufen hin und her. Das bedeutet, dass der Rücklauf eines Mikro-Batches ausgeführt werden kann, bevor der Vorwärtsdurchlauf eines anderen Mikro-Batches abgeschlossen ist.
![\[Beispiel für einen Ausführungsplan für die verschachtelte Pipeline über 2. GPUs\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-execution.png)
Die vorherige Abbildung zeigt ein Beispiel für einen Ausführungsplan für die Interleaved-Pipeline über 2. GPUs In der Abbildung steht F0 für den Vorwärtsdurchlauf für Mikro-Batch 0 und B1 für den Rückwärtsdurchgang für Mikro-Batch 1. **Update** stellt das Optimizer-Update der Parameter dar. GPU0 priorisiert immer Rückwärtsdurchläufe, wann immer dies möglich ist (führt beispielsweise B0 vor F2 aus), wodurch der Speicher gelöscht werden kann, der für frühere Aktivierungen verwendet wurde.
### Einfache Pipeline
Eine einfache Pipeline beendet dagegen die Ausführung des Vorwärtsdurchlaufs für jedes Mikro-Batch, bevor der Rückwärtsdurchlauf gestartet wird. Das bedeutet, dass sie nur die Phasen des Vorwärtsdurchlaufs und des Rücklaufs in sich selbst weiterleitet. Die folgende Abbildung zeigt ein Beispiel dafür, wie das funktioniert (mehr als 2). GPUs
![\[Beispiel für eine Pipeline, die den Vorwärtsdurchlauf für jedes Mikro-Batch ausführt, bevor der Rückwärtsdurchlauf gestartet wird.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/model-parallel/simple-pipeline-execution.png)
### Pipelining der Ausführung in bestimmten Frameworks
In den folgenden Abschnitten erfahren Sie mehr über die Framework-spezifischen Pipeline-Scheduling-Entscheidungen, die in SageMaker der Modellparallelitätsbibliothek für und vorgesehen sind. TensorFlow PyTorch
#### Pipeline-Ausführung mit TensorFlow
Die folgende Abbildung zeigt ein Beispiel TensorFlow für einen Graphen, der durch die Modellparallelitätsbibliothek partitioniert wurde. Dabei wird automatisiertes Modellsplitting verwendet. Wenn ein Diagramm geteilt wird, wird jeder resultierende Teilgraph B-mal repliziert (mit Ausnahme der Variablen). Dabei ist B die Anzahl der Mikro-Batches. In dieser Abbildung wird jeder Teilgraph zweimal repliziert (B=2). An jeder Eingabe eines Teilgraphen wird eine `SMPInput` Operation eingefügt und eine `SMPOutput` Operation wird an jedem Ausgang eingefügt. Diese Operationen kommunizieren mit dem Bibliotheks-Backend, um Tensoren zu und voneinander zu übertragen.
![\[Beispiel TensorFlow für einen Graphen, der durch die Modellparallelitätsbibliothek partitioniert wurde, wobei automatisiertes Modellsplitting verwendet wird.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-tf.png)
Das folgende Bild ist ein Beispiel für zwei Teilgraphen, die mit B=2 geteilt wurden. Dabei wurden Steigungsoperationen hinzugefügt. Der Gradient einer `SMPInput` Operation ist eine `SMPOutput` Operation und umgekehrt. So können die Steigungen während der Rückwärtsverteilung rückwärts laufen.
![\[Beispiel für zwei Teilgraphen, die mit B=2 geteilt wurden. Dabei wurden Steigungsoperationen hinzugefügt.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-tf.gif)
Dieses GIF zeigt ein Beispiel für einen Ausführungsplan für überlappende Pipelines mit B=2 Mikro-Batches und 2 Teilgraphen. Jedes Gerät führt nacheinander eines der replizierten Teilgraphen aus, um die GPU-Auslastung zu verbessern. Wenn B größer wird, geht der Anteil der Leerlaufzeitfenster gegen Null. Immer wenn es an der Zeit ist, Berechnungen (vorwärts oder rückwärts) für einen bestimmten replizierten Teilgraphen auszuführen, signalisiert die Pipeline-Layer den entsprechenden blauen `SMPInput` Operationen, das sie mit der Ausführung beginnen sollen.
Sobald die Steigungen aller Mikro-Batches in einem einzelnen Mini-Batch berechnet wurden, kombiniert die Bibliothek die Steigungen der einzelnen Mikro-Batches, die dann auf die Parameter angewendet werden können.
#### Pipeline-Ausführung mit PyTorch
Konzeptionell folgt das Pipelining einer ähnlichen Idee in. PyTorch Da PyTorch es sich jedoch nicht um statische Graphen handelt, verwendet die PyTorch Funktion der Modellparallelitätsbibliothek ein dynamischeres Pipelining-Paradigma.
Wie in TensorFlow, wird jeder Batch in eine Reihe von Mikrobatches aufgeteilt, die nacheinander auf jedem Gerät ausgeführt werden. Der Ausführungsplan wird jedoch über Ausführungsserver verwaltet, die auf jedem Gerät gestartet werden. Immer wenn die Ausgabe eines Submoduls, das sich auf einem anderen Gerät befindet, auf dem aktuellen Gerät gebraucht wird, wird zusammen mit den Eingangstensoren für das Submodul eine Ausführungsanfrage an den Ausführungsserver des entfernten Gerätes gesendet. Der Server führt dieses Modul dann mit den angegebenen Eingaben aus und gibt die Antwort an das aktuelle Gerät zurück.
Da sich das aktuelle Gerät während der Ausführung des Remote-Submoduls im Leerlauf befindet, wird die lokale Ausführung des aktuellen Mikro-Batches angehalten und die Bibliothekslaufzeit schaltet die Ausführung auf ein anderes Mikro-Batch um, an dem das aktuelle Gerät aktiv arbeiten kann. Die Priorisierung von Mikro-Batches wird durch den ausgewählten Pipeline-Zeitplan bestimmt. Bei einem überlappenden Pipeline-Zeitplan werden Mikro-Batches möglichst priorisiert, die sich in der Rückwärtsphase der Berechnung befinden.
# Tensor-Parallelität
*Tensor-Parallelität* ist eine Art von Modellparallelität, bei der bestimmte Modellgewichtungen, Steigungen und Optimierer-Zustände auf verschiedene Geräte aufgeteilt werden. Im Gegensatz zur Pipeline-Parallelität, bei der einzelne Gewichtungen intakt bleiben, die *Menge* der Gewichtungen jedoch fragmentiert wird, teilt die Tensor-Parallelität einzelne Gewichtungen auf. Dies beinhaltet in der Regel die verteilte Berechnung bestimmter Operationen, Module oder Layers des Modells.
Tensor-Parallelität ist dann erforderlich, wenn ein einzelner Parameter den größten Teil des GPU-Speichers beansprucht (z. B. große Einbettungstabellen mit großem Vokabular oder eine große Softmax-Layer mit einer großen Anzahl Klassen). In diesem Fall ist es ineffizient, diesen großen Tensor oder diese Operation als atomare Einheit zu behandeln und behindert die ausgeglichene Auslastung des Speichers.
Die Tensor-Parallelität ist auch für extrem große Modelle nützlich, bei denen ein reines Pipelining einfach nicht ausreicht. Bei Modellen in der Größe von GPT-3, die eine Partitionierung über Dutzende von Instances erfordern, ist ein reines Mikro-Batch-Pipelining z. B. ineffizient, da die Pipeline-Tiefe zu groß und der Overhead übermäßig groß wird.
**Anmerkung**
Die Tensorparallelität ist PyTorch in der SageMaker Modellparallelismus-Bibliothek v1.6.0 und höher verfügbar.
**Topics**
+ [So funktioniert die Tensor-Parallelität](model-parallel-extended-features-pytorch-tensor-parallelism-how-it-works.md)
+ [Führen Sie einen parallelen Trainingsjob für SageMaker verteilte Modelle mit Tensorparallelismus aus](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md)
+ [Support für Hugging Face Transformator-Modelle](model-parallel-extended-features-pytorch-hugging-face.md)
+ [Rangfolgemechanismus bei Verwendung einer Kombination aus Pipeline-Parallelität und Tensor-Parallelität](model-parallel-extended-features-pytorch-ranking-mechanism.md)
# So funktioniert die Tensor-Parallelität
Die Tensor-Parallelität findet auf der Ebene von `nn.Modules` statt. Sie partitioniert bestimmte Module im Modell über tensorparallele Ränge hinweg. Dies erfolgt zusätzlich zur bestehenden Partition der *Module*, die bei der Pipeline-Parallelität verwendet werden.
Wenn ein Modul durch Tensor-Parallelität partitioniert wird, werden seine Vorwärts- und Rückwärtsverteilung verteilt. Die Bibliothek kümmert sich um die geräteübergreifende Kommunikation, um die verteilte Ausführung dieser Module zu implementieren. Die Module werden über mehrere datenparallele Ränge partitioniert. Im Gegensatz zur herkömmlichen Verteilung von Workloads verfügt **nicht** jeder datenparallele Rang über die vollständige Modellreplizierung, wenn die Tensor-Parallelität der Bibliothek verwendet wird. Stattdessen hat jeder datenparallele Rang ggf. nur eine Partition der verteilten Module, zusätzlich zu der Gesamtheit der nicht verteilten Module.
**Beispiel:** Stellen Sie sich die Tensor-Parallelität über datenparallele Ränge hinweg vor, wobei der Daten-Parallelitätsgrad 4 und der Grad der Tensor-Parallelität 2 beträgt. Gehen Sie davon aus, dass Sie nach der Partitionierung der Menge der Module eine datenparallele Gruppe haben, die den folgenden Modulbaum enthält.
```
A
├── B
| ├── E
| ├── F
├── C
└── D
├── G
└── H
```
Gehen Sie davon aus, dass die Tensor-Parallelität für die Module B, G und H unterstützt wird. Ein mögliches Ergebnis der tensorparallelen Partition dieses Modells könnte sein:
```
dp_rank 0 (tensor parallel rank 0): A, B:0, C, D, G:0, H
dp_rank 1 (tensor parallel rank 1): A, B:1, C, D, G:1, H
dp_rank 2 (tensor parallel rank 0): A, B:0, C, D, G:0, H
dp_rank 3 (tensor parallel rank 1): A, B:1, C, D, G:1, H
```
Jede Zeile steht für die Menge der in diesem `dp_rank` gespeicherten Module, und die Notation `X:y` steht für den `y`. Bruchteil des Moduls `X`. Beachten Sie Folgendes:
1. Die Partitionierung erfolgt über Teilmengen von datenparallelen Rängen hinweg, die wir `TP_GROUP` nennen, nicht über die gesamte `DP_GROUP`, so dass die genaue Modellpartition über `dp_rank` 0 und `dp_rank` 2 und in ähnlicher Weise über `dp_rank` 1 und `dp_rank` 3 repliziert wird.
1. Die Module `E` und `F` gehören nicht mehr zum Modell, da ihr übergeordnetes Modul `B` partitioniert ist, und jede Ausführung, die normalerweise zu `E` und `F` gehört, findet innerhalb des (partitionierten) `B` Moduls statt.
1. Obwohl `H` für die Tensor-Parallelität unterstützt wird, wird es in diesem Beispiel nicht partitioniert. Das verdeutlicht, dass es von Benutzereingaben abhängt, ob ein Modul partitioniert werden soll oder nicht. Die Tatsache, dass ein Modul für Tensor-Parallelität unterstützt wird, bedeutet nicht unbedingt, dass es partitioniert wird.
## Wie die Bibliothek die Tensorparallelität an das Modul anpasst PyTorch `nn.Linear`
Wenn die Tensor-Parallelität über datenparallele Ränge ausgeführt wird, wird eine Teilmenge der Parameter, Steigungen und Optimierer-Zustände über die tensorparallelen Geräte *für die partitionierten Module* hinweg partitioniert. Für die übrigen Module arbeiten die tensorparallelen Geräte in der regulär datenparallelen Weise. Um das partitionierte Modul auszuführen, sammelt ein Gerät zunächst die erforderlichen Teile *aller Datenstichproben* auf Peer-Geräten in derselben Tensor-Parallelitätsgruppe. Das Gerät führt dann den lokalen Teil des Moduls für all diese Datenproben aus, gefolgt von einer weiteren Synchronisationsrunde, bei der sowohl die Teile der Ausgabe für jede Datenprobe kombiniert als auch die kombinierten Datenproben an die zurückgegeben werden, GPUs aus der die Datenprobe zuerst stammt. Die folgende Abbildung zeigt ein Beispiel für diesen Prozess in einem partitionierten `nn.Linear` Modul.
![\[Zwei Abbildungen zeigen zwei Tensorparallelkonzepte.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-concept.png)
Die erste Abbildung zeigt ein kleines Modell mit einem großen `nn.Linear` Modul mit Datenparallelität über die beiden Tensor-Parallelitätsränge. Das `nn.Linear` Modul wird in die beiden parallelen Ränge repliziert.
Die zweite Abbildung zeigt die Anwendung der Tensor-Parallelität auf ein größeres Modell bei der Aufteilung des `nn.Linear` Moduls. Jedes `tp_rank` enthält die Hälfte des linearen Moduls und die Gesamtheit der übrigen Operationen. Während das lineare Modul läuft, sammelt jedes `tp_rank` die entsprechende Hälfte aller Datenstichproben und übergibt sie an die jeweils andere Hälfte des `nn.Linear` Moduls. Das Ergebnis muss mit reduzierter Streuung (mit Summierung als Reduktionsvorgang) berechnet werden, so dass jeder Rang die endgültige lineare Ausgabe für seine eigenen Datenstichproben erhält. Der Rest des Modells läuft in der typischen datenparallelen Weise.
# Führen Sie einen parallelen Trainingsjob für SageMaker verteilte Modelle mit Tensorparallelismus aus
In diesem Abschnitt lernen Sie:
+ So konfigurieren Sie einen SageMaker PyTorch Schätzer und die Option SageMaker Modellparallelität, um Tensorparallelität zu verwenden.
+ Wie Sie Ihr Trainingsskript mithilfe der erweiterten `smdistributed.modelparallel` Module für Tensor-Parallelität anpassen.
Weitere Informationen zu den `smdistributed.modelparallel` Modulen finden Sie in der [SageMaker Modellparallele APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) in der *SageMaker Python SDK-Dokumentation*.
**Topics**
+ [Tensor-Parallelität allein](#model-parallel-extended-features-pytorch-tensor-parallelism-alone)
+ [Tensor-Parallelität kombiniert mit Pipeline-Parallelität](#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism)
## Tensor-Parallelität allein
Im Folgenden sehen Sie ein Beispiel für eine verteilte Trainingsoption zur Aktivierung der Tensor-Parallelität allein, ohne Pipeline-Parallelität. Konfigurieren Sie die `smp_options` Wörterbücher `mpi_options` und, um verteilte Trainingsoptionen für den SageMaker `PyTorch` Schätzer anzugeben.
**Anmerkung**
Erweiterte Funktionen zum Speichern von Speicherplatz sind über Deep Learning Containers for verfügbar PyTorch, das die SageMaker Modellparallelismusbibliothek v1.6.0 oder höher implementiert.
** SageMaker PyTorch Konfigurieren Sie einen Schätzer**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"pipeline_parallel_degree": 1, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 4, # tp over 4 devices
"ddp": True
}
}
smp_estimator = PyTorch(
entry_point='your_training_script.py', # Specify
role=role,
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
framework_version='1.13.1',
py_version='py36',
instance_count=1,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
**Tipp**
Eine vollständige Liste der Parameter für `distribution` finden Sie unter [Konfigurationsparameter für Modellparallelismus](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html) in der SageMaker Python SDK-Dokumentation.
**Passen Sie Ihr Trainingsskript PyTorch an**
Das folgende Beispiel-Trainingsskript zeigt, wie Sie die SageMaker Modellparallelitätsbibliothek an ein Trainingsskript anpassen. Bei diesem Beispiel wird davon ausgegangen, dass das Skript den Namen `your_training_script.py` trägt.
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
return F.log_softmax(x, 1)
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by
# the current process, based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
loss.backward()
optimizer.step()
# smdistributed: Initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
if smp.local_rank() == 0:
dataset = datasets.MNIST("../data", train=True, download=False)
smp.barrier()
# smdistributed: Shard the dataset based on data parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64)
# smdistributed: Enable tensor parallelism for all supported modules in the model
# i.e., nn.Linear in this case. Alternatively, we can use
# smp.set_tensor_parallelism(model.fc1, True)
# to enable it only for model.fc1
with smp.tensor_parallelism():
model = Net()
# smdistributed: Use the DistributedModel wrapper to distribute the
# modules for which tensor parallelism is enabled
model = smp.DistributedModel(model)
optimizer = optim.AdaDelta(model.parameters(), lr=4.0)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Tensor-Parallelität kombiniert mit Pipeline-Parallelität
Das Folgende ist ein Beispiel für eine verteilte Trainingsoption, die Tensorparallelität in Kombination mit Pipeline-Parallelität ermöglicht. Richten Sie die `smp_options` Parameter `mpi_options` und ein, um Modellparalleloptionen mit Tensorparallelität zu spezifizieren, wenn Sie einen Schätzer konfigurieren. SageMaker `PyTorch`
**Anmerkung**
Erweiterte Funktionen zum Speichern von Speicherplatz sind über Deep Learning Containers for verfügbar PyTorch, das die SageMaker Modellparallelismusbibliothek v1.6.0 oder höher implementiert.
** SageMaker PyTorch Konfigurieren Sie einen Schätzer**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True
}
}
smp_estimator = PyTorch(
entry_point='your_training_script.py', # Specify
role=role,
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
framework_version='1.13.1',
py_version='py36',
instance_count=1,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
**Passen Sie Ihr PyTorch Trainingsskript an**
Das folgende Beispiel-Trainingsskript zeigt, wie Sie die SageMaker Modellparallelitätsbibliothek an ein Trainingsskript anpassen. Beachten Sie, dass das Trainingsskript jetzt den `smp.step` Decorator enthält:
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
return F.log_softmax(x, 1)
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by
# the current process, based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: Initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
if smp.local_rank() == 0:
dataset = datasets.MNIST("../data", train=True, download=False)
smp.barrier()
# smdistributed: Shard the dataset based on data parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = Net()
# smdistributed: enable tensor parallelism only for model.fc1
smp.set_tensor_parallelism(model.fc1, True)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = optim.AdaDelta(model.parameters(), lr=4.0)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
# Support für Hugging Face Transformator-Modelle
Die Tensorparallelität der SageMaker Modellparallelitätsbibliothek bietet out-of-the-box Unterstützung für die folgenden Hugging Face Transformer-Modelle:
+ GPT-2, BERT und Ro BERTa (verfügbar in der Modellparallelitätsbibliothek v1.7.0 und höher) SageMaker
+ GPT-J (Verfügbar in der Modellparallelismus-Bibliothek v1.8.0 und höher SageMaker )
+ GPT-Neo (Verfügbar in der Modellparallelismus-Bibliothek v1.10.0 und höher SageMaker )
**Anmerkung**
Für alle anderen Transformer-Modelle müssen Sie die API [smdistributed.modelparallel.torch.tp\$1register\$1with\$1module()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tp_register_with_module) verwenden, um die Tensor-Parallelität anzuwenden.
**Anmerkung**
Um Tensorparallelität für das Training von Hugging Face Transformer-Modellen zu verwenden, stellen Sie sicher, dass Sie Hugging Face Deep Learning Containers verwenden, für die die Modellparallelismusbibliothek v1.7.0 und PyTorch höher verfügbar ist. SageMaker [Weitere Informationen finden Sie in den Versionshinweisen zur Modellparallelismus-Bibliothek. SageMaker ](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html)
## Ab Werk unterstützte Modelle
Für die Hugging Face Face-Transformer-Modelle, die von der Bibliothek standardmäßig unterstützt werden, müssen Sie Hooks nicht manuell implementieren, um Transformer in Transformer-Ebenen APIs zu `smdistributed` übersetzen. [Sie können die Tensorparallelität aktivieren, indem Sie den Kontextmanager [smdistributed.modelparallel.torch.tensor\$1parallelism () verwenden und das Modell mit smdistributed.modelparallel.torch](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tensor_parallelism) umschließen. DistributedModel().](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel) Sie brauchen für die Tensor-Parallelität keine Hooks mit Hilfe der `smp.tp_register` API manuell zu registrieren.
Die `state_dict` Übersetzung funktioniert zwischen Hugging Face Transformers und `smdistributed.modelparallel` kann wie folgt aufgerufen werden.
+ `smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_state_dict_to_hf_gpt2(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_hf_state_dict_to_smdistributed_gpt2(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.bert.translate_state_dict_to_hf_bert(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.bert.translate_hf_state_dict_to_smdistributed_bert(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_state_dict_to_hf_roberta(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_hf_state_dict_to_smdistributed_roberta(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_state_dict_to_hf_gptj(state_dict, max_seq_len=None)`(Verfügbar in der SageMaker Modellparallelismus-Bibliothek v1.8.0 und höher)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj`(Verfügbar in der SageMaker Modellparallelismus-Bibliothek v1.8.0 und höher)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None)`(Verfügbar in der SageMaker Modellparallelismus-Bibliothek v1.10.0 und höher)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict)`(Verfügbar in der SageMaker Modellparallelismus-Bibliothek v1.10.0 und höher)
**Beispiel für die Verwendung der GPT-2-Übersetzungsfunktion**
Beginnen Sie damit, das Modell wie im folgenden Code gezeigt zu umschließen:
```
from transformers import AutoModelForCausalLM
with smp.tensor_parallelism():
model = AutoModelForCausalLM.from_config(hf_gpt2_config)
model = smp.DistributedModel(model)
```
Ausgehend von `state_dict` von einem `DistributedModel` Objekt können Sie die Gewichtungen mithilfe der im folgenden Code gezeigten `translate_state_dict_to_hf_gpt2` Funktion in das ursprüngliche Hugging Face GPT-2-Modell laden.
```
from smdistributed.modelparallel.torch.nn.huggingface.gpt2 \
import translate_state_dict_to_hf_gpt2
max_seq_len = 1024
# [... code block for training ...]
if smp.rdp_rank() == 0:
state_dict = dist_model.state_dict()
hf_state_dict = translate_state_dict_to_hf_gpt2(state_dict, max_seq_len)
# can now call model.load_state_dict(hf_state_dict) to the original HF model
```
**Beispiel für die Verwendung der Ro-Übersetzungsfunktion BERTa **
In ähnlicher Weise können Sie bei einem unterstützten HuggingFace Modell die `translate_hf_state_dict_to_smdistributed` Funktion verwenden`state_dict`, um es in ein von lesbares Format zu konvertieren`smp.DistributedModel`. Dies kann bei Anwendungsfällen für Transfer Learning nützlich sein, wo ein vortrainiertes Modell zur parallelen Feinabstimmung des Modells in ein `smp.DistributedModel` geladen wird:
```
from smdistributed.modelparallel.torch.nn.huggingface.roberta \
import translate_state_dict_to_smdistributed
model = AutoModelForMaskedLM.from_config(roberta_config)
model = smp.DistributedModel(model)
pretrained_model = AutoModelForMaskedLM.from_pretrained("roberta-large")
translated_state_dict =
translate_state_dict_to_smdistributed(pretrained_model.state_dict())
# load the translated pretrained weights into the smp.DistributedModel
model.load_state_dict(translated_state_dict)
# start fine-tuning...
```
# Rangfolgemechanismus bei Verwendung einer Kombination aus Pipeline-Parallelität und Tensor-Parallelität
In diesem Abschnitt wird erklärt, wie der Rangfolgemechanismus der Modellparallelität mit der Tensor-Parallelität funktioniert. Dies ist die erweiterte Form der [Grundlagen der Rangfolge](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#ranking-basics) für [Kernfunktionen der SageMaker Model Parallelism Library](model-parallel-core-features.md). Mit der Tensorparallelität führt die Bibliothek drei Arten von Rangfolge und Prozessgruppe ein APIs: `smp.tp_rank()` für den parallelen Tensorrang, für den parallel Pipeline-Rang und `smp.pp_rank()` `smp.rdp_rank()` für den parallel Rang mit reduzierten Daten. Die entsprechenden Kommunikationsprozessgruppen sind die Tensor-Parallelgruppe (`TP_GROUP`), die Pipeline-Parallelgruppe (`PP_GROUP`) und die Parallelgruppe für reduzierte Daten (`RDP_GROUP`). Diese Gruppen sind wie folgt definiert:
+ Eine *Tensor-Parallelgruppe* (`TP_GROUP`) ist eine gleichmäßig teilbare Teilmenge der Daten-Parallelgruppe, über die die tensorparallele Verteilung von Modulen erfolgt. Wenn der Grad der Pipeline-Parallelität 1 ist, entspricht `TP_GROUP` der *Modell-Parallelgruppe* (`MP_GROUP`).
+ Eine *Pipeline-Parallelgruppe* (`PP_GROUP`) ist die Gruppe von Prozessen, über die die Pipeline-Parallelität erfolgt. Wenn der Grad der Tensor-Parallelität 1 ist, so ist `PP_GROUP` das Gleiche wie `MP_GROUP`.
+ Eine *Parallelgruppe für reduzierte Daten* (`RDP_GROUP`) ist eine Menge von Prozessen, die sowohl dieselben Pipeline-Parallelitätspartitionen als auch dieselben Tensor-Parallelitätspartitionen enthalten und untereinander Datenparallelität durchführen. Eine solche Gruppe wird als Parallelgruppe für reduzierte Daten bezeichnet, da es sich dabei um eine Teilmenge der gesamten Datenparallelitätsgruppe `DP_GROUP` handelt. Für die Modellparameter, die innerhalb der `TP_GROUP` verteilt sind, erfolgt die `allreduce` Steigungsoperation nur für die Parallelgruppe mit reduzierten Daten, während für die Parameter, die nicht verteilt sind, die Steigung `allreduce` über die gesamte `DP_GROUP` erfolgt.
+ Eine Modell-Parallelgruppe (`MP_GROUP`) bezieht sich auf eine Gruppe von Prozessen, die gemeinsam das gesamte Modell speichern. Sie besteht aus der Vereinigung der `PP_GROUP`s aller Ränge, die sich im `TP_GROUP` der aktuellen Prozess befinden. Wenn der Grad der Tensor-Parallelität 1 ist, entspricht `MP_GROUP` `PP_GROUP`. Sie entspricht auch der bestehenden Definition von `MP_GROUP` aus früheren `smdistributed` Versionen. Beachten Sie, dass die aktuelle `TP_GROUP` eine Teilmenge sowohl des aktuellen `DP_GROUP` als auch des aktuellen `MP_GROUP` ist.
Weitere Informationen zum Kommunikationsprozess APIs in der SageMaker Modellparallelismus-Bibliothek finden Sie unter [Common API](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html#) und [PyTorch-specific APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html) in der *SageMaker Python* SDK-Dokumentation.
![\[Ranking-Mechanismus, Parameterverteilung und damit verbundene AllReduce Operationen der Tensorparallelität.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-ranking-mechanism.png)
Stellen Sie sich beispielsweise Prozessgruppen für einen einzelnen Knoten mit 8 vor GPUs, wobei der Grad der Tensorparallelität 2, der Grad der Pipeline-Parallelität 2 und der Grad der Datenparallelität 4 ist. Der obere mittlere Teil der Abbildung weiter oben zeigt ein Beispiel für ein Modell mit 4 Layers. Die unteren linken und unteren rechten Teile der Abbildung veranschaulichen das 4-Schichten-Modell, das auf 4 verteilt ist und sowohl Pipeline-Parallelität als auch Tensorparallelität GPUs verwendet, wobei Tensorparallelität für die beiden mittleren Schichten verwendet wird. Diese beiden unteren Abbildungen sind einfache Kopien zur Veranschaulichung der Grenzlinien zwischen den verschiedenen Gruppen. Das partitionierte Modell wird aus Gründen der Datenparallelität zwischen 0-3 und 4-7 repliziert. GPUs Die Abbildung unten links zeigt die Definitionen von `MP_GROUP`, `PP_GROUP` und `TP_GROUP`. Die Abbildung unten rechts zeigt `RDP_GROUP``DP_GROUP`, und `WORLD` über demselben Satz von. GPUs Die Steigungen für die Ebenen und Layer-Slices, die dieselbe Farbe haben, werden aus Gründen der Datenparallelität zusammengefasst`allreduce`. z. B. erhält die erste Layer (hellblau) die `allreduce` Operationen über `DP_GROUP`. Dagegen erhält die dunkelorangefarbene Layer in der zweiten Layer nur die `allreduce` Operationen innerhalb der `RDP_GROUP` ihres Prozesses. Die fetten dunkelroten Pfeile stehen für Tensoren mit dem Batch aus ihren gesamten `TP_GROUP`.
```
GPU0: pp_rank 0, tp_rank 0, rdp_rank 0, dp_rank 0, mp_rank 0
GPU1: pp_rank 1, tp_rank 0, rdp_rank 0, dp_rank 0, mp_rank 1
GPU2: pp_rank 0, tp_rank 1, rdp_rank 0, dp_rank 1, mp_rank 2
GPU3: pp_rank 1, tp_rank 1, rdp_rank 0, dp_rank 1, mp_rank 3
GPU4: pp_rank 0, tp_rank 0, rdp_rank 1, dp_rank 2, mp_rank 0
GPU5: pp_rank 1, tp_rank 0, rdp_rank 1, dp_rank 2, mp_rank 1
GPU6: pp_rank 0, tp_rank 1, rdp_rank 1, dp_rank 3, mp_rank 2
GPU7: pp_rank 1, tp_rank 1, rdp_rank 1, dp_rank 3, mp_rank 3
```
In diesem Beispiel tritt Pipeline-Parallelität zwischen den GPU-Paaren (0,1); (2,3); (4,5) und (6,7) auf. Darüber hinaus findet Datenparallelität (`allreduce`) über GPUs 0, 2, 4, 6 und unabhängig über GPUs 1, 3, 5, 7 statt. Tensor-Parallelität tritt über Teilmengen von `DP_GROUP`s auf, über die GPU-Paare (0,2); (1,3); (4,6) und (5,7).
Für eine hybride Pipeline- und Tensor-Parallelität dieser Art bleibt die mathematische Behandlung für `data_parallel_degree` wie bei `data_parallel_degree = number_of_GPUs / pipeline_parallel_degree`. Die Bibliothek berechnet außerdem den reduzierten Daten-Parallelitätsgrad anhand der folgenden Beziehung `reduced_data_parallel_degree * tensor_parallel_degree = data_parallel_degree`.
# Optimizer-Zustandsfragmentierung
Die *Optimizer-Zustandsfragmentierung* ist eine nützliche Technik zur Speichereinsparung, bei der der Optimizer-Zustand (die Menge der Gewichtungen, die den Zustand des Optimierers beschreiben) auf datenparallele Gerätegruppen fragmentiert wird. Sie können das State-Sharding des Optimizers immer dann verwenden, wenn Sie einen Stateful-Optimizer (wie Adam) oder einen FP16 Optimizer (der beide FP16 und Kopien der Parameter speichert) verwenden. FP32
**Anmerkung**
Das State-Sharding von Optimizer ist PyTorch in der Modellparallelismus-Bibliothek v1.6.0 und höher verfügbar. SageMaker
## So wird die Optimizer-Zustandsfragmentierung verwendet
Die *Optimizer-Zustandsfragmentierung* können Sie aktivieren, indem Sie in der `modelparallel` Konfiguration `"shard_optimizer_state": True` einstellen.
Wenn diese Funktion aktiviert ist, partitioniert die Bibliothek die Menge der Modellparameter anhand des Datenparallelitätsgrades. Die Steigungen, die `i`-ten Partition entsprechen, werden erst im `i`ten Datenparallelrang reduziert. Am Ende des ersten Aufrufs einer `smp.step` Decorator-Funktion definiert der mit `smp.DistributedOptimizer` umschlossene Optimizer seine Parameter neu, so dass sie auf diejenigen Parameter beschränkt sind, die der Partition des aktuellen Datenparallelrangs entsprechen. Die neu definierten Parameter werden als *virtuelle Parameter* bezeichnet und teilen sich den zugrunde liegenden Speicher mit den ursprünglichen Parametern. Beim ersten Aufruf von `optimizer.step` werden die Optimierer-Zustände anhand dieser neu definierten Parameter erstellt, die aufgrund der ursprünglichen Partition fragmentiert sind. Nach dem Optimierer-Update wird der AllGather Vorgang (als Teil des `optimizer.step` Aufrufs) über die parallel Datenränge hinweg ausgeführt, um konsistente Parameterstatus zu erreichen.
**Tipp**
Die Optimizer-Zustandsfragmentierung kann nützlich sein, wenn der Daten-Parallelitätsgrad größer ist als 1 und das Modell mehr als eine Milliarde Parameter hat.
Der Daten-Parallelitätsgrad wird nach `(processes_per_host * instance_count / pipeline_parallel_degree)` berechnet, und die `smp.dp_size()` Funktion übernimmt im Hintergrund die Größenanpassung.
**Konfigurieren Sie einen SageMaker PyTorch Schätzer**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True,
"shard_optimizer_state": True
}
}
```
**Passen Sie Ihr PyTorch Trainingsskript an**
Weitere Informationen finden Sie unter [Anpassen Ihres PyTorch Trainingsskripts](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism-script) im Abschnitt *Tensor-Parallelität kombiniert mit Pipeline-Parallelität*. Für das Skript sind keine weiteren Änderungen erforderlich.
# Aktivierungs-Prüfpunkte
Bei den *Aktivierungs-Prüfpunkten* (oder *Steigungs-Prüfpunkten*) handelt es sich um eine Technik zur Reduzierung der Speicherbelegung, indem Aktivierungen bestimmter Layers gelöscht und bei einem Rücklauf neu berechnet werden. Dadurch wird zusätzliche Datenverarbeitungszeit effektiv gegen eine geringere Speicherauslastung eingetauscht. Wenn ein Modul mit einem Prüfpunkt versehen wird, bleiben am Ende eines Vorwärtsdurchlaufs die Ein- und Ausgaben des Moduls im Speicher. Alle Tensoren, die zwischenzeitlich Teil der Berechnung innerhalb dieses Moduls gewesen wären, werden während des Vorwärtsdurchlaufs wieder freigegeben. Beim Rückwärtsdurchlauf von Modulen mit Prüfpunkten werden diese Tensoren neu berechnet. Zu diesem Zeitpunkt haben die Layers hinter diesem Prüfpunkt-Modul ihren Rückwärtsdurchlauf abgeschlossen, so dass die maximale Speichernutzung mit Prüfpunkten geringer sein kann.
**Anmerkung**
Diese Funktion ist PyTorch in der SageMaker Modellparallelitätsbibliothek v1.6.0 und höher verfügbar.
## So werden Aktivierungs-Prüfpunkte verwendet
Mit `smdistributed.modelparallel` können Sie Aktivierungs-Prüfpunkte bei der Granularität eines Moduls verwenden. Für alle `torch.nn` Module außer `torch.nn.Sequential` können Sie Prüfpunkte für einen Modulbaum nur verwenden, wenn er aus Sicht der Pipeline-Parallelität innerhalb einer Partition liegt. Im Fall des `torch.nn.Sequential` Moduls muss jeder Modulbaum innerhalb des sequentiellen Moduls vollständig innerhalb einer Partition liegen, damit die Aktivierungs-Prüfpunkte funktionieren. Diese Einschränkungen sollten Sie berücksichtigen, wenn Sie die manuelle Partitionierung verwenden.
Wenn Sie die [automatisierte Modellpartitionierung](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-core-features.html#model-parallel-automated-model-splitting) verwenden, finden Sie die Protokolle der Partitionierungszuweisungen, beginnend mit `Partition assignments:` in den Protokollen der Trainingsaufträge. Wenn ein Modul über mehrere Ränge partitioniert ist (z. B. mit einem abstammenden Element auf einem Rang und einem anderen auf einem anderen Rang), ignoriert die Bibliothek den Versuch, für das Modul einen Checkpoint zu setzen, und gibt eine Warnmeldung aus, dass für das Modul kein Prüfpunkt verwendet wird.
**Anmerkung**
Die SageMaker Modellparallelitätsbibliothek unterstützt sowohl überlappende als auch nicht `allreduce` überlappende Operationen in Kombination mit Checkpointing.
**Anmerkung**
PyTorchDie native Checkpointing-API ist nicht kompatibel mit. `smdistributed.modelparallel`
**Beispiel 1:** Der folgende Beispielcode zeigt, wie Sie Aktivierungsprüfpunkte verwenden, wenn Sie in Ihrem Skript eine Modelldefinition haben.
```
import torch.nn as nn
import torch.nn.functional as F
from smdistributed.modelparallel.torch.patches.checkpoint import checkpoint
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
# This call of fc1 will be checkpointed
x = checkpoint(self.fc1, x)
x = self.fc2(x)
return F.log_softmax(x, 1)
```
**Beispiel 2:** Der folgende Beispielcode zeigt, wie Sie Aktivierungs-Prüfpunkte verwenden, wenn Ihr Skript ein sequentielles Modell enthält.
```
import torch.nn as nn
from smdistributed.modelparallel.torch.patches.checkpoint import checkpoint_sequential
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.seq = nn.Sequential(
nn.Conv2d(1,20,5),
nn.ReLU(),
nn.Conv2d(20,64,5),
nn.ReLU()
)
def forward(self, x):
# This call of self.seq will be checkpointed
x = checkpoint_sequential(self.seq, x)
return F.log_softmax(x, 1)
```
**Beispiel 3:** Der folgende Beispielcode zeigt, wie Aktivierungsprüfpunkte verwendet werden, wenn Sie ein vorgefertigtes Modell aus einer Bibliothek importieren, z. B. Hugging PyTorch Face Transformers. Gehen Sie wie folgt vor, unabhängig davon, ob Sie sequentielle Module mit Prüfpunkten versehen oder nicht:
1. Umschließen Sie das Modell mit `smp.DistributedModel()`.
1. Definieren Sie ein Objekt für sequenzielle Ebenen.
1. Umschließen Sie das sequentielle Layer-Objekt mit `smp.set_activation_checkpointig()`.
```
import smdistributed.modelparallel.torch as smp
from transformers import AutoModelForCausalLM
smp.init()
model = AutoModelForCausalLM(*args, **kwargs)
model = smp.DistributedModel(model)
# Call set_activation_checkpointing API
transformer_layers = model.module.module.module.transformer.seq_layers
smp.set_activation_checkpointing(
transformer_layers, pack_args_as_tuple=True, strategy='each')
```
# Aktivierungs-Entladung
Wenn Aktivierungs-Prüfpunkte und Pipeline-Parallelität aktiviert sind und die Anzahl der Mikro-Batches größer als eins ist, ist das *Aktivierungs-Entladen* eine zusätzliche Funktion, mit der die Speichernutzung weiter reduziert werden kann. Beim Aktivierungs-Entladen werden die Prüfpunkt-Aktivierungen asynchron verschoben, entsprechend ihren Mikro-Batches, die aktuell nicht auf der CPU ausgeführt werden. Kurz bevor die GPU die Aktivierungen für den Rückwärtsdurchgang des Mikro-Batchs braucht, ruft diese Funktion die ausgelagerten Aktivierungen vorab von der CPU zurück.
**Anmerkung**
Diese Funktion ist PyTorch in der SageMaker Modellparallelismus-Bibliothek v1.6.0 und höher verfügbar.
## So wird die Aktivierungs-Entladung verwendet
Verwenden Sie das Aktivierungs-Entladen, um die Speichernutzung zu reduzieren, wenn **die Anzahl der Mikro-Batches größer als 1 ist und die Aktivierungs-Prüfpunkte aktiviert sind ** (siehe [Aktivierungs-Prüfpunkte](model-parallel-extended-features-pytorch-activation-checkpointing.md)). Wenn keine Aktivierungs-Prüfpunkte verwendet werden, hat das Aktivierungs-Entladen keine Wirkung. Wenn es mit nur einem Mikro-Batch verwendet wird, spart es keinen Speicherplatz.
Um Aktivierungs-Entladen zu verwenden, legen Sie `"offload_activations": True` in der `modelparallel` Konfiguration fest.
Beim Aktivierungs-Entladen werden die Prüfpunkt-Aktivierungen in `nn.Sequential` Modulen asynchron auf die CPU verschoben. Die Datenübertragung über die PCIe Verbindung überschneidet sich mit der GPU-Berechnung. Das Entladen erfolgt sofort, sobald der Vorwärtsdurchgang für eine bestimmte Prüfpunkt-Layer berechnet wurde. Die Aktivierungen werden wieder auf die GPU geladen, kurz bevor sie für den Rückwärtslauf eines bestimmten Mikro-Batches gebraucht werden. Der CPU-GPU-Transfer überschneidet sich in ähnlicher Weise mit der Berechnung.
Um einzustellen, wie früh die Aktivierungen wieder in die GPU geladen werden, können Sie den Konfigurationsparameter `"activation_loading_horizon"` verwenden (der Standardwert ist auf 4 gesetzt, und er muss `int` größer als 0 sein). Ein größerer Ladehorizont für die Aktivierung würde dazu führen, dass die Aktivierungen früher wieder auf die GPU geladen werden. Wenn der Horizont zu groß ist, kann sich die speichersparende Wirkung des Aktivierungs-Entladens verringern. Wenn der Horizont zu klein ist, können die Aktivierungen ggf. nicht rechtzeitig zurückgeladen werden. Dadurch wird der Umfang der Überschneidung verringert und die Leistung beeinträchtigt.
**Tipp**
Das Aktivierungs-Entladen kann für große Modelle mit über hundert Milliarden Parametern nützlich sein.
**Konfigurieren Sie einen Schätzer SageMaker PyTorch **
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True,
"offload_activations": True,
"activation_loading_horizon": 4 # optional. default is 4.
}
}
```
# FP16 Training mit Modellparallelität
Wenden Sie für das FP16 Training die folgenden Änderungen an Ihrem Trainingsskript und Ihrem Schätzer an.
**Anmerkung**
Diese Funktion ist PyTorch in der SageMaker Modellparallelismus-Bibliothek v1.10.0 und höher verfügbar.
**Passen Sie Ihr Trainingsskript an PyTorch **
1. Umschließen Sie Ihr Modell mit dem Kontextmanager [smdistributed.modelparallel.torch.model\$1creation()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.model_creation).
```
# fp16_training_script.py
import torch
import smdistributed.modelparallel.torch as smp
with smp.model_creation(
dtype=torch.float16 if args.fp16 else torch.get_default_dtype()
):
model = ...
```
**Tipp**
Wenn Sie Tensor-Parallelität verwenden, fügen Sie `tensor_parallelism=smp.tp_size() > 1` zum `smp.model_creation`Kontextmanager hinzu. Mit Hilfe dieser zusätzlichen Zeile kann auch automatisch erkannt werden, ob die Tensor-Parallelität aktiviert ist oder nicht.
```
with smp.model_creation(
... ,
tensor_parallelism=smp.tp_size() > 1
):
model = ...
```
1. Wenn Sie den Optimierer mit `smdistributed.modelparallel.torch.DistributedOptimizer` umschließen, setzen Sie entweder das Argument `static_loss_scaling` oder `dynamic_loss_scaling`. `static_loss_scaling` Ist standardmäßig auf `1.0` gesetzt und `dynamic_loss_scaling` ist auf `False` gesetzt. Wenn Sie `dynamic_loss_scale=True` einstellen, können Sie dynamische Verlustskalierungsoptionen als Wörterbuch über das Argument `dynamic_loss_args` einspeisen. In den meisten Fällen empfehlen wir die dynamische Verlustskalierung mit den Standardoptionen zu verwenden. [Weitere Informationen, Optionen und Beispiele für die Optimizer-Wrapper-Funktion finden Sie unter smdistributed.modelparallel.torch. DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedoptimizer) API.
Der folgende Code ist ein Beispiel für das Umschließen eines `Adadelta` Optimiererobjekts mit dynamischer Verlustskalierung für das FP16 Training.
```
optimizer = torch.optim.Adadelta(...)
optimizer = smp.DistributedOptimizer(
optimizer,
static_loss_scale=None,
dynamic_loss_scale=True,
dynamic_loss_args={
"scale_window": 1000,
"min_scale": 1,
"delayed_shift": 2
}
)
```
**Konfigurieren Sie einen SageMaker PyTorch Schätzer**
Fügen Sie der Verteilungskonfiguration den FP16 Parameter (`"fp16"`) für Modellparallelität hinzu, wenn Sie ein SageMaker PyTorch Schätzerobjekt erstellen. Eine vollständige Liste der Konfigurationsparameter für Modellparallelität finden Sie unter [Parameter für `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#parameters-for-smdistributed).
```
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled": True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2,
"tensor_parallel_degree": 2,
...,
"fp16": True
}
}
fp16_estimator = PyTorch(
entry_point="fp16_training_script.py", # Specify your train script
...,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": {...}
}
)
fp16_estimator.fit(...)
```
[Wenn das FP16 Training beginnt, werden das Modell und der Optimizer von `FP16_Module``FP16_Optimizer` bzw. umschlossen. Dabei handelt es sich um modifizierte `smdistributed` Versionen der Apex-Utils.](https://nvidia.github.io/apex/fp16_utils.html#apex-fp16-utils) `FP16_Module`konvertiert das Modell in FP16 dtype und kümmert sich um die Weiterleitung. FP16
**Tipp**
Sie können die Steigungen beschneiden, indem Sie `clip_master_grads` vor `optimizer.step` aufrufen.
```
optimizer.clip_master_grads(max_norm) # max_norm(float or int): max norm of the gradients
```
**Tipp**
Bei der Verwendung `torch.optim.lr_scheduler` und beim FP16 Training müssen Sie sich `optimizer.optimizer` an den LR-Scheduler und nicht an den Optimizer wenden. Schauen Sie sich den folgenden Beispiel-Code an:
```
from torch.optim.lr_scheduler import StepLR
scheduler = StepLR(
optimizer.optimizer if smp.state.cfg.fp16 else optimizer,
step_size=1,
gamma=args.gamma
)
```
# Support für FlashAttention
Support für FlashAttention ist eine Funktion der Bibliothek, die nur für das *verteilte Transformer-Modell* gilt, bei dem es sich um ein Transformer-Modell handelt, das [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedmodel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedmodel)für modellparalleles Training genutzt wird. Diese Funktion ist auch mit [Tensor-Parallelität](model-parallel-extended-features-pytorch-tensor-parallelism.md) kompatibel.
Die [FlashAttention](https://github.com/HazyResearch/flash-attention)Bibliothek unterstützt nur Modelle, wenn sie auf einen Wert gesetzt `attention_head_size` ist, der ein Vielfaches von 8 und kleiner als 128 ist. Wenn Sie also einen dezentralen Transformator trainieren und sicherstellen, dass er ordnungsgemäß FlashAttention funktioniert, sollten Sie die Parameter so anpassen, dass die Größe des Aufmerksamkeitskopfs den Anforderungen entspricht. Weitere Informationen finden Sie auch unter [Installation und Funktionen](https://github.com/HazyResearch/flash-attention#installation-and-features) im *FlashAttention GitHubRepository*.
Nehmen wir z. B. an, Sie konfigurieren ein Transformator-Modell mit `hidden_width=864` und `num_heads=48`. Die Kopfgröße von FlashAttention wird berechnet als`attention_head_size = hidden_width / num_heads = 864 / 48 = 18`. Um das zu aktivieren FlashAttention, müssen Sie den `num_heads` Parameter so einstellen `54``attention_head_size = hidden_width / num_heads = 864 / 54 = 16`, dass das ein Vielfaches von 8 ist.
# Führen Sie einen SageMaker verteilten Trainingsjob mit Modellparallelität aus
Erfahren Sie, wie Sie mithilfe des SageMaker Python-SDK mit der Modellparallelismus-Bibliothek einen modellparallelen Trainingsjob Ihres eigenen Trainingsskripts ausführen. SageMaker
Es gibt drei Anwendungsszenarien für die Ausführung eines Trainingsjobs. SageMaker
1. Sie können einen der vorgefertigten AWS Deep Learning-Container für und verwenden. TensorFlow PyTorch Diese Option wird empfohlen, wenn Sie die Modellparallelbibliothek zum ersten Mal verwenden. Ein Tutorial zur Ausführung eines SageMaker Modelparallel-Trainingsjobs finden Sie in den Beispiel-Notebooks unter [PyTorch Training mit der Modellparallelismus-Bibliothek von Amazon SageMaker AI](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel).
1. Sie können die vorgefertigten Container erweitern, um alle zusätzlichen funktionalen Anforderungen für Ihren Algorithmus oder Ihr Modell zu erfüllen, die das vorgefertigte SageMaker Docker-Image nicht unterstützt. Ein Beispiel dafür, wie Sie einen vorgefertigten Container erweitern können, finden Sie unter [Erweitern eines vorgefertigten Containers](prebuilt-containers-extend.md).
1. [Mithilfe des Training-Toolkits können Sie Ihren eigenen Docker-Container an die Arbeit mit SageMaker KI anpassen. SageMaker ](https://github.com/aws/sagemaker-training-toolkit) [Ein Beispiel finden Sie unter Anpassung Ihres eigenen Trainingscontainers.](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html)
Die Optionen 2 und 3 in der vorherigen Liste finden Sie unter [Erweitern Sie einen vorgefertigten Docker-Container, der die SageMaker Distributed Model Parallel Library enthält](model-parallel-sm-sdk.md#model-parallel-customize-container), um zu erfahren, wie Sie die Model Parallel Library in einem erweiterten oder benutzerdefinierten Docker-Container installieren.
In allen Fällen starten Sie Ihren Trainingsjob, indem Sie einen SageMaker `TensorFlow` `PyTorch` Oder-Schätzer konfigurieren, um die Bibliothek zu aktivieren. Weitere Informationen finden Sie unter den folgenden Themen.
**Topics**
+ [Schritt 1: Ändern Sie Ihr eigenes Trainingsskript mithilfe SageMaker der Distributed Model Parallel Library](model-parallel-customize-training-script.md)
+ [Schritt 2: Starten Sie einen Trainingsjob mit dem SageMaker Python-SDK](model-parallel-sm-sdk.md)
# Schritt 1: Ändern Sie Ihr eigenes Trainingsskript mithilfe SageMaker der Distributed Model Parallel Library
In diesem Abschnitt erfahren Sie, wie Sie Ihr Schulungsskript anpassen können, um die Kernfunktionen der Amazon SageMaker AI-Bibliothek für Modellparallelismus zu nutzen. Um die bibliotheksspezifischen API-Funktionen und -Parameter zu verwenden, empfehlen wir Ihnen, diese Dokumentation zusammen mit der [SageMaker Modellparallel-Bibliothek APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) in der *SageMaker Python SDK-Dokumentation* zu verwenden.
Die in diesen Abschnitten bereitgestellten Beispiele für Trainingsskripte sind vereinfacht und sollen die erforderlichen Änderungen hervorheben, die Sie vornehmen müssen, um die Bibliothek verwenden zu können. Ausführbare Notebook-Beispiele end-to-end, die demonstrieren, wie Sie ein TensorFlow PyTorch OR-Trainingsskript mit der SageMaker Modellparallelismus-Bibliothek verwenden, finden Sie unter. [Beispiele für die Amazon SageMaker AI-Modellparallelismusbibliothek v2](distributed-model-parallel-v2-examples.md)
**Topics**
+ [Teilen Sie das Modell Ihres Trainingsskripts mithilfe der Modellparallelismus-Bibliothek auf SageMaker](#model-parallel-model-splitting-using-smp-lib)
+ [Ändern Sie ein TensorFlow Trainingsskript](model-parallel-customize-training-script-tf.md)
+ [Ein PyTorch Trainingsskript ändern](model-parallel-customize-training-script-pt.md)
## Teilen Sie das Modell Ihres Trainingsskripts mithilfe der Modellparallelismus-Bibliothek auf SageMaker
Es gibt zwei Möglichkeiten, Ihr Trainingsskript so zu ändern, dass das Modellsplitting eingerichtet wird: automatisiertes Splitting oder manuelles Splitting.
### Automatisiertes Aufteilen von Modellen
*Wenn Sie die Modellparallelitätsbibliothek verwenden SageMaker, können Sie die Vorteile der *automatisierten Modellteilung nutzen, die auch als automatisierte Modellpartitionierung* bezeichnet wird.* Die Bibliothek verwendet einen Partitionierungsalgorithmus, der den Arbeitsspeicher ausgleicht, die Kommunikation zwischen Geräten minimiert und die Leistung optimiert. Sie können den automatisierten Partitionierungsalgorithmus so konfigurieren, dass Geschwindigkeit oder Speicher optimiert werden.
Alternativ können Sie die manuelle Modell-Splitting verwenden. Wir empfehlen die automatische Modellteilung, sofern Sie mit der Modellarchitektur nicht sehr vertraut sind und eine gute Vorstellung davon haben, wie Sie Ihr Modell effizient partitionieren können.
#### Funktionsweise
Die automatische Partitionierung erfolgt während des ersten Trainingsschritts, wenn die mit `smp.step` -dekorierte Funktion zum ersten Mal aufgerufen wird. Während dieses Aufrufs erstellt die Bibliothek zunächst eine Version des Modells im CPU-RAM (um GPU-Speicherbeschränkungen zu vermeiden), analysiert dann das Modelldiagramm und trifft eine Partitionierungsentscheidung. Basierend auf dieser Entscheidung wird jede Modellpartition auf eine GPU geladen, und erst dann wird der erste Schritt ausgeführt. Aufgrund dieser Analyse- und Partitionierungsschritte kann der erste Trainingsschritt länger dauern.
In beiden Frameworks verwaltet die Bibliothek die Kommunikation zwischen Geräten über ihr eigenes Backend, das für die Infrastruktur optimiert ist. AWS
Das Design der automatischen Partition passt sich den Eigenschaften des Frameworks an, und die Bibliothek führt die Partitionierung auf der Granularitätsebene durch, die in jedem Framework natürlicher ist. Beispielsweise kann in TensorFlow jede spezifische Operation einem anderen Gerät zugewiesen werden, wohingegen die Zuweisung in PyTorch auf Modulebene erfolgt, wo jedes Modul aus mehreren Operationen besteht. Im folgenden Abschnitt werden die Besonderheiten des Designs in den einzelnen Frameworks beschrieben.
##### Automatisierte Modellteilung mit PyTorch
Während des ersten Trainingsschritts führt die Modellparallelitätsbibliothek intern einen Tracing-Schritt durch, der dazu dient, den Modellgraphen zu konstruieren und die Tensor- und Parameterformen zu bestimmen. Nach diesem Verfolgungsschritt erstellt die Bibliothek einen Baum, der aus den verschachtelten `nn.Module` Objekten im Modell sowie aus zusätzlichen Daten besteht, die bei der Ablaufverfolgung gesammelt wurden, wie z. B. die Menge der gespeicherten `nn.Parameters` und die Ausführungszeit für jedes `nn.Module`.
Als Nächstes durchläuft die Bibliothek diesen Baum von der Wurzel aus und führt einen Partitionierungsalgorithmus aus, der jedes `nn.Module` Gerät einem Gerät zuweist, wodurch die Rechenlast (gemessen an der Modulausführungszeit) und die Speichernutzung (gemessen an der gesamten gespeicherten `nn.Parameter` Größe und den Aktivierungen) ausgeglichen werden. Wenn mehrere Module `nn.Modules` dasselbe `nn.Parameter` verwenden, werden diese Module auf demselben Gerät platziert, um zu vermeiden, dass mehrere Versionen desselben Parameters beibehalten werden. Sobald die Entscheidung über die Partitionierung getroffen wurde, werden die zugewiesenen Module und Gewichte auf ihre Geräte geladen.
Eine Anleitung, wie Sie den `smp.step` Decorator für Ihr PyTorch Trainingsskript registrieren, finden Sie unter. [Automatisiertes Teilen mit PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16)
##### Automatisierte Modellteilung mit TensorFlow
Die Modellparallelitätsbibliothek analysiert die Größen der trainierbaren Variablen und die Graphstruktur und verwendet intern einen Algorithmus zur Graphpartitionierung. Dieser Algorithmus erstellt für jeden Vorgang eine Gerätezuweisung mit dem Ziel, den Kommunikationsaufwand zwischen den Geräten zu minimieren. Dabei gelten zwei Einschränkungen:
+ Ausbalancierung der Anzahl der in jedem Gerät gespeicherten Variablen
+ Ausgleich der Anzahl der auf jedem Gerät ausgeführten Operationen
Wenn Sie `speed` für `optimize` (in den Modellparallelitätsparametern im Python-SDK) angeben, versucht die Bibliothek, die Anzahl der Operationen und `tf.Variable` Objekte in jedem Gerät auszugleichen. Andernfalls versucht sie, die Gesamtgröße von `tf.Variables` auszugleichen.
Sobald die Entscheidung über die Partitionierung getroffen wurde, erstellt die Bibliothek eine serialisierte Darstellung des Untergraphen, den jedes Gerät ausführen muss, und importiert sie auf jedes Gerät. Bei der Partitionierung platziert die Bibliothek Operationen, die dasselbe `tf.Variable` verbrauchen, und Operationen, die Teil derselben Keras-Schicht sind, auf demselben Gerät. Es berücksichtigt auch die Colocation-Einschränkungen von. TensorFlow Dies bedeutet, dass, wenn es beispielsweise zwei Keras-Ebenen gibt, die sich eine `tf.Variable` teilen, alle Operationen, die Teil dieser Ebenen sind, auf einem einzigen Gerät platziert werden.
Eine Anleitung, wie Sie den `smp.step` Decorator für Ihr PyTorch Trainingsskript registrieren, finden Sie unter. [Automatisiertes Teilen mit TensorFlow](model-parallel-customize-training-script-tf.md#model-parallel-customize-training-script-tf-23)
##### Vergleich der automatisierten Modellaufteilung zwischen Frameworks
In TensorFlow ist die grundlegende Berechnungseinheit a `tf.Operation` und TensorFlow stellt das Modell als gerichteten azyklischen Graphen (DAG) von `tf.Operation` s dar. Aus diesem Grund partitioniert die Modellparallelitätsbibliothek diesen DAG, sodass jeder Knoten zu einem Gerät gehört. Entscheidend ist, dass `tf.Operation` Objekte ausreichend reich an anpassbaren Attributen sind und dass sie insofern universell sind, als jedes Modell garantiert aus einem Graphen solcher Objekte besteht.
PyTorch auf der anderen Seite verfügt sie nicht über ein entsprechendes Funktionsverständnis, das umfassend und universell genug wäre. Die Recheneinheit PyTorch , die diesen Eigenschaften am nächsten kommt, ist an`nn.Module`, die sich auf einer viel höheren Granularitätsebene befindet, und aus diesem Grund partitioniert die Bibliothek auf dieser Ebene in. PyTorch
### Manuelles Aufteilen von Modellen
Wenn Sie manuell angeben möchten, wie Ihr Modell geräteübergreifend partitioniert werden soll, verwenden Sie den `smp.partition` Kontext-Manager. Anleitungen zum Einrichten des Kontext-Managers für die manuelle Partitionierung finden Sie auf den folgenden Seiten.
+ [Manuelles Teilen mit TensorFlow](model-parallel-customize-training-script-tf.md#model-parallel-customize-training-script-tf-manual)
+ [Manuelles Teilen mit PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16-hvd)
Um diese Option zu verwenden, nachdem Sie Änderungen vorgenommen haben, müssen Sie in Schritt 2 `default_partition` in der Framework-Schätzerklasse des SageMaker Python-SDK eine festlegen und diese definieren. `auto_partition` `False` Jede Operation, die nicht explizit über den `smp.partition` Kontext-Manager auf einer Partition platziert wurde, wird auf der `default_partition` ausgeführt. In diesem Fall wird die automatische Aufteilungslogik umgangen und jede Operation wird auf der Grundlage Ihrer Spezifikation platziert. Auf der Grundlage der resultierenden Graphstruktur erstellt die Modellparallelitätsbibliothek automatisch einen Ausführungsplan über die Pipeline.
# Ändern Sie ein TensorFlow Trainingsskript
In diesem Abschnitt erfahren Sie, wie Sie TensorFlow Trainingsskripte ändern, um die SageMaker Modellparallelitätsbibliothek für automatische Partitionierung und manuelle Partitionierung zu konfigurieren. Diese Auswahl an Beispielen umfasst auch ein in Horovod integriertes Beispiel für Hybridmodell und Datenparallelität.
**Anmerkung**
Informationen darüber, welche TensorFlow Versionen von der Bibliothek unterstützt werden, finden Sie unter. [Unterstützte Frameworks und AWS-Regionen](distributed-model-parallel-support.md)
Die erforderlichen Änderungen, die Sie an Ihrem Trainingsskript vornehmen müssen, um die Bibliothek verwenden zu können, sind unter [Automatisiertes Teilen mit TensorFlow](#model-parallel-customize-training-script-tf-23) aufgeführt.
Informationen zum Ändern Ihres Trainingsskripts zur Verwendung des Hybridmodells und der Datenparallelität mit Horovod finden Sie unter [Automatisiertes Splitten mit TensorFlow und Horovod für Hybridmodell und Datenparallelität](#model-parallel-customize-training-script-tf-2.3).
Wenn Sie die manuelle Partitionierung verwenden möchten, lesen Sie auch [Manuelles Teilen mit TensorFlow](#model-parallel-customize-training-script-tf-manual).
Die folgenden Themen zeigen Beispiele für Trainingsskripte, mit denen Sie die Modellparallelitätsbibliothek für Modelle mit automatischer Partitionierung und manueller Partitionierung konfigurieren SageMaker können. TensorFlow
**Anmerkung**
Die automatische Partitionierung ist standardmäßig aktiviert. Sofern nicht anders angegeben, verwenden die Beispielskripten automatische Partitionierung.
**Topics**
+ [Automatisiertes Teilen mit TensorFlow](#model-parallel-customize-training-script-tf-23)
+ [Automatisiertes Splitten mit TensorFlow und Horovod für Hybridmodell und Datenparallelität](#model-parallel-customize-training-script-tf-2.3)
+ [Manuelles Teilen mit TensorFlow](#model-parallel-customize-training-script-tf-manual)
+ [Nicht unterstützte Framework-Funktionen](#model-parallel-tf-unsupported-features)
## Automatisiertes Teilen mit TensorFlow
Die folgenden Änderungen am Trainingsskript sind erforderlich, um ein TensorFlow Modell mit SageMaker der Modellparallelitätsbibliothek auszuführen:
1. Importieren und initialisieren Sie die Bibliothek mit. [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init)
1. Definieren Sie ein Keras-Modell, indem Sie es von der Keras Model-Klasse [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_tensorflow.html](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_tensorflow.html) statt von der Keras-Model-Klasse erben. Gibt die Modellausgaben der Aufrufmethode des `smp.DistributedModel` Objekts zurück. Beachten Sie, dass alle von der Aufrufmethode zurückgegebenen Tensoren über modellparallele Geräte übertragen werden, was zu einem Kommunikationsaufwand führt. Daher sollten alle Tensoren, die außerhalb der Aufrufmethode nicht benötigt werden (z. B. Zwischenaktivierungen), nicht zurückgegeben werden.
1. `drop_remainder=True` in Methode `tf.Dataset.batch()` eingeben. Damit soll sichergestellt werden, dass die Batchgröße immer durch die Anzahl der Mikrobatches teilbar ist.
1. Legen Sie die zufälligen Operationen in der Datenpipeline fest`smp.dp_rank()`, `shuffle(ds, seed=smp.dp_rank())` um z. B. die Konsistenz von Datenproben sicherzustellen GPUs , die unterschiedliche Modellpartitionen enthalten.
1. Fügen Sie die Vorwärts- und Rückwärtslogik in eine Schritt-Funktion ein und dekorieren Sie sie mit `smp.step`.
1. Führen Sie die Nachbearbeitung der Ausgänge in verschiedenen Mikrobatches mit Methoden [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput)wie durch `reduce_mean`. Die [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init)Funktion muss einen Rückgabewert haben, der von der Ausgabe von `smp.DistributedModel` abhängt.
1. [Wenn es einen Bewertungsschritt gibt, platzieren Sie die Vorwärtslogik auf ähnliche Weise in einer mit – `smp.step`dekorierten Funktion und verarbeiten Sie die Ausgaben mithilfe der `StepOutput` API](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput) nach.
Weitere Informationen über die API SageMaker der Modellparallelismus-Bibliothek finden Sie in der [API-Dokumentation](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html).
Das folgende Python-Skript ist ein Beispiel für ein Trainingsskript, nachdem die Änderungen vorgenommen wurden.
```
import tensorflow as tf
# smdistributed: Import TF2.x API
import smdistributed.modelparallel.tensorflow as smp
# smdistributed: Initialize
smp.init()
# Download and load MNIST dataset.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(
"MNIST-data-%d" % smp.rank()
)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
# smdistributed: If needed, seed the shuffle with smp.dp_rank(), and drop_remainder
# in batching to make sure batch size is always divisible by number of microbatches
train_ds = (
tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10000, seed=smp.dp_rank())
.batch(256, drop_remainder=True)
)
# smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API
class MyModel(smp.DistributedModel):
def __init__(self):
super(MyModel, self).__init__()
# define layers
def call(self, x, training=None):
# define forward pass and return the model output
model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy")
# smdistributed: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(images, labels):
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
grads = optimizer.get_gradients(loss, model.trainable_variables)
return grads, loss, predictions
@tf.function
def train_step(images, labels):
gradients, loss, predictions = get_grads(images, labels)
# smdistributed: Accumulate the gradients across microbatches
gradients = [g.accumulate() for g in gradients]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# smdistributed: Merge predictions and average losses across microbatches
train_accuracy(labels, predictions.merge())
return loss.reduce_mean()
for epoch in range(5):
# Reset the metrics at the start of the next epoch
train_accuracy.reset_states()
for images, labels in train_ds:
loss = train_step(images, labels)
accuracy = train_accuracy.result()
```
Wenn Sie mit der Vorbereitung Ihres Trainingsskripts fertig sind, fahren Sie zu [Schritt 2: Starten Sie einen Trainingsjob mit dem SageMaker Python-SDK](model-parallel-sm-sdk.md) fort. Wenn Sie einen hybriden Modell- und Datenparallel-Trainingsjob ausführen möchten, fahren Sie mit dem nächsten Abschnitt fort.
## Automatisiertes Splitten mit TensorFlow und Horovod für Hybridmodell und Datenparallelität
Sie können die SageMaker Modellparallelitätsbibliothek mit Horovod für Hybridmodell- und Datenparallelität verwenden. Weitere Informationen darüber, wie die Bibliothek ein Modell für hybride Parallelität aufteilt, finden Sie unter [PyTorch TensorFlowPipeline-Parallelität (verfügbar für und)](model-parallel-intro.md#model-parallel-intro-pp).
In diesem Schritt konzentrieren wir uns darauf, wie Sie Ihr Trainingsskript modifizieren können, um die Modellparallelitätsbibliothek anzupassen. SageMaker
Um Ihr Trainingsskript so einzurichten, dass es die Konfiguration der Hybrid-Parallelität, die Sie in [Schritt 2: Starten Sie einen Trainingsjob mit dem SageMaker Python-SDK](model-parallel-sm-sdk.md) einrichten werden, übernimmt, verwenden Sie die Hilfsfunktionen `smp.dp_rank()` und `smp.mp_rank()` der Bibliothek, die automatisch den parallel Datenrang bzw. den parallel Modellrang erkennen.
Informationen zu allen MPI-Primitiven, die die Bibliothek unterstützt, finden Sie unter [MPI Basics](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#mpi-basics) in der SageMaker Python SDK-Dokumentation.
Die erforderlichen Änderungen im Skript sind:
+ Hinzufügen von `hvd.allreduce`
+ Übertragung von Variablen nach dem ersten Batch, wie von Horovod gefordert
+ and/or Sharding-Sharding-Operationen in der Datenpipeline starten mit. `smp.dp_rank()`
**Anmerkung**
Wenn Sie Horovod verwenden, dürfen Sie Ihr Trainingsskript nicht direkt `hvd.init` aufrufen. Stattdessen müssen Sie `True` in den SageMaker `modelparallel` Python-SDK-Parametern unter auf einstellen[Schritt 2: Starten Sie einen Trainingsjob mit dem SageMaker Python-SDK](model-parallel-sm-sdk.md). `"horovod"` Dadurch kann die Bibliothek Horovod auf der Grundlage der Gerätezuweisungen der Modellpartitionen intern initialisieren. Direktes Aufrufen von `hvd.init()` in Ihrem Trainingsskript kann zu Problemen führen.
**Anmerkung**
Die Verwendung der `hvd.DistributedOptimizer`-API direkt in Ihrem Trainingsskript kann zu einer schlechten Trainingsleistung und -geschwindigkeit führen, da die API die `AllReduce`-Operation implizit in `smp.step` platziert. Wir empfehlen Ihnen, die Modellparallelismus-Bibliothek mit Horovod zu verwenden, indem Sie direkt `hvd.allreduce` nach dem Aufruf `accumulate()` oder `reduce_mean()` auf den zurückgegebenen Gradienten von `smp.step` aufrufen, wie im folgenden Beispiel gezeigt wird.
Weitere Informationen zur API SageMaker der Modellparallelismus-Bibliothek finden Sie in der [API-Dokumentation](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html).
```
import tensorflow as tf
import horovod.tensorflow as hvd
# smdistributed: Import TF2.x API
import smdistributed.modelparallel.tensorflow as smp
# smdistributed: Initialize
smp.init()
# Download and load MNIST dataset.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(
"MNIST-data-%d" % smp.rank()
)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
# smdistributed: Seed the shuffle with smp.dp_rank(), and drop_remainder
# in batching to make sure batch size is always divisible by number of microbatches
train_ds = (
tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10000, seed=smp.dp_rank())
.batch(256, drop_remainder=True)
)
# smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API
class MyModel(smp.DistributedModel):
def __init__(self):
super(MyModel, self).__init__()
# define layers
def call(self, x, training=None):
# define forward pass and return model outputs
model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy")
# smdistributed: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(images, labels):
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
grads = optimizer.get_gradients(loss, model.trainable_variables)
return grads, loss, predictions
@tf.function
def train_step(images, labels, first_batch):
gradients, loss, predictions = get_grads(images, labels)
# smdistributed: Accumulate the gradients across microbatches
# Horovod: AllReduce the accumulated gradients
gradients = [hvd.allreduce(g.accumulate()) for g in gradients]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# Horovod: Broadcast the variables after first batch
if first_batch:
hvd.broadcast_variables(model.variables, root_rank=0)
hvd.broadcast_variables(optimizer.variables(), root_rank=0)
# smdistributed: Merge predictions across microbatches
train_accuracy(labels, predictions.merge())
return loss.reduce_mean()
for epoch in range(5):
# Reset the metrics at the start of the next epoch
train_accuracy.reset_states()
for batch, (images, labels) in enumerate(train_ds):
loss = train_step(images, labels, tf.constant(batch == 0))
```
## Manuelles Teilen mit TensorFlow
Verwenden Sie `smp.partition` Kontextmanager, um Operationen in einer bestimmten Partition zu platzieren. Jede Operation, die nicht in einem `smp.partition` Kontext steht, wird in der `default_partition` platziert. [Weitere Informationen zur API SageMaker der Modellparallelismus-Bibliothek finden Sie in der API-Dokumentation.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html)
```
import tensorflow as tf
# smdistributed: Import TF2.x API.
import smdistributed.modelparallel.tensorflow as smp
# smdistributed: Initialize
smp.init()
# Download and load MNIST dataset.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(
"MNIST-data-%d" % smp.rank()
)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
# smdistributed: If needed, seed the shuffle with smp.dp_rank(), and drop_remainder
# in batching to make sure batch size is always divisible by number of microbatches.
train_ds = (
tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10000, seed=smp.dp_rank())
.batch(256, drop_remainder=True)
)
# smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API.
class MyModel(smp.DistributedModel):
def __init__(self):
# define layers
def call(self, x):
with smp.partition(0):
x = self.layer0(x)
with smp.partition(1):
return self.layer1(x)
model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy")
# smdistributed: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(images, labels):
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
grads = optimizer.get_gradients(loss, model.trainable_variables)
return grads, loss, predictions
@tf.function
def train_step(images, labels):
gradients, loss, predictions = get_grads(images, labels)
# smdistributed: Accumulate the gradients across microbatches
gradients = [g.accumulate() for g in gradients]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# smdistributed: Merge predictions and average losses across microbatches
train_accuracy(labels, predictions.merge())
return loss.reduce_mean()
for epoch in range(5):
# Reset the metrics at the start of the next epoch
train_accuracy.reset_states()
for images, labels in train_ds:
loss = train_step(images, labels)
accuracy = train_accuracy.result()
```
## Nicht unterstützte Framework-Funktionen
Die folgenden TensorFlow Funktionen werden von der Bibliothek nicht unterstützt:
+ `tf.GradientTape()` wird derzeit nicht unterstützt. Sie können stattdessen `Optimizer.get_gradients()` oder `Optimizer.compute_gradients()` verwenden, um Gradienten zu berechnen.
+ Derzeit wird die `tf.train.Checkpoint.restore()`-API nicht unterstützt. Verwenden Sie für Checkpointing `smp.CheckpointManager` stattdessen, das dieselbe API und Funktionalität bietet. Beachten Sie, dass Checkpoint-Wiederherstellungen mit `smp.CheckpointManager` nach dem ersten Schritt erfolgen sollten.
# Ein PyTorch Trainingsskript ändern
In diesem Abschnitt erfahren Sie, wie Sie PyTorch Trainingsskripte ändern, um die SageMaker Modellparallelitätsbibliothek für automatische Partitionierung und manuelle Partitionierung zu konfigurieren.
**Anmerkung**
Informationen darüber, welche PyTorch Versionen von der Bibliothek unterstützt werden, finden Sie unter. [Unterstützte Frameworks und AWS-Regionen](distributed-model-parallel-support.md)
**Tipp**
end-to-endNotebook-Beispiele, die veranschaulichen, wie ein PyTorch Trainingsskript mit der SageMaker Modellparallelitätsbibliothek verwendet wird, finden Sie unter. [Beispiele für die Amazon SageMaker AI-Modellparallelismusbibliothek v1](distributed-model-parallel-examples.md)
Beachten Sie, dass die automatische Partitionierung standardmäßig aktiviert ist. Sofern nicht anders angegeben, verwenden die folgenden Skripten automatische Partitionierung.
**Topics**
+ [Automatisiertes Teilen mit PyTorch](#model-parallel-customize-training-script-pt-16)
+ [Manuelles Teilen mit PyTorch](#model-parallel-customize-training-script-pt-16-hvd)
+ [Überlegungen](#model-parallel-pt-considerations)
+ [Nicht unterstützte Framework-Funktionen](#model-parallel-pt-unsupported-features)
## Automatisiertes Teilen mit PyTorch
Die folgenden Änderungen am Trainingsskript sind erforderlich, um ein PyTorch Trainingsskript mit SageMaker der Modellparallelismus-Bibliothek auszuführen:
1. Importieren und initialisieren Sie die Bibliothek mit [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init).
1. Schließen Sie das Modell mit [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedModel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedModel) um. Beachten Sie, dass alle Tensoren, die von der `forward` Methode des zugrunde liegenden `nn.Module` Objekts zurückgegeben werden, über modellparallele Geräte übertragen werden, was zu Kommunikationsaufwand führt. Daher sollten alle Tensoren, die außerhalb der Aufrufmethode nicht benötigt werden (z. B. Zwischenaktivierungen), nicht zurückgegeben werden.
**Anmerkung**
Für das FP16 Training müssen Sie den Kontextmanager [smdistributed.modelparallel.torch.model\$1creation](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html) () verwenden, um das Modell zu umschließen. Weitere Informationen finden Sie unter [FP16 Training mit Modellparallelität](model-parallel-extended-features-pytorch-fp16.md).
1. Umschließen Sie den Optimierer mit [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer).
**Anmerkung**
Für das Training müssen Sie eine statische oder dynamische Verlustskalierung einrichten FP16 . Weitere Informationen finden Sie unter [FP16 Training mit Modellparallelität](model-parallel-extended-features-pytorch-fp16.md).
1. Verwenden Sie das zurückgegebene `DistributedModel` Objekt anstelle eines Benutzermodells.
1. Fügen Sie die Vorwärts- und Rückwärtslogik in eine Schrittfunktion ein und dekorieren Sie sie mit [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init).
1. Beschränken Sie jeden Prozess auf sein eigenes Gerät durch `torch.cuda.set_device(smp.local_rank())`.
1. Verschieben Sie die Eingangstensoren mithilfe der `.to()` API vor dem `smp.step` Aufruf auf die GPU (siehe Beispiel unten).
1. Ersetzen Sie `torch.Tensor.backward` und `torch.autograd.backward` mit `DistributedModel.backward`.
1. Führen Sie die Nachbearbeitung der Ausgaben für alle Mikrobatches mithilfe von [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput) Methoden wie `reduce_mean` durch.
1. Wenn es einen Bewertungsschritt gibt, platzieren Sie die Vorwärtslogik auf ähnliche Weise in einer mit -`smp.step`dekorierten Funktionen und bearbeiten Sie die Ausgaben mithilfe der [`StepOutput`API](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput) nach.
1. `drop_last=True` in `DataLoader` einstellen. Alternativ können Sie einen Stapel in der Trainingsschleife manuell überspringen, wenn die Batchgröße nicht durch die Anzahl der Mikrobatches teilbar ist.
Weitere Informationen zur API SageMaker der Modellparallelismus-Bibliothek finden Sie in der [API-Dokumentation](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html).
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class GroupedNet(nn.Module):
def __init__(self):
super(GroupedNet, self).__init__()
# define layers
def forward(self, x):
# define forward pass and return model outputs
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by the current process,
# based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
dataset = datasets.MNIST("../data", train=True, download=False)
# smdistributed: Shard the dataset based on data-parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = GroupedNet()
optimizer = optim.Adadelta(model.parameters(), lr=4.0)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Manuelles Teilen mit PyTorch
Verwenden Sie [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer) Kontextmanager, um Module auf bestimmten Geräten zu platzieren. Jedes Modul, das sich nicht in einem `smp.partition` Kontext befindet, wird in den `default_partition` platziert. Das `default_partition` muss angegeben werden, wenn `auto_partition` auf `False` gesetzt ist. Die Module, die in einem bestimmten `smp.partition` Kontext erstellt werden, werden auf der entsprechenden Partition platziert.
[Weitere Informationen zur API SageMaker der Modellparallelismus-Bibliothek finden Sie in der API-Dokumentation.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html)
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class GroupedNet(nn.Module):
def __init__(self):
super(GroupedNet, self).__init__()
with smp.partition(0):
# define child modules on device 0
with smp.partition(1):
# define child modules on device 1
def forward(self, x):
# define forward pass and return model outputs
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by the current process,
# based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
dataset = datasets.MNIST("../data", train=True, download=False)
# smdistributed: Shard the dataset based on data-parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = GroupedNet()
optimizer = optim.Adadelta(model.parameters(), lr=4.0)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Überlegungen
Wenn Sie ein PyTorch Trainingsskript mithilfe SageMaker der Modellparallelismus-Bibliothek konfigurieren, sollten Sie Folgendes beachten:
+ Wenn Sie eine Optimierungstechnik verwenden, die auf globalen Gradientennormen basiert, z. B. der Gradientennorm aus dem gesamten Modell, wie z. B. einige Varianten des LAMB-Optimizers oder des globalen Gradientenclippings, müssen Sie alle Normen aus den Modellpartitionen zusammenstellen, um ihre Richtigkeit zu überprüfen. Zu diesem Zweck können Sie die grundlegenden Kommunikationsdatentypen der Bibliothek verwenden.
+ Alle `torch.Tensor` Argumente für die Vorwärtsmethoden von `nn.Modules` in Ihrem Modell müssen bei der Berechnung der Modulausgabe verwendet werden. Mit anderen Worten, die Bibliothek unterstützt nicht den Fall, dass es ein `torch.Tensor` Argument für ein Modul gibt, von dem die Modulausgabe nicht abhängt.
+ Das Argument für den `smp.DistributedModel.backward()` Aufruf muss von allen Modellausgaben abhängen. Mit anderen Worten, es darf keine Ausgabe des `smp.DistributedModel.forward` Aufrufs geben, die nicht bei der Berechnung des Tensors verwendet wird, der in den `smp.DistributedModel.backward` Aufruf eingespeist wird.
+ Wenn Ihr Code `torch.cuda.synchronize()` Aufrufe enthält, müssen Sie möglicherweise `torch.cuda.set_device(smp.local_rank())` unmittelbar vor dem Synchronisierungsaufruf anrufen. Andernfalls könnten in Gerät 0 unnötige CUDA-Kontexte erstellt werden, die unnötig Speicherplatz verbrauchen.
+ Da sich die Bibliothek `nn.Modules` auf unterschiedlichen Geräten befindet, dürfen die Module im Modell nicht von einem globalen Status abhängen, der im Inneren von `smp.step` geändert wird. Jeder Status, der während des gesamten Trainings unverändert bleibt oder außerhald von `smp.step` so verändert wird, dass er für alle Prozesse sichtbar ist, ist zulässig.
+ Sie müssen das Modell nicht auf die GPU verschieben (z. B. verwenden von `model.to(device)`), wenn Sie die Bibliothek verwenden. Wenn Sie versuchen, das Modell auf die GPU zu verschieben, bevor das Modell partitioniert wurde (vor dem ersten `smp.step` Aufruf), wird der Move-Aufruf ignoriert. Die Bibliothek verschiebt den Teil des Modells, der einem Rang zugewiesen wurde, automatisch auf ihre GPU. Sobald das Training mit der Bibliothek begonnen hat, sollten Sie das Modell nicht auf die CPU verschieben und es verwenden, da es sonst keine korrekten Parameter für Module enthält, die nicht der vom Prozess gespeicherten Partition zugewiesen sind. Wenn Sie ein Modell neu trainieren oder es ohne die Bibliothek für Inferenz verwenden möchten, nachdem es mit der Modellparallelismus-Bibliothek trainiert wurde, empfiehlt es sich, das vollständige Modell mithilfe unserer Checkpoint-API zu speichern und es wieder in ein reguläres Modul zu laden. PyTorch
+ Wenn Sie eine Liste von Modulen haben, bei denen die Ausgabe eines Moduls in ein anderes einfließen kann, kann das Ersetzen dieser Liste durch die Leistung erheblich verbessern. `nn.Sequential`
+ Das Gewichtsupdate (`optimizer.step()`) muss außerhalb von `smp.step` erfolgen, da dann der gesamte Rückwärtsdurchlauf abgeschlossen ist und die Farbverläufe bereit sind. Wenn Sie ein Hybridmodell mit Modell- und Datenparallelität verwenden, ist zu diesem Zeitpunkt auch garantiert, dass die Gradienten beendet AllReduce sind.
+ Wenn Sie die Bibliothek in Kombination mit Datenparallelität verwenden, stellen Sie sicher, dass die Anzahl der Batches auf allen datenparallelen Rängen gleich ist, damit Sie AllReduce nicht auf einen Rang warten, der nicht am Schritt teilnimmt.
+ Wenn Sie einen Trainingsjob mit einem ml.p4d-Instance-Typ (z. B. ml.p4d.24xlarge) starten, müssen Sie die Dataloader-Variable `num_workers=0` festlegen. Sie können `DataLoader` Ihren beispielsweise wie folgt definieren:
```
dataloader = torch.utils.data.DataLoader(
data,
batch_size=batch_size,
num_workers=0,
pin_memory=True,
drop_last=True,
shuffle=shuffle,
)
```
+ Die Eingaben für `smp.step` müssen die Modelleingaben sein, die von `DataLoader` generiert wurden. Der Grund dafür ist, dass `smp.step` die Eingabetensoren intern entlang der Stapeldimension aufteilt und sie in eine Pipeline einfügt. Dies bedeutet, dass es nicht funktioniert, `DataLoader` sich selbst an die `smp.step` Funktion zur Generierung der darin enthaltenen Modelleingaben zu übergeben.
Wenn Sie beispielsweise a `DataLoader` wie folgt definieren:
```
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
```
Sie sollten auf die Modelleingaben zugreifen, die von generiert wurden, `train_loader` und diese an eine `smp.step` dekorierte Funktion übergeben. Übergeben Sie `train_loader` nicht direkt an die `smp.step` Funktion.
```
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
...
_, loss_mb = train_step(model, data, target)
...
@smp.step
def train_step(model, data, target):
...
return output, loss
```
+ Die Eingangstensoren für `smp.step` müssen mithilfe der `.to()` API auf das aktuelle Gerät verschoben werden, was nach dem `torch.cuda.set_device(local_rank())` Aufruf erfolgen muss.
Sie können z. B. wie folgt die Funktion `train` definieren. Diese Funktion fügt dem aktuellen Gerät mithilfe der `.to()` API `data` und `target` hinzu, bevor diese Eingangstensoren zum Aufrufen von `train_step` verwendet werden.
```
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by the current process,
# based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
```
Die Eingangstensoren für diese `smp.set` dekorierte Funktion wurden in der obigen `train` Funktion auf das aktuelle Gerät verschoben. Das Modell muss *nicht* auf das aktuelle Gerät verschoben werden. Die Bibliothek verschiebt den Teil des Modells, der einem Rang zugewiesen ist, automatisch auf ihre GPU.
```
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
```
## Nicht unterstützte Framework-Funktionen
Die folgenden PyTorch Funktionen werden von der Modellparallelitätsbibliothek nicht unterstützt SageMaker:
+ Wenn Sie Datenparallelität mit dem nativen [PyTorch DDP](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html) verwenden, wird das [https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html)Wrapper-Modul von der Bibliothek nicht unterstützt. Die Bibliothek verwaltet intern die Integration mit PyTorch DDP, einschließlich Parameterübertragung und Gradient. AllReduce Bei Verwendung der Bibliothek werden Modulpuffer zu Beginn des Trainings nur einmal übertragen. Wenn Ihr Modell über Modulpuffer verfügt, die bei jedem Schritt über datenparallele Gruppen hinweg synchronisiert werden müssen, können Sie dies über die `torch.distributed` API tun, indem Sie die Prozessgruppe verwenden, die über `smp.get_dp_process_group()` abgerufen werden kann.
+ Für gemischtes Präzisionstraining wird das `apex.amp` Modul nicht unterstützt. Es wird empfohlen, die Bibliothek mit automatischer Mixed-Precision `torch.cuda.amp` zu verwenden, mit der Ausnahme, dass `smp.amp.GradScaler` anstelle der Implementierung in Torch verwendet wird.
+ `torch.jit.ScriptModules` und `ScriptFunctions` werden von `smp.DistributedModel` nicht unterstützt.
+ `apex` : `FusedLayerNorm`, `FusedAdam` `FusedLAMB`, und `FusedNovoGrad` von `apex` werden nicht unterstützt. Sie können stattdessen deren Bibliotheksimplementierungen über `smp.optimizers` und `smp.nn` APIs verwenden.
# Schritt 2: Starten Sie einen Trainingsjob mit dem SageMaker Python-SDK
Das SageMaker Python-SDK unterstützt das verwaltete Training von Modellen mit ML-Frameworks wie TensorFlow und PyTorch. Um einen Trainingsjob mit einem dieser Frameworks zu starten, definieren Sie einen Schätzer, einen SageMaker [TensorFlow Schätzer](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) oder einen SageMaker generischen SageMaker [PyTorch [Schätzer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/estimators.html#sagemaker.estimator.Estimator)](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator), um das modifizierte Trainingsskript und die Konfiguration der Modellparallelität zu verwenden.
**Topics**
+ [PyTorch Verwenden Sie die und Estimators SageMaker TensorFlow](#model-parallel-using-sagemaker-pysdk)
+ [Erweitern Sie einen vorgefertigten Docker-Container, der die SageMaker Distributed Model Parallel Library enthält](#model-parallel-customize-container)
+ [Erstellen Sie Ihren eigenen Docker-Container mit der SageMaker Distributed Model Parallel Library](#model-parallel-bring-your-own-container)
## PyTorch Verwenden Sie die und Estimators SageMaker TensorFlow
Die Klassen TensorFlow und PyTorch Estimator enthalten den `distribution` Parameter, mit dem Sie Konfigurationsparameter für die Verwendung verteilter Trainings-Frameworks angeben können. Die SageMaker Modellparallelbibliothek verwendet intern MPI für Hybriddaten und Modellparallelität, daher müssen Sie die MPI-Option mit der Bibliothek verwenden.
Die folgende Vorlage eines TensorFlow PyTorch OR-Schätzers zeigt, wie der `distribution` Parameter für die Verwendung der SageMaker Modellparallelbibliothek mit MPI konfiguriert wird.
------
#### [ Using the SageMaker TensorFlow estimator ]
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
smp_options = {
"enabled":True, # Required
"parameters": {
"partitions": 2, # Required
"microbatches": 4,
"placement_strategy": "spread",
"pipeline": "interleaved",
"optimize": "speed",
"horovod": True, # Use this for hybrid model and data parallelism
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8, # Required
# "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none"
}
smd_mp_estimator = TensorFlow(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.p3.16xlarge',
framework_version='2.6.3',
py_version='py38',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
------
#### [ Using the SageMaker PyTorch estimator ]
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled":True,
"parameters": { # Required
"pipeline_parallel_degree": 2, # Required
"microbatches": 4,
"placement_strategy": "spread",
"pipeline": "interleaved",
"optimize": "speed",
"ddp": True,
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8, # Required
# "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none"
}
smd_mp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.p3.16xlarge',
framework_version='1.13.1',
py_version='py38',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
------
Um die Bibliothek zu aktivieren, müssen Sie über das `distribution` Argument der Estimator-Konstruktoren Konfigurationswörterbücher an die `"mpi"` Schlüssel `"smdistributed"` und übergeben. SageMaker
**Konfigurationsparameter für Modellparallelität SageMaker**
+ Übergeben Sie für den `"smdistributed"` Schlüssel ein Wörterbuch mit dem `"modelparallel"` Schlüssel und den folgenden inneren Wörterbüchern.
**Anmerkung**
Die Verwendung von `"modelparallel"` und `"dataparallel"` in einem Trainingsjob wird nicht unterstützt.
+ `"enabled"` – Erforderlich. Um die Modellparallelität zu aktivieren, legen Sie `"enabled": True` fest.
+ `"parameters"` – Erforderlich. Geben Sie eine Reihe von Parametern für die SageMaker Modellparallelität an.
+ Eine vollständige Liste der allgemeinen Parameter finden Sie unter [Parameter für `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters) in der *SageMaker Python SDK-Dokumentation*.
Weitere Informationen finden Sie unter [TensorFlow-spezifische Parameter](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#tensorflow-specific-parameters). TensorFlow
Weitere Informationen finden Sie unter [PyTorch-spezifische Parameter](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#pytorch-specific-parameters). PyTorch
+ `"pipeline_parallel_degree"` (oder `"partitions"` in `smdistributed-modelparallel
Um einen vorgefertigten Container zu erweitern und die Modellparallelitätsbibliothek zu verwenden SageMaker, müssen Sie eines der verfügbaren AWS Deep Learning Containers (DLC) -Images für oder verwenden. PyTorch TensorFlow Die SageMaker Modellparallelitätsbibliothek ist in den DLC-Images TensorFlow (2.3.0 und höher) und (1.6.0 und höher) mit CUDA PyTorch () enthalten. `cuxyz` Eine vollständige Liste der DLC-Images finden Sie unter [Verfügbare Deep Learning Containers Learning-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) im *AWS Deep Learning Containers GitHub Container-Repository*.
**Tipp**
Wir empfehlen, das Image zu verwenden, das die neueste Version der Modellparallelismus-Bibliothek enthält PyTorch , TensorFlow oder um auf die meisten up-to-date Versionen der SageMaker Modellparallelismus-Bibliothek zuzugreifen.
Ihr Dockerfile sollte beispielsweise eine `FROM` Anweisung wie die folgende enthalten:
```
# Use the SageMaker DLC image URI for TensorFlow or PyTorch
FROM aws-dlc-account-id.dkr.ecr.aws-region.amazonaws.com/framework-training:{framework-version-tag}
# Add your dependencies here
RUN ...
ENV PATH="/opt/ml/code:${PATH}"
# this environment variable is used by the SageMaker AI container to determine our user code directory.
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code
```
Wenn Sie einen PyTorch TensorFlow Oder-Schätzer definieren, müssen Sie außerdem angeben, dass der `entry_point` für Ihr Trainingsskript gilt. Dies sollte derselbe Pfad sein, der in Ihrem Dockerfile mit `ENV SAGEMAKER_SUBMIT_DIRECTORY` angegeben ist.
**Tipp**
Sie müssen diesen Docker-Container an Amazon Elastic Container Registry (Amazon ECR) übertragen und mithilfe der Image-URI (`image_uri`) einen SageMaker Schätzer für das Training definieren. Weitere Informationen finden Sie unter [Erweitern eines vorgefertigten Containers](prebuilt-containers-extend.md).
Nachdem Sie das Hosten des Docker-Containers und das Abrufen der Image-URI des Containers abgeschlossen haben, erstellen Sie wie folgt ein SageMaker `PyTorch` Estimator-Objekt. In diesem Beispiel wird davon ausgegangen, dass Sie bereits `smp_options` und `mpi_options` definiert haben.
```
smd_mp_estimator = Estimator(
entry_point="your_training_script.py",
role=sagemaker.get_execution_role(),
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
image_uri='your_aws_account_id.dkr.ecr.region.amazonaws.com/name:tag'
instance_count=1,
distribution={
"smdistributed": smp_options,
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Erstellen Sie Ihren eigenen Docker-Container mit der SageMaker Distributed Model Parallel Library
Um Ihren eigenen Docker-Container für das Training zu erstellen und die SageMaker Model Parallel Library zu verwenden, müssen Sie die richtigen Abhängigkeiten und die Binärdateien der SageMaker verteilten parallel Bibliotheken in Ihr Dockerfile aufnehmen. Dieser Abschnitt enthält die Mindestmenge an Codeblöcken, die Sie hinzufügen müssen, um eine SageMaker Trainingsumgebung und die Modellparallelbibliothek in Ihrem eigenen Docker-Container ordnungsgemäß vorzubereiten.
**Anmerkung**
Diese benutzerdefinierte Docker-Option mit der SageMaker Modellparallelbibliothek als Binärdatei ist nur für PyTorch verfügbar.
**Um ein Dockerfile mit dem SageMaker Training Toolkit und der Model Parallel Library zu erstellen**
1. Beginnen Sie mit einem der [NVIDIA CUDA-Basisimages](https://hub.docker.com/r/nvidia/cuda).
```
FROM
```
**Tipp**
Die offiziellen AWS Deep Learning Container (DLC) -Images werden aus den [NVIDIA](https://hub.docker.com/r/nvidia/cuda) CUDA-Basisimages erstellt. Wir empfehlen Ihnen, in den [offiziellen Dockerfiles von AWS Deep Learning Container nachzuschauen PyTorch](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker), welche Versionen der Bibliotheken Sie installieren müssen und wie sie konfiguriert werden. Die offiziellen Dockerfiles sind vollständig, wurden auf Benchmarks getestet und werden von den Serviceteams SageMaker und Deep Learning Container verwaltet. Wählen Sie unter dem bereitgestellten Link die PyTorch Version aus, die Sie verwenden, wählen Sie den Ordner CUDA (`cuxyz`) und wählen Sie die Dockerfile, die mit oder endet. `.gpu` `.sagemaker.gpu`
1. Um eine verteilte Trainingsumgebung einzurichten, müssen Sie Software für Kommunikations- und Netzwerkgeräte wie [Elastic Fabric Adapter (EFA)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html), [NVIDIA Collective Communications Library (NCCL)](https://developer.nvidia.com/nccl) und [Open MPI installieren](https://www.open-mpi.org/). Abhängig von der ausgewählten Version PyTorch und der CUDA-Version müssen Sie kompatible Versionen der Bibliotheken installieren.
**Wichtig**
Da die SageMaker Modellparallelbibliothek die SageMaker Datenparallelbibliothek in den nachfolgenden Schritten benötigt, empfehlen wir dringend, dass Sie die Anweisungen unter befolgen, [Erstellen Sie Ihren eigenen Docker-Container mit der SageMaker AI Distributed Data Parallel Library](data-parallel-bring-your-own-container.md) um eine SageMaker Trainingsumgebung für verteiltes Training ordnungsgemäß einzurichten.
Weitere Informationen zur Einrichtung von EFA mit NCCL und Open MPI finden Sie unter [Erste Schritte mit EFA und MPI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html) und [Erste Schritte mit EFA und NCCL.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start-nccl.html)
1. Fügen Sie die folgenden Argumente hinzu, um die URLs SageMaker verteilten Trainingspakete für anzugeben PyTorch. Für die SageMaker Modellparallelbibliothek muss die SageMaker Datenparallelbibliothek den knotenübergreifenden Remote Direct Memory Access (RDMA) verwenden.
```
ARG SMD_MODEL_PARALLEL_URL=https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.10.0/build-artifacts/2022-02-21-19-26/smdistributed_modelparallel-1.7.0-cp38-cp38-linux_x86_64.whl
ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.10.2/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
```
1. Installieren Sie Abhängigkeiten, die für die SageMaker Model Parallel Library erforderlich sind.
1. Installieren Sie die [METIS](http://glaros.dtc.umn.edu/gkhome/metis/metis/overview)-Bibliothek.
```
ARG METIS=metis-5.1.0
RUN rm /etc/apt/sources.list.d/* \
&& wget -nv http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/${METIS}.tar.gz \
&& gunzip -f ${METIS}.tar.gz \
&& tar -xvf ${METIS}.tar \
&& cd ${METIS} \
&& apt-get update \
&& make config shared=1 \
&& make install \
&& cd .. \
&& rm -rf ${METIS}.tar* \
&& rm -rf ${METIS} \
&& rm -rf /var/lib/apt/lists/* \
&& apt-get clean
```
1. Installieren Sie die [RAPIDS Memory Manager-Bibliothek](https://github.com/rapidsai/rmm#rmm-rapids-memory-manager). Dies erfordert [CMake](https://cmake.org/)3.14 oder höher.
```
ARG RMM_VERSION=0.15.0
RUN wget -nv https://github.com/rapidsai/rmm/archive/v${RMM_VERSION}.tar.gz \
&& tar -xvf v${RMM_VERSION}.tar.gz \
&& cd rmm-${RMM_VERSION} \
&& INSTALL_PREFIX=/usr/local ./build.sh librmm \
&& cd .. \
&& rm -rf v${RMM_VERSION}.tar* \
&& rm -rf rmm-${RMM_VERSION}
```
1. Installieren Sie die SageMaker Modellparallelbibliothek.
```
RUN pip install --no-cache-dir -U ${SMD_MODEL_PARALLEL_URL}
```
1. Installieren Sie die SageMaker Data Parallel Library.
```
RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY}
```
1. Installieren Sie das [Sagemaker-Training-Toolkit](https://github.com/aws/sagemaker-training-toolkit). Das Toolkit enthält die allgemeinen Funktionen, die zur Erstellung eines Containers erforderlich sind, der mit der SageMaker Trainingsplattform und dem SageMaker Python-SDK kompatibel ist.
```
RUN pip install sagemaker-training
```
1. Wenn Sie mit der Erstellung des Dockerfiles fertig sind, erfahren Sie unter [Anpassen Ihres eigenen Trainingscontainers](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html), wie Sie den Docker-Container erstellen und in Amazon ECR hosten.
**Tipp**
Allgemeinere Informationen zum Erstellen eines benutzerdefinierten Dockerfiles für das Training in SageMaker KI finden Sie unter [Verwenden Sie Ihre eigenen](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html) Trainingsalgorhythmen.
# Überprüfung und Feinabstimmung eines Modells mit Modellparallelität
Die SageMaker Modellparallelitätsbibliothek bietet Checkpoints APIs zum Speichern des Modellstatus und des Optimiererstatus, aufgeteilt nach den verschiedenen Modellparallelismus-Strategien, und zum Laden von Checkpoints für kontinuierliches Training, von denen aus Sie das Training erneut starten und die Feinabstimmung vornehmen möchten. Sie unterstützen APIs auch Optionen zum teilweisen oder vollständigen Speichern des Modells und des Optimizerstatus.
**Topics**
+ [Überprüfung eines verteilten Modells](#distributed-model-parallel-checkpoint)
+ [Feinabstimmung eines verteilten Modells](#distributed-model-parallel-fine-tuning)
## Überprüfung eines verteilten Modells
Wählen Sie je nach Framework zwischen PyTorch und TensorFlow und der Version der verwendeten SageMaker Modellparallelitätsbibliothek eines der folgenden Themen aus.
**Topics**
+ [Checkpointing für ein verteiltes PyTorch Modell (für die SageMaker Modellparallelismus-Bibliothek v1.10.0 und höher)](#model-parallel-extended-features-pytorch-checkpoint)
+ [Checkpointing für ein verteiltes PyTorch Modell (für die SageMaker Modellparallelitätsbibliothek zwischen v1.6.0 und v1.9.0)](#model-parallel-extended-features-pytorch-saving-loading-checkpoints)
+ [Checkpoints für ein verteiltes Modell TensorFlow](#distributed-model-parallel-checkpoint-tensorflow)
### Checkpointing für ein verteiltes PyTorch Modell (für die SageMaker Modellparallelismus-Bibliothek v1.10.0 und höher)
Die SageMaker Modellparallelitätsbibliothek bietet Checkpoints APIs zum Speichern und Laden vollständiger oder teilweiser Checkpoints des verteilten Modellstatus und seines Optimierungsstatus.
**Anmerkung**
Diese Checkpoint-Methode wird empfohlen, wenn Sie die SageMaker Modellparallelismus-Bibliothek PyTorch v1.10.0 oder höher verwenden.
**Teilweises Checkpointing**
Um Checkpoints eines mit Modellparallelität trainierten Modells zu speichern, verwenden Sie die [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save_checkpoint](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save_checkpoint)API, wobei die Option für partielles Checkpointing auf true (`partial=True`) gesetzt ist. Dadurch wird jede Modellpartition einzeln gespeichert. Neben dem Modell und dem Status des Optimierers können Sie mit dem `user_content` Argument auch alle zusätzlichen benutzerdefinierten Daten speichern. Das Prüfpunktmodell, der Optimierer und der Benutzerinhalt werden als separate Dateien gespeichert. Der `save_checkpoint` API-Aufruf erstellt Checkpoint-Ordner in der folgenden Struktur.
```
- path
- ${tag}_partial (folder for partial checkpoints)
- model_rankinfo.pt
- optimizer_rankinfo.pt
- fp16_states_rankinfo.pt
- user_content.pt
- $tag (checkpoint file for full checkpoints)
- user_content_$tag (user_content file for full checkpoints)
- newest (a file that indicates the newest checkpoint)
```
Um das Training von partiellen Checkpoints aus fortzusetzen, verwenden Sie die [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.resume_from_checkpoint](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.resume_from_checkpoint)-API mit `partial=True` und geben Sie das Checkpoint-Verzeichnis und das Tag an, das beim Speichern der partiellen Checkpoints verwendet wurde. Beachten Sie, dass das tatsächliche Laden der Modellgewichte nach der Modellpartitionierung erfolgt, also während des ersten Durchlaufs der Trainingsschrittfunktion mit `smdistributed.modelparallel.torch.step` -dekoriertem Dekor.
Beim Speichern eines partiellen Checkpoints speichert die Bibliothek auch die Entscheidung für die Modellpartition als Datei mit der `.pt` Dateierweiterung. Umgekehrt lädt die Bibliothek die Partitionsentscheidungsdateien zusammen, wenn der Vorgang vom partiellen Checkpoint aus fortgesetzt wird. Sobald die Partitionsentscheidung geladen ist, können Sie die Partition nicht mehr ändern.
Der folgende Codeausschnitt zeigt, wie der Checkpoint in einem Trainingsskript festgelegt wird. APIs PyTorch
```
import smdistributed.modelparallel.torch as smp
model = ...
model = smp.DistributedModel(model)
optimizer = ...
optimizer = smp.DistributedOptimizer(optimizer)
user_content = ... # additional custom data
checkpoint_path = "/opt/ml/checkpoint/model_parallel"
# Save a checkpoint.
smp.save_checkpoint(
path=checkpoint_path,
tag=f"total_steps{total_steps}",
partial=True,
model=model,
optimizer=optimizer,
user_content=user_content
num_kept_partial_checkpoints=5
)
# Load a checkpoint.
# This automatically loads the most recently saved checkpoint.
smp_checkpoint = smp.resume_from_checkpoint(
path=checkpoint_path,
partial=True
)
```
**Vollständiges Checkpointing**
Um das endgültige Modellartefakt für Inferenzzwecke zu speichern, verwenden Sie die `smdistributed.modelparallel.torch.save_checkpoint` API mit `partial=False`, die die Modellpartitionen zu einem einzigen Modellartefakt kombiniert. Beachten Sie, dass die Zustände des Optimierers dabei nicht kombiniert werden.
Um das Training mit bestimmten Gewichten zu initialisieren, können Sie bei einem vollständigen Modell-Checkpoint die `smdistributed.modelparallel.torch.resume_from_checkpoint` API mit `partial=False` verwenden. Beachten Sie, dass dadurch keine Optimizer-Status geladen werden.
**Anmerkung**
Bei der Tensor-Parallelität muss das `state_dict` im Allgemeinen zwischen der ursprünglichen Modellimplementierung und der `DistributedModel`-Implementierung übersetzt werden. Optional können Sie die `state_dict` Übersetzungsfunktion als Argument für `smdistributed.modelparallel.torch.resume_from_checkpoint` angeben. Für [Ab Werk unterstützte Modelle](model-parallel-extended-features-pytorch-hugging-face.md#model-parallel-extended-features-pytorch-hugging-face-out-of-the-box) kümmert sich die Bibliothek jedoch automatisch um diese Übersetzung.
Der folgende Code zeigt ein Beispiel dafür, wie der Checkpoint verwendet wird, um ein mit APIs Modellparallelität trainiertes PyTorch Modell vollständig zu überprüfen.
```
import smdistributed.modelparallel.torch as smp
model = ...
model = smp.DistributedModel(model)
optimizer = ...
optimizer = smp.DistributedOptimizer(optimizer)
user_content = ... # additional custom data
checkpoint_path = "/opt/ml/checkpoint/model_parallel"
# Save a checkpoint.
smp.save_checkpoint(
path=checkpoint_path,
tag=f"total_steps{total_steps}",
partial=False,
model=model,
optimizer=optimizer,
user_content=user_content
num_kept_partial_checkpoints=5
)
# Load a checkpoint.
# This automatically loads the most recently saved checkpoint.
smp_checkpoint = smp.resume_from_checkpoint(
path=checkpoint_path,
partial=False
)
```
### Checkpointing für ein verteiltes PyTorch Modell (für die SageMaker Modellparallelitätsbibliothek zwischen v1.6.0 und v1.9.0)
Die SageMaker Modellparallelitätsbibliothek bietet Python-Funktionen zum Speichern teilweiser oder vollständiger Checkpoints für Trainingsjobs mit Tensorparallelität. Das folgende Verfahren zeigt, wie Sie [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save) und [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load) verwenden, um einen Prüfpunkt zu speichern und zu laden, wenn Sie Tensor-Parallelität verwenden.
**Anmerkung**
Diese Checkpoint-Methode wird empfohlen, wenn Sie, und die PyTorch SageMaker Modellparallelismus-Bibliothek zwischen [Tensor-Parallelität](model-parallel-extended-features-pytorch-tensor-parallelism.md) v1.6.0 und v1.9.0 verwenden.
1. Bereiten Sie ein Modellobjekt vor und umschließen Sie es mit der Wrapper-Funktion `smp.DistributedModel()` der Bibliothek.
```
model = MyModel(...)
model = smp.DistributedModel(model)
```
1. Bereiten Sie einen Optimierer für das Modell vor. Ein Satz von Modellparametern ist ein iterierbares Argument, das von Optimiererfunktionen benötigt wird. Um einen Satz von Modellparametern vorzubereiten, müssen Sie einzelne Modellparameter im Prozess eindeutig `model.parameters()` IDs zuweisen.
Wenn es Parameter gibt, bei denen der Modellparameter mehrfach IDs iterierbar ist, schlägt das Laden des Optimizerstatus mit Checkpoint fehl. Um eine Iterable von Modellparametern zu erstellen, die IDs für Ihren Optimierer eindeutig sind, gehen Sie wie folgt vor:
```
unique_params = []
unique_params_set = set()
for p in model.parameters():
if p not in unique_params_set:
unique_params.append(p)
unique_params_set.add(p)
del unique_params_set
optimizer = MyOpt(unique_params, ...)
```
1. Wickeln Sie den Optimizer mithilfe der Wrapper-Funktion `smp.DistributedOptimizer()` der Bibliothek ein.
```
optimizer = smp.DistributedOptimizer(optimizer)
```
1. Speichern Sie das Modell und den Status des Optimierers mit [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save). Wählen Sie eine der folgenden beiden Optionen aus, abhängig davon, wie Überprüfung gespeichert werden soll:
+ **Option 1:** Speichern Sie ein Teilmodell auf jedem `mp_rank` für ein einzelnes `MP_GROUP`.
```
model_dict = model.local_state_dict() # save a partial model
opt_dict = optimizer.local_state_dict() # save a partial optimizer state
# Save the dictionaries at rdp_rank 0 as a checkpoint
if smp.rdp_rank() == 0:
smp.save(
{"model_state_dict": model_dict, "optimizer_state_dict": opt_dict},
f"/checkpoint.pt",
partial=True,
)
```
Bei der Tensorparallelität speichert die Bibliothek Dateien mit Prüfpunkten, die im folgenden Format benannt sind: `checkpoint.pt_{pp_rank}_{tp_rank}`.
**Anmerkung**
Stellen Sie bei der Tensorparallelität sicher, dass Sie die if-Anweisung auf `if smp.rdp_rank() == 0` statt auf `if smp.dp_rank() == 0` setzen. Wenn der Optimiererstatus mit Tensorparallelität geteilt wird, müssen alle parallelen Ränge mit reduzierten Daten ihre eigene Partition des Optimiererstatus speichern. Die Verwendung einer falschen *if* -Anweisungfür Checkpoints kann dazu führen, dass der Trainingsjob ins Stocken gerät. Weitere Informationen zur Verwendung `if smp.dp_rank() == 0` ohne Tensorparallelität finden Sie unter [Allgemeine Anweisungen zum Speichern und Laden](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#general-instruction-for-saving-and-loading) in der *SageMaker Python* SDK-Dokumentation.
+ **Option 2:** Speichern Sie das vollständige Modell.
```
if smp.rdp_rank() == 0:
model_dict = model.state_dict(gather_to_rank0=True) # save the full model
if smp.rank() == 0:
smp.save(
{"model_state_dict": model_dict},
"/checkpoint.pt",
partial=False,
)
```
**Anmerkung**
Beachten Sie für ein vollständiges Checkpointing Folgendes:
Wenn Sie `gather_to_rank0=True` einstellen, geben alle anderen Ränge als `0` leere Wörterbücher zurück.
Für ein vollständiges Checkpointing können Sie nur das Modell mit Checkpoints versehen. Ein vollständiges Checkpointing von Optimizer-Status wird derzeit nicht unterstützt.
Das vollständige Modell muss nur unter `smp.rank() == 0` gespeichert werden.
1. Laden Sie die Checkpoints mit [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load). Wählen Sie, abhängig von der Überprüfung im vorherigen Schritt, eine der folgenden beiden Optionen aus:
+ **Option 1:** Laden Sie die partiellen Checkpoints.
```
checkpoint = smp.load("/checkpoint.pt", partial=True)
model.load_state_dict(checkpoint["model_state_dict"], same_partition_load=False)
optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
```
Sie können `same_partition_load=True` auf `model.load_state_dict()` für ein schnelleres Laden einstellen, wenn Sie wissen, dass sich die Partition nicht ändert.
+ **Option 2:** Lädt die vollständigen Checkpoints.
```
if smp.rdp_rank() == 0:
checkpoint = smp.load("/checkpoint.pt", partial=False)
model.load_state_dict(checkpoint["model_state_dict"])
```
Die `if smp.rdp_rank() == 0` Bedingung ist nicht erforderlich, kann aber dazu beitragen, redundantes Laden zwischen verschiedenen `MP_GROUP`s zu vermeiden. Das vollständige State-Diktat des Checkpointing-Optimizers wird derzeit bei der Tensorparallelität nicht unterstützt.
### Checkpoints für ein verteiltes Modell TensorFlow
Verwenden Sie die folgenden Funktionen der TensorFlow Modellparallelitätsbibliothek, um ein Modell zu speichern, während Sie mit SageMaker Modellparallelität trainieren.
+ [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.DistributedModel.save_model](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.DistributedModel.save_model)
+ [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.CheckpointManager](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.CheckpointManager)
## Feinabstimmung eines verteilten Modells
Die Feinabstimmung muss in Ihrem Trainingsskript konfiguriert werden. Der folgende Codeausschnitt zeigt eine Beispielstruktur eines Trainingsskripts, das die [AutoModelForCausalLM-Klasse](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModelForCausalLM) von Hugging Face Transformers verwendet, mit Änderungen für die Registrierung der `smdistributed.model.parallel.torch` Module und Einstellungen für die Feinabstimmung.
**Anmerkung**
Für die Feinabstimmung eines verteilten Transformators (ein Transformer-Modell eingeschlossen`smp.DistributedModel()`) mit aktivierter Funktion [smp.delayed\$1param\$1initialization](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization) muss der Feinabstimmungsjob mit einem for Lustre-Dateisystem konfiguriert werden. FSx In Fällen, in denen Sie ein umfangreiches Modell mit der Option zur verzögerten Parameterinitialisierung optimieren möchten, sollten Sie ein for Lustre-Dateisystem einrichten. FSx
```
import argparse
from transformers import AutoModelForCausalLM
import smdistributed.modelparallel
import smdistributed.modelparallel.torch as smp
def parse_args():
parser = argparse.ArgumentParser()
# set an arg group for model
model_grp = parser.add_argument_group(
title="model", description="arguments to describe model configuration"
)
... # set up numerous args to parse from the configuration dictionary to the script for training
# add arg for activating fine-tuning
model_grp.add_argument(
"--fine_tune",
type=int,
default=0,
help="Fine-tune model from checkpoint or pretrained model",
)
def main():
"""Main function to train GPT."""
args = parse_args()
... # parse numerous args
if args.fine_tune > 0 and args.delayed_param > 0 and smp.rank() == 0:
pretrained_model = AutoModelForCausalLM.from_pretrained(
args.model_name or args.model_dir
)
model_state_dict = pretrained_model.state_dict()
path = os.path.join(args.model_dir, "fullmodel.pt")
torch.save(model_state_dict, path)
# create a Transformer model and wrap by smp.model_creation()
# with options to configure model parallelism parameters offered by SageMaker AI
with smp.model_creation(
tensor_parallelism=smp.tp_size() > 1 or args.use_distributed_transformer > 0,
zero_init=args.use_distributed_transformer == 0,
dtype=dtype,
distribute_embedding=args.sharded_data_parallel_degree > 1 and smp.tp_size() > 1,
use_alibi=args.alibi > 0,
attention_in_fp32=args.attention_in_fp32 > 0,
fp32_residual_addition=args.residual_addition_in_fp32 > 0,
query_key_layer_scaling=args.query_key_layer_scaling > 0 and args.bf16 < 1,
fused_softmax=args.fused_softmax > 0,
fused_dropout=args.fused_dropout > 0,
fused_bias_gelu=args.fused_bias_gelu > 0,
flash_attention=args.flash_attention > 0,
):
if args.fine_tune > 0 and args.delayed_param == 0:
model = AutoModelForCausalLM.from_pretrained(
args.model_name or args.model_dir
)
else:
model = AutoModelForCausalLM.from_config(model_config)
# wrap the model by smp.DistributedModel() to apply SageMaker model parallelism
model = smp.DistributedModel(
model, trace_device="gpu", backward_passes_per_step=args.gradient_accumulation
)
# wrap the optimizer by smp.DistributedOptimizer() to apply SageMaker model parallelism
optimizer= ... # define an optimizer
optimizer = smp.DistributedOptimizer(
optimizer,
static_loss_scale=None,
dynamic_loss_scale=True,
dynamic_loss_args={"scale_window": 1000, "min_scale": 1, "delayed_shift": 2},
)
# for fine-tuning, use smp.resume_from_checkpoint() to load a pre-trained model
if args.fine_tune > 0 and args.delayed_param > 0:
smp.resume_from_checkpoint(args.model_dir, tag="fullmodel.pt", partial=False)
```
*Ein vollständiges Beispiel für Trainingsskripte und Jupyter-Notebooks finden Sie in den [GPT-2-Beispielen für im AI Examples Repository](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel/gpt2). PyTorch SageMaker GitHub*
# Beispiele für die Amazon SageMaker AI-Modellparallelismusbibliothek v1
Diese Seite enthält eine Liste von Blogs und Jupyter-Notebooks, die praktische Beispiele für die Implementierung der SageMaker Model Parallelism (SMP) -Bibliothek v1 zur Durchführung verteilter Trainingsaufgaben auf KI präsentieren. SageMaker
## Blogs und Fallstudien
In den folgenden Blogs werden Fallbeispiele zur Verwendung von SMP v1 behandelt.
+ [Neue Leistungsverbesserungen in der Amazon SageMaker AI-Modellparallelismus-Bibliothek](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/), *AWS Machine Learning Blog* (16. Dezember 2022)
+ [Trainieren Sie gigantische Modelle mit nahezu linearer Skalierung mithilfe von Sharded Data Parallelism auf Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/train-gigantic-models-with-near-linear-scaling-using-sharded-data-parallelism-on-amazon-sagemaker/), *AWS Machine Learning Blog* (31. Oktober 2022)
## Beispiel-Notebooks
[Beispiel-Notebooks finden Sie im AI Examples Repository. SageMaker GitHub ](https://github.com/aws/amazon-sagemaker-examples/tree/master/training/distributed_training/) Führen Sie zum Herunterladen der Beispiele den folgenden Befehl aus, um das Repository zu klonen, und gehen Sie zu `training/distributed_training/pytorch/model_parallel`.
**Anmerkung**
Klonen Sie die Beispiel-Notebooks und führen Sie sie in der folgenden SageMaker AI ML aus IDEs.
[SageMaker JupyterLab](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-jl.html)(verfügbar in [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html), das nach Dezember 2023 erstellt wurde)
[SageMaker Code-Editor](https://docs.aws.amazon.com/sagemaker/latest/dg/code-editor.html) (verfügbar in [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html), das nach Dezember 2023 erstellt wurde)
[Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) (verfügbar als Anwendung in [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html), das nach Dezember 2023 erstellt wurde)
[SageMaker Notebook-Instanzen](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html)
```
git clone https://github.com/aws/amazon-sagemaker-examples.git
cd amazon-sagemaker-examples/training/distributed_training/pytorch/model_parallel
```
**SMP v1-Beispiel-Notebooks für PyTorch**
+ [Trainieren Sie GPT-2 mit nahezu linearer Skalierung mithilfe der Sharded-Datenparallelismus-Technik aus der Modellparallelitätsbibliothek SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/smp-train-gpt-sharded-data-parallel.ipynb)
+ [Optimieren Sie GPT-2 mit nahezu linearer Skalierung mithilfe der Sharded-Datenparallelismus-Technik in der Modellparallelitätsbibliothek SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/smp-fine-tune-gpt-sharded-data-parallel.ipynb)
+ [Trainieren Sie GPT-Neox-20B mit nahezu linearer Skalierung mithilfe der Sharded-Datenparallelismus-Technik in der Modellparallelismus-Bibliothek SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt-neox/smp-train-gpt-neox-sharded-data-parallel.ipynb)
+ [Trainieren Sie GPT-J 6B mithilfe der Techniken der Sharded-Datenparallelität und der Tensorparallelität in der Modellparallelitätsbibliothek SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt-j/smp-train-gptj-sharded-data-parallel-tp.ipynb)
+ [Trainieren Sie FLAN-T5 mit nahezu linearer Skalierung mithilfe der Technik der Sharded-Datenparallelität in der Modellparallelitätsbibliothek SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/flan-t5/smp-train-t5-sharded-data-parallel.ipynb)
+ [Trainieren Sie Falcon mit nahezu linearer Skalierung mithilfe der Sharded-Datenparallelismus-Technik in der Modellparallelitätsbibliothek SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/falcon/smp-train-falcon-sharded-data-parallel.ipynb)
**SMP v1-Beispiel-Notebooks für TensorFlow**
+ [CNN mit TensorFlow 2.3.1 und der SageMaker Modellparallelismus-Bibliothek](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/tensorflow/model_parallel/mnist/tensorflow_smmodelparallel_mnist.html)
+ [HuggingFace mit der Bibliothek für TensorFlow verteilte Modellparallelität, Schulung zum Thema KI SageMaker ](https://github.com/huggingface/notebooks/blob/master/sagemaker/04_distributed_training_model_parallelism/sagemaker-notebook.ipynb)
# SageMaker Bewährte Methoden für verteilte Modellparallelität
Beachten Sie die folgenden Richtlinien, wenn Sie einen verteilten Trainingsjob mit der SageMaker Modellparallelbibliothek ausführen.
## Die richtige Konfiguration für ein bestimmtes Modell einrichten
Bei der Skalierung eines Modells empfehlen wir Ihnen, die folgende Liste der Reihe nach durchzugehen. In jedem Listenelement werden die Vorteile der Verwendung der Techniken der Bibliothek sowie die möglichen Kompromisse erörtert.
**Tipp**
Wenn ein Modell mit einer Teilmenge der Bibliotheksfeatures gut passt, führt das Hinzufügen weiterer Modellparallelität oder speicherschonender Features in der Regel nicht zu einer Leistungssteigerung.
**Verwendung großer GPU-Instancetypen**
+ Im Bereich der Modellparallelität empfiehlt es sich, leistungsstarke Instances mit großen GPU-Speichern zu verwenden, um den Mehraufwand zu bewältigen, der durch Modellparallelitätsoperationen wie die Partitionierung von Modellen auf mehrere entsteht. GPUs Wir empfehlen die Verwendung von `ml.p4d` oder `ml.p3dn` Instances für das Training großer DL-Modelle. Diese Instances sind außerdem mit dem Elastic Fabric Adapter (EFA) ausgestattet, der eine höhere Netzwerkbandbreite bietet und umfangreiche Trainings mit Modellparallelität ermöglicht.
**Status des Sharding-Optimierers**
+ Die Auswirkungen des Sharding-Optimizer-Status hängen von der Anzahl der parallel Datenränge ab. In der Regel kann ein höherer Grad an Datenparallelität (proportional zur Größe des Rechenknotens) die Effizienz der Speichernutzung verbessern.
Wenn Sie einen Cluster verkleinern möchten, stellen Sie sicher, dass Sie die State-Sharding-Konfiguration des Optimizers überprüfen. Beispielsweise passt ein großes DL-Modell mit Optimizer-State-Sharding, das auf einen Rechencluster mit 16 GPUs (z. B. zwei P4d- oder P4de-Instances) passt, möglicherweise nicht immer auf einen Knoten mit 8 GPUs (z. B. eine einzelne P4d- oder P4de-Instance). Dies liegt daran, dass der kombinierte Speicher von 8 niedriger GPUs ist als der kombinierte Speicher von 16 GPUs, und der erforderliche Speicher pro GPU für Sharding über 8 GPUs ist ebenfalls höher als der Speicher pro GPU für Sharding über das 16-GPU-Szenario. Infolgedessen passt der erhöhte Speicherbedarf möglicherweise nicht in den kleineren Cluster.
Weitere Informationen finden Sie unter [Optimizer-Zustandsfragmentierung](model-parallel-extended-features-pytorch-optimizer-state-sharding.md).
**Checkpoint bei der Aktivierung**
+ Die Speichereffizienz kann verbessert werden, indem Aktivierungsprüfpunkte für eine Gruppe von Modulen verwendet werden. Je mehr Sie die Module gruppieren, desto effizienter ist die Speichernutzung. Beim Checkpoint sequentieller Module für Ebenen gruppiert das `strategy` Argument der `smp.set_activation_checkpointing` Funktion die Ebenen für das Checkpointing zusammen. Beispielsweise ist das Gruppieren von zwei oder mehr Ebenen für Checkpoints speichereffizienter als das Gruppieren von Checkpoints für jeweils eine Ebene. Dadurch wird zusätzliche Rechenzeit gegen einen geringeren Speicherverbrauch eingetauscht.
Weitere Informationen finden Sie unter [Aktivierungs-Prüfpunkte](model-parallel-extended-features-pytorch-activation-checkpointing.md).
**Tensor-Parallelität**
+ Der Grad der Tensorparallelität sollte eine Zweierpotenz (2, 4, 8,..., 2 n) sein, wobei der maximale Grad der Anzahl der pro Knoten entsprechen muss. GPUs Wenn Sie beispielsweise einen Knoten mit 8 verwenden GPUs, sind die möglichen Zahlen für den Grad der Tensorparallelität 2, 4 und 8. Wir empfehlen keine willkürlichen Zahlen (wie 3, 5, 6 und 7) für den Grad der Tensorparallelität. Wenn Sie mehrere Knoten verwenden, kann eine Fehlkonfiguration des Grads der Tensorparallelität dazu führen, dass Tensorparallelität zwischen den Knoten ausgeführt wird. Dies erhöht den Mehraufwand für die Kommunikation von Aktivierungen zwischen den Knoten und kann rechenintensiv werden.
Weitere Informationen finden Sie unter [Tensor-Parallelität](model-parallel-extended-features-pytorch-tensor-parallelism.md).
**Pipeline-Parallelität zwischen Knoten**
+ Sie können die Pipeline-Parallelität sowohl innerhalb eines einzelnen Knotens als auch über mehrere Knoten hinweg ausführen. Wenn Sie Pipeline-Parallelität in Kombination mit Tensorparallelität verwenden, empfehlen wir, die Pipeline-Parallelität über mehrere Knoten hinweg auszuführen und die Tensorparallelität innerhalb einzelner Knoten beizubehalten.
+ Die Pipeline-Parallelität umfasst die folgenden drei Drehregler: `microbatches`, `active_microbatches`, und `prescaled_batch`.
+ Wenn Sie Tensorparallelität mit Pipeline-Parallelität verwenden, empfehlen wir die Aktivierung von `prescaled_batch`, damit die Batchgröße pro Modellparallelgruppe für effizientes Pipelining erhöht werden kann. Wenn `prescaled_batch` aktiviert ist, wird die im Trainingsskript festgelegte Losgröße `tp_size` mal die für jeden Rang festgelegte Losgröße ohne `prescaled_batch`.
+ Eine Erhöhung der Anzahl von `microbatches` hilft dabei, effizientes Pipelining und bessere Leistung zu erreichen. Beachten Sie, dass die effektive Mikrobatchgröße die Chargengröße geteilt durch die Anzahl der Mikrobatchen ist. Wenn Sie die Anzahl der Mikrobatchen erhöhen und gleichzeitig die Chargengröße konstant halten, verarbeitet jede Mikrocharge weniger Proben.
+ Die Anzahl von `active_microbatches` ist die maximale Anzahl von Mikrobatches, die während der Pipelining gleichzeitig verarbeitet werden. Für jeden aktiven Mikrobatch, der gerade verarbeitet wird, belegen seine Aktivierungen und Gradienten GPU-Speicher. Daher beansprucht eine Erhöhung von `active_microbatches` mehr GPU-Speicher.
+ Wenn sowohl der GPU- als auch der GPU-Speicher nicht ausreichend ausgelastet sind, erhöhen Sie `active_microbatches` für eine bessere Parallelisierung beim Pipelining.
+ Weitere Informationen zur Verwendung von Tensorparallelität mit Pipeline-Parallelität finden Sie unter [Tensor-Parallelität kombiniert mit Pipeline-Parallelität](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism).
+ Beschreibungen der oben genannten Parameter finden Sie unter [Parameter für `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#parameters-for-smdistributed) in der *SageMaker Python SDK-Dokumentation*.
**Aktivierungen auf die CPU auslagern**
+ Stellen Sie sicher, dass dies in Kombination mit Aktivierungs-Checkpointing und Pipeline-Parallelität verwendet wird. Um sicherzustellen, dass das Entladen und Vorladen im Hintergrund erfolgt, geben Sie für den Microbatches-Parameter einen Wert größer als 1 an.
+ Beim Auslagern von Aktivierungen können Sie möglicherweise die Gesamtzahl der Mikrobatches erhöhen `active_microbatches` und manchmal auch an sie anpassen. Das hängt davon ab, welche Module mit Checkpoints versehen sind und wie das Modell partitioniert ist.
Weitere Informationen finden Sie unter [Aktivierungs-Entladung](model-parallel-extended-features-pytorch-activation-offloading.md).
### Referenzkonfigurationen
Das Schulungsteam für SageMaker Modellparallelität bietet die folgenden Referenzpunkte auf der Grundlage von Experimenten mit dem GPT-2-Modell, einer Sequenzlänge von 512 und einer Vokabelgröße von 50.000.
| Die Anzahl der Modellparameter | Instance-Typ | Pipeline-Parallelität | Tensor-Parallelität | Zustands-Sharding im Optimizer | Checkpointing bei der Aktivierung | Vorskalierter Stapel | Batch-Größe |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 10 Milliarden | 16 ml.p4d.24xlarge | 1 | 4 | Wahr | Jede Transformatorschicht | Wahr | batch\$1size=40 |
| 30 Milliarden | 16 ml.p4d.24xlarge | 1 | 8 | Wahr | Jede Transformatorschicht | Wahr | batch\$1size=32 |
| 60 Milliarden | 32 ml.p4d.24xlarge | 2 | 8 | Wahr | Jede Transformatorschicht | Wahr | batch\$1size=56, microbatches=4, active\$1microbatches=2 |
Sie können aus den vorherigen Konfigurationen extrapolieren, um die GPU-Speicherauslastung für Ihre Modellkonfiguration zu schätzen. Wenn Sie beispielsweise die Sequenzlänge für ein Modell mit 10 Milliarden Parametern oder die Größe des Modells auf 20 Milliarden erhöhen, möchten Sie möglicherweise zuerst die Batchgröße verringern. Wenn das Modell immer noch nicht passt, versuchen Sie, den Grad der Tensorparallelität zu erhöhen.
## Ihr Trainingsskript ändern
+ Bevor Sie die Funktionen der SageMaker Modellparallel-Bibliothek in Ihrem Trainingsskript verwenden, lesen Sie sich das durch[Tipps und Fallstricke zur Konfiguration der SageMaker Distributed Model Parallelism Library](model-parallel-customize-tips-pitfalls.md).
+ Verwenden Sie den [lokalen SageMaker KI-Modus](https://sagemaker.readthedocs.io/en/v2.199.0/overview.html?highlight=local%20mode#local-mode), um einen Trainingsjob schneller zu starten. Auf diese Weise können Sie einen Trainingsjob schnell lokal auf einer SageMaker Notebook-Instanz ausführen. Abhängig von der Größe der ML-Instanz, auf der Ihre SageMaker Notebook-Instanz ausgeführt wird, müssen Sie möglicherweise die Größe Ihres Modells anpassen, indem Sie die Modellkonfigurationen ändern, z. B. die verborgene Breite, die Anzahl der Transformator-Layer und die Aufmerksamkeit Heads. Prüfen Sie, ob das reduzierte Modell auf der Notebook-Instance gut funktioniert, bevor Sie einen großen Cluster für das Training des vollständigen Modells verwenden.
## Überwachung und Protokollierung eines Trainingsjobs mithilfe der SageMaker AI-Konsole und Amazon CloudWatch
Verwenden Sie zur Überwachung von Kennzahlen auf Systemebene wie CPU-Speicherauslastung, GPU-Speicherauslastung und GPU-Auslastung die über die [SageMaker KI-Konsole](https://console.aws.amazon.com/sagemaker/) bereitgestellte Visualisierung.
1. Wählen Sie im linken Navigationsbereich die Option **Training** aus.
1. Wählen Sie **Training Jobs (Trainingsaufträge)** aus.
1. Wählen Sie im Hauptbereich den Namen des Trainingsjobs aus, für den Sie weitere Details anzeigen möchten.
1. Durchsuchen Sie den Hauptbereich und suchen Sie den Abschnitt **Monitor**, um sich die automatisierte Visualisierung anzusehen.
1. Um die Protokolle der Trainingsjobs einzusehen, wählen Sie im Bereich **Monitor** die Option **Protokolle anzeigen** aus. Sie können auf die verteilten Trainingsjob-Logs des Trainingsjobs in zugreifen. CloudWatch Wenn Sie ein verteiltes Training mit mehreren Knoten gestartet haben, sollten Sie mehrere Protokollstreams mit Tags im Format **algo-n-1234567890 sehen.** Der **Algo-1-Protokollstream** verfolgt Trainingsprotokolle vom Hauptknoten (0.).
Weitere Informationen finden Sie unter [Amazon CloudWatch Metrics für die Überwachung und Analyse von Schulungsaufträgen](training-metrics.md).
## Berechtigungen
Um einen SageMaker Trainingsjob mit Modellparallelität oder den [SageMaker verteilten Schulungsbeispielnotizbüchern](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/index.html) auszuführen, stellen Sie sicher, dass Sie in Ihrer IAM-Rolle über die richtigen Berechtigungen verfügen, z. B. die folgenden:
+ Um es [FSx für Lustre](https://aws.amazon.com/fsx/) zu verwenden, fügen Sie hinzu. [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonFSxFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonFSxFullAccess)
+ Um Amazon S3 als Datenkanal zu verwenden, fügen Sie [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonS3FullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonS3FullAccess) hinzu.
+ Um Docker zu verwenden, erstellen Sie Ihren eigenen Container und übertragen Sie ihn auf Amazon ECR, fügen Sie [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonEC2ContainerRegistryFullAccess) hinzu.
+ Um vollen Zugriff auf die gesamte Suite der SageMaker KI-Funktionen zu erhalten, fügen Sie hinzu [https://console.aws.amazon.com/iam/home#/policies/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#/policies/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonSageMakerFullAccess).
# Tipps und Fallstricke zur Konfiguration der SageMaker Distributed Model Parallelism Library
Lesen Sie die folgenden Tipps und Fallstricke, bevor Sie die SageMaker Modellparallelismus-Bibliothek von Amazon AI verwenden. Diese Liste enthält Tipps, die für alle Frameworks gelten. PyTorchSpezifische Tipps finden Sie unter [Ändern Sie ein TensorFlow Trainingsskript](model-parallel-customize-training-script-tf.md) bzw.[Ein PyTorch Trainingsskript ändern](model-parallel-customize-training-script-pt.md). TensorFlow
## Chargengröße und Anzahl der Mikrobatches
+ Die Bibliothek ist am effizientesten, wenn die Chargengröße erhöht wird. In Anwendungsfällen, in denen das Modell zwar in ein einzelnes Gerät passt, aber nur mit einer kleinen Chargengröße trainiert werden kann, kann und sollte die Chargengröße nach der Integration der Bibliothek erhöht werden. Modellparallelität spart Speicherplatz bei großen Modellen, sodass Sie mit Losgrößen trainieren können, die zuvor nicht in den Arbeitsspeicher passten.
+ Die Auswahl einer zu kleinen oder zu großen Anzahl von Mikrobatches kann zu Leistungseinbußen führen. Die Bibliothek führt jeden Mikrobatch sequentiell in jedem Gerät aus. Daher muss die Mikrobatch-Größe (Batchgröße geteilt durch die Anzahl der Mikrobatches) groß genug sein, um jede GPU voll auszunutzen. Gleichzeitig steigt die Effizienz der Pipeline mit der Anzahl der Mikrobatches, weshalb es wichtig ist, das richtige Gleichgewicht zu finden. In der Regel ist es ein guter Ausgangspunkt, 2 oder 4 Mikrobatches auszuprobieren, wobei die Chargengröße bis zur Speichergrenze erhöht wird, und dann mit größeren Chargengrößen und einer größeren Anzahl von Mikrobatches zu experimentieren. Wenn die Anzahl der Mikrobatches erhöht wird, könnten größere Chargengrößen realisierbar werden, wenn eine ineinander verschachtelte Pipeline verwendet wird.
+ Ihre Chargengröße muss immer durch die Anzahl der Mikrobatchen teilbar sein. Beachten Sie, dass je nach Größe des Datensatzes manchmal die letzte Charge jeder Epoche kleiner sein kann als die anderen, und diese kleinere Charge muss auch durch die Anzahl der Mikrobatches teilbar sein. Ist dies nicht der Fall, können Sie den `tf.Dataset.batch()` Aufruf (in TensorFlow) oder den Befehl `drop_last=True` in `DataLoader` (in PyTorch) so einstellen, dass dieser letzte kleine Batch nicht verwendet wird. `drop_remainder=True` Wenn Sie eine andere API für die Datenpipeline verwenden, müssen Sie den letzten Stapel möglicherweise manuell überspringen, wenn er nicht durch die Anzahl der Mikrobatches teilbar ist.
## Manuelle Partitionen
+ Wenn Sie die manuelle Partitionierung verwenden, sollten Sie die Parameter berücksichtigen, die für mehrere Operationen und Module in Ihrem Modell verwendet werden, z. B. für die Einbettungstabelle in Transformatorarchitekturen. Module, die denselben Parameter verwenden, müssen aus Gründen der Richtigkeit auf demselben Gerät platziert werden. Wenn die automatische Partitionierung verwendet wird, erzwingt die Bibliothek diese Einschränkung automatisch.
## Datenaufbereitung
+ Wenn das Modell mehrere Eingaben benötigt, stellen Sie sicher, dass Sie die Zufallsoperationen in Ihrer Datenpipeline (z. B. Mischen) mit `smp.dp_rank()` starten. Wenn der Datensatz deterministisch auf datenparallele Geräte aufgeteilt wird, stellen Sie sicher, dass der Shard von `smp.dp_rank()` indiziert wird. Dadurch soll sichergestellt werden, dass die Reihenfolge der Daten auf allen Rängen, die eine Modellpartition bilden, konsistent ist.
## Rückgabe von Tensoren von `smp.DistributedModel`
+ Jeder Tensor, der von der Funktion `smp.DistributedModel.call` (for TensorFlow) oder `smp.DistributedModel.forward` (for PyTorch) zurückgegeben wird, wird von dem Rang, der diesen bestimmten Tensor berechnet hat, an alle anderen Ränge übertragen. Daher sollte jeder Tensor, der außerhalb der Call- und Forward-Methoden nicht benötigt wird (z. B. Zwischenaktivierungen), nicht zurückgegeben werden, da dies zu unnötiger Kommunikation und Speicheraufwand führt und die Leistung beeinträchtigt.
## Der `@smp.step` Dekorateur
+ Wenn eine `smp.step`-dekorierte Funktion ein Tensor-Argument hat, das keine Stapeldimension hat, muss der Argumentname beim Aufruf von `non_split_inputs` in der `smp.step`-Liste angegeben werden. Dadurch wird verhindert, dass die Bibliothek versucht, den Tensor in Mikrobatches aufzuteilen. Weitere Informationen finden Sie unter [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html) in der API-Dokumentation.
## Verzögerung der Parameterinitialisierung
Bei sehr großen Modellen mit mehr als 100 Milliarden Parametern kann die Initialisierung der Gewichtung über den CPU-Speicher zu einem Fehler führen. out-of-memory Um dies zu umgehen, bietet die Bibliothek einen `smp.delay_param_initialization` Kontext-Manager. Dadurch wird die physische Zuweisung von Parametern verzögert, bis sie bei der ersten Ausführung einer `smp.step` -dekorierten Funktion auf die GPU übertragen werden. Dadurch wird eine unnötige Speicherauslastung der CPU bei der Initialisierung des Trainings vermieden. Verwenden Sie den Kontext-Manager, wenn Sie ein Modellobjekt erstellen, wie im folgenden Code gezeigt.
```
with smp.delay_param_initialization(enabled=True):
model = MyModel()
```
## Tensor-Parallelität für PyTorch
+ Wenn Sie einen Seed für deterministische Ergebnisse verwenden, setzen Sie den Seed auf der Grundlage von `smp.dp_rank()` (z. B. `torch.manual_seed(42 + smp.dp_rank())`). Andernfalls werden verschiedene Partitionen eines `nn.Parameter` auf die gleiche Weise initialisiert, was die Konvergenz beeinträchtigt.
+ SageMakerDie Modellparallelitätsbibliothek verwendet NCCL, um Kollektive zu implementieren, die für die Verteilung der Module benötigt werden. Insbesondere bei kleineren Modellen kann die Speichernutzung aufgrund des zusätzlichen Speicherplatzes, den NCCL beansprucht, zunehmen, wenn zu viele NCCL-Aufrufe gleichzeitig auf der GPU geplant sind. Um dem entgegenzuwirken, drosselt `smp` die NCCL-Aufrufe, so dass die Anzahl der laufenden NCCL-Operationen zu einem bestimmten Zeitpunkt kleiner oder gleich einem bestimmten Grenzwert ist. Das Standardlimit ist 8, kann aber mithilfe der Umgebungsvariablen `SMP_NCCL_THROTTLE_LIMIT` angepasst werden. Wenn Sie bei der Verwendung der Tensorparallelität einen höheren Speicherverbrauch als erwartet feststellen, können Sie versuchen, diesen Grenzwert zu reduzieren. Wenn Sie jedoch ein zu kleines Limit wählen, kann dies zu Durchsatzverlusten führen. Um die Drosselung vollständig zu deaktivieren, können Sie `SMP_NCCL_THROTTLE_LIMIT=-1` festlegen.
+ Die folgende Identität, die gilt, wenn der Grad der Tensorparallelität 1 ist, gilt nicht, wenn der Grad der Tensorparallelität größer als 1 ist: `smp.mp_size() * smp.dp_size() == smp.size()`. Dies liegt daran, dass die Tensorparallelitätsgruppe sowohl Teil der Modellparallelitätsgruppe als auch der Datenparallelitätsgruppe ist. Wenn Ihr Code bereits Verweise auf `mp_rank`, `mp_size`, `MP_GROUP`, usw. enthält und Sie nur mit der parallel Pipeline-Gruppe arbeiten möchten, müssen Sie die Verweise möglicherweise durch `smp.pp_size()` ersetzen. Die folgenden Identitäten sind immer wahr:
+ `smp.mp_size() * smp.rdp_size() == smp.size()`
+ `smp.pp_size() * smp.dp_size() == smp.size()`
+ `smp.pp_size() * smp.tp_size() * smp.rdp_size() == smp.size()`
+ Da der `smp.DistributedModel` Wrapper die Modellparameter ändert, wenn die Tensorparallelität aktiviert ist, sollte der Optimierer nach dem Aufruf von `smp.DistributedModel` mit den verteilten Parametern erstellt werden. Zum Beispiel funktioniert das Folgende nicht:
```
## WRONG
model = MyModel()
optimizer = SomeOptimizer(model.parameters())
model = smp.DistributedModel(model) # optimizer now has outdated parameters!
```
Stattdessen sollte der Optimierer mit den folgenden Parametern von `smp.DistributedModel` erstellt werden:
```
## CORRECT
model = smp.DistributedModel(MyModel())
optimizer = SomeOptimizer(model.optimizers())
```
+ Wenn ein Modul durch Tensorparallelität durch sein verteiltes Gegenstück ersetzt wird, erbt das verteilte Modul seine Gewichte nicht vom ursprünglichen Modul und initialisiert neue Gewichte. Das bedeutet, dass, wenn die Gewichte in einem bestimmten Aufruf initialisiert werden müssen (z. B. durch einen `load_state_dict`-Aufruf), dies nach dem `smp.DistributedModel`-Aufruf geschehen muss, sobald die Modulverteilung stattfindet.
+ Beachten Sie beim direkten Zugriff auf die Parameter verteilter Module, dass das Gewicht nicht dieselbe Form wie das ursprüngliche Modul hat. Zum Beispiel,
```
with smp.tensor_parallelism():
linear = nn.Linear(60, 60)
# will pass
assert tuple(linear.weight.shape) == (60, 60)
distributed_linear = smp.DistributedModel(linear)
# will fail. the number of input channels will have been divided by smp.tp_size()
assert tuple(distributed_linear.module.weight.shape) == (60, 60)
```
+ Die Verwendung von `torch.utils.data.distributed.DistributedSampler` wird aus Gründen der Tensorparallelität dringend empfohlen. Dadurch wird sichergestellt, dass jeder parallel Datenrang die gleiche Anzahl von Datenproben empfängt, wodurch verhindert wird, dass verschiedene `dp_rank`s eine unterschiedliche Anzahl von Schritten ausführen.
+ Wenn Sie die `join` API der PyTorch `DistributedDataParallel` Klasse verwenden, um Fälle zu behandeln, in denen verschiedene parallel Datenränge eine unterschiedliche Anzahl von Batches haben, müssen Sie dennoch sicherstellen, dass Ränge, die sich in derselben Reihe befinden, dieselbe Anzahl von Batches `TP_GROUP` haben. Andernfalls können die Kommunikationskollektive, die bei der verteilten Ausführung von Modulen verwendet werden, hängen bleiben. Ränge, die sich in unterschiedlichen `TP_GROUP` s befinden, können eine unterschiedliche Anzahl von Batches haben, solange die `join` API verwendet wird.
+ Wenn Sie Ihr Modell überprüfen und die Tensorparallelität verwenden möchten, sollten Sie Folgendes berücksichtigen:
+ Wenn Sie Tensorparallelität verwenden, sollten Sie sicherstellen, dass Sie die entsprechenden Funktionen aus den folgenden Modell- und Optimiererzuständen innerhalb eines Rangs mit reduzierter Datenparallelität aufrufen, damit beim Speichern und Laden von Modellen keine Verzögerungen auftreten.
+ Wenn Sie ein vorhandenes Pipeline-Parallel-Skript umstellen und Tensorparallel für das Skript aktivieren, stellen Sie sicher, dass Sie alle `if smp.dp_rank() == 0` Blöcke ändern, die zum Speichern und Laden mit `if smp.rdp_rank() == 0` Blöcken verwendet werden. Andernfalls könnte es dazu führen, dass Ihr Trainingsjob ins Stocken gerät.
Weitere Hinweise zum Checkpointing eines Modells mit Tensorparallelität finden Sie unter [Überprüfung eines verteilten Modells](distributed-model-parallel-checkpointing-and-finetuning.md#distributed-model-parallel-checkpoint).
# Parallele Problembehebung bei Modellen
Wenn Sie auf einen Fehler stoßen, können Sie anhand der folgenden Liste versuchen, Probleme mit Ihrem Trainingsjob zu beheben. Wenn das Problem weiterhin besteht, wenden Sie sich an den [AWS Support](https://aws.amazon.com/premiumsupport).
**Topics**
+ [Überlegungen zur Verwendung des SageMaker Debuggers mit der SageMaker Model Parallelism Library](#distributed-ts-model-parallel-debugger)
+ [Speichern von Prüfpunkten](#distributed-ts-model-parallel-checkpoints)
+ [Konvergenz unter Verwendung von Model Parallel und TensorFlow](#distributed-ts-model-parallel-tf-convergence)
+ [Blockieren oder Abstürzen von verteilten Trainingsaufträgen](#distributed-ts-model-parallel-training-issues)
+ [Empfangen eines NCCL-Fehlers für einen Schulungsjob PyTorch](#distributed-ts-model-parallel-nccl-error)
+ [Empfang `RecursionError` für eine PyTorch Ausbildungsstelle](#distributed-ts-model-parallel-super-forward-not-supported)
## Überlegungen zur Verwendung des SageMaker Debuggers mit der SageMaker Model Parallelism Library
SageMaker Der Debugger ist für die Modellparallelismus-Bibliothek nicht verfügbar. SageMaker Der Debugger ist standardmäßig für alle PyTorch Trainingsjobs aktiviert, SageMaker TensorFlow und es wird möglicherweise ein Fehler angezeigt, der wie folgt aussieht:
```
FileNotFoundError: [Errno 2] No such file or directory: '/opt/ml/checkpoints/metadata.json.sagemaker-uploading
```
Um dieses Problem zu beheben, deaktivieren Sie den Debugger, indem Sie `debugger_hook_config=False` beim Erstellen eines Frameworks `estimator` übergeben, wie im folgenden Beispiel gezeigt.
```
bucket=sagemaker.Session().default_bucket()
base_job_name="sagemaker-checkpoint-test"
checkpoint_in_bucket="checkpoints"
# The S3 URI to store the checkpoints
checkpoint_s3_bucket="s3://{}/{}/{}".format(bucket, base_job_name, checkpoint_in_bucket)
estimator = TensorFlow(
...
distribution={"smdistributed": {"modelparallel": { "enabled": True }}},
checkpoint_s3_uri=checkpoint_s3_bucket,
checkpoint_local_path="/opt/ml/checkpoints",
debugger_hook_config=False
)
```
## Speichern von Prüfpunkten
Beim Speichern von Checkpoints eines großen Modells auf SageMaker KI kann der folgende Fehler auftreten:
```
InternalServerError: We encountered an internal error. Please try again
```
Dies könnte durch eine SageMaker KI-Einschränkung beim Hochladen des lokalen Checkpoints auf Amazon S3 während des Trainings verursacht werden. Um Checkpointing in SageMaker AI zu deaktivieren, verwenden Sie das folgende Beispiel, um die Checkpoints explizit hochzuladen.
Wenn Sie auf den vorherigen Fehler stoßen, verwenden Sie ihn nicht `checkpoint_s3_uri` zusammen mit dem SageMaker `estimator` Aufruf. Beim Speichern von Checkpoints für größere Modelle empfehlen wir, Checkpoints in einem benutzerdefinierten Verzeichnis zu speichern und dieses an die Hilfsfunktion (als ein `local_path` Argument) zu übergeben.
```
import os
def aws_s3_sync(source, destination):
"""aws s3 sync in quiet mode and time profile"""
import time, subprocess
cmd = ["aws", "s3", "sync", "--quiet", source, destination]
print(f"Syncing files from {source} to {destination}")
start_time = time.time()
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p.wait()
end_time = time.time()
print("Time Taken to Sync: ", (end_time-start_time))
return
def sync_local_checkpoints_to_s3(local_path="/opt/ml/checkpoints", s3_uri=os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))+'/checkpoints'):
""" sample function to sync checkpoints from local path to s3 """
import boto3
#check if local path exists
if not os.path.exists(local_path):
raise RuntimeError("Provided local path {local_path} does not exist. Please check")
#check if s3 bucket exists
s3 = boto3.resource('s3')
if not s3_uri.startswith("s3://"):
raise ValueError(f"Provided s3 uri {s3_uri} is not valid.")
s3_bucket = s3_uri.replace('s3://','').split('/')[0]
print(f"S3 Bucket: {s3_bucket}")
try:
s3.meta.client.head_bucket(Bucket=s3_bucket)
except Exception as e:
raise e
aws_s3_sync(local_path, s3_uri)
return
def sync_s3_checkpoints_to_local(local_path="/opt/ml/checkpoints", s3_uri=os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))+'/checkpoints'):
""" sample function to sync checkpoints from s3 to local path """
import boto3
#try to create local path if it does not exist
if not os.path.exists(local_path):
print(f"Provided local path {local_path} does not exist. Creating...")
try:
os.makedirs(local_path)
except Exception as e:
raise RuntimeError(f"Failed to create {local_path}")
#check if s3 bucket exists
s3 = boto3.resource('s3')
if not s3_uri.startswith("s3://"):
raise ValueError(f"Provided s3 uri {s3_uri} is not valid.")
s3_bucket = s3_uri.replace('s3://','').split('/')[0]
print(f"S3 Bucket: {s3_bucket}")
try:
s3.meta.client.head_bucket(Bucket=s3_bucket)
except Exception as e:
raise e
aws_s3_sync(s3_uri, local_path)
return
```
Verwendung von Hilfsfunktionen:
```
#base_s3_uri - user input s3 uri or save to model directory (default)
#curr_host - to save checkpoints of current host
#iteration - current step/epoch during which checkpoint is saved
# save checkpoints on every node using local_rank
if smp.local_rank() == 0:
base_s3_uri = os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))
curr_host = os.environ['SM_CURRENT_HOST']
full_s3_uri = f'{base_s3_uri}/checkpoints/{curr_host}/{iteration}'
sync_local_checkpoints_to_s3(local_path=checkpoint_dir, s3_uri=full_s3_uri)
```
## Konvergenz unter Verwendung von Model Parallel und TensorFlow
Wenn Sie das SageMaker KI-Training mit mehreren Knoten TensorFlow und der Modellparallelitätsbibliothek verwenden, konvergiert der Verlust möglicherweise nicht wie erwartet, da die Reihenfolge der Trainingseingabedateien auf jedem Knoten unterschiedlich sein kann. Dies kann dazu führen, dass unterschiedliche Ränge in derselben Modellparallelgruppe mit unterschiedlichen Eingabedateien arbeiten, was zu Inkonsistenzen führen kann. Um dies zu verhindern, stellen Sie sicher, dass die Eingabedateien in allen Rängen gleich angeordnet sind, bevor sie in Datensätze konvertiert werden. TensorFlow Eine Möglichkeit, dies zu erreichen, besteht darin, die Namen der Eingabedateien im Trainingsskript zu sortieren.
## Blockieren oder Abstürzen von verteilten Trainingsaufträgen
Falls es bei Ihrem Trainingsjob zu Problemen kommt, die zum Stillstand kommen, abstürzen oder nicht reagieren, lesen Sie sich die folgenden Hinweise zur Problembehebung durch, um herauszufinden, was die Ursache des Problems ist. Wenn Sie weitere Unterstützung benötigen, wenden Sie sich über den [AWS Support](https://aws.amazon.com/premiumsupport) an das SageMaker verteilte Schulungsteam.
+ Wenn Sie feststellen, dass **ein verteilter Trainingsjob beim NCCL-Initialisierungsschritt ins Stocken** gerät, sollten Sie Folgendes beachten:
+ Wenn Sie eine der EFA-fähigen Instances ( `ml.p4d` oder `ml.p3dn` Instances) mit einer benutzerdefinierten VPC und ihrem Subnetz verwenden, stellen Sie sicher, dass die verwendete Sicherheitsgruppe eingehende und ausgehende Verbindungen für alle Ports zu und von derselben SG hat. In der Regel benötigen Sie außerdem ausgehende Verbindungen zu einer beliebigen IP als separate Regel (für den Internetzugang). Anweisungen zum Hinzufügen von Regeln für eingehenden und ausgehenden Datenverkehr für die EFA-Kommunikation finden Sie unter [SageMaker KI verteilte Trainingsaufgaben, die während der Initialisierung ins Stocken geraten](distributed-troubleshooting-data-parallel.md#distributed-ts-data-parallel-efa-sg).
+ Wenn Sie feststellen, dass ein **verteilter Trainingsjob beim Checkpoint des vollständigen Modells ins Stocken** gerät, kann das daran liegen, dass der `state_dict()` Aufruf des Modells oder Optimierers nicht auf allen Rängen mit `rdp_rank()==0` (bei Verwendung von Tensorparallelität) oder `dp_rank()==0` (bei ausschließlicher Verwendung von Pipeline-Parallelität) erfolgt ist. Diese Ränge müssen miteinander kommunizieren, um den Checkpoint zu erstellen, der gespeichert werden soll. Ähnliche Probleme können auch beim Checkpointing des partiellen Optimierers auftreten, wenn `shard_optimizer_state` aktiviert ist.
Weitere Informationen zum Checkpointing eines Modells mit Modellparallelität finden Sie unter [Allgemeine Anweisungen](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#general-instruction-for-saving-and-loading) zum Speichern und Laden und [Checkpointing für ein verteiltes PyTorch Modell (für die SageMaker Modellparallelitätsbibliothek zwischen v1.6.0 und v1.9.0)](distributed-model-parallel-checkpointing-and-finetuning.md#model-parallel-extended-features-pytorch-saving-loading-checkpoints).
+ Wenn der Trainingsjob mit dem **Fehler CUDA Out of Memory** abstürzt, bedeutet dies, dass die verteilte Trainingskonfiguration an das Modell auf dem GPU-Cluster angepasst werden muss. Weitere Informationen und bewährte Verfahren finden Sie unter [Die richtige Konfiguration für ein bestimmtes Modell einrichten](model-parallel-best-practices.md#model-parallel-best-practices-configuration).
+ Wenn der Trainingsjob mit einem **nicht behebbaren [ECC-Fehler](https://docs.nvidia.com/deploy/a100-gpu-mem-error-mgmt/index.html)** abstürzt, bedeutet dies, dass einer der Aufgaben GPUs im Cluster fehlerhaft geworden ist. Wenn Sie technischen Support benötigen, teilen Sie den Job-ARN mit dem AWS -Team und starten Sie Ihren Trainingsjob, wenn möglich, von einem Checkpoint aus neu.
+ In seltenen Fällen kann es vorkommen, dass eine Jobkonfiguration, die zuvor funktioniert hat, aber nahe an den Grenzen des GPU-Speichers liegt, später mit einem anderen Cluster aufgrund eines **CUDA-Fehlers Nicht genügend Arbeitsspeicher** fehlschlägt. Dies könnte daran liegen, dass einige GPUs aufgrund von ECC-Fehlern über weniger verfügbaren Arbeitsspeicher als gewöhnlich verfügen.
+ Ein **Netzwerk-Timeout-Absturz** kann auftreten, wenn ein Job mit mehreren Knoten ausgeführt wird, der nicht alle Knoten im Knoten verwendet. GPUs Um dieses Problem zu umgehen, verwenden Sie all GPUs auf dem Knoten, indem Sie sicherstellen, dass der `processes_per_host` Parameter auf die Anzahl von GPUs in jeder Instanz gesetzt ist. Zum Beispiel ist dies `processes_per_host=8` für `ml.p3.16xlarge`, `ml.p3dn.24xlarge` und `ml.p4d.24xlarge`-Instances.
+ Wenn Sie feststellen, dass Ihr Schulungsjob während des Herunterladens der Daten viel Zeit in Anspruch nimmt, stellen Sie sicher, dass der Amazon S3 S3-Pfad, den Sie `checkpoint_s3_uri` für den SageMaker `Estimator` Kurs angegeben haben, für den aktuellen Schulungsjob eindeutig ist. Wenn dieser Pfad für mehrere Trainingsjobs, die gleichzeitig ausgeführt werden, wiederverwendet wird, werden all diese Checkpoints auf denselben Amazon S3-Pfad hoch- und heruntergeladen, was die Ladezeit der Checkpoints erheblich verlängern kann.
+ Verwenden Sie FSx Lustre, wenn Sie mit großen Datenmengen und Modellen arbeiten.
+ Wenn Ihr Datensatz groß ist und das Abrufen lange dauert, empfehlen wir, Ihren Datensatz [FSx für](https://aws.amazon.com/fsx/lustre/) Lustre zu verwenden.
+ Wenn Trainingsmodelle mehr als 10 Milliarden Parameter enthalten, empfehlen wir die Verwendung von FSx for Lustre für das Checkpointing.
+ Nachdem Sie ein Dateisystem erstellt haben, warten Sie, bis der Status **verfügbar** ist, bevor Sie einen Trainingsjob mit diesem Dateisystem starten.
## Empfangen eines NCCL-Fehlers für einen Schulungsjob PyTorch
Wenn Sie auf den folgenden Fehler gestoßen sind, liegt dies möglicherweise daran, dass bei einem Prozess nicht mehr genügend GPU-Speicher zur Verfügung steht.
```
NCCL error in: ../torch/lib/c10d/ProcessGroupNCCL.cpp:825, unhandled system error, NCCL version 2.7.8
ncclSystemError: System call (socket, malloc, munmap, etc) failed.
```
Sie können dieses Problem beheben, indem Sie die Batchgröße reduzieren oder`active_microbatches`. Wenn die auto Partitionierung nicht zu einer ausgewogenen Partitionierung führt, müssen Sie möglicherweise eine manuelle Partitionierung in Betracht ziehen. Weitere Informationen finden Sie unter [Pipeline-Parallelität zwischen Knoten](model-parallel-best-practices.md#model-parallel-best-practices-configuration-pipeline-across-nodes).
## Empfang `RecursionError` für eine PyTorch Ausbildungsstelle
Die Bibliothek unterstützt das Aufrufen `super.forward()` innerhalb des Forward-Aufrufs eines Moduls nicht. Wenn Sie `super.forward()` verwenden, erhalten Sie möglicherweise die folgende Fehlermeldung.
```
RecursionError: maximum recursion depth exceeded
```
Um den Fehler zu beheben, sollten Sie nicht `super.forward()` anrufen, sondern `super()._orig_forward()`.