Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Paso 2: Inicie un trabajo de formación con el SDK de SageMaker Python
<a name="model-parallel-sm-sdk"></a>

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](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) un SageMaker [PyTorch estimador](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) SageMaker genérico para utilizar el guion de entrenamiento modificado y la [configuración](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/estimators.html#sagemaker.estimator.Estimator) de paralelismo del modelo.

**Topics**
+ [PyTorch Uso de los estimadores y SageMaker TensorFlow](#model-parallel-using-sagemaker-pysdk)
+ [Amplíe un contenedor Docker prediseñado que contiene SageMaker la biblioteca paralela de modelos distribuidos](#model-parallel-customize-container)
+ [Cree su propio contenedor Docker con la biblioteca paralela de modelos distribuidos SageMaker](#model-parallel-bring-your-own-container)

## PyTorch Uso de los estimadores y SageMaker TensorFlow
<a name="model-parallel-using-sagemaker-pysdk"></a>

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`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters) la *documentación del SDK de SageMaker Python*.

      Para ver TensorFlow, consulte [Parámetros TensorFlow específicos](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#tensorflow-specific-parameters).

      Para ver PyTorch, consulte [PyTorchParámetros específicos](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#pytorch-specific-parameters).
    + `"pipeline_parallel_degree"` (o `"partitions"` en `smdistributed-modelparallel<v1.6.0`): obligatorio. Entre los [parámetros de `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters), 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](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#common-parameters) para la configuración del paralelismo de SageMaker modelos y [Notas de la versión paralela de modelos SageMaker distribuidos en la documentación](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) 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 IA, un host es una única instancia de Amazon EC2 ML. El SDK de SageMaker Python mantiene un one-to-one mapeo entre procesos y paralelismo GPUs entre modelos y datos. Esto significa que la SageMaker IA programa cada proceso en una sola GPU independiente y ninguna GPU contiene más de un proceso. Si lo estás utilizando PyTorch, debes restringir cada proceso a su propio dispositivo`torch.cuda.set_device(smp.local_rank())`. Para obtener más información, consulte [División automática con PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16).
**importante**  
 `process_per_host`no *debe* ser mayor que el número de GPUs por instancia y, por lo general, será igual al número de GPUs 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 :
+ [ TensorFlow Utilízalo con el SDK de SageMaker Python](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/using_tf.html)
+ [ PyTorch Utilízalo con el SDK de SageMaker Python](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/using_pytorch.html)
+ 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, consulte[Ejemplos de la biblioteca de paralelismo de modelos Amazon SageMaker AI v2](distributed-model-parallel-v2-examples.md).
+ 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](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html).

## Amplíe un contenedor Docker prediseñado que contiene SageMaker la biblioteca paralela de modelos distribuidos
<a name="model-parallel-customize-container"></a>

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](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) 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 AI 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](prebuilt-containers-extend.md). 

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
<a name="model-parallel-bring-your-own-container"></a>

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

1. Comience con una de las [imágenes base de NVIDIA CUDA](https://hub.docker.com/r/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](https://hub.docker.com/r/nvidia/cuda) CUDA. Te recomendamos que consultes los [archivos Dockerfiles oficiales de AWS Deep Learning Container PyTorch para](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) 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`

1. 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](https://developer.nvidia.com/nccl) y [Open MPI](https://www.open-mpi.org/). 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 distribuidos de SageMaker IA](data-parallel-bring-your-own-container.md) para configurar correctamente un entorno de SageMaker formación para la formación distribuida.

   Para obtener más información sobre cómo configurar EFA con NCCL y Open MPI, consulte [Introducción a EFA y MPI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html) e [Introducción a EFA y NCCL](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start-nccl.html).

1. Añada los siguientes argumentos para especificar cuáles URLs son los paquetes de formación SageMaker distribuidos 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
   ```

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

   1. Instale la biblioteca [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. Instale la [biblioteca RAPIDS Memory Manager](https://github.com/rapidsai/rmm#rmm-rapids-memory-manager). Esto requiere la versión [CMake](https://cmake.org/)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}
      ```

1. Instale la biblioteca paralela de SageMaker modelos.

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

1. Instale la biblioteca paralela de SageMaker datos.

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

1. Instale el [kit de herramientas sagemaker-training](https://github.com/aws/sagemaker-training-toolkit). 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
   ```

1. Cuando termine de crear el Dockerfile, consulte [Adaptación de su propio contenedor de entrenamiento](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) 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 en SageMaker IA, consulte [Use sus propios](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html) algoritmos de entrenamiento.