Utilisation des estimateurs TensorFlow et PyTorch de SageMaker Extension d'un conteneur Docker préconçu contenant la bibliothèque de parallélisme de modèles distribués de SageMaker Création de votre propre conteneur Docker avec la bibliothèque

Étape 2 : lancer une tâche d'entraînement à l'aide du kit SDK Python SageMaker

Le kit SDK Python de SageMaker prend en charge l'entraînement géré des modèles avec des frameworks ML tels que TensorFlow et PyTorch. Pour lancer un travail d'entraînement à l'aide de l'un de ces cadres, vous définissez un estimateur SageMaker TensorFlow, un estimateur SageMaker PyTorch ou un estimateur SageMaker générique pour utiliser le script d'entraînement modifié et la configuration du parallélisme des modèles.

Rubriques

Utilisation des estimateurs TensorFlow et PyTorch de SageMaker
Extension d'un conteneur Docker préconçu contenant la bibliothèque de parallélisme de modèles distribués de SageMaker
Création de votre propre conteneur Docker avec la bibliothèque de modèles parallèles distribuées SageMaker

Utilisation des estimateurs TensorFlow et PyTorch de SageMaker

Les classes d'estimateur TensorFlow et PyTorch contiennent le paramètre distribution, que vous pouvez utiliser pour spécifier les paramètres de configuration pour l'utilisation des cadres d'entraînement distribués. La bibliothèque parallèle de modèles SageMaker utilise MPI en interne pour le parallélisme hybride des données et des modèles. Vous devez donc utiliser l'option MPI avec la bibliothèque.

Le modèle suivant d'un estimateur TensorFlow ou PyTorch montre comment configurer le paramètre distribution pour utiliser la bibliothèque parallèle de modèles 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 passer les dictionnaires de configuration aux clés "smdistributed" et "mpi" via l'argument des constructeurs de l'estimateur SageMaker.

Paramètres de configuration du parallélisme des modèles SageMaker

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 des modèles SageMaker.
  - Pour obtenir une liste complète des paramètres courants, consultez la rubrique Parameters for smdistributed (Paramètres pour smdistributed) dans la documentation du kit SDK Python de SageMaker.
    
    Pour TensorFlow, reportez-vous à la section TensorFlow-specific Parameters (Paramètres spécifiques à TensorFlow).
    
    Pour PyTorch, consultez PyTorch-specific Parameters (Paramètres spécifiques à PyTorch).
  - "pipeline_parallel_degree" (ou "partitions" dans smdistributed-modelparallel<v1.6.0) — obligatoire. Parmi les paramètres de smdistributed, 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, reportez-vous à la section Common Parameters (Paramètres communs) pour la configuration du parallélisme des modèles SageMaker et aux Notes de mise à jour des modèles distribués parallèles de SageMaker dans la documentation du kit 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 SageMaker AI, un hôte est une instance unique de machine learning Amazon EC2. Le kit SDK Python SageMaker gère un mappage biunivoque entre les processus et les GPU via le parallélisme des modèles et des données. Autrement dit, SageMaker AI planifie chaque processus sur un GPU unique distinct, et chaque GPU ne contient qu’un seul processus. Si vous utilisez PyTorch, vous devez restreindre chaque processus à son propre périphérique via torch.cuda.set_device(smp.local_rank()). Pour en savoir plus, consultez Fractionnement automatisé avec PyTorch.
  
  Important
  process_per_host ne doit pas être supérieur au nombre de GPU par instance. Généralement, il est égal à ce nombre.
- "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é pour le parallélisme des modèles SageMaker, exécutez la fonction estimator.fit().

Utilisez les ressources suivantes pour en savoir plus sur l'utilisation des fonctions de parallélisme des modèles dans le kit SDK SageMaker Python :

Nous vous recommandons d'utiliser une instance de bloc-notes SageMaker si vous êtes un nouvel utilisateur. Pour voir comment lancer une tâche d'entraînement à l'aide d'une instance de bloc-notes SageMaker, consultez Exemples de la bibliothèque Amazon SageMaker AI de parallélisme des modèles v2.
Vous pouvez également envoyer une tâche d'entraînement distribué à partir de votre machine en utilisant AWS CLI. Pour configurer AWS CLI sur votre machine, consultez la rubrique relative à la configuration de vos informations d’identification AWS et de la région pour le développement.

Extension d'un conteneur Docker préconçu contenant la bibliothèque de parallélisme de modèles distribués de SageMaker

Pour étendre un conteneur préconçu et utiliser la bibliothèque de parallélisme de modèles SageMaker, vous devez utiliser l'une des images AWS Deep Learning Containers (DLC) disponibles pour PyTorch ou TensorFlow. La bibliothèque de parallélisme de modèles SageMaker est incluse dans les images DLC de TensorFlow (versions 2.3.0 et ultérieures) et de PyTorch (versions 1.6.0 et ultérieures) avec CUDA (cuxyz). Pour obtenir une liste complète des images DLC, consultez la section Available Deep Learning Containers Images (Images disponibles des conteneurs de deep learning) dans le référentiel GitHub de Deep Learning Containers AWS.

Astuce

