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.

# Verteiltes Training mit der SageMaker KI-Bibliothek für verteilte Datenparallelität
<a name="data-parallel-modify-sdp"></a>

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
<a name="data-parallel-modify-sdp-select-framework"></a>

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
<a name="data-parallel-modify-sdp-pt"></a>

[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
<a name="data-parallel-enable-for-ptddp-ptfsdp"></a>

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
<a name="data-parallel-enable-for-deepspeed"></a>

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
<a name="data-parallel-modify-sdp-pt-lightning"></a>

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
<a name="smddp-pt-201-lightning-210"></a>

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)
<a name="data-parallel-modify-sdp-tf2"></a>

**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
<a name="data-parallel-use-api"></a>

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
<a name="data-parallel-framework-estimator"></a>

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
<a name="data-parallel-use-python-skd-api"></a>

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.<aws-region>.amazonaws.com/pytorch-training:<image-tag>

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
<a name="data-parallel-bring-your-own-container"></a>

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)