Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Étape 2 : Lancer un job de formation à l'aide du SDK SageMaker Python
<a name="model-parallel-sm-sdk"></a>

Le SDK SageMaker Python prend en charge l'entraînement géré des modèles avec des frameworks ML tels que TensorFlow et PyTorch. Pour lancer une tâche de formation à l'aide de l'un de ces frameworks, vous devez définir un SageMaker [TensorFlow estimateur, un estimateur ou](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) un SageMaker [PyTorch estimateur](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) SageMaker générique pour utiliser le script de formation modifié et [modéliser](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/estimators.html#sagemaker.estimator.Estimator) la configuration du parallélisme.

**Topics**
+ [Utilisation des SageMaker TensorFlow PyTorch estimateurs et](#model-parallel-using-sagemaker-pysdk)
+ [Étendre un conteneur Docker prédéfini qui contient SageMaker la bibliothèque parallèle de modèles distribués](#model-parallel-customize-container)
+ [Créez votre propre conteneur Docker avec la bibliothèque parallèle de modèles SageMaker distribués](#model-parallel-bring-your-own-container)

## Utilisation des SageMaker TensorFlow PyTorch estimateurs et
<a name="model-parallel-using-sagemaker-pysdk"></a>

Les classes TensorFlow et PyTorch estimator contiennent le `distribution` paramètre, que vous pouvez utiliser pour spécifier des paramètres de configuration pour l'utilisation de frameworks d'apprentissage distribués. La bibliothèque SageMaker model parallel utilise en interne MPI pour les données hybrides et le parallélisme des modèles. Vous devez donc utiliser l'option MPI avec la bibliothèque.

Le modèle d' PyTorch estimateur TensorFlow or suivant montre comment configurer le `distribution` paramètre d'utilisation de la bibliothèque model parallel SageMaker avec MPI.

------
#### [ Using the SageMaker TensorFlow estimator ]

```
import sagemaker
from sagemaker.tensorflow import TensorFlow

smp_options = {
    "enabled":True,              # Required
    "parameters": {
        "partitions": 2,         # Required
        "microbatches": 4,
        "placement_strategy": "spread",
        "pipeline": "interleaved",
        "optimize": "speed",
        "horovod": True,         # Use this for hybrid model and data parallelism
    }
}

mpi_options = {
    "enabled" : True,            # Required
    "processes_per_host" : 8,    # Required
    # "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none"
}

smd_mp_estimator = TensorFlow(
    entry_point="{{your_training_script.py}}", # Specify your train script
    source_dir="{{location_to_your_script}}",
    role=sagemaker.get_execution_role(),
    instance_count=1,
    instance_type='{{ml.p3.16xlarge}}',
    framework_version='{{2.6.3}}',
    py_version='{{py38}}',
    distribution={
        "smdistributed": {"modelparallel": smp_options},
        "mpi": mpi_options
    },
    base_job_name="{{SMD-MP-demo}}",
)

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

------
#### [ Using the SageMaker PyTorch estimator ]

```
import sagemaker
from sagemaker.pytorch import PyTorch

smp_options = {
    "enabled":True,
    "parameters": {                        # Required
        "pipeline_parallel_degree": 2,     # Required
        "microbatches": 4,
        "placement_strategy": "spread",
        "pipeline": "interleaved",
        "optimize": "speed",
        "ddp": True,
    }
}

mpi_options = {
    "enabled" : True,                      # Required
    "processes_per_host" : 8,              # Required
    # "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none"
}

smd_mp_estimator = PyTorch(
    entry_point="{{your_training_script.py}}", # Specify your train script
    source_dir="{{location_to_your_script}}",
    role=sagemaker.get_execution_role(),
    instance_count=1,
    instance_type='{{ml.p3.16xlarge}}',
    framework_version='{{1.13.1}}',
    py_version='{{py38}}',
    distribution={
        "smdistributed": {"modelparallel": smp_options},
        "mpi": mpi_options
    },
    base_job_name="{{SMD-MP-demo}}",
)

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

------

Pour activer la bibliothèque, vous devez transmettre des dictionnaires de configuration aux `"mpi"` clés `"smdistributed"` et via l'`distribution`argument des constructeurs de l' SageMaker estimateur.

**Paramètres de configuration pour le parallélisme SageMaker du modèle**
+ Pour la clé `"smdistributed"`, transmettez un dictionnaire avec la clé `"modelparallel"` et les dictionnaires internes suivants. 
**Note**  
L'utilisation de `"modelparallel"` et `"dataparallel"` dans la même tâche d'entraînement n'est pas pris en charge. 
  + `"enabled"` : obligatoire. Pour activer le parallélisme des modèles, définissez `"enabled": True`.
  + `"parameters"` : obligatoire. Spécifiez un ensemble de paramètres pour le parallélisme SageMaker du modèle.
    + Pour une liste complète des paramètres courants, consultez la section [Paramètres pour `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters) dans la *documentation du SDK SageMaker Python*.

      Pour TensorFlow, voir [Paramètres TensorFlow spécifiques](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#tensorflow-specific-parameters).

      Pour PyTorch, voir [Paramètres PyTorch spécifiques](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#pytorch-specific-parameters).
    + `"pipeline_parallel_degree"` (ou `"partitions"` dans `smdistributed-modelparallel<v1.6.0`) — obligatoire. Parmi les [paramètres de `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters), ce paramètre est nécessaire pour spécifier le nombre de partitions de modèle dans lesquelles vous souhaitez effectuer la répartition.
**Important**  
Il y a une modification avec rupture dans le nom du paramètre. Le paramètre `"pipeline_parallel_degree"` remplace les `"partitions"` depuis la v1.6.0 de `smdistributed-modelparallel`. Pour plus d'informations, consultez la section [Paramètres communs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#common-parameters) pour la configuration SageMaker du parallélisme des modèles et les [notes de version de 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) dans la documentation du *SDK SageMaker Python*.
+ Pour la clé `"mpi"`, transmettez un dictionnaire contenant les éléments suivants :
  + `"enabled"` : obligatoire. Permet à `True` de lancer la tâche d'entraînement distribuée avec MPI.
  + `"processes_per_host"` : obligatoire. Spécifiez le nombre de processus que la MPI doit lancer sur chaque hôte. Dans l' SageMaker IA, un hôte est une instance Amazon EC2 ML unique. Le SDK SageMaker Python assure un one-to-one mappage entre les processus et GPUs entre le parallélisme des modèles et des données. Cela signifie que l' SageMaker IA planifie chaque processus sur un seul GPU distinct et qu'aucun GPU ne contient plus d'un processus. Si vous utilisez PyTorch, vous devez limiter chaque processus à son propre appareil`torch.cuda.set_device(smp.local_rank())`. Pour en savoir plus, veuillez consulter la section [Fractionnement automatique avec PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16).
**Important**  
 `process_per_host`ne *doit* pas être supérieur au nombre de GPUs par instance et sera généralement égal au nombre de GPUs par instance.
  + `"custom_mpi_options"` (obligatoire) : utilisez cette clé pour transmettre toutes les options MPI personnalisées dont vous pouvez avoir besoin. Si vous ne transmettez aucune option personnalisée MPI à la clé, l'option MPI est définie par défaut sur l'indicateur suivant.

    ```
    --mca btl_vader_single_copy_mechanism none
    ```
**Note**  
Vous n'avez pas besoin de spécifier explicitement cet indicateur par défaut à la clé. Si vous le spécifiez explicitement, votre tâche d'entraînement parallèle de modèle distribué peut échouer avec l'erreur suivante :  

    ```
    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.
    ```
**Astuce**  
Si vous lancez une tâche d'entraînement à l'aide d'un type d'instance compatible EFA, tel que `ml.p4d.24xlarge` et `ml.p3dn.24xlarge`, utilisez l'indicateur suivant pour de meilleures performances :  

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

Pour lancer la tâche d'entraînement à l'aide de l'estimateur et du script d'entraînement configuré en SageMaker parallèle de votre modèle, exécutez la `estimator.fit()` fonction.

Utilisez les ressources suivantes pour en savoir plus sur l'utilisation des fonctionnalités de parallélisme des modèles dans le SDK SageMaker Python :
+ [Utilisation TensorFlow avec le SDK SageMaker Python](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/using_tf.html)
+ [Utilisation PyTorch avec le SDK SageMaker Python](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/using_pytorch.html)
+ Nous vous recommandons d'utiliser une instance de SageMaker bloc-notes si vous êtes de nouveaux utilisateurs. Pour voir un exemple de la façon dont vous pouvez lancer une tâche de formation à l'aide d'une instance de SageMaker bloc-notes, consultez[Exemples de bibliothèque de parallélisme de modèles Amazon SageMaker AI v2](distributed-model-parallel-v2-examples.md).
+ Vous pouvez également envoyer une tâche d'entraînement distribué à partir de votre machine en utilisant AWS CLI. Pour effectuer AWS CLI la configuration sur votre machine, consultez les sections [Configurer vos AWS informations d'identification et Région pour le développement](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html).

## Étendre un conteneur Docker prédéfini qui contient SageMaker la bibliothèque parallèle de modèles distribués
<a name="model-parallel-customize-container"></a>

Pour étendre un conteneur prédéfini et utiliser SageMaker sa bibliothèque de modèles de parallélisme, vous devez utiliser l'une des images AWS Deep Learning Containers (DLC) disponibles pour ou. PyTorch TensorFlow La bibliothèque de parallélisme des SageMaker modèles est incluse dans les images DLC TensorFlow (2.3.0 et versions ultérieures) et PyTorch (1.6.0 et versions ultérieures) avec CUDA (). `cuxyz` Pour obtenir la liste complète des images des DLC, consultez la section Images [Deep Learning Containers disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) dans le * GitHub référentiel AWS Deep Learning Containers*.

**Astuce**  
Nous vous recommandons d'utiliser l'image contenant la dernière version TensorFlow ou d'accéder PyTorch à la version la plus récente de la up-to-date bibliothèque de parallélisme de SageMaker modèles.

Par exemple, votre Dockerfile devrait contenir une instruction `FROM` similaire à la suivante :

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

En outre, lorsque vous définissez un TensorFlow estimateur PyTorch or, vous devez le spécifier `entry_point` pour votre script d'entraînement. Il doit être identique au chemin d'accès que celui identifié avec `ENV SAGEMAKER_SUBMIT_DIRECTORY`dans votre Dockerfile. 

**Astuce**  
Vous devez transférer ce conteneur Docker vers Amazon Elastic Container Registry (Amazon ECR) et utiliser l'URI de l'image (`image_uri`) pour définir un estimateur pour l'entraînement. SageMaker Pour de plus amples informations, veuillez consulter [Extension d’un conteneur préconçu](prebuilt-containers-extend.md). 

Une fois que vous avez fini d'héberger le conteneur Docker et d'avoir récupéré l'URI de l'image du conteneur, créez un objet SageMaker `PyTorch` estimateur comme suit. Cet exemple suppose que vous avez déjà défini les `smp_options` et `mpi_options`. 

```
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/')
```

## Créez votre propre conteneur Docker avec la bibliothèque parallèle de modèles SageMaker distribués
<a name="model-parallel-bring-your-own-container"></a>

Pour créer votre propre conteneur Docker à des fins de formation et utiliser la bibliothèque SageMaker model parallel, vous devez inclure les dépendances correctes et les fichiers binaires des bibliothèques parallèles SageMaker distribuées dans votre Dockerfile. Cette section fournit l'ensemble minimal de blocs de code que vous devez inclure pour préparer correctement un environnement de SageMaker formation et la bibliothèque model parallel dans votre propre conteneur Docker.

**Note**  
Cette option Docker personnalisée avec la bibliothèque SageMaker model parallel sous forme de binaire n'est disponible que pour PyTorch.

**Pour créer un Dockerfile avec le kit de SageMaker formation et la bibliothèque model parallel**

1. Commencez par l'une des [images de base NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda).

   ```
   FROM {{<cuda-cudnn-base-image>}}
   ```
**Astuce**  
Les images officielles du AWS Deep Learning Container (DLC) sont créées à partir des images de [base NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). Nous vous recommandons de consulter les [Dockerfiles officiels de AWS Deep Learning PyTorch Container pour](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) savoir quelles versions des bibliothèques vous devez installer et comment les configurer. Les Dockerfiles officiels sont complets, testés et gérés par les équipes de service et de SageMaker Deep Learning Container. Dans le lien fourni, choisissez la PyTorch version que vous utilisez, choisissez le dossier CUDA (`cuxyz`) et choisissez le Dockerfile se terminant par ou. `.gpu` `.sagemaker.gpu`

1. Pour configurer un environnement d'entraînement distribué, vous devez installer des logiciels de communication et de mise en réseau, tels que [Elastic Fabric Adapter (EFA)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html), [NVIDIA Collective Communications Library (NCCL)](https://developer.nvidia.com/nccl) et [Open MPI](https://www.open-mpi.org/). Selon les versions PyTorch et CUDA que vous choisissez, vous devez installer des versions compatibles des bibliothèques.
**Important**  
Étant donné que la bibliothèque SageMaker model parallel nécessite la bibliothèque SageMaker data parallel dans les étapes suivantes, nous vous recommandons vivement de suivre les instructions de la section [Créez votre propre conteneur Docker avec la bibliothèque SageMaker AI distributed data parallel library](data-parallel-bring-your-own-container.md) pour configurer correctement un environnement de SageMaker formation pour la formation distribuée.

   Pour plus d'informations sur la configuration de l'EPT avec NCCL et Open MPI, consultez les rubriques [Get started with EFA and MPI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html) (Démarrer avec EFA et MPI) et [Get started with EFA and NCCL](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start-nccl.html) (Démarrer avec EFA et NCCL).

1. Ajoutez les arguments suivants pour spécifier les modules URLs de formation SageMaker distribués pour PyTorch. La bibliothèque SageMaker model parallel nécessite que la bibliothèque SageMaker data parallel utilise le Remote Direct Memory Access (RDMA) entre nœuds.

   ```
   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. Installez les dépendances requises par la bibliothèque SageMaker model parallel.

   1. Installez la bibliothèque [METIS](http://glaros.dtc.umn.edu/gkhome/metis/metis/overview).

      ```
      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. Installez la [bibliothèque du gestionnaire de mémoire RAPIDS](https://github.com/rapidsai/rmm#rmm-rapids-memory-manager). Cela nécessite la version [CMake](https://cmake.org/)3.14 ou une version ultérieure.

      ```
      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. Installez la bibliothèque SageMaker model parallel.

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

1. Installez la bibliothèque SageMaker Data Parallel.

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

1. Installez la [boîte à outils d'entraînement Sagemaker](https://github.com/aws/sagemaker-training-toolkit). La boîte à outils contient les fonctionnalités communes nécessaires pour créer un conteneur compatible avec la plateforme de SageMaker formation et le SDK SageMaker Python.

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

1. Une fois la création du Dockerfile terminée, consultez la section [Adapting Your Own Training Container](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) (Adapter votre propre conteneur d'entraînement) pour découvrir comment créer le conteneur Docker et l'héberger dans Amazon ECR.

**Astuce**  
Pour des informations plus générales sur la création d'un Dockerfile personnalisé pour l'entraînement à l' SageMaker IA, consultez [Utiliser vos propres algorithmes d'entraînement](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html).