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.

# Schritt 2: Starten Sie einen Trainingsjob mithilfe des SageMaker Python-SDK
<a name="model-parallel-sm-sdk"></a>

Das SageMaker Python-SDK unterstützt das verwaltete Training von Modellen mit ML-Frameworks wie TensorFlow und PyTorch. Um einen Trainingsjob mit einem dieser Frameworks zu starten, definieren Sie einen Schätzer, einen SageMaker [ TensorFlow Schätzer ](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_train.html) oder einen SageMaker generischen SageMaker [ PyTorch [ Estimator](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_train.html), ](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_train.html) um das modifizierte Trainingsskript und die Konfiguration der Modellparallelität zu verwenden.

**Topics**
+ [PyTorch Verwenden der und Estimators SageMaker TensorFlow](#model-parallel-using-sagemaker-pysdk)
+ [Erweitern Sie einen Pre-built Docker-Container, der die SageMaker Distributed Model Parallel Library enthält](#model-parallel-customize-container)
+ [Erstellen Sie Ihren eigenen Docker-Container mit der SageMaker Distributed Model Parallel Library](#model-parallel-bring-your-own-container)

## PyTorch Verwenden der und Estimators SageMaker TensorFlow
<a name="model-parallel-using-sagemaker-pysdk"></a>

Die Klassen TensorFlow und PyTorch Estimator enthalten den `distribution` Parameter, mit dem Sie Konfigurationsparameter für die Verwendung verteilter Trainingsframeworks angeben können. Die SageMaker Modellparallelbibliothek verwendet intern MPI für Hybriddaten und Modellparallelität, daher müssen Sie die MPI-Option zusammen mit der Bibliothek verwenden.

Die folgende Vorlage eines TensorFlow PyTorch OR-Schätzers zeigt, wie der `distribution` Parameter für die Verwendung der SageMaker Modellparallelbibliothek mit MPI konfiguriert wird.

```
import sagemaker
from sagemaker.train import ModelTrainer
from sagemaker.train.configs import SourceCode, Compute
from sagemaker.train.distributed import Torchrun
from sagemaker.core.helper.session_helper import get_execution_role
from sagemaker.core import image_uris

training_image = image_uris.retrieve(
    framework="{{tensorflow}}", region=region, version='{{2.6.3}}',
    py_version='{{py38}}', instance_type='{{ml.p3.16xlarge}}',
    image_scope="training"
)

smd_mp_model_trainer = ModelTrainer(
    source_code=SourceCode(entry_script="{{your_training_script.py}}", source_dir="{{location_to_your_script}}"),
    role=get_execution_role(),
    compute=Compute(instance_count=1, instance_type='{{ml.p3.16xlarge}}'),
    training_image=training_image,
    distributed=Torchrun(),
    base_job_name="{{SMD-MP-demo}}",
)

smd_mp_model_trainer.train('{{s3://my_bucket/my_training_data/}}')
```

Um die Bibliothek zu aktivieren, müssen Sie Konfigurationswörterbücher über das `distribution` Argument der `"smdistributed"` Schätzkonstruktoren an die `"mpi"` Schlüssel und übergeben. SageMaker 

**Konfigurationsparameter für Modellparallelität SageMaker**
+ Übergeben Sie für den `"smdistributed"` Schlüssel ein Wörterbuch mit dem `"modelparallel"` Schlüssel und den folgenden inneren Wörterbüchern. 
**Anmerkung**  
Die Verwendung von `"modelparallel"` und `"dataparallel"` in einem Trainingsjob wird nicht unterstützt. 
  + `"enabled"` – Erforderlich. Um die Modellparallelität zu aktivieren, legen Sie `"enabled": True` fest.
  + `"parameters"` – Erforderlich. Geben Sie eine Reihe von Parametern für die SageMaker Modellparallelität an.
    + Eine vollständige Liste gängiger [ Parameter finden Sie unter Parameters for `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters) in der * SageMaker Python-SDK-Dokumentation. *

      Weitere Informationen finden Sie unter [ TensorFlow-specific Parameter](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#tensorflow-specific-parameters). TensorFlow

      Informationen finden Sie unter [ PyTorch-specific Parameter](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#pytorch-specific-parameters). PyTorch
    + `"pipeline_parallel_degree"` (oder `"partitions"` in `smdistributed-modelparallel<v1.6.0`) – Erforderlich. Unter den [Parametern für `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters) ist dieser Parameter erforderlich, um anzugeben, in wie viele Modellpartitionen Sie aufteilen möchten.
**Wichtig**  
Der Parametername wurde grundlegend geändert. Der `"pipeline_parallel_degree"` Parameter ersetzt den `"partitions"` seit `smdistributed-modelparallel` Version 1.6.0. Weitere Informationen finden Sie unter [ Allgemeine Parameter ](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#common-parameters) für die Konfiguration der SageMaker Modellparallelität und Versionshinweise zu [ SageMaker Distributed Model Parallel ](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) in der * SageMaker Python-SDK-Dokumentation. *
+ Übergeben Sie für den `"mpi"` Schlüssel ein Wörterbuch, das Folgendes enthält:
  + `"enabled"` – Erforderlich. `True` ist so eingestellt, dass der verteilte Trainingsjob mit MPI gestartet wird.
  + `"processes_per_host"` – Erforderlich. Geben Sie die Anzahl der Prozesse an, die MPI auf jedem Host starten soll. In SageMaker AI ist ein Host eine einzelne Amazon EC2 ML-Instance. Das SageMaker Python-SDK sorgt für eine Eins-zu-Eins-Zuordnung zwischen Prozessen und GPUs über Modell- und Datenparallelität hinweg. Das bedeutet, dass SageMaker KI jeden Prozess auf einer einzelnen, separaten GPU plant und keine GPU mehr als einen Prozess enthält. Wenn Sie es verwenden PyTorch, müssen Sie jeden Prozess auf sein eigenes Gerät beschränken`torch.cuda.set_device(smp.local_rank())`. Weitere Informationen hierzu finden Sie unter [Automatisiertes Teilen mit PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16).
**Wichtig**  
 `process_per_host`*darf* nicht größer als die Anzahl der GPUs pro Instance sein und entspricht in der Regel der Anzahl der GPUs pro Instance.
  + `"custom_mpi_options"` (optional) – Verwenden Sie diesen Schlüssel, um alle benutzerdefinierten MPI-Optionen zu übergeben, die Sie möglicherweise benötigen. Wenn Sie dem Schlüssel keine benutzerdefinierten MPI-Optionen übergeben, ist die MPI-Option standardmäßig auf das folgende Flag gesetzt.

    ```
    --mca btl_vader_single_copy_mechanism none
    ```
**Anmerkung**  
Sie müssen dieses Standardflag nicht explizit für den Schlüssel angeben. Wenn Sie es explizit angeben, schlägt Ihr paralleles Trainingsjob für verteilte Modelle möglicherweise mit dem folgenden Fehler fehl:  

    ```
    The following MCA parameter has been listed multiple times on the command line: 
    MCA param: btl_vader_single_copy_mechanism MCA parameters can only be listed once 
    on a command line to ensure there is no ambiguity as to its value. 
    Please correct the situation and try again.
    ```
**Tipp**  
Wenn Sie einen Trainingsjob mit einem EFA-enabled Instanztyp wie `ml.p4d.24xlarge` und starten, verwenden Sie das folgende Kennzeichen`ml.p3dn.24xlarge`, um die beste Leistung zu erzielen:  

    ```
    -x FI_EFA_USE_DEVICE_RDMA=1 -x FI_PROVIDER=efa -x RDMAV_FORK_SAFE=1
    ```

Um den Trainingsjob mithilfe des Schätzers und Ihres parallel konfigurierten SageMaker Modell-Trainingsskripts zu starten, führen Sie die `estimator.fit()` Funktion aus.

Verwenden Sie die folgenden Ressourcen, um mehr über die Verwendung der Modellparallelitätsfunktionen im Python-SDK zu erfahren: SageMaker 
+ [ TensorFlow Mit dem Python-SDK SageMaker verwenden ](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/using_tf.html)
+ [ PyTorch Mit dem SageMaker Python-SDK verwenden ](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/using_pytorch.html)
+ Wir empfehlen Ihnen, eine SageMaker Notebook-Instanz zu verwenden, wenn Sie neue Benutzer sind. Ein Beispiel dafür, wie Sie einen Trainingsjob mithilfe einer SageMaker Notebook-Instance starten können, finden Sie unter[Beispiele für die Amazon SageMaker AI-Modellparallelismusbibliothek v2](distributed-model-parallel-v2-examples.md).
+ Sie können auch einen verteilten Trainingsauftrag von Ihrem Rechner aus mit AWS CLIübermitteln. Informationen zur Einrichtung AWS CLI auf Ihrem Computer finden Sie unter [ Einrichten Ihrer AWS Anmeldeinformationen und Region für die Entwicklung](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html).

## Erweitern Sie einen Pre-built Docker-Container, der die SageMaker Distributed Model Parallel Library enthält
<a name="model-parallel-customize-container"></a>

Um einen vorgefertigten Container zu erweitern und die Modellparallelismus-Bibliothek zu verwenden SageMaker, müssen Sie eines der verfügbaren AWS Deep Learning Containers (DLC) -Images für oder verwenden. PyTorch TensorFlow Die SageMaker Modellparallelismus-Bibliothek ist in den DLC-Images TensorFlow (2.3.0 und höher) und (1.6.0 und höher) mit CUDA PyTorch () enthalten. `cuxyz` Eine vollständige Liste der DLC-Images finden Sie unter [ Verfügbare Deep-Learning-Container-Images im Deep-Learning-Container-Repository](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). *AWS GitHub *

**Tipp**  
Wir empfehlen, das Image zu verwenden, das die neueste Version von TensorFlow oder den PyTorch Zugriff auf die aktuelle Version der SageMaker Modellparallelismus-Bibliothek enthält.

Ihr Dockerfile sollte beispielsweise eine `FROM` Anweisung wie die folgende enthalten:

```
# Use the SageMaker DLC image URI for TensorFlow or PyTorch
FROM {{aws-dlc-account-id}}.dkr.ecr.{{aws-region}}.amazonaws.com/{{framework}}-training:{{{framework-version-tag}}}

# Add your dependencies here
RUN {{...}}

ENV PATH="/opt/ml/code:{{${PATH}}}"

# this environment variable is used by the SageMaker AI container to determine our user code directory.
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code
```

Wenn Sie einen PyTorch TensorFlow OR-Schätzer definieren, müssen Sie außerdem Folgendes `entry_point` für Ihr Trainingsskript angeben. Dies sollte derselbe Pfad sein, der in Ihrem Dockerfile mit `ENV SAGEMAKER_SUBMIT_DIRECTORY` angegeben ist. 

**Tipp**  
Sie müssen diesen Docker-Container in die Amazon Elastic Container Registry (Amazon ECR) übertragen und den Image-URI (`image_uri`) verwenden, um einen SageMaker Schätzer für das Training zu definieren. Weitere Informationen finden Sie unter [Einen Pre-built Container erweitern](prebuilt-containers-extend.md). 

Nachdem Sie den Docker-Container gehostet und die Image-URI des Containers abgerufen haben, erstellen Sie wie folgt ein SageMaker `PyTorch` Schätzobjekt. In diesem Beispiel wird davon ausgegangen, dass Sie bereits `smp_options` und `mpi_options` definiert haben. 

```
smd_mp_estimator = Estimator(
    entry_point="{{your_training_script.py}}",
    role=sagemaker.get_execution_role(),
    instance_type='{{ml.p3.16xlarge}}',
    sagemaker_session=sagemaker_session,
    image_uri='{{your_aws_account_id}}.dkr.ecr.{{region}}.amazonaws.com/{{name}}:{{tag}}'
    instance_count={{1}},
    distribution={
        "smdistributed": smp_options,
        "mpi": mpi_options
    },
    base_job_name="{{SMD-MP-demo}}",
)

smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```

## Erstellen Sie Ihren eigenen Docker-Container mit der SageMaker Distributed Model Parallel Library
<a name="model-parallel-bring-your-own-container"></a>

Um Ihren eigenen Docker-Container für das Training zu erstellen und die SageMaker Model-Parallelbibliothek zu verwenden, müssen Sie die richtigen Abhängigkeiten und die Binärdateien der SageMaker verteilten parallelen Bibliotheken in Ihr Dockerfile aufnehmen. Dieser Abschnitt enthält den Mindestsatz an Codeblöcken, die Sie zur ordnungsgemäßen Vorbereitung einer SageMaker Trainingsumgebung und der parallelen Modellbibliothek in Ihrem eigenen Docker-Container benötigen.

**Anmerkung**  
Diese benutzerdefinierte Docker-Option mit der parallelen SageMaker Modellbibliothek als Binärdatei ist nur für verfügbar. PyTorch

**Um ein Dockerfile mit dem SageMaker Training-Toolkit und der parallelen Modellbibliothek zu erstellen**

1. Beginnen Sie mit einem der [NVIDIA CUDA-Basisimages](https://hub.docker.com/r/nvidia/cuda).

   ```
   FROM {{<cuda-cudnn-base-image>}}
   ```
**Tipp**  
Die offiziellen AWS Deep Learning Container (DLC) -Images werden aus den [ NVIDIA CUDA-Basisimages erstellt. ](https://hub.docker.com/r/nvidia/cuda) Wir empfehlen Ihnen, in den [ offiziellen Dockerfiles von AWS Deep Learning Container nachzuschauen, welche Versionen der Bibliotheken Sie installieren müssen und wie Sie sie konfigurieren müssen. PyTorch ](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) Die offiziellen Dockerfiles sind vollständig, auf Benchmarks getestet und werden von den SageMaker Serviceteams von Deep Learning Container verwaltet. Wählen Sie im bereitgestellten Link die PyTorch Version aus, die Sie verwenden, wählen Sie den Ordner CUDA (`cuxyz`) und wählen Sie das Dockerfile, das mit oder endet. `.gpu` `.sagemaker.gpu`

1. Um eine verteilte Trainingsumgebung einzurichten, müssen Sie Software für Kommunikations- und Netzwerkgeräte wie [Elastic Fabric Adapter (EFA)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html), [NVIDIA Collective Communications Library (NCCL)](https://developer.nvidia.com/nccl) und [Open MPI installieren](https://www.open-mpi.org/). Abhängig von der PyTorch ausgewählten CUDA-Version müssen Sie kompatible Versionen der Bibliotheken installieren.
**Wichtig**  
Da die parallele SageMaker Modellbibliothek in den nachfolgenden Schritten die parallele SageMaker Datenbibliothek benötigt, empfehlen wir Ihnen dringend, die Anweisungen unter [Erstellen Sie Ihren eigenen Docker-Container mit der SageMaker AI-Bibliothek für verteilte parallele Daten](data-parallel-bring-your-own-container.md) zu befolgen, um eine SageMaker Trainingsumgebung für verteiltes Training ordnungsgemäß einzurichten.

   Weitere Informationen zur Einrichtung von EFA mit NCCL und Open MPI finden Sie unter [Erste Schritte mit EFA und MPI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html) und [Erste Schritte mit EFA und NCCL.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start-nccl.html)

1. Fügen Sie die folgenden Argumente hinzu, um die URLs der SageMaker verteilten Trainingspakete für anzugeben PyTorch. Die parallele SageMaker Modellbibliothek erfordert, dass die parallele SageMaker Datenbibliothek den knotenübergreifenden Remote Direct Memory Access (RDMA) verwendet.

   ```
   ARG SMD_MODEL_PARALLEL_URL=https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.10.0/build-artifacts/2022-02-21-19-26/smdistributed_modelparallel-1.7.0-cp38-cp38-linux_x86_64.whl
   ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.10.2/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
   ```

1. Installieren Sie Abhängigkeiten, die die parallele SageMaker Modellbibliothek benötigt.

   1. Installieren Sie die [METIS](http://glaros.dtc.umn.edu/gkhome/metis/metis/overview)-Bibliothek.

      ```
      ARG METIS=metis-{{5.1.0}}
      
      RUN rm /etc/apt/sources.list.d/* \
        && wget -nv http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/${METIS}.tar.gz \
        && gunzip -f ${METIS}.tar.gz \
        && tar -xvf ${METIS}.tar \
        && cd ${METIS} \
        && apt-get update \
        && make config shared=1 \
        && make install \
        && cd .. \
        && rm -rf ${METIS}.tar* \
        && rm -rf ${METIS} \
        && rm -rf /var/lib/apt/lists/* \
        && apt-get clean
      ```

   1. Installieren Sie die [RAPIDS Memory Manager-Bibliothek](https://github.com/rapidsai/rmm#rmm-rapids-memory-manager). Dies erfordert [CMake](https://cmake.org/) 3.14 oder höher.

      ```
      ARG RMM_VERSION={{0.15.0}}
      
      RUN  wget -nv https://github.com/rapidsai/rmm/archive/v${RMM_VERSION}.tar.gz \
        && tar -xvf v${RMM_VERSION}.tar.gz \
        && cd rmm-${RMM_VERSION} \
        && INSTALL_PREFIX=/usr/local ./build.sh librmm \
        && cd .. \
        && rm -rf v${RMM_VERSION}.tar* \
        && rm -rf rmm-${RMM_VERSION}
      ```

1. Installieren Sie die parallele SageMaker Modellbibliothek.

   ```
   RUN pip install --no-cache-dir -U ${SMD_MODEL_PARALLEL_URL}
   ```

1. Installieren Sie die parallele SageMaker Datenbibliothek.

   ```
   RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY}
   ```

1. Installieren Sie das [Sagemaker-Training-Toolkit](https://github.com/aws/sagemaker-training-toolkit). Das Toolkit enthält die allgemeinen Funktionen, die erforderlich sind, um einen Container zu erstellen, der mit der SageMaker Trainingsplattform und dem SageMaker Python-SDK kompatibel ist.

   ```
   RUN pip install sagemaker-training
   ```

1. Wenn Sie mit der Erstellung des Dockerfiles fertig sind, erfahren Sie unter [Anpassen Ihres eigenen Trainingscontainers](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html), wie Sie den Docker-Container erstellen und in Amazon ECR hosten.

**Tipp**  
Weitere allgemeine Informationen zum Erstellen eines benutzerdefinierten Dockerfiles für das SageMaker KI-Training finden Sie unter [ Verwenden Sie Ihre eigenen Trainingsalgorithmen. ](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html)