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 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)