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.

# Lanzamiento de trabajos de formación distribuidos con SMDDP mediante el SDK de Python SageMaker
<a name="data-parallel-use-api"></a>

Para ejecutar un trabajo de entrenamiento distribuido con su script adaptado[Adaptación del script de entrenamiento para utilizar las operaciones colectivas de SMDDP](data-parallel-modify-sdp-select-framework.md), utilice el marco del SDK de SageMaker Python o estimadores genéricos especificando el script de entrenamiento preparado como un script de punto de entrada y la configuración de entrenamiento distribuida.

En esta página, se explica cómo utilizar el [SDK de Python para SageMaker IA](https://sagemaker.readthedocs.io/en/stable/api/training/index.html) de dos maneras.
+ Si quieres lograr una rápida adopción de tu trabajo de formación distribuida en SageMaker IA, configura una clase de SageMaker IA [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch)o un estimador de [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)marcos. El estimador del marco recoge el guion de entrenamiento y automáticamente coincide con el URI de imagen correcto de los Deep Learning Containers (DLC) [prediseñados PyTorch o de los TensorFlow Deep Learning Containers (DLC)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only), dado el valor especificado para el parámetro. `framework_version`
+ Si desea ampliar uno de los contenedores prediseñados o crear un contenedor personalizado para crear su propio entorno de aprendizaje automático con SageMaker IA, utilice la `Estimator` clase genérica SageMaker AI y especifique el URI de imagen del contenedor Docker personalizado alojado en su Amazon Elastic Container Registry (Amazon ECR).

Sus conjuntos de datos de entrenamiento deben almacenarse en Amazon S3 o [Amazon FSx for Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) Región de AWS en los que vaya a iniciar su trabajo de entrenamiento. Si utilizas los cuadernos de Jupyter, deberías tener una instancia de bloc de notas o una SageMaker aplicación de SageMaker Studio Classic ejecutándose en el mismo. Región de AWS Para obtener más información sobre cómo almacenar los datos de entrenamiento, consulta la documentación de [entradas de datos del SDK de SageMaker Python](https://sagemaker.readthedocs.io/en/stable/overview.html#use-file-systems-as-training-input). 

**sugerencia**  
Le recomendamos que utilice Amazon FSx for Lustre en lugar de Amazon S3 para mejorar el rendimiento del entrenamiento. Amazon FSx tiene un rendimiento más alto y una latencia más baja que Amazon S3.

**sugerencia**  
Para ejecutar correctamente entrenamiento distribuido en los tipos de instancia habilitadas para EFA, debe habilitar tráfico entre las instancias mediante la configuración del grupo de seguridad de su VPC de forma que permita que todo el tráfico entrante y saliente hacia y desde el propio grupo de seguridad. Para obtener información sobre cómo configurar reglas de grupo de seguridad, consulte [Paso 1: preparar un grupo de seguridad habilitado para EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) en la *Guía del usuario de Amazon EC2*.

Seleccione uno de los siguientes temas para obtener instrucciones sobre cómo ejecutar un trabajo de entrenamiento distribuido de su script de entrenamiento. Tras iniciar un trabajo de formación, puede supervisar la utilización del sistema y el rendimiento del modelo mediante [Amazon SageMaker Debugger](train-debugger.md) Amazon CloudWatch.

Siga las instrucciones de los siguientes temas para obtener más información sobre los detalles técnicos, pero también le recomendamos que pruebe [Ejemplos de bibliotecas de paralelismo de datos de Amazon SageMaker AI](distributed-data-parallel-v2-examples.md) para empezar.

**Topics**
+ [Usa los estimadores del PyTorch framework del SDK de Python SageMaker](data-parallel-framework-estimator.md)
+ [Utilice el estimador genérico de SageMaker IA para ampliar los contenedores de DLC prediseñados](data-parallel-use-python-skd-api.md)
+ [Cree su propio contenedor Docker con la biblioteca paralela de datos distribuidos de SageMaker IA](data-parallel-bring-your-own-container.md)

# Usa los estimadores del PyTorch framework del SDK de Python SageMaker
<a name="data-parallel-framework-estimator"></a>

Puede lanzar un entrenamiento distribuido añadiendo el `distribution` argumento a los estimadores del marco de SageMaker IA, [https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch)o. [https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) Para obtener más información, elige uno de los marcos compatibles con la biblioteca de paralelismo de datos distribuidos de SageMaker IA (SMDDP) de entre las siguientes selecciones.

------
#### [ PyTorch ]

Las siguientes opciones de inicio están disponibles para iniciar la formación distribuida. PyTorch 
+ `pytorchddp`— Esta opción ejecuta `mpirun` y configura las variables de entorno necesarias para ejecutar la formación PyTorch distribuida en SageMaker IA. Para usar esta opción, pase el siguiente diccionario al parámetro `distribution`.

  ```
  { "pytorchddp": { "enabled": True } }
  ```
+ `torch_distributed`— Esta opción ejecuta `torchrun` y configura las variables de entorno necesarias para ejecutar la formación PyTorch distribuida en SageMaker IA. Para usar esta opción, pase el siguiente diccionario al parámetro `distribution`.

  ```
  { "torch_distributed": { "enabled": True } }
  ```
+ `smdistributed`— Esta opción también funciona`mpirun`, pero con ella `smddprun` se configuran las variables de entorno necesarias para ejecutar la formación PyTorch distribuida en SageMaker IA.

  ```
  { "smdistributed": { "dataparallel": { "enabled": True } } }
  ```

Si opta por sustituir `AllGather` de NCCL por `AllGather` de SMDDP, puede utilizar las tres opciones. Seleccione una opción que se adapte a su caso de uso.

Si opta por sustituir `AllReduce` de NCCL por `AllReduce` de SMDDP, debe elegir una de las opciones basadas en `mpirun`: `smdistributed` o `pytorchddp`. También puede agregar opciones de MPI adicionales de la siguiente manera.

```
{ 
    "pytorchddp": {
        "enabled": True, 
        "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION"
    }
}
```

```
{ 
    "smdistributed": { 
        "dataparallel": {
            "enabled": True, 
            "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION"
        }
    }
}
```

El siguiente ejemplo de código muestra la estructura básica de un PyTorch estimador con opciones de entrenamiento distribuidas.

```
from sagemaker.pytorch import PyTorch

pt_estimator = PyTorch(
    base_job_name="training_job_name_prefix",
    source_dir="subdirectory-to-your-code",
    entry_point="adapted-training-script.py",
    role="SageMakerRole",
    py_version="py310",
    framework_version="2.0.1",

    # For running a multi-node distributed training job, specify a value greater than 1
    # Example: 2,3,4,..8
    instance_count=2,

    # Instance types supported by the SageMaker AI data parallel library: 
    # ml.p4d.24xlarge, ml.p4de.24xlarge
    instance_type="ml.p4d.24xlarge",

    # Activate distributed training with SMDDP
    distribution={ "pytorchddp": { "enabled": True } }  # mpirun, activates SMDDP AllReduce OR AllGather
    # distribution={ "torch_distributed": { "enabled": True } }  # torchrun, activates SMDDP AllGather
    # distribution={ "smdistributed": { "dataparallel": { "enabled": True } } }  # mpirun, activates SMDDP AllReduce OR AllGather
)

pt_estimator.fit("s3://bucket/path/to/training/data")
```

**nota**  
PyTorch Lightning y sus bibliotecas de utilidades, como Lightning Bolts, no vienen preinstaladas en la IA. SageMaker PyTorch DLCs Cree el siguiente archivo `requirements.txt` y guárdelo en el directorio de origen donde guarda el script de entrenamiento.  

```
# requirements.txt
pytorch-lightning
lightning-bolts
```
Por ejemplo, el directorio con estructura de árbol debería tener el siguiente aspecto.  

```
├── pytorch_training_launcher_jupyter_notebook.ipynb
└── sub-folder-for-your-code
    ├──  adapted-training-script.py
    └──  requirements.txt
```
Para obtener más información sobre cómo especificar el directorio de origen para colocar el `requirements.txt` archivo junto con el guion de entrenamiento y el envío de un trabajo, consulte [Uso de bibliotecas de terceros](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) en la *documentación del SDK de Python de Amazon SageMaker AI*.

**Consideraciones para activar las operaciones colectivas de SMDDP y utilizar las opciones del iniciador de entrenamiento distribuido adecuadas**
+ Actualmente, `AllReduce` de SMDDP y `AllGather` de SMDDP no son compatibles entre sí.
+ `AllReduce` de SMDDP se activa de forma predeterminada cuando se utiliza `smdistributed` o `pytorchddp`, que son iniciadores basados en `mpirun` y se utiliza `AllGather` de NCCL.
+ `AllGather` de SMDDP se activa de forma predeterminada cuando se utiliza el iniciador de `torch_distributed` y `AllReduce` recurre a NCCL.
+ `AllGather` de SMDDP también se puede activar cuando se utilizan los iniciadores basados en `mpirun` con una variable de entorno adicional configurada de la siguiente manera.

  ```
  export SMDATAPARALLEL_OPTIMIZE_SDP=true
  ```

------
#### [ TensorFlow ]

**importante**  
La biblioteca SMDDP dejó de ser compatible con la versión TensorFlow 2.11.0 y ya no estará disponible a partir DLCs de TensorFlow esa fecha. Para encontrar versiones anteriores TensorFlow DLCs con la biblioteca SMDDP instalada, consulte. [TensorFlow (obsoleto)](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks-tensorflow)

```
from sagemaker.tensorflow import TensorFlow

tf_estimator = TensorFlow(
    base_job_name = "training_job_name_prefix",
    entry_point="adapted-training-script.py",
    role="SageMakerRole",
    framework_version="2.11.0",
    py_version="py38",

    # For running a multi-node distributed training job, specify a value greater than 1
    # Example: 2,3,4,..8
    instance_count=2,

    # Instance types supported by the SageMaker AI data parallel library: 
    # ml.p4d.24xlarge, ml.p3dn.24xlarge, and ml.p3.16xlarge
    instance_type="ml.p3.16xlarge",

    # Training using the SageMaker AI data parallel distributed training strategy
    distribution={ "smdistributed": { "dataparallel": { "enabled": True } } }
)

tf_estimator.fit("s3://bucket/path/to/training/data")
```

------

# Utilice el estimador genérico de SageMaker IA para ampliar los contenedores de DLC prediseñados
<a name="data-parallel-use-python-skd-api"></a>

Puedes personalizar los contenedores prediseñados de SageMaker IA o ampliarlos para cumplir con cualquier requisito funcional adicional de tu algoritmo o modelo que no sea compatible con la imagen de Docker de SageMaker IA prediseñada. Para ver un ejemplo de cómo ampliar un contenedor prediseñado, consulte [Ampliar un contenedor prediseñado](https://docs.aws.amazon.com/sagemaker/latest/dg/prebuilt-containers-extend.html).

Para ampliar un contenedor prediseñado o adaptar su propio contenedor para usar la biblioteca, debe usar una de las imágenes que aparecen en [Marcos admitidos](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks).

**nota**  
A partir de las TensorFlow versiones 2.4.1 y PyTorch 1.8.1, el marco DLCs de SageMaker IA admite tipos de instancias compatibles con EFA. Te recomendamos que utilices las imágenes del DLC que contengan las TensorFlow versiones 2.4.1 o versiones posteriores y 1.8.1 o posteriores. PyTorch 

Por ejemplo, si las usas PyTorch, tu Dockerfile debe contener una `FROM` declaración similar a la siguiente:

```
# SageMaker AI PyTorch image
FROM 763104351884.dkr.ecr.<aws-region>.amazonaws.com/pytorch-training:<image-tag>

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

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

# /opt/ml and all subdirectories are utilized by SageMaker AI, use the /code subdirectory to store your user code.
COPY train.py /opt/ml/code/train.py

# Defines cifar10.py as script entrypoint
ENV SAGEMAKER_PROGRAM train.py
```

Puede personalizar aún más su propio contenedor de Docker para que funcione con la SageMaker IA mediante el [kit de herramientas de SageMaker formación](https://github.com/aws/sagemaker-training-toolkit) y el archivo binario de la biblioteca paralela de SageMaker datos distribuidos de IA. Para obtener más información, consulte las instrucciones de la siguiente sección.

# Cree su propio contenedor Docker con la biblioteca paralela de datos distribuidos de SageMaker IA
<a name="data-parallel-bring-your-own-container"></a>

Para crear tu propio contenedor Docker para entrenar y usar la biblioteca paralela de datos de SageMaker IA, debes incluir las dependencias correctas y los archivos binarios de las bibliotecas paralelas distribuidas por SageMaker IA en tu Dockerfile. En esta sección, se proporcionan instrucciones sobre cómo crear un Dockerfile completo con el conjunto mínimo de dependencias para el entrenamiento distribuido en SageMaker IA mediante la biblioteca data parallel.

**nota**  
Esta opción personalizada de Docker con la biblioteca paralela de datos de SageMaker IA como binaria solo está disponible para PyTorch.

**Para crear un Dockerfile con el kit de herramientas de SageMaker formación y la biblioteca de datos paralelos**

1. Comience con una imagen de Docker de [NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). [Utilice las versiones para desarrolladores de cuDNN que contienen herramientas de desarrollo y tiempo de ejecución de CUDA (encabezados y bibliotecas) para compilar a partir del código fuente. PyTorch ](https://github.com/pytorch/pytorch#from-source)

   ```
   FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04
   ```
**sugerencia**  
[Las imágenes oficiales del AWS Deep Learning Container (DLC) se crean a partir de las imágenes base de NVIDIA CUDA.](https://hub.docker.com/r/nvidia/cuda) Si quieres usar las imágenes del DLC prediseñadas como referencia mientras sigues el resto de las instrucciones, consulta [AWS Deep Learning Containers for PyTorch ](https://github.com/aws/deep-learning-containers/tree/master/pytorch) Dockerfiles. 

1. Agregue los siguientes argumentos para especificar las versiones y otros paquetes. PyTorch Además, indique las rutas de los buckets de Amazon S3 a la biblioteca paralela de datos de SageMaker IA y a otro software para utilizar AWS los recursos, como el complemento Amazon S3. 

   Para utilizar versiones de bibliotecas de terceros distintas de las que se proporcionan en el siguiente ejemplo de código, le recomendamos que consulte los [Dockerfiles oficiales de AWS Deep Learning Container PyTorch para](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) encontrar versiones probadas, compatibles y adecuadas para su aplicación. 

    URLs Para encontrar el `SMDATAPARALLEL_BINARY` argumento, consulte las tablas de consulta en. [Marcos admitidos](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks)

   ```
   ARG PYTORCH_VERSION=1.10.2
   ARG PYTHON_SHORT_VERSION=3.8
   ARG EFA_VERSION=1.14.1
   ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
   ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl
   ARG CONDA_PREFIX="/opt/conda"
   ARG BRANCH_OFI=1.1.3-aws
   ```

1. Configure las siguientes variables de entorno para crear correctamente los componentes de SageMaker entrenamiento y ejecutar la biblioteca data parallel. Estas variables se utilizan para los componentes en los pasos siguientes.

   ```
   # Set ENV variables required to build PyTorch
   ENV TORCH_CUDA_ARCH_LIST="7.0+PTX 8.0"
   ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all"
   ENV NCCL_VERSION=2.10.3
   
   # Add OpenMPI to the path.
   ENV PATH /opt/amazon/openmpi/bin:$PATH
   
   # Add Conda to path
   ENV PATH $CONDA_PREFIX/bin:$PATH
   
   # Set this enviroment variable for SageMaker AI to launch SMDDP correctly.
   ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main
   
   # Add enviroment variable for processes to be able to call fork()
   ENV RDMAV_FORK_SAFE=1
   
   # Indicate the container type
   ENV DLC_CONTAINER_TYPE=training
   
   # Add EFA and SMDDP to LD library path
   ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH"
   ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH
   ```

1. Instale o actualice `curl`, `wget` y `git` para descargar y crear paquetes en los pasos siguientes.

   ```
   RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
       apt-get update && apt-get install -y  --no-install-recommends \
           curl \
           wget \
           git \
       && rm -rf /var/lib/apt/lists/*
   ```

1. Instale el software [Elastic Fabric Adapter (EFA)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) para la comunicación de red de Amazon EC2.

   ```
   RUN DEBIAN_FRONTEND=noninteractive apt-get update
   RUN mkdir /tmp/efa \
       && cd /tmp/efa \
       && curl --silent -O https://efa-installer.amazonaws.com/aws-efa-installer-${EFA_VERSION}.tar.gz \
       && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \
       && cd aws-efa-installer \
       && ./efa_installer.sh -y --skip-kmod -g \
       && rm -rf /tmp/efa
   ```

1. Instale [Conda](https://docs.conda.io/en/latest/) para gestionar la administración de paquetes. 

   ```
   RUN curl -fsSL -v -o ~/miniconda.sh -O  https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh  && \
       chmod +x ~/miniconda.sh && \
       ~/miniconda.sh -b -p $CONDA_PREFIX && \
       rm ~/miniconda.sh && \
       $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \
       $CONDA_PREFIX/bin/conda clean -ya
   ```

1. Obtenga, compile e instale PyTorch y sus dependencias. Creamos [PyTorch a partir del código fuente](https://github.com/pytorch/pytorch#from-source) porque necesitamos tener el control de la versión NCCL para garantizar la compatibilidad con el complemento [AWS OFI](https://github.com/aws/aws-ofi-nccl) NCCL.

   1. [Siguiendo los pasos del [docker PyTorch oficial, instalamos](https://github.com/pytorch/pytorch/blob/master/Dockerfile) las dependencias de compilación y configuramos ccache para acelerar la recompilación.](https://ccache.dev/)

      ```
      RUN DEBIAN_FRONTEND=noninteractive \
          apt-get install -y --no-install-recommends \
              build-essential \
              ca-certificates \
              ccache \
              cmake \
              git \
              libjpeg-dev \
              libpng-dev \
          && rm -rf /var/lib/apt/lists/*
        
      # Setup ccache
      RUN /usr/sbin/update-ccache-symlinks
      RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache
      ```

   1. Instala las dependencias comunes y [PyTorchde Linux.](https://github.com/pytorch/pytorch#install-dependencies)

      ```
      # Common dependencies for PyTorch
      RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses
      
      # Linux specific dependency for PyTorch
      RUN conda install -c pytorch magma-cuda113
      ```

   1. Clona el [PyTorch GitHubrepositorio.](https://github.com/pytorch/pytorch)

      ```
      RUN --mount=type=cache,target=/opt/ccache \
          cd / \
          && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION}
      ```

   1. Instale y cree una versión específica de [NCCL](https://developer.nvidia.com/nccl). Para ello, sustituye el contenido PyTorch de la carpeta NCCL predeterminada (`/pytorch/third_party/nccl`) por la versión NCCL específica del repositorio de NVIDIA. La versión NCCL se configuró en el paso 3 de esta guía.

      ```
      RUN cd /pytorch/third_party/nccl \
          && rm -rf nccl \
          && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \
          && cd nccl \
          && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \
          && make pkg.txz.build \
          && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1
      ```

   1. Compile e instale. PyTorch Para completar este proceso se necesita por lo general algo más de una hora. Compilar con la versión NCCL descargada en un paso anterior.

      ```
      RUN cd /pytorch \
          && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \
          python setup.py install \
          && rm -rf /pytorch
      ```

1. Cree e instale el [complemento OFI NCCL de AWS](https://github.com/aws/aws-ofi-nccl). Esto permite que [libfabric sea](https://github.com/ofiwg/libfabric) compatible con la biblioteca paralela de datos de SageMaker IA.

   ```
   RUN DEBIAN_FRONTEND=noninteractive apt-get update \
       && apt-get install -y --no-install-recommends \
           autoconf \
           automake \
           libtool
   RUN mkdir /tmp/efa-ofi-nccl \
       && cd /tmp/efa-ofi-nccl \
       && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \
       && cd aws-ofi-nccl \
       && ./autogen.sh \
       && ./configure --with-libfabric=/opt/amazon/efa \
       --with-mpi=/opt/amazon/openmpi \
       --with-cuda=/usr/local/cuda \
       --with-nccl=$CONDA_PREFIX \
       && make \
       && make install \
       && rm -rf /tmp/efa-ofi-nccl
   ```

1. Compila e instala [TorchVision](https://github.com/pytorch/vision.git).

   ```
   RUN pip install --no-cache-dir -U \
       packaging \
       mpi4py==3.0.3
   RUN cd /tmp \
       && git clone https://github.com/pytorch/vision.git -b v0.9.1 \
       && cd vision \
       && BUILD_VERSION="0.9.1+cu111" python setup.py install \
       && cd /tmp \
       && rm -rf vision
   ```

1. Instale y configure OpenSSL. Se requiere OpenSSH para que MPI se comunique entre contenedores. Permita que OpenSSH se comunique con los contenedores sin necesidad de confirmación.

   ```
   RUN apt-get update \
       && apt-get install -y  --allow-downgrades --allow-change-held-packages --no-install-recommends \
       && apt-get install -y --no-install-recommends openssh-client openssh-server \
       && mkdir -p /var/run/sshd \
       && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \
       && echo "    StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \
       && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \
       && rm -rf /var/lib/apt/lists/*
   
   # Configure OpenSSH so that nodes can communicate with each other
   RUN mkdir -p /var/run/sshd && \
    sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd
   RUN rm -rf /root/.ssh/ && \
    mkdir -p /root/.ssh/ && \
    ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \
    cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \
    && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config
   ```

1. Instale el complemento PT S3 para acceder de manera eficiente a los conjuntos de datos de Amazon S3.

   ```
   RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU}
   RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt
   ```

1. Instale la biblioteca [libboost](https://www.boost.org/). Este paquete es necesario para conectar en red la funcionalidad de E/S asíncrona de la biblioteca paralela de SageMaker datos de IA.

   ```
   WORKDIR /
   RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \
       && tar -xzf boost_1_73_0.tar.gz \
       && cd boost_1_73_0 \
       && ./bootstrap.sh \
       && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \
       && cd .. \
       && rm -rf boost_1_73_0.tar.gz \
       && rm -rf boost_1_73_0 \
       && cd ${CONDA_PREFIX}/include/boost
   ```

1. Instale las siguientes herramientas de SageMaker IA para la formación. PyTorch 

   ```
   WORKDIR /root
   RUN pip install --no-cache-dir -U \
       smclarify \
       "sagemaker>=2,<3" \
       sagemaker-experiments==0.* \
       sagemaker-pytorch-training
   ```

1. Por último, instale el binario paralelo de datos de SageMaker IA y las dependencias restantes.

   ```
   RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
     apt-get update && apt-get install -y  --no-install-recommends \
     jq \
     libhwloc-dev \
     libnuma1 \
     libnuma-dev \
     libssl1.1 \
     libtool \
     hwloc \
     && rm -rf /var/lib/apt/lists/*
   
   RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY}
   ```

1. Cuando termine de crear el Dockerfile, consulte [Adaptación de su propio contenedor de formación](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) para obtener información sobre cómo crear el contenedor de Docker, alojarlo en Amazon ECR y ejecutar un trabajo de formación con el SDK de Python. SageMaker 

El siguiente código de ejemplo muestra un dockerfile completo tras combinar todos los bloques de código anteriores.

```
# This file creates a docker image with minimum dependencies to run SageMaker AI data parallel training
FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04

# Set appropiate versions and location for components
ARG PYTORCH_VERSION=1.10.2
ARG PYTHON_SHORT_VERSION=3.8
ARG EFA_VERSION=1.14.1
ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl
ARG CONDA_PREFIX="/opt/conda"
ARG BRANCH_OFI=1.1.3-aws

# Set ENV variables required to build PyTorch
ENV TORCH_CUDA_ARCH_LIST="3.7 5.0 7.0+PTX 8.0"
ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all"
ENV NCCL_VERSION=2.10.3

# Add OpenMPI to the path.
ENV PATH /opt/amazon/openmpi/bin:$PATH

# Add Conda to path
ENV PATH $CONDA_PREFIX/bin:$PATH

# Set this enviroment variable for SageMaker AI to launch SMDDP correctly.
ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main

# Add enviroment variable for processes to be able to call fork()
ENV RDMAV_FORK_SAFE=1

# Indicate the container type
ENV DLC_CONTAINER_TYPE=training

# Add EFA and SMDDP to LD library path
ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH"
ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH

# Install basic dependencies to download and build other dependencies
RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
  apt-get update && apt-get install -y  --no-install-recommends \
  curl \
  wget \
  git \
  && rm -rf /var/lib/apt/lists/*

# Install EFA.
# This is required for SMDDP backend communication
RUN DEBIAN_FRONTEND=noninteractive apt-get update
RUN mkdir /tmp/efa \
    && cd /tmp/efa \
    && curl --silent -O https://efa-installer.amazonaws.com/aws-efa-installer-${EFA_VERSION}.tar.gz \
    && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \
    && cd aws-efa-installer \
    && ./efa_installer.sh -y --skip-kmod -g \
    && rm -rf /tmp/efa

# Install Conda
RUN curl -fsSL -v -o ~/miniconda.sh -O  https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh  && \
    chmod +x ~/miniconda.sh && \
    ~/miniconda.sh -b -p $CONDA_PREFIX && \
    rm ~/miniconda.sh && \
    $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \
    $CONDA_PREFIX/bin/conda clean -ya

# Install PyTorch.
# Start with dependencies listed in official PyTorch dockerfile
# https://github.com/pytorch/pytorch/blob/master/Dockerfile
RUN DEBIAN_FRONTEND=noninteractive \
    apt-get install -y --no-install-recommends \
        build-essential \
        ca-certificates \
        ccache \
        cmake \
        git \
        libjpeg-dev \
        libpng-dev && \
    rm -rf /var/lib/apt/lists/*

# Setup ccache
RUN /usr/sbin/update-ccache-symlinks
RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache

# Common dependencies for PyTorch
RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses

# Linux specific dependency for PyTorch
RUN conda install -c pytorch magma-cuda113

# Clone PyTorch
RUN --mount=type=cache,target=/opt/ccache \
    cd / \
    && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION}
# Note that we need to use the same NCCL version for PyTorch and OFI plugin.
# To enforce that, install NCCL from source before building PT and OFI plugin.

# Install NCCL.
# Required for building OFI plugin (OFI requires NCCL's header files and library)
RUN cd /pytorch/third_party/nccl \
    && rm -rf nccl \
    && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \
    && cd nccl \
    && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \
    && make pkg.txz.build \
    && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1

# Build and install PyTorch.
RUN cd /pytorch \
    && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \
    python setup.py install \
    && rm -rf /pytorch

RUN ccache -C

# Build and install OFI plugin. \
# It is required to use libfabric.
RUN DEBIAN_FRONTEND=noninteractive apt-get update \
    && apt-get install -y --no-install-recommends \
        autoconf \
        automake \
        libtool
RUN mkdir /tmp/efa-ofi-nccl \
    && cd /tmp/efa-ofi-nccl \
    && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \
    && cd aws-ofi-nccl \
    && ./autogen.sh \
    && ./configure --with-libfabric=/opt/amazon/efa \
        --with-mpi=/opt/amazon/openmpi \
        --with-cuda=/usr/local/cuda \
        --with-nccl=$CONDA_PREFIX \
    && make \
    && make install \
    && rm -rf /tmp/efa-ofi-nccl

# Build and install Torchvision
RUN pip install --no-cache-dir -U \
    packaging \
    mpi4py==3.0.3
RUN cd /tmp \
    && git clone https://github.com/pytorch/vision.git -b v0.9.1 \
    && cd vision \
    && BUILD_VERSION="0.9.1+cu111" python setup.py install \
    && cd /tmp \
    && rm -rf vision

# Install OpenSSH.
# Required for MPI to communicate between containers, allow OpenSSH to talk to containers without asking for confirmation
RUN apt-get update \
    && apt-get install -y  --allow-downgrades --allow-change-held-packages --no-install-recommends \
    && apt-get install -y --no-install-recommends openssh-client openssh-server \
    && mkdir -p /var/run/sshd \
    && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \
    && echo "    StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \
    && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \
    && rm -rf /var/lib/apt/lists/*
# Configure OpenSSH so that nodes can communicate with each other
RUN mkdir -p /var/run/sshd && \
    sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd
RUN rm -rf /root/.ssh/ && \
    mkdir -p /root/.ssh/ && \
    ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \
    cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \
    && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config

# Install PT S3 plugin.
# Required to efficiently access datasets in Amazon S3
RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU}
RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt

# Install libboost from source.
# This package is needed for smdataparallel functionality (for networking asynchronous IO).
WORKDIR /
RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \
    && tar -xzf boost_1_73_0.tar.gz \
    && cd boost_1_73_0 \
    && ./bootstrap.sh \
    && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \
    && cd .. \
    && rm -rf boost_1_73_0.tar.gz \
    && rm -rf boost_1_73_0 \
    && cd ${CONDA_PREFIX}/include/boost

# Install SageMaker AI PyTorch training.
WORKDIR /root
RUN pip install --no-cache-dir -U \
    smclarify \
    "sagemaker>=2,<3" \
    sagemaker-experiments==0.* \
    sagemaker-pytorch-training

# Install SageMaker AI data parallel binary (SMDDP)
# Start with dependencies
RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
    apt-get update && apt-get install -y  --no-install-recommends \
        jq \
        libhwloc-dev \
        libnuma1 \
        libnuma-dev \
        libssl1.1 \
        libtool \
        hwloc \
    && rm -rf /var/lib/apt/lists/*

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

**sugerencia**  
[Para obtener más información general sobre cómo crear un Dockerfile personalizado para la formación en SageMaker IA, consulte Use sus propios algoritmos de entrenamiento.](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html)

**sugerencia**  
Si desea ampliar el Dockerfile personalizado para incorporar la biblioteca paralela de SageMaker modelos AI, consulte. [Cree su propio contenedor Docker con la biblioteca paralela de modelos distribuidos SageMaker](model-parallel-sm-sdk.md#model-parallel-bring-your-own-container)