PyTorch Uso de los estimadores y SageMaker TensorFlow Amplíe un contenedor Docker prediseñado que contiene SageMaker la biblioteca paralela de modelos distribuidos Cree su propio contenedor de Docker con la biblioteca

Paso 2: Inicie un trabajo de formación con el SDK de SageMaker Python

El SDK de SageMaker Python admite el entrenamiento gestionado de modelos con marcos de aprendizaje automático como TensorFlow y PyTorch. Para iniciar un trabajo de formación con uno de estos marcos, debe definir un SageMaker TensorFlow estimador, un estimador o un SageMaker PyTorch estimador SageMaker genérico para utilizar el guion de entrenamiento modificado y la configuración de paralelismo del modelo.

Temas

PyTorch Uso de los estimadores y SageMaker TensorFlow
Amplíe un contenedor Docker prediseñado que contiene SageMaker la biblioteca paralela de modelos distribuidos
Cree su propio contenedor Docker con la biblioteca paralela de modelos distribuidos SageMaker

PyTorch Uso de los estimadores y SageMaker TensorFlow

Las clases TensorFlow y PyTorch estimador contienen el distribution parámetro, que puede utilizar para especificar los parámetros de configuración para utilizar marcos de entrenamiento distribuidos. La biblioteca paralela de SageMaker modelos usa MPI internamente para datos híbridos y paralelismo de modelos, por lo que debe usar la opción MPI con la biblioteca.

La siguiente plantilla de un PyTorch estimador TensorFlow or muestra cómo configurar el distribution parámetro para utilizar la biblioteca SageMaker paralela de modelos con 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/')

Para habilitar la biblioteca, es necesario pasar los diccionarios de configuración a "mpi" las claves "smdistributed" y a través del distribution argumento de los constructores del SageMaker estimador.

Parámetros de configuración para el paralelismo del modelo SageMaker

Para la clave "smdistributed", pase un diccionario con la clave "modelparallel" y los siguientes diccionarios internos.

nota
No se admite el uso de "modelparallel" y "dataparallel" en un trabajo de entrenamiento.
- "enabled": obligatorio. Para habilitar el paralelismo de modelos, establezca "enabled": True.
- "parameters": obligatorio. Especifique un conjunto de parámetros para SageMaker el paralelismo del modelo.
  - Para obtener una lista completa de los parámetros comunes, consulte Parámetros de smdistributed la documentación del SDK de SageMaker Python.
    
    Para ver TensorFlow, consulte Parámetros TensorFlow específicos.
    
    Para ver PyTorch, consulte PyTorchParámetros específicos.
  - "pipeline_parallel_degree" (o "partitions" en smdistributed-modelparallel<v1.6.0): obligatorio. Entre los parámetros de smdistributed, este parámetro es necesario para especificar en cuántas particiones del modelo se desea dividir.
    
    importante
    Se ha producido un cambio sustancial en el nombre del parámetro. El parámetro "pipeline_parallel_degree" reemplaza el "partitions" desde smdistributed-modelparallel v1.6.0. Para obtener más información, consulte Parámetros comunes para la configuración del paralelismo de SageMaker modelos y Notas de la versión paralela de modelos SageMaker distribuidos en la documentación del SDK de SageMaker Python.
Para la clave "mpi", pase un diccionario que contenga lo siguiente:
- "enabled": obligatorio. Establezca True para iniciar el trabajo de entrenamiento distribuido con MPI.
- "processes_per_host": obligatorio. Especifique el número de procesos que MPI debe lanzar en cada host. En SageMaker, un host es una única instancia de Amazon EC2 ML. El SDK de SageMaker Python mantiene un one-to-one mapeo entre los procesos y las GPU a través del paralelismo de modelos y datos. Esto significa que SageMaker programa cada proceso en una sola GPU independiente y ninguna GPU contiene más de un proceso. Si lo está utilizando PyTorch, debe restringir cada proceso a su propio dispositivotorch.cuda.set_device(smp.local_rank()). Para obtener más información, consulte División automática con PyTorch.
  
  importante
  process_per_host no debe ser mayor que la cantidad de GPU por instancia y normalmente será igual a la cantidad de GPU por instancia.
