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á.

# Etapa 2: Iniciar um Training Job usando o SageMaker Python SDK
<a name="model-parallel-sm-sdk"></a>

O SDK do SageMaker Python oferece suporte ao treinamento gerenciado de modelos com estruturas de ML, como e. TensorFlow PyTorch Para iniciar um trabalho de treinamento usando uma dessas estruturas, você define um SageMaker [TensorFlow estimador, um estimador ou um SageMaker PyTorch estimador SageMaker ](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) [genérico para usar o script](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) de treinamento modificado e a [configuração de paralelismo](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/estimators.html#sagemaker.estimator.Estimator) do modelo.

**Topics**
+ [Usando os SageMaker TensorFlow PyTorch estimadores e](#model-parallel-using-sagemaker-pysdk)
+ [Estenda um contêiner Docker pré-construído que contém a biblioteca paralela SageMaker de modelos distribuídos](#model-parallel-customize-container)
+ [Crie seu próprio contêiner Docker com a biblioteca paralela de modelos SageMaker distribuídos](#model-parallel-bring-your-own-container)

## Usando os SageMaker TensorFlow PyTorch estimadores e
<a name="model-parallel-using-sagemaker-pysdk"></a>

As classes TensorFlow e PyTorch estimator contêm o `distribution` parâmetro, que você pode usar para especificar parâmetros de configuração para usar estruturas de treinamento distribuídas. A biblioteca paralela de SageMaker modelos usa internamente MPI para dados híbridos e paralelismo de modelos, portanto, você deve usar a opção MPI com a biblioteca.

O modelo a seguir de um PyTorch estimador TensorFlow or mostra como configurar o `distribution` parâmetro para usar a biblioteca SageMaker paralela de modelos com 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 a biblioteca, você precisa passar dicionários de configuração para `"mpi"` as chaves `"smdistributed"` e por meio do `distribution` argumento dos construtores do SageMaker estimador.

**Parâmetros de configuração para SageMaker paralelismo do modelo**
+ Para a chave `"smdistributed"`, passe um dicionário com a chave `"modelparallel"` e os dicionários internos a seguir. 
**nota**  
Não há suporte para os usos `"modelparallel"` e `"dataparallel"` em um trabalho de treinamento. 
  + `"enabled"` – Obrigatório. Para ativar o paralelismo do modelo, defina `"enabled": True`.
  + `"parameters"` – Obrigatório. Especifique um conjunto de parâmetros para o SageMaker paralelismo do modelo.
    + Para obter uma lista completa dos parâmetros comuns, consulte [Parâmetros para `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters) na documentação do *SDK do SageMaker Python*.

      Para TensorFlow isso, 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 PyTorch isso, consulte [Parâmetros PyTorch específicos](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#pytorch-specific-parameters).
    + `"pipeline_parallel_degree"` (ou `"partitions"` em `smdistributed-modelparallel<v1.6.0`) — Obrigatório. Entre os [parâmetros para `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters), esse parâmetro é necessário para especificar em quantas partições de modelo você deseja dividir.
**Importante**  
Há uma alteração importante no nome do parâmetro. O parâmetro `"pipeline_parallel_degree"` substitui o `"partitions"` desde `smdistributed-modelparallel` v1.6.0. *Para obter mais informações, consulte [Parâmetros comuns](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#common-parameters) para configuração de paralelismo de SageMaker modelos e [Notas de versão do SageMaker Distributed Model Parallel na documentação do SDK](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) do PythonSageMaker .*
+ Para a chave `"mpi"`, passe um dicionário que contenha o seguinte:
  + `"enabled"` – obrigatório. Configure `True` para iniciar o trabalho de treinamento distribuído com o MPI.
  + `"processes_per_host"` – obrigatório. Especifique o número de processos que o MPI deve iniciar em cada host. Na SageMaker IA, um host é uma única instância de ML do Amazon EC2. O SDK do SageMaker Python mantém um one-to-one mapeamento entre processos e paralelismo GPUs entre modelos e dados. Isso significa que a SageMaker IA agenda cada processo em uma única GPU separada e nenhuma GPU contém mais de um processo. Se você estiver usando PyTorch, você deve restringir cada processo ao seu próprio dispositivo por meio de`torch.cuda.set_device(smp.local_rank())`. Para saber mais, consulte [Divisão automatizada com PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16).
**Importante**  
 `process_per_host`não *deve* ser maior que o número de GPUs por instância e normalmente será igual ao número de GPUs por instância.
  + `"custom_mpi_options"`(opcional) — Use essa chave para transmitir quaisquer opções personalizadas de MPI que você possa precisar. Se você não passar nenhuma opção personalizada de MPI para a chave, a opção MPI será definida por padrão com o seguinte sinalizador.

    ```
    --mca btl_vader_single_copy_mechanism none
    ```
**nota**  
Você não precisa especificar explicitamente esse sinalizador padrão na chave. Se você especificar isso explicitamente, seu trabalho de treinamento paralelo de modelo distribuído poderá falhar com o seguinte erro:  

    ```
    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.
    ```
**dica**  
Se você iniciar um trabalho de treinamento usando um tipo de instância habilitado para EFA, como `ml.p4d.24xlarge` e `ml.p3dn.24xlarge`, use a seguinte sinalização para obter o melhor desempenho:  

    ```
    -x FI_EFA_USE_DEVICE_RDMA=1 -x FI_PROVIDER=efa -x RDMAV_FORK_SAFE=1
    ```

Para iniciar o trabalho de treinamento usando o estimador e seu script de treinamento configurado em SageMaker paralelo do modelo, execute a `estimator.fit()` função.

Use os recursos a seguir para saber mais sobre como usar os recursos de paralelismo de modelos no SDK do Python SageMaker :
+ [Use TensorFlow com o SDK do SageMaker Python](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/using_tf.html)
+ [Use PyTorch com o SDK do SageMaker Python](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/using_pytorch.html)
+ Recomendamos que você use uma instância de SageMaker notebook se você for um novo usuário. Para ver um exemplo de como você pode iniciar um trabalho de treinamento usando uma instância de SageMaker notebook, consulte[Exemplos da biblioteca de paralelismo de modelos de SageMaker IA da Amazon v2](distributed-model-parallel-v2-examples.md).
+ Você também pode enviar um trabalho de treinamento distribuído de sua máquina usando AWS CLI. Para configurar AWS CLI sua máquina, consulte [Configurar suas AWS credenciais e a região para desenvolvimento](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html).

## Estenda um contêiner Docker pré-construído que contém a biblioteca paralela SageMaker de modelos distribuídos
<a name="model-parallel-customize-container"></a>

Para estender um contêiner pré-criado e usar a biblioteca SageMaker de paralelismo de modelos, você deve usar uma das imagens de AWS Deep Learning Containers (DLC) disponíveis para ou. PyTorch TensorFlow A biblioteca de paralelismo de SageMaker modelos está incluída nas imagens DLC TensorFlow (2.3.0 e posteriores) e PyTorch (1.6.0 e posteriores) com CUDA (). `cuxyz` Para obter uma lista completa de imagens de DLC, consulte Imagens de contêineres de [Deep Learning disponíveis no GitHub repositório de contêineres](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) *de AWS Deep Learning*.

**dica**  
Recomendamos que você use a imagem que contém a versão mais recente TensorFlow ou PyTorch para acessar a up-to-date versão mais recente da biblioteca de paralelismo de SageMaker modelos.

Por exemplo, o Dockerfile deve conter uma declaração `FROM` semelhante à seguinte:

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

Além disso, ao definir um TensorFlow estimador PyTorch or, você deve especificá-lo `entry_point` para seu script de treinamento. Esse deve ser o mesmo caminho identificado com `ENV SAGEMAKER_SUBMIT_DIRECTORY` no seu Dockerfile. 

**dica**  
Você deve enviar esse contêiner do Docker para o Amazon Elastic Container Registry (Amazon ECR) e usar a imagem URI (`image_uri`) para definir um SageMaker estimador para treinamento. Para obter mais informações, consulte [Estenda uma imagem de contêiner predefinida](prebuilt-containers-extend.md). 

Depois de terminar de hospedar o contêiner Docker e recuperar o URI da imagem do contêiner, crie um objeto SageMaker `PyTorch` estimador da seguinte forma. Este exemplo pressupõe que você já definiu `smp_options` e `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/')
```

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

Para criar seu próprio contêiner Docker para treinamento e usar a biblioteca paralela de SageMaker modelos, você deve incluir as dependências corretas e os arquivos binários das bibliotecas SageMaker paralelas distribuídas em seu Dockerfile. Esta seção fornece o conjunto mínimo de blocos de código que você deve incluir para preparar adequadamente um ambiente de SageMaker treinamento e a biblioteca paralela de modelos em seu próprio contêiner Docker.

**nota**  
Essa opção personalizada do Docker com a biblioteca paralela de SageMaker modelos 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 modelos**

1. Comece com uma das imagens [básicas do NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda).

   ```
   FROM {{<cuda-cudnn-base-image>}}
   ```
**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). 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) descobrir quais versões das bibliotecas você precisa instalar e como configurá-las. Os Dockerfiles oficiais estão completos, testados em benchmark e gerenciados pelas equipes de serviço SageMaker e pelo Deep Learning Container. No link fornecido, escolha a PyTorch versão que você usa, escolha a pasta CUDA (`cuxyz`) e escolha o Dockerfile que termina com ou. `.gpu` `.sagemaker.gpu`

1. Para configurar um ambiente de treinamento distribuído, você precisa instalar um software para dispositivos de comunicação e rede, como, por exemplo, [Elastic Fabric Adapter (EFA)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html), [NVIDIA Collective Communications Library (NCCL)](https://developer.nvidia.com/nccl) e [Open MPI](https://www.open-mpi.org/). Dependendo das versões CUDA PyTorch e da CUDA que você escolher, você deve instalar versões compatíveis das bibliotecas.
**Importante**  
Como a biblioteca paralela de SageMaker modelos exige a biblioteca paralela de SageMaker dados nas etapas subsequentes, é altamente recomendável que você siga as instruções em [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) para configurar adequadamente um ambiente de SageMaker treinamento para treinamento distribuído.

   Para obter mais informações sobre como configurar o EFA com o NCCL e o Open MPI, consulte [Começar com EFA e MPI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html) e [Começar com EFA e NCCL](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start-nccl.html).

1. Adicione os argumentos a seguir para especificar os pacotes URLs de treinamento SageMaker distribuídos para PyTorch. A biblioteca paralela do SageMaker modelo exige que a biblioteca paralela de SageMaker dados use o Acesso Direto à Memória Remoto (RDMA) entre nós.

   ```
   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 as dependências que a biblioteca paralela de SageMaker modelos exige.

   1. Instale a 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 a [biblioteca RAPIDS Memory Manager](https://github.com/rapidsai/rmm#rmm-rapids-memory-manager). Isso requer [CMake](https://cmake.org/)3.14 ou 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 a biblioteca paralela de SageMaker modelos.

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

1. Instale a biblioteca paralela de SageMaker dados.

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

1. Instale o [kit de ferramentas de treinamento do SageMaker](https://github.com/aws/sagemaker-training-toolkit). O kit de ferramentas contém a funcionalidade comum necessária para criar um contêiner compatível com a plataforma de SageMaker treinamento e o SDK do SageMaker Python.

   ```
   RUN pip install sagemaker-training
   ```

1. Depois de concluir a criação do Dockerfile, consulte [Adaptando seu próprio contêiner de treinamento para saber como criar o contêiner Docker](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) e hospedá-lo no Amazon ECR.

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