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. # 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.