- "custom_mpi_options" (opcional): utilice esta tecla para pasar cualquier opción MPI personalizada que pueda necesitar. Si no pasa ninguna opción personalizada de MPI a la clave, la opción MPI se establece de forma predeterminada en el siguiente indicador.
```
--mca btl_vader_single_copy_mechanism none
```
  nota
  No es necesario especificar explícitamente este indicador predeterminado en la clave. Si lo especifica explícitamente, el trabajo de entrenamiento distribuido de paralelismo de modelos podría fallar con el siguiente error:
  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.
  sugerencia
  Si lanza un trabajo de entrenamiento utilizando un tipo de instancia habilitado para EFA, como ml.p4d.24xlarge y ml.p3dn.24xlarge, utilice el siguiente indicador para obtener el mejor rendimiento:
  -x FI_EFA_USE_DEVICE_RDMA=1 -x FI_PROVIDER=efa -x RDMAV_FORK_SAFE=1

Para iniciar el trabajo de entrenamiento con el estimador y el script de entrenamiento de su modelo configurado en SageMaker paralelo, ejecute la estimator.fit() función.

Utilice los siguientes recursos para obtener más información sobre el uso de las funciones de paralelismo de modelos en el SDK de Python SageMaker :

Te recomendamos que utilices una instancia de SageMaker notebook si eres un usuario nuevo. Para ver un ejemplo de cómo lanzar un trabajo de formación con una instancia de SageMaker bloc de notas, consulteEjemplos de la biblioteca de paralelismo de SageMaker modelos de Amazon v2.
También puede enviar un trabajo de entrenamiento distribuido desde su máquina utilizando AWS CLI. Para configurarlo AWS CLI en su máquina, consulte Configurar AWS las credenciales y la región para el desarrollo.

Amplíe un contenedor Docker prediseñado que contiene SageMaker la biblioteca paralela de modelos distribuidos

Para ampliar un contenedor prediseñado y usar SageMaker la biblioteca de paralelismo de modelos, debe usar una de las imágenes de AWS Deep Learning Containers (DLC) disponibles para o. PyTorch TensorFlow La biblioteca de paralelismo de SageMaker modelos se incluye en las imágenes del DLC TensorFlow (2.3.0 y versiones posteriores) y (1.6.0 y versiones posteriores) con PyTorch CUDA (). cuxyz Para obtener una lista completa de imágenes de DLC, consulte Imágenes de Deep Learning Containers disponibles en el GitHub repositorio de AWS Deep Learning Containers.

sugerencia

Le recomendamos que utilice la imagen que contiene la última versión de la biblioteca de paralelismo de SageMaker modelos TensorFlow o PyTorch para acceder a la mayoría de las up-to-date versiones de la misma.

Por ejemplo, su Dockerfile debe contener una declaración FROM similar a la siguiente:


# 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 container to determine our user code directory.
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code

Además, al definir un TensorFlow estimador PyTorch o, debe especificarlo para su guion de entry_point entrenamiento. Debe ser el mismo camino identificado con ENV SAGEMAKER_SUBMIT_DIRECTORY en su Dockerfile.

sugerencia

Debe enviar este contenedor de Docker a Amazon Elastic Container Registry (Amazon ECR) y usar el URI de la imagen (image_uri) para definir un estimador para el entrenamiento. SageMaker Para obtener más información, consulte Ampliar una contenedor precompilado.

Cuando termine de alojar el contenedor de Docker y de recuperar el URI de la imagen del contenedor, cree un objeto estimador de la siguiente manera. SageMaker PyTorch En este ejemplo se supone que ya ha definido smp_options y 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/')

Cree su propio contenedor Docker con la biblioteca paralela de modelos distribuidos SageMaker

Para crear su propio contenedor Docker para el entrenamiento y usar la biblioteca paralela de SageMaker modelos, debe incluir las dependencias correctas y los archivos binarios de las bibliotecas SageMaker paralelas distribuidas en su Dockerfile. Esta sección proporciona el conjunto mínimo de bloques de código que debe incluir para preparar adecuadamente un entorno de SageMaker entrenamiento y la biblioteca paralela de modelos en su propio contenedor de Docker.

