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. # Verteilte Schulungen in Amazon SageMaker AI SageMaker KI bietet verteilte Schulungsbibliotheken und unterstützt verschiedene verteilte Schulungsoptionen für Deep-Learning-Aufgaben wie Computer Vision (CV) und Verarbeitung natürlicher Sprache (NLP). Mit den verteilten Trainingsbibliotheken von SageMaker AI können Sie hoch skalierbare und kostengünstige benutzerdefinierte Daten parallel ausführen und parallele Deep-Learning-Trainingsjobs modellieren. Sie können auch andere verteilte Schulungs-Frameworks und -Pakete wie PyTorch DistributedDataParallel (DDP)`torchrun`, MPI (`mpirun`) und Parameterserver verwenden. Der folgende Abschnitt enthält Informationen über grundlegende Konzepte für verteiltes Training. In der gesamten Dokumentation konzentrieren sich Anleitungen und Beispiele darauf, wie die verteilten Trainingsoptionen für Deep-Learning-Aufgaben mithilfe des SageMaker Python-SDK eingerichtet werden. **Tipp** Bewährte Methoden für verteiltes Rechnen für Training und Verarbeitung von Machine Learning (ML) im Allgemeinen finden Sie unter [Verteiltes Rechnen mit Best Practices für SageMaker KI](distributed-training-options.md). ## Konzepte für verteiltes Training SageMaker Die verteilten Schulungsbibliotheken von AI verwenden die folgenden Begriffe und Funktionen für verteilte Schulungen. **Datensätze und Batches** + **Trainingsdatensatz**: Alle Daten, die Sie zum Trainieren des Modells verwenden. + **Globale Batchgröße**: Die Anzahl der Datensätze, die in jeder Iteration aus dem Trainingsdatensatz ausgewählt wurden, um sie an den GPUs im Cluster zu senden. Dies ist die Anzahl der Datensätze, über die die Steigung bei jeder Iteration berechnet wird. Wenn Datenparallelität verwendet wird, entspricht sie der Gesamtzahl der Modellreplikate multipliziert mit der Batch-Größe pro Replikat: `global batch size = (the number of model replicas) * (per-replica batch size)`. Eine einzelner Batch mit globaler Batch-Größe wird in der Fachliteratur zum Machine Learning oft als *Mini-Batch* bezeichnet. + **Batch-Größe pro Replikat:** Wenn Datenparallelität verwendet wird, ist dies die Anzahl der Datensätze, die an jedes Modellreplikat gesendet werden. Jedes Modellreplikat führt mit diesem Batch einen Vorwärts- und Rückwärtsdurchlauf durch, um Gewichtungsaktualisierungen zu berechnen. Die resultierenden Gewichtungsaktualisierungen werden für alle Replikate synchronisiert (gemittelt), bevor der nächste Satz von Pro-Replikat-Batches verarbeitet wird. + **Mikro-Batch**: Eine Teilmenge des Mini-Batch oder, wenn Hybridmodell und Datenparallelität verwendet werden, eine Teilmenge des Batches mit Größe pro Replikat. Wenn Sie die Bibliothek für verteilte Modellparallelität von SageMaker AI verwenden, wird jeder Mikrobatch in die Trainingspipeline eingespeist one-by-one und folgt einem [Ausführungsplan](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-core-features.html#model-parallel-pipeline-execution), der durch die Laufzeit der Bibliothek definiert wird. **Training** + **Epoche**: Ein Trainingszyklus durch den gesamten Datensatz. Es ist üblich, mehrere Iterationen pro Epoche durchzuführen. Die Anzahl der Epochen, die Sie beim Training verwenden, hängt von Ihrem Modell und Anwendungsfall ab. + **Iteration**: Ein einziger Vorwärts- und Rückwärtsdurchlauf, der mit einem globalen Batch (einem Mini-Batch) von Trainingsdaten durchgeführt wird. Die Anzahl der während des Trainings durchgeführten Iterationen wird durch die globale Batchgröße und die Anzahl der für das Training verwendeten Epochen bestimmt. Wenn ein Datensatz beispielsweise 5.000 Beispiel umfasst und Sie eine globale Batch-Größe von 500 verwenden, dauert es 10 Iterationen, bis eine einzelne Epoche abgeschlossen ist. + **Lernrate**: Eine Variable, die beeinflusst, wie stark Gewichtungen als Reaktion auf den berechneten Fehler des Modells geändert werden. Die Lernrate spielt eine wichtige Rolle bei der Konvergenzfähigkeit des Modells sowie der Geschwindigkeit und Optimalität der Konvergenz. **Instanzen und GPUs** + **Instanzen**: Eine [Recheninstanz für AWS maschinelles Lernen](https://aws.amazon.com/sagemaker/pricing/). Diese werden auch als *Knoten* bezeichnet. + **Clustergröße**: Bei Verwendung der verteilten Trainingsbibliothek von SageMaker AI ist dies die Anzahl der Instanzen multipliziert mit der Anzahl der GPUs in jeder Instanz. Wenn Sie beispielsweise zwei ml.p3.8xlarge-Instances mit jeweils 4 GPUs in einem Trainingsauftrag verwenden, beträgt die Cluster-Größe 8. Eine Erhöhung der Cluster-Größe kann zwar zu schnelleren Trainingszeiten führen, die Kommunikation zwischen den Instances muss jedoch optimiert werden. Andernfalls kann die Kommunikation zwischen den Knoten einen zusätzlichen Aufwand verursachen und zu langsameren Trainingszeiten führen. Die verteilte SageMaker AI-Trainingsbibliothek wurde entwickelt, um die Kommunikation zwischen Amazon EC2 ML-Recheninstanzen zu optimieren, was zu einer höheren Gerätenutzung und schnelleren Trainingszeiten führt. **Lösungen für verteilte Trainings** + **Datenparallelität**: Eine Strategie für verteilte Trainings, bei der ein Trainingsdatensatz auf mehrere GPUs in einem Datenverarbeitungs-Cluster aufgeteilt wird, das aus mehreren Amazon-EC2-ML-Instances besteht. Jede GPU enthält ein *Replikat* des Modells, empfängt unterschiedliche Batches von Trainingsdaten, führt einen Vorwärts- und Rückwärtsdurchlauf durch und teilt Gewichtungsaktualisierungen zur Synchronisation mit den anderen Knoten, bevor sie zum nächsten Batch und letztendlich zu einer anderen Epoche übergeht. + **Modellparallelität**: Eine Strategie für verteilte Trainings, bei der das Modell auf mehrere GPUs in einem Datenverarbeitungs-Cluster partitioniert wird, das aus mehreren Amazon-EC2-ML-Instances besteht. Das Modell kann komplex sein und eine große Anzahl von versteckten Ebenen und Gewichtungen aufweisen, sodass es nicht in den Speicher einer einzelnen Instance passt. Jede GPU enthält eine Teilmenge des Modells, über die die Datenabläufe und Transformationen gemeinsam genutzt und kompiliert werden. Die Effizienz der Modellparallelität in Bezug auf die GPU-Auslastung und die Trainingszeit hängt stark davon ab, wie das Modell partitioniert ist und welcher Ausführungsplan die Vorwärts- und Rückwärtsdurchläufe verwendet wird. + **Pipeline-Ausführungsplan** (**Pipelining**): Der Pipeline-Ausführungsplan bestimmt die Reihenfolge, in der Berechnungen (Mikro-Batches) 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 und den Leistungsverlust aufgrund sequentieller Berechnungen zu überwinden, indem die Berechnung gleichzeitig für verschiedene Datenproben durchgeführt wird. GPUs Weitere Informationen finden Sie unter [Pipeline-Ausführungsplan](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-core-features.html#model-parallel-pipeline-execution). ### Fortgeschrittene Konzepte Experten für Machine Learning (ML) stehen beim Trainieren von Modellen häufig vor zwei Skalierungsherausforderungen: *Skalierung der Modellgröße* und *Skalierung von Trainingsdaten*. Modellgröße und Komplexität können zwar zu einer besseren Genauigkeit führen, die Modellgröße, die in eine einzelne CPU oder GPU passt, ist jedoch begrenzt. Darüber hinaus kann die Skalierung der Modellgröße zu mehr Berechnungen und längeren Trainingszeiten führen. Nicht alle Modelle können mit der Skalierung von Trainingsdaten gleich gut umgehen, da sie für das Training alle Trainingsdaten *im Speicher* aufnehmen müssen. Sie skalieren nur vertikal und auf immer größere Instance-Typen. In den meisten Fällen führt die Skalierung von Trainingsdaten zu längeren Trainingszeiten. Deep Learning (DL) ist eine spezielle Familie von ML-Algorithmen, die aus mehreren Ebenen künstlicher neuronaler Netze besteht. Die gängigste Trainingsmethode ist Stochastic Gradient Descent (SGD) im Mini-Batch-Modus. Beim Mini-Batch-SGD wird das Modell trainiert, indem kleine iterative Änderungen seiner Koeffizienten in die Richtung vorgenommen werden, die seinen Fehler reduziert. Diese Iterationen werden an gleich großen Teilproben des Trainingsdatensatzes durchgeführt, die als *Mini-Batches* bezeichnet werden. Für jeden Mini-Batch wird das Modell in jedem Datensatz des Mini-Batches ausgeführt, wobei der Fehler gemessen und die Steigung des Fehlers geschätzt wird. Anschließend wird die durchschnittliche Steigung in allen Datensätzen des Mini-Batches gemessen und gibt eine Aktualisierungsrichtung für jeden Modellkoeffizienten vor. Ein vollständiger Durchlauf des Trainingsdatensatzes wird als *Epoche* bezeichnet. Modelltrainings bestehen üblicherweise aus Dutzenden bis Hunderten von Epochen. Mini-Batch-SGD hat mehrere Vorteile: Erstens sorgt das iterative Design dafür, dass die Trainingszeit theoretisch linear zur Datensatzgröße verläuft. Zweitens wird in einem bestimmten Mini-Batch jeder Datensatz einzeln vom Modell verarbeitet, ohne dass außer dem endgültigen Steigungsdurchschnitt eine Kommunikation zwischen den Datensätzen erforderlich ist. Die Verarbeitung eines Mini-Batches eignet sich daher besonders für die Parallelisierung und Verteilung.  Die Parallelisierung des SGD-Trainings durch Verteilung der Datensätze eines Mini-Batches auf verschiedene Computergeräte wird als *datenparalleles verteiltes Training* bezeichnet und ist das am häufigsten verwendete DL-Verteilungsparadigma. Datenparalleles Training ist eine wichtige Verteilungsstrategie, um die Größe der Mini-Batches zu skalieren und jeden Mini-Batch schneller zu verarbeiten. Datenparalleles Training bringt jedoch die zusätzliche Komplexität mit sich, dass der Steigungsdurchschnitt für Mini-Batches mit Steigungen von allen Auftragnehmern berechnet und an alle Auftragnehmer weitergegeben werden muss. Dieser Schritt wird *allreduce* genannt und kann einen wachsenden Mehraufwand bedeuten, da der Trainingscluster skaliert wird, was auch die Trainingszeit drastisch beeinträchtigen kann, wenn er falsch implementiert oder über unsachgemäße Hardware-Subtraktionen implementiert wird.  Datenparalleles SGD erfordert zudem, dass Entwickler in der Lage sind, mindestens das Modell und einen einzelnen Datensatz in ein Computergerät zu integrieren, z. B. eine einzelne CPU oder GPU. Beim Training sehr großer Modelle, wie z. B. großer Transformatoren bei Modellen der natürlichen Sprachverarbeitung (NLP) oder bei Segmentierungsmodellen für hochauflösende Bilder, kann es Situationen geben, in denen dies nicht möglich ist. Eine alternative Möglichkeit, die Workload aufzuteilen, besteht darin, das Modell auf mehrere Computergeräte zu partitionieren. Dieser Ansatz wird als *modellparalleles verteiltes Training* bezeichnet. # Beginnen Sie mit verteilten Schulungen in Amazon SageMaker AI Auf der folgenden Seite finden Sie Informationen zu den Schritten, die für den Einstieg in verteilte Schulungen in Amazon SageMaker AI erforderlich sind. Wenn Sie bereits mit verteilten Trainings vertraut sind, wählen Sie zunächst eine der folgenden Optionen, die Ihrer bevorzugten Strategie oder Ihrem bevorzugten Framework entspricht. Weitere Informationen zu verteilten Trainings im Allgemeinen finden Sie unter [Konzepte für verteiltes Training](distributed-training.md#distributed-training-basic-concepts). Die verteilten SageMaker KI-Schulungsbibliotheken sind für die SageMaker Schulungsumgebung optimiert. Sie helfen Ihnen dabei, Ihre verteilten Schulungsaufgaben an SageMaker KI anzupassen und die Trainingsgeschwindigkeit und den Durchsatz zu verbessern. Die Bibliotheken bieten sowohl datenparallele als auch modellparallele Trainingsstrategien. Sie kombinieren Software- und Hardwaretechnologien, um die Kommunikation zwischen GPU und Knoten zu verbessern und die Trainingsmöglichkeiten von SageMaker KI um integrierte Optionen zu erweitern, die nur minimale Codeänderungen an Ihren Trainingsskripten erfordern.  ## Bevor Sie beginnen: SageMaker Training unterstützt verteilte Schulungen sowohl auf einer einzelnen Instanz als auch auf mehreren Instanzen, sodass Sie Schulungen jeder Größe in großem Umfang durchführen können. Wir empfehlen Ihnen, die Framework-Estimator-Klassen wie [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator)und [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)im SageMaker Python-SDK zu verwenden. Dabei handelt es sich um die Trainingsjob-Starter mit verschiedenen verteilten Trainingsoptionen. Wenn Sie ein Schätzerobjekt erstellen, richtet das Objekt eine verteilte Trainingsinfrastruktur ein, führt die `CreateTrainingJob` API im Backend aus, findet die Region, in der Ihre aktuelle Sitzung läuft, und ruft einen der vorgefertigten AWS Deep-Learning-Container ab, der mit einer Reihe von Bibliotheken wie Deep-Learning-Frameworks, verteilten Trainingsframeworks und dem [EFA-Treiber](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) vorkonfiguriert ist. Wenn Sie ein FSx Dateisystem für die Trainingsinstanzen bereitstellen möchten, müssen Sie Ihr VPC-Subnetz und Ihre Sicherheitsgruppen-ID an den Estimator übergeben. Bevor Sie Ihren verteilten Trainingsjob in SageMaker KI ausführen, lesen Sie die folgenden allgemeinen Hinweise zur grundlegenden Einrichtung der Infrastruktur. ### Availability Zones und Netzwerk-Backplane Bei der Verwendung mehrerer Instances (auch *Knoten* genannt) ist es wichtig, das Netzwerk zu verstehen, das die Instances verbindet, wie die Trainingsdaten gelesen und wie Informationen untereinander ausgetauscht werden. Wenn Sie beispielsweise einen verteilten datenparallelen Trainingsjob ausführen, spielen eine Reihe von Faktoren, wie die Kommunikation zwischen den Knoten eines Rechenclusters zur Ausführung des `AllReduce` Vorgangs und die Datenübertragung zwischen den Knoten und die Datenspeicherung in Amazon Simple Storage Service oder Amazon FSx for Lustre, eine entscheidende Rolle, um eine optimale Nutzung der Rechenressourcen und eine schnellere Trainingsgeschwindigkeit zu erreichen. Um den Kommunikationsaufwand zu reduzieren, stellen Sie sicher, dass Sie Instanzen, VPC-Subnetz und Datenspeicher in derselben AWS-Region und in der Availability Zone konfigurieren. ### GPU-Instances mit schnellerem Netzwerk und Speicher mit hohem Durchsatz Sie können technisch gesehen beliebiges Instances für verteilte Trainings verwenden. Für Fälle, in denen Sie verteilte Trainingsjobs mit mehreren Knoten ausführen müssen, um große Modelle wie große Sprachmodelle (LLMs) und Diffusionsmodelle zu trainieren, die eine schnellere Kommutierung zwischen den Knoten erfordern, empfehlen wir [EFA-fähige](https://aws.amazon.com/about-aws/whats-new/2021/05/amazon-sagemaker-supports-elastic-fabric-adapter-distributed-training/) GPU-Instances, die von KI unterstützt werden. SageMaker Insbesondere um die leistungsstärkste verteilte Trainingsaufgabe in SageMaker KI zu erreichen, empfehlen wir [P4d- und P4de-Instances](https://aws.amazon.com/ec2/instance-types/p4/), die mit NVIDIA A100 ausgestattet sind. GPUs Diese sind außerdem mit lokalem Instance-Speicher mit hohem Durchsatz und niedriger Latenz sowie schnellerem Knotennetzwerk ausgestattet. Für die Datenspeicherung empfehlen wir [Amazon FSx for Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html), das einen hohen Durchsatz für die Speicherung von Trainingsdatensätzen und Modell-Checkpoints bietet. **Verwenden Sie die SageMaker AI-Bibliothek für verteilte Datenparallelität (SMDDP)** Die SMDDP-Bibliothek verbessert die Kommunikation zwischen Knoten durch Implementierungen `AllReduce` und `AllGather` kollektive Kommunikationsoperationen, die für die AWS Netzwerkinfrastruktur und die Amazon SageMaker AI ML-Instance-Topologie optimiert sind. [Sie können die [SMDDP-Bibliothek als Backend für PyTorch basierte verteilte Trainingspakete verwenden: PyTorch Distributed](https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel-modify-sdp-pt.html)[Data Parallel (DDP)](https://pytorch.org/docs/stable/notes/ddp.html), [PyTorch Fully Sharded Data Parallelism (FSDP](https://pytorch.org/docs/stable/fsdp.html)) und Megatron-. [DeepSpeed](https://github.com/microsoft/DeepSpeed)DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed) Das folgende Codebeispiel zeigt, wie Sie eine `PyTorch`-Schätzfunktion für das Starten eines verteilten Trainingsjobs auf zwei `ml.p4d.24xlarge`-Instances festlegen. ``` from sagemaker.pytorch import PyTorch estimator = PyTorch( ..., instance_count=2, instance_type="ml.p4d.24xlarge", # Activate distributed training with SMDDP distribution={ "pytorchddp": { "enabled": True } } # mpirun, activates SMDDP AllReduce OR AllGather # distribution={ "torch_distributed": { "enabled": True } } # torchrun, activates SMDDP AllGather # distribution={ "smdistributed": { "dataparallel": { "enabled": True } } } # mpirun, activates SMDDP AllReduce OR AllGather ) ``` Informationen zum Erstellen Ihres Schulungsskripts und zum Starten eines verteilten datenparallelen Trainingsjobs für SageMaker KI finden Sie unter[Führen Sie verteilte Schulungen mit der SageMaker KI-Bibliothek für verteilte Datenparallelität durch](data-parallel.md). **Verwenden Sie die SageMaker AI Model Parallelism Library (SMP)** SageMaker AI stellt die SMP-Bibliothek bereit und unterstützt verschiedene verteilte Trainingstechniken wie Sharded Data Parallelism, Pipelining, Tensor Parallelism, Optimizer State Sharding und mehr. Weitere Informationen über das Angebot der SMP-Bibliothek finden Sie unter [Kernfunktionen der SageMaker Model Parallelism Library](model-parallel-core-features.md). Um die Modellparallelismus-Bibliothek von SageMaker AI zu verwenden, konfigurieren Sie die Parameter der KI-Framework-Schätzer. `distribution` SageMaker Unterstützte Framework-Schätzer sind und. [PyTorch[TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) Das folgende Codebeispiel zeigt, wie Sie eine Framework-Schätzfunktion für verteilte Trainings mit der Modellparallelitätsbibliothek auf zwei `ml.p4d.24xlarge`-Instances erstellen. ``` from sagemaker.framework import Framework distribution={ "smdistributed": { "modelparallel": { "enabled":True, "parameters": { ... # enter parameter key-value pairs here } }, }, "mpi": { "enabled" : True, ... # enter parameter key-value pairs here } } estimator = Framework( ..., instance_count=2, instance_type="ml.p4d.24xlarge", distribution=distribution ) ``` Informationen dazu, wie Sie Ihr Trainingsskript anpassen, Verteilungsparameter in der `estimator` Klasse konfigurieren und einen verteilten Trainingsjob starten, finden Sie in der [Modellparallelismus-Bibliothek von SageMaker AI](model-parallel.md) (siehe auch [Distributed Training APIs](https://sagemaker.readthedocs.io/en/stable/api/training/distributed.html#the-sagemaker-distributed-model-parallel-library) in der *SageMaker Python SDK-Dokumentation*). **Verwenden verteilter Open-Source-Trainingsframeworks** SageMaker KI unterstützt auch die folgenden Optionen für den Betrieb `mpirun` und `torchrun` im Backend. + Um [PyTorch DistributedDataParallel (DDP)](https://pytorch.org/docs/master/generated/torch.nn.parallel.DistributedDataParallel.html) in SageMaker KI mit dem `mpirun` Backend zu verwenden, fügen Sie es Ihrem Schätzer `distribution={"pytorchddp": {"enabled": True}}` hinzu. PyTorch Weitere Informationen finden Sie auch unter [PyTorch Distributed Training](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#distributed-pytorch-training) and [SageMaker AI PyTorch Estimator's](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) `distribution` argument in der *SageMaker Python SDK-Dokumentation*. **Anmerkung** Diese Option ist für PyTorch 1.12.0 und höher verfügbar. ``` from sagemaker.pytorch import PyTorch estimator = PyTorch( ..., instance_count=2, instance_type="ml.p4d.24xlarge", distribution={"pytorchddp": {"enabled": True}} # runs mpirun in the backend ) ``` + SageMaker [KI unterstützt den [PyTorch `torchrun`Launcher](https://pytorch.org/docs/stable/elastic/run.html) für verteiltes Training auf GPU-basierten Amazon EC2 EC2-Instances wie P3 und P4 sowie Trn1, das vom Trainium-Gerät betrieben wird.AWS](https://aws.amazon.com/machine-learning/trainium/) Um [PyTorch DistributedDataParallel (DDP)](https://pytorch.org/docs/master/generated/torch.nn.parallel.DistributedDataParallel.html) in KI mit dem Backend zu verwenden, fügen Sie es dem Schätzer hinzu SageMaker . `torchrun` `distribution={"torch_distributed": {"enabled": True}}` PyTorch **Anmerkung** Diese Option ist für PyTorch 1.13.0 und höher verfügbar. Der folgende Codeausschnitt zeigt ein Beispiel für die Konstruktion eines SageMaker PyTorch KI-Estimators zur Ausführung von verteiltem Training auf zwei `ml.p4d.24xlarge` Instances mit der Verteilungsoption. `torch_distributed` ``` from sagemaker.pytorch import PyTorch estimator = PyTorch( ..., instance_count=2, instance_type="ml.p4d.24xlarge", distribution={"torch_distributed": {"enabled": True}} # runs torchrun in the backend ) ``` Weitere Informationen finden Sie unter [Distributed PyTorch Training](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#distributed-pytorch-training) and [SageMaker AI PyTorch Estimator's](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) `distribution` argument in der *SageMaker Python SDK-Dokumentation*. **Hinweise für verteilte Trainings auf Trn1** Eine Trn1-Instanz besteht aus bis zu 16 Trainium-Geräten, und jedes Trainium-Gerät besteht aus zwei. [NeuronCores](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/general/arch/neuron-hardware/neuroncores-arch.html#neuroncores-v2-arch) [https://awsdocs-neuron.readthedocs-hosted.com/en/latest/general/arch/neuron-hardware/trn1-arch.html#id2](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/general/arch/neuron-hardware/trn1-arch.html#id2) Um auf den Trainium-basierten Instances zu trainieren, müssen Sie nur den Trn1-Instanzcode als Zeichenfolge für das Argument der `ml.trn1.*` AI-Estimator-Klasse angeben. `instance_type` SageMaker PyTorch Die verfügbaren Trn1-Instance-Typen finden Sie unter [AWS Trn1-Architektur](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/general/arch/neuron-hardware/trn1-arch.html#aws-trn1-arch) in der *AWS Neuron-Dokumentation*. **Anmerkung** SageMaker Schulungen zu Amazon EC2 Trn1-Instances sind derzeit nur für das PyTorch Framework in den AWS Deep Learning Containers for PyTorch Neuron ab Version 1.11.0 verfügbar. Eine vollständige Liste der unterstützten Versionen von PyTorch Neuron finden Sie unter [Neuron Containers im AWS Deep Learning Containers GitHub ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) *Repository*. Wenn Sie mithilfe des SageMaker Python-SDK einen Trainingsjob auf Trn1-Instances starten, nimmt SageMaker KI automatisch den richtigen Container aus [Neuron Containers auf und führt ihn aus, die von AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) bereitgestellt werden. Die Neuron Container sind mit Einstellungen und Abhängigkeiten für die Trainingsumgebung vorkonfiguriert, sodass Sie Ihre Trainingsaufgabe leichter an die SageMaker Trainingsplattform und Amazon EC2 Trn1-Instances anpassen können. **Anmerkung** [Um Ihren PyTorch Trainingsjob auf Trn1-Instances mit SageMaker KI auszuführen, sollten Sie Ihr Trainingsskript so ändern, dass Prozessgruppen mit dem Backend initialisiert und /XLA verwendet werden. `xla` PyTorch](https://pytorch.org/xla/release/1.12/index.html) Zur Unterstützung des XLA-Einführungsprozesses bietet das Neuron SDK AWS Neuron, das XLA verwendet, um Operationen in PyTorch Trainium-Befehle umzuwandeln. PyTorch *Informationen zum Ändern Ihres Trainingsskripts finden Sie im [Developer Guide for Training with PyTorch Neuron () in der Neuron-Dokumentation](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/frameworks/torch/torch-neuronx/programming-guide/training/pytorch-neuron-programming-guide.html). `torch-neuronx`AWS * *Weitere Informationen finden Sie unter [Distributed Training with PyTorch Neuron on Trn1-Instances](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id24) und dem `distribution` Argument von [SageMaker AI PyTorch Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) in der SageMaker Python SDK-Dokumentation.* + Um MPI in SageMaker KI zu verwenden, fügen Sie es Ihrem Estimator hinzu. `distribution={"mpi": {"enabled": True}}` Die MPI-Verteilungsoption ist für die folgenden Frameworks verfügbar: MXNet, und PyTorch. TensorFlow + Um einen Parameterserver in SageMaker AI zu verwenden, fügen Sie ihn `distribution={"parameter_server": {"enabled": True}}` zu Ihrem Schätzer hinzu. Die Parameterserveroption ist für die folgenden Frameworks verfügbar: MXNet PyTorch, und TensorFlow. **Tipp** Weitere Informationen zur Verwendung der MPI- und Parameterserveroptionen pro Framework finden Sie unter den folgenden Links zur *SageMaker Python SDK-Dokumentation*. [MXNet Distributed Training](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html#distributed-training) und das Argument von [SageMaker AI MXNet Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html#mxnet-estimator) `distribution` PyTorch Das Argument von [Distributed Training](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#distributed-pytorch-training) und [SageMaker KI PyTorch Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) `distribution` TensorFlow Das Argument von [Distributed Training](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/using_tf.html#distributed-training) und [SageMaker AI TensorFlow Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator). `distribution` # Strategien für verteiltes Training Verteilte Trainings werden normalerweise nach zwei Ansätzen aufgeteilt: datenparallel und modellparallel. *Datenparallelität* ist der gängigste Ansatz für verteiltes Training: Sie haben eine Menge Daten, stapeln sie und senden Datenblöcke an mehrere CPUs oder GPUs (Knoten), um sie vom neuronalen Netzwerk oder dem ML-Algorithmus zu verarbeiten, und kombinieren dann die Ergebnisse. Das neuronale Netzwerk ist auf jedem Knoten dasselbe. Ein *modellparalleler* Ansatz wird bei großen Modellen verwendet, die nicht in einem Stück in den Speicher eines Knotens passen. Das Modell wird zerlegt, und verschiedene Teile werden auf verschiedenen Knoten platziert. In diesem Fall müssen Sie Ihre Daten-Batches an jeden Knoten senden, damit die Daten in allen Teilen des Modells verarbeitet werden. Die Begriffe *Netzwerk* und *Modell* werden oft synonym verwendet: Ein großes Modell ist in Wirklichkeit ein großes Netzwerk mit vielen Ebenen und Parametern. Beim Training mit einem großen Netzwerk entsteht ein großes Modell, und wenn Sie das Modell mit all Ihren vorab trainierten Parametern und deren Gewichtungen wieder in das Netzwerk laden, wird ein großes Modell in den Speicher geladen. Wenn Sie ein Modell zerlegen, um es auf mehrere Knoten aufzuteilen, zerlegen Sie auch das zugrunde liegende Netzwerk. Ein Netzwerk besteht aus Ebenen, und um das Netzwerk aufzuteilen, platzieren Sie Ebenen auf verschiedenen Datenverarbeitungsgeräten. Ein häufiger Fallstrick bei der naiven Aufteilung von Ebenen auf mehrere Geräte ist die starke Unterauslastung der GPU. Das Training erfolgt grundsätzlich sequenziell, sowohl in Vorwärts- als auch in Rückwärtsdurchgängen. Zu einem bestimmten Zeitpunkt kann nur eine GPU aktiv verarbeiten, während die anderen darauf warten, dass die Aktivierungen gesendet werden. Moderne modellparallele Bibliotheken lösen dieses Problem, indem sie Pipeline-Ausführungspläne verwenden, um die Geräteauslastung zu verbessern. Allerdings beinhaltet nur die verteilte Modellparallelbibliothek von Amazon SageMaker AI die automatische Modellteilung. Die beiden Kernfunktionen der Bibliothek, die automatische Modellaufteilung und die Planung der Pipeline-Ausführung, vereinfachen den Prozess der Implementierung der Modellparallelität, indem automatisierte Entscheidungen getroffen werden, die zu einer effizienten Geräteauslastung führen. ## Training mit Datenparallelität und Modellparallelität Wenn Sie mit einem großen Datensatz trainieren, beginnen Sie mit einem datenparallelen Ansatz. Wenn Ihnen während des Trainings der Speicherplatz ausgeht, sollten Sie zu einem modellparallelen Ansatz wechseln oder eine hybride Modell- und Datenparallelität ausprobieren. Sie können auch Folgendes versuchen, um die Leistung mit Datenparallelität zu verbessern: + Ändern Sie die Hyperparameter Ihres Modells. + Verringern Sie die Batch-Größe. + Verringern Sie die Batch-Größe so lange, bis sie passt. Wenn Sie die Batch-Größe auf 1 verringern und immer noch nicht genügend Arbeitsspeicher zur Verfügung steht, sollten Sie es mit modellparallelem Training versuchen. Versuchen Sie es mit Gradientenkomprimierung (FP16, INT8): + Auf mit NVIDIA TensorCore ausgestatteter Hardware führt die Verwendung von [Mixed-Precision-Training](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html) sowohl zu einer Beschleunigung als auch zu einer Reduzierung des Speicherverbrauchs. + SageMaker Die Bibliothek für verteilte Datenparallelität von AI unterstützt Automatic Mixed Precision (AMP) von Haus aus. Um AMP zu aktivieren, sind außer den Änderungen auf Framework-Ebene an Ihrem Trainingsskript keine weiteren Maßnahmen erforderlich. Wenn Gradienten aktiviert sind FP16, führt die SageMaker AI-Bibliothek für Datenparallelität ihren Betrieb in. `AllReduce` FP16 Weitere Informationen zur Implementierung von AMP APIs in Ihrem Trainingsskript finden Sie in den folgenden Ressourcen: + [Frameworks — PyTorch](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#pytorch) in der *Dokumentation zu NVIDIA Deep Learning Performance* + [Frameworks — TensorFlow](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#tensorflow) in der *Dokumentation zu NVIDIA Deep Learning Performance* + [Automatic Mixed Precision for Deep Learning](https://developer.nvidia.com/automatic-mixed-precision) in den *NVIDIA-Entwicklerdokumenten* + [Vorstellung der systemeigenen PyTorch automatischen Mixed-Precision-Technologie für schnelleres Training auf NVIDIA GPUs](https://pytorch.org/blog/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision/) im *PyTorch Blog* + [TensorFlow gemischte Präzision APIs](https://www.tensorflow.org/guide/mixed_precision) in der *TensorFlowDokumentation* Versuchen Sie, die Eingabegröße zu reduzieren: + Reduzieren Sie die Länge der NLP-Sequenz, wenn Sie den Sequenz-Link vergrößern, die Stapelgröße nach unten oder nach GPUs oben anpassen müssen, um den Stapel zu verteilen. + Verringern der Bildauflösung. Prüfen Sie, ob Sie die Batch-Normalisierung verwenden, da dies die Konvergenz beeinträchtigen kann. Wenn Sie verteiltes Training verwenden, wird Ihr Stapel aufgeteilt, GPUs und eine viel geringere Batchgröße kann zu einer höheren Fehlerquote führen, wodurch die Konvergenz des Modells gestört wird. Wenn Sie beispielsweise Ihr Netzwerk auf einer einzelnen GPU mit einer Batchgröße von 64 prototypisiert und dann auf vier p3dn.24xlarge hochskaliert haben, haben Sie jetzt 32 GPUs und Ihre Batchgröße pro GPU sinkt von 64 auf 2. Dadurch wird die Konvergenz, die Sie mit einem einzelnen Knoten hatten, wahrscheinlich durchbrochen. Beginnen Sie mit dem modellparallelen Training, wenn: + Ihr Modell nicht auf ein einzelnes Gerät passt. + Aufgrund Ihrer Modellgröße stoßen Sie bei der Auswahl größerer Batch-Größen auf Einschränkungen, z. B. wenn Ihre Modellgewichtungen den größten Teil Ihres GPU-Speichers beanspruchen und Sie gezwungen sind, eine kleinere, suboptimale Batch-Größe zu wählen.  Weitere Informationen zu den verteilten KI-Bibliotheken finden Sie im Folgenden: SageMaker + [Führen Sie verteilte Schulungen mit der SageMaker KI-Bibliothek für verteilte Datenparallelität durch](data-parallel.md) + [(Archiviert) SageMaker-Modellparallelitätsbibliothek v1.x](model-parallel.md) # Optimierung des verteilten Trainings Passen Sie Hyperparameter an Ihren Anwendungsfall und Ihre Daten an, um die beste Skalierungseffizienz zu erzielen. In der folgenden Diskussion heben wir einige der wichtigsten Trainingsvariablen hervor und geben Verweise auf state-of-the-art Implementierungen, damit Sie mehr über Ihre Optionen erfahren können. Wir empfehlen Ihnen außerdem, sich das Trainingsdokumentation Ihres bevorzugten Frameworks anzusehen. + [Von Apache verteilte Schulungen MXNet ](https://mxnet.apache.org/versions/1.7/api/faq/distributed_training) + [PyTorch verteiltes Training](https://pytorch.org/tutorials/beginner/dist_overview.html) + [TensorFlow verteiltes Training](https://www.tensorflow.org/guide/distributed_training) ## Batch-Größe SageMaker Mit verteilten KI-Toolkits können Sie in der Regel an größeren Chargen trainieren. Wenn ein Modell beispielsweise in ein einzelnes Gerät passt, aber nur mit einer kleinen Batch-Größe trainiert werden kann, können Sie entweder modellparallele Trainings oder datenparallele Trainings verwenden, um mit größeren Batch-Größen zu experimentieren. Beachten Sie, dass die Batch-Größe die Modellgenauigkeit direkt beeinflusst, indem sie bei jeder Iteration das Rauschen bei der Modellaktualisierung kontrolliert. Durch eine Erhöhung der Batch-Größe wird das Rauschen bei der Steigungsschätzung reduziert. Dies kann vorteilhaft sein, wenn von sehr kleinen Batch-Größen ausgegangen wird, es kann jedoch zu einer Verschlechterung der Modellgenauigkeit führen, wenn die Batch-Größe auf große Werte ansteigt.  **Tipp** Passen Sie Ihre Hyperparameter an, um sicherzustellen, dass Ihr Modell bei der Erhöhung der Batch-Größe auf eine zufriedenstellende Konvergenz trainiert wird. Es wurden eine Reihe von Techniken entwickelt, um eine gute Modellkonvergenz aufrechtzuerhalten, wenn der Batch erhöht wird. ## Mini-Batch-Größe In SGD quantifiziert die Größe der Mini-Batches das Ausmaß des Rauschens, das bei der Steigungsschätzung vorhanden ist. Ein kleiner Mini-Batch führt zu einer sehr verrauschten Mini-Batch-Steigung, die nicht repräsentativ für die tatsächliche Steigung über den Datensatz hinweg ist. Ein großer Mini-Batch führt zu einer Mini-Batch-Steigung, die der wahren Steigung über den Datensatz hinweg nahe kommt und deren Rauschen möglicherweise nicht stark genug ist – es ist wahrscheinlich, dass sie in irrelevanten Minima verharrt. Weitere Informationen zu diesen Techniken finden Sie in den folgenden Dokumenten: + [Präzise, große Minibatch-SGD: Schulung ImageNet in 1](https://arxiv.org/pdf/1706.02677.pdf) Stunde, Goya et al. + [PowerAI DDL](https://arxiv.org/pdf/1708.02188.pdf), Cho et al. + [Scale Out for Large Minibatch SGD: Restnetzwerktraining auf ImageNet -1K mit verbesserter Genauigkeit und kürzerer](https://arxiv.org/pdf/1711.04291.pdf) Trainingszeit, Codreanu et al. + [ImageNet Training in wenigen Minuten](https://arxiv.org/pdf/1709.05011.pdf), Sie et al. + [Large Batch Training of Convolutional Networks](https://arxiv.org/pdf/1708.03888.pdf), You et al. + [Large Batch Optimization for Deep Learning: Training BERT in 76 Minutes](https://arxiv.org/pdf/1904.00962.pdf), You et al. + [Accelerated Large Batch Optimization of BERT Pretraining in 54 minutes](https://arxiv.org/pdf/2006.13484.pdf), Zheng et al. + [Deep Gradient Compression](https://arxiv.org/abs/1712.01887), Lin et al. # Training skalieren In den folgenden Abschnitten werden Szenarien behandelt, in denen Sie das Training möglicherweise erweitern möchten, und wie Sie dies mithilfe von AWS Ressourcen tun können. In einem der folgenden Fälle empfiehlt es sich möglicherweise, das Training zu skalieren: + Skalierung von einer einzelnen GPU auf viele GPUs + Skalieren von einer einzelnen Instance auf mehrere Instances + Benutzerdefinierte Trainingsskripte verwenden ## Skalierung von einer einzelnen GPU auf viele GPUs Die Datenmenge oder die Größe des Modells, das beim Machine Learning verwendet wird, können zu Situationen führen, in denen das Training eines Modells länger dauert als Sie warten möchten. Manchmal funktioniert das Training überhaupt nicht, weil das Modell oder die Trainingsdaten zu groß sind. Eine Lösung besteht darin, die Anzahl der Geräte zu erhöhen, die GPUs Sie für das Training verwenden. Bei einer Instanz mit mehreren GPUs, z. B. einer `p3.16xlarge` Instanz mit acht GPUs, werden die Daten und die Verarbeitung auf die acht aufgeteilt GPUs. Wenn Sie verteilte Trainingsbibliotheken verwenden, kann dies zu einer nahezu linearen Beschleunigung der Zeit führen, die für das Trainieren Ihres Modells benötigt wird. Es dauert etwas mehr als ein Achtel der Zeit, die es in `p3.2xlarge` mit einer GPU gedauert hätte. | Instance-Typ | GPUs | | --- | --- | | p3.2xgroß | 1 | | p3.8xgroß | 4 | | p3.16xgroß | 8 | | p3dn.24xgroß | 8 | **Anmerkung** Die beim SageMaker Training verwendeten ML-Instanztypen haben dieselbe Anzahl GPUs wie die entsprechenden p3-Instanztypen. `ml.p3.8xlarge`Hat zum Beispiel dieselbe Anzahl von GPUs wie `p3.8xlarge` - 4. ## Skalieren von einer einzelnen Instance auf mehrere Instances Wenn Sie Ihr Training noch weiter skalieren möchten, können Sie mehr Instances verwenden. Sie sollten jedoch einen größeren Instance-Typ wählen, bevor Sie weitere Instances hinzufügen. Sehen Sie sich die vorherige Tabelle an, um zu sehen, wie GPUs viele es in jedem p3-Instance-Typ gibt. Wenn Sie den Sprung von einer einzelnen GPU auf eine auf vier GPUs auf eine geschafft haben`p3.8xlarge`, aber `p3.2xlarge` zu dem Schluss kommen, dass Sie mehr Rechenleistung benötigen, können Sie eine bessere Leistung und geringere Kosten erzielen, wenn Sie sich für eine entscheiden, `p3.16xlarge` bevor Sie versuchen, die Anzahl der Instanzen zu erhöhen. Je nachdem, welche Bibliotheken Sie verwenden, sind die Leistung besser und die Kosten niedriger als bei einem Szenario, in dem Sie mehrere Instances verwenden, wenn Sie das Training auf einer einzelnen Instance fortsetzen. Wenn Sie bereit sind, die Anzahl der Instanzen zu skalieren, können Sie dies mit der SageMaker AI Python `estimator` SDK-Funktion tun, indem Sie Ihre einstellen`instance_count`. Sie können beispielsweise `instance_type = p3.16xlarge` und `instance_count = 2` festlegen. Statt der acht GPUs bei einer einzigen stehen `p3.16xlarge` Ihnen 16 GPUs für zwei identische Instanzen zur Verfügung. Das folgende Diagramm zeigt [Skalierung und Durchsatz, angefangen bei acht GPUs](https://aws.amazon.com/blogs/machine-learning/scalable-multi-node-training-with-tensorflow/) auf einer einzelnen Instance bis hin zu 64 Instances, also insgesamt 256 GPUs. ![\[Chart showing how throughput increases and time to train decreases with more GPUs.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/Distributed-Training-in-SageMaker-image.png) ## Benutzerdefinierte Trainingsskripte SageMaker KI macht es zwar einfach, die Anzahl der Instanzen bereitzustellen und zu skalieren GPUs, und je nach Framework Ihrer Wahl kann die Verwaltung der Daten und Ergebnisse sehr schwierig sein, weshalb häufig externe unterstützende Bibliotheken verwendet werden. Diese einfachste Form des verteilten Trainings erfordert eine Änderung Ihres Trainingsskripts, um die Datenverteilung zu verwalten. SageMaker KI unterstützt auch Horovod und Implementierungen von verteiltem Training, die für jedes wichtige Deep-Learning-Framework systemspezifisch sind. Wenn Sie sich dafür entscheiden, Beispiele aus diesen Frameworks zu verwenden, können Sie dem [Container-Leitfaden](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers.html) von SageMaker AI für Deep Learning Containers und verschiedenen [Beispielnotizbüchern](https://sagemaker-examples.readthedocs.io/en/latest/training/bring_your_own_container.html) folgen, die Implementierungen demonstrieren. # Führen Sie verteilte Schulungen mit der SageMaker KI-Bibliothek für verteilte Datenparallelität durch Die SageMaker AI-Bibliothek für verteilte Datenparallelität (SMDDP) erweitert die SageMaker Trainingsmöglichkeiten für Deep-Learning-Modelle mit nahezu linearer Skalierungseffizienz, indem sie Implementierungen von kollektiven Kommunikationsoperationen bereitstellt, die für die Infrastruktur optimiert sind. AWS Beim Training großer Machine-Learning-Modelle (ML), wie z. B. große Sprachmodelle (LLM) und Diffusionsmodelle, auf einem riesigen Trainingsdatensatz verwenden ML-Praktiker Cluster von Beschleunigern und verteilte Trainingstechniken, um die Zeit für das Training zu reduzieren oder Speicherbeschränkungen für Modelle zu lösen, die nicht in jeden GPU-Speicher passen. ML-Praktiker beginnen häufig mit mehreren Beschleunigern auf einer einzigen Instance und skalieren dann auf Cluster von Instances, wenn ihre Workload-Anforderungen steigen. Mit zunehmender Clustergröße nimmt auch der Kommunikationsaufwand zwischen mehreren Knoten zu, was zu einem Rückgang der gesamten Rechenleistung führt. Um solchen Aufwands- und Speicherproblemen zu begegnen, bietet die SMDDP-Bibliothek Folgendes. + Die SMDDP-Bibliothek optimiert Trainingsaufgaben für die AWS Netzwerkinfrastruktur und die Amazon SageMaker AI ML-Instance-Topologie. + Die SMDDP-Bibliothek verbessert die Kommunikation zwischen Knoten durch Implementierungen `AllReduce` und `AllGather` kollektive Kommunikationsoperationen, die für die Infrastruktur optimiert sind. AWS Weitere Informationen dazu, was die SMDDP-Bibliothek bietet, finden Sie unter [Einführung in die SageMaker KI-Bibliothek für verteilte Datenparallelität](data-parallel-intro.md). Weitere Informationen zum Training mit der von SageMaker KI angebotenen modellparallelen Strategie finden Sie auch unter. [(Archiviert) SageMaker-Modellparallelitätsbibliothek v1.x](model-parallel.md) **Topics** + [Einführung in die SageMaker KI-Bibliothek für verteilte Datenparallelität](data-parallel-intro.md) + [Unterstützte Frameworks AWS-Regionen und Instanztypen](distributed-data-parallel-support.md) + [Verteiltes Training mit der SageMaker KI-Bibliothek für verteilte Datenparallelität](data-parallel-modify-sdp.md) + [Beispiele für die Amazon SageMaker AI-Bibliothek zur Datenparallelität](distributed-data-parallel-v2-examples.md) + [Konfigurationstipps für die SageMaker KI-Bibliothek für verteilte Datenparallelität](data-parallel-config.md) + [Häufig gestellte Fragen zur Amazon-SMDDP-Bibliothek (SageMaker AI Distributed Data Parallelism)](data-parallel-faq.md) + [Fehlerbehebung für verteilte Schulungen in Amazon SageMaker AI](distributed-troubleshooting-data-parallel.md) + [SageMaker Versionshinweise zur Bibliothek für KI-Datenparallelität](data-parallel-release-notes.md) # Einführung in die SageMaker KI-Bibliothek für verteilte Datenparallelität Die SageMaker AI Distributed Data Parallelism (SMDDP) -Bibliothek ist eine kollektive Kommunikationsbibliothek, die die Rechenleistung des parallel Trainings mit verteilten Daten verbessert. Die SMDDP-Bibliothek trägt dem Kommunikationsaufwand der wichtigsten kollektiven Kommunikationsoperationen Rechnung, indem sie Folgendes bietet. 1. Die Bibliothek bietet optimierte Angebote für. `AllReduce` AWS`AllReduce`ist eine wichtige Operation, mit der Gradienten am Ende jeder Trainingsiteration GPUs beim Training mit verteilten Daten synchronisiert werden. 1. Die Bibliothek bietet optimierte Angebote `AllGather` für. AWS`AllGather`ist eine weitere wichtige Operation, die beim Sharded Data Parallel Training verwendet wird. Dabei handelt es sich um eine speichereffiziente Datenparallelitätstechnik, die von beliebten Bibliotheken wie der SageMaker AI Model Parallelism (SMP) -Bibliothek, dem DeepSpeed Zero Redundancy Optimizer (ZerO) und Fully Sharded Data Parallelism (FSDP) angeboten wird. PyTorch 1. Die Bibliothek ermöglicht eine optimierte node-to-node Kommunikation, indem sie die AWS Netzwerkinfrastruktur und die Amazon EC2 EC2-Instance-Topologie vollständig nutzt. Die SMDDP-Bibliothek kann die Trainingsgeschwindigkeit erhöhen, indem sie bei der Skalierung Ihres Trainingsclusters eine Leistungsverbesserung mit nahezu linearer Skalierungseffizienz bietet. **Anmerkung** Die über SageMaker KI verteilten Schulungsbibliotheken sind über die AWS Deep-Learning-Container für PyTorch und Hugging Face auf der SageMaker Trainingsplattform verfügbar. Um die Bibliotheken verwenden zu können, müssen Sie das SageMaker Python-SDK oder das SageMaker APIs Through-SDK für 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. ## Kollektive SMDDP-Kommunikationsoperationen, optimiert für AWS Rechenressourcen und Netzwerkinfrastruktur Die SMDDP-Bibliothek bietet Implementierungen `AllReduce` und `AllGather` kollektive Operationen, die für AWS Rechenressourcen und Netzwerkinfrastruktur optimiert sind. ### Kollektive `AllReduce`-Operation mit SMDDP Die SMDDP-Bibliothek sorgt für eine optimale Überlappung der `AllReduce`-Operation mit dem Rückwärtsdurchlauf, wodurch die GPU-Auslastung erheblich verbessert wird. Durch die Optimierung der Kerneloperationen zwischen und wird eine nahezu lineare Skalierungseffizienz und eine schnellere Trainingsgeschwindigkeit erreicht. CPUs GPUs Die Bibliothek führt `AllReduce` parallel aus, während die GPU Gradienten berechnet, ohne zusätzliche GPU-Zyklen in Anspruch zu nehmen, wodurch die Bibliothek ein schnelleres Training erzielt. + *Vorteile CPUs*: Die Bibliothek verwendet zwei `AllReduce` Gradienten und CPUs entlastet diese Aufgabe von der. GPUs + *Verbesserte GPU-Nutzung*: Der GPUs Schwerpunkt des Clusters liegt auf der Berechnung von Gradienten, wodurch deren Nutzung während des gesamten Trainings verbessert wird. Im Folgenden wird der allgemeine Arbeitsablauf der SMDDP-`AllReduce`-Operation beschrieben. 1. Die Bibliothek weist GPUs (Arbeitern) Dienstgrade zu. 1. Bei jeder Iteration teilt die Bibliothek jeden globalen Stapel durch die Gesamtzahl der Arbeiter (Weltgröße) und weist den Arbeitern kleine Chargen (Batch-Shards) zu. + Die Größe des globalen Batches ist `(number of nodes in a cluster) * (number of GPUs per node) * (per batch shard)`. + Ein Batch-Shard (kleiner Batch) ist eine Teilmenge von Datensätzen, die jeder GPU (Worker) pro Iteration zugewiesen wird. 1. Die Bibliothek startet für jeden Worker ein Trainingsskript. 1. In der Bibliothek werden am Ende jeder Iteration Kopien der Modellgewichte und -verläufe von den Workern verwaltet. 1. Die Bibliothek synchronisiert die Gewichte und Farbverläufe der Modelle der einzelnen Worker, um ein einziges trainiertes Modell zu aggregieren. Das folgende Architekturdiagramm zeigt ein Beispiel dafür, wie die Bibliothek Datenparallelität für einen Cluster von 3 Knoten einrichtet. ![\[Architekturdiagramm für SMDDP AllReduce und Datenparallelität\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/distributed/data-parallel/sdp-architecture.png) ### Kollektive SMDDP-`AllGather`-Operation `AllGather` ist eine kollektive Operation, bei der jeder Worker mit einem Eingabepuffer beginnt und dann die Eingabepuffer aller anderen Worker zu einem Ausgabepuffer verkettet oder *zusammenfasst*. **Anmerkung** Der `AllGather` gemeinsame SMDDP-Vorgang ist in `smdistributed-dataparallel>=2.0.1` und AWS Deep Learning Containers (DLC) für Version 2.0.1 und höher verfügbar PyTorch . `AllGather` wird häufig für verteilte Trainingstechniken wie die Parallelität fragmentierter Daten verwendet, bei der jeder einzelne Worker einen Bruchteil eines Modells oder eine fragmentierte Ebene besitzt. Die Worker rufen `AllGather` vor Vorwärts- und Rückwärtsdurchläufen auf, um die fragmentierten Ebenen zu rekonstruieren. Die Vorwärts- und Rückwärtsdurchläufe setzen sich fort, nachdem *alle Parameter erfasst* wurden. Während des Rückwärtsdurchlaufs ruft jeder Worker außerdem `ReduceScatter` auf, um Gradienten zu sammeln (zu reduzieren) und sie in Gradientenfragmente zu zerlegen (zu zerteilen), um die entsprechende fragmentierte Ebene zu aktualisieren. [Weitere Informationen zur Rolle dieser kollektiven Operationen beim Sharded Data Parallelism finden Sie in der Dokumentation zur [Implementierung von Sharded Data Parallelism in der SMP-Bibliothek, [ZerO](https://deepspeed.readthedocs.io/en/latest/zero3.html#), und im Blog über Fully Sharded Data Parallelism](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-sharded-data-parallelism.html). DeepSpeed PyTorch ](https://engineering.fb.com/2021/07/15/open-source/fsdp/) Da kollektive Operationen wie in jeder Iteration aufgerufen AllGather werden, sind sie der Hauptverursacher des GPU-Kommunikationsaufwands. Eine schnellere Berechnung dieser kollektiven Operationen führt direkt zu einer kürzeren Trainingszeit ohne negative Auswirkungen auf die Konvergenz. [Um dies zu erreichen, bietet die SMDDP-Bibliothek `AllGather`, optimiert für P4-Instances an.](https://aws.amazon.com/ec2/instance-types/p4/) SMDDP `AllGather` verwendet die folgenden Techniken, um die Rechenleistung auf P4d-Instances zu verbessern. 1. Es überträgt Daten zwischen Instances (zwischen Knoten) über das [Elastic Fabric Adapter (EFA)](https://aws.amazon.com/hpc/efa/)-Netzwerk mit einer Mesh-Topologie. EFA ist die Netzwerklösung AWS mit niedriger Latenz und hohem Durchsatz. Eine Mesh-Topologie für die Netzwerkkommunikation zwischen Knoten ist stärker auf die Eigenschaften von EFA und Netzwerkinfrastruktur zugeschnitten. AWS Im Vergleich zur NCCL-Ring- oder Baumtopologie, die mehrere Paket-Hops umfasst, vermeidet SMDDP die Akkumulation von Latenz aufgrund mehrerer Hops, da nur ein Hop benötigt wird. SMDDP implementiert einen Algorithmus zur Steuerung der Netzwerkrate, der die Workload auf jeden Kommunikationspartner in einer Mesh-Topologie verteilt und so einen höheren globalen Netzwerkdurchsatz erzielt. 1. Sie verwendet eine [GPU-Speicherkopierbibliothek mit niedriger Latenz, die auf der NVIDIA GPUDirect RDMA-Technologie (GDRCopy) basiert, um den lokalen und EFA-Netzwerkverkehr](https://github.com/NVIDIA/gdrcopy) zu koordinieren. NVLink GDRCopy, eine von NVIDIA angebotene Bibliothek für GPU-Speicherkopien mit niedriger Latenz, ermöglicht die Kommunikation mit niedriger Latenz zwischen CPU-Prozessen und GPU-CUDA-Kerneln. Mit dieser Technologie ist die SMDDP-Bibliothek in der Lage, die Datenbewegung innerhalb und zwischen den Knoten zu leiten. 1. Sie reduziert den Einsatz von GPU-Streaming-Multiprozessoren, um die Rechenleistung für die Ausführung von Modellkerneln zu erhöhen. P4d- und P4de-Instances sind mit NVIDIA GPUs A100 ausgestattet, die jeweils über 108 Streaming-Multiprozessoren verfügen. Während NCCL bis zu 24 Streaming-Multiprozessoren benötigt, um kollektive Operationen auszuführen, verwendet SMDDP weniger als 9 Streaming-Multiprozessoren. Modell-Compute-Kernel greifen für schnellere Berechnungen auf die gespeicherten Streaming-Multiprozessoren zurück. # Unterstützte Frameworks AWS-Regionen und Instanztypen Bevor Sie die SageMaker AI Distributed Data Parallelism (SMDDP) -Bibliothek verwenden, überprüfen Sie, welche ML-Frameworks und Instanztypen unterstützt werden und ob in Ihrem Konto genügend Kontingente vorhanden sind und. AWS AWS-Region ## Unterstützte Frameworks In den folgenden Tabellen sind die Deep-Learning-Frameworks und ihre Versionen aufgeführt, die von SageMaker KI und SMDDP unterstützt werden. Die SMDDP-Bibliothek ist in [SageMaker AI Framework-Containern verfügbar, in Docker-Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) [integriert, die über die SageMaker Model Parallelism (SMP) -Bibliothek v2 vertrieben](distributed-model-parallel-support-v2.md#distributed-model-parallel-supported-frameworks-v2) werden, oder als Binärdatei heruntergeladen werden. **Anmerkung** Die neuesten Updates und Versionshinweise der SMDDP-Bibliothek finden Sie in den [SageMaker Versionshinweise zur Bibliothek für KI-Datenparallelität](data-parallel-release-notes.md). **Topics** + [PyTorch](#distributed-data-parallel-supported-frameworks-pytorch) + [PyTorch Lightning](#distributed-data-parallel-supported-frameworks-lightning) + [Hugging Face Transformer](#distributed-data-parallel-supported-frameworks-transformers) + [TensorFlow (veraltet)](#distributed-data-parallel-supported-frameworks-tensorflow) ### PyTorch | PyTorch Version | Version der SMDDP-Bibliothek | SageMaker Mit SMDDP vorinstallierte AI Framework Container-Images | SMP-Docker-Images mit vorinstalliertem SMDDP | URL der Binärdatei\$1\$1 | | --- | --- | --- | --- | --- | | v2.3.1 | smdistributed-dataparallel==v2.5.0 | Nicht verfügbar | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.4.1/cu121/2024-10-09/smdistributed\$1dataparallel-2.5.0-cp311-cp311-linux\$1x86\$164.whl | | v2.3.0 | smdistributed-dataparallel==v2.3.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.3.0-gpu-py311-cu121-ubuntu20.04-sagemaker | Derzeit nicht verfügbar | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.3.0/cu121/2024-05-23/smdistributed\$1dataparallel-2.3.0-cp311-cp311-linux\$1x86\$164.whl | | v2.2.0 | smdistributed-dataparallel==v2.2.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.2.0-gpu-py310-cu121-ubuntu20.04-sagemaker | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.2.0/cu121/2024-03-04/smdistributed\$1dataparallel-2.2.0-cp310-cp310-linux\$1x86\$164.whl | | v2.1.0 | smdistributed-dataparallel==v2.1.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.1.0-gpu-py310-cu121-ubuntu20.04-sagemaker | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.1.2-gpu-py310-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.1.0/cu121/2024-02-04/smdistributed\$1dataparallel-2.1.0-cp310-cp310-linux\$1x86\$164.whl | | v2.0.1 | smdistributed-dataparallel==v2.0.1 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker | Nicht verfügbar | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.1/cu118/2023-12-07/smdistributed\$1dataparallel-2.0.2-cp310-cp310-linux\$1x86\$164.whl | | v2.0.0 | smdistributed-dataparallel==v1.8.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.0-gpu-py310-cu118-ubuntu20.04-sagemaker | Nicht verfügbar | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.0/cu118/2023-03-20/smdistributed\$1dataparallel-1.8.0-cp310-cp310-linux\$1x86\$164.whl | | v1.13.1 | smdistributed-dataparallel==v1.7.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.13.1-gpu-py39-cu117-ubuntu20.04-sagemaker | Nicht verfügbar | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.13.1/cu117/2023-01-09/smdistributed\$1dataparallel-1.7.0-cp39-cp39-linux\$1x86\$164.whl | | v1.12.1 | smdistributed-dataparallel==v1.6.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.1-gpu-py38-cu113-ubuntu20.04-sagemaker | Nicht verfügbar | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.12.1/cu113/2022-12-05/smdistributed\$1dataparallel-1.6.0-cp38-cp38-linux\$1x86\$164.whl | | v1.12.0 | smdistributed-dataparallel==v1.5.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.0-gpu-py38-cu113-ubuntu20.04-sagemaker | Nicht verfügbar | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.12.0/cu113/2022-07-01/smdistributed\$1dataparallel-1.5.0-cp38-cp38-linux\$1x86\$164.whl | | v1.11.0 | smdistributed-dataparallel==v1.4.1 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.11.0-gpu-py38-cu113-ubuntu20.04-sagemaker | Nicht verfügbar | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.11.0/cu113/2022-04-14/smdistributed\$1dataparallel-1.4.1-cp38-cp38-linux\$1x86\$164.whl | \$1\$1 Die URLs Binärdateien dienen zur Installation der SMDDP-Bibliothek in benutzerdefinierten Containern. Weitere Informationen finden Sie unter [Erstellen Sie Ihren eigenen Docker-Container mit der SageMaker AI Distributed Data Parallel Library](data-parallel-bring-your-own-container.md). **Anmerkung** Die SMDDP-Bibliothek ist dort verfügbar, AWS-Regionen wo die [SageMaker AI Framework-Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) und die [SMP-Docker-Images](distributed-model-parallel-support-v2.md) im Einsatz sind. **Anmerkung** Die SMDDP-Bibliothek v1.4.0 und höher funktioniert als Backend für PyTorch verteilte (torch.distributed) Datenparallelität (torch.parallel). DistributedDataParallel). Entsprechend der Änderung sind die folgenden [smdistributed APIs](https://sagemaker.readthedocs.io/en/stable/api/training/sdp_versions/latest/smd_data_parallel_pytorch.html#pytorch-api) für das PyTorch verteilte Paket veraltet. `smdistributed.dataparallel.torch.distributed` ist veraltet. Verwenden Sie stattdessen das Paket [torch.distributed](https://pytorch.org/docs/stable/distributed.html). `smdistributed.dataparallel.torch.parallel.DistributedDataParallel` ist veraltet. [Benutze die Datei torch.nn.parallel. DistributedDataParallel](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html) Stattdessen API. Wenn Sie die vorherigen Versionen der Bibliothek (v1.3.0 oder früher) verwenden müssen, finden Sie in der [archivierten Dokumentation zum SageMaker AI Distributed Data Parallelism in der *SageMaker AI Python* SDK-Dokumentation](https://sagemaker.readthedocs.io/en/stable/api/training/sdp_versions/latest.html#documentation-archive) weitere Informationen. ### PyTorch Lightning Die SMDDP-Bibliothek ist für PyTorch Lightning in den folgenden SageMaker AI Framework-Containern für PyTorch und den SMP-Docker-Containern verfügbar. **PyTorch Lightning v2** | PyTorch Lightning-Version | PyTorch Version | Version der SMDDP-Bibliothek | SageMaker Mit SMDDP vorinstallierte AI Framework Container-Images | SMP-Docker-Images mit vorinstalliertem SMDDP | URL der Binärdatei\$1\$1 | | --- | --- | --- | --- | --- | --- | | 2.2.5 | 2.3.0 | smdistributed-dataparallel==v2.3.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.3.0-gpu-py311-cu121-ubuntu20.04-sagemaker | Derzeit nicht verfügbar | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.3.0/cu121/2024-05-23/smdistributed\$1dataparallel-2.3.0-cp311-cp311-linux\$1x86\$164.whl | | 2.2.0 | 2.2.0 | smdistributed-dataparallel==v2.2.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.2.0-gpu-py310-cu121-ubuntu20.04-sagemaker | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.2.0/cu121/2024-03-04/smdistributed\$1dataparallel-2.2.0-cp310-cp310-linux\$1x86\$164.whl | | 2.1.2 | 2.1.0 | smdistributed-dataparallel==v2.1.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.1.0-gpu-py310-cu121-ubuntu20.04-sagemaker | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.1.2-gpu-py310-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.1.0/cu121/2024-02-04/smdistributed\$1dataparallel-2.1.0-cp310-cp310-linux\$1x86\$164.whl | | 2.1.0 | 2.0.1 | smdistributed-dataparallel==v2.0.1 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker | Nicht verfügbar | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.1/cu118/2023-12-07/smdistributed\$1dataparallel-2.0.2-cp310-cp310-linux\$1x86\$164.whl | **PyTorch Lightning v1** | PyTorch Lightning-Version | PyTorch Version | Version der SMDDP-Bibliothek | SageMaker Mit SMDDP vorinstallierte AI Framework Container-Images | URL der Binärdatei\$1\$1 | | --- | --- | --- | --- | --- | | 1.7.2 1.7.0 1.6.4 1.6.3 1.5.10 | 1.12.0 | smdistributed-dataparallel==v1.5.0 | 763104351884.dkr.ecr. .amazonaws.com/pytorch-training:1.12.0-gpu-py38-cu113-ubuntu20.04-sagemaker | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.12.0/cu113/2022-07-01/smdistributed\$1dataparallel-1.5.0-cp38-cp38-linux\$1x86\$164.whl | \$1\$1 Die Binärdateien dienen zur Installation der SMDDP-Bibliothek in benutzerdefinierten Containern. URLs Weitere Informationen finden Sie unter [Erstellen Sie Ihren eigenen Docker-Container mit der SageMaker AI Distributed Data Parallel Library](data-parallel-bring-your-own-container.md). **Anmerkung** PyTorch Lightning und seine Hilfsbibliotheken wie Lightning Bolts sind in der nicht vorinstalliert. PyTorch DLCs Wenn Sie in [Schritt 2](https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel-use-api.html#data-parallel-framework-estimator) einen SageMaker PyTorch KI-Schätzer erstellen und eine Anfrage für eine Schulungsstelle einreichen, müssen Sie die Informationen `requirements.txt` zur Installation `pytorch-lightning` und `lightning-bolts` im SageMaker PyTorch KI-Schulungscontainer angeben. ``` # requirements.txt pytorch-lightning lightning-bolts ``` Weitere Informationen zur Angabe des Quellverzeichnisses, in dem die `requirements.txt` Datei zusammen mit Ihrem Schulungsskript und einer Jobübermittlung platziert werden soll, finden Sie unter [Verwenden von Bibliotheken von Drittanbietern](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) in der *Amazon SageMaker AI Python SDK-Dokumentation*. ### Hugging Face Transformer 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). ### TensorFlow (veraltet) **Wichtig** Die SMDDP-Bibliothek hat die Unterstützung für Versionen ab Version 2.11.0 eingestellt TensorFlow und ist ab Version 2.11.0 nicht mehr verfügbar. DLCs TensorFlow In der folgenden Tabelle sind frühere Versionen von aufgeführt, bei denen DLCs die SMDDP-Bibliothek installiert TensorFlow war. | TensorFlow Version | Version der SMDDP-Bibliothek | | --- | --- | | 2.9.1, 2.10.1, 2.11.0 | smdistributed-dataparallel==v1.4.1 | | 2.8.3 | smdistributed-dataparallel==v1.3.0 | ## AWS-Regionen Die SMDDP-Bibliothek ist überall dort verfügbar, AWS-Regionen wo die [AWS Deep Learning Containers for SageMaker AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) und die [SMP Docker-Images](distributed-model-parallel-support-v2.md) im Einsatz sind. ## Unterstützte Instance-Typen Die SMDDP-Bibliothek erfordert einen der folgenden Instance-Typen. | Instance-Typ | | --- | | ml.p3dn.24xlarge\$1 | | ml.p4d.24xlarge | | ml.p4de.24xlarge | **Tipp** Zum ordnungsgemäßen Ausführen von verteilten Trainings der EFA-fähigen Instance-Typen sollten Sie den Datenverkehr zwischen den Instances aktivieren, indem Sie die Sicherheitsgruppe Ihrer VPC einrichten, die allen eingehenden und ausgehenden Datenverkehr von und zu der Sicherheitsgruppe selbst zulässt. Informationen zum Einrichten der Sicherheitsgruppenregeln finden Sie unter [Schritt 1: Vorbereiten einer EFA-fähigen Sicherheitsgruppe](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) im *Amazon-EC2-Benutzerhandbuch*. **Wichtig** \$1 Die SMDDP-Bibliothek hat die Unterstützung für die Optimierung ihrer kollektiven Kommunikationsoperationen auf P3-Instances eingestellt. Sie können zwar weiterhin das SMDDP-optimierte `AllReduce`-Kollektiv auf `ml.p3dn.24xlarge`-Instances verwenden, aber es wird keinen weiteren Entwicklungssupport geben, um die Leistung auf diesem Instance-Typ zu verbessern. Beachten Sie, dass das SMDDP-optimierte `AllGather`-Kollektiv nur für P4-Instances verfügbar ist. Die Spezifikationen der Instance-Typen finden Sie im Abschnitt **Beschleunigte Datenverarbeitung** auf der Seite [Amazon-EC2-Instance-Typen](https://aws.amazon.com/ec2/instance-types/). Informationen zu Instance-Preisen finden Sie unter [ SageMaker Amazon-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. ``` # Verteiltes Training mit der SageMaker KI-Bibliothek für verteilte Datenparallelität Die SageMaker AI-Bibliothek für verteilte Datenparallelität (SMDDP) wurde so konzipiert, dass sie benutzerfreundlich ist und eine nahtlose Integration mit ermöglicht. PyTorch Wenn Sie ein Deep-Learning-Modell mit der SMDDP-Bibliothek für SageMaker KI trainieren, können Sie sich darauf konzentrieren, Ihr Trainingsskript zu schreiben und das Training zu modellieren. Importieren Sie zunächst die SMDDP-Bibliothek, um ihre kollektiven Operationen zu verwenden, die für AWS optimiert sind. Die folgenden Themen enthalten Anweisungen dazu, was Sie Ihrem Trainingsskript hinzufügen müssen, je nachdem, welche kollektive Operation Sie optimieren möchten. **Topics** + [Anpassung Ihres Trainingsskripts zur Nutzung der kollektiven SMDDP-Operationen](data-parallel-modify-sdp-select-framework.md) + [Verteilte Trainingsjobs mit SMDDP mithilfe des SageMaker Python-SDK starten](data-parallel-use-api.md) # Anpassung Ihres Trainingsskripts zur Nutzung der kollektiven SMDDP-Operationen Die in diesem Abschnitt bereitgestellten Beispiele für Trainingsskripte sind vereinfacht und heben nur die Änderungen hervor, die erforderlich sind, um die SMDDP-Bibliothek ( SageMaker AI Distributed Data Parallelism) in Ihrem Trainingsskript zu aktivieren. Beispiele für end-to-end Jupyter-Notebooks, die zeigen, wie ein verteilter Trainingsjob mit der SMDDP-Bibliothek ausgeführt wird, finden Sie unter. [Beispiele für die Amazon SageMaker AI-Bibliothek zur Datenparallelität](distributed-data-parallel-v2-examples.md) **Topics** + [Verwenden Sie die SMDDP-Bibliothek in Ihrem Trainingsskript PyTorch](data-parallel-modify-sdp-pt.md) + [Verwenden Sie die SMDDP-Bibliothek in Ihrem PyTorch Lightning-Schulungsskript](data-parallel-modify-sdp-pt-lightning.md) + [Verwenden Sie die SMDDP-Bibliothek in Ihrem TensorFlow Schulungsskript (veraltet)](data-parallel-modify-sdp-tf2.md) # Verwenden Sie die SMDDP-Bibliothek in Ihrem Trainingsskript PyTorch [Ausgehend von der SageMaker AI Distributed Data Parallelism (SMDDP) -Bibliothek v1.4.0 können Sie die Bibliothek als Backend-Option für das verteilte Paket verwenden. PyTorch ](https://pytorch.org/tutorials/beginner/dist_overview.html) Um SMDDP `AllReduce` und `AllGather` Collective Operations zu verwenden, müssen Sie die SMDDP-Bibliothek nur zu Beginn Ihres Trainingsskripts importieren und SMDDP bei der Initialisierung der Prozessgruppe als Backend für verteilte Module festlegen. PyTorch Mit der einzigen Zeile der Backend-Spezifikation können Sie alle nativen PyTorch verteilten Module und das gesamte Trainingsskript unverändert lassen. [Die folgenden Codefragmente zeigen, wie die SMDDP-Bibliothek als Backend für PyTorch basierte verteilte Trainingspakete verwendet wird: [PyTorch Distributed Data Parallel (DDP), [PyTorch Fully Sharded Data Parallelism](https://pytorch.org/docs/stable/fsdp.html) (FSDP)](https://pytorch.org/docs/stable/notes/ddp.html) und Megatron-. [DeepSpeed](https://github.com/microsoft/DeepSpeed)DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed) ## Für PyTorch DDP oder FSDP Initialisieren Sie die Prozessgruppe wie folgt. ``` import torch.distributed as dist import smdistributed.dataparallel.torch.torch_smddp dist.init_process_group(backend="smddp") ``` **Anmerkung** (Nur für PyTorch DDP-Jobs) Das `smddp` Backend unterstützt derzeit nicht die Erstellung von Unterprozessgruppen mit der API. `torch.distributed.new_group()` Sie können das `smddp`-Backend auch nicht gleichzeitig mit anderen Prozessgruppen-Backends wie `NCCL` und `Gloo` verwenden. ## Für DeepSpeed oder Megatron- DeepSpeed Initialisieren Sie die Prozessgruppe wie folgt. ``` import deepspeed import smdistributed.dataparallel.torch.torch_smddp deepspeed.init_distributed(dist_backend="smddp") ``` **Anmerkung** Um SMDDP `AllGather` mit den `mpirun`-basierten Launchern (`smdistributed` und `pytorchddp`) in [Verteilte Trainingsjobs mit SMDDP mithilfe des SageMaker Python-SDK starten](data-parallel-use-api.md) zu verwenden, müssen Sie außerdem die folgende Umgebungsvariable in Ihrem Trainingsskript festlegen. ``` export SMDATAPARALLEL_OPTIMIZE_SDP=true ``` Allgemeine Hinweise zum Schreiben eines PyTorch FSDP-Trainingsskripts finden Sie in der [Dokumentation unter Advanced Model Training with Fully Sharded Data Parallel (FSDP](https://pytorch.org/tutorials/intermediate/FSDP_adavnced_tutorial.html)). PyTorch Allgemeine Hinweise zum Schreiben eines PyTorch DDP-Trainingsskripts finden Sie in der PyTorch Dokumentation unter [Erste Schritte mit verteilten Daten parallel](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html). Nachdem Sie die Anpassung Ihres Trainingsskripts abgeschlossen haben, fahren Sie mit [Verteilte Trainingsjobs mit SMDDP mithilfe des SageMaker Python-SDK starten](data-parallel-use-api.md) fort. # Verwenden Sie die SMDDP-Bibliothek in Ihrem PyTorch Lightning-Schulungsskript Wenn Sie Ihr [PyTorchLightning-Trainingsskript](https://pytorch-lightning.readthedocs.io/en/latest/starter/introduction.html) verwenden und einen parallel Trainingsjob mit verteilten Daten in SageMaker KI ausführen möchten, können Sie den Trainingsjob mit minimalen Änderungen an Ihrem Trainingsskript ausführen. Zu den erforderlichen Änderungen gehören die folgenden: Importieren Sie die PyTorch Module der `smdistributed.dataparallel` Bibliothek, richten Sie die Umgebungsvariablen für PyTorch Lightning so ein, dass sie die vom SageMaker Schulungs-Toolkit voreingestellten SageMaker KI-Umgebungsvariablen akzeptieren, und aktivieren Sie die SMDDP-Bibliothek, indem Sie das Prozessgruppen-Backend auf einstellen. `"smddp"` Um mehr zu erfahren, gehen Sie die folgenden Anweisungen durch, die die Schritte anhand von Codebeispielen aufschlüsseln. **Anmerkung** Die PyTorch Lightning-Unterstützung ist in der SageMaker AI Data Parallel Library v1.5.0 und höher verfügbar. ## PyTorch Lightning == v2.1.0 und == 2.0.1 PyTorch 1. Importieren Sie die `pytorch_lightning` Bibliothek und die `smdistributed.dataparallel.torch` Module. ``` import lightning as pl import smdistributed.dataparallel.torch.torch_smddp ``` 1. Instanziieren Sie die. [LightningEnvironment](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.plugins.environments.LightningEnvironment.html) ``` from lightning.fabric.plugins.environments.lightning import LightningEnvironment env = LightningEnvironment() env.world_size = lambda: int(os.environ["WORLD_SIZE"]) env.global_rank = lambda: int(os.environ["RANK"]) ``` 1. **Für PyTorch DDP** [— Erstellen Sie ein Objekt der [DDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.DDPStrategy.html)Klasse mit `"smddp"` for `process_group_backend` und `"gpu"` for und übergeben Sie `accelerator` es an die Trainer-Klasse.](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html) ``` import lightning as pl from lightning.pytorch.strategies import DDPStrategy ddp = DDPStrategy( cluster_environment=env, process_group_backend="smddp", accelerator="gpu" ) trainer = pl.Trainer( max_epochs=200, strategy=ddp, devices=num_gpus, num_nodes=num_nodes ) ``` **Für PyTorch FSDP** — Erstellen Sie ein Objekt der [FSDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.FSDPStrategy.html)Klasse (mit der gewünschten [Wrapping-Richtlinie](https://pytorch.org/docs/stable/fsdp.html)) mit `"smddp"` for `process_group_backend` und `"gpu"` for `accelerator` und übergeben Sie es an die [Trainer-Klasse](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html). ``` import lightning as pl from lightning.pytorch.strategies import FSDPStrategy from functools import partial from torch.distributed.fsdp.wrap import size_based_auto_wrap_policy policy = partial( size_based_auto_wrap_policy, min_num_params=10000 ) fsdp = FSDPStrategy( auto_wrap_policy=policy, process_group_backend="smddp", cluster_environment=env ) trainer = pl.Trainer( max_epochs=200, strategy=fsdp, devices=num_gpus, num_nodes=num_nodes ) ``` Nachdem Sie die Anpassung Ihres Trainingsskripts abgeschlossen haben, fahren Sie mit [Verteilte Trainingsjobs mit SMDDP mithilfe des SageMaker Python-SDK starten](data-parallel-use-api.md) fort. **Anmerkung** Wenn Sie einen SageMaker PyTorch KI-Schätzer erstellen und eine Trainingsanfrage einreichen[Verteilte Trainingsjobs mit SMDDP mithilfe des SageMaker Python-SDK starten](data-parallel-use-api.md), müssen Sie Angaben `requirements.txt` zur Installation `pytorch-lightning` und `lightning-bolts` im SageMaker PyTorch KI-Trainingscontainer machen. ``` # requirements.txt pytorch-lightning lightning-bolts ``` Weitere Informationen zur Angabe des Quellverzeichnisses, in dem die `requirements.txt` Datei zusammen mit Ihrem Schulungsskript und einer Jobübermittlung platziert werden soll, finden Sie unter [Verwenden von Bibliotheken von Drittanbietern](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) in der *Amazon SageMaker AI Python SDK-Dokumentation*. # Verwenden Sie die SMDDP-Bibliothek in Ihrem TensorFlow Schulungsskript (veraltet) **Wichtig** Die SMDDP-Bibliothek hat die Unterstützung für TensorFlow Versionen ab Version 2.11.0 eingestellt TensorFlow und ist ab Version DLCs 2.11.0 nicht mehr verfügbar. Frühere Versionen TensorFlow DLCs mit installierter SMDDP-Bibliothek finden Sie unter. [Unterstützte Frameworks](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks) Die folgenden Schritte zeigen Ihnen, wie Sie ein TensorFlow Trainingsskript ändern, um die verteilte parallel Datenbibliothek von SageMaker AI zu nutzen.  Die Bibliothek ist APIs so konzipiert, dass sie APIs Horovod ähnelt. Weitere Informationen zu den einzelnen APIs, für die die Bibliothek anbietet TensorFlow, finden Sie in der [Dokumentation zur SageMaker AI Distributed Data Parallel TensorFlow API](https://sagemaker.readthedocs.io/en/stable/api/training/smd_data_parallel.html#api-documentation). **Anmerkung** SageMaker AI Distributed Data Parallel ist an TensorFlow Trainingsskripte anpassbar, die aus `tf` Kernmodulen mit Ausnahme `tf.keras` von Modulen bestehen. SageMaker AI Distributed Data Parallel unterstützt die TensorFlow Keras-Implementierung nicht. **Anmerkung** Die SageMaker AI-Bibliothek für verteilte Datenparallelität unterstützt Automatic Mixed Precision (AMP) standardmäßig. Um AMP zu aktivieren, sind außer den Änderungen auf Framework-Ebene an Ihrem Trainingsskript keine weiteren Maßnahmen erforderlich. Wenn Gradienten aktiviert sind FP16, führt die SageMaker AI-Datenparallelitätsbibliothek ihren Betrieb in aus. `AllReduce` FP16 Weitere Informationen zur Implementierung von AMP APIs in Ihrem Trainingsskript finden Sie in den folgenden Ressourcen: [Frameworks — TensorFlow](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#tensorflow) in der *Dokumentation zu NVIDIA Deep Learning Performance* [Automatic Mixed Precision for Deep Learning](https://developer.nvidia.com/automatic-mixed-precision) in den *NVIDIA-Entwicklerdokumenten* [TensorFlow gemischte Präzision APIs](https://www.tensorflow.org/guide/mixed_precision) in der *TensorFlowDokumentation* 1. Importieren Sie den TensorFlow Client der Bibliothek und initialisieren Sie ihn. ``` import smdistributed.dataparallel.tensorflow as sdp  sdp.init() ``` 1. Ordnen Sie jede GPU einem einzelnen `smdistributed.dataparallel` Prozess zu mit `local_rank`–das bezieht sich auf den relativen Rang des Prozesses innerhalb eines bestimmten Knotens. Die `sdp.tensorflow.local_rank()`-API stellt Ihnen den lokalen Rang des Geräts zur Verfügung. Der Führungsnoten hat Rang 0, und die Worker-Knoten haben Rang 1, 2, 3, usw. Dies wird im folgenden Codeblock als aufgerufen. `sdp.local_rank()` `set_memory_growth`steht nicht in direktem Zusammenhang mit verteilter SageMaker KI, muss aber für verteiltes Training mit TensorFlow eingerichtet werden. ``` gpus = tf.config.experimental.list_physical_devices('GPU') for gpu in gpus:     tf.config.experimental.set_memory_growth(gpu, True) if gpus:     tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU') ``` 1. Skalieren Sie die Lernrate nach der Anzahl der Auftragnehmer. Die `sdp.tensorflow.size()` API stellt Ihnen die Anzahl der Auftragnehmer im Cluster zur Verfügung. Dies wird im folgenden Codeblock als `sdp.size()` aufgerufen. ``` learning_rate = learning_rate * sdp.size() ``` 1. Verwenden Sie die `DistributedGradientTape` der Bibliothek, um den `AllReduce` Betrieb während des Trainings zu optimieren. `tf.GradientTape` ist damit abgeschlossen.  ``` with tf.GradientTape() as tape:       output = model(input)       loss_value = loss(label, output)      # SageMaker AI data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape tape = sdp.DistributedGradientTape(tape) ``` 1. Senden Sie die anfänglichen Modellvariablen vom Führungsknoten (Rang 0) an alle Worker-Knoten (Ränge 1 bis n). Dies ist erforderlich, um eine konsistente Initialisierung in allen Auftragnehmer-Rängen sicherzustellen. Verwenden Sie die `sdp.tensorflow.broadcast_variables` API, nachdem die Modell- und Optimizer-Variablen initialisiert wurden. Dies wird im folgenden Codeblock als `sdp.broadcast_variables()` aufgerufen. ``` sdp.broadcast_variables(model.variables, root_rank=0) sdp.broadcast_variables(opt.variables(), root_rank=0) ``` 1. Ändern Sie abschließend Ihr Skript so, dass es Checkpoints nur auf dem Führungsknoten speichert. Der Führungsknoten hat ein synchronisiertes Modell. Dadurch wird auch vermieden, dass Worker-Knoten die Checkpoints überschreiben und die Checkpoints möglicherweise beschädigen. ``` if sdp.rank() == 0:     checkpoint.save(checkpoint_dir) ``` Im Folgenden finden Sie ein Beispiel für ein TensorFlow Trainingsskript für verteiltes Training mit der Bibliothek. ``` import tensorflow as tf # SageMaker AI data parallel: Import the library TF API import smdistributed.dataparallel.tensorflow as sdp # SageMaker AI data parallel: Initialize the library sdp.init() gpus = tf.config.experimental.list_physical_devices('GPU') for gpu in gpus:     tf.config.experimental.set_memory_growth(gpu, True) if gpus:     # SageMaker AI data parallel: Pin GPUs to a single library process     tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU') # Prepare Dataset dataset = tf.data.Dataset.from_tensor_slices(...) # Define Model mnist_model = tf.keras.Sequential(...) loss = tf.losses.SparseCategoricalCrossentropy() # SageMaker AI data parallel: Scale Learning Rate # LR for 8 node run : 0.000125 # LR for single node run : 0.001 opt = tf.optimizers.Adam(0.000125 * sdp.size()) @tf.function def training_step(images, labels, first_batch):     with tf.GradientTape() as tape:         probs = mnist_model(images, training=True)         loss_value = loss(labels, probs)     # SageMaker AI data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape     tape = sdp.DistributedGradientTape(tape)     grads = tape.gradient(loss_value, mnist_model.trainable_variables)     opt.apply_gradients(zip(grads, mnist_model.trainable_variables))     if first_batch:        # SageMaker AI data parallel: Broadcast model and optimizer variables        sdp.broadcast_variables(mnist_model.variables, root_rank=0)        sdp.broadcast_variables(opt.variables(), root_rank=0)     return loss_value ... # SageMaker AI data parallel: Save checkpoints only from master node. if sdp.rank() == 0:     checkpoint.save(checkpoint_dir) ``` Nachdem Sie die Anpassung Ihres Trainingsskripts abgeschlossen haben, fahren Sie mit [Verteilte Trainingsjobs mit SMDDP mithilfe des SageMaker Python-SDK starten](data-parallel-use-api.md) fort. # Verteilte Trainingsjobs mit SMDDP mithilfe des SageMaker Python-SDK starten Um einen verteilten Trainingsjob mit Ihrem angepassten Skript von auszuführen[Anpassung Ihres Trainingsskripts zur Nutzung der kollektiven SMDDP-Operationen](data-parallel-modify-sdp-select-framework.md), verwenden Sie das Framework oder generische Schätzer des SageMaker Python SDK, indem Sie das vorbereitete Trainingsskript als Einstiegsskript und die verteilte Trainingskonfiguration angeben. Auf dieser Seite erfahren Sie, wie Sie das [SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/api/training/index.html) auf zwei Arten verwenden können. + Wenn Sie eine schnelle Einführung in Ihren verteilten Schulungsberuf im Bereich SageMaker KI erreichen möchten, konfigurieren Sie eine SageMaker KI [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch)- oder [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)Framework-Estimator-Klasse. Der Framework-Estimator nimmt Ihr Trainingsskript auf und gleicht anhand des für den Parameter angegebenen Werts automatisch die richtige Image-URI der [vorgefertigten Container PyTorch oder TensorFlow Deep Learning Container (DLC)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) ab. `framework_version` + Wenn Sie einen der vorgefertigten Container erweitern oder einen benutzerdefinierten Container erstellen möchten, um Ihre eigene ML-Umgebung mit SageMaker KI zu erstellen, verwenden Sie die generische `Estimator` AI-Klasse und geben Sie den SageMaker Image-URI des benutzerdefinierten Docker-Containers an, der in Ihrer Amazon Elastic Container Registry (Amazon ECR) gehostet wird. Ihre Trainingsdatensätze sollten in Amazon S3 oder [Amazon FSx for Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) in dem Land gespeichert werden, AWS-Region in dem Sie Ihren Trainingsjob starten. Wenn Sie Jupyter-Notebooks verwenden, sollte auf derselben Instanz eine SageMaker Notebook-Instance oder eine SageMaker Studio Classic-App ausgeführt werden. AWS-Region Weitere Informationen zum Speichern Ihrer Trainingsdaten finden Sie in der Dokumentation zu den [SageMaker Python-SDK-Dateneingaben](https://sagemaker.readthedocs.io/en/stable/overview.html#use-file-systems-as-training-input). **Tipp** Wir empfehlen, Amazon FSx for Lustre anstelle von Amazon S3 zu verwenden, um die Trainingsleistung zu verbessern. Amazon FSx hat einen höheren Durchsatz und eine geringere Latenz als Amazon S3. **Tipp** Zum ordnungsgemäßen Ausführen von verteilten Trainings der EFA-fähigen Instance-Typen sollten Sie den Datenverkehr zwischen den Instances aktivieren, indem Sie die Sicherheitsgruppe Ihrer VPC einrichten, die allen eingehenden und ausgehenden Datenverkehr von und zu der Sicherheitsgruppe selbst zulässt. Informationen zum Einrichten der Sicherheitsgruppenregeln finden Sie unter [Schritt 1: Vorbereiten einer EFA-fähigen Sicherheitsgruppe](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) im *Amazon-EC2-Benutzerhandbuch*. Wählen Sie eines der folgenden Themen mit Anweisungen zum Ausführen eines verteilten Trainingsjobs aus. Nachdem Sie einen Schulungsjob gestartet haben, können Sie die Systemauslastung und die Modellleistung mithilfe von [SageMaker Amazon-Debugger](train-debugger.md) Amazon überwachen CloudWatch. Folgen Sie den Anweisungen in den folgenden Themen, um mehr über technische Details zu erfahren. Wir empfehlen Ihnen jedoch, zunächst [Beispiele für die Amazon SageMaker AI-Bibliothek zur Datenparallelität](distributed-data-parallel-v2-examples.md) das auszuprobieren. **Topics** + [Verwenden Sie die PyTorch Framework-Schätzer im SageMaker Python-SDK](data-parallel-framework-estimator.md) + [Verwenden Sie den generischen SageMaker AI-Estimator, um vorgefertigte DLC-Container zu erweitern](data-parallel-use-python-skd-api.md) + [Erstellen Sie Ihren eigenen Docker-Container mit der SageMaker AI Distributed Data Parallel Library](data-parallel-bring-your-own-container.md) # Verwenden Sie die PyTorch Framework-Schätzer im SageMaker Python-SDK Sie können ein verteiltes Training starten, indem Sie das `distribution` Argument zu den SageMaker KI-Framework-Schätzern hinzufügen, [https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch)oder [https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator). Für weitere Informationen wählen Sie aus den folgenden Optionen eines der Frameworks aus, die von der SageMaker AI Distributed Data Parallelism (SMDDP) -Bibliothek unterstützt werden. ------ #### [ PyTorch ] Die folgenden Launcher-Optionen sind für den Start von verteilten Schulungen verfügbar. PyTorch + `pytorchddp`— Diese Option führt Umgebungsvariablen aus `mpirun` und richtet sie ein, die für die Durchführung PyTorch verteilter Schulungen auf SageMaker KI erforderlich sind. Um diese Option zu verwenden, übergeben Sie das folgende Wörterbuch an den Parameter `distribution`. ``` { "pytorchddp": { "enabled": True } } ``` + `torch_distributed`— Diese Option führt Umgebungsvariablen aus `torchrun` und richtet sie ein, die für die Durchführung PyTorch verteilter Schulungen auf SageMaker KI benötigt werden. Um diese Option zu verwenden, übergeben Sie das folgende Wörterbuch an den Parameter `distribution`. ``` { "torch_distributed": { "enabled": True } } ``` + `smdistributed`— Diese Option läuft ebenfalls`smddprun`, richtet `mpirun` aber damit Umgebungsvariablen ein, die für die Durchführung PyTorch verteilter Schulungen auf SageMaker KI benötigt werden. ``` { "smdistributed": { "dataparallel": { "enabled": True } } } ``` Wenn Sie NCCL `AllGather` durch SMDDP `AllGather` ersetzen möchten, können Sie alle drei Optionen verwenden. Wählen Sie eine Option aus, die zu Ihrem Anwendungsfall passt. Wenn Sie NCCL `AllReduce` durch SMDDP `AllReduce` ersetzen möchten, sollten Sie eine der `mpirun`-basierten Optionen wählen: `smdistributed` oder `pytorchddp`. Sie können auch zusätzliche MPI-Optionen hinzufügen. ``` { "pytorchddp": { "enabled": True, "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION" } } ``` ``` { "smdistributed": { "dataparallel": { "enabled": True, "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION" } } } ``` Das folgende Codebeispiel zeigt die grundlegende Struktur eines PyTorch Schätzers mit verteilten Trainingsoptionen. ``` from sagemaker.pytorch import PyTorch pt_estimator = PyTorch( base_job_name="training_job_name_prefix", source_dir="subdirectory-to-your-code", entry_point="adapted-training-script.py", role="SageMakerRole", py_version="py310", framework_version="2.0.1",     # For running a multi-node distributed training job, specify a value greater than 1     # Example: 2,3,4,..8 instance_count=2,     # Instance types supported by the SageMaker AI data parallel library: # ml.p4d.24xlarge, ml.p4de.24xlarge instance_type="ml.p4d.24xlarge", # Activate distributed training with SMDDP distribution={ "pytorchddp": { "enabled": True } } # mpirun, activates SMDDP AllReduce OR AllGather # distribution={ "torch_distributed": { "enabled": True } } # torchrun, activates SMDDP AllGather # distribution={ "smdistributed": { "dataparallel": { "enabled": True } } } # mpirun, activates SMDDP AllReduce OR AllGather ) pt_estimator.fit("s3://bucket/path/to/training/data") ``` **Anmerkung** PyTorch Lightning und seine Utility-Bibliotheken wie Lightning Bolts sind in der SageMaker KI nicht vorinstalliert. PyTorch DLCs Erstellen Sie die folgende `requirements.txt` Datei und speichern Sie sie in dem Quellverzeichnis, in dem Sie das Trainingsskript speichern. ``` # requirements.txt pytorch-lightning lightning-bolts ``` Die Verzeichnisstruktur sollte wie folgt aussehen: ``` ├── pytorch_training_launcher_jupyter_notebook.ipynb └── sub-folder-for-your-code ├── adapted-training-script.py └── requirements.txt ``` Weitere Informationen zur Angabe des Quellverzeichnisses, in dem die `requirements.txt` Datei zusammen mit Ihrem Schulungsskript und einer Jobübermittlung platziert werden soll, finden Sie unter [Verwenden von Bibliotheken von Drittanbietern](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) in der *Amazon SageMaker AI Python SDK-Dokumentation*. **Überlegungen zur Aktivierung kollektiver SMDDP-Operationen und zur Verwendung der richtigen Launcher-Optionen für verteiltes Training** + SMDDP `AllReduce` und SMDDP `AllGather` sind derzeit nicht miteinander kompatibel. + SMDDP `AllReduce` ist standardmäßig aktiviert, wenn die `mpirun`-basierten Launcher `smdistributed` oder `pytorchddp` und NCCL `AllGather` verwendet werden. + SMDDP `AllGather` ist standardmäßig aktiviert, wenn der `torch_distributed`-Launcher verwendet wird und `AllReduce` auf NCCL zurückgreift. + SMDDP `AllGather` kann auch aktiviert werden, wenn die `mpirun`-basierten Launcher mit einer zusätzlichen Umgebungsvariablen wie folgt verwendet werden. ``` export SMDATAPARALLEL_OPTIMIZE_SDP=true ``` ------ #### [ TensorFlow ] **Wichtig** Die SMDDP-Bibliothek hat die Unterstützung für TensorFlow Versionen ab Version 2.11.0 eingestellt TensorFlow und ist ab Version DLCs 2.11.0 nicht mehr verfügbar. Frühere Versionen TensorFlow DLCs mit installierter SMDDP-Bibliothek finden Sie unter. [TensorFlow (veraltet)](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks-tensorflow) ``` from sagemaker.tensorflow import TensorFlow tf_estimator = TensorFlow( base_job_name = "training_job_name_prefix", entry_point="adapted-training-script.py", role="SageMakerRole", framework_version="2.11.0", py_version="py38",     # For running a multi-node distributed training job, specify a value greater than 1 # Example: 2,3,4,..8 instance_count=2,     # Instance types supported by the SageMaker AI data parallel library: # ml.p4d.24xlarge, ml.p3dn.24xlarge, and ml.p3.16xlarge instance_type="ml.p3.16xlarge",     # Training using the SageMaker AI data parallel distributed training strategy distribution={ "smdistributed": { "dataparallel": { "enabled": True } } } ) tf_estimator.fit("s3://bucket/path/to/training/data") ``` ------ # Verwenden Sie den generischen SageMaker AI-Estimator, um vorgefertigte DLC-Container zu erweitern Sie können vorgefertigte SageMaker KI-Container anpassen oder erweitern, um zusätzliche funktionale Anforderungen für Ihren Algorithmus oder Ihr Modell zu erfüllen, die das vorgefertigte SageMaker KI-Docker-Image nicht unterstützt. Ein Beispiel dafür, wie Sie einen vorgefertigten Container erweitern können, finden Sie unter [Erweitern eines vorgefertigten Containers](https://docs.aws.amazon.com/sagemaker/latest/dg/prebuilt-containers-extend.html). Um einen vorgefertigten Container zu erweitern oder Ihren eigenen Container an die Verwendung der Bibliothek anzupassen, müssen Sie eines der unter [Unterstützte Frameworks](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks) aufgeführten Bilder verwenden. **Anmerkung** Ab TensorFlow 2.4.1 und PyTorch 1.8.1 unterstützt das SageMaker KI-Framework DLCs EFA-fähige Instance-Typen. Wir empfehlen, die DLC-Images zu verwenden, die TensorFlow 2.4.1 oder höher und 1.8.1 oder höher enthalten. PyTorch Wenn Sie beispielsweise verwenden PyTorch, sollte Ihr Dockerfile eine `FROM` Anweisung enthalten, die der folgenden ähnelt: ``` # SageMaker AI PyTorch image FROM 763104351884.dkr.ecr..amazonaws.com/pytorch-training: ENV PATH="/opt/ml/code:${PATH}" # this environment variable is used by the SageMaker AI PyTorch container to determine our user code directory. ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code # /opt/ml and all subdirectories are utilized by SageMaker AI, use the /code subdirectory to store your user code. COPY train.py /opt/ml/code/train.py # Defines cifar10.py as script entrypoint ENV SAGEMAKER_PROGRAM train.py ``` Mithilfe des [SageMaker Training Toolkits](https://github.com/aws/sagemaker-training-toolkit) und der Binärdatei der SageMaker AI Distributed Data Parallel Library können Sie Ihren eigenen Docker-Container weiter an die Arbeit mit SageMaker KI anpassen. Weitere Informationen hierzu finden Sie in den Anweisungen im folgenden Abschnitt. # Erstellen Sie Ihren eigenen Docker-Container mit der SageMaker AI Distributed Data Parallel Library Um Ihren eigenen Docker-Container für das Training zu erstellen und die SageMaker KI-Datenparallelbibliothek zu verwenden, müssen Sie die richtigen Abhängigkeiten und die Binärdateien der verteilten parallel SageMaker AI-Bibliotheken in Ihr Dockerfile aufnehmen. Dieser Abschnitt enthält Anweisungen zum Erstellen eines vollständigen Dockerfiles mit den minimalen Abhängigkeiten für verteiltes Training in SageMaker KI mithilfe der Data Parallel Library. **Anmerkung** Diese benutzerdefinierte Docker-Option mit der SageMaker AI-Datenparallelbibliothek als Binärdatei ist nur für PyTorch verfügbar. **Um ein Dockerfile mit dem SageMaker Training Toolkit und der Data Parallel Library zu erstellen** 1. Beginnen Sie mit einem Docker-Image von [NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). [Verwenden Sie die cuDNN-Entwicklerversionen, die CUDA-Laufzeit- und Entwicklungstools (Header und Bibliotheken) enthalten, um aus dem Quellcode zu erstellen. PyTorch ](https://github.com/pytorch/pytorch#from-source) ``` FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04 ``` **Tipp** [Die offiziellen AWS Deep Learning Container (DLC) -Images werden aus den NVIDIA CUDA-Basisimages erstellt.](https://hub.docker.com/r/nvidia/cuda) Wenn Sie die vorgefertigten DLC-Images als Referenz verwenden und gleichzeitig die restlichen Anweisungen befolgen möchten, finden Sie weitere Informationen unter [AWS Deep Learning Containers for PyTorch ](https://github.com/aws/deep-learning-containers/tree/master/pytorch) Dockerfiles. 1. Fügen Sie die folgenden Argumente hinzu, um Versionen von PyTorch und anderen Paketen anzugeben. Geben Sie außerdem die Amazon S3 S3-Bucket-Pfade zur SageMaker AI-Datenparallelbibliothek und zu anderer Software zur Nutzung von AWS Ressourcen an, z. B. das Amazon S3 S3-Plug-In. Um andere Versionen der Bibliotheken von Drittanbietern als die im folgenden Codebeispiel bereitgestellten zu verwenden, empfehlen wir Ihnen, in den [offiziellen Dockerfiles von AWS Deep Learning Container nach Versionen PyTorch zu suchen](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker), die getestet, kompatibel und für Ihre Anwendung geeignet sind. Informationen zur URLs Suche nach dem `SMDATAPARALLEL_BINARY` Argument finden Sie in den Nachschlagetabellen unter. [Unterstützte Frameworks](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks) ``` ARG PYTORCH_VERSION=1.10.2 ARG PYTHON_SHORT_VERSION=3.8 ARG EFA_VERSION=1.14.1 ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl ARG CONDA_PREFIX="/opt/conda" ARG BRANCH_OFI=1.1.3-aws ``` 1. Stellen Sie die folgenden Umgebungsvariablen ein, um die SageMaker Trainingskomponenten ordnungsgemäß zu erstellen und die Datenparallelbibliothek auszuführen. In den nachfolgenden Schritten verwenden Sie diese Variablen für die Komponenten. ``` # Set ENV variables required to build PyTorch ENV TORCH_CUDA_ARCH_LIST="7.0+PTX 8.0" ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all" ENV NCCL_VERSION=2.10.3 # Add OpenMPI to the path. ENV PATH /opt/amazon/openmpi/bin:$PATH # Add Conda to path ENV PATH $CONDA_PREFIX/bin:$PATH # Set this enviroment variable for SageMaker AI to launch SMDDP correctly. ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main # Add enviroment variable for processes to be able to call fork() ENV RDMAV_FORK_SAFE=1 # Indicate the container type ENV DLC_CONTAINER_TYPE=training # Add EFA and SMDDP to LD library path ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH" ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH ``` 1. Installieren oder aktualisieren `curl`, `wget`, und `git` in den nachfolgenden Schritten Pakete herunterladen und erstellen. ``` RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \ apt-get update && apt-get install -y --no-install-recommends \ curl \ wget \ git \ && rm -rf /var/lib/apt/lists/* ``` 1. Installieren Sie die [Elastic Fabric Adapter (EFA)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html)-Software für die Amazon EC2-Netzwerkkommunikation. ``` RUN DEBIAN_FRONTEND=noninteractive apt-get update RUN mkdir /tmp/efa \ && cd /tmp/efa \ && curl --silent -O https://efa-installer.amazonaws.com/aws-efa-installer-${EFA_VERSION}.tar.gz \ && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \ && cd aws-efa-installer \ && ./efa_installer.sh -y --skip-kmod -g \ && rm -rf /tmp/efa ``` 1. Installieren Sie [Conda](https://docs.conda.io/en/latest/), um die Paketverwaltung zu übernehmen. ``` RUN curl -fsSL -v -o ~/miniconda.sh -O https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh && \ chmod +x ~/miniconda.sh && \ ~/miniconda.sh -b -p $CONDA_PREFIX && \ rm ~/miniconda.sh && \ $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \ $CONDA_PREFIX/bin/conda clean -ya ``` 1. Abrufen, Erstellen und Installieren PyTorch sowie die zugehörigen Abhängigkeiten. Wir bauen [PyTorch aus dem Quellcode](https://github.com/pytorch/pytorch#from-source), weil wir die Kontrolle über die NCCL-Version haben müssen, um die Kompatibilität mit dem [AWS OFI-NCCL-Plug-In](https://github.com/aws/aws-ofi-nccl) zu gewährleisten. 1. [Folgen Sie den Schritten in der [PyTorch offiziellen Docker-Datei](https://github.com/pytorch/pytorch/blob/master/Dockerfile), installieren Sie die Build-Abhängigkeiten und richten Sie den Cache ein, um die Neukompilierung zu beschleunigen.](https://ccache.dev/) ``` RUN DEBIAN_FRONTEND=noninteractive \ apt-get install -y --no-install-recommends \ build-essential \ ca-certificates \ ccache \ cmake \ git \ libjpeg-dev \ libpng-dev \ && rm -rf /var/lib/apt/lists/* # Setup ccache RUN /usr/sbin/update-ccache-symlinks RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache ``` 1. [PyTorchDie allgemeinen und Linux-Abhängigkeiten von](https://github.com/pytorch/pytorch#install-dependencies) Install. ``` # Common dependencies for PyTorch RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses # Linux specific dependency for PyTorch RUN conda install -c pytorch magma-cuda113 ``` 1. Klonen Sie das [PyTorch GitHubRepository](https://github.com/pytorch/pytorch). ``` RUN --mount=type=cache,target=/opt/ccache \ cd / \ && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION} ``` 1. Installieren und erstellen Sie eine bestimmte [NCCL](https://developer.nvidia.com/nccl)-Version. Ersetzen Sie dazu den Inhalt im Standard-NCCL-Ordner (`/pytorch/third_party/nccl`) durch die PyTorch spezifische NCCL-Version aus dem NVIDIA-Repository. Die NCCL-Version wurde in Schritt 3 dieses Handbuchs festgelegt. ``` RUN cd /pytorch/third_party/nccl \ && rm -rf nccl \ && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \ && cd nccl \ && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \ && make pkg.txz.build \ && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1 ``` 1. Erstellen und installieren. PyTorch Dieser Vorgang dauert in der Regel etwas mehr als 1 Stunde. Es wird mit der NCCL-Version erstellt, die in einem vorherigen Schritt heruntergeladen wurde. ``` RUN cd /pytorch \ && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \ python setup.py install \ && rm -rf /pytorch ``` 1. Erstellen und installieren Sie das [AWS OFI NCCL-Plugin](https://github.com/aws/aws-ofi-nccl). Dies ermöglicht die [libfabric-Unterstützung](https://github.com/ofiwg/libfabric) für die SageMaker AI-Datenparallelbibliothek. ``` RUN DEBIAN_FRONTEND=noninteractive apt-get update \ && apt-get install -y --no-install-recommends \ autoconf \ automake \ libtool RUN mkdir /tmp/efa-ofi-nccl \ && cd /tmp/efa-ofi-nccl \ && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \ && cd aws-ofi-nccl \ && ./autogen.sh \ && ./configure --with-libfabric=/opt/amazon/efa \ --with-mpi=/opt/amazon/openmpi \ --with-cuda=/usr/local/cuda \ --with-nccl=$CONDA_PREFIX \ && make \ && make install \ && rm -rf /tmp/efa-ofi-nccl ``` 1. Erstellen und installieren [TorchVision](https://github.com/pytorch/vision.git). ``` RUN pip install --no-cache-dir -U \ packaging \ mpi4py==3.0.3 RUN cd /tmp \ && git clone https://github.com/pytorch/vision.git -b v0.9.1 \ && cd vision \ && BUILD_VERSION="0.9.1+cu111" python setup.py install \ && cd /tmp \ && rm -rf vision ``` 1. Installieren und konfigurieren Sie OpenSSL. OpenSSH ist erforderlich, damit MPI zwischen Containern kommunizieren kann. Erlaube OpenSSH, mit Containern zu kommunizieren, ohne um Bestätigung zu bitten. ``` RUN apt-get update \ && apt-get install -y --allow-downgrades --allow-change-held-packages --no-install-recommends \ && apt-get install -y --no-install-recommends openssh-client openssh-server \ && mkdir -p /var/run/sshd \ && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \ && echo " StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \ && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \ && rm -rf /var/lib/apt/lists/* # Configure OpenSSH so that nodes can communicate with each other RUN mkdir -p /var/run/sshd && \ sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd RUN rm -rf /root/.ssh/ && \ mkdir -p /root/.ssh/ && \ ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \ cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \ && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config ``` 1. Installieren Sie das PT S3-Plug-In, um effizient auf Datensätze in Amazon S3 zuzugreifen. ``` RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU} RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt ``` 1. Installieren Sie die Bibliothek [libboost](https://www.boost.org/). Dieses Paket wird für die Vernetzung der asynchronen IO-Funktionalität der SageMaker AI-Datenparallelbibliothek benötigt. ``` WORKDIR / RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \ && tar -xzf boost_1_73_0.tar.gz \ && cd boost_1_73_0 \ && ./bootstrap.sh \ && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \ && cd .. \ && rm -rf boost_1_73_0.tar.gz \ && rm -rf boost_1_73_0 \ && cd ${CONDA_PREFIX}/include/boost ``` 1. Installieren Sie die folgenden SageMaker KI-Tools für das PyTorch Training. ``` WORKDIR /root RUN pip install --no-cache-dir -U \ smclarify \ "sagemaker>=2,<3" \ sagemaker-experiments==0.* \ sagemaker-pytorch-training ``` 1. Installieren Sie abschließend die parallel SageMaker AI-Datenbinärdatei und die verbleibenden Abhängigkeiten. ``` RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \ apt-get update && apt-get install -y --no-install-recommends \ jq \ libhwloc-dev \ libnuma1 \ libnuma-dev \ libssl1.1 \ libtool \ hwloc \ && rm -rf /var/lib/apt/lists/* RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY} ``` 1. Wenn Sie mit der Erstellung des Dockerfiles fertig sind, erfahren Sie unter [Adapting Your Own Training Container](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html), wie Sie den Docker-Container erstellen, in Amazon ECR hosten und einen Trainingsjob mit dem Python-SDK ausführen. SageMaker Der folgende Beispielcode zeigt ein vollständiges Dockerfile, nachdem alle vorherigen Codeblöcke kombiniert wurden. ``` # This file creates a docker image with minimum dependencies to run SageMaker AI data parallel training FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04 # Set appropiate versions and location for components ARG PYTORCH_VERSION=1.10.2 ARG PYTHON_SHORT_VERSION=3.8 ARG EFA_VERSION=1.14.1 ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl ARG CONDA_PREFIX="/opt/conda" ARG BRANCH_OFI=1.1.3-aws # Set ENV variables required to build PyTorch ENV TORCH_CUDA_ARCH_LIST="3.7 5.0 7.0+PTX 8.0" ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all" ENV NCCL_VERSION=2.10.3 # Add OpenMPI to the path. ENV PATH /opt/amazon/openmpi/bin:$PATH # Add Conda to path ENV PATH $CONDA_PREFIX/bin:$PATH # Set this enviroment variable for SageMaker AI to launch SMDDP correctly. ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main # Add enviroment variable for processes to be able to call fork() ENV RDMAV_FORK_SAFE=1 # Indicate the container type ENV DLC_CONTAINER_TYPE=training # Add EFA and SMDDP to LD library path ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH" ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH # Install basic dependencies to download and build other dependencies RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \ apt-get update && apt-get install -y --no-install-recommends \ curl \ wget \ git \ && rm -rf /var/lib/apt/lists/* # Install EFA. # This is required for SMDDP backend communication RUN DEBIAN_FRONTEND=noninteractive apt-get update RUN mkdir /tmp/efa \ && cd /tmp/efa \ && curl --silent -O https://efa-installer.amazonaws.com/aws-efa-installer-${EFA_VERSION}.tar.gz \ && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \ && cd aws-efa-installer \ && ./efa_installer.sh -y --skip-kmod -g \ && rm -rf /tmp/efa # Install Conda RUN curl -fsSL -v -o ~/miniconda.sh -O https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh && \ chmod +x ~/miniconda.sh && \ ~/miniconda.sh -b -p $CONDA_PREFIX && \ rm ~/miniconda.sh && \ $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \ $CONDA_PREFIX/bin/conda clean -ya # Install PyTorch. # Start with dependencies listed in official PyTorch dockerfile # https://github.com/pytorch/pytorch/blob/master/Dockerfile RUN DEBIAN_FRONTEND=noninteractive \ apt-get install -y --no-install-recommends \ build-essential \ ca-certificates \ ccache \ cmake \ git \ libjpeg-dev \ libpng-dev && \ rm -rf /var/lib/apt/lists/* # Setup ccache RUN /usr/sbin/update-ccache-symlinks RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache # Common dependencies for PyTorch RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses # Linux specific dependency for PyTorch RUN conda install -c pytorch magma-cuda113 # Clone PyTorch RUN --mount=type=cache,target=/opt/ccache \ cd / \ && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION} # Note that we need to use the same NCCL version for PyTorch and OFI plugin. # To enforce that, install NCCL from source before building PT and OFI plugin. # Install NCCL. # Required for building OFI plugin (OFI requires NCCL's header files and library) RUN cd /pytorch/third_party/nccl \ && rm -rf nccl \ && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \ && cd nccl \ && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \ && make pkg.txz.build \ && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1 # Build and install PyTorch. RUN cd /pytorch \ && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \ python setup.py install \ && rm -rf /pytorch RUN ccache -C # Build and install OFI plugin. \ # It is required to use libfabric. RUN DEBIAN_FRONTEND=noninteractive apt-get update \ && apt-get install -y --no-install-recommends \ autoconf \ automake \ libtool RUN mkdir /tmp/efa-ofi-nccl \ && cd /tmp/efa-ofi-nccl \ && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \ && cd aws-ofi-nccl \ && ./autogen.sh \ && ./configure --with-libfabric=/opt/amazon/efa \ --with-mpi=/opt/amazon/openmpi \ --with-cuda=/usr/local/cuda \ --with-nccl=$CONDA_PREFIX \ && make \ && make install \ && rm -rf /tmp/efa-ofi-nccl # Build and install Torchvision RUN pip install --no-cache-dir -U \ packaging \ mpi4py==3.0.3 RUN cd /tmp \ && git clone https://github.com/pytorch/vision.git -b v0.9.1 \ && cd vision \ && BUILD_VERSION="0.9.1+cu111" python setup.py install \ && cd /tmp \ && rm -rf vision # Install OpenSSH. # Required for MPI to communicate between containers, allow OpenSSH to talk to containers without asking for confirmation RUN apt-get update \ && apt-get install -y --allow-downgrades --allow-change-held-packages --no-install-recommends \ && apt-get install -y --no-install-recommends openssh-client openssh-server \ && mkdir -p /var/run/sshd \ && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \ && echo " StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \ && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \ && rm -rf /var/lib/apt/lists/* # Configure OpenSSH so that nodes can communicate with each other RUN mkdir -p /var/run/sshd && \ sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd RUN rm -rf /root/.ssh/ && \ mkdir -p /root/.ssh/ && \ ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \ cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \ && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config # Install PT S3 plugin. # Required to efficiently access datasets in Amazon S3 RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU} RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt # Install libboost from source. # This package is needed for smdataparallel functionality (for networking asynchronous IO). WORKDIR / RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \ && tar -xzf boost_1_73_0.tar.gz \ && cd boost_1_73_0 \ && ./bootstrap.sh \ && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \ && cd .. \ && rm -rf boost_1_73_0.tar.gz \ && rm -rf boost_1_73_0 \ && cd ${CONDA_PREFIX}/include/boost # Install SageMaker AI PyTorch training. WORKDIR /root RUN pip install --no-cache-dir -U \ smclarify \ "sagemaker>=2,<3" \ sagemaker-experiments==0.* \ sagemaker-pytorch-training # Install SageMaker AI data parallel binary (SMDDP) # Start with dependencies RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \ apt-get update && apt-get install -y --no-install-recommends \ jq \ libhwloc-dev \ libnuma1 \ libnuma-dev \ libssl1.1 \ libtool \ hwloc \ && rm -rf /var/lib/apt/lists/* # Install SMDDP RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY} ``` **Tipp** [Weitere allgemeine Informationen zum Erstellen eines benutzerdefinierten Dockerfiles für das Training in SageMaker KI finden Sie unter Verwenden Sie Ihre eigenen Trainingsalgorhythmen.](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html) **Tipp** Wenn Sie das benutzerdefinierte Dockerfile erweitern möchten, um die parallel SageMaker AI-Modellbibliothek zu integrieren, finden Sie weitere Informationen 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) # Beispiele für die Amazon SageMaker AI-Bibliothek zur Datenparallelität Auf dieser Seite finden Sie Jupyter-Notebooks mit Beispielen für die Implementierung der SMDDP-Bibliothek ( SageMaker AI Distributed Data Parallelism) zur Ausführung verteilter Trainingsaufgaben auf KI. SageMaker ## Blogs und Fallstudien In den folgenden Blogs werden Fallbeispiele zur Verwendung der SMDDP-Bibliothek behandelt. **Blogs zu SMDDP v2** + [Ermöglichen Sie schnelleres Training mit der Amazon SageMaker AI-Datenparallelbibliothek](https://aws.amazon.com/blogs/machine-learning/enable-faster-training-with-amazon-sagemaker-data-parallel-library/), *AWS Machine Learning Blog* (5. Dezember 2023) **Blogs zu SMDDP v1** + [Wie ich 10 TB für stabile Diffusion auf SageMaker KI in *Medium* trainiert habe](https://medium.com/@emilywebber/how-i-trained-10tb-for-stable-diffusion-on-sagemaker-39dcea49ce32) (29. November 2022) + [ PyTorch Lightning und natives PyTorch DDP auf Amazon SageMaker Training mit Amazon Search ausführen](https://aws.amazon.com/blogs/machine-learning/run-pytorch-lightning-and-native-pytorch-ddp-on-amazon-sagemaker-training-featuring-amazon-search/), *Blog für AWS Machine Learning* (18. August 2022) + [Schulung YOLOv5 zur parallel Bibliothek AWS mit PyTorch und mit SageMaker KI verteilter Daten](https://medium.com/@sitecao/training-yolov5-on-aws-with-pytorch-and-sagemaker-distributed-data-parallel-library-a196ab01409b), *Medium* (6. Mai 2022) + [Beschleunigen Sie EfficientNet das Modelltraining auf SageMaker KI mit PyTorch und der SageMaker AI-Parallelbibliothek für verteilte Daten](https://medium.com/@dangmz/speed-up-efficientnet-model-training-on-amazon-sagemaker-with-pytorch-and-sagemaker-distributed-dae4b048c01a), *Medium* (21. März 2022) + [Beschleunigen Sie das EfficientNet Training AWS mit der parallel SageMaker KI-Datenbibliothek](https://towardsdatascience.com/speed-up-efficientnet-training-on-aws-by-up-to-30-with-sagemaker-distributed-data-parallel-library-2dbf6d1e18e8) *Towards Data Science* (12. Januar 2022) + [Hyundai reduziert mithilfe von Amazon SageMaker AI die Trainingszeit für ML-Modelle für autonomes Fahren](https://aws.amazon.com/blogs/machine-learning/hyundai-reduces-training-time-for-autonomous-driving-models-using-amazon-sagemaker/), *AWS Machine Learning Blog* (25. Juni 2021) + [Verteiltes Training: BART/T5 mithilfe von Transformers und Amazon SageMaker AI auf die Zusammenfassung vorbereiten](https://huggingface.co/blog/sagemaker-distributed-training-seq2seq), die *Hugging Face Face-Website* (8. April 2021) ## 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/data_parallel`. **Anmerkung** Klonen Sie die Beispiel-Notebooks und führen Sie sie in der folgenden SageMaker AI ML aus IDEs. [SageMaker KI 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 AI 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/data_parallel ``` **Beispiele für SMDDP v2** + [Trainiere Llama 2 mit der SageMaker AI Distributed Data Parallel Library (SMDDP) und DeepSpeed](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/data_parallel/deepspeed/llama2/smddp_deepspeed_example.ipynb) + [Trainiere Falcon mit der SageMaker AI Distributed Data Parallel Library (SMDDP) und PyTorch Fully Sharded Data Parallelism (FSDP)](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/data_parallel/fully_sharded_data_parallel/falcon/smddp_fsdp_example.ipynb) **Beispiele für SMDDP v1** + [CNN mit und der KI-Datenparallelismus-Bibliothek PyTorch SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/data_parallel/mnist/pytorch_smdataparallel_mnist_demo.ipynb) + [BERT mit PyTorch und der SageMaker KI-Datenparallelitätsbibliothek](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/data_parallel/bert/pytorch_smdataparallel_bert_demo.ipynb) + [CNN mit TensorFlow 2.3.1 und der AI-Datenparallelitätsbibliothek SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/tensorflow/data_parallel/mnist/tensorflow2_smdataparallel_mnist_demo.html) + [BERT mit TensorFlow 2.3.1 und der AI-Datenparallelitätsbibliothek SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/tensorflow/data_parallel/bert/tensorflow2_smdataparallel_bert_demo.html) + [HuggingFace Paralleles Training mit verteilten Daten zum PyTorch Thema SageMaker KI — Verteilte Beantwortung von Fragen](https://github.com/huggingface/notebooks/blob/master/sagemaker/03_distributed_training_data_parallelism/sagemaker-notebook.ipynb) + [HuggingFace Paralleles Training mit verteilten Daten PyTorch zum Thema SageMaker KI — Zusammenfassung verteilter Texte](https://github.com/huggingface/notebooks/blob/master/sagemaker/08_distributed_summarization_bart_t5/sagemaker-notebook.ipynb) + [HuggingFace Paralleles Training mit verteilten Daten TensorFlow im Bereich KI SageMaker ](https://github.com/huggingface/notebooks/blob/master/sagemaker/07_tensorflow_distributed_training_data_parallelism/sagemaker-notebook.ipynb) # Konfigurationstipps für die SageMaker KI-Bibliothek für verteilte Datenparallelität Lesen Sie sich die folgenden Tipps durch, bevor Sie die SageMaker AI Distributed Data Parallelism (SMDDP) -Bibliothek verwenden. Diese Liste enthält Tipps, die für alle Frameworks gelten. **Topics** + [Datenvorverarbeitung](#data-parallel-config-dataprep) + [Einzelner oder mehrere Knoten](#data-parallel-config-multi-node) + [Skalierungseffizienz mit Debugger](#data-parallel-config-debug) + [Batch-Größe](#data-parallel-config-batch-size) + [Benutzerdefinierte MPI-Optionen](#data-parallel-config-mpi-custom) + [Nutzen Sie Amazon FSx und richten Sie eine optimale Lager- und Durchsatzkapazität ein](#data-parallel-config-fxs) ## Datenvorverarbeitung Wenn Sie Daten während des Trainings mithilfe einer externen Bibliothek, die die CPU nutzt, vorverarbeiten, kann es zu einem CPU-Engpass kommen, da SageMaker KI Distributed Data Parallel die CPU für Operationen verwendet. `AllReduce` Möglicherweise können Sie die Trainingszeit verkürzen, indem Sie die Vorverarbeitungsschritte in eine Bibliothek verschieben, die diese verwendet, GPUs oder indem Sie die gesamte Vorverarbeitung vor dem Training abschließen. ## Einzelner oder mehrere Knoten Wir empfehlen die Verwendung dieser Bibliothek mit mehreren Knoten. Die Bibliothek kann mit einem einzelnen Host und mehreren Geräten (z. B. einer einzelnen ML-Compute-Instanz mit mehreren GPUs) verwendet werden. Wenn Sie jedoch zwei oder mehr Knoten verwenden, führt der `AllReduce` Betrieb der Bibliothek zu einer deutlichen Leistungsverbesserung. Außerdem trägt dies auf einem einzelnen Host NVLink bereits zur Effizienz innerhalb `AllReduce` der Knoten bei. ## Skalierungseffizienz mit Debugger Sie können Amazon SageMaker Debugger verwenden, um die CPU- und GPU-Auslastung und andere interessante Messwerte während des Trainings zu überwachen und zu visualisieren. Sie können die [integrierten Debuger-Regeln](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html) verwenden, um Probleme mit der Rechenleistung zu überwachen, wie, `CPUBottleneck`, `LoadBalancing`, und `LowGPUUtilization`. Sie können diese Regeln mit [Debugger-Konfigurationen](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configuration-for-debugging.html) angeben, wenn Sie einen Amazon SageMaker Python SDK-Schätzer definieren. Wenn Sie KI verwenden AWS CLI und AWS SDK für Python (Boto3) für Schulungen zu SageMaker KI verwenden, können Sie den Debugger aktivieren, wie unter [ SageMaker Debugger mithilfe der SageMaker Amazon-API konfigurieren](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html) beschrieben. [Um ein Beispiel für die Verwendung von Debugger in einem SageMaker Schulungsjob zu sehen, können Sie auf eines der Notebook-Beispiele im Repository Notebook Examples SageMaker verweisen. GitHub ](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger) Weitere Informationen über Debugger finden Sie unter [Amazon SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/train-debugger.html). ## Batch-Größe Beim verteilten Training sollten die Batchgrößen proportional zunehmen, wenn mehr Knoten hinzugefügt werden. Um die Konvergenzgeschwindigkeit zu erhöhen, wenn Sie Ihrem Trainingsjob mehr Knoten hinzufügen und die globale Batchgröße erhöhen, erhöhen Sie die Lernrate. Eine Möglichkeit, dies zu erreichen, besteht in der schrittweisen Aufwärmphase der Lernrate, bei der die Lernrate im Laufe der Trainingsaufgabe von einem kleinen auf einen großen Wert erhöht wird. Durch diese Erhöhung wird ein plötzlicher Anstieg der Lernrate vermieden und eine gesunde Konvergenz zu Beginn der Ausbildung ermöglicht. Sie können beispielsweise eine *lineare Skalierungsregel* verwenden, bei der jedes Mal, wenn die Größe eines Minibatches mit k multipliziert wird, auch die Lernrate mit k multipliziert wird. Weitere Informationen zu dieser Technik finden Sie in der Forschungsarbeit [Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour](https://arxiv.org/pdf/1706.02677.pdf), Abschnitte 2 und 3. ## Benutzerdefinierte MPI-Optionen Die SageMaker AI-Bibliothek für verteilte parallel Daten verwendet Message Passing Interface (MPI), einen beliebten Standard für die Verwaltung der Kommunikation zwischen Knoten in einem Hochleistungscluster, und verwendet die NCCL-Bibliothek von NVIDIA für die Kommunikation auf GPU-Ebene. Wenn Sie die Datenparallelbibliothek mit a TensorFlow oder Pytorch verwenden`Estimator`, richtet der jeweilige Container die MPI-Umgebung ein und führt den `mpirun` Befehl zum Starten von Jobs auf den Clusterknoten aus. Sie können benutzerdefinierte MPI-Operationen mithilfe des `custom_mpi_options`-Parameters in der `Estimator` festlegen. Alle in diesem Feld übergebenen `mpirun` Flags werden dem `mpirun` Befehl hinzugefügt und von SageMaker KI zu Trainingszwecken ausgeführt. Sie können den `distribution` Parameter eines `Estimator` beispielsweise wie folgt definieren, um die [https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/env.html#nccl-debug](https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/env.html#nccl-debug) Variable zu verwenden, um die NCCL-Version zu Beginn des Programms zu drucken: ``` distribution = {'smdistributed':{'dataparallel':{'enabled': True, "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION"}}} ``` ## Nutzen Sie Amazon FSx und richten Sie eine optimale Lager- und Durchsatzkapazität ein Wenn Sie ein Modell auf mehreren Knoten mit verteilter Datenparallelität trainieren, wird die Verwendung von [FSx for](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) Lustre dringend empfohlen. Amazon FSx ist ein skalierbarer und leistungsstarker Speicherservice, der gemeinsam genutzte Dateispeicherung mit schnellerem Durchsatz unterstützt. Wenn Sie Amazon FSx Storage in großem Maßstab verwenden, können Sie eine schnellere Datenladegeschwindigkeit über die Rechenknoten hinweg erreichen. In der Regel würden Sie bei verteilter Datenparallelität erwarten, dass der gesamte Trainingsdurchsatz nahezu linear mit der Anzahl von skaliert. GPUs Wenn Sie jedoch suboptimalen FSx Amazon-Speicher verwenden, kann sich die Trainingsleistung aufgrund eines niedrigen FSx Amazon-Durchsatzes verlangsamen. Wenn Sie beispielsweise den [Bereitstellungstyp **SCRATCH\$12** des FSx Amazon-Dateisystems](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html#fsx-aggregate-perf) mit einer Mindestspeicherkapazität von 1,2 TiB verwenden, beträgt die I/O Durchsatzkapazität 240. MB/s. Amazon FSx storage works in a way that you can assign physical storage devices, and the more devices assigned, the larger throughput you get. The smallest storage increment for the SRATCH\$12 type is 1.2 TiB, and the corresponding throughput gain is 240 MB/s Gehen Sie davon aus, dass Sie über ein Modell verfügen, mit dem Sie auf einem 4-Node-Cluster über einen 100-GB-Datensatz trainieren können. Gehen Sie bei einer bestimmten Batchgröße, die für den Cluster optimiert ist, davon aus, dass das Modell eine Epoche in etwa 30 Sekunden abschließen kann. In diesem Fall beträgt die erforderliche I/O Mindestgeschwindigkeit ungefähr 3 GB/s (100 GB/30 s). Dies ist offenbar eine viel höhere Durchsatzanforderung als bei 240 MB/s. With such a limited Amazon FSx capacity, scaling your distributed training job up to larger clusters might aggravate I/O Engpassproblemen. Der Durchsatz beim Modelltraining könnte sich in späteren Epochen verbessern, wenn sich der Cache aufbaut, aber der FSx Amazon-Durchsatz kann immer noch ein Engpass sein. Um solche I/O Engpässe zu vermeiden, sollten Sie die FSx Amazon-Speichergröße erhöhen, um eine höhere Durchsatzkapazität zu erzielen. Um einen optimalen I/O Durchsatz zu ermitteln, können Sie in der Regel mit verschiedenen FSx Amazon-Durchsatzkapazitäten experimentieren und einen Durchsatz zuweisen, der Ihrer Schätzung entspricht oder geringfügig darunter liegt, bis Sie feststellen, dass dieser ausreicht, um die I/O Engpassprobleme zu lösen. Im oben genannten Beispiel wäre FSx Amazon-Speicher mit 2,4 GB/s Durchsatz und 67 GB RAM-Cache ausreichend. Wenn das Dateisystem einen optimalen Durchsatz hat, sollte der Durchsatz beim Modelltraining entweder sofort oder nach der ersten Epoche, in der sich der Cache aufgebaut hat, seinen Höchstwert erreichen. Weitere Informationen darüber, wie Sie die FSx Speicher- und Bereitstellungstypen von Amazon erhöhen können, finden Sie auf den folgenden Seiten in der *Amazon FSx for Lustre-Dokumentation*: + [Wie erhöht man die Speicherkapazität](https://docs.aws.amazon.com/fsx/latest/LustreGuide/managing-storage-capacity.html#increase-storage-capacity) + [Aggregierte Dateisystemleistung](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html#fsx-aggregate-perf) # Häufig gestellte Fragen zur Amazon-SMDDP-Bibliothek (SageMaker AI Distributed Data Parallelism) Im Folgenden finden Sie Antworten auf häufig gestellte Fragen zur SMDDP-Bibliothek. **F: Wie werden bei der Nutzung der Bibliothek die `allreduce` CPU-Instances verwaltet, die diese unterstützen? Muss ich heterogene CPU-GPU-Cluster erstellen, oder erstellt der SageMaker-AI-Dienst zusätzliche C5s für Jobs, die die SMDDP-Bibliothek verwenden?** Die SMDDP-Bibliothek unterstützt nur GPU-Instances, genauer gesagt, P4d- und P4de-Instances mit NVIDIA A100-GPUs und EFA. Es werden keine zusätzlichen C5- oder CPU-Instances gestartet. Wenn Ihr SageMaker-AI-Trainingsjob auf einem P4d-Cluster mit 8 Knoten ausgeführt wird, werden nur 8 `ml.p4d.24xlarge`-Instances verwendet. Es werden keine zusätzlichen Instances bereitgestellt. **F: Ich habe einen Trainingsjob, der 5 Tage für eine einzelne `ml.p3.24xlarge` Instance mit einem Satz von Hyperparametern H1 (Lernrate, Batchgröße, Optimizer usw.) dauert. Reicht die Verwendung der Datenparallelitätsbibliothek von SageMaker AI und eines fünfmal größeren Clusters aus, um eine ungefähre fünffache Beschleunigung zu erreichen? Oder muss ich nach der Aktivierung der SMDDP-Bibliothek die Trainings-Hyperparameter erneut aufrufen?** Die Bibliothek ändert die gesamte Batchgröße. Die neue Gesamtstapelgröße wird linear mit der Anzahl der verwendeten Trainings-Instances skaliert. Aus diesem Grund müssen Hyperparameter wie die Lernrate geändert werden, um die Konvergenz sicherzustellen. **F: Unterstützt die SMDDP-Bibliothek Spot? ** Ja. So verwenden Sie Managed Spot Training. Sie geben den Pfad zur Checkpoint-Datei im SageMaker-Trainingsjob an. Sie speichern und stellen Checkpoints in ihrem Trainingsskript wieder her, wie in den letzten Schritten von [Verwenden Sie die SMDDP-Bibliothek in Ihrem TensorFlow Schulungsskript (veraltet)](data-parallel-modify-sdp-tf2.md) und [Verwenden Sie die SMDDP-Bibliothek in Ihrem Trainingsskript PyTorch](data-parallel-modify-sdp-pt.md) beschrieben. **F: Ist die SMDDP-Bibliothek für eine Konfiguration mit einem Host und mehreren Geräten relevant?** Die Bibliothek kann für Trainings mit einem Host und mehreren Geräten verwendet werden. Leistungsverbesserungen bietet die Bibliothek jedoch nur bei Trainings mit mehreren Hosts. **F: Wo sollte der Trainingsdatensatz gespeichert werden?** Der Trainingsdatensatz kann in einem Amazon-S3-Bucket oder auf einem Amazon FSx-Laufwerk gespeichert werden. In diesem [Dokument finden Sie verschiedene unterstützte Eingabedateisysteme für einen Trainingsjob](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html#sagemaker.inputs.FileSystemInput). **F: Ist es bei der Nutzung der SMDDP-Bibliothek zwingend erforderlich, Trainingsdaten in FSx für Lustre zu haben? Können Amazon EFS und Amazon S3 verwendet werden?** Wir empfehlen generell, Amazon FSx zu verwenden, da es eine geringere Latenz und einen höheren Durchsatz bietet. Wenn Sie möchten, können Sie auch Amazon EFS oder Amazon S3 verwenden. **F: Kann die Bibliothek mit CPU-Knoten verwendet werden?** Nein. Informationen zu Instance-Typen, die von der SMDDP-Bibliothek unterstützt werden, finden Sie unter [Unterstützte Instance-Typen](distributed-data-parallel-support.md#distributed-data-parallel-supported-instance-types). **F: Welche Frameworks und Framework-Versionen werden derzeit von der SMDDP-Bibliothek beim Start unterstützt?** Die SMDDP-Bibliothek unterstützt derzeit PyTorch v1.6.0 oder höher und TensorFlow v2.3.0 oder höher. TensorFlow 1.x. wird nicht unterstützt. Weitere Informationen darüber, welche Version der SMDDP-Bibliothek in AWS Deep Learning Containers verpackt ist, finden Sie unter [Versionshinweise für Deep-Learning-Container](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/dlc-release-notes.html). **F: Unterstützt die Bibliothek AMP?** Ja, die SMDDP-Bibliothek unterstützt Automatic Mixed Precision (AMP) von Haus aus. Für die Verwendung von AMP sind außer den Änderungen an Ihrem Trainingsskript auf Framework-Ebene keine weiteren Maßnahmen erforderlich. Wenn Gradienten in FP16 sind, führt die SageMaker-AI-Datenparallelitätsbibliothek ihren Betrieb in FP16 aus. `AllReduce` Weitere Informationen zum Implementieren von AMP-APIs in Ihrem Trainingsskript finden Sie in den folgenden Ressourcen: + [Frameworks – PyTorch](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#pytorch) in der *NVIDIA Deep Learning Performance-Dokumentation* + [Frameworks – TensorFlow](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#tensorflow) in der *NVIDIA Deep Learning Performance-Dokumentation* + [Automatische gemischte Präzision für Deep Learning](https://developer.nvidia.com/automatic-mixed-precision) in den *NVIDIA-Entwicklerdokumenten* + [Einführung der systemeigenen automatischen gemischten Präzision von PyTorch für schnelleres Training auf NVIDIA-GPUs](https://pytorch.org/blog/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision/) im *PyTorch-Blog* + [TensorFlow-APIs mit gemischter Präzision](https://www.tensorflow.org/guide/mixed_precision) in der *TensorFlow-Dokumentation* **F: Wie stelle ich fest, ob mein verteilter Trainingsjob aufgrund von I/O-Engpässen verlangsamt wird?** Bei einem größeren Cluster erfordert der Trainingsjob einen höheren I/O-Durchsatz. Daher kann es länger dauern (mehr Epochen), bis der Trainingsdurchsatz die maximale Leistung erreicht. Dies deutet darauf hin, dass I/O-Engpässe auftreten und der Cache schwieriger aufzubauen ist, wenn Sie die Knoten vergrößern (höhere Durchsatzanforderungen und komplexere Netzwerktopologie). Weitere Informationen zur Überwachung des Amazon FSx-Durchsatzes auf CloudWatch finden Sie unter [Monitoring FSx für Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/monitoring_overview.html) im FSx for *Lustre-Benutzerhandbuch*. **F: Wie behebe ich I/O-Engpässe, wenn ich einen verteilten Trainingsjob mit Datenparallelität ausführe?** Wir empfehlen Ihnen dringend, Amazon FSx als Ihren Datenkanal zu verwenden, wenn Sie Amazon S3 verwenden. Wenn Sie Amazon FSx bereits verwenden, aber immer noch I/O-Engpassprobleme haben, haben Sie Ihr Amazon FSx-Dateisystem möglicherweise mit einem niedrigen I/O-Durchsatz und einer geringen Speicherkapazität eingerichtet. Weitere Informationen zur Schätzung und Auswahl der richtigen Größe der I/O-Durchsatzkapazität finden Sie unter [Nutzen Sie Amazon FSx und richten Sie eine optimale Lager- und Durchsatzkapazität ein](data-parallel-config.md#data-parallel-config-fxs). **F: (Für die Bibliothek v1.4.0 oder höher) Wie behebe ich den `Invalid backend` Fehler beim Initialisieren der Prozessgruppe.** Wenn Sie beim Aufrufen von `init_process_group` auf die Fehlermeldung `ValueError: Invalid backend: 'smddp'` stoßen, liegt das an der grundlegenden Änderung in der SMDDP-Bibliothek v1.4.0 und höher. Sie müssen den PyTorch-Client der Bibliothek, `smdistributed.dataparallel.torch.torch_smddp`, importieren, der `smddp` als Backend für PyTorch registriert. Weitere Informationen hierzu finden Sie unter [Verwenden Sie die SMDDP-Bibliothek in Ihrem Trainingsskript PyTorch](data-parallel-modify-sdp-pt.md). **F: (Für die SMDDP-Bibliothek v1.4.0 oder höher) möchte ich die kollektiven Primitiven der [https://pytorch.org/docs/stable/distributed.html](https://pytorch.org/docs/stable/distributed.html)-Schnittstelle aufrufen. Welche Primitive unterstützt das `smddp` Backend?** In Version 1.4.0 unterstützt die SMDDP-Bibliothek`all_reduce`, `broadcast`, `reduce`, `all_gather` und `barrier` aus der `torch.distributed`-Schnittstelle. **F: (Für die SMDDP-Bibliothek v1.4.0 oder höher) Funktioniert diese neue API mit anderen benutzerdefinierten DDP-Klassen oder -Bibliotheken wie Apex DDP?** Die SMDDP-Bibliothek wurde mit anderen verteilten datenparallelen Bibliotheken und Framework-Implementierungen von Drittanbietern getestet, die die Module `torch.distribtued` verwenden. Die Verwendung der SMDDP-Bibliothek mit benutzerdefinierten DDP-Klassen funktioniert, solange die von den benutzerdefinierten DDP-Klassen verwendeten kollektiven Operationen von der SMDDP-Bibliothek unterstützt werden. In der vorherigen Frage finden Sie eine Liste der unterstützten Kollektive. Wenn Sie diese Anwendungsfälle haben und weitere Unterstützung benötigen, wenden Sie sich über das [AWSSupport Center](https://console.aws.amazon.com/support/) oder die [AWSEntwicklerforen für Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285) an das SageMaker-AI-Team. **F: Unterstützt die SMDDP-Bibliothek die BYOC-Option (Bring-Your-Own-Container)? Falls ja, wie installiere ich die Bibliothek und führe einen verteilten Trainingsjob aus, indem ich ein benutzerdefiniertes Dockerfile schreibe?** Wenn Sie die SMDDP-Bibliothek und ihre minimalen Abhängigkeiten in Ihren eigenen Docker-Container integrieren möchten, ist BYOC der richtige Ansatz. Sie können Ihren eigenen Container mithilfe der Binärdatei der Bibliothek erstellen. Der empfohlene Prozess besteht darin, ein benutzerdefiniertes Dockerfile mit der Bibliothek und ihren Abhängigkeiten zu schreiben, den Docker-Container zu erstellen, ihn in Amazon ECR zu hosten und den ECR-Image-URI zu verwenden, um einen Trainingsjob mit der generischen Schätzerklasse SageMaker AI zu starten. Weitere Anweisungen zur Vorbereitung eines benutzerdefinierten Dockerfiles für verteiltes Training in SageMaker AI mit der SMDDP-Bibliothek finden Sie unter [Erstellen Sie Ihren eigenen Docker-Container mit der SageMaker AI Distributed Data Parallel Library](data-parallel-bring-your-own-container.md). # Fehlerbehebung für verteilte Schulungen in Amazon SageMaker AI Wenn Sie Probleme bei der Ausführung eines Trainingsjobs haben, während Sie die Bibliothek verwenden, verwenden Sie die folgende Liste, um zu versuchen, diese zu beheben. Wenn Sie weitere Unterstützung benötigen, wenden Sie sich über das SageMaker [AWS Support Center](https://console.aws.amazon.com/support/) oder die [AWS Entwicklerforen für Amazon Amazon SageMaker AI an das KI-Team](https://forums.aws.amazon.com/forum.jspa?forumID=285). **Topics** + [Verwendung von verteilten SageMaker KI-Daten parallel zu Amazon SageMaker Debugger und Checkpoints](#distributed-ts-data-parallel-debugger) + [Modellparameterschlüsseln wurde ein unerwartetes Präfix zugewiesen](#distributed-ts-data-parallel-pytorch-prefix) + [SageMaker KI verteilte Trainingsaufgaben, die während der Initialisierung ins Stocken geraten](#distributed-ts-data-parallel-efa-sg) + [SageMaker KI verteilte Schulungen, Jobs, die am Ende der Schulung ins Stocken gerieten](#distributed-ts-data-parallel-stall-at-the-end) + [Beobachtung der Verschlechterung der Skalierungseffizienz aufgrund von FSx Durchsatzengpässen bei Amazon](#distributed-ts-data-parallel-fxs-bottleneck) + [SageMaker Von KI verteilter Schulungsjob mit Hinweisen auf PyTorch veraltete Inhalte](#distributed-ts-data-parallel-deprecation-warnings) ## Verwendung von verteilten SageMaker KI-Daten parallel zu Amazon SageMaker Debugger und Checkpoints Verwenden Sie Amazon Debugger, um Systemengpässe zu überwachen, Framework-Operationen zu profilieren und Modellausgabetensoren für Trainingsjobs mit parallel verteilten SageMaker KI-Daten zu debuggen. SageMaker Wenn Sie jedoch SageMaker Debugger, SageMaker AI Distributed Data Parallel und SageMaker AI-Checkpoints verwenden, wird möglicherweise ein Fehler angezeigt, der dem folgenden Beispiel ähnelt. ``` SMDebug Does Not Currently Support Distributed Training Jobs With Checkpointing Enabled ``` Dies ist auf einen internen Fehler zwischen Debugger und Checkpoints zurückzuführen, der auftritt, wenn Sie SageMaker AI Distributed Data parallel aktivieren. + Wenn Sie alle drei Funktionen aktivieren, schaltet das SageMaker Python-SDK den Debugger automatisch durch Übergabe aus`debugger_hook_config=False`, was dem folgenden `estimator` Framework-Beispiel entspricht. ``` 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": {"dataparallel": { "enabled": True }}}, checkpoint_s3_uri=checkpoint_s3_bucket, checkpoint_local_path="/opt/ml/checkpoints", debugger_hook_config=False ) ``` + Wenn Sie weiterhin sowohl SageMaker AI Distributed Data parallel als auch SageMaker Debugger verwenden möchten, besteht eine Problemumgehung darin, Ihrem Trainingsskript manuell Checkpoint-Funktionen hinzuzufügen, anstatt die `checkpoint_local_path` Parameter `checkpoint_s3_uri` und aus dem Schätzer anzugeben. Weitere Informationen zum Einrichten von manuellem Checkpointing in einem Trainingsskript finden Sie unter [Speichern von Prüfpunkten](distributed-troubleshooting-model-parallel.md#distributed-ts-model-parallel-checkpoints). ## Modellparameterschlüsseln wurde ein unerwartetes Präfix zugewiesen Bei PyTorch verteilten Trainingsaufgaben kann ein unerwartetes Präfix (z. `model` B.) an `state_dict` Schlüssel (Modellparameter) angehängt werden. Die SageMaker KI-Datenparallelbibliothek ändert oder stellt Modellparameternamen nicht direkt voran, wenn PyTorch Trainingsjobs Modellartefakte speichern. PyTorchDas verteilte Training ändert die Namen in der, um über das Netzwerk `state_dict` zu gehen, wobei das Präfix vorangestellt wird. Wenn Sie bei der Verwendung der SageMaker AI-Datenparallelbibliothek und des Checkpoints für das PyTorch Training auf ein Modellfehlerproblem stoßen, das auf unterschiedliche Parameternamen zurückzuführen ist, passen Sie den folgenden Beispielcode an, um das Präfix zu entfernen, wenn Sie Checkpoints in Ihr Trainingsskript laden. ``` state_dict = {k.partition('model.')[2]:state_dict[k] for k in state_dict.keys()} ``` Dabei wird jeder `state_dict` Schlüssel als Zeichenkettenwert verwendet, die Zeichenfolge beim ersten Vorkommen von `'model.'` getrennt und das dritte Listenelement (mit Index 2) der partitionierten Zeichenfolge verwendet. Weitere Informationen zum Problem mit dem Präfix finden Sie in einem Diskussionsthread unter [Präfixparameternamen im gespeicherten Modell, wenn es von mehreren Grafikprozessoren trainiert wurde?](https://discuss.pytorch.org/t/prefix-parameter-names-in-saved-model-if-trained-by-multi-gpu/494) im *PyTorch Diskussionsforum*. Weitere Informationen zu den PyTorch Methoden zum Speichern und Laden von Modellen finden Sie in der *PyTorchDokumentation* unter [Modell geräteübergreifend speichern und laden](https://pytorch.org/tutorials/beginner/saving_loading_models.html#saving-loading-model-across-devices). ## SageMaker KI verteilte Trainingsaufgaben, die während der Initialisierung ins Stocken geraten Wenn Ihr parallel SageMaker AI-Trainingsjob für verteilte Daten während der Initialisierung bei Verwendung von EFA-fähigen Instances zum Stillstand kommt, kann dies an einer Fehlkonfiguration in der Sicherheitsgruppe des VPC-Subnetzes liegen, das für den Trainingsjob verwendet wird. EFA benötigt eine korrekte Sicherheitsgruppenkonfiguration, um den Verkehr zwischen den Knoten zu ermöglichen. **So konfigurieren Sie eingehende und ausgehende Regeln für die Sicherheitsgruppe** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon VPC-Konsole unter [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. Klicken Sie im linken Navigationsbereich auf **Sichewrheitsgruppen**. 1. Wählen Sie die Sicherheitsgruppe aus, die mit dem VPC-Subnetz verknüpft ist, das Sie für das Training verwenden. 1. Kopieren Sie im Abschnitt **Details** die **Sicherheitsgruppen-ID**. 1. Wählen Sie auf der Registerkarte **Inbound rules (Regeln für eingehenden Datenverkehr) ** die Option **Edt inbound rules (Regeln für eingehenden Datenverkehr bearbeiten)** aus. 1. Führen Sie im Dialogfeld **Edt inbound rules (Regeln für eingehenden Datenverkehr bearbeiten)** die folgenden Schritte aus: 1. Wählen Sie **Add rule**. 1. Wählen Sie für **Type (Typ)** die Option **All traffic (Gesamter Datenverkehr)** aus. 1. Wählen Sie für **Quelle** die Option **Benutzerdefiniert** aus, fügen Sie die Sicherheitsgruppen-ID in das Suchfeld ein und wählen Sie die Sicherheitsgruppe aus, die angezeigt wird. 1. Wählen Sie **Regeln speichern**, um die Konfiguration der eingehenden Regel für die Sicherheitsgruppe abzuschließen. 1. Wählen Sie auf der Registerkarte **Regeln für ausgehenden Datenverkehr** die Option **Regeln für ausgehenden Datenverkehr bearbeiten** aus. 1. Wiederholen Sie die Schritte 6 und 7, um dieselbe Regel als ausgehende Regel hinzuzufügen. Nachdem Sie die vorherigen Schritte zur Konfiguration der Sicherheitsgruppe mit den Regeln für eingehenden und ausgehenden Datenverkehr abgeschlossen haben, führen Sie den Trainingsjob erneut aus und überprüfen Sie, ob das Blockierungsproblem behoben ist. Weitere Informationen über das Konfigurieren von Sicherheitsgruppen für VPC und EFA finden Sie unter [Sicherheitsgruppen für Ihre VPC und](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) Ihren [Elastic Fabric Adapter](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html). ## SageMaker KI verteilte Schulungen, Jobs, die am Ende der Schulung ins Stocken gerieten Eine der Hauptursachen für Verzögerungen am Ende des Trainings ist eine Diskrepanz bei der Anzahl der Batches, die pro Epoche auf verschiedenen Rängen verarbeitet werden. Alle Worker (GPUs) synchronisieren ihre lokalen Farbverläufe im Rückwärtsgang, um sicherzustellen, dass am Ende der Batch-Iteration alle dieselbe Kopie des Modells haben. Wenn die Chargengrößen in der letzten Phase der Ausbildung ungleichmäßig verschiedenen Arbeitergruppen zugewiesen werden, gerät die Ausbildung ins Stocken. Während beispielsweise eine Gruppe von Arbeitern (Gruppe A) die Bearbeitung aller Chargen beendet und die Trainingsschleife beendet, beginnt eine andere Gruppe von Arbeitern (Gruppe B) mit der Verarbeitung eines weiteren Stapels und erwartet weiterhin, dass die Kommunikation von Gruppe A die Gradienten synchronisiert. Dies veranlasst Gruppe B, auf Gruppe A zu warten, die das Training bereits abgeschlossen hat und über keine zu synchronisierenden Farbverläufe verfügt. Daher ist es bei der Einrichtung Ihres Trainingsdatensatzes wichtig, dass jeder Mitarbeiter dieselbe Anzahl von Datenproben erhält, damit jeder Mitarbeiter während des Trainings dieselbe Anzahl von Batches durchläuft. Stellen Sie sicher, dass jeder Rang die gleiche Anzahl von Chargen erhält, um dieses Problem zu vermeiden, dass es zu Verzögerungen kommt. ## Beobachtung der Verschlechterung der Skalierungseffizienz aufgrund von FSx Durchsatzengpässen bei Amazon Eine mögliche Ursache für eine verringerte Skalierungseffizienz ist die FSx Durchsatzbegrenzung. Wenn Sie beim Wechsel zu einem größeren Trainingscluster einen plötzlichen Rückgang der Skalierungseffizienz feststellen, versuchen Sie, ein FSx für Lustre größeres Dateisystem mit einer höheren Durchsatzgrenze zu verwenden. Weitere Informationen finden Sie unter [Aggregierte Dateisystemleistung](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html#fsx-aggregate-perf) und [Verwaltung der Speicher- und Durchsatzkapazität](https://docs.aws.amazon.com/fsx/latest/LustreGuide/managing-storage-capacity.html) im *Amazon FSx for Lustre-Benutzerhandbuch*. ## SageMaker Von KI verteilter Schulungsjob mit Hinweisen auf PyTorch veraltete Inhalte Seit Version 1.4.0 funktioniert die SageMaker AI-Bibliothek für verteilte Datenparallelität als Backend von Distributed. PyTorch Aufgrund der bahnbrechenden Änderung bei der Verwendung der Bibliothek mit wird möglicherweise eine Warnmeldung angezeigt PyTorch, dass die `smdistributed` APIs für das PyTorch verteilte Paket veraltet sind. Die Warnmeldung sollte in etwa wie folgt aussehen: ``` smdistributed.dataparallel.torch.dist is deprecated in the SageMaker AI distributed data parallel library v1.4.0+. Please use torch.distributed and specify 'smddp' as a backend when initializing process group as follows: torch.distributed.init_process_group(backend='smddp') For more information, see the library's API documentation at https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel-modify-sdp-pt.html ``` In Version 1.4.0 und höher muss die Bibliothek nur einmal am Anfang Ihres Trainingsskripts importiert und während der verteilten Initialisierung als Backend eingerichtet werden. PyTorch Mit der einzigen Zeile der Backend-Spezifikation können Sie Ihr PyTorch Trainingsskript unverändert lassen und die verteilten Module direkt verwenden. PyTorch Weitere [Verwenden Sie die SMDDP-Bibliothek in Ihrem Trainingsskript PyTorch](data-parallel-modify-sdp-pt.md) Informationen über die wichtigsten Änderungen und die neue Art der Verwendung der Bibliothek finden Sie unter PyTorch. # SageMaker Versionshinweise zur Bibliothek für KI-Datenparallelität In den folgenden Versionshinweisen finden Sie die neuesten Updates für die SageMaker AI Distributed Data Parallelism (SMDDP) -Bibliothek. ## Die SageMaker AI-Bibliothek für verteilte Datenparallelität v2.5.0 *Datum: 17. Oktober 2024* **Neue Features** + Unterstützung für PyTorch v2.4.1 mit CUDA v12.1 hinzugefügt. **Integration in Docker-Container, die über die SageMaker AI Model Parallelism (SMP) -Bibliothek vertrieben werden** Diese Version der SMDDP-Bibliothek ist zu [Die SageMaker Modellparallelismus-Bibliothek v2.6.0](model-parallel-release-notes.md#model-parallel-release-notes-20241017) migriert. ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121 ``` Informationen zu Regionen, in denen die SMP-Docker-Images verfügbar sind, finden Sie unter [AWS-Regionen](distributed-model-parallel-support-v2.md#distributed-model-parallel-availablity-zone-v2). **Binärdatei dieser Version** Sie können die Bibliothek über die folgende URL herunterladen oder installieren. ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.4.1/cu121/2024-10-09/smdistributed_dataparallel-2.5.0-cp311-cp311-linux_x86_64.whl ``` ## Die SageMaker KI-Bibliothek für verteilte Datenparallelität v2.3.0 *Datum: 11. Juni 2024* **Neue Features** + Unterstützung für PyTorch v2.3.0 mit CUDA v12.1 und Python v3.11 hinzugefügt. + Unterstützung für PyTorch Lightning v2.2.5 hinzugefügt. Dies ist in den SageMaker AI-Framework-Container für PyTorch v2.3.0 integriert. + Es wurde eine Überprüfung des Instance-Typs während des Imports hinzugefügt, um das Laden der SMDDP-Bibliothek bei nicht unterstützten Instance-Typen zu verhindern. Eine Liste der Instance-Typen, die mit der SMDDP-Bibliothek kompatibel sind, finden Sie unter [Unterstützte Frameworks AWS-Regionen und Instanztypen](distributed-data-parallel-support.md). **Integration in SageMaker AI Framework-Container** Diese Version der SMDDP-Bibliothek wurde in den folgenden [SageMaker AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) Framework-Container migriert. + PyTorch v2.3.0 ``` 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.3.0-gpu-py311-cu121-ubuntu20.04-sagemaker ``` Eine vollständige Liste der Versionen der SMDDP-Bibliothek und der vorgefertigten Container finden Sie unter [Unterstützte Frameworks AWS-Regionen und Instanztypen](distributed-data-parallel-support.md). **Binärdatei dieser Version** Sie können die Bibliothek über die folgende URL herunterladen oder installieren. ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.3.0/cu121/2024-05-23/smdistributed_dataparallel-2.3.0-cp311-cp311-linux_x86_64.whl ``` Weitere Änderungen + Die SMDDP-Bibliothek v2.2.0 ist in den AI-Framework-Container für v2.2.0 integriert. SageMaker PyTorch ## Die SageMaker AI-Bibliothek für verteilte Datenparallelität v2.2.0 *Datum: 4. März 2024* **Neue Features** + Unterstützung für PyTorch v2.2.0 mit CUDA v12.1 hinzugefügt. **Integration in Docker-Container, die über die SageMaker AI Model Parallelism (SMP) -Bibliothek vertrieben werden** Diese Version der SMDDP-Bibliothek ist zu [Die SageMaker Modellparallelitätsbibliothek v2.2.0](model-parallel-release-notes.md#model-parallel-release-notes-20240307) migriert. ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 ``` Informationen zu Regionen, in denen die SMP-Docker-Images verfügbar sind, finden Sie unter [AWS-Regionen](distributed-model-parallel-support-v2.md#distributed-model-parallel-availablity-zone-v2). **Binärdatei dieser Version** Sie können die Bibliothek über die folgende URL herunterladen oder installieren. ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.2.0/cu121/2024-03-04/smdistributed_dataparallel-2.2.0-cp310-cp310-linux_x86_64.whl ``` ## Die SageMaker KI-Bibliothek für verteilte Datenparallelität v2.1.0 *Datum: 1. März 2024* **Neue Features** + Unterstützung für PyTorch v2.1.0 mit CUDA v12.1 hinzugefügt. **Fehlerbehebungen** + Das Problem mit dem CPU-Speicherleck in [SMDDP v2.0.1](#data-parallel-release-notes-20231207) wurde behoben. **Integration in AI Framework-Container SageMaker ** Diese Version der SMDDP-Bibliothek hat die Benchmark-Tests bestanden und wurde in den folgenden [SageMaker AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) Framework-Container migriert. + PyTorch v2.1.0 ``` 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.1.0-gpu-py310-cu121-ubuntu20.04-sagemaker ``` **Integration in Docker-Container, die über die SageMaker AI Model Parallelism (SMP) -Bibliothek vertrieben werden** Diese Version der SMDDP-Bibliothek ist zu [Die SageMaker Modellparallelitätsbibliothek v2.1.0](model-parallel-release-notes.md#model-parallel-release-notes-20240206) migriert. ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.1.2-gpu-py310-cu121 ``` Informationen zu Regionen, in denen die SMP-Docker-Images verfügbar sind, finden Sie unter [AWS-Regionen](distributed-model-parallel-support-v2.md#distributed-model-parallel-availablity-zone-v2). **Binärdatei dieser Version** Sie können die Bibliothek über die folgende URL herunterladen oder installieren. ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.1.0/cu121/2024-02-04/smdistributed_dataparallel-2.1.0-cp310-cp310-linux_x86_64.whl ``` ## Die SageMaker KI-Bibliothek für verteilte Datenparallelität v2.0.1 *Datum: 7. Dezember 2023* **Neue Features** + Es wurde eine neue SMDDP-Implementierung für `AllGather` kollektiven Betrieb hinzugefügt, die für Rechenressourcen und Netzwerkinfrastruktur optimiert ist. AWS Weitere Informationen hierzu finden Sie unter [Kollektive SMDDP-`AllGather`-Operation](data-parallel-intro.md#data-parallel-allgather). + Der `AllGather` kollektive SMDDP-Betrieb ist kompatibel mit FSDP und. PyTorch DeepSpeed Weitere Informationen hierzu finden Sie unter [Verwenden Sie die SMDDP-Bibliothek in Ihrem Trainingsskript PyTorch](data-parallel-modify-sdp-pt.md). + Unterstützung für v2.0.1 hinzugefügt PyTorch **Bekannte Probleme** + Es gibt ein CPU-Speicherleck, das durch eine allmähliche Erhöhung des CPU-Speichers beim Training mit SMDDP `AllReduce` im DDP-Modus entsteht. **Integration in SageMaker AI Framework-Container** Diese Version der SMDDP-Bibliothek hat die Benchmark-Tests bestanden und wurde in den folgenden [SageMaker AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) Framework-Container migriert. + PyTorch v2.0.1 ``` 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker ``` **Binärdatei dieser Version** Sie können die Bibliothek über die folgende URL herunterladen oder installieren. ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.1/cu118/2023-12-07/smdistributed_dataparallel-2.0.2-cp310-cp310-linux_x86_64.whl ``` Weitere Änderungen + Ab dieser Version ist die Dokumentation für die SMDDP-Bibliothek vollständig in diesem *Amazon SageMaker AI Developer* Guide verfügbar. Für das vollständige Entwicklerhandbuch für SMDDP v2, das im *Amazon SageMaker AI Developer Guide* enthalten ist, wird die Dokumentation für die [zusätzliche Referenz für SMDDP v1.x](https://sagemaker.readthedocs.io/en/stable/api/training/smd_data_parallel.html) in der *SageMaker AI Python SDK-Dokumentation* nicht mehr unterstützt. Wenn Sie weiterhin die SMP v1.x-Dokumentation benötigen, sehen Sie sich den folgenden Snapshot der Dokumentation in der [SageMaker Python SDK v2.212.0-Dokumentation](https://sagemaker.readthedocs.io/en/v2.212.0/api/training/distributed.html#the-sagemaker-distributed-data-parallel-library) an. # SageMaker Modellparallelitätsbibliothek v2 **Anmerkung** Seit der Veröffentlichung der SageMaker-Modellparallelitätsbibliothek (SMP) v2.0.0 am 19. Dezember 2023 wurde diese Dokumentation für die SMP-Bibliothek v2 erneuert. Informationen zu früheren Versionen der SMP-Bibliothek finden Sie unter [(Archiviert) SageMaker-Modellparallelitätsbibliothek v1.x](model-parallel.md). Die Modellparallelitätsbibliothek von Amazon SageMaker AI ist eine Funktion von SageMaker AI, die leistungsstarke, optimierte Trainings in großem Maßstab auf beschleunigten Computing-Instances von SageMaker AI ermöglicht. Zu den [Kernfunktionen der SageMaker Modellparallelitätsbibliothek v2](model-parallel-core-features-v2.md) gehören Techniken und Optimierungen zur Beschleunigung und Vereinfachung des Trainings großer Modelle, wie z. B. die Parallelität hybrider fragmentierter Daten, Tensorparallelität, Aktivierungs-Checkpointing und Aktivierungsauslagerung. Sie können die SMP-Bibliothek verwenden, um das Training und die Optimierung von großen Sprachmodellen (LLMs), Large Vision Models (LVMs) und Basismodellen (FMs) mit Hunderten von Milliarden von Parametern zu beschleunigen. Die SageMaker-Modellparallelitätsbibliothek v2 (SMP v2) passt die APIs und Methoden der Bibliothek an die Open Source PyTorch Fully Sharded Data Parallelism (FSDP) an, wodurch Sie die Vorteile von SMP-Leistungsoptimierungen mit minimalen Codeänderungen nutzen können. Mit SMP v2 können Sie die Rechenleistung beim Training eines hochmodernen großen Modells auf SageMaker AI verbessern, indem Sie Ihre PyTorch-FSDP-Trainingsskripte in SageMaker AI integrieren. Sie können SMP v2 für allgemeine [SageMaker-Trainingsjobs](train-model.md) und verteilte Trainings-Workloads auf [Amazon SageMaker HyperPod](sagemaker-hyperpod.md)-Clustern verwenden. **Topics** + [Konzepte der Modellparallelität](model-parallel-intro-v2.md) + [Unterstützte Frameworks und AWS-Regionen](distributed-model-parallel-support-v2.md) + [Verwenden Sie die SageMaker Modellparallelitätsbibliothek v2](model-parallel-use-api-v2.md) + [Kernfunktionen der SageMaker Modellparallelitätsbibliothek v2](model-parallel-core-features-v2.md) + [Beispiele für die Amazon SageMaker AI-Modellparallelismusbibliothek v2](distributed-model-parallel-v2-examples.md) + [SageMaker Bewährte Methoden für verteilte Modellparallelität](model-parallel-best-practices-v2.md) + [Die Referenz zur SageMaker Modellparallelbibliothek v2](distributed-model-parallel-v2-reference.md) + [Versionshinweise für die SageMaker Modellparallelitätsbibliothek](model-parallel-release-notes.md) + [(Archiviert) SageMaker-Modellparallelitätsbibliothek v1.x](model-parallel.md) # Konzepte der Modellparallelität Modellparallelität ist eine verteilte Trainingsmethode, bei der das Deep-Learning-Modell (DL) auf mehrere GPUs AND-Instanzen aufgeteilt ist. Die SageMaker Modellparallelbibliothek v2 (SMP v2) ist mit den nativen PyTorch APIs Funktionen von AMD kompatibel. Auf diese Weise können Sie Ihr FSDP-Trainingsskript ( PyTorch Fully Sharded Data Parallel) bequem an die SageMaker Trainingsplattform anpassen und die Leistungsverbesserung nutzen, die SMP v2 bietet. Diese Einführungsseite bietet einen allgemeinen Überblick über die Modellparallelität und beschreibt, wie sie helfen kann, Probleme zu lösen, die beim Training von Deep-Learning-Modellen (DL), die in der Regel sehr groß sind, auftreten. Es enthält auch Beispiele dafür, was die SageMaker Modellparallel-Bibliothek bietet, um Modellparallelstrategien und 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, stellt SageMaker KI die Modellparallelbibliothek zur Verfügung, 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 die Modellparallelität 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 automatische Mixed-Precision-Optimierer wie `float16` `bfloat16` (FP16) oder (BF16) und Adam-Optimierer verwendet, beträgt der benötigte GPU-Speicher pro Parameter etwa 20 Byte, den wir wie folgt aufschlüsseln können: + Ein FP16 BF16 Oder-Parameter \$1 2 Byte + Ein FP16 BF16 Oder-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/80 GB Speicher), der auf einer einzelnen GPU verfügbar ist. Zusätzlich zu den Speicheranforderungen für Modell- und Optimiererstatus kommen weitere Speicherverbraucher hinzu, wie z. B. Aktivierungen, die im Vorwärtsdurchlauf generiert werden. Der benötigte Speicher kann deutlich mehr als 200 GB betragen. Für verteilte Schulungen empfehlen wir die Verwendung von Amazon EC2 P4- und P5-Instances mit NVIDIA A100 bzw. H100 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/). Informationen zu Instance-Typen, die SMP v2 unterstützt, finden Sie unter [Unterstützte Instance-Typen](distributed-model-parallel-support-v2.md#distributed-model-parallel-supported-instance-types-v2). Selbst bei den beschleunigte Computing-Instances können 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. ## 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** + [Parallelität fragmentierter Daten](#model-parallel-intro-sdp-v2) + [Expertenparallelität](#model-parallel-intro-expert-parallelism-v2) + [Tensor-Parallelität](#model-parallel-intro-tp-v2) + [Aktivierungs-Checkpointing und -auslagerung](#model-parallel-intro-activation-offloading-checkpointing-v2) + [Auswahl der richtigen Techniken für Ihr Modell](#model-parallel-intro-choosing-techniques-v2) ### Parallelität fragmentierter Daten *Sharded Data Parallelism* ist eine speichersparende verteilte Trainingstechnik, die den Status eines Modells (Modellparameter, Gradienten und Optimiererzustände) innerhalb einer datenparallelen Gruppe aufteilt. GPUs SMP v2 implementiert die Parallelität fragmentierter Daten durch FSDP und erweitert sie, um die skalierbare hybride Sharding-Strategie zu implementieren, die im Blogbeitrag [Nahezu lineare Skalierung des Trainings von Riesenmodellen auf AWS](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws) erörtert wurde. Sie können die Parallelität fragmentierter Daten als eigenständige Strategie auf Ihr Modell anwenden. [Wenn Sie die leistungsfähigsten GPU-Instanzen verwenden, die mit NVIDIA A100 Tensor Core `ml.p4d.24xlarge` und und ausgestattet sind GPUs, können Sie außerdem die Vorteile der verbesserten Trainingsgeschwindigkeit nutzen`ml.p4de.24xlarge`, die der Betrieb der Datenparallelismus-Bibliothek (SMDDP) bietet. `AllGather` SageMaker ](data-parallel.md) Weitere Informationen zur Sharded-Datenparallelität und zu deren Einrichtung oder Verwendung einer Kombination aus Sharded-Datenparallelität und anderen Techniken wie Tensorparallelismus und Training mit gemischter Präzision finden Sie unter [Parallelität hybrider fragmentierter Daten](model-parallel-core-features-v2-sharded-data-parallelism.md). ### Expertenparallelität SMP v2 ist in [NVIDIA Megatron](https://github.com/NVIDIA/Megatron-LM) integriert, um zusätzlich zur Unterstützung des nativen FSDP *Expertenparallelismus* zu implementieren. PyTorch APIs *Sie können Ihren PyTorch FSDP-Trainingscode unverändert lassen und die SMP-Expertenparallelität für das Training von Mixture of Experts (MoE) -Modellen innerhalb von KI anwenden.* SageMaker Ein MoE-Modell ist eine Art Transformer-Modell, das aus mehreren *Experten* besteht, von denen jeder aus einem neuronalen Netzwerk besteht, in der Regel einem Feed-Forward-Netzwerk (FFN). Ein Gate-Netzwerk, das als *Router* bezeichnet wird, bestimmt, welche Token an welchen Experten gesendet werden. Diese Experten sind auf die Verarbeitung bestimmter Aspekte der Eingabedaten spezialisiert, sodass das Modell schneller trainiert werden kann, die Datenverarbeitungskosten reduziert werden und gleichzeitig dieselbe Leistungsqualität wie bei dem Modell mit hoher Dichte erreicht wird. Und *Expertenparallelismus* ist eine Parallelitätstechnik, bei der Experten eines MoE-Modells auf verschiedene GPU-Geräte aufgeteilt werden. Informationen zum Trainieren von MoE-Modellen mit SMP v2 finden Sie unter [Expertenparallelität](model-parallel-core-features-v2-expert-parallelism.md). ### Tensor-Parallelität Die Tensorparallelität teilt einzelne Schichten oder `nn.Modules` auf verschiedene Geräte auf, die parallel ausgeführt werden. Die folgende Abbildung zeigt das einfachste Beispiel dafür, wie die SMP-Bibliothek ein Modell in vier Schichten aufteilt, um eine bidirektionale Tensorparallelität zu erreichen (`"tensor_parallel_degree": 2`). In der folgenden Abbildung lauten die Notationen für Modellparallelgruppe, Tensorparallelgruppe und Datenparallelgruppe jeweils `MP_GROUP`, `TP_GROUP` und `DP_GROUP`. Die Schichten jedes Modellreplikats sind halbiert und in zwei Teile aufgeteilt. GPUs Die Bibliothek verwaltet die Kommunikation zwischen den über Tensor verteilten Modellreplikaten. ![\[Dies ist das einfachste Beispiel dafür, wie die SMP-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/smp-v2-tensor-parallel.png) Weitere Informationen zur Tensorparallelität und zu anderen speichersparenden Funktionen sowie zum PyTorch Einstellen einer Kombination der Kernfunktionen finden Sie unter. [Tensor-Parallelität](model-parallel-core-features-v2-tensor-parallelism.md) ### Aktivierungs-Checkpointing und -auslagerung 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 sie bei der Aktivierungsauslagerung 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 [Checkpointing bei der Aktivierung](model-parallel-core-features-v2-pytorch-activation-checkpointing.md) und [Aktivierung, Entladung](model-parallel-core-features-v2-pytorch-activation-offloading.md). ### Auswahl der richtigen Techniken für Ihr Modell Weitere Informationen zur Auswahl der richtigen Techniken und Konfigurationen finden Sie unter [SageMaker Bewährte Methoden für verteilte Modellparallelität](model-parallel-best-practices-v2.md). # Unterstützte Frameworks und AWS-Regionen Bevor Sie die SageMaker Model Parallelism Library v2 (SMP v2) verwenden, überprüfen Sie die unterstützten Frameworks und Instance-Typen 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 unter [Versionshinweise für die SageMaker Modellparallelitätsbibliothek](model-parallel-release-notes.md). ## Unterstützte Frameworks SMP v2 unterstützt die folgenden Deep-Learning-Frameworks und ist über SMP-Docker-Container und einen SMP-Conda-Kanal verfügbar. Wenn Sie die Framework-Schätzerklassen im SageMaker Python-SDK verwenden und die Verteilungskonfiguration für die Verwendung von SMP v2 angeben, nimmt SageMaker KI die SMP-Docker-Container automatisch auf. Um SMP v2 zu verwenden, empfehlen wir, dass Sie das SageMaker Python-SDK in Ihrer Entwicklungsumgebung immer auf dem neuesten Stand halten. **PyTorch Versionen, die die SageMaker Modellparallelismus-Bibliothek unterstützt** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/distributed-model-parallel-support-v2.html) **SMP-Conda-Kanal** Der folgende Amazon-S3-Bucket ist ein öffentlicher Conda-Kanal, der vom SMP-Serviceteam gehostet wird. Wenn Sie die SMP v2-Bibliothek in einer Umgebung wie SageMaker HyperPod Clustern installieren möchten, verwenden Sie diesen Conda-Kanal, um die SMP-Bibliothek ordnungsgemäß zu installieren. ``` https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/ ``` Weitere Informationen zu Conda-Kanälen im Allgemeinen finden Sie unter [Kanäle](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) in der *Conda-Dokumentation*. **Anmerkung** *Frühere Versionen der SMP-Bibliothek v1.x und vorkonfigurierte Versionen finden Sie [Unterstützte Frameworks](distributed-model-parallel-support.md#distributed-model-parallel-supported-frameworks) in der SMP DLCs v1-Dokumentation.* ### SMP v2 mit Open-Source-Bibliotheken verwenden Die SMP v2-Bibliothek funktioniert mit anderen PyTorch basierten Open-Source-Bibliotheken wie PyTorch Lightning, Hugging Face Transformers und Hugging Face Accelerate, da SMP v2 mit dem FSDP kompatibel ist. PyTorch APIs Wenn Sie weitere Fragen zur Verwendung der SMP-Bibliothek mit anderen Bibliotheken von Drittanbietern haben, wenden Sie sich an das SMP-Serviceteam unter `sm-model-parallel-feedback@amazon.com`. ## AWS-Regionen SMP v2 ist im Folgenden verfügbar. AWS-Regionen Wenn Sie das SMP Docker-Image URIs oder den SMP Conda-Kanal verwenden möchten, überprüfen Sie die folgende Liste und wählen Sie das AWS-Region passende aus. Aktualisieren Sie die Image-URI oder die Kanal-URL entsprechend. + ap-northeast-1 + ap-northeast-2 + ap-northeast-3 + ap-south-1 + ap-southeast-1 + ap-southeast-2 + ca-central-1 + eu-central-1 + eu-north-1 + eu-west-1 + eu-west-2 + eu-west-3 + sa-east-1 + us-east-1 + us-east-2 + us-west-1 + us-west-2 ## Unterstützte Instance-Typen SMP v2 erfordert einen der folgenden ML-Instance-Typen. | Instance-Typ | | --- | | ml.p4d.24xlarge | | ml.p4de.24xlarge | | ml.p5.48xlarge | | ml.p5e.48xlarge | **Tipp** Ab SMP v2.2.0 ist Unterstützung PyTorch für v2.2.0 und höher verfügbar. [Training mit gemischter Präzision FP8 auf P5-Instanzen mithilfe der Transformer Engine](model-parallel-core-features-v2-mixed-precision.md#model-parallel-core-features-v2-mixed-precision-fp8-training-on-p5) Allgemeine Spezifikationen der SageMaker Machine-Learning-Instance-Typen finden Sie im Abschnitt **Accelerated Computing** auf der [Seite Amazon EC2 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 einer Kontingenterhöhung](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html) im *AWS Service Quotas – Benutzerhandbuch*. ``` 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. ``` # Verwenden Sie die SageMaker Modellparallelitätsbibliothek v2 Auf dieser Seite erfahren Sie, wie Sie die SageMaker Modellparallelismus-Bibliothek v2 verwenden APIs und mit der Ausführung eines FSDP-Trainingsjobs ( PyTorch Fully Sharded Data Parallel) auf der Trainingsplattform oder in einem Cluster beginnen. SageMaker SageMaker HyperPod Es gibt verschiedene Szenarien für die Ausführung eines PyTorch Trainingsjobs mit SMP v2. 1. Verwenden Sie für SageMaker Schulungen einen der vorgefertigten SageMaker Framework-Container für Version PyTorch 2.0.1 und höher, die im Lieferumfang von SMP v2 enthalten sind. 1. Verwenden Sie die SMP v2-Binärdatei, um eine Conda-Umgebung für die Ausführung eines verteilten Trainingsworkloads auf einem Cluster einzurichten. SageMaker HyperPod 1. Erweitern Sie die vorgefertigten SageMaker Framework-Container für Version PyTorch 2.0.1 und höher, um zusätzliche funktionale Anforderungen für Ihren Anwendungsfall zu installieren. Informationen dazu, wie Sie einen vorgefertigten Container erweitern können, finden Sie unter [Erweitern eines vorgefertigten Containers](prebuilt-containers-extend.md). 1. Sie können auch Ihren eigenen Docker-Container mitbringen und die gesamte SageMaker Trainingsumgebung mithilfe des [Training-Toolkits manuell einrichten und die SageMaker SMP v2-Binärdatei](https://github.com/aws/sagemaker-training-toolkit) installieren. Diese Option wird aufgrund der Komplexität der Abhängigkeiten am wenigsten empfohlen. Informationen zum Ausführen Ihres eigenen Docker-Containers finden Sie unter [Anpassung Ihres eigenen Trainingscontainers](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html). Dieser Einführungsleitfaden behandelt die ersten beiden Szenarien. **Topics** + [Schritt 1: Passen Sie Ihr PyTorch FSDP-Trainingsskript an](#model-parallel-adapt-pytorch-script-v2) + [Schritt 2: Starten eines Trainingsjobs](#model-parallel-launch-a-training-job-v2) ## Schritt 1: Passen Sie Ihr PyTorch FSDP-Trainingsskript an Um die SMP-v2-Bibliothek zu aktivieren und zu konfigurieren, importieren Sie zunächst das `torch.sagemaker.init()`-Modul und fügen Sie es oben im Skript hinzu. Dieses Modul nimmt das SMP-Konfigurationswörterbuch von [Konfigurationsparameter für die Kernfunktionen von SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config) auf, das Sie in [Schritt 2: Starten eines Trainingsjobs](#model-parallel-launch-a-training-job-v2) vorbereiten werden. Um die verschiedenen Kernfunktionen von SMP v2 nutzen zu können, müssen Sie möglicherweise weitere Änderungen zur Anpassung Ihres Trainingsskripts vornehmen. Ausführlichere Anweisungen zur Anpassung Ihres Trainingsskripts für die Nutzung der Kernfunktionen von SMP v2 finden Sie unter [Kernfunktionen der SageMaker Modellparallelitätsbibliothek v2](model-parallel-core-features-v2.md). ------ #### [ SageMaker Training ] Fügen Sie Ihrem Trainingsskript die folgenden zwei Codezeilen hinzu. Dies ist die Mindestanforderung, um mit dem Training mit SMP v2 zu beginnen. In [Schritt 2: Starten eines Trainingsjobs](#model-parallel-launch-a-training-job-v2) richten Sie mithilfe des `distribution` Arguments der Schätzerklasse ein Objekt der SageMaker `PyTorch` Schätzerklasse mit einem SMP-Konfigurationswörterbuch ein. ``` import torch.sagemaker as tsm tsm.init() ``` **Anmerkung** Sie können ein Konfigurationswörterbuch von [Konfigurationsparameter für die Kernfunktionen von SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config) auch direkt an das `torch.sagemaker.init()`-Modul übergeben. Die an den PyTorch Schätzer übergebenen Parameter haben jedoch Priorität und überschreiben die für das Modul angegebenen Parameter. [Schritt 2: Starten eines Trainingsjobs](#model-parallel-launch-a-training-job-v2) `torch.sagemaker.init()` ------ #### [ SageMaker HyperPod ] Fügen Sie in Ihrem Trainingsskript die folgenden beiden Codezeilen hinzu. In [Schritt 2: Starten eines Trainingsjobs](#model-parallel-launch-a-training-job-v2) richten Sie eine `smp_config.json` Datei für die Einrichtung von SMP-Konfigurationen im JSON-Format ein und laden sie in einen Speicher oder ein Dateisystem hoch, das Ihrem Cluster zugeordnet ist. SageMaker HyperPod Wir empfehlen, die Konfigurationsdatei in demselben Verzeichnis zu speichern, in das Sie Ihr Trainingsskript hochladen. ``` import torch.sagemaker as tsm tsm.init("/dir_to_training_files/smp_config.json") ``` **Anmerkung** Sie können ein Konfigurationswörterbuch von [Konfigurationsparameter für die Kernfunktionen von SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config) auch direkt an das `torch.sagemaker.init()`-Modul übergeben. ------ ## Schritt 2: Starten eines Trainingsjobs Erfahren Sie, wie Sie SMP-Verteilungsoptionen für den Start eines PyTorch FSDP-Trainingsjobs mit SMP-Kernfunktionen konfigurieren. ------ #### [ SageMaker Training ] Wenn Sie ein Trainingsjob-Launcher-Objekt der [PyTorch Framework-Estimator-Klasse](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html) im SageMaker Python-SDK einrichten, konfigurieren Sie [Konfigurationsparameter für die Kernfunktionen von SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config) das `distribution` Argument wie folgt. **Anmerkung** Die `distribution` Konfiguration für SMP v2 ist ab Version 2.200 in das SageMaker Python-SDK integriert. Stellen Sie sicher, dass Sie das SageMaker Python-SDK v2.200 oder höher verwenden. **Anmerkung** In SMP v2 sollten Sie `smdistributed` mit `torch_distributed` für das `distribution` Argument des Schätzers konfigurieren. SageMaker `PyTorch` [Mit `torch_distributed` wird SageMaker AI ausgeführt. Dabei handelt es `torchrun` sich um den standardmäßigen Job-Launcher von Distributed mit mehreren Knoten. PyTorch ](https://pytorch.org/tutorials/beginner/dist_overview.html) ``` from sagemaker.pytorch import PyTorch estimator = PyTorch( framework_version=2.2.0, py_version="310" # image_uri="" # For using prior versions, specify the SMP image URI directly. entry_point="your-training-script.py", # Pass the training script you adapted with SMP from Step 1. ... # Configure other required and optional parameters distribution={ "torch_distributed": { "enabled": True }, "smdistributed": { "modelparallel": { "enabled": True, "parameters": { "hybrid_shard_degree": Integer, "sm_activation_offloading": Boolean, "activation_loading_horizon": Integer, "fsdp_cache_flush_warnings": Boolean, "allow_empty_shards": Boolean, "tensor_parallel_degree": Integer, "expert_parallel_degree": Integer, "random_seed": Integer } } } } ) ``` **Wichtig** Wenn Sie eine der früheren Versionen von PyTorch oder SMP anstelle der neuesten verwenden möchten, müssen Sie das SMP-Docker-Image direkt angeben, indem Sie das `image_uri` Argument anstelle des und-Paars verwenden. `framework_version` `py_version` Es folgt ein Beispiel für ``` estimator = PyTorch( ..., image_uri="658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121" ) ``` Informationen zum Suchen des SMP Docker-Images finden Sie unter. URIs [Unterstützte Frameworks](distributed-model-parallel-support-v2.md#distributed-model-parallel-supported-frameworks-v2) ------ #### [ SageMaker HyperPod ] Überprüfen Sie vor Beginn, ob die folgenden Anforderungen erfüllt sind: + Ein FSx freigegebenes Amazon-Verzeichnis, das an Ihren HyperPod Cluster gemountet ist (`/fsx`). + Conda wurde im FSx gemeinsamen Verzeichnis installiert. Anweisungen zur Installation von Conda finden Sie unter [Installation unter Linux](https://docs.conda.io/projects/conda/en/latest/user-guide/install/linux.html) im *Conda-Benutzerhandbuch*. + `cuda11.8`oder auf den Head- und Compute-Knoten Ihres HyperPod Clusters `cuda12.1` installiert. Wenn alle Voraussetzungen erfüllt sind, fahren Sie mit den folgenden Anweisungen zum Starten eines Workloads mit SMP v2 auf einem HyperPod Cluster fort. 1. Bereiten Sie eine `smp_config.json`-Datei vor, die ein Wörterbuch von [Konfigurationsparameter für die Kernfunktionen von SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config) enthält. Stellen Sie sicher, dass Sie diese JSON-Datei in den Speicherort Ihres Trainingsskripts oder den in [Schritt 1](#model-parallel-adapt-pytorch-script-v2) für das `torch.sagemaker.init()`-Modul angegebenen Pfad hochladen. Wenn Sie das Konfigurationswörterbuch bereits in [Schritt 1](#model-parallel-adapt-pytorch-script-v2) an das `torch.sagemaker.init()`-Modul im Trainingsskript übergeben haben, können Sie diesen Schritt überspringen. ``` // smp_config.json { "hybrid_shard_degree": Integer, "sm_activation_offloading": Boolean, "activation_loading_horizon": Integer, "fsdp_cache_flush_warnings": Boolean, "allow_empty_shards": Boolean, "tensor_parallel_degree": Integer, "expert_parallel_degree": Integer, "random_seed": Integer } ``` 1. Laden Sie die `smp_config.json`-Datei in ein Verzeichnis in Ihrem Dateisystem hoch. Der Verzeichnispfad muss mit dem Pfad übereinstimmen, den Sie in [Schritt 1](#model-parallel-adapt-pytorch-script-v2) angegeben haben. Wenn Sie das Konfigurationswörterbuch bereits an das `torch.sagemaker.init()`-Modul im Trainingsskript übergeben haben, können Sie diesen Schritt überspringen. 1. Starten Sie auf den Rechenknoten Ihres Clusters eine Terminalsitzung mit dem folgenden Befehl. ``` sudo su -l ubuntu ``` 1. Erstellen Sie eine Conda-Umgebung auf den Rechenknoten. Der folgende Code ist ein Beispielskript für die Erstellung einer Conda-Umgebung und die Installation von SMP, [SMDDP](data-parallel.md), CUDA und anderen Abhängigkeiten. ``` # Run on compute nodes SMP_CUDA_VER=<11.8 or 12.1> source /fsx//miniconda3/bin/activate export ENV_PATH=/fsx//miniconda3/envs/ conda create -p ${ENV_PATH} python=3.10 conda activate ${ENV_PATH} # Verify aws-cli is installed: Expect something like "aws-cli/2.15.0*" aws ‐‐version # Install aws-cli if not already installed # https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html#cliv2-linux-install # Install the SMP library conda install pytorch="2.0.1=sm_py3.10_cuda${SMP_CUDA_VER}*" packaging ‐‐override-channels \ -c https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-2.0.0-pt-2.0.1/2023-12-11/smp-v2/ \ -c pytorch -c numba/label/dev \ -c nvidia -c conda-forge # Install dependencies of the script as below python -m pip install packaging transformers==4.31.0 accelerate ninja tensorboard h5py datasets \ && python -m pip install expecttest hypothesis \ && python -m pip install "flash-attn>=2.0.4" ‐‐no-build-isolation # Install the SMDDP wheel SMDDP_WHL="smdistributed_dataparallel-2.0.2-cp310-cp310-linux_x86_64.whl" \ && wget -q https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.1/cu118/2023-12-07/${SMDDP_WHL} \ && pip install ‐‐force ${SMDDP_WHL} \ && rm ${SMDDP_WHL} # cuDNN installation for Transformer Engine installation for CUDA 11.8 # Please download from below link, you need to agree to terms # https://developer.nvidia.com/downloads/compute/cudnn/secure/8.9.5/local_installers/11.x/cudnn-linux-x86_64-8.9.5.30_cuda11-archive.tar.xz tar xf cudnn-linux-x86_64-8.9.5.30_cuda11-archive.tar.xz \ && rm -rf /usr/local/cuda-$SMP_CUDA_VER/include/cudnn* /usr/local/cuda-$SMP_CUDA_VER/lib/cudnn* \ && cp ./cudnn-linux-x86_64-8.9.5.30_cuda11-archive/include/* /usr/local/cuda-$SMP_CUDA_VER/include/ \ && cp ./cudnn-linux-x86_64-8.9.5.30_cuda11-archive/lib/* /usr/local/cuda-$SMP_CUDA_VER/lib/ \ && rm -rf cudnn-linux-x86_64-8.9.5.30_cuda11-archive.tar.xz \ && rm -rf cudnn-linux-x86_64-8.9.5.30_cuda11-archive/ # Please download from below link, you need to agree to terms # https://developer.download.nvidia.com/compute/cudnn/secure/8.9.7/local_installers/12.x/cudnn-linux-x86_64-8.9.7.29_cuda12-archive.tar.xz \ # cuDNN installation for TransformerEngine installation for cuda12.1 tar xf cudnn-linux-x86_64-8.9.7.29_cuda12-archive.tar.xz \ && rm -rf /usr/local/cuda-$SMP_CUDA_VER/include/cudnn* /usr/local/cuda-$SMP_CUDA_VER/lib/cudnn* \ && cp ./cudnn-linux-x86_64-8.9.7.29_cuda12-archive/include/* /usr/local/cuda-$SMP_CUDA_VER/include/ \ && cp ./cudnn-linux-x86_64-8.9.7.29_cuda12-archive/lib/* /usr/local/cuda-$SMP_CUDA_VER/lib/ \ && rm -rf cudnn-linux-x86_64-8.9.7.29_cuda12-archive.tar.xz \ && rm -rf cudnn-linux-x86_64-8.9.7.29_cuda12-archive/ # TransformerEngine installation export CUDA_HOME=/usr/local/cuda-$SMP_CUDA_VER export CUDNN_PATH=/usr/local/cuda-$SMP_CUDA_VER/lib export CUDNN_LIBRARY=/usr/local/cuda-$SMP_CUDA_VER/lib export CUDNN_INCLUDE_DIR=/usr/local/cuda-$SMP_CUDA_VER/include export PATH=/usr/local/cuda-$SMP_CUDA_VER/bin:$PATH export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-$SMP_CUDA_VER/lib python -m pip install ‐‐no-build-isolation git+https://github.com/NVIDIA/TransformerEngine.git@v1.0 ``` 1. Führen Sie einen Test-Trainingsjob aus. 1. Klonen Sie im gemeinsam genutzten Dateisystem (`/fsx`) das [Awsome Distributed GitHub Training-Repository](https://github.com/aws-samples/awsome-distributed-training/) und wechseln Sie zu dem `3.test_cases/11.modelparallel` Ordner. ``` git clone https://github.com/aws-samples/awsome-distributed-training/ cd awsome-distributed-training/3.test_cases/11.modelparallel ``` 1. Reichen Sie einen Job mit `sbatch` wie folgt ein. ``` conda activate sbatch -N 16 conda_launch.sh ``` Wenn der Job erfolgreich eingereicht wurde, sollte die Ausgabemeldung dieses `sbatch`-Befehls ähnlich wie `Submitted batch job ABCDEF` lauten. 1. Überprüfen Sie die Protokolldatei im aktuellen Verzeichnis unter `logs/`. ``` tail -f ./logs/fsdp_smp_ABCDEF.out ``` ------ # Kernfunktionen der SageMaker Modellparallelitätsbibliothek v2 Die Amazon SageMaker AI Model Parallelism Library v2 (SMP v2) bietet Vertriebsstrategien und speichersparende Techniken wie Sharded Data Parallelism, Tensor Parallelism und Checkpointing. Die Strategien und Techniken zur Modellparallelität von SMP v2 helfen dabei, große Modelle auf mehrere Geräte zu verteilen und dabei das Trainingsgeschwindigkeit und die Speichernutzung zu optimieren. SMP v2 bietet auch ein Python-Paket `torch.sagemaker`, mit dem Sie Ihr Trainingsskript mit wenigen Codeänderungen anpassen können. Dieses Handbuch folgt dem grundlegenden zweistufigen Ablauf, der in [Verwenden Sie die SageMaker Modellparallelitätsbibliothek v2](model-parallel-use-api-v2.md) vorgestellt wurde. Weitere Informationen zu den Kernfunktionen von SMP 2 und deren Verwendung finden Sie in den folgenden Themen. **Anmerkung** Diese Kernfunktionen sind in SMP v2.0.0 und höher sowie im SageMaker Python SDK v2.200.0 und höher verfügbar und funktionieren für v2.0.1 und höher. PyTorch Informationen zur Überprüfung der Versionen der Pakete finden Sie unter [Unterstützte Frameworks und AWS-Regionen](distributed-model-parallel-support-v2.md). **Topics** + [Parallelität hybrider fragmentierter Daten](model-parallel-core-features-v2-sharded-data-parallelism.md) + [Expertenparallelität](model-parallel-core-features-v2-expert-parallelism.md) + [Kontextparallelität](model-parallel-core-features-v2-context-parallelism.md) + [Kompatibilität mit der für die Infrastruktur optimierten SMDDP-Bibliothek AWS](model-parallel-core-features-v2-smddp-allgather.md) + [Training mit gemischter Präzision](model-parallel-core-features-v2-mixed-precision.md) + [Verzögerte Parameterinitialisierung](model-parallel-core-features-v2-delayed-param-init.md) + [Checkpointing bei der Aktivierung](model-parallel-core-features-v2-pytorch-activation-checkpointing.md) + [Aktivierung, Entladung](model-parallel-core-features-v2-pytorch-activation-offloading.md) + [Tensor-Parallelität](model-parallel-core-features-v2-tensor-parallelism.md) + [Feinabstimmung](model-parallel-core-features-v2-fine-tuning.md) + [FlashAttention](model-parallel-core-features-v2-flashattention.md) + [Checkpointing mit SMP](model-parallel-core-features-v2-checkpoints.md) # Parallelität hybrider fragmentierter Daten *Parallelität fragmentierter Daten* ist eine verteilte Trainingstechnik, die Speicher spart und den Zustand eines Modells (Modellparameter, Steigungen und Optimierer-Zustände) auf mehrere Geräte aufteilt. Auf diese Weise können Sie mithilfe des freigewordenen GPU-Speichers ein größeres Modell aufnehmen oder die Batchgröße erhöhen. Die SMP-Bibliothek bietet die Möglichkeit, Sharded Data Parallelität mit Fully Sharded Data Parallel (FSDP) auszuführen. PyTorch PyTorch FSDP verwendet standardmäßig Shards für den gesamten verwendeten Satz. GPUs In SMP v2 bietet die Bibliothek diese Shard-Datenparallelität zusätzlich zu PyTorch FSDP, indem sie PyTorch Hybrid Sharding (`HYBRID_SHARD`) erweitert. Dabei handelt es sich um eine der [Sharding-Strategien](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.ShardingStrategy) von FSDP:,,,. PyTorch `FULL_SHARD` `SHARD_GRAD_OP` `HYBRID_SHARD` `_HYBRID_SHARD_ZERO2` [Die Erweiterung des Hybrid-Shardings auf diese Weise hilft bei der Implementierung, scale-aware-sharding wie im Blog Near-linear scaling of gigantic-model training on for FSDP beschrieben. AWS](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws) PyTorch Die SMP-Bibliothek ermöglicht eine einfache Bedienung `HYBRID_SHARD` und ermöglicht eine beliebige konfigurierbare Anzahl von `_HYBRID_SHARD_ZERO2` Anwendungen. Sie erweitert das native PyTorch FSDP GPUs, das Sharding auf einem einzelnen Knoten () oder auf allen () unterstützt. `HYBRID_SHARD` GPUs `FULL_SHARD` PyTorch FSDP-Aufrufe können unverändert bleiben, und Sie müssen nur das `hybrid_shard_degree` Argument zur SMP-Konfiguration hinzufügen, wie im folgenden Codebeispiel gezeigt. Sie müssen den Wert des `sharding_strategy` Arguments im PyTorch FSDP-Wrapper, der Ihr Modell umgibt, nicht ändern. PyTorch Sie können `ShardingStrategy.HYBRID_SHARD` als Wert übergeben. Alternativ überschreibt die SMP-Bibliothek die Strategie im Skript und setzt sie auf `ShardingStrategy.HYBRID_SHARD`, wenn Sie für den `hybrid_shard_degree`-Parameter einen Wert gleich oder größer als 2 angeben. Die folgenden Codefragmente zeigen, wie Sie das SMP-Initialisierungsmodul `torch.sagemaker.init()` zu Ihrem Trainingsskript hinzufügen und das SMP-Konfigurationswörterbuch im JSON-Format für den Trainingsjob-Launcher einrichten. Dabei folgen Sie dem in [Verwenden Sie die SageMaker Modellparallelitätsbibliothek v2](model-parallel-use-api-v2.md) beschriebenen zweistufigen Prozess. Sie müssen keine Änderungen an Ihrem PyTorch Modell oder Ihrer [PyTorch FSDP-Konfiguration](https://pytorch.org/docs/stable/fsdp.html#module-torch.distributed.fsdp) vornehmen. Weitere Informationen zum Parameter `hybrid_shard_degree` erhalten Sie unter [Konfigurationsparameter für die Kernfunktionen von SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config). **SMP-Konfigurationswörterbuch** ``` { "hybrid_shard_degree": 16 } ``` **Im Trainingsskript** ``` import torch.sagemaker as tsm tsm.init() # Set up a PyTorch model model = ... # Wrap the PyTorch model using the PyTorch FSDP module model = FSDP( model, ... ) # Optimizer needs to be created after FSDP wrapper optimizer = ... ``` # Expertenparallelität Ein *Mixture-of-Experts*-Modell (MoE) ist eine Art Transformer-Modell, das einen Ansatz mit *geringer Dichte* verwendet, sodass es leichter zu trainieren ist als das Training mit herkömmlichen Modellen mit hoher Dichte. In der neuronalen Netzwerkarchitektur von MoE wird für jede Eingabe nur eine Teilmenge der Modellkomponenten, die als *Experten* bezeichnet werden, verwendet. Dieser Ansatz bietet mehrere Vorteile, darunter effizienteres Training und schnellere Inferenz, selbst bei einer größeren Modellgröße. Mit anderen Worten: Mit dem gleichen Budget für das Training eines Modells mit hoher Dichte können Sie ein größeres Modell oder einen größeren Datensatz einfügen, wenn Sie MoE verwenden. Ein MoE-Modell besteht aus mehreren *Experten*, die jeweils aus einem neuronalen Netzwerk bestehen, in der Regel einem Feed-Forward-Netzwerk (FFN). Ein Gate-Netzwerk, das als *Router* bezeichnet wird, bestimmt, welche Token an welchen Experten gesendet werden. Diese Experten sind auf die Verarbeitung bestimmter Aspekte der Eingabedaten spezialisiert, sodass das Modell schneller trainiert werden kann, die Datenverarbeitungskosten reduziert werden und gleichzeitig dieselbe Leistungsqualität wie bei dem Modell mit hoher Dichte erreicht wird. Weitere Informationen zu Mixture of Experts im Allgemeinen finden Sie im Blog [Anwendung von Mixture of Experts in LLM-Architekturen](https://developer.nvidia.com/blog/applying-mixture-of-experts-in-llm-architectures/) auf der *NVIDIA-Entwickler-Website*. *Expertenparallelität* ist eine Art von Parallelität, bei der Experten eines MoE-Modells auf verschiedene GPU-Geräte aufgeteilt werden. SMP v2 ist in [NVIDIA Megatron](https://github.com/NVIDIA/Megatron-LM) integriert, um Expertenparallelität zur Unterstützung von MoE-Trainingsmodellen zu implementieren, und läuft auf FSDP. PyTorch APIs Sie verwenden Ihren PyTorch FSDP-Trainingscode unverändert und aktivieren die SMP-Expertenparallelität für das Training von MoE-Modellen. ## Transformer-Modelle von Hugging Face, die mit der SMP-Expertenparallelität kompatibel sind SMP v2 bietet derzeit Unterstützung der Expertenparallelität für die folgenden Transformer-Modelle von Hugging Face. + [Mixtral](https://huggingface.co/docs/transformers/en/model_doc/mixtral) ## Expertenparallelität konfigurieren Für `expert_parallel_degree` wählen Sie einen Wert für den Grad der Expertenparallelität aus. Der Wert muss die Anzahl der in Ihrem Cluster gleichmäßig teilen. GPUs Um beispielsweise Ihr Modell zu teilen, während Sie eine Instanz mit 8 verwenden GPUs, wählen Sie 2, 4 oder 8. Wir empfehlen, mit einer kleinen Zahl zu beginnen und diese schrittweise zu erhöhen, bis das Modell in den GPU-Speicher passt. Die folgenden Codefragmente zeigen, wie Sie das SMP-Initialisierungsmodul `torch.sagemaker.init()` zu Ihrem Trainingsskript hinzufügen und das SMP-Konfigurationswörterbuch im JSON-Format für den Trainingsjob-Launcher einrichten. Dabei folgen Sie dem in [Verwenden Sie die SageMaker Modellparallelitätsbibliothek v2](model-parallel-use-api-v2.md) beschriebenen zweistufigen Prozess. Sie müssen keine Änderungen an Ihrem PyTorch Modell oder Ihrer [PyTorch FSDP-Konfiguration](https://pytorch.org/docs/stable/fsdp.html#module-torch.distributed.fsdp) vornehmen. Weitere Informationen zum Parameter `expert_parallel_degree` erhalten Sie unter [Konfigurationsparameter für die Kernfunktionen von SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config). **Anmerkung** Sie können Expertenparallelität mit [Parallelität hybrider fragmentierter Daten](model-parallel-core-features-v2-sharded-data-parallelism.md) verwenden. Beachten Sie, dass die Expertenparallelität derzeit nicht mit der Tensor-Parallelität kompatibel ist. **Anmerkung** Diese Schulungsfunktion für Experten im Bereich Parallelität ist in der folgenden Kombination aus Bibliotheken von SageMaker und der Bibliothek verfügbar: PyTorch SMP v2.3.0 und höher Das SageMaker Python SDK v2.214.4 und höher PyTorch v2.2.0 und höher ### In Ihrem Trainingsskript Initialisieren Sie im Rahmen von [Schritt 1](model-parallel-use-api-v2.md#model-parallel-adapt-pytorch-script-v2) Ihr Skript mit `torch.sagemaker.init()`, um SMP v2 zu aktivieren, und umschließen Sie Ihr Modell mit der [`torch.sagemaker.transform`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-transform)-API, wobei Sie der API den `config`-Parameter hinzufügen, um MoE zu aktivieren. Der folgende Codeausschnitt zeigt, wie Sie SMP MoE für die generische Modellklasse `AutoModelForCausalLM` aktivieren, indem Sie mit der `from_config`-Methode für das Training von Grund auf oder mit der `from_pretrained`-Methode für die Optimierung eine MoE-Transformer-Modellkonfiguration abrufen. Weitere Informationen zur SMP-`MoEConfig`-Klasse finden Sie unter [`torch.sagemaker.moe.moe_config.MoEConfig`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-moe). ``` # Import the torch.sagemaker.transform API and initialize. import torch.sagemaker as tsm tsm.init() # Import transformers AutoModelForCausalLM class. from transformers import AutoModelForCausalLM # Import the SMP-implementation of MoE configuration class. from torch.sagemaker.moe.moe_config import MoEConfig # Define a transformer model with an MoE model configuration model = AutoModelForCausalLM.from_config(MoEModelConfig) # Wrap it by torch.sagemaker.transform with the SMP MoE configuration. model = tsm.transform( model, config=MoEConfig( smp_moe=True, random_seed=12345, moe_load_balancing="sinkhorn", global_token_shuffle=False, moe_all_to_all_dispatcher=True, moe_aux_loss_coeff=0.001, moe_z_loss_coeff=0.001 ) ) ``` ### SMP-Konfiguration Fügen Sie im Rahmen von [Schritt 2](model-parallel-use-api-v2.md#model-parallel-launch-a-training-job-v2) den folgenden Parameter zum SMP-Konfigurationswörterbuch für den Schätzer hinzu. SageMaker PyTorch ``` { ..., # other SMP config parameters "expert_parallel_degree": 8 } ``` # Kontextparallelität *Kontextparallelität* ist eine Art von Modellparallelität, bei der die Modellaktivierungen entlang der Sequenzdimension fragmentiert werden. Im Gegensatz zu anderen Techniken der [Sequenzparallelität](https://arxiv.org/abs/2205.05198), die nur die `LayerNorm` und `RMSNorm` partitionieren, partitioniert die Kontextparallelität die Netzwerkeingänge und alle dazwischenliegenden Aktivierungen entlang der Sequenzdimension. SMP v2 ist für Kontextparallelität in die [Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/index.html) integriert und kann in Verbindung mit FSDP und SMP verwendet werden. PyTorch [Tensor-Parallelität](model-parallel-core-features-v2-tensor-parallelism.md) Sie können alle drei Parallelitäten gleichzeitig für das Modelltraining aktivieren. Kontextparallelität ist für Trainingsmodelle mit großen Aktivierungsgrößen und langen Sequenzlängen von Vorteil. Sie beschleunigt die Berechnung von Aufmerksamkeitswerten und Aufmerksamkeitsergebnissen, da jedes Gerät nur einen Teil der Werte und Ergebnisse entlang der Sequenzdimension berechnen kann. Die Tensorparallelität beschleunigt zwar auch die Berechnung durch Partitionierung entlang der verborgenen Dimension, doch der Vorteil der Kontextparallelität ist größer, da die Rechenanforderungen quadratisch mit der Sequenzdimension steigen. ## Transformer-Modelle von Hugging Face, die mit der SMP-Kontextparallelität kompatibel sind SMP v2 bietet derzeit Unterstützung der Kontextparallelität für die folgenden Transformer-Modelle von Hugging Face. + GPT-NeoX + Llama 2 und Llama 3 + [Mistral 7B](https://huggingface.co/mistralai/Mistral-7B-v0.3) ## Kontextparallelität konfigurieren Legen Sie einen ganzzahligen Wert für den `context_parallel_degree` Parameter fest, der die Anzahl der in Ihrem Cluster gleichmäßig verteilt. GPUs Wenn Sie z. B. eine 8-GPU-Instance haben, verwenden Sie 2, 4 oder 8 für `context_parallel_degree`. Wir empfehlen, mit einem kleinen `context_parallel_degree`-Wert zu beginnen und ihn schrittweise zu erhöhen, bis das Modell mit der erforderlichen Länge der Eingabesequenz in den GPU-Speicher passt. Die folgenden Codefragmente zeigen, wie Sie das SMP-Initialisierungsmodul `torch.sagemaker.init()` zu Ihrem Trainingsskript hinzufügen und das SMP-Konfigurationswörterbuch im JSON-Format für den Trainingsjob-Launcher einrichten. Dabei folgen Sie dem in [Verwenden Sie die SageMaker Modellparallelitätsbibliothek v2](model-parallel-use-api-v2.md) beschriebenen zweistufigen Prozess. Sie müssen keine Änderungen an Ihrem PyTorch Modell oder Ihrer [PyTorch FSDP-Konfiguration](https://pytorch.org/docs/stable/fsdp.html#module-torch.distributed.fsdp) vornehmen. Weitere Informationen zum Parameter `context_parallel_degree` erhalten Sie unter [Konfigurationsparameter für die Kernfunktionen von SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config). ### In Ihrem Trainingsskript Initialisieren Sie im Rahmen von [Schritt 1](model-parallel-use-api-v2.md#model-parallel-adapt-pytorch-script-v2) Ihr Skript mit `torch.sagemaker.init()`, um SMP v2 zu aktivieren, und umschließen Sie Ihr Modell mit der [`torch.sagemaker.transform`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-transform)-API. Ab SMP v2.6.0 können Sie das Argument `cp_comm_type` verwenden, um zu bestimmen, welche Implementierung der Kontextparallelität verwendet werden soll. Die SMP-Bibliothek unterstützt derzeit zwei Implementierungen: `p2p` und `all_gather`. Die `p2p` Implementierung verwendet peer-to-peer Send-Receive-Aufrufe zur Akkumulation von Schlüsselwerten während der Aufmerksamkeitsimplementierung und wird asynchron ausgeführt, sodass Überschneidungen mit der Datenverarbeitung möglich sind. `all_gather`Die Implementierung verwendet stattdessen die kollektive Operation und wird synchron ausgeführt`AllGather`. ``` import torch.sagemaker as tsm tsm.init() from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_config(..) model = tsm.transform(model, cp_comm_type="p2p") ``` ### SMP-Konfiguration Fügen Sie im Rahmen von [Schritt 2](model-parallel-use-api-v2.md#model-parallel-launch-a-training-job-v2) den folgenden Parameter zum SMP-Konfigurationswörterbuch für den SageMaker PyTorch Schätzer hinzu. ``` { ..., # other SMP config parameters "context_parallel_degree": 2 } ``` # Kompatibilität mit der für die Infrastruktur optimierten SMDDP-Bibliothek AWS Sie können die SageMaker Modellparallelismusbibliothek v2 (SMP v2) in Verbindung mit der Bibliothek für [SageMaker verteilte Datenparallelität (SMDDP) verwenden, die den für die Infrastruktur optimierten Betrieb der kollektiven Kommunikation](data-parallel.md) ermöglicht. `AllGather` AWS Beim verteilten Training sind kollektive Kommunikationsoperationen darauf ausgelegt, mehrere GPU-Worker zu synchronisieren und Informationen zwischen ihnen auszutauschen. `AllGather` ist eine der wichtigsten kollektiven Kommunikationsoperationen, die typischerweise bei der Parallelität fragmentierter Data verwendet werden. Weitere Informationen zum `AllGather` SMDDP-Betrieb finden Sie unter Die [Kollektive SMDDP-`AllGather`-Operation](data-parallel-intro.md#data-parallel-allgather) Optimierung solcher kollektiver Kommunikationsoperationen würde direkt zu einem schnelleren Training beitragen, ohne dass Nebenwirkungen auf die Konvergenz auftreten. end-to-end **Anmerkung** Die SMDDP-Bibliothek unterstützt P4- und P4de-Instances (siehe auch [Unterstützte Frameworks AWS-Regionen und Instanztypen](distributed-data-parallel-support.md) von der SMDDP-Bibliothek). [Die SMDDP-Bibliothek lässt sich PyTorch über die Prozessgruppenebene nativ integrieren.](https://pytorch.org/docs/stable/distributed.html) Um die SMDDP-Bibliothek zu verwenden, müssen Sie Ihrem Trainingsskript nur zwei Codezeilen hinzufügen. Sie unterstützt alle Schulungs-Frameworks wie SageMaker Model Parallelism Library, FSDP und. PyTorch DeepSpeed Um SMDDP zu aktivieren und die `AllGather`-Operation zu nutzen, müssen Sie Ihrem Trainingsskript als Teil von [Schritt 1: Passen Sie Ihr PyTorch FSDP-Trainingsskript an](model-parallel-use-api-v2.md#model-parallel-adapt-pytorch-script-v2) zwei Codezeilen hinzufügen. Beachten Sie, dass Sie PyTorch Distributed zuerst mit dem SMDDP-Backend initialisieren und dann die SMP-Initialisierung ausführen müssen. ``` import torch.distributed as dist # Initialize with SMDDP import smdistributed.dataparallel.torch.torch_smddp dist.init_process_group(backend="smddp") # Replacing "nccl" # Initialize with SMP import torch.sagemaker as tsm tsm.init() ``` [SageMaker Framework-Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) für PyTorch (siehe auch [Unterstützte Frameworks und AWS-Regionen](distributed-model-parallel-support-v2.md) von SMP v2 und [Unterstützte Frameworks AWS-Regionen und Instanztypen](distributed-data-parallel-support.md) von der SMDDP-Bibliothek) sind mit der SMP-Binärdatei und der SMDDP-Binärdatei vorkonfiguriert. Weitere Informationen zur SMDDP-Bibliothek finden Sie unter [Führen Sie verteilte Schulungen mit der SageMaker KI-Bibliothek für verteilte Datenparallelität durch](data-parallel.md). # Training mit gemischter Präzision Die SageMaker Modellparallelismus-Bibliothek (SMP) v2 unterstützt standardmäßig gemischtes Präzisionstraining, indem sie in Open-Source-Frameworks wie FSDP und Transformer Engine integriert wird. PyTorch Weitere Informationen finden Sie unter den folgenden Themen. **Topics** + [Training mit gemischter Präzision FP8 auf P5-Instanzen mithilfe der Transformer Engine](#model-parallel-core-features-v2-mixed-precision-fp8-training-on-p5) + [Gemischtes Präzisionstraining mit Datentypen mit halber Genauigkeit unter Verwendung von FSDP PyTorch](#model-parallel-core-features-v2-mixed-precision-half-precision) ## Training mit gemischter Präzision FP8 auf P5-Instanzen mithilfe der Transformer Engine [Ausgehend von der SageMaker Modellparallelismus-Bibliothek (SMP) v2.2.0 ist die SMP-Bibliothek in die [Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/index.html) integriert und unterstützt standardmäßig [FP8 gemischtes Präzisionstraining](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/examples/fp8_primer.html), wobei die Kompatibilität mit FSDP gewahrt bleibt. PyTorch `MixedPrecision`](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.MixedPrecision) Das bedeutet, dass Sie sowohl PyTorch FSDP für Mixed-Precision-Training als auch Transformer Engine für Schulungen verwenden können. FP8 Für Modellebenen, die nicht von der FP8 Trainingsfunktion der Transformer Engine unterstützt werden, greifen diese Schichten auf PyTorch FSDP Mixed Precision zurück. **Anmerkung** SMP v2 bietet FP8 Unterstützung für die folgenden Hugging Face Transformer-Modelle: GPT-NeoX (verfügbar in SMP v2.2.0 und höher) Llama 2 (verfügbar in SMP v2.2.0 und höher) Mixtral 8x7b und Mixtral 8x22b (verfügbar in SMP v2.5.0 und höher) **Anmerkung** Diese FP8 Schulung zur P5-Funktion ist in der folgenden Kombination aus Bibliotheken von und der SageMaker Bibliothek verfügbar: PyTorch Das SageMaker Python SDK v2.212.0 und höher PyTorch v2.2.0 und höher *FP8*(8-Bit-Fließkomma-Präzision) ist ein Datentyp, der sich als weiteres Paradigma zur Beschleunigung des Deep-Learning-Trainings von LLM-Modellen herausgestellt hat. Mit der Veröffentlichung von NVIDIA H100, die FP8 Datentypen GPUs unterstützt, können Sie von den Vorteilen der Leistungsverbesserungen auf P5-Instances profitieren, die mit dem H100 ausgestattet sind GPUs, und gleichzeitig das verteilte Training mit gemischter Präzision beschleunigen. FP8 Der FP8 Datentyp verzweigt sich weiter in die Formate E4M3 und E5M2. *E4M3* bietet eine bessere Präzision, hat einen begrenzten Dynamikbereich und ist ideal für den Vorwärtsdurchlauf beim Modelltraining. *E5M2* hat einen größeren Dynamikbereich, aber auch eine geringere Präzision und eignet sich besser für den Rückwärtsdurchlauf, bei dem Präzision weniger wichtig ist und ein größerer Dynamikbereich von Vorteil ist. Daher empfehlen wir Ihnen, die [ FP8 Hybridstrategie zu verwenden, um diese Merkmale effektiv](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/examples/fp8_primer.html#FP8-recipe) zu nutzen. Bei Datentypen mit halber Genauigkeit (FP16 und BF16) lösen globale Techniken zur Verlustskalierung wie statische Verlustskalierung oder dynamische Verlustskalierung Konvergenzprobleme, die sich aus Informationsverlusten aufgrund von Rundungsgradienten bei halber Genauigkeit ergeben. Der Dynamikbereich von FP8 ist jedoch noch enger, und die Techniken zur globalen Verlustskalierung reichen nicht aus. An diesem Punkt benötigen wir eine detailliertere Skalierungstechnik pro Tensor. Die *verzögerte Skalierung* ist eine Strategie, bei der ein Skalierungsfaktor auf der Grundlage der maximalen absoluten Werte ausgewählt wird, die in einer Reihe von Tensoren aus früheren Iterationen beobachtet wurden. Bei dieser Strategie gibt es einen Kompromiss: Sie nutzt alle Leistungsvorteile der FP8 Berechnung, benötigt aber Speicher, um den Maximalwertverlauf von Tensoren zu speichern. Weitere Informationen zur Strategie der verzögerten Skalierung im Allgemeinen finden Sie im paper [https://arxiv.org/pdf/2209.05433.pdf](https://arxiv.org/pdf/2209.05433.pdf). In der Praxis FP8 ist die Verwendung in allen Trainingsszenarien auf P5-Instanzen hilfreich. Wir empfehlen dringend, die Aktivierung FP8 wann immer möglich zu aktivieren, um die Trainingsleistung zu verbessern. SMP v2 unterstützt standardmäßig Transformer Engine. Wenn Sie also ein FP8 Training mit SMP v2 auf P5-Instanzen von SageMaker AI (`ml.p5.48xlarge`) ausführen, müssen Sie nur `torch.sagemaker` in Ihr Trainingsskript importieren und weiterhin das native Python-Paket Transformer Engine verwenden. Weitere Informationen zur Verwendung der Transformer Engine für allgemeine FP8 Trainingszwecke finden Sie unter [Verwendung FP8 mit Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/user-guide/examples/fp8_primer.html) in der *NVIDIA Transformer Engine-Dokumentation*. Der folgende Codeausschnitt zeigt, wie die Codezeilen für den Import der SMP-Bibliothek und die Einrichtung FP8 in Ihrem Trainingsskript aussehen sollten. ``` import torch.sagemaker as tsm import transformer_engine.pytorch as te from transformer_engine.common.recipe import DelayedScaling, Format # Initialize the SMP torch.sagemaker API. tsm.init() # Define a transformer model and wrap it with the torch.sagemaker.transform API. from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_config(ModelConfig) model = tsm.transform(model) # Enable E4M3 during forward pass, E5M2 during backward pass. fp8_format = Format.HYBRID # Create an FP8 recipe. fp8_recipe = DelayedScaling(fp8_format=fp8_format, amax_history_len=32, amax_compute_algo="max") # Enable FP8 autocasting. with te.fp8_autocast(enabled=True, fp8_recipe=fp8_recipe, fp8_group=tsm.state.world_process_group): out = model(inp) loss = out.sum() loss.backward() ``` Ein praktisches Beispiel für das FP8 Training mit SMP v2 auf P5-Instances finden Sie im Beispiel-Notizbuch unter [Accelerate SageMaker PyTorch FSDP Training of Llama-v2 (](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/llama_v2/smp-train-llama-fsdp-tp-fp8.ipynb)oder GPT-Neox) with on P5-Instances. FP8 ## Gemischtes Präzisionstraining mit Datentypen mit halber Genauigkeit unter Verwendung von FSDP PyTorch SMP v2 unterstützt [PyTorch FSDP `MixedPrecision`](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.MixedPrecision) für Trainingsjobs auf P4- und P5-Instances. PyTorch FSDP bietet verschiedene Konfigurationen für gemischte Präzision, sowohl zur Leistungsverbesserung als auch zur Speicherreduzierung. **Anmerkung** Dieses Training mit gemischter Präzision und der PyTorch FSDP-Funktion ist in der folgenden Kombination aus Bibliotheken von SageMaker und der PyTorch Bibliothek verfügbar. SMP v2.0.0 und höher das SageMaker Python SDK v2.200.0 und höher PyTorch v2.0.1 und höher Die Standardmethode, ein Modell für gemischte Präzision zu konfigurieren, besteht darin, das Modell in `float32` zu erstellen und dann FSDP zu erlauben, die Parameter durch Übergabe einer `MixedPrecision`-Richtlinie im laufenden Betrieb in `float16` oder `bfloat16` umzuwandeln, wie im folgenden Codeausschnitt gezeigt. *Weitere Informationen zu den Optionen zum Ändern der Parameter, der `dtype` Reduzierung oder der Puffer für gemischte Genauigkeit in finden Sie in der Dokumentation PyTorch unter [PyTorch `MixedPrecision`FSDP-API](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.MixedPrecision). PyTorch* ``` # Native PyTorch API from torch.distributed.fsdp import MixedPrecision dtype = torch.bfloat16 mixed_precision_policy = MixedPrecision( param_dtype=dtype, reduce_dtype=dtype, buffer_dtype=dtype ) model = FSDP( model, ..., mixed_precision=mixed_precision_policy ) ``` Beachten Sie, dass bei bestimmten Modellen (wie dem Llama-Modell von Hugging Face Transformers) Puffer als `float32` erwartet werden. Um `float32` zu verwenden, ersetzen Sie `torch.bfloat16` durch `torch.float32` in der Zeile, die das `dtype`-Objekt definiert. # Verzögerte Parameterinitialisierung Die Initialisierung eines großen Modells für das Training ist aufgrund des begrenzten GPU-Speichers nicht immer möglich. Um das Problem des unzureichenden GPU-Speichers zu beheben, können Sie das Modell im CPU-Speicher initialisieren. Bei größeren Modellen mit mehr als 20 oder 40 Milliarden Parametern reicht jedoch möglicherweise nicht einmal der CPU-Speicher aus. In einem solchen Fall empfehlen wir, dass Sie das Modell auf einem sogenannten PyTorch *Meta-Gerät* initialisieren, das die Erstellung von Tensoren ermöglicht, ohne dass Daten an sie angehängt werden. Ein Tensor auf einem Metagerät benötigt nur die Forminformationen, was es ermöglicht, ein großes Modell mit seinen Parametern auf Metageräten zu erstellen. [Hugging Face Accelerate](https://huggingface.co/docs/accelerate/index) bietet den Kontextmanager `init_empty_weights`, mit dem Sie ein solches Modell auf Metageräten erstellen und gleichzeitig die Puffer auf einem normalen Gerät initialisieren können. Bevor das Training beginnt, initialisiert PyTorch FSDP die Modellparameter. Diese Funktion zur verzögerten Parameterinitialisierung von SMP v2 verzögert die Erstellung von Modellparametern, sodass sie erst erfolgt, nachdem PyTorch FSDP das Parameter-Sharding durchgeführt hat. PyTorch FSDP akzeptiert beim Sharding der Module eine Parameterinitialisierungsfunktion (`param_init_fn`) und ruft jedes Modul auf. `param_init_fn` Die `param_init_fn`-API verwendet ein Modul als Argument und initialisiert alle darin enthaltenen Parameter, ausgenommen der Parameter eines untergeordneten Moduls. Beachten Sie, dass sich dieses Verhalten von der nativen Version PyTorch 2.0.1 *unterscheidet*, die einen Fehler aufweist, der dazu führt, dass die Parameter mehrfach initialisiert werden. SMP v2 stellt die [`torch.sagemaker.delayed_param.DelayedParamIniter`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-delayed-param-init)-API für die Anwendung der verzögerten Parameterinitialisierung bereit. Die folgenden Codefragmente zeigen, wie Sie die `torch.sagemaker.delayed_param.DelayedParamIniter`-API auf Ihr Trainingsskript anwenden. Gehen Sie davon aus, dass Sie ein PyTorch FSDP-Trainingsskript wie folgt haben. ``` # Creation of model on meta device from accelerate import init_empty_weights with init_empty_weights(): model = create_model() # Define a param init fn, below is an example for Hugging Face GPTNeoX. def init_weights(module): d = torch.cuda.current_device() # Note that below doesn't work if you have buffers in the model # buffers will need to reinitialized after this call module.to_empty(device=d, recurse=False) if isinstance(module, (nn.Linear, Conv1D)): module.weight.data.normal_(mean=0.0, std=args.initializer_range) if module.bias: module.bias.data.zero_() elif isinstance(module, nn.Embedding): module.weight.data.normal_(mean=0.0, std=args.initializer_range) if module.padding_idx: module.weight.data[module.padding_idx].zero_() elif isinstance(module, nn.LayerNorm): module.bias.data.zero_() module.weight.data.fill_(1.0) # Changes to FSDP wrapper. model = FSDP( model, ..., param_init_fn=init_weights ) # At this point model is initialized and sharded for sharded data parallelism. ``` Beachten Sie, dass der Ansatz der verzögerten Parameterinitialisierung nicht modellunabhängig ist. Um dieses Problem zu lösen, müssen Sie, wie im vorherigen Beispiel gezeigt, eine `init_weights`-Funktion schreiben, die der Initialisierung in der ursprünglichen Modelldefinition entspricht und alle Parameter des Modells abdecken sollte. Um den Prozess zur Vorbereitung einer solchen `init_weights`-Funktion zu vereinfachen, implementiert SMP v2 diese Initialisierungsfunktion für die folgenden Modelle: GPT-2, GPT-J, GPT-NeoX und Llama von Hugging Face Transformers. Die `torch.sagemaker.delayed_param.DelayedParamIniter`-API funktioniert auch mit dem `torch.sagemaker.tensor_parallel.transformer.TransformerLMHead`-Modell der parallelen SMP-Tensor-Implementierung, das Sie nach dem [`torch.sagemaker.transform`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-transform)-API-Aufruf aufrufen können. Mithilfe der `torch.sagemaker.delayed_param.DelayedParamIniter` API können Sie Ihr PyTorch FSDP-Skript wie folgt anpassen. Nachdem Sie ein Modell mit leeren Gewichtungen erstellt haben, registrieren Sie die `torch.sagemaker.delayed_param.DelayedParamIniter`-API für das Modell und definieren Sie ein Objekt davon. Übergeben Sie das Objekt an das `param_init_fn` der PyTorch FSDP-Klasse. ``` from torch.sagemaker.delayed_param import DelayedParamIniter from accelerate import init_empty_weights with init_empty_weights(): model = create_model() delayed_initer = DelayedParamIniter(model) with delayed_initer.validate_params_and_buffers_inited(): model = FSDP( model, ..., param_init_fn=delayed_initer.get_param_init_fn() ) ``` **Hinweise zu verknüpften Gewichtungen** Beim Training von Modellen mit gebündelten Gewichten müssen wir besonders darauf achten, die Gewichte nach der Initialisierung der Gewichte mit verzögerter Parameterinitialisierung zu verknüpfen. PyTorch FSDP hat keinen Mechanismus, um die Gewichte zu binden, nachdem sie `param_init_fn` wie oben beschrieben initialisiert wurden. Um solche Fälle zu lösen, haben wir eine API hinzugefügt, die die Funktion `post_init_hook_fn` erlaubt, mit der die Gewichtungen verknüpft werden können. Sie können dort jede Funktion übergeben, die das Modul als Argument akzeptiert, wir haben jedoch auch eine vordefinierte `post_param_init_fn` in `DelayedParamIniter`, durch die die `tie_weights`-Methode des Moduls aufgerufen wird, sofern vorhanden. Die Übergabe in `post_param_init_fn` ist immer sicher, auch wenn es keine `tie_weights`-Methode für das Modul gibt. ``` with delayed_initer.validate_params_and_buffers_inited(): model = FSDP( model, ..., param_init_fn=delayed_initer.get_param_init_fn(), post_param_init_fn=delayed_initer.get_post_param_init_fn() ) ``` # Checkpointing bei der Aktivierung Beim *Aktivierungs-Checkpointing* handelt es sich um eine Technik zur Reduzierung der Speicherbelegung, indem Aktivierungen bestimmter Layers gelöscht und bei dem Rücklauf neu berechnet werden. Dadurch wird zusätzliche Datenverarbeitungszeit effektiv gegen eine verringerte Speicherauslastung eingetauscht. Wenn ein Modul mit einem Checkpoint versehen ist, bleiben am Ende eines Vorwärtsdurchlaufs nur die anfänglichen Eingänge des Moduls und die letzten Ausgänge des Moduls im Speicher. PyTorch gibt während des Vorwärtsdurchlaufs alle Zwischentensoren frei, die Teil der Berechnung innerhalb dieses Moduls sind. Berechnet diese Tensoren während des Rückwärtsdurchlaufs der Checkpoint-Module neu. PyTorch Zu diesem Zeitpunkt haben die Ebenen hinter diesem Prüfpunktmodul ihren Rückwärtsdurchlauf abgeschlossen, sodass die maximale Speichernutzung mit Checkpointing geringer wird. SMP v2 unterstützt das Aktivierungs-Checkpoint-Modul,. PyTorch [https://pytorch.org/blog/scaling-multimodal-foundation-models-in-torchmultimodal-with-pytorch-distributed/#activation-checkpointing](https://pytorch.org/blog/scaling-multimodal-foundation-models-in-torchmultimodal-with-pytorch-distributed/#activation-checkpointing) Im Folgenden finden Sie Beispiele für das Aktivierungs-Checkpointing des GPT-NeoX-Modells von Hugging Face. **Checkpointing der Transformer-Schichten des GPT-NeoX-Modells von Hugging Face** ``` from transformers.models.gpt_neox import GPTNeoXLayer from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import ( apply_activation_checkpointing ) # check_fn receives a module as the arg, # and it needs to return whether the module is to be checkpointed def is_transformer_layer(module): from transformers.models.gpt_neox import GPTNeoXLayer return isinstance(submodule, GPTNeoXLayer) apply_activation_checkpointing(model, check_fn=is_transformer_layer) ``` **Checkpointing jeder anderen Transformer-Schicht des GPT-NeoX-Modells von Hugging Face** ``` # check_fn receives a module as arg, # and it needs to return whether the module is to be checkpointed # here we define that function based on global variable (transformer_layers) from transformers.models.gpt_neox import GPTNeoXLayer from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import ( apply_activation_checkpointing ) transformer_layers = [ m for m model.modules() if isinstance(m, GPTNeoXLayer) ] def is_odd_transformer_layer(module): return transformer_layers.index(module) % 2 == 0 apply_activation_checkpointing(model, check_fn=is_odd_transformer_layer) ``` Alternativ gibt es PyTorch auch das `torch.utils.checkpoint` Modul für Checkpointing, das von einer Untergruppe der Hugging Face Transformers-Modelle verwendet wird. Dieses Modul funktioniert auch mit SMP v2. Sie benötigen jedoch Zugriff auf die Modelldefinition, um den Prüfpunkt-Wrapper hinzufügen zu können. Daher empfehlen wir, die `apply_activation_checkpointing`-Methode zu verwenden. # Aktivierung, Entladung **Wichtig** In SMP v2.2.0 funktioniert die Funktion zum Auslagern von Aktivierungen der SMP-Bibliothek nicht. Verwenden Sie stattdessen das native PyTorch Aktivierungs-Offloading. In der Regel werden beim Vorwärtsdurchlauf Aktivierungen auf jeder Ebene berechnet und im GPU-Speicher belassen, bis der Rückwärtsdurchlauf für die entsprechende Ebene abgeschlossen ist. Wenn Sie diese Tensoren nach dem Forward-Durchlauf in den CPU-Speicher auslagern und sie bei Bedarf wieder auf die GPU abrufen, kann der GPU-Speicherverbrauch erheblich gesenkt werden. PyTorch unterstützt das Auslagern von Aktivierungen, aber die Implementierung führt dazu, dass GPUs sie inaktiv sind, während Aktivierungen während des Rückwärtsdurchlaufs von der CPU abgerufen werden. Dies führt zu erheblichen Leistungseinbußen, wenn das Auslagern von Aktivierungen verwendet wird. SMP v2 verbessert die Aktivierungsauslagerung. Es ruft Aktivierungen im Voraus ab, bevor sie benötigt werden, damit die GPU mit dem Rückwärtsdurchlauf dieser Aktivierungen beginnen kann. Mit der Funktion zum Vorabrufen können Trainingsfortschritte effizienter und ohne Leerlauf ausgeführt werden. GPUs Dies führt dazu, dass die Vorteile einer geringeren Speichernutzung ohne Leistungseinbußen genutzt werden können. Sie können die systemeigenen PyTorch Module zum Auslagern von Aktivierungen in Ihrem Trainingsskript behalten. Im Folgenden finden Sie eine Beispielstruktur für die Anwendung der Funktion zum Auslagern der SMP-Aktivierung in Ihrem Skript. Beachten Sie, dass das Auslagern von Aktivierungen *nur* in Kombination mit [Checkpointing bei der Aktivierung](model-parallel-core-features-v2-pytorch-activation-checkpointing.md) verwendet wird. Weitere Informationen zu den systemeigenen PyTorch Checkpoint-Tools für das Offloading von Aktivierungen finden Sie unter: + [checkpoint\$1wrapper.py](https://github.com/pytorch/pytorch/blob/v2.0.1/torch/distributed/algorithms/_checkpoint/checkpoint_wrapper.py#L171) *im Repository PyTorch GitHub* + [Checkpointing zur Aktivierung](https://pytorch.org/blog/scaling-multimodal-foundation-models-in-torchmultimodal-with-pytorch-distributed/#activation-checkpointing) im PyTorch Blog *Scaling Multimodal Foundation Models in TorchMultimodal with PyTorch Distributed*. [Sie können die SMP-Aktivierungsauslagerungsfunktion beim Aktivierungs-Checkpointing anwenden. PyTorch ](https://pytorch.org/blog/scaling-multimodal-foundation-models-in-torchmultimodal-with-pytorch-distributed/#activation-checkpointing) Dazu werden die Parameter `activation_loading_horizon` und `sm_activation_offloading` während [Schritt 2: Starten eines Trainingsjobs](model-parallel-use-api-v2.md#model-parallel-launch-a-training-job-v2) dem SMP-Konfigurationswörterbuch hinzugefügt. Die folgenden Codefragmente zeigen, wie Sie das SMP-Initialisierungsmodul `torch.sagemaker.init()` zu Ihrem Trainingsskript hinzufügen und das SMP-Konfigurationswörterbuch im JSON-Format für den Trainingsjob-Launcher einrichten. Dabei folgen Sie dem in [Verwenden Sie die SageMaker Modellparallelitätsbibliothek v2](model-parallel-use-api-v2.md) beschriebenen zweistufigen Prozess. [Sie müssen keine Änderungen an Ihrem PyTorch Modell oder PyTorch Ihrer FSDP-Konfiguration vornehmen.](https://pytorch.org/docs/stable/fsdp.html#module-torch.distributed.fsdp) Weitere Hinweise zu den Parametern `sm_activation_offloading` und `activation_loading_horizon` finden Sie unter [Konfigurationsparameter für die Kernfunktionen von SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config). **SMP-Konfiguration** ``` { "activation_loading_horizon": 2, "sm_activation_offloading": True } ``` **Im Trainingsskript** **Anmerkung** Achten Sie bei der Aktivierung der SMP-Aktivierungs-Offloading-Funktion darauf, dass Sie die PyTorch `offload_wrapper` Funktion auch verwenden und sie auf das Root-Modul anwenden. Die SMP-Funktion zur Aktivierungsauslagerung verwendet das Root-Modul, um zu bestimmen, wann ein Vorwärtsdurchlauf durchgeführt wird, um mit dem Vorabruf zu beginnen. ``` import torch.sagemaker as tsm tsm.init() # Native PyTorch module for activation offloading from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import ( apply_activation_checkpointing, offload_wrapper, ) model = FSDP(...) # Activation offloading requires activation checkpointing. apply_activation_checkpointing( model, check_fn=checkpoint_transformer_layers_policy, ) model = offload_wrapper(model) ``` # 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 die einzelnen Gewichtungen intakt bleiben, die *Menge* der Gewichtungen, Gradienten oder des Optimierers jedoch auf verschiedene Geräte aufgeteilt wird, teilt die Tensor-Parallelität die *einzelnen* 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. SMP v2 ist für die Implementierung von Tensorparallelität in [Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/index.html) integriert und läuft auf FSDP. PyTorch APIs Sie können die PyTorch FSDP- und SMP-Tensorparallelität gleichzeitig aktivieren und die beste Modellparallelität für die beste Leistung ermitteln. In der Praxis ist die Tensorparallelität in den folgenden Szenarien besonders hilfreich. + Beim Training mit langen Kontextlängen, was allein mit FSDP zu einem hohen Aktivierungsspeicher führt. + Beim Training mit sehr großen Clustern, bei denen die globale Batchgröße die gewünschten Grenzwerte überschreitet. ## Transformer-Modelle von Hugging Face, die mit der SMP-Tensorparallelität kompatibel sind SMP v2 bietet derzeit Unterstützung der Tensorparallelität für die folgenden Transformer-Modelle von Hugging Face. + GPT-NeoX + Llama 2 + Llama 3 + [Mistral 7B](https://huggingface.co/mistralai/Mistral-7B-v0.3) + [Mistral 8x7B](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1) + [Mixtral 8x22B](https://huggingface.co/mistralai/Mixtral-8x22B-v0.1) Eine Referenzkonfiguration für die Anwendung der Tensorparallelität auf diese Modelle finden Sie unter [Konfigurationstipps](model-parallel-best-practices-v2.md#model-parallel-best-practices-v2-config-tips). ## Tensorparallelität konfigurieren Für `tensor_parallel_degree` wählen Sie einen Wert für den Grad der Tensorparallelität aus. Der Wert muss die Anzahl der in Ihrem Cluster gleichmäßig verteilen. GPUs Um beispielsweise Ihr Modell zu teilen, während Sie eine Instanz mit 8 verwenden GPUs, wählen Sie 2, 4 oder 8. Wir empfehlen, mit einer kleinen Zahl zu beginnen und diese schrittweise zu erhöhen, bis das Modell in den GPU-Speicher passt. Die folgenden Codefragmente zeigen, wie Sie das SMP-Initialisierungsmodul `torch.sagemaker.init()` zu Ihrem Trainingsskript hinzufügen und das SMP-Konfigurationswörterbuch im JSON-Format für den Trainingsjob-Launcher einrichten. Dabei folgen Sie dem in [Verwenden Sie die SageMaker Modellparallelitätsbibliothek v2](model-parallel-use-api-v2.md) beschriebenen zweistufigen Prozess. Sie müssen keine Änderungen an Ihrem PyTorch Modell oder Ihrer [PyTorch FSDP-Konfiguration](https://pytorch.org/docs/stable/fsdp.html#module-torch.distributed.fsdp) vornehmen. Weitere Hinweise zu den Parametern `tensor_parallel_degree` und `random_seed` finden Sie unter [Konfigurationsparameter für die Kernfunktionen von SMP v2](distributed-model-parallel-v2-reference.md#distributed-model-parallel-v2-reference-init-config). **SMP-Konfiguration** ``` { "tensor_parallel_degree": 8, "random_seed": 0 } ``` **In Ihrem Trainingsskript** Initialisieren Sie mit `torch.sagemaker.init()`, um SMP v2 zu aktivieren, und umschließen Sie Ihr Modell mit der [`torch.sagemaker.transform`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-transform)-API. ``` import torch.sagemaker as tsm tsm.init() from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_config(..) model = tsm.transform(model) ``` ## Speichern und Laden der Prüfpunkte von Hugging Face Transformer Nachdem die SMP-Bibliothek ein Modell transformiert hat, ändert sie das Zustandswörterbuch (`state_dict`) des Modells. Dies bedeutet, dass das Modell nicht mehr mit den ursprünglichen Checkpointing-Funktionen von Hugging Face Transformer kompatibel ist. Um dies zu handhaben, bietet APIs die SMP-Bibliothek das Speichern von Checkpoints aus einem transformierten Modell in der Hugging Face Transformer-Darstellung und die `torch.sagemaker.transform` API zum Laden eines Hugging Face Transformer-Modell-Checkpoints zur Feinabstimmung. Weitere Informationen zum Speichern von Prüfpunkten bei Verwendung der Tensorparallelitätsfunktion von SMP v2 finden Sie unter [Checkpointing mit SMP](model-parallel-core-features-v2-checkpoints.md). Weitere Informationen zur Optimierung eines Modells unter Verwendung der Tensorparallelitätsfunktion von SMP v2 finden Sie unter [Feinabstimmung](model-parallel-core-features-v2-fine-tuning.md). # Feinabstimmung Bei der Optimierung werden vortrainierte Modelle kontinuierlich trainiert, um ihre Leistung für bestimmte Anwendungsfälle zu verbessern. Die Feinabstimmung kleiner Modelle, die vollständig auf eine einzelne GPU passen, oder solcher, auf die 8 Kopien des Modells vollständig passen, ist unkompliziert. CPUs Es ist keine besondere Änderung des regulären FSDP-Trainings erforderlich. Bei größeren Modellen sollten Sie die Verwendung der Funktion zur verzögerten Parameterinitialisierung in Betracht ziehen, was schwieriger sein kann. Zu diesem Zweck lädt die SMP-Bibliothek das vollständige Modell in einen der Ränge, während die übrigen Ränge Modelle mit leeren Gewichtungen auf einem Metagerät erstellen. Anschließend initialisiert PyTorch FSDP mithilfe der `init_weights` Funktion die Gewichtungen auf Rängen ungleich Null und synchronisiert die Gewichtungen auf allen Rängen mit den Gewichtungen auf dem Rang 0 mit der Einstellung auf. `sync_module_states` `True` Der folgende Codeausschnitt veranschaulicht, wie Sie dies in Ihrem Trainingsskript einrichten sollten. ``` import torch.distributed as dist from transformers import AutoModelForCasalLM from accelerate import init_empty_weights from torch.sagemaker.delayed_param import DelayedParamIniter if dist.get_rank() == 0: model = AutoModelForCasalLM.from_pretrained(..., low_cpu_mem_usage=True) else: with init_empty_weights(): model = AutoModelForCasalLM.from_config(AutoConfig.from_pretrained(...)) delayed_initer = DelayedParamIniter(model) model = FSDP( model, ..., sync_module_states=True, param_init_fn=delayed_initer.get_param_init_fn() if dist.get_rank() > 0 else None ) ``` ## Optimierung eines vortrainierten Transformer-Modells von Hugging Face mit SMP-Tensorparallelität In diesem Abschnitt wird das Laden von Transformer-Modellen für zwei Anwendungsfälle beschrieben: die Optimierung kleiner Transformer-Modelle und die Optimierung großer Transformer-Modelle. Bei kleineren Modellen ohne verzögerte Parameterinitialisierung umschließen Sie das Modell mit der API, bevor Sie es mit FSDP umschließen. `torch.sagemaker.transform` PyTorch ``` import functools from transformers import AutoModelForCausalLM from torch.distributed.fsdp import FullyShardedDataParallel as FSDP from torch.distributed.fsdp.wrap import transformer_auto_wrap_policy from torch.sagemaker import transform model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", low_cpu_mem_usage=True) # Transform model while loading state dictionary from rank 0. tp_model = transform(model, load_state_dict_from_rank0=True) # Wrap with FSDP. model = FSDP( tp_model, ... sync_module_states=True, ) ``` Bei größeren Modellen führt der vorherige Ansatz dazu, dass der CPU-Speicher knapp wird. Wir empfehlen, die verzögerte Parameterinitialisierung zu verwenden, um solche CPU-Speicherprobleme zu vermeiden. In diesem Fall können Sie die `torch.sagemaker.transform`-API und die `torch.sagemaker.delayed_param.DelayedParamIniter`-API wie im folgenden Codebeispiel gezeigt anwenden. ``` from transformers import AutoModelForCausalLM from torch.sagemaker import transform from torch.sagemaker.delayed_param import DelayedParamIniter # Create one instance of model without delayed param # on CPU, on one rank. if dist.get_rank() == 0: model = AutoModelForCasalLM.from_pretrained(...,low_cpu_mem_usage=True) else: with init_empty_weights(): model = AutoModelForCasalLM.from_config(AutoConfig.from_pretrained(...)) # Transform model while loading state dictionary from rank 0 model = transform(model, load_state_dict_from_rank0=True) if dist.get_rank() != 0: # For fine-tuning, delayed parameter on non-zero ranks delayed_initer = DelayedParamIniter(model) else: delayed_initer = None with ( delayed_initer.validate_params_and_buffers_inited() if delayed_initer else nullcontext() ): # Wrap the model with FSDP model = FSDP( model, ..., sync_module_states=True, param_init_fn=delayed_initer.get_param_init_fn() if delayed_initer else None ) ``` # FlashAttention SMP v2 unterstützt [FlashAttention](https://github.com/HazyResearch/flash-attention)Kernel und macht es einfach, sie auf verschiedene Szenarien für Hugging Face Transformer-Modelle anzuwenden. Beachten Sie, dass SMP FlashAttention v2 verwendet, wenn Sie FlashAttention Paket v2.0 oder höher verwenden. Triton Flash Attention verwendet jedoch standardmäßig den Flash Attention-Kernel in FlashAttention v1.x, sodass er ausschließlich in Version 1 unterstützt wird. FlashAttention Das Modul (`nn.Module`) ist eine Low-Level-API, die die Aufmerksamkeitsebenen eines Modells definiert. Es sollte direkt nach der Modellerstellung angewendet werden, beispielsweise über die `AutoModelForCausalLM.from_config()`-API, bevor das Modell transformiert oder mit FSDP umschlossen wird. ## Verwenden Sie Kernel zur Selbstwahrnehmung FlashAttention Der folgende Codeausschnitt veranschaulicht, wie die von SMP v2 bereitgestellte [`torch.sagemaker.nn.attn.FlashSelfAttention`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-flashselfattention)-API verwendet wird. ``` def new_attn(self, q, k, v, attention_mask=None, head_mask=None): return ( self.flashmod((q, k, v), causal=True, cast_dtype=torch.bfloat16, layout="b h s d"), None, ) for layer in model.gpt_neox.layers: layer.attention.flash_mod = torch.sagemaker.nn.attn.FlashSelfAttention() layer.attention._attn = functools.partial(new_attn, layer.attention) ``` ## Verwenden Sie FlashAttention Kernel für die Aufmerksamkeit bei gruppierten Abfragen SMP v2 unterstützt auch [FlashAttention](https://github.com/HazyResearch/flash-attention)Kernel für Grouped-Query Attention (GQA) und macht es einfach, sie auf verschiedene Szenarien für Hugging Face Transformer-Modelle anzuwenden. Im Unterschied zur ursprünglichen Aufmerksamkeitsarchitektur unterteilt GQA Abfrageköpfe gleichmäßig in Gruppen und die Abfrageköpfe in derselben Gruppe verwenden dieselben Schlüssel- und Wertköpfe. Daher werden q- und kv-Köpfe getrennt an den Vorwärtsaufruf übergeben. Hinweis: Die Anzahl der q-Köpfe muss durch die Anzahl der kv-Köpfe teilbar sein. **Beispiel für die Verwendung FlashGroupedQueryAttention** Der folgende Codeausschnitt veranschaulicht, wie die von SMP v2 bereitgestellte [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn)-API verwendet wird. ``` from transformers.models.llama.modeling_llama import LlamaAttention from torch.sagemaker.nn.attn import FlashGroupedQueryAttention class LlamaFlashAttention(LlamaAttention): def __init__(self, config: LlamaConfig): super().__init__(config) self.flash_attn = FlashGroupedQueryAttention( attention_dropout_prob=0.0, ) def forward( self, hidden_states: torch.Tensor, attention_mask: Optional[torch.Tensor] = None, position_ids: Optional[torch.LongTensor] = None, ... ): query_states = self.q_proj(hidden_states) key_states = self.k_proj(hidden_states) value_states = self.v_proj(hidden_states) ... kv = (key_states, value_states) attn_output = self.flash_attn( query_states, kv, attn_mask=attention_mask, causal=True, layout="b h s d", ) ... attn_output = self.o_proj(attn_output) ... return attn_output ``` Die SMP-Bibliothek bietet auch die Funktion [`torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-llamaFlashAttn), die die [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn)-API auf niedriger Ebene verwendet. Hugging Face Transformers hat eine ähnliche Implementierung, die ab Version 4.36.0 [https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama/modeling_llama.py](https://github.com/huggingface/transformers/blob/main/src/transformers/models/llama/modeling_llama.py) genannt wird. Der folgende Codeausschnitt zeigt, wie die APIs SMP `LlamaFlashAttention` v2 oder Transformers `LlamaFlashAttention2` verwendet werden, um die Aufmerksamkeitsebenen eines vorhandenen Llama-Modells zu ersetzen. ``` from torch.sagemaker.nn.huggingface.llama_flashattn import LlamaFlashAttention from transformers.models.llama.modeling_llama import LlamaFlashAttention2 flash_attn_class = LlamaFlashAttention # or flash_attn_class = LlamaFlashAttention2 attn_name = "self_attn" for layer in model.model.layers: prev_layer = getattr(layer, attn_name) setattr(layer, attn_name, flash_attn_class(model.config)) ``` # Checkpointing mit SMP Die SageMaker Modellparallelismus-Bibliothek (SMP) unterstützt PyTorch APIs für Checkpoints und stellt APIs diese Hilfesuchpoints bei der Verwendung der SMP-Bibliothek korrekt bereit. PyTorch FSDP (Fully Sharded Data Parallelism) unterstützt drei Arten von Checkpoints: vollständige, geteilte und lokale Checkpoints, die jeweils unterschiedlichen Zwecken dienen. Vollständige Prüfpunkte werden verwendet, wenn das Modell nach Abschluss des Trainings exportiert wird, da die Generierung eines vollständigen Prüfpunkts ein rechenintensiver Prozess ist. Mit Hilfe von fragmentierten Prüfpunkten kann der Zustand eines Modells, das für jeden einzelnen Rang fragmentiert wurde, gespeichert und geladen werden. Mit Sharded Checkpoints können Sie das Training mit unterschiedlichen Hardwarekonfigurationen fortsetzen, z. B. mit einer anderen Anzahl von. GPUs Das Laden von fragmentierten Prüfpunkten kann jedoch aufgrund der Kommunikation zwischen mehreren Geräten langsam sein. Die SMP-Bibliothek bietet lokale Prüfpunktfunktionen, die ein schnelleres Abrufen des Modellzustands ohne zusätzlichen Kommunikationsaufwand ermöglichen. Beachten Sie, dass von FSDP erstellte Checkpoints in ein gemeinsam genutztes Netzwerkdateisystem wie Amazon geschrieben werden müssen. FSx ## Asynchrone lokale Prüfpunkte Beim Training von Machine-Learning-Modellen sind keine nachfolgenden Iterationen erforderlich, um darauf zu warten, dass die Prüfpunktdateien auf der Festplatte gespeichert werden. Mit der Veröffentlichung von SMP v2.5 unterstützt die Bibliothek das asynchrone Speichern von Prüfpunktdateien. Das bedeutet, dass die nachfolgende Trainingsiteration gleichzeitig mit den Eingabe- und Ausgabeoperationen (Operationen) ausgeführt werden kann. I/O) operations for creating checkpoints, without being slowed down or held back by those I/O Außerdem PyTorch kann das Abrufen von Shard-Modell- und Optimizer-Parametern zeitaufwändig sein, da zusätzliche kollektive Kommunikation erforderlich ist, um verteilte Tensor-Metadaten zwischen Rängen auszutauschen. Selbst wenn es verwendet wird, `StateDictType.LOCAL_STATE_DICT` um lokale Checkpoints für jeden Rang zu speichern, ruft es PyTorch immer noch Hooks auf, die kollektive Kommunikation durchführen. Um dieses Problem zu beheben und den Zeitaufwand für das Abrufen von Prüfpunkten zu reduzieren, führt SMP `SMStateDictType.SM_LOCAL_STATE_DICT` für einen schnelleren Abruf von Modell- und Optimierer-Prüfpunkten ein, indem der kollektive Kommunikationsaufwand umgangen wird. **Anmerkung** Die Wahrung der Konsistenz im FSDP `SHARD_DEGREE` ist eine Voraussetzung für die Nutzung von `SMStateDictType.SM_LOCAL_STATE_DICT`. Stellen Sie sicher, dass der `SHARD_DEGREE` unverändert bleibt. Die Anzahl der Modellreplikationen kann zwar variieren, der Grad der Modellfragmentierung muss jedoch mit dem vorherigen Trainingsaufbau identisch sein, wenn der Vorgang von einem Prüfpunkt aus fortgesetzt wird. ``` import os import torch.distributed as dist import torch.sagemaker as tsm from torch.sagemaker import state from torch.distributed.fsdp import FullyShardedDataParallel as FSDP from torch.sagemaker.distributed.checkpoint.state_dict_saver import ( async_save, maybe_finalize_async_calls, ) from torch.sagemaker.distributed.checkpoint.state_dict_utils import ( sm_state_dict_type, SMStateDictType, ) global_rank = dist.get_rank() save_dir = "/opt/ml/checkpoints" sub_dir = f"tp{state.tp_rank}_ep{state.ep_rank}_fsdp{model.rank}" # 1. Get replication ranks and group current_replication_group = None current_replication_ranks = None for replication_ranks in state.ranker.get_rep_groups(): rep_group = dist.new_group(replication_ranks) if global_rank in replication_ranks: current_replication_group = rep_group current_replication_ranks = replication_ranks coordinator_rank = min(current_replication_ranks) # 2. Wait for the previous checkpointing done maybe_finalize_async_calls( blocking=True, process_group=current_replication_group ) # 3. Get model local checkpoint with sm_state_dict_type(model, SMStateDictType.SM_LOCAL_STATE_DICT): state_dict = { "model": model.state_dict(), "optimizer": optimizer.state_dict(), # Potentially add more customized state dicts. } # 4. Save a local checkpoint async_save( state_dict, checkpoint_id=os.path.join(save_dir, sub_dir), process_group=current_replication_group, coordinator_rank=coordinator_rank, ) ``` Der folgende Codeausschnitt zeigt, wie Sie mit `SMStateDictType.SM_LOCAL_STATE_DICT` einen Prüfpunkt laden können. ``` import os import torch.sagemaker as tsm from torch.sagemaker import state from torch.sagemaker.distributed.checkpoint.state_dict_loader import load from torch.sagemaker.distributed.checkpoint.state_dict_utils import ( sm_state_dict_type, SMStateDictType, init_optim_state ) from torch.sagemaker.distributed.checkpoint.filesystem import ( DistributedFileSystemReader, ) load_dir = "/opt/ml/checkpoints" sub_dir = f"tp{state.tp_rank}_ep{state.ep_rank}_fsdp{model.rank}" global_rank = dist.get_rank() checkpoint_id = os.path.join(load_dir, sub_dir) storage_reader = DistributedFileSystemReader(checkpoint_id) # 1. Get replication ranks and group current_replication_group = None current_replication_ranks = None for replication_ranks in state.ranker.get_rep_groups(): rep_group = dist.new_group(replication_ranks) if global_rank in replication_ranks: current_replication_group = rep_group current_replication_ranks = replication_ranks coordinator_rank = min(current_replication_ranks) # 2. Create local state_dict with sm_state_dict_type(model, SMStateDictType.SM_LOCAL_STATE_DICT): state_dict = { "model": model.state_dict(), # Potentially add more customized state dicts. } # Init optimizer state_dict states by setting zero grads and step. init_optim_state(optimizer, skip_empty_param=True) state_dict["optimizer"] = optimizer.state_dict() # 3. Load a checkpoint load( state_dict=state_dict, process_group=current_replication_group, coordinator_rank=coordinator_rank, storage_reader=storage_reader, ) ``` Das Speichern von Checkpoints für umfangreiche Sprachmodelle (LLMs) kann teuer sein, da dafür oft ein großes Dateisystemvolumen erstellt werden muss. Um die Kosten zu senken, haben Sie die Möglichkeit, Checkpoints direkt in Amazon S3 zu speichern, ohne dass zusätzliche Dateisystemdienste wie Amazon erforderlich sind. FSx Sie können das vorherige Beispiel mit dem folgenden Codeausschnitt anwenden, um Checkpoints in S3 zu speichern, indem Sie eine S3-URL als Ziel angeben. ``` key = os.path.join(checkpoint_dir, sub_dir) checkpoint_id= f"s3://{your_s3_bucket}/{key}" async_save(state_dict, checkpoint_id=checkpoint_id, **kw) load(state_dict, checkpoint_id=checkpoint_id, **kw) ``` ## Asynchrone fragmentierten Prüfpunkte Es kann Situationen geben, in denen Sie das Training mit unterschiedlichen Hardwarekonfigurationen fortsetzen müssen, z. B. wenn Sie die Anzahl der Geräte ändern. GPUs In diesen Fällen müssen Ihre Trainingsprozesse Prüfpunkte während des Reshardings laden, was bedeutet, dass Sie das nachfolgende Training mit einer anderen Anzahl von `SHARD_DEGREE` wieder aufnehmen. In diesem Szenario, in dem Sie das Training mit einer anderen Anzahl von `SHARD_DEGREE` fortsetzen müssen, müssen Sie Ihre Modellprüfpunkte mithilfe des Fragmentierungs-Zustandswörterbuchs speichern, das durch `StateDictType.SHARDED_STATE_DICT` dargestellt wird. Wenn Sie Prüfpunkte in diesem Format speichern, können Sie den Resharding-Prozess ordnungsgemäß durchführen, wenn Sie das Training mit einer geänderten Hardwarekonfiguration fortsetzen. Der bereitgestellte Codeausschnitt veranschaulicht, wie die `tsm`-API verwendet werden kann, um fragmentierte Prüfpunkte asynchron zu speichern, was einen effizienteren und optimierten Trainingsprozess ermöglicht. ``` import os import torch.sagemaker as tsm from torch.sagemaker import state from torch.distributed.fsdp import FullyShardedDataParallel as FSDP from torch.distributed.fsdp import StateDictType from torch.sagemaker.utils.process_group_utils import get_global_ranks from torch.sagemaker.distributed.checkpoint.state_dict_saver import ( async_save, maybe_finalize_async_calls, ) save_dir = "/opt/ml/checkpoints" sub_dir = f"tp{state.tp_rank}_ep{state.ep_rank}" checkpoint_id = os.path.join(save_dir, sub_dir) # To determine whether curreto take part in checkpointing. global_rank = dist.get_rank() action_rank = state.ranker.get_rep_rank(global_rank) == 0 process_group = model.process_group coordinator_rank = min(get_global_ranks(process_group)) # 1. wait for the previous checkpointing done maybe_finalize_async_calls(blocking=True, process_group=process_group) # 2. retrieve model & optimizer sharded state_dict with FSDP.state_dict_type(model, StateDictType.SHARDED_STATE_DICT): state_dict = { "model": model.state_dict(), "optimizer": FSDP.optim_state_dict(model, optimizer), # Potentially add more customized state dicts. } # 3. save checkpoints asynchronously using async_save if action_rank: async_save( state_dict, checkpoint_id=checkpoint_id, process_group=process_group, coordinator_rank=coordinator_rank, ) ``` Der Vorgang zum Laden gemeinsamer Prüfpunkte ähnelt dem vorherigen Abschnitt, beinhaltet jedoch die Verwendung von `torch.sagemaker.distributed.checkpoint.filesystem.DistributedFileSystemReader` und der `load`-Methode. Diese `load`-Methode ermöglicht es Ihnen, die gemeinsamen Prüfpunktdaten nach einem Verfahren zu laden, das dem zuvor beschriebenen Vorgang entspricht. ``` import os from torch.distributed.fsdp import FullyShardedDataParallel as FSDP from torch.distributed.fsdp import StateDictType from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict from torch.sagemaker.distributed.checkpoint.state_dict_loader import load from torch.sagemaker.utils.process_group_utils import get_global_ranks from torch.sagemaker.distributed.checkpoint.filesystem import ( DistributedFileSystemReader, ) load_dir = "/opt/ml/checkpoints" sub_dir = f"tp{state.tp_rank}_ep{state.ep_rank}" checkpoint_id = os.path.join(load_dir, sub_dir) reader = DistributedFileSystemReader(checkpoint_id) process_group = model.process_group coordinator_rank = min(get_global_ranks(process_group)) with FSDP.state_dict_type(model, StateDictType.SHARDED_STATE_DICT): # 1. Load model and everything else except the optimizer. state_dict = { "model": model.state_dict() # Potentially more customized state dicts. } load( state_dict, storage_reader=reader, process_group=process_group, coordinator_rank=coordinator_rank, ) model.load_state_dict(state_dict["model"]) # 2. Load optimizer. optim_state = load_sharded_optimizer_state_dict( model_state_dict=state_dict["model"], optimizer_key="optimizer", storage_reader=reader, process_group=process_group, ) flattened_optimizer_state = FSDP.optim_state_dict_to_load( optim_state["optimizer"], model, optimizer, group=model.process_group ) optimizer.load_state_dict(flattened_optimizer_state) ``` ## Vollständige Modellprüfpunkte Am Ende des Trainings können Sie einen vollständigen Prüfpunkt speichern, der alle Shards eines Modells in einer einzigen Modellprüfpunktdatei zusammenfasst. Die SMP-Bibliothek unterstützt die PyTorch vollständige Modell-Checkpoint-API vollständig, sodass Sie keine Änderungen vornehmen müssen. Beachten Sie, dass die SMP-Bibliothek das Modell transformiert, wenn Sie SMP [Tensor-Parallelität](model-parallel-core-features-v2-tensor-parallelism.md) verwenden. In diesem Fall übersetzt die SMP-Bibliothek beim Checkpointing des vollständigen Modells das Modell standardmäßig zurück in das Prüfpunktformat von Hugging Face Transformers. In Fällen, in denen Sie mit der SMP-Tensorparallelität trainieren und den SMP-Übersetzungsprozess ausschalten, können Sie das `translate_on_save` Argument der PyTorch `FullStateDictConfig` API verwenden, um die automatische SMP-Übersetzung nach Bedarf ein- oder auszuschalten. Wenn Sie sich beispielsweise darauf konzentrieren, ein Modell zu trainieren, müssen Sie den Übersetzungsprozess nicht hinzufügen, was zusätzlichen Aufwand hinzufügt. In diesem Fall empfehlen wir die Einstellung von `translate_on_save=False`. Wenn Sie planen, die SMP-Übersetzung des Modells auch in Zukunft für das Training zu verwenden, können Sie diese Funktion auch ausschalten, um die SMP-Übersetzung des Modells für eine spätere Verwendung zu speichern. Die Rückübersetzung des Modells in das Modellprüfpunktformat von Hugging Face Transformers ist erforderlich, wenn Sie das Training Ihres Modells abschließen und es für Inferenzen verwenden. ``` from torch.distributed.fsdp import FullyShardedDataParallel as FSDP from torch.distributed.fsdp import FullStateDictConfig import torch.sagemaker as tsm # Save checkpoints. with FSDP.state_dict_type( model, StateDictType.FULL_STATE_DICT, FullStateDictConfig( rank0_only=True, offload_to_cpu=True, # Default value is to translate back to Hugging Face Transformers format, # when saving full checkpoints for models trained with SMP tensor parallelism. # translate_on_save=True ), ): state_dict = model.state_dict() if dist.get_rank() == 0: logger.info("Processed state dict to save. Starting write to disk now.") os.makedirs(save_dir, exist_ok=True) # This name is needed for HF from_pretrained API to work. torch.save(state_dict, os.path.join(save_dir, "pytorch_model.bin")) hf_model_config.save_pretrained(save_dir) dist.barrier() ``` Beachten Sie, dass die Option `FullStateDictConfig(rank0_only=True, offload_to_cpu=True)` dazu dient, das Modell auf der CPU des Geräts des 0ten Ranges zu sammeln, um beim Training großer Modelle Speicherplatz zu sparen. Um das Modell für die Inferenz wieder zu laden, gehen Sie wie im folgenden Codebeispiel gezeigt vor. Beachten Sie, dass die Klasse `AutoModelForCausalLM` in Hugging Face Transformers je nach Modell möglicherweise zu anderen Faktor-Builder-Klassen wechselt, wie z. B. `AutoModelForSeq2SeqLM`. Weitere Informationen finden Sie in der [Dokumentation zu Hugging Face Transformers](https://huggingface.co/docs/transformers/v4.36.1/en/model_doc/auto#natural-language-processing). ``` from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_pretrained(save_dir) ``` # Beispiele für die Amazon SageMaker AI-Modellparallelismusbibliothek v2 Diese Seite enthält eine Liste von Blogs und Jupyter-Notebooks, die praktische Beispiele für die Implementierung der SageMaker Model Parallelism (SMP) -Bibliothek v2 zur Durchführung verteilter Trainingsaufgaben auf KI präsentieren. SageMaker ## Blogs und Fallstudien In den folgenden Blogs werden Fallbeispiele zur Verwendung von SMP v2 behandelt. + [Die Amazon SageMaker AI Model Parallel Library beschleunigt PyTorch FSDP-Workloads jetzt um bis zu 20%](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-model-parallel-library-now-accelerates-pytorch-fsdp-workloads-by-up-to-20/) ## PyTorch Beispiele für Notizbücher Beispiel-Notebooks finden Sie im [SageMaker AI Examples GitHub Repository](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_v2`. **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_v2 ``` **Beispiel-Notebooks zu SMP v2** + [Beschleunigen Sie das Training von Llama v2 mit SMP v2, PyTorch FSDP und Transformer Engine, indem Sie FP8 Schulungen auf P5-Instanzen durchführen](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/llama_v2/smp-train-llama-fsdp-tp-fp8.ipynb) + [Optimieren Sie Llama v2 mit SMP v2 und PyTorch FSDP im großen Maßstab mithilfe von Tensorparallelität, Hybrid-Sharding und Aktivierungs-Offloading](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/llama_v2/smp-finetuning-llama-fsdp-tp.ipynb) + [Trainieren Sie GPT-Neox mit SMP v2 und FSDP in großem Maßstab PyTorch ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/gpt-neox/smp-train-gpt-neox-fsdp-tp.ipynb) + [Optimieren Sie GPT-Neox mit SMP v2 und PyTorch FSDP im großen Maßstab mithilfe von Tensorparallelität, Hybrid-Sharding und Aktivierungs-Offloading](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/gpt-neox/smp-finetuning-gpt-neox-fsdp-tp.ipynb) # SageMaker Bewährte Methoden für verteilte Modellparallelität Beachten Sie die folgenden Richtlinien, wenn Sie einen verteilten Trainingsjob mit der SageMaker Model Parallel Library v2 (SMP v2) ausführen. ## Einrichtung der richtigen Konfiguration für verteiltes Training Sehen Sie sich die folgende Liste an, um den besten Ausgangspunkt für die Anwendung verteilter Trainingstechniken, die SMP v2 bietet, abzuschätzen und zu finden. In jedem Listenelement werden die Vorteile der Verwendung von [Kernfunktionen der SageMaker Modellparallelitätsbibliothek v2](model-parallel-core-features-v2.md) sowie mögliche Kompromisse erörtert. ### Konfigurationstipps Dieser Abschnitt enthält Richtlinien zur Auswahl der besten Modellkonfigurationen für einen optimalen Durchsatz bei globalen Anforderungen an die Batchgröße. Zunächst empfehlen wir unabhängig von der Größe Ihres Modells die folgenden Konfigurationen. 1. Verwenden Sie den leistungsstärksten Instance-Typ, den Sie verwenden können. 1. Lassen Sie die [gemischte Genauigkeit](model-parallel-core-features-v2-mixed-precision.md) durchgehend aktiviert, da dies erhebliche Vorteile in Bezug auf Leistung und Speicherreduzierung bietet. Wir empfehlen Ihnen, `bfloat16` zu verwenden, da es genauer als `float16` ist. 1. Aktivieren Sie die [Bibliothek für SageMaker verteilte Datenparallelität](data-parallel.md) (anstatt NCCL zu verwenden), wann immer dies möglich ist, wie unter beschrieben. [Kompatibilität mit der für die Infrastruktur optimierten SMDDP-Bibliothek AWS](model-parallel-core-features-v2-smddp-allgather.md) Eine Ausnahme bilden tensor-parallelism-only Anwendungsfälle (und). `hybrid_shard_degree = 1` `tensor_paralle_degree > 1` 1. Wenn Ihr Modell mehr als etwa 60 Milliarden Parameter hat, empfehlen wir die Verwendung von [Verzögerte Parameterinitialisierung](model-parallel-core-features-v2-delayed-param-init.md). Sie können auch die verzögerte Parameterinitialisierung verwenden, um die Initialisierung für jedes Modell zu beschleunigen. 1. Wir empfehlen Ihnen, [Checkpointing bei der Aktivierung](model-parallel-core-features-v2-pytorch-activation-checkpointing.md) zu aktivieren. Abhängig von der Größe Ihres Modells empfehlen wir Ihnen, mit den folgenden Anweisungen zu beginnen. 1. Verwenden Sie die Parallelität fragmentierter Daten. 1. Abhängig von der Batchgröße, die Sie in den GPU-Speicher aufnehmen möchten, wählen Sie den entsprechenden Grad der Parallelität fragmentierter Daten aus. Normalerweise sollten Sie mit dem niedrigsten Grad beginnen, damit Ihr Modell in den GPU-Speicher passt, wobei Sie gleichzeitig den durch die Netzwerkkommunikation verursachten Overhead minimieren. Wenn eine Warnung angezeigt wird, die besagt, dass Cache-Löschungen durchgeführt werden, empfehlen wir Ihnen, den Grad der Fragmentierung zu erhöhen. 1. Ermitteln Sie `world_size` anhand der maximalen lokalen Batchgröße und der erforderlichen globalen Batchgröße, falls vorhanden. 1. Sie können mit dem Entladen der Aktivierung experimentieren. Je nach Szenario kann es Ihren Speicherbedarf decken, ohne dass der Fragmentierungsgrad erhöht werden muss, was weniger Kommunikation bedeutet. 1. Verwenden Sie die Sharded-Datenparallelität von PyTorch FSDP und die Tensorparallelität von SMP v2 gleichzeitig, wie unter eingeführt. [Tensor-Parallelität](model-parallel-core-features-v2-tensor-parallelism.md) 1. Beim Training auf großen Clustern mit FSDP allein kann die globale Batchgröße zu groß werden, was zu Konvergenzproblemen für das Modell führen kann. In der Regel wird bei den meisten Forschungsarbeiten die Batchgröße unter 4 Millionen Token gehalten. In diesem Fall können Sie das Problem lösen, indem Sie PyTorch FSDP mit der Tensorparallelität von SMP v2 zusammenstellen, um die Batchgröße zu reduzieren. Wenn Sie beispielsweise 256 Knoten und eine Sequenzlänge von 4096 haben, führt selbst eine Batchgröße von 1 pro GPU zu einer globalen Batchgröße von 8 Millionen Token. Wenn Sie jedoch die Tensorparallelität mit Grad 2 und einer Batchgröße von 1 pro Tensorparallelgruppe verwenden, wird daraus 1/2 Batchgröße pro GPU, was 4 Millionen Token entspricht. 1. Beim Training mit langen Kontextlängen wie 8.000 oder 16.000 kann der Aktivierungsspeicher sehr hoch werden. FSDP teilt Aktivierungen nicht, und Aktivierungen können dazu führen, dass nicht genügend Speicherplatz zur Verfügung steht. GPUs In solchen Szenarien können Sie effizient trainieren, indem Sie PyTorch FSDP mit der Tensorparallelität von SMP v2 zusammenstellen. ### Referenzkonfigurationen Das Schulungsteam für SageMaker Modellparallelität bietet die folgenden Referenzpunkte auf der Grundlage von Experimenten mit dem Lama-2-Modell, das mithilfe [`torch.sagemaker.transform`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-transform) von `ml.p4d.24xlarge` Instanzen mit Sequenzlänge 4096 und gemischter Genauigkeit (oder) in das SMP-Transformatormodell transformiert und an diesen trainiert wurde. FP16 BF16 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/model-parallel-best-practices-v2.html) 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. ## Überwachung und Protokollierung eines Trainingsjobs mithilfe der SageMaker KI-Konsole und Amazon CloudWatch Verwenden Sie die über die [SageMaker KI-Konsole](https://console.aws.amazon.com/sagemaker/) bereitgestellte Visualisierung, um Metriken auf Systemebene wie CPU-Speicherauslastung, GPU-Speicherauslastung und GPU-Auslastung zu überwachen. 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 auszuführen, stellen Sie sicher, dass Sie über die richtigen Berechtigungen in Ihrer IAM-Rolle 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). # Die Referenz zur SageMaker Modellparallelbibliothek v2 Im Folgenden finden Sie Referenzen für die SageMaker Model Parallel Library v2 (SMP v2). **Topics** + [Konfigurationsparameter für die Kernfunktionen von SMP v2](#distributed-model-parallel-v2-reference-init-config) + [Referenz für das `torch.sagemaker`-Paket von SMP v2](#model-parallel-v2-torch-sagemaker-reference) + [Upgrade von SMP v1 auf SMP v2](#model-parallel-v2-upgrade-from-v1) ## Konfigurationsparameter für die Kernfunktionen von SMP v2 Nachfolgend finden Sie eine vollständige Liste der Parameter zur Aktivierung und Konfiguration von [Kernfunktionen der SageMaker Modellparallelitätsbibliothek v2](model-parallel-core-features-v2.md). Diese müssen im JSON-Format geschrieben und an den PyTorch Schätzer im SageMaker Python-SDK übergeben oder als JSON-Datei für SageMaker HyperPod gespeichert werden. ``` { "hybrid_shard_degree": Integer, "sm_activation_offloading": Boolean, "activation_loading_horizon": Integer, "fsdp_cache_flush_warnings": Boolean, "allow_empty_shards": Boolean, "tensor_parallel_degree": Integer, "context_parallel_degree": Integer, "expert_parallel_degree": Integer, "random_seed": Integer } ``` + `hybrid_shard_degree` (Ganzzahl) – Gibt einen Parallelitätsgrad fragmentierter Daten an. Der Wert muss eine Ganzzahl zwischen `0` und `world_size` sein. Der Standardwert ist `0`. + Wenn auf gesetzt`0`, wird auf die native PyTorch Implementierung und API im Skript zurückgegriffen, wenn der Wert 1 `tensor_parallel_degree` ist. Andernfalls wird der größtmögliche Wert für `tensor_parallel_degree` auf der Grundlage von `hybrid_shard_degree` und `world_size` berechnet. Wenn Sie auf die nativen PyTorch FSDP-Anwendungsfälle zurückgreifen `FULL_SHARD` und diese Strategie verwenden, verteilt sie sich auf den gesamten Cluster von. GPUs Wenn als Strategie `HYBRID_SHARD` oder `_HYBRID_SHARD_ZERO2` verwendet wird, entspricht der `hybrid_shard_degree` 8. Wenn die Tensorparallelität aktiviert ist, basiert die Fragmentierung auf dem überarbeiteten `hybrid_shard_degree`. + Falls auf gesetzt`1`, wird auf die native PyTorch Implementierung und API für `NO_SHARD` im Skript zurückgegriffen, wenn der Wert 1 `tensor_parallel_degree` ist. Andernfalls entspricht der Wert `NO_SHARD` innerhalb einer beliebigen Tensorparallelgruppe. + Wenn dieser Wert auf eine Ganzzahl zwischen 2 und gesetzt ist`world_size`, erfolgt das Sharding für die angegebene Anzahl von GPUs. Wenn Sie nicht `sharding_strategy` im FSDP-Skript einrichten, wird es in `HYBRID_SHARD` überschrieben. Wenn Sie `_HYBRID_SHARD_ZERO2` festlegen, wird die von Ihnen angegebene `sharding_strategy` verwendet. + `sm_activation_offloading` (Boolean) – Legt fest, ob die Implementierung der SMP-Aktivierungsauslagerung aktiviert werden soll. Falls`False`, wird beim Auslagern die native PyTorch Implementierung verwendet. Wenn `True`, wird die Implementierung der SMP-Aktivierungsauslagerung verwendet. Sie müssen auch den PyTorch Aktivierungs-Offload-Wrapper (`torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper`) in Ihrem Skript verwenden. Weitere Informationen hierzu finden Sie unter [Aktivierung, Entladung](model-parallel-core-features-v2-pytorch-activation-offloading.md). Der Standardwert ist `True`. + `activation_loading_horizon` (Ganzzahl) – Eine Ganzzahl, die die Art von Aktivierungsauslagerungshorizont für FSDP angibt. Dies ist die maximale Anzahl von Prüfpunkt- oder Auslagerungsebenen, deren Eingaben sich gleichzeitig im GPU-Speicher befinden können. Weitere Informationen hierzu finden Sie unter [Aktivierung, Entladung](model-parallel-core-features-v2-pytorch-activation-offloading.md). Der Eingabewert muss eine positive Ganzzahl sein. Der Standardwert ist `2`. + `fsdp_cache_flush_warnings`(Boolean) — Erkennt Cache-Leerungen im PyTorch Speichermanager und warnt davor, da sie die Rechenleistung beeinträchtigen können. Der Standardwert ist `True`. + `allow_empty_shards` (Boolean) – Ob beim Tensor-Sharding leere Shards zulässig sind, wenn der Tensor nicht teilbar ist. Dies ist eine experimentelle Lösung für Abstürze beim Checkpointing in bestimmten Szenarien. Wenn Sie dies deaktivieren, wird auf das ursprüngliche Verhalten zurückgegriffen. PyTorch Der Standardwert ist `False`. + `tensor_parallel_degree` (Ganzzahl) – Gibt einen Tensor-Parallelitätsgrad an. Dieser Wert muss zwischen `1` und `world_size` liegen. Der Standardwert ist `1`. Beachten Sie, dass die Übergabe eines Werts größer als 1 die Kontextparallelität nicht automatisch aktiviert. Sie müssen auch die [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform)-API verwenden, um das Modell in Ihr Trainingsskript einzubinden. Weitere Informationen hierzu finden Sie unter [Tensor-Parallelität](model-parallel-core-features-v2-tensor-parallelism.md). + `context_parallel_degree` (Ganzzahl) – Gibt den Grad der Kontextparallelität an. Der Wert muss zwischen `1` und `world_size` liegen und muss der `<= hybrid_shard_degree` sein. Der Standardwert ist `1`. Beachten Sie, dass die Übergabe eines Werts größer als 1 die Kontextparallelität nicht automatisch aktiviert. Sie müssen auch die [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform)-API verwenden, um das Modell in Ihr Trainingsskript einzubinden. Weitere Informationen hierzu finden Sie unter [Kontextparallelität](model-parallel-core-features-v2-context-parallelism.md). + `expert_parallel_degree` (Ganzzahl) – Gibt einen Grad der Expertenparallelität an. Dieser Wert muss zwischen 1 und `world_size` liegen. Der Standardwert ist `1`. Beachten Sie, dass die Übergabe eines Werts größer als 1 die Kontextparallelität nicht automatisch aktiviert. Sie müssen auch die [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform)-API verwenden, um das Modell in Ihr Trainingsskript einzubinden. Weitere Informationen hierzu finden Sie unter [Expertenparallelität](model-parallel-core-features-v2-expert-parallelism.md). + `random_seed` (Ganzzahl) – Eine Seed-Zahl für zufällige Operationen in verteilten Modulen nach SMP-Tensorparallelität oder Expertenparallelität. Dieser Seed-Wert wird zu tensorparallelen oder expertenparallelen Rängen hinzugefügt, um den tatsächlichen Seed-Wert für jeden Rang festzulegen. Er ist für jeden tensorparallelen und expertenparallelen Rang einzigartig. SMP v2 stellt sicher, dass die Zufallszahl, die über tensorparallele und expertenparallele Ränge generiert wird, den jeweiligen Fällen entspricht. non-tensor-parallelism non-expert-parallelism ## Referenz für das `torch.sagemaker`-Paket von SMP v2 Dieser Abschnitt ist eine Referenz für das von SMP v2 bereitgestellte `torch.sagemaker`-Paket. **Topics** + [`torch.sagemaker.delayed_param.DelayedParamIniter`](#model-parallel-v2-torch-sagemaker-reference-delayed-param-init) + [`torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-async-save) + [`torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-state-dict-saver) + [`torch.sagemaker.distributed.checkpoint.state_dict_saver.save`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-save) + [`torch.sagemaker.distributed.checkpoint.state_dict_loader.load`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-load) + [`torch.sagemaker.moe.moe_config.MoEConfig`](#model-parallel-v2-torch-sagemaker-reference-moe) + [`torch.sagemaker.nn.attn.FlashSelfAttention`](#model-parallel-v2-torch-sagemaker-reference-flashselfattention) + [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) + [`torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention`](#model-parallel-v2-torch-sagemaker-reference-llamaFlashAttn) + [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform) + [Util-Funktionen und -Eigenschaften von `torch.sagemaker`](#model-parallel-v2-torch-sagemaker-reference-utils) ### `torch.sagemaker.delayed_param.DelayedParamIniter` Eine API zur Anwendung auf ein Modell. [Verzögerte Parameterinitialisierung](model-parallel-core-features-v2-delayed-param-init.md) PyTorch ``` class torch.sagemaker.delayed_param.DelayedParamIniter( model: nn.Module, init_method_using_config : Callable = None, verbose: bool = False, ) ``` **Parameter** + `model`(`nn.Module`) — Ein PyTorch Modell zum Umschließen und Anwenden der verzögerten Parameterinitialisierungsfunktion von SMP v2. + `init_method_using_config` (aufrufbar) – Wenn Sie die SMP-v2-Implementierung mit Tensorparallelität oder unterstützte [Transformer-Modelle von Hugging Face, die mit der SMP-Tensorparallelität kompatibel sind](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) verwenden, behalten Sie für diesen Parameter den Standardwert `None` bei. Standardmäßig findet die `DelayedParamIniter`-API heraus, wie das angegebene Modell korrekt initialisiert wird. Für alle anderen Modelle müssen Sie eine benutzerdefinierte Parameter-Initialisierungsfunktion erstellen und sie Ihrem Skript hinzufügen. Der folgende Codeausschnitt ist die `init_method_using_config`-Standardfunktion, die SMP v2 für die [Transformer-Modelle von Hugging Face, die mit der SMP-Tensorparallelität kompatibel sind](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) implementiert hat. Verwenden Sie den folgenden Codeausschnitt als Referenz, um Ihre eigene Initialisierungskonfigurationsfunktion zu erstellen, sie Ihrem Skript hinzuzufügen und sie an den `init_method_using_config`-Parameter der SMP-`DelayedParamIniter`-API zu übergeben. ``` from torch.sagemaker.utils.module_utils import empty_module_params, move_buffers_to_device # Define a custom init config function. def custom_init_method_using_config(module): d = torch.cuda.current_device() empty_module_params(module, device=d) if isinstance(module, (nn.Linear, Conv1D)): module.weight.data.normal_(mean=0.0, std=config.initializer_range) if module.bias is not None: module.bias.data.zero_() elif isinstance(module, nn.Embedding): module.weight.data.normal_(mean=0.0, std=config.initializer_range) if module.padding_idx is not None: module.weight.data[module.padding_idx].zero_() elif isinstance(module, nn.LayerNorm): module.weight.data.fill_(1.0) module.bias.data.zero_() elif isinstance(module, LlamaRMSNorm): module.weight.data.fill_(1.0) move_buffers_to_device(module, device=d) delayed_initer = DelayedParamIniter(model, init_method_using_config=custom_init_method_using_config) ``` Weitere Informationen zu den `torch.sagemaker.module_util`-Funktionen im vorherigen Codeausschnitt finden Sie unter [Util-Funktionen und -Eigenschaften von `torch.sagemaker`](#model-parallel-v2-torch-sagemaker-reference-utils). + `verbose` (Boolean) – Ob eine detailliertere Protokollierung während der Initialisierung und Validierung aktiviert werden soll. Der Standardwert ist `False`. **Methoden** + `get_param_init_fn()`— Gibt die Parameterinitialisierungsfunktion zurück, die Sie an das `param_init_fn` Argument der PyTorch FSDP-Wrapper-Klasse übergeben können. + `get_post_param_init_fn()`— Gibt die Parameterinitialisierungsfunktion zurück, die Sie an das `post_param_init_fn` Argument der FSDP-Wrapper-Klasse übergeben können. PyTorch Dies ist erforderlich, wenn Sie gebundene Gewichtungen im Modell haben. Das Modell muss die Methode `tie_weights` implementieren. Weitere Informationen finden Sie in den **Hinweisen zu gebundenen Gewichtungen** in [Verzögerte Parameterinitialisierung](model-parallel-core-features-v2-delayed-param-init.md). + `count_num_params` (`module: nn.Module, *args: Tuple[nn.Parameter]`) – Verfolgt, wie viele Parameter von der Parameter-Initialisierungsfunktion initialisiert werden. Dies hilft bei der Implementierung der folgenden `validate_params_and_buffers_inited`-Methode. Normalerweise müssen Sie diese Funktion nicht explizit aufrufen, da die `validate_params_and_buffers_inited`-Methode diese Methode implizit im Backend aufruft. + `validate_params_and_buffers_inited` (`enabled: bool=True`) – Dies ist ein Kontextmanager, mit dessen Hilfe überprüft werden kann, ob die Anzahl der initialisierten Parameter mit der Gesamtzahl der Parameter im Modell übereinstimmt. Außerdem wird überprüft, ob sich alle Parameter und Puffer jetzt auf GPU-Geräten statt auf Metageräten befinden. Es werden `AssertionErrors` angezeigt, wenn diese Bedingungen nicht erfüllt sind. Dieser Kontextmanager ist optional und muss für die Initialisierung von Parametern nicht verwendet werden. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save` Eingabe-API für asynchrones Speichern. Verwenden Sie diese Methode, um ein `state_dict` asynchron an einem bestimmten `checkpoint_id` zu speichern. ``` def async_save( state_dict: STATE_DICT_TYPE, *, checkpoint_id: Union[str, os.PathLike, None] = None, storage_writer: Optional[StorageWriter] = None, planner: Optional[SavePlanner] = None, process_group: Optional[dist.ProcessGroup] = None, coordinator_rank: int = 0, queue : AsyncCallsQueue = None, sharded_strategy: Union[SaveShardedStrategy, Tuple[str, int], None] = None, wait_error_handling: bool = True, force_check_all_plans: bool = True, s3_region: Optional[str] = None, s3client_config: Optional[S3ClientConfig] = None ) -> None: ``` **Parameter** + `state_dict` (dict) – Erforderlich. Das zu speichernde Zustandswörterbuch. + `checkpoint_id` (str) – Erforderlich. Der Speicherpfad, in dem Prüfpunkte gespeichert werden sollen. + `storage_writer`(StorageWriter) — Fakultativ. Eine Instanz von [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter)in PyTorch zur Ausführung von Schreiboperationen. Wenn dies nicht angegeben ist, wird die Standardkonfiguration von [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter) verwendet. + `planner`(SavePlanner) — Fakultativ. Eine Instanz von [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)in PyTorch. Wenn dies nicht angegeben ist, wird die Standardkonfiguration von [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner) verwendet. + `process_group`(ProcessGroup) — Fakultativ. Die zu bearbeitende Prozessgruppe. Falls `None`, wird die standardmäßige (globale) Prozessgruppe verwendet. + `coordinator_rank` (int) – Optional. Der Rang des Koordinators bei der Durchführung kollektiver Kommunikationsoperatoren wie z. B. `AllReduce`. + `queue`(AsyncRequestQueue) - Fakultativ. Der zu verwendende asynchrone Scheduler. Standardmäßig wird der globale Parameter `DEFAULT_ASYNC_REQUEST_QUEUE` verwendet. + `sharded_strategy`(PyTorchDistSaveShardedStrategy) - Fakultativ. Die Sharding-Strategie, die zum Speichern von Prüfpunkten verwendet werden soll. Wenn dies nicht angegeben wird, wird standardmäßig `torch.sagemaker.distributed.checkpoint.state_dict_saver.PyTorchDistSaveShardedStrategy` verwendet. + `wait_error_handling` (bool) – Optional. Ein Flag, das angibt, ob gewartet werden soll, bis alle Ränge die Fehlerbehandlung abgeschlossen haben. Der Standardwert ist `True`. + `force_check_all_plans` (bool) – Optional. Ein Flag, das festlegt, ob Pläne auch im Fall eines Cache-Treffers zwangsweise über mehrere Ränge hinweg synchronisiert werden sollen. Der Standardwert ist `True`. + `s3_region` (str) – Optional. Die Region, in der sich der S3-Bucket befindet. Wenn nicht angegeben, wird die Region aus der `checkpoint_id` abgeleitet. + `s3client_config`(S3ClientConfig) — Fakultativ. Die Datenklasse, die konfigurierbare Parameter für den S3-Client bereitstellt. Falls nicht angegeben, ClientConfig wird die Standardkonfiguration von [S3](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7) verwendet. Standardmäßig ist der `part_size`-Parameter auf 64 MB eingestellt. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls` Diese Funktion ermöglicht es einem Trainingsprozess, mehrere asynchrone Anfragen zu überwachen, die zu erledigen sind. ``` def maybe_finalize_async_calls( blocking=True, process_group=None ) -> List[int]: ``` **Parameter** + `blocking` (bool) – Optional. Wenn `True`, wird gewartet, bis alle aktiven Anfragen abgeschlossen sind. Andernfalls werden nur die asynchronen Anfragen beendet, die bereits abgeschlossen wurden. Der Standardwert ist `True`. + `process_group`(ProcessGroup) — Fakultativ. Die zu bearbeitende Prozessgruppe. Wenn auf `None` gesetzt, wird die standardmäßige (globale) Prozessgruppe verwendet. **Rückgabewerte** + Eine Liste mit den Indizes asynchroner Aufrufe, die erfolgreich abgeschlossen wurden. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.save` Verwenden Sie diese Methode, um ein `state_dict` synchron in einer bestimmten `checkpoint_id` zu speichern. ``` def save( state_dict: STATE_DICT_TYPE, *, checkpoint_id: Union[str, os.PathLike, None] = None, storage_writer: Optional[StorageWriter] = None, planner: Optional[SavePlanner] = None, process_group: Optional[dist.ProcessGroup] = None, coordinator_rank: int = 0, wait_error_handling: bool = True, force_check_all_plans: bool = True, s3_region: Optional[str] = None, s3client_config: Optional[S3ClientConfig] = None ) -> None: ``` **Parameter** + `state_dict` (dict) – Erforderlich. Das zu speichernde Zustandswörterbuch. + `checkpoint_id` (str) – Erforderlich. Der Speicherpfad, in dem Prüfpunkte gespeichert werden sollen. + `storage_writer`(StorageWriter) - Fakultativ. Eine Instanz von [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter)in PyTorch zur Ausführung von Schreiboperationen. Wenn dies nicht angegeben ist, wird die Standardkonfiguration von [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter) verwendet. + `planner`(SavePlanner) — Fakultativ. Eine Instanz von [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)in PyTorch. Wenn dies nicht angegeben ist, wird die Standardkonfiguration von [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner) verwendet. + `process_group`(ProcessGroup) — Fakultativ. Die zu bearbeitende Prozessgruppe. Falls `None`, wird die standardmäßige (globale) Prozessgruppe verwendet. + `coordinator_rank` (int) – Optional. Der Rang des Koordinators bei der Durchführung kollektiver Kommunikationsoperatoren wie z. B. `AllReduce`. + `wait_error_handling` (bool) – Optional. Ein Flag, das angibt, ob gewartet werden soll, bis alle Ränge die Fehlerbehandlung abgeschlossen haben. Der Standardwert ist `True`. + `force_check_all_plans` (bool) – Optional. Ein Flag, das festlegt, ob Pläne auch im Fall eines Cache-Treffers zwangsweise über mehrere Ränge hinweg synchronisiert werden sollen. Der Standardwert ist `True`. + `s3_region` (str) – Optional. Die Region, in der sich der S3-Bucket befindet. Wenn nicht angegeben, wird die Region aus der `checkpoint_id` abgeleitet. + `s3client_config`(S3ClientConfig) — Fakultativ. Die Datenklasse, die konfigurierbare Parameter für den S3-Client bereitstellt. Falls nicht angegeben, ClientConfig wird die Standardkonfiguration von [S3](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7) verwendet. Standardmäßig ist der `part_size`-Parameter auf 64 MB eingestellt. ### `torch.sagemaker.distributed.checkpoint.state_dict_loader.load` Lädt das Zustandswörterbuch eines verteilten Modells (`state_dict`). ``` def load( state_dict: Dict[str, Any], *, checkpoint_id: Union[str, os.PathLike, None] = None, storage_reader: Optional[StorageReader] = None, planner: Optional[LoadPlanner] = None, process_group: Optional[dist.ProcessGroup] = None, check_keys_matched: bool = True, coordinator_rank: int = 0, s3_region: Optional[str] = None, s3client_config: Optional[S3ClientConfig] = None ) -> None: ``` **Parameter** + `state_dict` (dict) – Erforderlich. Das zu ladende `state_dict`. + `checkpoint_id` (str) – Erforderlich. Die ID eines Prüfpunkts. Die Bedeutung von `checkpoint_id` hängt vom Speicher ab. Es kann ein Pfad zu einem Ordner oder zu einer Datei sein. Es kann auch ein Schlüssel sein, wenn es sich bei dem Speicher um einen Schlüsselwertspeicher handelt. + `storage_reader`(StorageReader) — Fakultativ. Eine Instanz von [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageReader](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageReader)in PyTorch , um Lesevorgänge durchzuführen. Falls nicht angegeben, leitet das verteilte Checkpointing automatisch den Leser anhand von `checkpoint_id` ab. Wenn für `checkpoint_id` auch `None` angegeben ist, wird ein Ausnahmefehler ausgelöst. + `planner`(StorageReader) — Fakultativ. Eine Instanz von [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner)in PyTorch. Wenn nicht angegeben, wird die Standardkonfiguration von [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner) verwendet. + `check_keys_matched` (bool) – Optional. Wenn diese Option aktiviert ist, wird geprüft, ob die `state_dict`-Schlüssel aller Ränge mit `AllGather` übereinstimmen. + `s3_region` (str) – Optional. Die Region, in der sich der S3-Bucket befindet. Wenn nicht angegeben, wird die Region aus der `checkpoint_id` abgeleitet. + `s3client_config`(S3ClientConfig) — Fakultativ. Die Datenklasse, die konfigurierbare Parameter für den S3-Client bereitstellt. Falls nicht angegeben, ClientConfig wird die Standardkonfiguration von [S3](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7) verwendet. Standardmäßig ist der `part_size`-Parameter auf 64 MB eingestellt. ### `torch.sagemaker.moe.moe_config.MoEConfig` Eine Konfigurationsklasse zum Einrichten der SMP-Implementierung von Mixture-of-Experts (MoE). Sie können MoE-Konfigurationswerte über diese Klasse angeben und sie an den API-Aufruf [https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-model-parallel-v2-reference.html#model-parallel-v2-torch-sagemaker-reference-transform](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-model-parallel-v2-reference.html#model-parallel-v2-torch-sagemaker-reference-transform) übergeben. Weitere Informationen zur Verwendung dieser Klasse für das Training von MoE-Modellen finden Sie unter [Expertenparallelität](model-parallel-core-features-v2-expert-parallelism.md). ``` class torch.sagemaker.moe.moe_config.MoEConfig( smp_moe=True, random_seed=12345, moe_load_balancing="sinkhorn", global_token_shuffle=False, moe_all_to_all_dispatcher=True, moe_aux_loss_coeff=0.001, moe_z_loss_coeff=0.001 ) ``` **Parameter** + `smp_moe` (Boolean) – Ob die SMP-Implementierung von MoE verwendet werden soll. Der Standardwert ist `True`. + `random_seed` (Ganzzahl) – Eine Seed-Zahl für die Zufallsoperationen in von verteilten Modulen mit Expertenparallelität. Dieser Seed-Wert wird dem expertenparallelen Rang hinzugefügt, um den tatsächlichen Seed-Wert für jeden Rang festzulegen. Er ist für jeden expertenparallelen Rang einzigartig. Der Standardwert ist `12345`. + `moe_load_balancing` (Zeichenfolge) – Geben Sie den Load-Balancer-Typ des MoE-Routers an. Gültige Optionen sind `aux_loss`, `sinkhorn`, `balanced` und `none`. Der Standardwert ist `sinkhorn`. + `global_token_shuffle` (Boolean) – Gibt an, ob Token zwischen EP-Rängen innerhalb derselben EP-Gruppe gemischt werden sollen. Der Standardwert ist `False`. + `moe_all_to_all_dispatcher`(Boolean) — Ob der all-to-all Dispatcher für die Kommunikation in MoE verwendet werden soll. Der Standardwert ist `True`. + `moe_aux_loss_coeff` (Float) – Ein Koeffizient für den Hilfslastausgleichsverlust. Der Standardwert ist `0.001`. + `moe_z_loss_coeff` (Float) – Koeffizient für den Z-Verlust. Der Standardwert ist `0.001`. ### `torch.sagemaker.nn.attn.FlashSelfAttention` Eine API zur Verwendung von [FlashAttention](model-parallel-core-features-v2-flashattention.md) mit SMP v2. ``` class torch.sagemaker.nn.attn.FlashSelfAttention( attention_dropout_prob: float = 0.0, scale: Optional[float] = None, triton_flash_attention: bool = False, use_alibi: bool = False, ) ``` **Parameter** + `attention_dropout_prob` (float) – Die Dropout-Wahrscheinlichkeit für die Aufmerksamkeit. Der Standardwert ist `0.0`. + `scale` (float) – Falls übergeben, wird dieser Skalierungsfaktor für Softmax angewendet. Wenn auf `None` gesetzt (was auch der Standardwert ist), ist der Skalierungsfaktor `1 / sqrt(attention_head_size)`. Der Standardwert ist `None`. + `triton_flash_attention` (bool) — Falls übergeben, wird die Triton-Implementierung von Flash Attention verwendet. Dies ist notwendig, um Attention with Linear Biases (ALiBi) zu unterstützen (siehe den folgenden Parameter). `use_alibi` Diese Version des Kernels unterstützt kein Dropout. Der Standardwert ist `False`. + `use_alibi`(bool) — Wenn der Wert übergeben wird, aktiviert er Attention with Linear Biases (ALiBi) mithilfe der bereitgestellten Maske. Wenn Sie ALi Bi verwenden, benötigen Sie eine Aufmerksamkeitsmaske, die wie folgt vorbereitet ist. Der Standardwert ist `False`. ``` def generate_alibi_attn_mask(attention_mask, batch_size, seq_length, num_attention_heads, alibi_bias_max=8): device, dtype = attention_mask.device, attention_mask.dtype alibi_attention_mask = torch.zeros( 1, num_attention_heads, 1, seq_length, dtype=dtype, device=device ) alibi_bias = torch.arange(1 - seq_length, 1, dtype=dtype, device=device).view( 1, 1, 1, seq_length ) m = torch.arange(1, num_attention_heads + 1, dtype=dtype, device=device) m.mul_(alibi_bias_max / num_attention_heads) alibi_bias = alibi_bias * (1.0 / (2 ** m.view(1, num_attention_heads, 1, 1))) alibi_attention_mask.add_(alibi_bias) alibi_attention_mask = alibi_attention_mask[..., :seq_length, :seq_length] if attention_mask is not None and attention_mask.bool().any(): alibi_attention_mask.masked_fill( attention_mask.bool().view(batch_size, 1, 1, seq_length), float("-inf") ) return alibi_attention_mask ``` **Methoden** + `forward(self, qkv, attn_mask=None, causal=False, cast_dtype=None, layout="b h s d")`— Eine reguläre PyTorch Modulfunktion. Wenn ein `module(x)` aufgerufen wird, führt SMP diese Funktion automatisch aus. + `qkv` – `torch.Tensor` in der folgenden Form: `(batch_size x seqlen x (3 x num_heads) x head_size)` oder `(batch_size, (3 x num_heads) x seqlen x head_size)`, ein Tupel von `torch.Tensors`, die jeweils die Form `(batch_size x seqlen x num_heads x head_size)` oder `(batch_size x num_heads x seqlen x head_size)` haben können. Basierend auf der Form muss ein geeignetes Layoutargument übergeben werden. + `attn_mask` – `torch.Tensor` der folgenden Form `(batch_size x 1 x 1 x seqlen)`. Um diesen Parameter für die Aufmerksamkeitsmaske zu aktivieren, sind `triton_flash_attention=True` und `use_alibi=True` erforderlich. Informationen zum Generieren einer Aufmerksamkeitsmaske mit dieser Methode finden Sie in den Codebeispielen unter [FlashAttention](model-parallel-core-features-v2-flashattention.md). Der Standardwert ist `None`. + `causal` – Wenn dieser Wert auf `False` gesetzt ist, was der Standardwert des Arguments ist, wird keine Maske angewendet. Wenn er auf `True` gesetzt ist, verwendet die `forward`-Methode die untere dreieckige Standardmaske. Der Standardwert ist `False`. + `cast_dtype` – Wenn dieser Wert auf einen bestimmten `dtype` gesetzt ist, werden die `qkv`-Tensoren vor `attn` in diesen `dtype` umgewandelt. Dies ist nützlich für Implementierungen wie das GPT-NeoX-Modell von Hugging Face Transformer, das nach den rotativen Einbettungen über `q` und `k` mit `fp32` verfügt. Wenn auf `None` gesetzt, wird kein Cast angewendet. Der Standardwert ist `None`. + `layout` (Zeichenfolge) – Verfügbare Werte sind `b h s d` oder `b s h d`. Dies sollte auf das Layout der übergebenen `qkv`-Tensoren eingestellt werden, damit entsprechende Transformationen auf `attn` angewendet werden können. Der Standardwert ist `b h s d`. **Rückgabewerte** Ein einziger `torch.Tensor` mit der Form `(batch_size x num_heads x seq_len x head_size)`. ### `torch.sagemaker.nn.attn.FlashGroupedQueryAttention` Eine API zur Verwendung von `FlashGroupedQueryAttention` mit SMP v2. Weitere Informationen zur Verwendung dieser API finden Sie unter [Verwenden Sie FlashAttention Kernel für die Aufmerksamkeit bei gruppierten Abfragen](model-parallel-core-features-v2-flashattention.md#model-parallel-core-features-v2-flashattention-grouped-query). ``` class torch.sagemaker.nn.attn.FlashGroupedQueryAttention( attention_dropout_prob: float = 0.0, scale: Optional[float] = None, ) ``` **Parameter** + `attention_dropout_prob` (float) – Die Dropout-Wahrscheinlichkeit für die Aufmerksamkeit. Der Standardwert ist `0.0`. + `scale` (float) – Falls übergeben, wird dieser Skalierungsfaktor für Softmax angewendet. Wenn auf `None` gesetzt, wird `1 / sqrt(attention_head_size)` als Skalierungsfaktor verwendet. Der Standardwert ist `None`. **Methoden** + `forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d")`— Eine reguläre PyTorch Modulfunktion. Wenn ein `module(x)` aufgerufen wird, führt SMP diese Funktion automatisch aus. + `q` – `torch.Tensor` in der folgenden Form `(batch_size x seqlen x num_heads x head_size)` oder `(batch_size x num_heads x seqlen x head_size)`. Basierend auf der Form muss ein geeignetes Layoutargument übergeben werden. + `kv` – `torch.Tensor` in der folgenden Form: `(batch_size x seqlen x (2 x num_heads) x head_size)` oder `(batch_size, (2 x num_heads) x seqlen x head_size)`, oder ein Tupel von zwei `torch.Tensor`en, die jeweils die Form `(batch_size x seqlen x num_heads x head_size)` oder `(batch_size x num_heads x seqlen x head_size)` haben können. Basierend auf der Form muss auch ein entsprechendes `layout`-Argument übergeben werden. + `causal` – Wenn dieser Wert auf `False` gesetzt ist, was der Standardwert des Arguments ist, wird keine Maske angewendet. Wenn er auf `True` gesetzt ist, verwendet die `forward`-Methode die untere dreieckige Standardmaske. Der Standardwert ist `False`. + `cast_dtype` – Wenn dieser Wert auf einen bestimmten dtype gesetzt ist, werden die `qkv`-Tensoren vor `attn` in diesen dtype umgewandelt. Dies ist nützlich für Implementierungen wie das Hugging Face Transformer GPT-NeoX, das nach den rotativen Einbettungen über `q,k` mit `fp32` verfügt. Wenn auf `None` gesetzt, wird kein Cast angewendet. Der Standardwert ist `None`. + Layout (Zeichenfolge) – Verfügbare Werte sind `"b h s d"` oder `"b s h d"`. Dies sollte auf das Layout der übergebenen `qkv`-Tensoren eingestellt werden, damit entsprechende Transformationen auf `attn` angewendet werden können. Der Standardwert ist `"b h s d"`. **Rückgabewerte** Gibt einen einzelnen `torch.Tensor (batch_size x num_heads x seq_len x head_size)` zurück, der das Ergebnis der Aufmerksamkeitsberechnung darstellt. ### `torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention` Eine API, die FlashAttention das Lama-Modell unterstützt. Diese API verwendet die [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn)-API auf niedriger Ebene. Weitere Informationen zu ihrer Verwendung erhalten Sie unter [Verwenden Sie FlashAttention Kernel für die Aufmerksamkeit bei gruppierten Abfragen](model-parallel-core-features-v2-flashattention.md#model-parallel-core-features-v2-flashattention-grouped-query). ``` class torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention( config: LlamaConfig ) ``` **Parameter** + `config`— Eine FlashAttention Konfiguration für das Lama-Modell. **Methoden** + `forward(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)` + `hidden_states` (`torch.Tensor`) – Versteckte Zustände eines Tensors in Form von `(batch_size x seq_len x num_heads x head_size)`. + `attention_mask` (`torch.LongTensor`) – Maske mit der Form `(batch_size x seqlen)`, um zu vermeiden, dass Aufmerksamkeit auf das Auffüllen von Token-Indizes in Form gerichtet wird. Der Standardwert ist `None`. + `position_ids` (`torch.LongTensor`) – Wenn dieser Wert nicht auf `None` gesetzt ist, gibt er in der Form `(batch_size x seqlen)` die Positionsindizes jedes Eingabesequenz-Tokens in den Positionseinbettungen an. Der Standardwert ist `None`. + `past_key_value` (Cache) – Vorberechnete versteckte Zustände (Schlüssel und Werte in den Selbstaufmerksamkeitsblöcken und in den Queraufmerksamkeitsblöcken). Der Standardwert ist `None`. + `output_attentions` (bool) – Gibt an, ob die Aufmerksamkeitstensoren aller Aufmerksamkeitsebenen zurückgegeben werden sollen. Der Standardwert ist `False`. + `use_cache` (bool) – Gibt an, ob der Schlüsselwertstatus für `past_key_values` zurückgegeben werden sollen. Der Standardwert ist `False`. **Rückgabewerte** Gibt einen einzelnen `torch.Tensor (batch_size x num_heads x seq_len x head_size)` zurück, der das Ergebnis der Aufmerksamkeitsberechnung darstellt. ### `torch.sagemaker.transform` SMP v2 bietet diese `torch.sagemaker.transform()`-API zur Transformation von Transformer-Modellen von Hugging Face in SMP-Modellimplementierungen und zur Aktivierung der SMP-Tensorparallelität. ``` torch.sagemaker.transform( model: nn.Module, device: Optional[torch.device] = None, dtype: Optional[torch.dtype] = None, config: Optional[Dict] = None, load_state_dict_from_rank0: bool = False, cp_comm_type: str = "p2p" ) ``` SMP v2 verwaltet die Transformationsrichtlinien für [Transformer-Modelle von Hugging Face, die mit der SMP-Tensorparallelität kompatibel sind](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models), indem es die Konfiguration der Transformer-Modelle von Hugging Face in die SMP-Transformer-Konfiguration konvertiert. **Parameter** + `model` (`torch.nn.Module`) – Ein Modell von [Transformer-Modelle von Hugging Face, die mit der SMP-Tensorparallelität kompatibel sind](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) zur Transformation und Anwendung des Tensorparallelitäts-Feature der SMP-Bibliothek. + `device` (`torch.device`) – Falls übergeben, wird auf diesem Gerät ein neues Modell erstellt. Wenn das ursprüngliche Modul einen Parameter auf dem Metagerät hat (siehe [Verzögerte Parameterinitialisierung](model-parallel-core-features-v2-delayed-param-init.md)), dann wird das transformierte Modul auch auf dem Metagerät erstellt, wobei das hier übergebene Argument ignoriert wird. Der Standardwert ist `None`. + `dtype` (`torch.dtype`) – Falls übergeben, wird dieser Wert als dtype-Kontextmanager für die Erstellung des Modells festgelegt und ein Modell mit diesem dtype wird erstellt. Dies ist normalerweise unnötig, da wir das Modell mit erstellen wollen, `fp32` wenn wir es verwenden`MixedPrecision`, und `fp32` es ist der Standard-Dtype in. PyTorch Der Standardwert ist `None`. + `config` (dict) – Dies ist ein Wörterbuch für die Konfiguration des SMP-Transformers. Der Standardwert ist `None`. + `load_state_dict_from_rank0` (Boolean) – Standardmäßig erstellt dieses Modul eine neue Instance des Modells mit neuen Gewichtungen. Wenn dieses Argument auf gesetzt ist`True`, versucht SMP, das Zustandswörterbuch des PyTorch Originalmodells vom 0-ten Rang in ein transformiertes Modell für die Tensorparallelgruppe zu laden, zu der der 0-te Rang gehört. Wenn dieser Wert auf `True` gesetzt ist, kann Rang 0 keine Parameter auf dem Metagerät haben. Nur die erste Tensorparallelgruppe füllt nach diesem Transformationsaufruf die Gewichtungen aus dem 0ten Rang auf. Sie müssen `sync_module_states` im FSDP-Wrapper auf `True` setzen, um diese Gewichtungen von der ersten Tensorparallelgruppe auf alle anderen Prozesse zu übertragen. Wenn diese Option aktiviert ist, lädt die SMP-Bibliothek das Statuswörterbuch aus dem Originalmodell. Die SMP-Bibliothek nimmt das `state_dict` des Modells vor der Transformation, konvertiert es, sodass es der Struktur des transformierten Modells entspricht, fragmentiert es für jeden tensorparallelen Rang, übermittelt diesen Zustand vom 0-ten Rang an andere Ränge in der Tensorparallelgruppe, zu der der 0-te Rang gehört, und lädt es. Der Standardwert ist `False`. + `cp_comm_type` (str) – Bestimmt die Implementierung der Kontextparallelität und ist nur anwendbar, wenn der `context_parallel_degree` größer als 1 ist. Verfügbare Werte für diesen Parameter sind `p2p` und `all_gather`. Die `p2p` Implementierung verwendet peer-to-peer Sende- und Empfangsrufe für die Akkumulation von key-and-value (KV) -Tensoren während der Aufmerksamkeitsberechnung, die asynchron ablaufen und es ermöglichen, dass sich die Kommunikation mit der Berechnung überschneidet. Andererseits verwendet die `all_gather`-Implementierung die kollektive `AllGather`-Kommunikationsoperation für die Ansammlung von KV-Tensoren. Der Standardwert ist `"p2p"`. **Gibt zurück** Gibt ein transformiertes Modell zurück, das Sie mit PyTorch FSDP umschließen können. Wenn `load_state_dict_from_rank0` auf `True` gesetzt ist, hat die Tensorparallelgruppe, die Rang 0 beinhaltet, Gewichtungen, die aus dem ursprünglichen Zustandswörterbuch auf Rang 0 geladen wurden. Bei der Verwendung [Verzögerte Parameterinitialisierung](model-parallel-core-features-v2-delayed-param-init.md) auf dem Originalmodell sind nur bei diesen Rängen die tatsächlichen Tensoren CPUs für die Parameter und Puffer des transformierten Modells aktiviert. Die restlichen Ränge haben weiterhin die Parameter und Puffer auf dem Metagerät, um Speicherplatz zu sparen. ### Util-Funktionen und -Eigenschaften von `torch.sagemaker` **Util-Funktionen von torch.sagemaker** + `torch.sagemaker.init(config: Optional[Union[str, Dict[str, Any]]] = None) -> None`— Initialisiert den PyTorch Trainingsjob mit SMP. + `torch.sagemaker.is_initialized() -> bool` – Prüft, ob der Trainingsjob mit SMP initialisiert ist. **Wenn bei der Initialisierung des Jobs mit SMP auf die native PyTorch Version zurückgegriffen wird, sind einige Eigenschaften nicht relevant und werden, wie in der folgenden Eigenschaftenliste angegeben`None`, entsprechend.** + `torch.sagemaker.utils.module_utils.empty_module_params(module: nn.Module, device: Optional[torch.device] = None, recurse: bool = False) -> nn.Module` – Erzeugt leere Parameter für das angegebene `device`, sofern vorhanden, und kann für alle verschachtelten Module, falls angegeben, rekursiv sein. + `torch.sagemaker.utils.module_utils.move_buffers_to_device(module: nn.Module, device: torch.device, recurse: bool = False) -> nn.Module` – Verschiebt Modulpuffer in das angegebene `device` und kann, für alle verschachtelten Module, falls angegeben, rekursiv sein. **Eigenschaften** `torch.sagemaker.state` enthält nach der Initialisierung von SMP mit `torch.sagemaker.init` mehrere nützliche Eigenschaften. + `torch.sagemaker.state.hybrid_shard_degree` (int) – Der Parallelitätsgrad fragmentierter Daten gemäß der Benutzereingabe in der SMP-Konfiguration, die an `torch.sagemaker.init()` übergeben wurde. Weitere Informationen hierzu finden Sie unter [Verwenden Sie die SageMaker Modellparallelitätsbibliothek v2](model-parallel-use-api-v2.md). + `torch.sagemaker.state.rank` (int) – Der globale Rang für das Gerät im Bereich von `[0, world_size)`. + `torch.sagemaker.state.rep_rank_process_group` (`torch.distributed.ProcessGroup`) – Die Prozessgruppe, die alle Geräte mit demselben Replikationsrang umfasst. Beachten Sie den subtilen, aber grundlegenden Unterschied zu `torch.sagemaker.state.tp_process_group`. Wenn auf die native Version zurückgegriffen wird PyTorch, kehrt sie zurück. `None` + `torch.sagemaker.state.tensor_parallel_degree` (int) – Der Grad der Tensorparallelität gemäß der Benutzereingabe in der SMP-Konfiguration, die an `torch.sagemaker.init()` übergeben wurde. Weitere Informationen hierzu finden Sie unter [Verwenden Sie die SageMaker Modellparallelitätsbibliothek v2](model-parallel-use-api-v2.md). + `torch.sagemaker.state.tp_size` (int) – Ein Alias für `torch.sagemaker.state.tensor_parallel_degree`. + `torch.sagemaker.state.tp_rank` (int) – Der Tensorparallelitätsrang für das Gerät im Bereich von `[0, tp_size)`, der durch den Grad der Tensorparallelität und den Rangfolgemechanismus bestimmt wird. + `torch.sagemaker.state.tp_process_group` (`torch.distributed.ProcessGroup`) – Die tensorparallele Prozessgruppe, die alle Geräte mit demselben Rang in anderen Dimensionen (z. B. Parallelität fragmentierter Daten und Replikation), aber einzigartigen Rängen der Tensorparallelität umfasst. Wenn auf Native zurückgegriffen wird PyTorch, kehrt es zurück`None`. + `torch.sagemaker.state.world_size` (int) – Die Gesamtzahl der im Training verwendeten Geräte. ## Upgrade von SMP v1 auf SMP v2 Um von SMP v1 zu SMP v2 zu wechseln, müssen Sie Änderungen am Skript vornehmen, um SMP v1 zu entfernen APIs und SMP v2 anzuwenden. APIs Anstatt mit Ihrem SMP v1-Skript zu beginnen, empfehlen wir Ihnen, mit einem PyTorch FSDP-Skript zu beginnen und den Anweisungen unter zu folgen. [Verwenden Sie die SageMaker Modellparallelitätsbibliothek v2](model-parallel-use-api-v2.md) Um SMP-v1-*Modelle* auf SMP v2 zu übertragen, müssen Sie in SMP v1 das vollständige Modellstatuswörterbuch erfassen und die Übersetzungsfunktionen auf das Modellstatuswörterbuch anwenden, um es in das Modellprüfpunktformat von Hugging Face Transformers zu konvertieren. Dann können Sie in SMP v2, wie unter beschrieben[Checkpointing mit SMP](model-parallel-core-features-v2-checkpoints.md), die Modell-Checkpoints von Hugging Face Transformers laden und dann mit der Verwendung des PyTorch APIs Checkpoints mit SMP v2 fortfahren. Um SMP mit Ihrem PyTorch FSDP-Modell zu verwenden, stellen Sie sicher, dass Sie zu SMP v2 wechseln und Änderungen an Ihrem Trainingsskript vornehmen, um FSDP und andere aktuelle Funktionen zu verwenden. PyTorch ``` import smdistributed.modelparallel.torch as smp # Create model model = ... model = smp.DistributedModel(model) # Run training ... # Save v1 full checkpoint if smp.rdp_rank() == 0: model_dict = model.state_dict(gather_to_rank0=True) # save the full model # Get the corresponding translation function in smp v1 and translate if model_type == "gpt_neox": from smdistributed.modelparallel.torch.nn.huggingface.gptneox import translate_state_dict_to_hf_gptneox translated_state_dict = translate_state_dict_to_hf_gptneox(state_dict, max_seq_len=None) # Save the checkpoint checkpoint_path = "checkpoint.pt" if smp.rank() == 0: smp.save( {"model_state_dict": translated_state_dict}, checkpoint_path, partial=False, ) ``` Die verfügbaren Übersetzungsfunktionen in SMP v1 finden Sie unter [Support für Hugging Face Transformator-Modelle](model-parallel-extended-features-pytorch-hugging-face.md). Anweisungen zum Speichern und Laden von Modellprüfpunkten in SMP v2 finden Sie unter [Checkpointing mit SMP](model-parallel-core-features-v2-checkpoints.md). # Versionshinweise für die SageMaker Modellparallelitätsbibliothek In den folgenden Versionshinweisen finden Sie die neuesten Updates für die SageMaker Modellparallelismus-Bibliothek (SMP). Wenn Sie weitere Fragen zur SMP-Bibliothek haben, wenden Sie sich an das SMP-Serviceteam unter `sm-model-parallel-feedback@amazon.com`. ## Die SageMaker Modellparallelismus-Bibliothek v2.8.0 *Datum: 01. April 2025* ### Aktualisierungen der SMP-Bibliothek **Fehlerbehebungen** + Das SMP-Gradientennorm-Clipping unterstützt jetzt die Aktivierungsauslagerung. ### SMP-Docker- und Enroot-Container Das SMP-Bibliotheksteam verteilt Docker-Container als Ersatz für die Framework-Container. SageMaker PyTorch Wenn Sie die PyTorch Estimator-Klasse im SageMaker Python-SDK verwenden und die Verteilungskonfiguration für die Verwendung von SMP v2 angeben, nimmt SageMaker KI die SMP-Docker-Container automatisch auf. Um diese Version von SMP v2 zu verwenden, aktualisieren Sie Ihr SageMaker Python-SDK auf `v2.243.0` oder höher. **Aktualisierungen der Währungen** + Unterstützung für v2.5.1 PyTorch hinzugefügt + Die CUDA-Unterstützung wurde auf v12.4 aktualisiert. + Die NCCL-Unterstützung wurde auf v2.23.4 aktualisiert. + Die SMDDP-Bibliothek wurde auf 2.6.0 aktualisiert. **Details zum Container** + SMP Docker-Container für PyTorch v2.5.1 mit CUDA v12.4 ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.5.1-gpu-py311-cu124 ``` + SMP Enroot-Container für v2.5.1 mit CUDA v12.4 PyTorch ``` https://sagemaker-distributed-model-parallel.s3..amazonaws.com/enroot/2.5.1-gpu-py311-cu124.sqsh ``` + Vorinstallierte Pakete + SMP-Bibliothek v2.8.0 + SMDDP-Bibliothek v2.6.0 + CUDNN v9.4.0 + FlashAttention v2.5.8 + TransformerEngine v1.10 + Megatron v0.8.0 + Hugging Face Transformers v4.44.2 + Hugging Face Datensatz-Bibliothek v2.19.0 + EFA v1.36.0 + NCCL v2.23.4 + AWS-OFI-NCCL v1.13.2 ### SMP-Conda-Kanal Der folgende S3-Bucket ist der öffentliche Conda-Kanal der SMP-Bibliothek, der vom SMP-Serviceteam gehostet wird. Wenn Sie die SMP v2-Bibliothek in einer Umgebung wie SageMaker HyperPod Clustern installieren möchten, verwenden Sie diesen Conda-Kanal, um die SMP-Bibliothek ordnungsgemäß zu installieren. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Weitere Informationen zu Conda-Kanälen im Allgemeinen finden Sie unter [Kanäle](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) in der *Conda-Dokumentation*. ## Die SageMaker Modellparallelismus-Bibliothek v2.7.0 *Datum: 04. Dezember 2024* ### Aktualisierungen der SMP-Bibliothek **Neue Features** + Unterstützung für [SageMaker HyperPod Rezepte](sagemaker-hyperpod-recipes.md) hinzugefügt. ### SMP-Docker- und Enroot-Container Das SMP-Bibliotheksteam verteilt Docker- und Enroot-Container als Ersatz für die Framework-Container. SageMaker PyTorch Wenn Sie die PyTorch Estimator-Klasse im SageMaker Python-SDK verwenden und die Verteilungskonfiguration für die Verwendung von SMP v2 angeben, SageMaker werden die SMP-Docker-Container automatisch übernommen. Um diese Version von SMP v2 zu verwenden, aktualisieren Sie Ihr SageMaker Python-SDK auf `v2.237.0` oder höher. **Details zum Container** + SMP Docker-Container für PyTorch v2.4.1 mit CUDA v12.1 ``` 658645717510.dkr.ecr..smdistributed-modelparallel:2.4.1-gpu-py311-cu121 ``` + SMP Enroot-Container für v2.4.1 mit CUDA v12.1 PyTorch ``` https://sagemaker-distributed-model-parallel.s3..amazonaws.com/enroot/2.4.1-gpu-py311-cu121.sqsh ``` + Vorinstallierte Pakete + SMP-Bibliothek v2.7.0 + SMDDP-Bibliothek v2.5.0 + CUDNN v9.4.0 + FlashAttention v2.5.8 + TransformerEngine v1.10 + Megatron v0.8.0 + Hugging Face Transformers v4.44.2 + Hugging Face Datensatz-Bibliothek v2.19.0 + EFA v1.32.0 + NCCL v2.21.5 ### SMP-Conda-Kanal Der folgende S3-Bucket ist der öffentliche Conda-Kanal der SMP-Bibliothek, der vom SMP-Serviceteam gehostet wird. Wenn Sie die SMP v2-Bibliothek in einer Conda-Umgebung wie SageMaker HyperPod Clustern installieren möchten, verwenden Sie diesen Conda-Kanal, um die SMP-Bibliothek ordnungsgemäß zu installieren. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Weitere Informationen zu Conda-Kanälen im Allgemeinen finden Sie unter [Kanäle](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) in der *Conda-Dokumentation*. ## Die SageMaker Modellparallelismus-Bibliothek v2.6.1 *Datum: 31. Oktober 2024* ### Aktualisierungen der SMP-Bibliothek **Fehlerbehebungen** + Es wurde ein `ImportError`-Problem behoben, das bei der Verwendung älterer Trainingsskripte mit SMP v2.6.0 auftrat. Dies behebt die Abwärtsinkompatibilität mit SMP v2.6.0. + Es wurde eine `DeprecationWarning` für `torch.sagemaker.distributed.fsdp.checkpoint` hinzugefügt. Dieses Modul wird in SMP v2.7.0 nicht mehr unterstützt und entfernt. Wenn Sie derzeit `torch.sagemaker.distributed.fsdp.checkpoint` in Ihrem Code verwenden, sollten Sie Ihre Skripts vor der Veröffentlichung von SMP v2.7.0 aktualisieren, um zukünftige Probleme zu vermeiden. + Ein in SMP v2.6.0 festgestelltes Problem mit der Abwärtskompatibilität wurde behoben. Dieses Problem stand im Zusammenhang mit der veralteten Checkpoint-Methode `USE_PG_WITH_UTIL` in SMP v2.6.0, wodurch die Abwärtskompatibilität mit früheren Versionen von Trainingsskripten beeinträchtigt wurde. Um dieses Problem zu beheben, führen Sie Ihre PyTorch Trainingsaufgaben erneut aus, um den neuesten SMP-Container zu erhalten, der in SMP v2.6.1 enthalten ist. ### SMP-Docker-Container Das SMP-Bibliotheksteam verteilt Docker-Container als Ersatz für die Framework-Container. SageMaker PyTorch Wenn Sie die PyTorch Estimator-Klasse im SageMaker Python-SDK verwenden und die Verteilungskonfiguration für die Verwendung von SMP v2 angeben, nimmt SageMaker KI die SMP-Docker-Container automatisch auf. **Details zum Container** + SMP Docker-Container für v2.4.1 mit CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121 ``` + Vorinstallierte Pakete + SMP-Bibliothek v2.6.1 + SMDDP-Bibliothek v2.5.0 + CUDNN v9.4.0 + FlashAttention v2.5.8 + TransformerEngine v1.10 + Megatron v0.8.0 + Hugging Face Transformers v4.44.2 + Hugging Face Datensatz-Bibliothek v2.19.0 + EFA v1.32.0 + NCCL v2.21.5 ### SMP-Conda-Kanal Der folgende S3-Bucket ist der öffentliche Conda-Kanal der SMP-Bibliothek, der vom SMP-Serviceteam gehostet wird. Wenn Sie die SMP v2-Bibliothek in einer Umgebung mit hochgradig anpassbaren Rechenressourcen wie SageMaker HyperPod Clustern installieren möchten, verwenden Sie diesen Conda-Kanal, um die SMP-Bibliothek ordnungsgemäß zu installieren. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Weitere Informationen zu Conda-Kanälen im Allgemeinen finden Sie unter [Kanäle](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) in der *Conda-Dokumentation*. ## Die SageMaker Modellparallelismus-Bibliothek v2.6.0 *Datum: 17. Oktober 2024* ### Aktualisierungen der SMP-Bibliothek **Neue Features** + Die folgenden LLM-Modellkonfigurationen werden nun unterstützt. Sie können mit der Verwendung von [Kontextparallelität](model-parallel-core-features-v2-context-parallelism.md) und [Tensor-Parallelität](model-parallel-core-features-v2-tensor-parallelism.md) beginnen. + [Llama 3.1 8B](https://huggingface.co/meta-llama/Llama-3.1-8B) + [Llama 3.1 70B](https://huggingface.co/meta-llama/Llama-3.1-70B) + [Mistral 7B](https://huggingface.co/mistralai/Mistral-7B-v0.3) + Für die folgenden Mixtral-Modellkonfigurationen wird nun [Tensor-Parallelität](model-parallel-core-features-v2-tensor-parallelism.md) unterstützt. + [Mixtral 8x7B](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1) + [Mixtral 8x22B](https://huggingface.co/mistralai/Mixtral-8x22B-v0.1) + Unterstützung für eine AllGather basierte Implementierung von Kontextparallelität hinzugefügt, die das AllGather Kommunikationskollektiv nutzt, um die vollständige Sequenz von Tensoren zu erhalten. key-and-value Verfügbare Implementierungen sind `p2p` und `all_gather`. Die `p2p` Implementierung verwendet peer-to-peer Sende- und Empfangsrufe für die Akkumulation von key-and-value (KV) -Tensoren während der Aufmerksamkeitsberechnung, die asynchron ablaufen und es ermöglichen, dass sich die Kommunikation mit der Berechnung überschneidet. Andererseits verwendet die `all_gather`-Implementierung die kollektive `AllGather`-Kommunikationsoperation für die Ansammlung von KV-Tensoren. Informationen zur Anwendung dieser Implementierung von Kontextparallelität finden Sie unter [Kontextparallelität](model-parallel-core-features-v2-context-parallelism.md). + Die Einstellung des RoPE-Theta-Werts (Rotary Position Embedding) wird nun unterstützt. **Fehlerbehebungen** + Es wurde ein Fehler behoben, bei dem Rotary Position Embedding (RoPE) beim Vortraining nicht richtig initialisiert wurde, wenn die verzögerte Parameterinitialisierung aktiviert war. **Bekannte Probleme** + Transformer Engine unterstützt derzeit keine Kontextparallelität oder die Aktivierung von Sliding Window Attention. FP8 Daher unterstützt die SMP-Version von Mistral Transformers keine Kontextparallelität oder FP8 Training, wenn die Konfiguration des Schiebefensters auf einen Wert ungleich Null gesetzt ist. ### SMP-Docker-Container Das SMP-Bibliotheksteam verteilt Docker-Container als Ersatz für die Framework-Container. SageMaker PyTorch Wenn Sie die PyTorch Estimator-Klasse im SageMaker Python-SDK verwenden und die Verteilungskonfiguration für die Verwendung von SMP v2 angeben, nimmt SageMaker KI die SMP-Docker-Container automatisch auf. **Aktualisierungen der Währungen** + PyTorch Auf v2.4.1 aktualisiert + Megatron auf v0.8.0 aktualisiert + Die TransformerEngine Bibliothek wurde auf v1.10 aktualisiert + Transformers auf v4.44.2 aktualisiert + cuDNN auf v9.4.0.58 aktualisiert **Details zum Container** + SMP Docker-Container für PyTorch v2.4.1 mit CUDA v12.1 ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121 ``` + Vorinstallierte Pakete + SMP-Bibliothek v2.6.0 + SMDDP-Bibliothek v2.5.0 + CUDNN v9.4.0 + FlashAttention v2.5.8 + TransformerEngine v1.10 + Megatron v0.8.0 + Hugging Face Transformers v4.44.2 + Hugging Face Datensatz-Bibliothek v2.19.0 + EFA v1.32.0 + NCCL v2.21.5 ### SMP-Conda-Kanal Der folgende S3-Bucket ist der öffentliche Conda-Kanal der SMP-Bibliothek, der vom SMP-Serviceteam gehostet wird. Wenn Sie die SMP v2-Bibliothek in einer Umgebung mit hochgradig anpassbaren Rechenressourcen wie SageMaker HyperPod Clustern installieren möchten, verwenden Sie diesen Conda-Kanal, um die SMP-Bibliothek ordnungsgemäß zu installieren. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Weitere Informationen zu Conda-Kanälen im Allgemeinen finden Sie unter [Kanäle](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) in der *Conda-Dokumentation*. ## Die SageMaker Modellparallelismus-Bibliothek v2.5.0 *Datum: 28. August 2024* ### Aktualisierungen der SMP-Bibliothek **Neue Features** + Unterstützung für Training mit gemischter Genauigkeit unter Verwendung des FP8 Datenformats auf P5-Instances für das Mixtral-Modell hinzugefügt. + Die unterstützten Mixtral-Konfigurationen sind 8x7B und 8x22B. Weitere Informationen hierzu finden Sie unter [Training mit gemischter Präzision FP8 auf P5-Instanzen mithilfe der Transformer Engine](model-parallel-core-features-v2-mixed-precision.md#model-parallel-core-features-v2-mixed-precision-fp8-training-on-p5). + [Kontextparallelität](model-parallel-core-features-v2-context-parallelism.md) wird nun für die folgenden Modellkonfigurationen unterstützt. + Llama-v2: 7B und 70B + Llama-v3: 8B und 70B + GPT-NeoX: 20B + Das asynchrone Speichern von Checkpoints wird nun unterstützt. Weitere Informationen hierzu finden Sie unter [Checkpointing mit SMP](model-parallel-core-features-v2-checkpoints.md). + Unterstützung für das direkte Speichern von Checkpoints in S3 ohne Amazon EBS oder Dateiserver **Fehlerbehebungen** + Es wurde ein Problem behoben, das bei der Llama-Optimierung zu unerwartet hohen Anfangsverlusten führte, wenn ein vortrainierter Modell-Checkpoint geladen und die Tensorparallelität verwendet wurde. **Hinweise** + Um das Aktivierungs-Checkpointing für Mixtral mit FP8 gemischter Genauigkeit zu verwenden, müssen Sie die Aufmerksamkeits- und Expertenebene separat überprüfen. Ein Beispiel für die korrekte Einrichtung finden Sie im [Beispiel-Trainingsskript](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel_v2/shared-scripts/train_utils.py) im *Amazon SageMaker AI Examples Repository*. **Bekannte Probleme** + Der Lastenausgleich in der MoE-Konfiguration ([`torch.sagemaker.moe.moe_config.MoEConfig`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-moe)) ist derzeit nicht mit dem Aktivierungs-Checkpoint kompatibel. + Bei der Kontextparallelität weist GPT-NeoX sowohl bei dem Vortraining als auch bei der Optimierung einen Leistungsrückgang auf. + Bei GPT-NeoX auf P4-Instances führt das direkte Laden von Gewichtungen aus einem transformierten Modell mit verzögerter Parameterinitialisierung in ein Transformer-Modell von Hugging Face zu einer Verlust-Fehlanpassung im ersten Schritt. ### SMP-Docker-Container Das SMP-Bibliotheksteam verteilt Docker-Container als Ersatz für die SageMaker PyTorch Framework-Container. Wenn Sie die PyTorch Estimator-Klasse im SageMaker Python-SDK verwenden und die Verteilungskonfiguration für die Verwendung von SMP v2 angeben, nimmt SageMaker KI die SMP-Docker-Container automatisch auf. Um diese Version von SMP v2 zu verwenden, aktualisieren Sie Ihr SageMaker Python-SDK auf Version 2.224.0 oder höher. **Aktualisierungen der Währungen** + Die Bibliothek wurde auf v2.5.8 aktualisiert FlashAttention + TransformerEngine-Bibliothek auf v1.8 aktualisiert + Wenn Sie Transformer Engine in einer Conda-Umgebung installieren möchten, müssen Sie auf dem Quellcode aufbauen und die spezifischen Upstream-Korrekturen auswählen ([744624d](https://github.com/NVIDIA/TransformerEngine/commit/744624d004f4514ffbaa90ac83e214311c86c607), [27c6342](https://github.com/NVIDIA/TransformerEngine/commit/27c6342ea8ad88034bf04b587dd13cb6088d2474), [7669bf3](https://github.com/NVIDIA/TransformerEngine/commit/7669bf3da68074517b134cd6acebd04b221fd545)). **Details zum Container** + SMP Docker-Container für PyTorch v2.3.1 mit CUDA v12.1 ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.3.1-gpu-py311-cu121 ``` Eine vollständige Liste der unterstützten Regionen finden Sie unter [AWS-Regionen](distributed-data-parallel-support.md#distributed-data-parallel-availablity-zone). + Vorinstallierte Pakete + SMP-Bibliothek v2.5.0 + SMDDP-Bibliothek v2.3.0 + CUDNN v8.9.7.29 + FlashAttention v2.5.8 + TransformerEngine v1.8 + Megatron v0.7.0 + Hugging Face Transformers v4.40.1 + Hugging Face Datensatz-Bibliothek v2.19.0 + EFA v1.32.0 + NCCL v2.21.5 ### SMP-Conda-Kanal Der folgende S3-Bucket ist der öffentliche Conda-Kanal der SMP-Bibliothek, der vom SMP-Serviceteam gehostet wird. Wenn Sie die SMP v2-Bibliothek in einer Umgebung mit hochgradig anpassbaren Rechenressourcen wie SageMaker HyperPod Clustern installieren möchten, verwenden Sie diesen Conda-Kanal, um die SMP-Bibliothek ordnungsgemäß zu installieren. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Weitere Informationen zu Conda-Kanälen im Allgemeinen finden Sie unter [Kanäle](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) in der *Conda-Dokumentation*. ## Die SageMaker Modellparallelismus-Bibliothek v2.4.0 *Datum: 20. Juni 2024* ### Aktualisierungen der SMP-Bibliothek **Fehlerbehebungen** + Es wurde ein Fehler behoben, der zu falschen Logit-Formen führte, wenn bei der Verwendung des SMP-Transformers im Vorwärtsdurchlauf keine Beschriftungen übergeben wurden. **Aktualisierungen der Währungen** + Unterstützung für v2.3.1 hinzugefügt. PyTorch + Unterstützung für Python v3.11 hinzugefügt + Die Bibliothek Hugging Face Transformers v4.40.1 wird nun unterstützt. **Veraltete Versionen** + Die Unterstützung für Python v3.10 wurde eingestellt. + Die Unterstützung für die Versionen der Bibliothek Hugging Face Transformers vor v4.40.1 wurde eingestellt. Weitere Änderungen + Es wurde ein Patch hinzugefügt, mit dem beim Speichern deduplizierter Tensoren zwischen verschiedenen Rängen gewechselt werden kann. Weitere Informationen finden Sie im [Diskussionsthread](https://github.com/pytorch/pytorch/pull/126569) im PyTorch GitHub Repository. **Bekannte Probleme** + Es ist bekannt, dass es bei der Optimierung von Llama-3 70B mit Tensorparallelität zu Verlustspitzen und dann zu einem höheren Verlustwert kommen kann. ### SMP-Docker-Container Das SMP-Bibliotheksteam verteilt Docker-Container als Ersatz für die SageMaker PyTorch Framework-Container. Wenn Sie die PyTorch Estimator-Klasse im SageMaker Python-SDK verwenden und die Verteilungskonfiguration für die Verwendung von SMP v2 angeben, nimmt SageMaker KI die SMP-Docker-Container automatisch auf. Um diese Version von SMP v2 zu verwenden, aktualisieren Sie Ihr SageMaker Python-SDK auf Version 2.224.0 oder höher. **Aktualisierungen der Währungen** + Die SMDDP-Bibliothek wurde auf v2.3.0 aktualisiert. + Die NCCL-Bibliothek wurde auf v2.21.5 aktualisiert. + Die EFA-Software wurde auf v1.32.0 aktualisiert. **Veraltete Versionen** + Die Installation der Bibliothek [Torch Distributed Experimental (torchdistX)](https://pytorch.org/torchdistx/latest/index.html) wurde eingestellt. **Details zum Container** + SMP Docker-Container für PyTorch v2.3.1 mit CUDA v12.1 ``` 658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.3.1-gpu-py311-cu121 ``` + Vorinstallierte Pakete + SMP-Bibliothek v2.4.0 + SMDDP-Bibliothek v2.3.0 + CUDNN v8.9.7.29 + FlashAttention v2.3.3 + TransformerEngine v1.2.1 + Hugging Face Transformers v4.40.1 + Hugging Face Datensatz-Bibliothek v2.19.0 + EFA v1.32.0 + NCCL v2.21.5 ### SMP-Conda-Kanal Der folgende S3-Bucket ist der öffentliche Conda-Kanal der SMP-Bibliothek, der vom SMP-Serviceteam gehostet wird. Wenn Sie die SMP v2-Bibliothek in einer Umgebung mit hochgradig anpassbaren Rechenressourcen wie SageMaker HyperPod Clustern installieren möchten, verwenden Sie diesen Conda-Kanal, um die SMP-Bibliothek ordnungsgemäß zu installieren. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Weitere Informationen zu Conda-Kanälen im Allgemeinen finden Sie unter [Kanäle](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) in der *Conda-Dokumentation*. ## Die SageMaker Modellparallelismus-Bibliothek v2.3.1 *Datum: 9. Mai 2024* **Fehlerbehebungen** + Es wurde ein `ImportError`-Problem behoben, das bei der Verwendung von `moe_load_balancing=balanced` in [`torch.sagemaker.moe.moe_config.MoEConfig`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-moe) zur Expertenparallelität auftrat. + Es wurde ein Problem bei der Optimierung behoben, bei dem beim Aufruf von [`torch.sagemaker.transform`](distributed-model-parallel-v2-reference.md#model-parallel-v2-torch-sagemaker-reference-transform) ein `KeyError` ausgelöst wurde, wenn `load_state_dict_from_rank0` aktiviert war. + Es wurde ein out-of-memory (OOM) -Fehler behoben, der beim Laden großer Mixture of Experts (MoE) -Modelle wie Mixtral 8x22B zur Feinabstimmung auftrat. **SMP-Docker-Container** Das SMP-Bibliotheksteam verteilt Docker-Container als Ersatz für die Framework-Container. SageMaker PyTorch Diese Version enthält die oben genannten Fehlerbehebungen im folgenden SMP-Docker-Image. + SMP Docker-Container für v2.2.0 mit CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 ``` ## Die SageMaker Modellparallelismus-Bibliothek v2.3.0 *Datum: 11. April 2024* **Neue Features** + Zur Unterstützung von MoE-Transformer-Modellen (Mixture of Experts) wurde die *Expertenparallelität* als neue Kernfunktion hinzugefügt. Weitere Informationen hierzu finden Sie unter [Expertenparallelität](model-parallel-core-features-v2-expert-parallelism.md). **SMP-Docker-Container** Das SMP-Bibliotheksteam verteilt Docker-Container als Ersatz für die Framework-Container. SageMaker PyTorch Wenn Sie die PyTorch Estimator-Klasse im SageMaker Python-SDK verwenden und die Verteilungskonfiguration für die Verwendung von SMP v2 angeben, SageMaker werden die SMP-Docker-Container automatisch übernommen. Um diese Version von SMP v2 zu verwenden, aktualisieren Sie Ihr SageMaker Python-SDK auf Version 2.214.4 oder höher. + SMP Docker-Container für v2.2.0 mit CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 ``` + Vorinstallierte Pakete in diesem Docker-Container + SMDDP-Bibliothek v2.2.0 + CUDNN v8.9.5.29 + FlashAttention v2.3.3 + TransformerEngine v1.2.1 + Hugging Face Transformers v4.37.1 + Hugging Face Datensatz-Bibliothek v2.16.1 + Megatron-Kern 0.5.0 + EFA v1.30.0 + NCCL v2.19.4 ## Die SageMaker Modellparallelitätsbibliothek v2.2.0 *Datum: 7. März 2024* **Neue Funktionen** + Unterstützung für das [FP8 Training](model-parallel-core-features-v2-mixed-precision.md#model-parallel-core-features-v2-mixed-precision-fp8-training-on-p5) der folgenden Hugging Face Face-Transformer-Modelle auf P5-Instances mit Transformer Engine-Integration hinzugefügt: + GPT-NeoX + Llama 2 **Fehlerbehebungen** + Es wurde ein Fehler behoben, bei dem vor dem kollektiven `AllGather`-Aufruf während des Tensorparallelitätstrainings nicht garantiert wurde, dass die Tensoren zusammenhängend waren. **Währungsaktualisierungen** + Unterstützung für PyTorch v2.2.0 hinzugefügt. + Die SMDDP-Bibliothek wurde auf v2.2.0 aktualisiert. + Die FlashAttention Bibliothek wurde auf Version 2.3.3 aktualisiert. + Die NCCL-Bibliothek wurde auf v2.19.4 aktualisiert. **Veraltet** + Die Unterstützung für die Transformer-Engine-Versionen vor v1.2.0 wurde eingestellt. **Bekannte Probleme** + Das SMP-Feature [Aktivierung, Entladung](model-parallel-core-features-v2-pytorch-activation-offloading.md) funktioniert derzeit nicht. Verwenden Sie stattdessen das native PyTorch Aktivierungs-Offloading. Weitere Änderungen + Es wurde ein Patch zur Behebung der Leistungsregression hinzugefügt, die im Problemthread unter [https://github.com/pytorch/pytorch/issues/117748 im Repository](https://github.com/pytorch/pytorch/issues/117748) besprochen wurde. PyTorch GitHub **SMP-Docker-Container** Das SMP-Bibliotheksteam verteilt Docker-Container als Ersatz für die Framework-Container. SageMaker PyTorch Wenn Sie die PyTorch Estimator-Klasse im SageMaker Python-SDK verwenden und die Verteilungskonfiguration für die Verwendung von SMP v2 angeben, nimmt SageMaker KI die SMP-Docker-Container automatisch auf. Um diese Version von SMP v2 zu verwenden, aktualisieren Sie Ihr SageMaker Python-SDK auf Version 2.212.0 oder höher. + SMP Docker-Container für v2.2.0 mit CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 ``` + Verfügbar für P4d-, P4de- und P5-Instances + Vorinstallierte Pakete in diesem Docker-Container + SMDDP-Bibliothek v2.2.0 + CUDNN v8.9.5.29 + FlashAttention v2.3.3 + TransformerEngine v1.2.1 + Hugging Face Transformers v4.37.1 + Hugging Face Datensatz-Bibliothek v2.16.1 + EFA v1.30.0 + NCCL v2.19.4 ## Die SageMaker Modellparallelitätsbibliothek v2.1.0 *Datum: 6. Februar 2024* **Währungsupdates** + Unterstützung für PyTorch v2.1.2 hinzugefügt. **Veraltet** + Die Unterstützung für Hugging Face Transformers v4.31.0 wurde eingestellt. **Bekannte Probleme** + Es wurde festgestellt, dass die Optimierung des Llama-2-Modells von Hugging Face mit `attn_implementation=flash_attention_2` und FSDP zu Modellabweichungen führt. Weitere Informationen finden Sie im [Issue-Ticket](https://github.com/huggingface/transformers/issues/28826) im *Hugging Face GitHub Transformers-Repository*. Um das Divergenzproblem zu vermeiden, verwenden Sie `attn_implementation=sdpa`. Verwenden Sie alternativ die Implementierung des SMP-Transformer-Modells, indem Sie `use_smp_implementation=True` einrichten. **SMP-Docker-Container** Das SMP-Bibliotheksteam verteilt Docker-Container als Ersatz für die Framework-Container. SageMaker PyTorch Wenn Sie die PyTorch Estimator-Klasse im SageMaker Python-SDK verwenden und die Verteilungskonfiguration für die Verwendung von SMP v2 angeben, SageMaker werden die SMP-Docker-Container automatisch übernommen. Um diese Version von SMP v2 zu verwenden, aktualisieren Sie Ihr SageMaker Python-SDK auf Version 2.207.0 oder höher. + SMP Docker-Container für v2.1.2 mit CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.1.2-gpu-py310-cu121 ``` + Verfügbar für P4d-, P4de- und P5-Instances + Vorinstallierte Pakete in diesem Docker-Container + SMDDP-Bibliothek v2.1.0 + CUDNN v8.9.5.29 + FlashAttention v2.3.3 + TransformerEngine v1.2.1 + Hugging Face Transformers v4.37.1 + Hugging Face Datensatz-Bibliothek v2.16.1 + EFA v1.30.0 **SMP-Conda-Kanal** Der folgende S3-Bucket ist ein öffentlicher Conda-Kanal, der vom SMP-Serviceteam gehostet wird. Wenn Sie die SMP v2-Bibliothek in einer Umgebung mit hochgradig anpassbaren Rechenressourcen wie SageMaker HyperPod Clustern installieren möchten, verwenden Sie diesen Conda-Kanal, um die SMP-Bibliothek ordnungsgemäß zu installieren. + `https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/smp-v2/` Weitere Informationen zu Conda-Kanälen im Allgemeinen finden Sie unter [Kanäle](https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html) in der *Conda-Dokumentation*. ## Die SageMaker Modellparallelismus-Bibliothek v2.0.0 *Datum: 19. Dezember 2023* **Neue Features** Die SageMaker Modellparallelismus-Bibliothek (SMP) v2.0.0 wurde mit den folgenden neuen Angeboten veröffentlicht. + Ein neues `torch.sagemaker`-Paket wurde gegenüber dem vorherigen `smdistributed.modelparallel.torch`-Paket in SMP v1.x vollständig überarbeitet. + Support für PyTorch 2.0.1. + Support für PyTorch FSDP. + Implementierung der Tensorparallelität durch Integration in die [Transformer-Engine](https://docs.nvidia.com/deeplearning/transformer-engine/index.html)-Bibliothek + Support sowohl für [SageMaker Schulungen](train-model.md) als auch [SageMaker HyperPod](sagemaker-hyperpod.md). **Bahnbrechende Änderungen** + SMP v2 hat das APIs komplett überarbeitet und bietet das `torch.sagemaker` Paket. In den meisten Fällen sind nur die Initialisierung mit dem `torch.sagemaker.init()`-Modul und die Übergabe der Konfigurationsparameter zur Modellparallelität erforderlich. Mit diesem neuen Paket können Sie Codeänderungen in Ihrem Trainingsskript erheblich vereinfachen. Weitere Informationen zur Anpassung Ihres Trainingsskripts an SMP v2 finden Sie unter [Verwenden Sie die SageMaker Modellparallelitätsbibliothek v2](model-parallel-use-api-v2.md). + Wenn Sie SMP v1 für das Training von Transformer-Modellen von Hugging Face verwendet haben und die Modelle in SMP v2 wiederverwenden möchten, finden Sie weitere Informationen unter [Upgrade von SMP v1 auf SMP v2](distributed-model-parallel-v2-reference.md#model-parallel-v2-upgrade-from-v1). + Für PyTorch FSDP-Schulungen sollten Sie SMP v2 verwenden. **Bekannte Probleme** + Aktivierungs-Checkpointing funktioniert derzeit nur mit den folgenden Wrapping-Richtlinien mit FSDP. + `auto_wrap_policy = functools.partial(transformer_auto_wrap_policy, ...)` + Für die Verwendung von [Aktivierung, Entladung](model-parallel-core-features-v2-pytorch-activation-offloading.md) muss der Typ des FSDP-Aktivierungs-Checkpoints [REENTRANT](https://pytorch.org/docs/stable/checkpoint.html) sein. + Bei der Ausführung mit aktivierter Tensorparallelität und dem Parallelitätsgrad `1` der fragmentierten Daten müssen Sie `backend = nccl` verwenden. Die `smddp`-Backend-Option wird in diesem Szenario nicht unterstützt. + [Transformer Engine](https://docs.nvidia.com/deeplearning/transformer-engine/index.html) ist für die Verwendung PyTorch mit der SMP-Bibliothek erforderlich, auch wenn keine Tensorparallelität verwendet wird. Weitere Änderungen + Ab dieser Version ist die Dokumentation für die SageMaker Modellparallelismus-Bibliothek vollständig in diesem *Amazon SageMaker AI Developer* Guide verfügbar. Zugunsten dieses vollständigen Entwicklerhandbuchs für SMP v2 im *Amazon SageMaker AI Developer Guide* ist die [zusätzliche Referenz für SMP v1.x](https://sagemaker.readthedocs.io/en/stable/api/training/distributed.html#the-sagemaker-distributed-model-parallel-library) in der *SageMaker Python SDK-Dokumentation veraltet*. [Wenn Sie die Dokumentation für SMP v1.x weiterhin benötigen, finden Sie das Entwicklerhandbuch für SMP v1.x unter[(Archiviert) SageMaker-Modellparallelitätsbibliothek v1.x](model-parallel.md), und die Referenz zur SMP-Python-Bibliothek v1.x finden Sie in der Python SDK v2.199.0-Dokumentation. SageMaker ](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) **Veraltete Versionen** + Der Support für wurde eingestellt. TensorFlow + Die Pipeline-Parallelität wird in SMP v2 nicht unterstützt. + Es gibt keine Unterstützung für die DeepSpeed Bibliothek zugunsten von nativem PyTorch FSDP. **SMP-Docker-Container** Das SMP-Bibliotheksteam verteilt Docker-Container als Ersatz für die Framework-Container. SageMaker PyTorch Wenn Sie die PyTorch Estimator-Klasse im SageMaker Python-SDK verwenden und die Verteilungskonfiguration für die Verwendung von SMP v2 angeben, nimmt SageMaker KI die SMP-Docker-Container automatisch auf. Um diese Version von SMP v2 zu verwenden, aktualisieren Sie Ihr SageMaker Python-SDK auf Version 2.207.0 oder höher. + SMP Docker-Container für v2.0.1 mit CUDA v12.1 PyTorch ``` 658645717510.dkr.ecr.us-west-2.amazonaws.com/smdistributed-modelparallel:2.0.1-gpu-py310-cu121 ``` # (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()`. # Verteiltes Rechnen mit Best Practices für SageMaker KI Auf dieser Seite mit bewährten Methoden werden verschiedene Varianten der verteilten Datenverarbeitung für Aufgaben im Bereich Machine Learning (ML) im Allgemeinen vorgestellt. Der Begriff *verteiltes Rechnen* auf dieser Seite umfasst verteiltes Training für Aufgaben des maschinellen Lernens und paralleles Rechnen für Datenverarbeitung, Datengenerierung, Feature-Engineering und Reinforcement-Learning. Auf dieser Seite besprechen wir die häufigsten Herausforderungen bei der verteilten Datenverarbeitung und die verfügbaren Optionen im Bereich SageMaker Training and SageMaker Processing. Weiteres Lesematerial zum Thema verteiltes Rechnen finden Sie unter [Was ist verteiltes Rechnen?](https://aws.amazon.com/what-is/distributed-computing/). Sie können ML-Aufgaben so konfigurieren, dass sie verteilt auf mehrere Knoten (Instanzen), Beschleuniger (NVIDIA GPUs, AWS Trainium-Chips) und vCPU-Kerne ausgeführt werden. Durch die Ausführung verteilter Berechnungen können Sie eine Vielzahl von Zielen erreichen, z. B. schnellere Rechenoperationen, die Verarbeitung großer Datensätze oder das Training großer ML-Modelle. In der folgenden Liste werden häufig auftretende Herausforderungen behandelt, mit denen Sie konfrontiert werden können, wenn Sie einen ML-Trainingsjob in großem Umfang durchführen. + Sie müssen Entscheidungen darüber treffen, wie Sie die Berechnungen je nach ML-Aufgaben, Softwarebibliotheken, die Sie verwenden möchten, und Rechenressourcen verteilen. + Nicht alle ML-Aufgaben sind einfach zu verteilen. Außerdem unterstützen nicht alle ML-Bibliotheken verteilte Berechnungen. + Verteilte Berechnungen führen möglicherweise nicht immer zu einer linearen Steigerung der Recheneffizienz. Insbesondere müssen Sie herausfinden, ob Daten I/O und die Kommunikation zwischen den GPUs zu Engpässen führen oder zu Mehraufwand führen. + Verteilte Berechnungen können numerische Prozesse stören und die Modellgenauigkeit verändern. Insbesondere beim Training mit datenparallelen neuronalen Netzwerken müssen Sie, wenn Sie die globale Batchgröße ändern und gleichzeitig auf einen größeren Rechencluster skalieren, auch die Lernrate entsprechend anpassen. SageMaker KI bietet verteilte Schulungslösungen, um solche Herausforderungen für verschiedene Anwendungsfälle zu bewältigen. Wählen Sie eine der folgenden Optionen, die am besten zu Ihrem Anwendungsfall passt. **Topics** + [Option 1: Verwenden Sie einen integrierten SageMaker KI-Algorithmus, der verteiltes Training unterstützt](#distributed-training-options-1) + [Option 2: Führen Sie einen benutzerdefinierten ML-Code in der KI-verwalteten Trainings- oder Verarbeitungsumgebung aus SageMaker](#distributed-training-options-2) + [Option 3: Schreiben Sie Ihren eigenen benutzerdefinierten verteilten Trainingscode](#distributed-training-options-3) + [Option 4: Starten Sie mehrere Jobs parallel oder nacheinander](#distributed-training-options-4) ## Option 1: Verwenden Sie einen integrierten SageMaker KI-Algorithmus, der verteiltes Training unterstützt SageMaker KI bietet [integrierte Algorithmen](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html), die Sie sofort über die SageMaker KI-Konsole oder das SageMaker Python-SDK verwenden können. Mithilfe der integrierten Algorithmen müssen Sie keine Zeit für die Code-Anpassung, das Verständnis der Wissenschaft hinter den Modellen oder die Ausführung von Docker auf bereitgestellten Amazon-EC2-Instances aufwenden. Ein Teil der integrierten SageMaker KI-Algorithmen unterstützt verteiltes Training. Informationen darüber, ob der Algorithmus Ihrer Wahl verteiltes Training unterstützt, finden Sie in der Spalte **Parallelisierbar** in der Tabelle [Allgemeine Informationen zu integrierten Algorithmen](https://docs.aws.amazon.com/sagemaker/latest/dg/common-info-all-im-models.html). **Einige der Algorithmen unterstützen verteiltes Training mit mehreren Instanzen, während die übrigen parallelisierbaren Algorithmen die Parallelisierung über mehrere Instanzen hinweg unterstützen, wie GPUs in der Spalte Parallelisierbar angegeben.** ## Option 2: Führen Sie einen benutzerdefinierten ML-Code in der KI-verwalteten Trainings- oder Verarbeitungsumgebung aus SageMaker SageMaker KI-Jobs können eine verteilte Trainingsumgebung für bestimmte Anwendungsfälle und Frameworks instanziieren. Diese Umgebung fungiert als ready-to-use Whiteboard, in das Sie Ihren eigenen ML-Code einbringen und ausführen können. ### Wenn Ihr ML-Code ein Deep-Learning-Framework verwendet Sie können verteilte Trainingsjobs mithilfe der [Deep Learning Containers (DLC)](https://github.com/aws/deep-learning-containers) for SageMaker Training starten, die Sie entweder über die speziellen Python-Module im [SageMaker AI Python SDK oder über das SageMaker APIs Tool](http://sagemaker.readthedocs.io/), orchestrieren können. [AWS CLI[AWS SDK für Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html)](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/index.html) SageMaker [KI bietet Trainingscontainer für Frameworks für maschinelles Lernen [PyTorch[TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/index.html)](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/index.html), darunter [Hugging Face Transformers](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/index.html) und Apache. MXNet](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/index.html) Sie haben zwei Möglichkeiten, Deep-Learning-Code für verteiltes Training zu schreiben. + **Die SageMaker KI verteilte Schulungsbibliotheken** Die von SageMaker KI verteilten Trainingsbibliotheken bieten AWS verwalteten Code für Datenparallelität und Modellparallelität neuronaler Netzwerke. SageMaker Die verteilte KI-Schulung umfasst auch Launcher-Clients, die in das SageMaker Python-SDK integriert sind, sodass Sie keinen parallelen Startcode erstellen müssen. Weitere Informationen finden Sie in [der Datenparallelismus-Bibliothek von SageMaker KI und der Modellparallelismus-Bibliothek](https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel.html) [von SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel.html). + **Verteilte Open-Source-Trainingsbibliotheken** Open-Source-Frameworks haben ihre eigenen Vertriebsmechanismen wie [DistributedDataParallelism (DDP)](https://pytorch.org/docs/stable/notes/ddp.html) in oder Module in. PyTorch `tf.distribute` TensorFlow Sie können sich dafür entscheiden, diese verteilten Schulungs-Frameworks in den SageMaker KI-verwalteten Framework-Containern auszuführen. Der Beispielcode für das [Training von MaskRCNN in SageMaker KI zeigt beispielsweise, wie sowohl PyTorch DDP im KI-Framework-Container](https://github.com/aws-samples/amazon-sagemaker-cv) als auch [Horovod SageMaker ](https://horovod.readthedocs.io/en/stable/) im PyTorch Framework-Container verwendet werden. SageMaker TensorFlow SageMaker [In AI ML-Containern ist [MPI auch vorinstalliert, sodass Sie Ihr Einstiegspunktskript mit mpi4py](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/mpi_on_sagemaker/intro/mpi_demo.ipynb) parallelisieren können.](https://mpi4py.readthedocs.io/en/stable/) Die Verwendung der integrierten MPI-Trainingscontainer ist eine hervorragende Option, wenn Sie einen verteilten Trainingsstarter eines Drittanbieters starten oder parallel Ad-hoc-Code in die SageMaker KI-verwaltete Trainingsumgebung schreiben. *Hinweise für das Training datenparalleler neuronaler Netzwerke am GPUs* + **Skalieren Sie gegebenenfalls auf Parallelität mit mehreren GPUs und mehreren Computern** Wir führen häufig Trainingsjobs für neuronale Netzwerke auf Instances mit mehreren CPUs oder mehreren GPUs durch. Jede GPU-basierte Instance enthält normalerweise mehrere GPU-Geräte. Folglich kann verteiltes GPU-Computing entweder innerhalb einer einzelnen GPU-Instanz mit mehreren GPUs (Einzelknoten-Multi-GPU-Training) oder über mehrere GPU-Instanzen mit jeweils mehreren GPU-Kernen (Multi-GPU-Training mit mehreren Knoten) erfolgen. Das Schreiben und Debuggen von Einzelinstanzen ist einfacher, Code zu schreiben und zu debuggen, und der Durchsatz innerhalb der Knoten ist normalerweise schneller als der GPU-to-GPU Durchsatz zwischen den Knoten. GPU-to-GPU Daher ist es eine gute Idee, die Datenparallelität zunächst vertikal zu skalieren (verwenden Sie eine GPU-Instanz mit mehreren GPUs) und bei Bedarf auf mehrere GPU-Instanzen zu erweitern. Dies gilt möglicherweise nicht für Fälle, in denen das CPU-Budget hoch ist (z. B. eine enorme Arbeitslast für die Datenvorverarbeitung) und wenn das CPU-to-GPU Verhältnis einer Multi-GPU-Instanz zu niedrig ist. In allen Fällen müssen Sie mit verschiedenen Kombinationen von Instance-Typen experimentieren, die auf Ihren eigenen ML-Trainingsanforderungen und Ihres Workloads basieren. + **Überwachen Sie die Qualität der Konvergenz** Wenn ein neuronales Netzwerk mit Datenparallelität trainiert wird, führt die Erhöhung der Anzahl von GPUs bei gleichbleibender Mini-Batch-Größe pro GPU zu einer Erhöhung der Größe des globalen Mini-Batches für den Mini-Batch-Prozess mit stochastischem Gradientenabstieg (MSGD). Es ist bekannt, dass sich die Größe der Mini-Batches für MSGD auf das Abstiegsgeräusch und die Konvergenz auswirkt. Für eine korrekte Skalierung unter Beibehaltung der Genauigkeit müssen Sie andere Hyperparameter wie die Lernrate anpassen [[Goyal et al.](https://arxiv.org/abs/1706.02677) (2017). + ** I/O Überwachen Sie Engpässe** Wenn Sie die Anzahl der erhöhen GPUs, sollte auch der Durchsatz für den Lese- und Schreibspeicher steigen. Stellen Sie sicher, dass Ihre Datenquelle und Pipeline nicht zu Engpässen führen. + **Ändern Sie Ihr Trainingsskript nach Bedarf** Trainingsskripte, die für das Training mit einer GPU geschrieben wurden, müssen für das Training mit mehreren Knoten und mehreren GPUs geändert werden. In den meisten Datenparallelitätsbibliotheken ist eine Änderung des Skripts erforderlich, um Folgendes zu erreichen. + Weisen Sie jeder GPU Stapel von Trainingsdaten zu. + Verwenden Sie einen Optimierer, der Gradientenberechnungen und Parameteraktualisierungen über mehrere hinweg verarbeiten kann. GPUs + Weisen Sie einem bestimmten Host und einer bestimmten GPU die Verantwortung für das Checkpointing zu. ### Wenn Ihr ML-Code tabellarische Datenverarbeitung beinhaltet PySpark ist ein Python-Frontend von Apache Spark, einem Open-Source-Framework für verteilte Datenverarbeitung. PySpark wurde weithin für die verteilte tabellarische Datenverarbeitung für umfangreiche Produktionsworkloads eingesetzt. Wenn Sie tabellarischen Datenverarbeitungscode ausführen möchten, sollten Sie die [SageMaker PySpark Verarbeitungscontainer](https://docs.aws.amazon.com/sagemaker/latest/dg/use-spark-processing-container.html) verwenden und parallel Jobs ausführen. Mithilfe von SageMaker Training and Processing in Amazon SageMaker Studio Classic, das APIs in [Amazon EMR](https://aws.amazon.com/blogs/machine-learning/part-1-create-and-manage-amazon-emr-clusters-from-sagemaker-studio-to-run-interactive-spark-and-ml-workloads/) und [AWS Glue](https://aws.amazon.com/about-aws/whats-new/2022/09/sagemaker-studio-supports-glue-interactive-sessions/?nc1=h_ls)integriert ist, können Sie SageMaker Datenverarbeitungsaufträge auch parallel ausführen. ## Option 3: Schreiben Sie Ihren eigenen benutzerdefinierten verteilten Trainingscode Wenn Sie einen Schulungs- oder Verarbeitungsjob bei SageMaker AI einreichen, starten die SageMaker Trainings- und SageMaker KI-Verarbeitungs-APIs Amazon EC2 EC2-Recheninstanzen. Sie können die Schulungs- und Verarbeitungsumgebung in den Instances anpassen, indem Sie Ihren eigenen Docker-Container ausführen oder zusätzliche Bibliotheken in den AWS verwalteten Containern installieren. Weitere Informationen zu Docker with SageMaker Training finden Sie unter [Anpassen Ihres eigenen Docker-Containers an die Arbeit mit SageMaker KI](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-adapt-your-own.html) und [Erstellen Sie einen Container mit Ihren eigenen Algorithmen](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-create.html) und Modellen. Weitere Informationen zu Docker mit SageMaker KI-Verarbeitung finden Sie unter [Verwenden Sie Ihren eigenen](https://docs.aws.amazon.com/sagemaker/latest/dg/use-your-own-processing-code.html) Verarbeitungscode. Jede SageMaker Trainings-Job-Umgebung enthält eine Konfigurationsdatei unter`/opt/ml/input/config/resourceconfig.json`, und jede SageMaker Verarbeitungs-Job-Umgebung enthält eine ähnliche Konfigurationsdatei unter`/opt/ml/config/resourceconfig.json`. Ihr Code kann diese Datei lesen, um die Kommunikation zwischen den Knoten und `hostnames` zu finden und herzustellen. Weitere Informationen, einschließlich des Schemas der JSON-Datei, finden Sie unter [Distributed Training Configuration](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-dist-training) und [How Amazon SageMaker Processing Configure Your Processing Container](https://docs.aws.amazon.com/sagemaker/latest/dg/build-your-own-processing-container.html#byoc-config). Sie können auch verteilte Computerbibliotheken von Drittanbietern wie [Ray](https://github.com/aws-samples/aws-samples-for-ray/tree/main/sagemaker) oder DeepSpeed in SageMaker AI installieren und verwenden. Sie können SageMaker Training and SageMaker Processing auch verwenden, um benutzerdefinierte verteilte Berechnungen auszuführen, für die keine Kommunikation zwischen Mitarbeitern erforderlich ist. In der Computerliteratur werden diese Aufgaben oft als *peinlich parallel* oder ohne *gemeinsame* Nutzung beschrieben. Beispiele hierfür sind die parallel Verarbeitung von Datendateien, das parallel Training von Modellen in verschiedenen Konfigurationen oder das Ausführen von Batch-Inferenzen für eine Sammlung von Datensätzen. Sie können solche Share-Nothing-Anwendungsfälle trivial mit Amazon AI parallelisieren. SageMaker Wenn Sie einen SageMaker Trainings- oder SageMaker Verarbeitungsjob auf einem Cluster mit mehreren Knoten starten, repliziert SageMaker KI standardmäßig Ihren Trainingscode (in Python oder Docker) und startet ihn auf allen Knoten. Aufgaben, die eine zufällige Verteilung der Eingabedaten über so viele Knoten erfordern, können erleichtert werden, indem `S3DataDistributionType=ShardedByS3Key` die Dateneingabekonfiguration der SageMaker `TrainingInput` KI-API festgelegt wird. ## Option 4: Starten Sie mehrere Jobs parallel oder nacheinander Sie können einen ML-Berechnungsworkflow auch in kleinere parallel oder sequentielle Rechenaufgaben aufteilen, die jeweils durch einen eigenen SageMaker Trainings- oder SageMaker Verarbeitungsjob repräsentiert werden. Das Aufteilen einer Aufgabe in mehrere Jobs kann in den folgenden Situationen oder Aufgaben von Vorteil sein: + Wenn Sie über spezifische [Datenkanäle](https://docs.aws.amazon.com/sagemaker/latest/dg/model-train-storage.html) und Metadateneinträge (wie Hyperparameter, Modellkonfiguration oder Instance-Typen) für jede Unteraufgabe verfügen. + Wenn Sie Wiederholungsschritte auf Unteraufgabenebene implementieren. + Wenn Sie die Konfiguration der Unteraufgaben im Laufe der Workload variieren, z. B. beim Training für steigende Batchgrößen. + Wenn Sie eine ML-Aufgabe ausführen müssen, die länger dauert als die maximal zulässige Trainingszeit für einen einzelnen Trainingsjob (maximal 28 Tage). + Wenn für verschiedene Schritte eines Rechen-Workflows unterschiedliche Instance-Typen erforderlich sind. Verwenden Sie für den speziellen Fall der Hyperparametersuche [SageMaker AI Automated Model Tuning.](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning.html) SageMaker AI Automated Model Tuning ist ein serverloser Orchestrator für die Parametersuche, der in Ihrem Namen mehrere Trainingsjobs startet. Dabei wird eine Suchlogik verwendet, die zufällig, Bayes'sch oder. HyperBand [Darüber hinaus können Sie zur Orchestrierung mehrerer Schulungsaufgaben auch Tools zur Workflow-Orchestrierung wie [SageMaker Pipelines](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-pipelines/index.html), [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/connect-sagemaker.html) und Apache Airflow in Betracht ziehen, die von [Amazon Managed Workflows for Apache Airflow (MWAA) und AI Workflows](https://aws.amazon.com/managed-workflows-for-apache-airflow/) unterstützt werden. SageMaker ](https://sagemaker.readthedocs.io/en/stable/workflows/airflow/using_workflow.html)