As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Lançamento de trabalhos de treinamento distribuídos com SMDDP usando o Python SDK SageMaker
<a name="data-parallel-use-api"></a>

Para executar um trabalho de treinamento distribuído com seu script adaptado do[Adaptação de seu script de treinamento para usar as operações coletivas do SMDDP](data-parallel-modify-sdp-select-framework.md), use a estrutura do SageMaker Python SDK ou estimadores genéricos especificando o script de treinamento preparado como um script de ponto de entrada e a configuração de treinamento distribuído.

Nesta página, você aprenderá a usar o [SDK SageMaker AI Python](https://sagemaker.readthedocs.io/en/stable/api/training/index.html) de duas maneiras.
+ Se você quiser obter uma adoção rápida de seu trabalho de treinamento distribuído em SageMaker IA, configure uma classe de estimador de SageMaker IA [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch)ou [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)estrutura. O estimador da estrutura pega seu script de treinamento e combina automaticamente o URI correto da imagem dos Deep Learning [ PyTorch Containers (DLC) pré-construídos ou do TensorFlow Deep Learning Containers (DLC)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only), considerando o valor especificado para o parâmetro. `framework_version`
+ Se você quiser estender um dos contêineres pré-criados ou criar um contêiner personalizado para criar seu próprio ambiente de ML com SageMaker IA, use a `Estimator` classe genérica SageMaker AI e especifique o URI da imagem do contêiner Docker personalizado hospedado em seu Amazon Elastic Container Registry (Amazon ECR).

Seus conjuntos de dados de treinamento devem ser armazenados no Amazon S3 ou no [ FSx Amazon for](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) Lustre Região da AWS no qual você está lançando seu trabalho de treinamento. Se você usa notebooks Jupyter, você deve ter uma instância de SageMaker notebook ou um aplicativo SageMaker Studio Classic em execução no mesmo. Região da AWS Para obter mais informações sobre como armazenar seus dados de treinamento, consulte a documentação de entradas de [dados do SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#use-file-systems-as-training-input). 

**dica**  
Recomendamos que você use o Amazon FSx for Lustre em vez do Amazon S3 para melhorar o desempenho do treinamento. FSx A Amazon tem maior taxa de transferência e menor latência do que o Amazon S3.

**dica**  
Para executar adequadamente o treinamento distribuído nos tipos de instância habilitados para o EFA, você deve habilitar o tráfego entre as instâncias configurando o grupo de segurança da VPC para permitir todo o tráfego de entrada e saída de e para o próprio grupo de segurança. Para saber como configurar as regras do grupo de segurança, consulte [Etapa 1: preparar um grupo de segurança habilitado para EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) no *Guia do usuário do Amazon EC2*.

Escolha um dos tópicos a seguir para obter instruções sobre como executar um trabalho de treinamento distribuído do script de treinamento. Depois de iniciar um trabalho de treinamento, você pode monitorar a utilização do sistema e o desempenho do modelo usando [SageMaker Depurador Amazon](train-debugger.md) a Amazon CloudWatch.

Enquanto você segue as instruções nos tópicos a seguir para saber mais sobre detalhes técnicos, também recomendamos que você experimente o [Exemplos da biblioteca de paralelismo de dados da Amazon SageMaker AI](distributed-data-parallel-v2-examples.md) para começar.

**Topics**
+ [

# Use os estimadores da PyTorch estrutura no SDK do Python SageMaker
](data-parallel-framework-estimator.md)
+ [

# Use o estimador genérico de SageMaker IA para estender contêineres de DLC pré-construídos
](data-parallel-use-python-skd-api.md)
+ [

# Crie seu próprio contêiner Docker com a biblioteca paralela de dados distribuídos de SageMaker IA
](data-parallel-bring-your-own-container.md)

# Use os estimadores da PyTorch estrutura no SDK do Python SageMaker
<a name="data-parallel-framework-estimator"></a>

Você pode iniciar o treinamento distribuído adicionando o `distribution` argumento aos estimadores da estrutura de SageMaker IA ou. [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) Para obter mais detalhes, escolha uma das estruturas suportadas pela biblioteca de paralelismo de dados distribuídos de SageMaker IA (SMDDP) entre as seleções a seguir.

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

As seguintes opções de lançador estão disponíveis para iniciar o treinamento PyTorch distribuído.
+ `pytorchddp`— Essa opção executa `mpirun` e configura as variáveis de ambiente necessárias para executar o treinamento PyTorch distribuído em SageMaker IA. Para usar essa opção, transfira o seguinte dicionário para o parâmetro `distribution`:

  ```
  { "pytorchddp": { "enabled": True } }
  ```
+ `torch_distributed`— Essa opção executa `torchrun` e configura as variáveis de ambiente necessárias para executar o treinamento PyTorch distribuído em SageMaker IA. Para usar essa opção, transfira o seguinte dicionário para o parâmetro `distribution`:

  ```
  { "torch_distributed": { "enabled": True } }
  ```
+ `smdistributed`— Essa opção também é executada`mpirun`, mas com `smddprun` isso configura as variáveis de ambiente necessárias para executar o treinamento PyTorch distribuído em SageMaker IA.

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

Se você optar por substituir o NCCL `AllGather` pelo SMDDP `AllGather`, poderá usar todas as três opções. Escolha uma opção que seja mais adequada ao caso de uso.

Se você optar por substituir o NCCL `AllReduce` pelo SMDDP `AllReduce`, deverá escolher uma das opções encontradas em `mpirun`: `smdistributed` ou `pytorchddp`. Você também pode adicionar outras opções de MPI da seguinte forma:

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

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

O exemplo de código a seguir mostra a estrutura básica de um PyTorch estimador com opções de treinamento distribuídas.

```
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 O Lightning e suas bibliotecas de utilitários, como o Lightning Bolts, não estão pré-instalados na IA. SageMaker PyTorch DLCs Crie o arquivo `requirements.txt` a seguir e salve no diretório de origem em que você salva o script de treinamento.  

```
# requirements.txt
pytorch-lightning
lightning-bolts
```
Por exemplo, o diretório de árvore estruturada deve ser semelhante ao seguinte:  

```
├── pytorch_training_launcher_jupyter_notebook.ipynb
└── sub-folder-for-your-code
    ├──  adapted-training-script.py
    └──  requirements.txt
```
Para obter mais informações sobre como especificar o diretório de origem para colocar o `requirements.txt` arquivo junto com seu script de treinamento e o envio de um trabalho, consulte [Uso de bibliotecas de terceiros](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) na documentação do *Amazon SageMaker AI Python SDK*.

**Considerações para ativar as operações coletivas do SMDDP e usar as opções corretas de inicializador de treinamento distribuído**
+ SMDDP `AllReduce` e SMDDP `AllGather` não são mutuamente compatíveis no momento.
+ O SMDDP `AllReduce` é ativado por padrão ao usar `smdistributed` ou `pytorchddp`, que são iniciadores encontrados no `mpirun`, e é usado o NCCL `AllGather`.
+ O SMDDP `AllGather` é ativado por padrão ao usar o iniciador `torch_distributed` e `AllReduce` volta para o NCCL.
+ O SMDDP `AllGather` pode ser ativado também com o uso dos iniciadores encontrados em `mpirun` com uma variável de ambiente adicional definida da seguinte forma:

  ```
  export SMDATAPARALLEL_OPTIMIZE_SDP=true
  ```

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

**Importante**  
A biblioteca SMDDP interrompeu o suporte TensorFlow e não está mais disponível para versões TensorFlow posteriores à DLCs v2.11.0. Para saber mais sobre TensorFlow DLCs a 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")
```

------

# Use o estimador genérico de SageMaker IA para estender contêineres de DLC pré-construídos
<a name="data-parallel-use-python-skd-api"></a>

Você pode personalizar contêineres pré-criados de SageMaker IA ou estendê-los para lidar com quaisquer requisitos funcionais adicionais para seu algoritmo ou modelo que a imagem pré-criada do SageMaker AI Docker não suporte. Para ver um exemplo de como você pode estender um contêiner pré-compilado, consulte [Estender um contêiner pré-compilado](https://docs.aws.amazon.com/sagemaker/latest/dg/prebuilt-containers-extend.html).

Para estender um contêiner pré-compilado ou adaptar seu próprio contêiner para usar a biblioteca, você deve usar uma das imagens listadas em [Frameworks compatíveis](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks).

**nota**  
A partir das TensorFlow versões 2.4.1 e PyTorch 1.8.1, o SageMaker AI framework DLCs oferece suporte a tipos de instância habilitados para EFA. Recomendamos que você use as imagens de DLC que contenham TensorFlow 2.4.1 ou posterior e PyTorch 1.8.1 ou posterior. 

Por exemplo, se você usa PyTorch, seu Dockerfile deve conter uma `FROM` declaração semelhante à seguinte:

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

Você pode personalizar ainda mais seu próprio contêiner Docker para trabalhar com SageMaker IA usando o [kit de ferramentas de SageMaker treinamento](https://github.com/aws/sagemaker-training-toolkit) e o arquivo binário da biblioteca paralela de dados distribuídos de SageMaker IA. Para saber mais, consulte as instruções na seção a seguir.

# Crie seu próprio contêiner Docker com a biblioteca paralela de dados distribuídos de SageMaker IA
<a name="data-parallel-bring-your-own-container"></a>

Para criar seu próprio contêiner Docker para treinamento e usar a biblioteca paralela de dados de SageMaker IA, você deve incluir as dependências corretas e os arquivos binários das bibliotecas paralelas distribuídas de SageMaker IA em seu Dockerfile. Esta seção fornece instruções sobre como criar um Dockerfile completo com o conjunto mínimo de dependências para treinamento distribuído em SageMaker IA usando a biblioteca paralela de dados.

**nota**  
Essa opção personalizada do Docker com a biblioteca paralela de dados SageMaker AI como binária está disponível somente para PyTorch.

**Para criar um Dockerfile com o kit de ferramentas de SageMaker treinamento e a biblioteca paralela de dados**

1. Comece com uma imagem do Docker da [NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). [Use as versões de desenvolvedor cuDNN que contêm ferramentas de desenvolvimento e tempo de execução CUDA (cabeçalhos e bibliotecas) para criar a partir do código-fonte. PyTorch ](https://github.com/pytorch/pytorch#from-source)

   ```
   FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04
   ```
**dica**  
As imagens oficiais do AWS Deep Learning Container (DLC) são criadas a partir das imagens básicas [NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). Se você quiser usar as imagens de DLC pré-criadas como referências enquanto segue o resto das instruções, consulte [AWS Deep Learning Containers para PyTorch ](https://github.com/aws/deep-learning-containers/tree/master/pytorch) Dockerfiles. 

1. Adicione os argumentos a seguir para especificar versões PyTorch e outros pacotes. Além disso, indique os caminhos do bucket do Amazon S3 para a biblioteca paralela de dados de SageMaker IA e outros softwares para usar AWS recursos, como o plug-in Amazon S3. 

   Para usar versões de bibliotecas de terceiros diferentes das fornecidas no exemplo de código a seguir, recomendamos que você consulte os [Dockerfiles oficiais do AWS Deep Learning Container PyTorch para](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) encontrar versões testadas, compatíveis e adequadas para seu aplicativo. 

    URLs Para encontrar o `SMDATAPARALLEL_BINARY` argumento, consulte as tabelas de pesquisa em[Frameworks compatíveis](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. Defina as seguintes variáveis de ambiente para criar adequadamente os componentes de SageMaker treinamento e executar a biblioteca paralela de dados. Você usa essas variáveis para os componentes nas etapas subsequentes.

   ```
   # 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 ou atualize `curl`, `wget` e `git` para baixar e criar pacotes nas etapas subsequentes.

   ```
   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 o [software Elastic Fabric Adapter (EFA) para comunicação](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) de rede do 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 o [Conda](https://docs.conda.io/en/latest/) para lidar com o gerenciamento de pacotes. 

   ```
   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. Obtenha, construa PyTorch e instale suas dependências. Construímos [a PyTorch partir do código-fonte](https://github.com/pytorch/pytorch#from-source) porque precisamos ter controle da versão NCCL para garantir a compatibilidade com o plug-in [AWS OFI](https://github.com/aws/aws-ofi-nccl) NCCL.

   1. Seguindo as etapas no [dockerfile PyTorch oficial](https://github.com/pytorch/pytorch/blob/master/Dockerfile), instale as dependências de compilação e configure o [ccache](https://ccache.dev/) para acelerar a recompilação.

      ```
      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. Instale [PyTorchas dependências comuns e do 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. Clone o [PyTorch GitHubrepositório](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 e construa uma versão específica do [NCCL.](https://developer.nvidia.com/nccl) Para fazer isso, substitua o conteúdo na pasta NCCL padrão (`/pytorch/third_party/nccl`) pela versão específica da NCCL do repositório NVIDIA. PyTorch A versão NCCL foi definida na etapa 3 deste guia.

      ```
      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. Crie e instale PyTorch. Esse processo geralmente leva um pouco mais de uma hora para ser concluído. Ele é construído usando a versão NCCL baixada em uma etapa anterior.

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

1. Crie e instale o [plugin OFI NCCL AWS](https://github.com/aws/aws-ofi-nccl). Isso permite o suporte [do libfabric](https://github.com/ofiwg/libfabric) para a biblioteca paralela de dados SageMaker AI.

   ```
   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. Crie e instale [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 e configure o OpenSSH. O OpenSSH é necessário para que o MPI se comunique entre contêineres. Permita que o OpenSSH se comunique com contêineres sem solicitar confirmação.

   ```
   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 o plug-in PT S3 para acessar com eficiência conjuntos de dados no 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 a biblioteca [libboost](https://www.boost.org/). Esse pacote é necessário para conectar em rede a funcionalidade de E/S assíncrona da biblioteca paralela de SageMaker dados AI.

   ```
   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 as seguintes ferramentas de SageMaker IA para PyTorch treinamento.

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

1. Por fim, instale o binário paralelo de dados SageMaker AI e as dependências 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. Depois de concluir a criação do Dockerfile, consulte [Adaptando seu próprio contêiner de treinamento para aprender a criar o contêiner](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) do Docker, hospedá-lo no Amazon ECR e executar um trabalho de treinamento usando o SDK do Python. SageMaker 

O código de exemplo a seguir mostra um Dockerfile completo depois de combinar todos os blocos 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}
```

**dica**  
Para obter mais informações gerais sobre a criação de um Dockerfile personalizado para treinamento em SageMaker IA, consulte [Use seus próprios algoritmos de treinamento](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html).

**dica**  
Se você quiser estender o Dockerfile personalizado para incorporar a biblioteca paralela do modelo SageMaker AI, consulte. [Crie seu próprio contêiner Docker com a biblioteca paralela de modelos SageMaker distribuídos](model-parallel-sm-sdk.md#model-parallel-bring-your-own-container)