nota

Esta opción de Docker personalizada con la biblioteca paralela del SageMaker modelo como binario solo está disponible para PyTorch.

Para crear un Dockerfile con el kit de herramientas de SageMaker entrenamiento y la biblioteca paralela de modelos

Comience con una de las imágenes base de NVIDIA CUDA.
```
FROM <cuda-cudnn-base-image>
```
sugerencia
Las imágenes oficiales del AWS Deep Learning Container (DLC) se crean a partir de las imágenes base de NVIDIA CUDA. Te recomendamos que consultes los archivos Dockerfiles oficiales de AWS Deep Learning Container PyTorch para saber qué versiones de las bibliotecas necesitas instalar y cómo configurarlas. Los Dockerfiles oficiales están completos, sometidos a pruebas comparativas y gestionados por los equipos de servicio y de Deep Learning Container. SageMaker En el enlace proporcionado, elige la PyTorch versión que utilizas, elige la carpeta CUDA (cuxyz) y elige el Dockerfile que termina en o. .gpu .sagemaker.gpu
Para establecer un entorno de entrenamiento distribuido, debe instalar software para dispositivos de comunicación y red, como Elastic Fabric Adapter (EFA), NVIDIA Collective Communications Library (NCCL y Open MPI. Según las versiones PyTorch y CUDA que elija, debe instalar versiones compatibles de las bibliotecas.

importante
Dado que la biblioteca paralela de SageMaker modelos requiere la biblioteca paralela de SageMaker datos en los pasos siguientes, le recomendamos encarecidamente que siga las instrucciones que aparecen en Cree su propio contenedor Docker con la biblioteca paralela de datos SageMaker distribuidos para configurar correctamente un entorno de SageMaker formación para la formación distribuida.

Para obtener más información sobre cómo configurar la EFA con NCCL y Open MPI, consulte Introducción a EFA y MPI y Introducción a EFA y NCCL.

Añada los siguientes argumentos para especificar las direcciones URL de los paquetes de formación distribuidos. SageMaker PyTorch La biblioteca paralela de SageMaker modelos requiere que la biblioteca paralela de SageMaker datos utilice el acceso remoto directo a memoria (RDMA) entre nodos.


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

Instale las dependencias que requiera la biblioteca paralela de SageMaker modelos.

Instale la biblioteca 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

Instale la biblioteca RAPIDS Memory Manager. Esto requiere CMake 3.14 o una versión posterior.


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}

Instale la biblioteca paralela de SageMaker modelos.


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

Instale la biblioteca paralela de SageMaker datos.


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

Instale el kit de herramientas sagemaker-training. El kit de herramientas contiene la funcionalidad común necesaria para crear un contenedor compatible con la plataforma de SageMaker entrenamiento y el SDK de SageMaker Python.
```
RUN pip install sagemaker-training
```
Cuando termine de crear el Dockerfile, consulte Adaptación de su propio contenedor de entrenamiento para aprender a crear el contenedor de Docker y alojarlo en Amazon ECR.

sugerencia

Para obtener más información general sobre cómo crear un Dockerfile personalizado para el entrenamiento SageMaker, consulte Use sus propios algoritmos de entrenamiento.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

PyTorch

Puntos de control y ajuste de un modelo con paralelismo de modelos

Paso 2: Inicie un trabajo de formación con el SDK de SageMaker Python

Temas

PyTorch Uso de los estimadores y SageMaker TensorFlow

Parámetros de configuración para el paralelismo del modelo SageMaker

nota

importante

importante

nota

sugerencia

Amplíe un contenedor Docker prediseñado que contiene SageMaker la biblioteca paralela de modelos distribuidos

sugerencia

sugerencia

Cree su propio contenedor Docker con la biblioteca paralela de modelos distribuidos SageMaker

nota

Para crear un Dockerfile con el kit de herramientas de SageMaker entrenamiento y la biblioteca paralela de modelos

sugerencia

importante

sugerencia