Usando os estimadores TensorFlow e PyTorch do SageMaker Estenda um contêiner Docker predefinido que contém a biblioteca paralela de modelos distribuídos do SageMaker Criar contêineres do Docker com a biblioteca de contêineres

Etapa 2: Iniciar um trabalho de treinamento usando o SDK do SageMaker para Python

O SDK do SageMaker para Python oferece suporte ao treinamento gerenciado de modelos com estruturas de ML, como TensorFlow e PyTorch. Para iniciar um trabalho de treinamento usando uma dessas estruturas, você define um estimador do TensorFlow do SageMaker, um estimador do PyTorch do SageMaker ou um estimador genérico do SageMaker para usar o script de treinamento modificado e a configuração de paralelismo do modelo.

Tópicos

Usando os estimadores TensorFlow e PyTorch do SageMaker
Estenda um contêiner Docker predefinido que contém a biblioteca paralela de modelos distribuídos do SageMaker
Crie seu próprio contêiner Docker com a biblioteca paralela de modelos distribuídos do SageMaker

Usando os estimadores TensorFlow e PyTorch do SageMaker

As classes de estimador TensorFlow e PyTorch contêm o parâmetro distribution que você pode usar para especificar parâmetros de configuração para usar estruturas de treinamento distribuídas. A biblioteca paralela de modelos do SageMaker usa internamente o 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 estimador TensorFlow ou PyTorch mostra como configurar o parâmetro distribution para usar a biblioteca paralela de modelos do SageMaker 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 as chaves "smdistributed" e "mpi" por meio do argumento distribution dos construtores do estimador do SageMaker.

Parâmetros de configuração para paralelismo do modelo SageMaker

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 paralelismo do modelo SageMaker.
  - Para obter uma lista completa dos parâmetros comuns, consulte Parâmetros para smdistributed na documentação do SDK do SageMaker para Python.
    
    Para o TensorFlow, consulte Parâmetros específicos do TensorFlow.
    
    Para PyTorch, consulte Parâmetros específicos do PyTorch.
  - "pipeline_parallel_degree" (ou "partitions" em smdistributed-modelparallel<v1.6.0) — Obrigatório. Entre os parâmetros para smdistributed, 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 para a configuração do paralelismo do modelo SageMaker e Notas da versão paralela do modelo distribuído do SageMaker na documentação do SDK do SageMaker Python.
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. No SageMaker, um host é uma única instância de ML do Amazon EC2. O SDK do SageMaker para Python mantém um mapeamento individual entre processos e GPUs em todo o paralelismo de modelos e dados. Isso significa que o SageMaker agenda cada processo em uma única GPU separada e nenhuma GPU contém mais de um processo. Se você estiver usando o PyTorch, deverá restringir cada processo ao seu próprio dispositivo. torch.cuda.set_device(smp.local_rank()) Para saber mais, consulte Divisão automatizada com PyTorch.
  
  Importante
  process_per_hostnã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 paralelo do modelo SageMaker, execute a função estimator.fit().

Use os recursos a seguir para saber mais sobre o uso dos atributos de paralelismo de modelos no SDK do SageMaker para Python:

Recomendamos que você use uma instância do bloco de anotações do SageMaker 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 bloco de anotações do SageMaker, consulte. Exemplos da biblioteca de paralelismo de modelos do Amazon SageMaker v2
Você também pode enviar um trabalho de treinamento distribuído de sua máquina usando AWS CLI. Para configurar AWS CLI na sua máquina, consulte Configurar suas AWS credenciais e a região para desenvolvimento.

Estenda um contêiner Docker predefinido que contém a biblioteca paralela de modelos distribuídos do SageMaker

Para estender um contêiner predefinido e usar a biblioteca de paralelismo de modelos do SageMaker, use uma das imagens de Deep Learning Containers (DLC) disponíveis para PyTorch ou TensorFlow AWS. A biblioteca de paralelismo do modelo SageMaker está incluída nas imagens DLC TensorFlow (2.3.0 e posterior) e PyTorch (1.6.0 e posterior) com CUDA (cuxyz). Para obter uma lista completa de imagens de DLC, consulte Imagens de contêineres de Aprendizado profundo disponíveis no repositório GitHub de contêineres de aprendizado profundo AWS.

dica

Recomendamos que você use a imagem que contém a versão mais recente do TensorFlow ou do PyTorch para acessar a versão mais atualizada da biblioteca de paralelismo de modelos do SageMaker.

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

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