Nous vous recommandons d'utiliser l'image qui contient la dernière version de TensorFlow ou PyTorch pour accéder à la version la plus récente de la bibliothèque de parallélisme de modèles SageMaker.

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 estimateur PyTorch ou TensorFlow, vous devez spécifier le entry_point pour votre script d'entraînement. Il doit être identique au chemin d'accès que celui identifié avec ENV SAGEMAKER_SUBMIT_DIRECTORYdans votre Dockerfile.

Astuce

Vous devez envoyer ce conteneur Docker vers Amazon Elastic Container Registry (Amazon ECR) et utiliser l'URI de l'image (image_uri) pour définir un estimateur SageMaker pour l'entraînement. Pour plus d’informations, consultez Extension d’un conteneur préconçu.

Après avoir fini d'héberger le conteneur Docker et de récupérer l'URI de l'image du conteneur, créez un objet estimateur PyTorch SageMaker 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éation de votre propre conteneur Docker avec la bibliothèque de modèles parallèles distribuées SageMaker

Pour créer votre propre conteneur Docker pour l'entraînement et utiliser la bibliothèque parallèle de modèles SageMaker, vous devez inclure les bonnes dépendances et les fichiers binaires des bibliothèques parallèles distribuées SageMaker dans votre Dockerfile. Cette section fournit le jeu minimal de blocs de code que vous devez inclure pour préparer correctement un environnement d'entraînement SageMaker et la bibliothèque parallèle de modèles dans votre propre conteneur Docker.

Note

Cette option Docker personnalisée avec la bibliothèque parallèle de modèles SageMaker sous forme de binaire est disponible uniquement pour PyTorch.

Pour créer un Dockerfile avec la boîte à outils d'entraînement de SageMaker et la bibliothèque de modèles parallèles.

Commencez par l'une des images de base NVIDIA CUDA.
```
FROM <cuda-cudnn-base-image>
```
Astuce
Les images officielles Deep Learning Container (DLC) de AWS sont créées à partir des images de base NVIDIA CUDA. Nous vous recommandons de consulter les Dockerfiles officiels de AWS Deep Learning Container for PyTorch pour trouver les versions des bibliothèques que vous devez installer et comment les configurer. Les Dockerfiles officiels sont complets, ont subi des tests de référence et sont gérés par les équipes des services SageMaker et Deep Learning Container. Dans le lien fourni, sélectionnez la version de PyTorch que vous utilisez, sélectionnez le dossier CUDA (cuxyz), et sélectionnez le Dockerfile se terminant par .gpu ou .sagemaker.gpu.
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), NVIDIA Collective Communications Library (NCCL) et Open MPI. En fonction des versions de PyTorch et de CUDA que vous sélectionnez, vous devez installer des versions compatibles des bibliothèques.

Important
Étant donné que la bibliothèque parallèle de modèles SageMaker nécessite la bibliothèque parallèle de données SageMaker dans les étapes suivantes, nous vous recommandons vivement de suivre les instructions de Création de votre propre conteneur Docker avec la bibliothèque SageMaker AI de parallélisme distribué des données pour configurer correctement un environnement d'entraînement SageMaker pour l'entraînement distribué.

Pour plus d'informations sur la configuration de l'EPT avec NCCL et Open MPI, consultez les rubriques Get started with EFA and MPI (Démarrer avec EFA et MPI) et Get started with EFA and NCCL (Démarrer avec EFA et NCCL).

Ajoutez les arguments suivants pour spécifier les URL des packages d'entraînement distribués par SageMaker pour PyTorch. La bibliothèque parallèle de modèles SageMaker a besoin de la bibliothèque parallèle de données SageMaker pour utiliser l'accès direct à la mémoire à distance (RDMA) entre les 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

Installez les dépendances dont la bibliothèque parallèle de modèles SageMaker a besoin.

Installez la bibliothèque METIS.


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

Installez la bibliothèque du gestionnaire de mémoire RAPIDS. Il vous faut pour cela CMake 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}

Installez la bibliothèque parallèle de modèles SageMaker.
```
RUN pip install --no-cache-dir -U ${SMD_MODEL_PARALLEL_URL}
```

Installez la bibliothèque parallèle de données SageMaker.


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

Installez la boîte à outils d'entraînement Sagemaker. La boîte à outils contient les fonctionnalités communes nécessaires à la création d'un conteneur compatible avec la plateforme d'entraînement SageMaker et le kit SDK SageMaker Python.
```
RUN pip install sagemaker-training
```
Une fois la création du Dockerfile terminée, consultez la section Adapting Your Own Training Container (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 plus d’informations générales sur la création d’un Dockerfile personnalisé pour l’entraînement dans SageMaker AI, consultez Utilisation de vos propres algorithmes d’entraînement.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

PyTorch

Point de contrôle et optimisation d'un modèle grâce au parallélisme de modèles

Étape 2 : lancer une tâche d'entraînement à l'aide du kit SDK Python SageMaker

Rubriques

Utilisation des estimateurs TensorFlow et PyTorch de SageMaker

Paramètres de configuration du parallélisme des modèles SageMaker

Note

Important

Important

Note

Astuce

Extension d'un conteneur Docker préconçu contenant la bibliothèque de parallélisme de modèles distribués de SageMaker

Astuce

Astuce

Création de votre propre conteneur Docker avec la bibliothèque de modèles parallèles distribuées SageMaker

Note

Pour créer un Dockerfile avec la boîte à outils d'entraînement de SageMaker et la bibliothèque de modèles parallèles.

Astuce

Important

Astuce