dica

Você deve enviar esse contêiner do Docker ao Amazon Elastic Container Registry (Amazon ECR) e usar o URI de imagem (image_uri) para definir um estimador do SageMaker para treinamento. Para ter mais informações, consulte Estenda uma imagem de contêiner predefinida.

Depois de terminar de hospedar o contêiner Docker e recuperar o URI da imagem do contêiner, crie um objeto estimador PyTorch do SageMaker 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 distribuídos do SageMaker

Para criar seu próprio contêiner Docker para treinamento e usar a biblioteca paralela do modelo SageMaker, você deve incluir as dependências corretas e os arquivos binários das bibliotecas paralelas distribuídas do SageMaker 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 treinamento do SageMaker e a biblioteca paralela de modelos em seu próprio contêiner Docker.

nota

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

Para criar um Dockerfile com o kit de ferramentas de treinamento do SageMaker e a biblioteca paralela de modelos

Comece com uma das imagens básicas do 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. Recomendamos que você consulte os Dockerfiles oficiais do AWS Deep Learning Container for PyTorch para 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 do SageMaker e do Deep Learning Container. No link fornecido, escolha a versão do PyTorch que você usa, escolha a pasta CUDA (cuxyz) e escolha o Dockerfile que termina com .gpu ou .sagemaker.gpu.
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), NVIDIA Collective Communications Library (NCCL) e Open MPI. Dependendo das versões de PyTorch e CUDA escolhidas, você deve instalar versões compatíveis das bibliotecas.

Importante
Como a biblioteca paralela do modelo SageMaker exige a biblioteca paralela de dados do SageMaker nas etapas subsequentes, é altamente recomendável que você siga as instruções em Crie seu próprio contêiner do Docker com a biblioteca de paralelismo dos dados distribuídos do SageMaker para configurar adequadamente um ambiente de treinamento do SageMaker 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 e Começar com EFA e NCCL.

Adicione os argumentos a seguir para especificar os URLs dos pacotes de treinamento distribuídos do SageMaker para PyTorch. A biblioteca paralela do modelo SageMaker exige que a biblioteca paralela de dados do SageMaker use o Acesso Direto à Memória (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

Instale as dependências que a biblioteca paralela do modelo SageMaker exige.

Instale a biblioteca METIS.


ARG METIS=metis-5.1.0

RUN rm /etc/apt/sources.list.d/* \
  && wget -nv http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/${METIS}.tar.gz \
  && gunzip -f ${METIS}.tar.gz \
  && tar -xvf ${METIS}.tar \
  && cd ${METIS} \
  && apt-get update \
  && make config shared=1 \
  && make install \
  && cd .. \
  && rm -rf ${METIS}.tar* \
  && rm -rf ${METIS} \
  && rm -rf /var/lib/apt/lists/* \
  && apt-get clean

Instale a biblioteca RAPIDS Memory Manager. Isso requer o CMake 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}

Instale a biblioteca de paralelismo de modelos do SageMaker.
```
RUN pip install --no-cache-dir -U ${SMD_MODEL_PARALLEL_URL}
```

Instale a biblioteca de paralelismo de modelos do SageMaker.


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

Instale o kit de ferramentas de treinamento do SageMaker. O kit de ferramentas contém a funcionalidade comum necessária para criar um contêiner compatível com a plataforma de treinamento do SageMaker e o SDK do SageMaker Python.
```
RUN pip install sagemaker-training
```
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 e hospedá-lo no Amazon ECR.

dica

Para obter mais informações gerais sobre a criação de um Dockerfile personalizado para treinamento no SageMaker, consulte Use seus próprios algoritmos de treinamento.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

PyTorch

Apontando pontos de verificação e ajustando um modelo com paralelismo de modelos

Etapa 2: Iniciar um trabalho de treinamento usando o SDK do SageMaker para Python

Tópicos

Usando os estimadores TensorFlow e PyTorch do SageMaker

Parâmetros de configuração para paralelismo do modelo SageMaker

nota

Importante

Importante

nota

dica

Estenda um contêiner Docker predefinido que contém a biblioteca paralela de modelos distribuídos do SageMaker

dica

dica

Crie seu próprio contêiner Docker com a biblioteca paralela de modelos distribuídos do SageMaker

nota

Para criar um Dockerfile com o kit de ferramentas de treinamento do SageMaker e a biblioteca paralela de modelos

dica

Importante

dica