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á.
# Biblioteca de paralelismo de modelos do SageMaker v1.x (arquivada)
**Importante**
Em 19 de dezembro de 2023, foi lançada a biblioteca de paralelismo de modelos (SMP) v2 do SageMaker. Em benefício da biblioteca de SMP v2, os recursos de SMP v1 não serão mais acessíveis em versões futuras. A seção e os tópicos a seguir são arquivados e específicos para o uso da biblioteca de SMP v1. Para obter mais informações sobre o uso da biblioteca de SMP v2, consulte [Biblioteca de paralelismo de modelos do SageMaker v2](model-parallel-v2.md).
Use a biblioteca de paralelismo de modelos do Amazon SageMaker AI para treinar grandes modelos de aprendizado profundo (DL) que são difíceis de treinar devido a limitações de memória da GPU. A biblioteca divide um modelo de forma automática e eficiente em várias GPUs e instâncias. Usando a biblioteca, você pode obter uma precisão de predição de metas mais rapidamente treinando com eficiência modelos DL maiores com bilhões ou trilhões de parâmetros.
Você pode usar a biblioteca para particionar automaticamente seus próprios modelos do TensorFlow e do PyTorch em várias GPUs e vários nós com o mínimo de alterações no código. Você pode acessar a API da biblioteca por meio do SageMaker Python SDK.
Use as seções a seguir para saber mais sobre o paralelismo de modelos e a biblioteca paralela de modelos do SageMaker. A documentação da API dessa biblioteca está localizada em [APIs de treinamento distribuído](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html), na *documentação do SageMaker Python SDK v2.199.0*.
**Topics**
+ [Introdução ao paralelismo de modelos](model-parallel-intro.md)
+ [Estruturas suportadas e Regiões da AWS](distributed-model-parallel-support.md)
+ [Principais características da biblioteca de SageMaker paralelismo de modelos](model-parallel-core-features.md)
+ [Execute um trabalho de treinamento SageMaker distribuído com paralelismo de modelos](model-parallel-use-api.md)
+ [Apontando pontos de verificação e ajustando um modelo com paralelismo de modelos](distributed-model-parallel-checkpointing-and-finetuning.md)
+ [Exemplos da biblioteca de paralelismo de modelos Amazon SageMaker AI v1](distributed-model-parallel-examples.md)
+ [SageMaker Melhores práticas de paralelismo de modelos distribuídos](model-parallel-best-practices.md)
+ [Dicas e armadilhas de configuração da SageMaker Distributed Model Parallelism Library](model-parallel-customize-tips-pitfalls.md)
+ [Solução de problemas de paralelismo do modelo](distributed-troubleshooting-model-parallel.md)
# Introdução ao paralelismo de modelos
O paralelismo de modelos é um método de treinamento distribuído no qual o modelo de aprendizado profundo é particionado em vários dispositivos, dentro de ou entre instâncias. Esta página de introdução fornece uma visão geral de alto nível sobre o paralelismo de modelos, uma descrição de como ele pode ajudar a superar os problemas que surgem ao treinar modelos de DL que normalmente são muito grandes e exemplos do que a biblioteca paralela de modelos oferece para ajudar a gerenciar estratégias SageMaker paralelas de modelos, bem como o consumo de memória.
## O que é paralelismo de modelos?
Aumentar o tamanho dos modelos de aprendizado profundo (camadas e parâmetros) gera maior precisão para tarefas complexas, como visão computacional e processamento de linguagem natural. No entanto, há um limite para o tamanho máximo do modelo que você pode colocar na memória de uma única GPU. Ao treinar modelos de DL, as limitações de memória da GPU podem ser gargalos das seguintes maneiras:
+ Limitam o tamanho do modelo que você pode treinar, já que a área ocupada pela memória de um modelo é escalada proporcionalmente ao número de parâmetros.
+ Limitam o tamanho do lote por GPU durante o treinamento, reduzindo a utilização da GPU e a eficiência do treinamento.
Para superar as limitações associadas ao treinamento de um modelo em uma única GPU, SageMaker fornece a biblioteca paralela de modelos para ajudar a distribuir e treinar modelos de DL de forma eficiente em vários nós de computação. Além disso, com a biblioteca, você pode obter o treinamento distribuído mais otimizado usando dispositivos compatíveis com a EFA, que aprimoram o desempenho da comunicação entre nós com baixa latência, alto throughput e desvio do sistema operacional.
## Estime os requisitos de memória antes de usar o paralelismo do modelo
Antes de usar a biblioteca paralela de SageMaker modelos, considere o seguinte para ter uma ideia dos requisitos de memória para treinar grandes modelos de DL.
Para um trabalho de treinamento que usa os otimizadores AMP (FP16) e Adam, a memória de GPU necessária por parâmetro é de cerca de 20 bytes, que podemos dividir da seguinte forma:
+ Um FP16 parâmetro de \$1 2 bytes
+ Um FP16 gradiente de \$1 2 bytes
+ Um estado de FP32 otimizador de \$1 8 bytes com base nos otimizadores Adam
+ Uma FP32 cópia do parâmetro \$1 4 bytes (necessária para a operação `optimizer apply` (OA))
+ Uma FP32 cópia do gradiente de \$1 4 bytes (necessária para a operação OA)
Mesmo para um modelo DL relativamente pequeno com 10 bilhões de parâmetros, ele pode exigir pelo menos 200 GB de memória, que é muito mais do que a memória típica da GPU (por exemplo, NVIDIA A100 com 40/80 GB de memória e V100 com 16/32 GB) disponível em uma única GPU. Observe que, além dos requisitos de memória para os estados do modelo e do otimizador, há outros consumidores de memória, como ativações geradas na passagem direta. A memória necessária pode ser muito superior a 200 GB.
Para treinamento distribuído, recomendamos que você use instâncias P3 e P4 do Amazon EC2 que tenham NVIDIA V100 e A100 Tensor Core, respectivamente. GPUs Para obter mais detalhes sobre especificações como núcleos de CPU, RAM, volume de armazenamento anexado e largura de banda de rede, consulte a seção *Computação acelerada* na página [Tipos de instância do Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
Mesmo com as instâncias com computação acelerada, é óbvio que modelos com cerca de 10 bilhões de parâmetros, como Megatron-LM e T5, e modelos ainda maiores com centenas de bilhões de parâmetros, como GPT-3, não cabem réplicas de modelos em cada dispositivo de GPU.
## Como a biblioteca emprega técnicas de paralelismo de modelos e economia de memória
A biblioteca consiste em vários tipos de atributos de paralelismo de modelos e atributos de economia de memória, como fragmentação de estado do otimizador, ponto de verificação de ativação e descarregamento de ativação. Todas essas técnicas podem ser combinadas para treinar com eficiência modelos grandes que consistem em centenas de bilhões de parâmetros.
**Topics**
+ [Paralelismo de dados fragmentados (disponível para) PyTorch](#model-parallel-intro-sdp)
+ [Paralelismo de tubulação (disponível para e) PyTorch TensorFlow](#model-parallel-intro-pp)
+ [Paralelismo de tensores (disponível para) PyTorch](#model-parallel-intro-tp)
+ [Fragmentação de estado do otimizador (disponível para) PyTorch](#model-parallel-intro-oss)
+ [Ativação, descarregamento e ponto de verificação (disponível para) PyTorch](#model-parallel-intro-activation-offloading-checkpointing)
+ [Escolhendo as técnicas certas para seu modelo](#model-parallel-intro-choosing-techniques)
### Paralelismo de dados fragmentados (disponível para) PyTorch
O *paralelismo de dados fragmentados* é uma técnica de treinamento distribuído que economiza memória e divide o estado de um modelo (parâmetros do modelo, gradientes e estados do otimizador) em um grupo paralelo de dados. GPUs
SageMaker **[A IA implementa o paralelismo de dados compartilhados por meio da implementação do MICS, que é uma biblioteca que minimiza a comunicação em escala e é discutida na postagem do **blog** Escalonamento **quase linear** do treinamento em modelos gigantes. AWS](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws)**
Você pode aplicar paralelismo de dados fragmentados ao seu modelo como uma estratégia independente. Além disso, se você estiver usando as instâncias de GPU de melhor desempenho equipadas com o NVIDIA A100 Tensor Core GPUs`ml.p4d.24xlarge`, você pode aproveitar a velocidade de treinamento aprimorada da `AllGather` operação oferecida pela SMDDP Collectives.
Para se aprofundar no paralelismo de dados fragmentados e aprender como configurá-lo ou usar uma combinação de paralelismo de dados fragmentados com outras técnicas, como paralelismo de tensores e treinamento, consulte. FP16 [Paralelismo de dados compartilhados](model-parallel-extended-features-pytorch-sharded-data-parallelism.md)
### Paralelismo de tubulação (disponível para e) PyTorch TensorFlow
O *paralelismo do pipeline* particiona o conjunto de camadas ou operações no conjunto de dispositivos, deixando cada operação intacta. Quando você especifica um valor para o número de partições do modelo (`pipeline_parallel_degree`), o número total de GPUs (`processes_per_host`) deve ser divisível pelo número das partições do modelo. Para configurar isso corretamente, é preciso especificar os valores corretos para os parâmetros `pipeline_parallel_degree` e `processes_per_host`. A matemática simples é a seguinte:
```
(pipeline_parallel_degree) x (data_parallel_degree) = processes_per_host
```
A biblioteca se encarrega de calcular o número de réplicas do modelo (também chamado `data_parallel_degree`) de acordo com os dois parâmetros de entrada que você fornece.
Por exemplo, se você definir `"pipeline_parallel_degree": 2` e `"processes_per_host": 8` usar uma instância de ML com oito trabalhadores de GPU`ml.p3.16xlarge`, como, por exemplo, a biblioteca configura automaticamente o modelo distribuído em todo o GPUs paralelismo de dados quadridirecional. A imagem a seguir ilustra como um modelo é distribuído entre os oito, GPUs alcançando o paralelismo de dados quadridirecional e o paralelismo bidirecional do pipeline. Cada réplica do modelo, na qual a definimos como um *grupo paralelo de pipeline* e a rotulamos como`PP_GROUP`, é particionada em duas. GPUs Cada partição do modelo é atribuída a quatro GPUs, onde as quatro réplicas de partição estão em um *grupo paralelo de dados* e são rotuladas como. `DP_GROUP` Sem paralelismo de tensores, o grupo paralelo do pipeline é essencialmente o grupo paralelo do modelo.
![\[Como um modelo é distribuído entre os oito, GPUs alcançando o paralelismo de dados de quatro vias e o paralelismo bidirecional do pipeline.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-pipeline-parallel-only.png)
Para se aprofundar no paralelismo do pipeline, consulte [Principais características da biblioteca de SageMaker paralelismo de modelos](model-parallel-core-features.md).
Para começar a executar seu modelo usando o paralelismo de pipeline, consulte [Run a Distributed SageMaker Training Job with the SageMaker Model](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-use-api.html) Parallel Library.
### Paralelismo de tensores (disponível para) PyTorch
O *paralelismo de tensores* divide camadas individuais ou `nn.Modules`, entre dispositivos, para ser executado em paralelo. A figura a seguir mostra o exemplo mais simples de como a biblioteca divide um modelo com quatro camadas para obter o paralelismo de tensores bidirecionais (`"tensor_parallel_degree": 2`). As camadas de cada réplica do modelo são divididas ao meio e distribuídas em duas. GPUs Nesse caso de exemplo, a configuração paralela do modelo também inclui `"pipeline_parallel_degree": 1` and `"ddp": True` (usa o PyTorch DistributedDataParallel pacote em segundo plano), então o grau de paralelismo de dados se torna oito. A biblioteca gerencia a comunicação entre as réplicas do modelo distribuído por tensor.
![\[O exemplo mais simples de como a biblioteca divide um modelo com quatro camadas para obter o paralelismo bidirecional de tensores ("tensor_parallel_degree": 2).\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-tensor-parallel-only.png)
A utilidade desse atributo está no fato de que você pode selecionar camadas específicas ou um subconjunto de camadas para aplicar o paralelismo de tensores. Para se aprofundar no paralelismo de tensores e em outros recursos de economia de memória e aprender como definir uma combinação de paralelismo de pipeline e tensor PyTorch, consulte. [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md)
### Fragmentação de estado do otimizador (disponível para) PyTorch
Para entender como a biblioteca executa a *fragmentação de estado do otimizador*, considere um modelo de exemplo simples com quatro camadas. A ideia principal para otimizar a fragmentação de estado é que você não precisa replicar o estado do otimizador em todos os seus. GPUs Em vez disso, uma única réplica do estado do otimizador é fragmentada em classificações paralelas de dados, sem redundância entre dispositivos. Por exemplo, a GPU 0 mantém o estado do otimizador para a camada um, a próxima GPU 1 mantém o estado do otimizador para a L2 e assim por diante. A figura animada a seguir mostra uma propagação inversa com a técnica de fragmentação de estado do otimizador. No final da propagação reversa, há tempo de computação e rede para a operação `optimizer apply` (OA) atualizar os estados do otimizador e a operação `all-gather` (AG) para atualizar os parâmetros do modelo para a próxima iteração. Mais importante ainda, a operação `reduce` pode se sobrepor à computação na GPU 0, resultando em uma propagação retroativa mais rápida e eficiente em termos de memória. Na implantação atual, as operações AG e OA não se sobrepõem a `compute`. Isso pode resultar em uma computação estendida durante a operação do AG, portanto, pode haver uma compensação.
![\[Uma propagação inversa com a técnica de fragmentação de estado do otimizador.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/smdmp-optimizer-state-sharding.gif)
Para obter mais informações sobre como usar esse atributo, consulte [Fragmentação do estado do otimizador](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-optimizer-state-sharding.html).
### Ativação, descarregamento e ponto de verificação (disponível para) PyTorch
Para economizar memória da GPU, a biblioteca oferece apoio ao ponto de verificação de ativação para evitar o armazenamento de ativações internas na memória da GPU para módulos especificados pelo usuário durante a passagem direta. A biblioteca recalcula essas ativações durante a retropassagem. Além disso, o atributo de descarregamento de ativação descarrega as ativações armazenadas na memória da CPU e retorna à GPU durante a retropassagem para reduzir ainda mais o espaço ocupado pela memória de ativação. Para mais informações sobre como usar esses atributo, consulte [Ponto de verificação de ativação](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-activation-checkpointing.html) e [Descarregamento de ativação](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-activation-offloading.html).
### Escolhendo as técnicas certas para seu modelo
Para obter mais informações sobre como escolher as técnicas e configurações corretas, consulte [Melhores práticas paralelas do modelo SageMaker distribuído](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-best-practices.html) e [dicas e armadilhas de configuração](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-customize-tips-pitfalls.html).
# Estruturas suportadas e Regiões da AWS
Antes de usar a biblioteca de paralelismo de SageMaker modelos, verifique as estruturas e os tipos de instância compatíveis e determine se há cotas suficientes em sua conta e. AWS Região da AWS
**nota**
Para verificar as atualizações e notas de lançamento mais recentes da biblioteca, consulte as [Notas de versão do SageMaker Model Parallel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) na documentação do *SDK para SageMaker Python*.
## Estruturas compatíveis
A biblioteca de paralelismo de SageMaker modelos oferece suporte às seguintes estruturas de aprendizado profundo e está disponível em AWS Deep Learning Containers (DLC) ou pode ser baixada como um arquivo binário.
PyTorch versões suportadas pela SageMaker IA e pela biblioteca de SageMaker paralelismo de modelos
| PyTorch versão | SageMaker versão da biblioteca de paralelismo do modelo | URI da imagem DLC integrado `smdistributed-modelparallel` | URL do arquivo binário\$1\$1 |
| --- | --- | --- | --- |
| v2.0.0 | smdistributed-modelparallel==v1.15.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.0-gpu-py310-cu118-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-2.0.0/artefatos de construção/2023-04-14-20-14/smdistributed\$1modelparallel-1.15.0-cp310-cp310-linux\$1x86\$164.whl |
| v1.13.1 | smdistributed-modelparallel==v1.15.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.13.1-gpu-py39-cu117-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.13.1/artefatos de construção/2023-04-17-15-49/smdistributed\$1modelparallel-1.15.0-cp39-cp39-linux\$1x86\$164.whl |
| v1.12.1 | smdistributed-modelparallel==v1.13.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.1-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.12.1/artefatos de construção/2022-12-08-21-34/smdistributed\$1modelparallel-1.13.0-cp38-cp38-linux\$1x86\$164.whl |
| v1.12.0 | smdistributed-modelparallel==v1.11.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.12.0/artefatos de construção/2022-08-12-16-58/smdistributed\$1modelparallel-1.11.0-cp38-cp38-linux\$1x86\$164.whl |
| v1.11.0 | smdistributed-modelparallel==v1.10.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.11.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.11.0/artefatos de construção/2022-07-11-19-23/smdistributed\$1modelparallel-1.10.0-cp38-cp38-linux\$1x86\$164.whl |
| v1.10.2 | smdistributed-modelparallel==v1.7.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.10.2-gpu-py38-cu113-ubuntu20.04-sagemaker` | - |
| v1.10.0 | smdistributed-modelparallel==v1.5.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.10.0-gpu-py38-cu113-ubuntu20.04-sagemaker` | - |
| v1.9.1 | smdistributed-modelparallel==v1.4.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.9.1-gpu-py38-cu111-ubuntu20.04` | - |
| v1.8.1\$1 | smdistributed-modelparallel==v1.6.0 | `763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.8.1-gpu-py36-cu111-ubuntu18.04` | - |
**nota**
A biblioteca de paralelismo de SageMaker modelos v1.6.0 e versões posteriores fornece recursos estendidos para o. PyTorch Para obter mais informações, consulte [Principais características da biblioteca de SageMaker paralelismo de modelos](model-parallel-core-features.md).
\$1\$1 Os URLs arquivos binários são para instalar a biblioteca de paralelismo de SageMaker modelos em contêineres personalizados. Para obter mais informações, 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).
TensorFlow versões suportadas pela SageMaker IA e pela biblioteca de SageMaker paralelismo de modelos
| TensorFlow versão | SageMaker versão da biblioteca de paralelismo do modelo | URI da imagem DLC integrado `smdistributed-modelparallel` |
| --- | --- | --- |
| v2.6.0 | smdistributed-modelparallel==v1.4.0 | 763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.6.0-gpu-py38-cu112-ubuntu20.04 |
| v2.5.1 | smdistributed-modelparallel==v1.4.0 | 763104351884.dkr.ecr..amazonaws.com/tensorflow-training:2.5.1-gpu-py37-cu112-ubuntu18.04 |
**Versões do Hugging Face Transformers suportadas pela SageMaker IA e pela biblioteca paralela de dados distribuídos SageMaker**
Os AWS Deep Learning Containers for Hugging Face usam os SageMaker Training Containers para PyTorch e TensorFlow como suas imagens base. [Para consultar as versões e as versões emparelhadas da biblioteca Hugging Face Transformers, consulte as versões mais recentes do Hugging Face Containers PyTorch e TensorFlow as versões anteriores do [Hugging Face Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#huggingface-training-containers).](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#prior-hugging-face-container-versions)
## Regiões da AWS
A biblioteca paralela de SageMaker dados está disponível em todos os locais em Regiões da AWS que os [AWS Deep Learning Containers SageMaker](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) estão em serviço. Para obter mais informações, consulte as [Imagens disponíveis de contêineres de aprendizado profundo](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#available-deep-learning-containers-images).
## Tipos de instâncias compatíveis
A biblioteca de paralelismo de SageMaker modelos exige um dos seguintes tipos de instância de ML.
| Tipo de instância |
| --- |
| ml.g4dn.12xlarge |
| ml.p3.16xlarge |
| ml.p3dn.24xlarge |
| ml.p4d.24xlarge |
| ml.p4de.24xlarge |
Para especificações dos tipos de instância, consulte a seção **Computação acelerada** na [página Tipos de instância do Amazon EC2](https://aws.amazon.com/ec2/instance-types/). Para obter informações sobre preços de instâncias, consulte [Amazon SageMaker AI Pricing](https://aws.amazon.com/sagemaker/pricing/).
Se você encontrou uma mensagem de erro semelhante à seguinte, siga as instruções em [Solicitar um aumento da cota de serviço para recursos de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html#service-limit-increase-request-procedure).
```
ResourceLimitExceeded: An error occurred (ResourceLimitExceeded) when calling
the CreateTrainingJob operation: The account-level service limit 'ml.p3dn.24xlarge
for training job usage' is 0 Instances, with current utilization of 0 Instances
and a request delta of 1 Instances.
Please contact AWS support to request an increase for this limit.
```
# Principais características da biblioteca de SageMaker paralelismo de modelos
A biblioteca de paralelismo de modelos da Amazon SageMaker AI oferece estratégias de distribuição e técnicas de economia de memória, como paralelismo de dados fragmentados, paralelismo de tensores, particionamento de modelos por camadas para agendamento de pipeline e pontos de verificação. As estratégias e técnicas de paralelismo de modelos ajudam a distribuir modelos grandes em vários dispositivos, otimizando a velocidade de treinamento e o consumo de memória. A biblioteca também fornece funções auxiliares, gerenciadores de contexto e funções de wrapper do Python para adaptar seu script de treinamento para particionamento automático ou manual do seu modelo.
Ao implementar o paralelismo de modelos em seu trabalho de treinamento, você mantém o mesmo fluxo de trabalho em duas etapas mostrado na seção [Executar um trabalho de SageMaker treinamento distribuído com](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-use-api.html) paralelismo de modelos. Para adaptar seu script de treinamento, você adicionará zero ou poucas linhas de código adicionais ao seu script de treinamento. Para iniciar um trabalho de treinamento do script de treinamento adaptado, você precisará definir os parâmetros de configuração da distribuição para ativar os atributos de economia de memória ou para passar valores para o grau de paralelismo.
Para começar com exemplos, consulte os seguintes cadernos Jupyter que demonstram como usar a biblioteca de paralelismo de SageMaker modelos.
+ [PyTorch exemplos de cadernos](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel)
+ [TensorFlow exemplos de cadernos](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/tensorflow/model_parallel/mnist)
Para se aprofundar nos principais atributos da biblioteca, consulte os tópicos a seguir.
**nota**
As bibliotecas de treinamento SageMaker distribuídas estão disponíveis por meio dos contêineres de aprendizado AWS profundo do Hugging Face e TensorFlow na plataforma de treinamento. PyTorch SageMaker Para utilizar os recursos das bibliotecas de treinamento distribuídas, recomendamos que você use o SDK do SageMaker Python. Você também pode configurar manualmente a sintaxe de solicitação JSON se usar SageMaker APIs por meio do SDK for Python (Boto3) ou. AWS Command Line Interface Em toda a documentação, as instruções e os exemplos se concentram em como usar as bibliotecas de treinamento distribuídas com o SDK do SageMaker Python.
**Importante**
A biblioteca de paralelismo de SageMaker modelos oferece suporte a todos os recursos principais e oferece suporte ao paralelismo de pipeline para PyTorch. TensorFlow
**Topics**
+ [Paralelismo de dados compartilhados](model-parallel-extended-features-pytorch-sharded-data-parallelism.md)
+ [Programação de um modelo](model-parallel-core-features-pipieline-parallelism.md)
+ [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md)
+ [Fragmentação de estado do otimizador](model-parallel-extended-features-pytorch-optimizer-state-sharding.md)
+ [Ponto de verificação de ativação](model-parallel-extended-features-pytorch-activation-checkpointing.md)
+ [Ativação e descarregamento](model-parallel-extended-features-pytorch-activation-offloading.md)
+ [FP16 Treinamento com paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md)
+ [Support for FlashAttention](model-parallel-attention-head-size-for-flash-attention.md)
# Paralelismo de dados compartilhados
O *paralelismo de dados fragmentados* é uma técnica de treinamento distribuído que economiza memória e divide o estado de um modelo (parâmetros do modelo, gradientes e estados do otimizador) em um grupo paralelo de dados. GPUs
**nota**
O paralelismo de dados fragmentados está disponível PyTorch na biblioteca de paralelismo de SageMaker modelos v1.11.0 e versões posteriores.
Ao escalar seu trabalho de treinamento para um grande cluster de GPU, você pode reduzir o espaço de memória por GPU do modelo fragmentando o estado de treinamento do modelo em vários. GPUs Isso traz dois benefícios: você pode ajustar modelos maiores, que de outra forma ficariam sem memória com o paralelismo de dados padrão, ou você pode aumentar o tamanho do lote usando a memória liberada da GPU.
A técnica padrão de paralelismo de dados replica os estados de treinamento no grupo paralelo de dados e GPUs executa a agregação de gradientes com base na operação. `AllReduce` O paralelismo de dados fragmentados modifica o procedimento padrão de treinamento distribuído em paralelo a dados para considerar a natureza fragmentada dos estados do otimizador. Um grupo de classificações nas quais os estados do modelo e do otimizador são fragmentados é chamado de *grupo de fragmentação*. *A técnica de paralelismo de dados fragmentados fragmenta os parâmetros treináveis de um modelo e os gradientes e estados do otimizador correspondentes em todo o grupo de fragmentação. GPUs *
SageMaker A IA alcança o paralelismo de dados fragmentados por meio da implementação de MICs, que é discutida na postagem do AWS blog Escalonamento [quase](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws) linear do treinamento de modelos gigantes em. AWS Nessa implementação, você pode definir o grau de fragmentação como um parâmetro configurável, que deve ser menor que o grau de paralelismo de dados. Durante cada passagem para frente e para trás, os MICs recombinam temporariamente os parâmetros do modelo em GPUs toda a operação. `AllGather` Após a passagem para frente ou para trás de cada camada, os MiCS fragmentam os parâmetros novamente para economizar memória da GPU. Durante a passagem para trás, os MICs reduzem os gradientes e, simultaneamente, os fragmentam durante a operação. GPUs `ReduceScatter` Por fim, os MiCS aplicam os gradientes locais reduzidos e fragmentados aos fragmentos de parâmetros locais correspondentes, usando os fragmentos locais dos estados do otimizador. Para reduzir a sobrecarga de comunicação, a biblioteca de paralelismo de SageMaker modelos pré-busca as próximas camadas na passagem para frente ou para trás e sobrepõe a comunicação de rede à computação.
O estado de treinamento do modelo é replicado nos grupos de fragmentação. Isso significa que antes que os gradientes sejam aplicados aos parâmetros, a operação `AllReduce` deve ocorrer nos grupos de fragmentação, além da operação `ReduceScatter` que ocorre dentro do grupo de fragmentação.
Na verdade, o paralelismo de dados fragmentados introduz uma compensação entre a sobrecarga de comunicação e a eficiência da memória da GPU. Usar o paralelismo de dados fragmentados aumenta o custo de comunicação, mas o espaço de memória por GPU (excluindo o uso de memória devido a ativações) é dividido pelo grau de paralelismo de dados fragmentados, portanto, modelos maiores podem caber no cluster de GPU.
**Seleção do grau de paralelismo de dados fragmentados**
Quando você seleciona um valor para o grau de paralelismo de dados fragmentados, o valor deve dividir uniformemente o grau de paralelismo de dados. Por exemplo, para um trabalho de paralelismo de dados de 8 vias, escolha 2, 4 ou 8 para o grau de paralelismo de dados fragmentados. Ao escolher o grau de paralelismo de dados fragmentados, recomendamos que você comece com um número pequeno e aumente gradualmente até que o modelo caiba na memória junto com o tamanho de lote desejado.
**Seleção do tamanho do lote**
Depois de configurar o paralelismo de dados fragmentados, certifique-se de encontrar a configuração de treinamento ideal que possa ser executada com êxito no cluster da GPU. Para treinar modelos de linguagem grande (LLM), comece com o tamanho do lote 1 e aumente-o gradualmente até chegar ao ponto de receber o erro out-of-memory (OOM). Se você encontrar o erro OOM mesmo com o menor tamanho de lote, aplique um grau mais alto de paralelismo de dados fragmentados ou uma combinação de paralelismo de dados fragmentados e paralelismo de tensores.
**Topics**
+ [Como aplicar o paralelismo de dados fragmentados ao seu trabalho de treinamento](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use)
+ [Configurações de referência](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use-config-sample)
+ [Paralelismo de dados fragmentados com coletivos SMDDP](#model-parallel-extended-features-pytorch-sharded-data-parallelism-smddp-collectives)
+ [Treinamento misto de precisão com paralelismo de dados fragmentados](#model-parallel-extended-features-pytorch-sharded-data-parallelism-16bits-training)
+ [Paralelismo de dados fragmentados com paralelismo de tensores](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism)
+ [Dicas e considerações para usar o paralelismo de dados fragmentados](#model-parallel-extended-features-pytorch-sharded-data-parallelism-considerations)
## Como aplicar o paralelismo de dados fragmentados ao seu trabalho de treinamento
Para começar com o paralelismo de dados fragmentados, aplique as modificações necessárias em seu script de treinamento e configure o SageMaker PyTorch estimador com os parâmetros. sharded-data-parallelism-specific Considere também usar valores de referência e exemplos de cadernos como ponto de partida.
### Adapte seu roteiro PyTorch de treinamento
Siga as instruções na [Etapa 1: Modifique um script de PyTorch treinamento](model-parallel-customize-training-script-pt.md) para agrupar os objetos do modelo e do otimizador com os `smdistributed.modelparallel.torch` invólucros dos módulos `torch.nn.parallel` e. `torch.distributed`
**(Opcional) Modificação adicional para registrar os parâmetros externos do modelo**
Se seu modelo for construído com `torch.nn.Module` e usar parâmetros que não estão definidos na classe do módulo, você deve registrá-los manualmente no módulo para que o SMP colete os parâmetros completos enquanto. Para registrar parâmetros em um módulo, use `smp.register_parameter(module, parameter)`.
```
class Module(torch.nn.Module):
def __init__(self, *args):
super().__init__(self, *args)
self.layer1 = Layer1()
self.layer2 = Layer2()
smp.register_parameter(self, self.layer1.weight)
def forward(self, input):
x = self.layer1(input)
# self.layer1.weight is required by self.layer2.forward
y = self.layer2(x, self.layer1.weight)
return y
```
### Configurar o SageMaker PyTorch estimador
Ao configurar um SageMaker PyTorch estimador em[Etapa 2: Iniciar um Training Job usando o SageMaker Python SDK](model-parallel-sm-sdk.md), adicione os parâmetros para paralelismo de dados fragmentados.
Para ativar o paralelismo de dados fragmentados, adicione o `sharded_data_parallel_degree` parâmetro ao Estimador. SageMaker PyTorch Esse parâmetro especifica o número GPUs sobre o qual o estado de treinamento é fragmentado. O valor de `sharded_data_parallel_degree` deve ser um número inteiro entre um e o grau de paralelismo de dados e deve dividir uniformemente o grau de paralelismo de dados. Observe que a biblioteca detecta automaticamente o número de, GPUs portanto, o grau paralelo dos dados. Os parâmetros adicionais a seguir estão disponíveis para configurar o paralelismo de dados fragmentados.
+ `"sdp_reduce_bucket_size"`*(int, default: 5e8)* — Especifica o tamanho dos compartimentos de [gradiente PyTorch DDP em número de elementos](https://pytorch.org/docs/stable/notes/ddp.html#internal-design) do dtype padrão.
+ `"sdp_param_persistence_threshold"`*(int, default: 1e6)*: Especifica o tamanho de um tensor de parâmetros em número de elementos que podem persistir em cada GPU. O paralelismo de dados fragmentados divide cada tensor de parâmetros em um grupo paralelo de GPUs dados. Se o número de elementos no tensor do parâmetro for menor que esse limite, o tensor do parâmetro não será dividido; isso ajuda a reduzir a sobrecarga de comunicação porque o tensor do parâmetro é replicado em dados paralelos. GPUs
+ `"sdp_max_live_parameters"`*(int, default: 1e9)*: Especifica o número máximo de parâmetros que podem estar simultaneamente em um estado de treinamento recombinado durante a passagem para frente e para trás. A busca de parâmetros com a operação `AllGather` é interrompida quando o número de parâmetros ativos atinge o limite determinado. Observe que aumentar esse parâmetro aumenta o espaço ocupado pela memória.
+ `"sdp_hierarchical_allgather"`*(bool, default: True)*: Se definida como `True`, a operação `AllGather` é executada hierarquicamente: ela é executada primeiro em cada nó e depois em todos os nós. Para trabalhos de treinamento distribuídos de vários nós, a operação `AllGather` hierárquica é ativada automaticamente.
+ `"sdp_gradient_clipping"`*(float, padrão: 1.0)*: especifica um limite para recortar o gradiente na norma L2 dos gradientes antes de propagá-los para trás por meio dos parâmetros do modelo. Quando o paralelismo de dados fragmentados é ativado, o recorte de gradiente também é ativado. O limite padrão é `1.0`. Ajuste esse parâmetro se você tiver o problema de gradientes explosivos.
O código a seguir mostra um exemplo de como configurar o paralelismo de dados fragmentados.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled": True,
"parameters": {
# "pipeline_parallel_degree": 1, # Optional, default is 1
# "tensor_parallel_degree": 1, # Optional, default is 1
"ddp": True,
# parameters for sharded data parallelism
"sharded_data_parallel_degree": 2, # Add this to activate sharded data parallelism
"sdp_reduce_bucket_size": int(5e8), # Optional
"sdp_param_persistence_threshold": int(1e6), # Optional
"sdp_max_live_parameters": int(1e9), # Optional
"sdp_hierarchical_allgather": True, # Optional
"sdp_gradient_clipping": 1.0 # Optional
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
smp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.p3.16xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-job"
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Configurações de referência
A equipe de treinamento SageMaker distribuída fornece as seguintes configurações de referência que você pode usar como ponto de partida. Você pode extrapolar a partir das configurações a seguir para experimentar e estimar o uso de memória da GPU para a configuração do seu modelo.
Paralelismo de dados fragmentados com coletivos SMDDP
| Modelo/número de parâmetros | Número de instâncias | Tipo de instância | Comprimento da sequência | Tamanho global do lote | Tamanho do minilote | Grau paralelo de dados fragmentados |
| --- | --- | --- | --- | --- | --- | --- |
| GPT-NEOX-20B | 2 | ml.p4d.24xlarge | 2048 | 64 | 4 | 16 |
| GPT-NEOX-20B | 8 | ml.p4d.24xlarge | 2048 | 768 | 12 | 32 |
Por exemplo, se você aumentar o comprimento da sequência de um modelo de 20 bilhões de parâmetros ou aumentar o tamanho do modelo para 65 bilhões de parâmetros, primeiro precisará tentar reduzir o tamanho do lote. Se o modelo ainda não se adequar ao menor tamanho de lote (o tamanho do lote de 1), tente aumentar o grau de paralelismo do modelo.
Paralelismo de dados fragmentados com paralelismo de tensores e coletivos NCCL
| Modelo/número de parâmetros | Número de instâncias | Tipo de instância | Comprimento da sequência | Tamanho global do lote | Tamanho do minilote | Grau paralelo de dados fragmentados | Tensor de grau paralelo | Ativação e descarregamento |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| GPT-NEOX-65B | 64 | ml.p4d.24xlarge | 2048 | 512 | 8 | 16 | 8 | S |
| GPT-NEOX-65B | 64 | ml.p4d.24xlarge | 4096 | 512 | 2 | 64 | 2 | S |
O uso combinado de paralelismo de dados fragmentados e paralelismo de tensores é útil quando você deseja ajustar um modelo de linguagem grande (LLM) em um cluster de grande escala enquanto usa dados de texto com um comprimento de sequência maior, o que leva ao uso de um tamanho de lote menor e, consequentemente, manipula o uso da memória da GPU para treinar com sequências de texto mais longas. LLMs Para saber mais, consulte [Paralelismo de dados fragmentados com paralelismo de tensores](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism).
Para estudos de caso, benchmarks e mais exemplos de configuração, consulte a postagem do blog [Novas melhorias de desempenho na biblioteca paralela de modelos de SageMaker IA da Amazon](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/).
## Paralelismo de dados fragmentados com coletivos SMDDP
A biblioteca SageMaker de paralelismo de dados oferece primitivas de comunicação coletiva (coletivas SMDDP) otimizadas para a infraestrutura. AWS Ele obtém a otimização adotando um padrão de all-to-all-type comunicação usando o [Elastic Fabric Adapter (](https://aws.amazon.com/hpc/efa/)EFA), resultando em coletivos de alto rendimento e menos sensíveis à latência, transferindo o processamento relacionado à comunicação para a CPU e liberando ciclos de GPU para computação. Em grandes clusters, os coletivos SMDDP podem oferecer melhorias no performance de treinamento distribuído em até 40% em comparação com o NCCL. Para estudos de caso e resultados de benchmark, consulte o blog [Novas melhorias de desempenho na biblioteca de paralelismo de modelos de SageMaker IA da Amazon](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/).
**nota**
O paralelismo de dados fragmentados com SMDDP Collectives está disponível na biblioteca de paralelismo de SageMaker modelos v1.13.0 e posterior e na biblioteca de paralelismo de dados v1.6.0 e posterior. SageMaker Consulte também [Supported configurations](#sharded-data-parallelism-smddp-collectives-supported-config) para usar o paralelismo de dados fragmentados com coletivos SMDDP.
No paralelismo de dados fragmentados, que é uma técnica comumente usada em treinamento distribuído em grande escala, o coletivo `AllGather` é usado para reconstituir os parâmetros da camada fragmentada para cálculos de passagem para frente e para trás, em paralelo com a computação da GPU. Para modelos grandes, realizar a operação `AllGather` com eficiência é fundamental para evitar problemas de gargalo na GPU e diminuir a velocidade de treinamento. Quando o paralelismo de dados fragmentados é ativado, os coletivos SMDDP entram nesses coletivos de performance crítico, melhorando a produtividade do treinamento `AllGather`.
**Treine com coletivos SMDDP**
Quando seu trabalho de treinamento tem o paralelismo de dados fragmentados ativado e atende ao [Supported configurations](#sharded-data-parallelism-smddp-collectives-supported-config), os coletivos SMDDP são ativados automaticamente. Internamente, os coletivos SMDDP otimizam o `AllGather` coletivo para ter desempenho na AWS infraestrutura e recorrem ao NCCL para todos os outros coletivos. Além disso, em configurações incompatíveis, todos os coletivos, inclusive `AllGather`, usam automaticamente o backend NCCL.
Desde a versão 1.13.0 da biblioteca de paralelismo de SageMaker modelos, o `"ddp_dist_backend"` parâmetro é adicionado às opções. `modelparallel` O valor padrão desse parâmetro de configuração é `"auto"`, que usa coletivos SMDDP sempre que possível e, caso contrário, volta para NCCL. Para forçar a biblioteca a sempre usar NCCL, especifique `"nccl"` para o parâmetro de configuração `"ddp_dist_backend"`.
O exemplo de código a seguir mostra como configurar um PyTorch estimador usando o paralelismo de dados fragmentados com o `"ddp_dist_backend"` parâmetro, que é definido como padrão e, portanto, `"auto"` opcional para adição.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled":True,
"parameters": {
"partitions": 1,
"ddp": True,
"sharded_data_parallel_degree": 64
"bf16": True,
"ddp_dist_backend": "auto" # Specify "nccl" to force to use NCCL.
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
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=8,
instance_type='ml.p4d.24xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
**Configurações compatíveis**
A operação `AllGather` com coletivos SMDDP é ativada em trabalhos de treinamento quando todos os requisitos de configuração a seguir são atendidos.
+ O grau de paralelismo de dados fragmentados maior que 1
+ `Instance_count` maior que 1
+ `Instance_type` igual a `ml.p4d.24xlarge`
+ SageMaker contêiner de treinamento para PyTorch v1.12.1 ou posterior
+ A biblioteca SageMaker de paralelismo de dados v1.6.0 ou posterior
+ A biblioteca de paralelismo de SageMaker modelos v1.13.0 ou posterior
**Ajuste de performance e memória**
Os coletivos SMDDP utilizam memória GPU adicional. Há duas variáveis de ambiente para configurar o uso da memória da GPU, dependendo dos diferentes casos de uso de treinamento de modelo.
+ `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES`: Durante a operação SMDDP `AllGather`, o buffer de entrada `AllGather` é copiado em um buffer temporário para comunicação entre nós. A variável `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` controla o tamanho (em bytes) desse buffer temporário. Se o tamanho do buffer temporário for menor que o tamanho do buffer `AllGather` de entrada, o coletivo `AllGather` voltará a usar o NCCL.
+ Valor padrão: 16 \$1 1024 \$1 1024 (16 MB)
+ Valores aceitáveis: qualquer múltiplo de 8192
+ `SMDDP_AG_SORT_BUFFER_SIZE_BYTES`: A variável `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` é dimensionar o buffer temporário (em bytes) para armazenar os dados coletados da comunicação entre nós. Se o tamanho desse buffer temporário for menor que `1/8 * sharded_data_parallel_degree * AllGather input size`, o coletivo `AllGather` volta a usar o NCCL.
+ Valor padrão: 128 \$1 1024 \$1 1024 (128 MB)
+ Valores aceitáveis: qualquer múltiplo de 8192
**Orientação de ajuste sobre as variáveis de tamanho do buffer**
Os valores padrão das variáveis de ambiente devem funcionar bem na maioria dos casos de uso. Recomendamos ajustar essas variáveis somente se o treinamento apresentar o erro out-of-memory (OOM).
A lista a seguir discute algumas dicas de ajuste para reduzir o consumo de memória da GPU dos coletivos SMDDP e, ao mesmo tempo, reter o ganho de performance deles.
+ Ajustar `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES`
+ O tamanho do buffer de entrada `AllGather` é menor para modelos menores. Portanto, o tamanho necessário para `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` pode ser menor para modelos com menos parâmetros.
+ O tamanho do buffer de `AllGather` entrada diminui à medida que `sharded_data_parallel_degree` aumenta, porque o modelo fica mais fragmentado. GPUs Portanto, o tamanho necessário para `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` pode ser menor para trabalhos de treinamento com valores grandes para `sharded_data_parallel_degree`.
+ Ajustar `SMDDP_AG_SORT_BUFFER_SIZE_BYTES`
+ A quantidade de dados coletados da comunicação entre nós é menor para modelos com menos parâmetros. Portanto, o tamanho necessário para `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` pode ser menor para modelos com menor número de parâmetros.
Alguns coletivos podem voltar a usar o NCCL; portanto, você pode não obter o ganho de performance dos coletivos SMDDP otimizados. Se houver memória da GPU adicional disponível para uso, considere aumentar os valores `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` e `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` se beneficiar do ganho de performance.
O código a seguir mostra como você pode configurar as variáveis de ambiente anexando-as ao `mpi_options` parâmetro de distribuição do PyTorch estimador.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
.... # All modelparallel configuration options go here
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
# Use the following two lines to tune values of the environment variables for buffer
mpioptions += " -x SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES=8192"
mpioptions += " -x SMDDP_AG_SORT_BUFFER_SIZE_BYTES=8192"
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=8,
instance_type='ml.p4d.24xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-demo-with-tuning",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Treinamento misto de precisão com paralelismo de dados fragmentados
Para economizar ainda mais a memória da GPU com números de ponto flutuante de meia precisão e paralelismo de dados fragmentados, você pode ativar o formato de ponto flutuante de 16 bits (FP16) ou o formato de [ponto flutuante Brain](https://en.wikichip.org/wiki/brain_floating-point_format) (BF16) adicionando um parâmetro adicional à configuração de treinamento distribuído.
**nota**
O treinamento misto de precisão com paralelismo de dados fragmentados está disponível na biblioteca de paralelismo de SageMaker modelos v1.11.0 e versões posteriores.
**Para FP16 treinamento com paralelismo de dados fragmentados**
Para executar o FP16 treinamento com paralelismo de dados fragmentados, adicione `"fp16": True"` ao dicionário de configuração. `smp_options` Em seu script de treinamento, você pode escolher entre as opções de escalonamento de perda estática e dinâmica por meio do módulo `smp.DistributedOptimizer`. Para obter mais informações, consulte [FP16 Treinamento com paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md).
```
smp_options = {
"enabled": True,
"parameters": {
"ddp": True,
"sharded_data_parallel_degree": 2,
"fp16": True
}
}
```
**Para BF16 treinamento com paralelismo de dados fragmentados**
O recurso de paralelismo de dados fragmentados da SageMaker IA oferece suporte ao treinamento em tipos de dados. BF16 O tipo de BF16 dados usa 8 bits para representar o expoente de um número de ponto flutuante, enquanto o tipo de FP16 dados usa 5 bits. Preservar os 8 bits para o expoente permite manter a mesma representação do expoente de um número de ponto flutuante () de precisão única de 32 bits. FP32 Isso torna a conversão entre FP32 e BF16 mais simples e significativamente menos propensa a causar problemas de estouro e subfluxo que surgem com frequência no FP16 treinamento, especialmente ao treinar modelos maiores. Embora os dois tipos de dados usem 16 bits no total, esse aumento na faixa de representação do expoente no BF16 formato prejudica a precisão reduzida. Para treinar modelos grandes, essa precisão reduzida geralmente é considerada uma compensação aceitável para o alcance e a estabilidade do treinamento.
**nota**
Atualmente, o BF16 treinamento funciona somente quando o paralelismo de dados fragmentados é ativado.
Para executar o BF16 treinamento com paralelismo de dados fragmentados, adicione `"bf16": True` ao dicionário de configuração. `smp_options`
```
smp_options = {
"enabled": True,
"parameters": {
"ddp": True,
"sharded_data_parallel_degree": 2,
"bf16": True
}
}
```
## Paralelismo de dados fragmentados com paralelismo de tensores
Se você usa paralelismo de dados fragmentados e também precisa reduzir o tamanho global do lote, considere usar paralelismo de [tensores com paralelismo](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-tensor-parallelism.html) de dados fragmentados. Ao treinar um modelo grande com paralelismo de dados fragmentados em um cluster de computação muito grande (normalmente 128 nós ou mais), até mesmo um pequeno tamanho de lote por GPU resulta em um tamanho de lote global muito grande. Isso pode levar a problemas de convergência ou problemas de baixo performance computacional. Às vezes, não é possível reduzir o tamanho do lote por GPU apenas com o paralelismo de dados fragmentados, quando um único lote já é grande e não pode ser reduzido ainda mais. Nesses casos, usar o paralelismo de dados fragmentados em combinação com o paralelismo de tensores ajuda a reduzir o tamanho global do lote.
A escolha dos graus ideais de dados fragmentados paralelos e tensores paralelos depende da escala do modelo, do tipo de instância e do tamanho global do lote que seja razoável para a convergência do modelo. Recomendamos que você comece com um grau paralelo de baixo tensor para ajustar o tamanho do lote global ao cluster de computação para resolver out-of-memory erros de CUDA e obter o melhor desempenho. Veja os dois exemplos de casos a seguir para saber como a combinação de paralelismo de tensores e paralelismo de dados fragmentados ajuda você a ajustar o tamanho global do lote por meio do agrupamento GPUs para paralelismo do modelo, resultando em um número menor de réplicas do modelo e em um tamanho de lote global menor.
**nota**
Esse recurso está disponível na biblioteca de paralelismo de SageMaker modelos v1.15 e oferece suporte à v1.13.1. PyTorch
**nota**
Esse atributo está disponível para os modelos compatíveis com a funcionalidade de paralelismo de tensores da biblioteca. Para encontrar a lista dos modelos compatíveis, consulte [Ajuda para modelo tipo transformador do Hugging Face](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-hugging-face.html). Observe também que você precisa passar `tensor_parallelism=True` para o argumento `smp.model_creation` ao modificar seu script de treinamento. Para saber mais, consulte o script de treinamento [https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L793](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L793)no * GitHub repositório de exemplos de SageMaker IA*.
### Exemplo 1
Suponha que queremos treinar um modelo em um cluster de 1536 GPUs (192 nós com 8 GPUs em cada), definindo o grau de paralelismo de dados fragmentados como 32 (`sharded_data_parallel_degree=32`) e o tamanho do lote por GPU como 1, onde cada lote tem um comprimento de sequência de 4096 tokens. Nesse caso, existem 1536 réplicas de modelos, o tamanho do lote global se torna 1536 e cada lote global contém cerca de 6 milhões de tokens.
```
(1536 GPUs) * (1 batch per GPU) = (1536 global batches)
(1536 batches) * (4096 tokens per batch) = (6,291,456 tokens)
```
Adicionar paralelismo de tensor a ele pode diminuir o tamanho global do lote. Um exemplo de configuração pode ser definir o grau paralelo do tensor como 8 e o tamanho do lote por GPU como 4. Isso forma 192 grupos paralelos de tensores ou 192 réplicas de modelo, onde cada réplica do modelo é distribuída em 8. GPUs O tamanho do lote de 4 é a quantidade de dados de treinamento por iteração e por grupo paralelo de tensores; ou seja, cada réplica do modelo consome 4 lotes por iteração. Nesse caso, o tamanho do lote global se torna 768 e cada lote global contém cerca de 3 milhões de tokens. Portanto, o tamanho do lote global é reduzido pela metade em comparação com o caso anterior com apenas o paralelismo de dados fragmentados.
```
(1536 GPUs) / (8 tensor parallel degree) = (192 tensor parallelism groups)
(192 tensor parallelism groups) * (4 batches per tensor parallelism group) = (768 global batches)
(768 batches) * (4096 tokens per batch) = (3,145,728 tokens)
```
### Exemplo 2
Quando o paralelismo de dados fragmentados e o paralelismo de tensores são ativados, a biblioteca primeiro aplica o paralelismo de tensores e fragmenta o modelo em toda essa dimensão. Para cada classificação paralela do tensor, o paralelismo de dados é aplicado conforme `sharded_data_parallel_degree`.
Por exemplo, suponha que queremos definir 32 GPUs com um tensor paralelo de 4 (formando grupos de 4 GPUs), um grau paralelo de dados fragmentados de 4, terminando com um grau de replicação de 2. A atribuição cria oito grupos de GPU com base no grau paralelo do tensor da seguinte forma: `(0,1,2,3)`, `(4,5,6,7)`, `(8,9,10,11)`, `(12,13,14,15)`, `(16,17,18,19)`, `(20,21,22,23)`, `(24,25,26,27)`, `(28,29,30,31)`. Ou seja, quatro GPUs formam um grupo tensor paralelo. Nesse caso, o grupo paralelo de dados reduzido para a 0ª classificação GPUs dos grupos paralelos tensores seria. `(0,4,8,12,16,20,24,28)` O grupo paralelo de dados reduzido é fragmentado com base no grau paralelo de dados fragmentados de 4, resultando em dois grupos de replicação para paralelismo de dados. GPUs`(0,4,8,12)`forme um grupo de fragmentação, que coletivamente contém uma cópia completa de todos os parâmetros para a classificação paralela do 0º tensor, e GPUs `(16,20,24,28)` forme outro grupo desse tipo. Outras classificações paralelas de tensores também têm grupos de fragmentação e replicação semelhantes.
![\[Figura 1: Grupos de paralelismo de tensores.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/sdp_tp_group_tp.jpg)
Figura 1: Grupos de paralelismo de tensores para (nós, grau paralelo de dados fragmentados, grau paralelo do tensor) = (4, 4, 4), onde cada retângulo representa uma GPU com índices de 0 a 31. O paralelismo GPUs de tensores de forma agrupa de TPG a TPG. 0 7 Os grupos de replicação são (\$1TPG0, TPG4\$1, \$1TPG1, TPG5\$1, \$1TPG2, TPG6\$1 e \$1TPG3, TPG7\$1); cada par de grupos de replicação compartilha a mesma cor, mas preenchida de forma diferente.
![\[Figura 2: Grupos de paralelismo de dados fragmentados.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/sdp_tp_group_sdp.jpg)
Figura 2: Grupos de paralelismo de dados fragmentados para (nós, grau paralelo de dados fragmentados, grau paralelo do tensor) = (4, 4, 4), onde cada retângulo representa uma GPU com índices de 0 a 31. O GPUs formulário agrupa o paralelismo de dados fragmentados de SDPG a SDPG. 0 7 Os grupos de replicação são (\$1SDPG0, SDPG4\$1, \$1SDPG1, SDPG5\$1, \$1SDPG2, SDPG6\$1 e \$1SDPG3, SDPG7\$1); cada par de grupos de replicação compartilha a mesma cor, mas é preenchido de forma diferente.
### Como ativar o paralelismo de dados fragmentados com o paralelismo de tensores
Para usar o paralelismo de dados fragmentados com o paralelismo de tensores, você precisa definir ambos `sharded_data_parallel_degree` e `tensor_parallel_degree` na configuração para criar um objeto da classe estimadora`distribution`. SageMaker PyTorch
Você também precisa ativar `prescaled_batch`. Isso significa que, em vez de cada GPU ler seu próprio lote de dados, cada grupo paralelo de tensores lê coletivamente um lote combinado do tamanho de lote escolhido. Efetivamente, em vez de dividir o conjunto de dados em partes iguais ao número de GPUs (ou tamanho paralelo dos dados`smp.dp_size()`), ele se divide em partes iguais ao número de GPUs dividido por `tensor_parallel_degree` (também chamado de tamanho paralelo de dados reduzido). `smp.rdp_size()` Para obter mais detalhes sobre o lote pré-escalado, consulte [Prescaled Batch](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#prescaled-batch) na documentação do *SageMaker Python* SDK. Veja também o exemplo de script de treinamento [https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L164](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L164)para GPT-2 no repositório de exemplos de *SageMaker IA*. GitHub
O trecho de código a seguir mostra um exemplo de criação de um objeto PyTorch estimador com base no cenário mencionado acima em. [Exemplo 2](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism-ex2)
```
mpi_options = "-verbose --mca orte_base_help_aggregate 0 "
smp_parameters = {
"ddp": True,
"fp16": True,
"prescaled_batch": True,
"sharded_data_parallel_degree": 4,
"tensor_parallel_degree": 4
}
pytorch_estimator = PyTorch(
entry_point="your_training_script.py",
role=role,
instance_type="ml.p4d.24xlarge",
volume_size=200,
instance_count=4,
sagemaker_session=sagemaker_session,
py_version="py3",
framework_version="1.13.1",
distribution={
"smdistributed": {
"modelparallel": {
"enabled": True,
"parameters": smp_parameters,
}
},
"mpi": {
"enabled": True,
"processes_per_host": 8,
"custom_mpi_options": mpi_options,
},
},
source_dir="source_directory_of_your_code",
output_path=s3_output_location
)
```
## Dicas e considerações para usar o paralelismo de dados fragmentados
Considere o seguinte ao usar o paralelismo de dados fragmentados da biblioteca de paralelismo de SageMaker modelos.
+ O paralelismo de dados fragmentados é compatível com o treinamento. FP16 Para realizar o FP16 treinamento, consulte a [FP16 Treinamento com paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md) seção.
+ O paralelismo de dados fragmentados é compatível com o paralelismo de tensores. Os itens a seguir são o que talvez você precise considerar para usar o paralelismo de dados fragmentados com o paralelismo de tensores.
+ Ao usar paralelismo de dados fragmentados com paralelismo de tensores, as camadas de incorporação também são distribuídas automaticamente pelo grupo paralelo de tensores. Em outras palavras, o parâmetro `distribute_embedding` é definido automaticamente como `True`. Para obter mais informações sobre paralelismo de tensores, consulte [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md).
+ Observe que o paralelismo de dados fragmentados com o paralelismo de tensores atualmente usa os coletivos NCCL como backend da estratégia de treinamento distribuído.
Para saber mais, consulte a seção [Paralelismo de dados fragmentados com paralelismo de tensores](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism).
+ Atualmente, o paralelismo de dados fragmentados é incompatível com o [paralelismo de pipeline](model-parallel-intro.md#model-parallel-intro-pp) ou com a [fragmentação de estado do otimizador](model-parallel-extended-features-pytorch-optimizer-state-sharding.md). Para ativar o paralelismo de dados fragmentados, desative a fragmentação de estado do otimizador e defina o grau paralelo do pipeline como 1.
+ Os atributos de [ponto de verificação de ativação](model-parallel-extended-features-pytorch-activation-checkpointing.md) e [descarregamento de ativação](model-parallel-extended-features-pytorch-activation-offloading.md) são compatíveis com o paralelismo de dados fragmentados.
+ Para usar o paralelismo de dados fragmentados com o acúmulo de gradiente, defina o argumento `backward_passes_per_step` para o número de etapas de acumulação ao agrupar seu modelo com o módulo [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel). Isso garante que a operação `AllReduce` de gradiente nos grupos de replicação do modelo (grupos de fragmentação) ocorra no limite do acúmulo de gradiente.
+ Você pode verificar seus modelos treinados com paralelismo de dados fragmentados usando o ponto de verificação da biblioteca e. APIs `smp.save_checkpoint` `smp.resume_from_checkpoint` Para obter mais informações, consulte [Apontando um PyTorch modelo distribuído (para a biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)](distributed-model-parallel-checkpointing-and-finetuning.md#model-parallel-extended-features-pytorch-checkpoint).
+ O comportamento do parâmetro de configuração [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization) muda sob o paralelismo de dados fragmentados. Quando esses dois atributos são ativados simultaneamente, os parâmetros são inicializados imediatamente após a criação do modelo de forma fragmentada, em vez de atrasar a inicialização do parâmetro, para que cada classificação inicialize e armazene seu próprio fragmento de parâmetros.
+ Quando o paralelismo de dados fragmentados é ativado, a biblioteca executa o recorte de gradiente internamente quando a chamada `optimizer.step()` é executada. Você não precisa usar utilitários APIs para recorte de gradiente, como. [https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html](https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html) Para ajustar o valor limite para recorte de gradiente, você pode defini-lo por meio do `sdp_gradient_clipping` parâmetro para a configuração do parâmetro de distribuição ao construir o SageMaker PyTorch estimador, conforme mostrado na seção. [Como aplicar o paralelismo de dados fragmentados ao seu trabalho de treinamento](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use)
# Programação de um modelo
Um dos principais recursos da biblioteca de SageMaker paralelismo de modelos é o paralelismo de *pipeline*, que determina a ordem na qual os cálculos são feitos e os dados são processados nos dispositivos durante o treinamento do modelo. O pipelining é uma técnica para alcançar a verdadeira paralelização no paralelismo do modelo, fazendo com que a GPUs computação seja feita simultaneamente em diferentes amostras de dados e para superar a perda de desempenho devido à computação sequencial. Quando você usa o paralelismo de pipeline, o trabalho de treinamento é executado de forma agrupada em microlotes para maximizar o uso da GPU.
**nota**
O paralelismo de pipeline, também chamado de particionamento de modelo, está disponível para e. PyTorch TensorFlow Para versões compatíveis com os frameworks, consulte [Estruturas suportadas e Regiões da AWS](distributed-model-parallel-support.md).
## Cronograma de execução do pipeline
O pipelining é baseado na divisão de um minilote em microlotes, que são inseridos no pipeline de treinamento one-by-one e seguem um cronograma de execução definido pelo tempo de execução da biblioteca. Um *microlote* é um subconjunto menor de um determinado minilote de treinamento. O cronograma do pipeline determina qual microlote é executado por qual dispositivo em cada intervalo de tempo.
Por exemplo, dependendo do cronograma do pipeline e da partição do modelo, a GPU `i` pode realizar a computação (para frente ou para trás) no microlote, `b` enquanto a GPU `i+1` executa a computação no microlote`b+1`, mantendo as duas ativas ao mesmo tempo. GPUs Durante uma única passagem para frente ou para trás, o fluxo de execução de um único microlote pode visitar o mesmo dispositivo várias vezes, dependendo da decisão de particionamento. Por exemplo, uma operação que está no início do modelo pode ser colocada no mesmo dispositivo que uma operação no final do modelo, enquanto as operações intermediárias estão em dispositivos diferentes, o que significa que esse dispositivo é visitado duas vezes.
A biblioteca oferece dois cronogramas de pipeline diferentes, *simples* e *intercalados, que podem ser configurados* usando o parâmetro `pipeline` no SDK do Python. SageMaker Na maioria dos casos, o pipeline intercalado pode alcançar um melhor desempenho ao utilizá-lo com mais eficiência. GPUs
### Gasoduto intercalado
Em um pipeline intercalado, a execução reversa dos microlotes é priorizada sempre que possível. Isso permite uma liberação mais rápida da memória usada para ativações, usando a memória com mais eficiência. Também permite aumentar o número de microlotes, reduzindo o tempo de inatividade do. GPUs Em estado estacionário, cada dispositivo alterna entre passes para frente e para trás. Isso significa que a passagem para trás de um microlote pode ser executada antes que a passagem para frente de outro microlote termine.
![\[Exemplo de cronograma de execução para o pipeline intercalado acima de 2. GPUs\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-execution.png)
A figura anterior ilustra um exemplo de cronograma de execução para o pipeline intercalado acima de 2. GPUs Na figura, F0 representa a passagem para frente para o microlote 0 e B1 representa a passagem para trás para o microlote 1. A **atualização** representa a atualização do otimizador dos parâmetros. GPU0 sempre prioriza as passagens para trás sempre que possível (por exemplo, executa B0 antes de F2), o que permite limpar a memória usada para ativações anteriores.
### Pipeline simples
Uma tubulação simples, por outro lado, termina de executar a passagem para frente para cada microlote antes de iniciar a passagem para trás. Isso significa que ele apenas canaliza os estágios de passagem para frente e para trás dentro de si. A figura a seguir ilustra um exemplo de como isso funciona, mais de 2 GPUs.
![\[Exemplo de um pipeline executando o avanço de cada microlote antes de iniciar o retrocesso.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/simple-pipeline-execution.png)
### Execução de pipelining em estruturas específicas
Use as seções a seguir para aprender sobre as decisões de agendamento de pipeline específicas da estrutura que a biblioteca de SageMaker paralelismo de modelos faz para e. TensorFlow PyTorch
#### Execução de pipeline com TensorFlow
A imagem a seguir é um exemplo de um TensorFlow gráfico particionado pela biblioteca de paralelismo de modelos, usando a divisão automatizada de modelos. Quando um gráfico é dividido, cada subgráfico resultante é replicado B vezes (exceto para as variáveis), onde B é o número de microlotes. Nesta figura, cada subgráfico é replicado 2 vezes (B=2). Uma operação `SMPInput` é inserida em cada entrada de um subgráfico e uma operação `SMPOutput` é inserida em cada saída. Essas operações se comunicam com o backend da biblioteca para transferir tensores de e para os outros.
![\[Exemplo de um TensorFlow gráfico particionado pela biblioteca de paralelismo de modelos, usando a divisão automatizada de modelos.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-tf.png)
A imagem a seguir é um exemplo de 2 subgráficos divididos com B=2 com operações de gradiente adicionadas. O gradiente de uma operação `SMPInput` é uma operação `SMPOutput` e vice-versa. Isso permite que os gradientes fluam para trás durante a retropropagação.
![\[Exemplo de 2 subgráficos divididos com B=2 com operações de gradiente adicionadas.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-tf.gif)
Esse GIF demonstra um exemplo de cronograma de execução de pipeline intercalado com B=2 microlotes e 2 subgráficos. Cada dispositivo executa sequencialmente uma das réplicas do subgráfico para melhorar a utilização da GPU. À medida que B cresce, a fração de intervalos de tempo ociosos vai para zero. Sempre que é hora de fazer cálculos (para frente ou para trás) em uma réplica específica do subgráfico, a camada do pipeline sinaliza para as operações azuis correspondentes `SMPInput` começarem a ser executadas.
Depois que os gradientes de todos os microlotes em um único minilote são calculados, a biblioteca combina os gradientes entre microlotes, que podem ser aplicados aos parâmetros.
#### Execução de pipeline com PyTorch
Conceitualmente, o pipelining segue uma ideia semelhante em. PyTorch No entanto, como PyTorch não envolve gráficos estáticos, o PyTorch recurso da biblioteca de paralelismo de modelos usa um paradigma de pipeline mais dinâmico.
Por exemplo TensorFlow, cada lote é dividido em vários microlotes, que são executados um por vez em cada dispositivo. No entanto, o cronograma de execução é gerenciado por meio de servidores de execução lançados em cada dispositivo. Sempre que a saída de um submódulo colocado em outro dispositivo é necessária no dispositivo atual, uma solicitação de execução é enviada ao servidor de execução do dispositivo remoto junto com os tensores de entrada do submódulo. O servidor então executa esse módulo com as entradas fornecidas e retorna a resposta para o dispositivo atual.
Como o dispositivo atual fica ocioso durante a execução do submódulo remoto, a execução local do microlote atual é pausada e o runtime da biblioteca muda a execução para outro microlote no qual o dispositivo atual possa trabalhar ativamente. A priorização dos microlotes é determinada pelo cronograma de pipeline escolhido. Para um cronograma de pipeline intercalado, os microlotes que estão no estágio anterior da computação são priorizados sempre que possível.
# Paralelismo de tensores
O *paralelismo de tensores* é um tipo de paralelismo de modelo no qual pesos, gradientes e estados do otimizador específicos do modelo são divididos entre dispositivos. Em contraste com o paralelismo de tubulação, que mantém os pesos individuais intactos, mas divide o *conjunto* de pesos, o paralelismo de tensores divide os pesos individuais. Isso normalmente envolve computação distribuída de operações, módulos ou camadas específicas do modelo.
O paralelismo do tensor é necessário nos casos em que um único parâmetro consome a maior parte da memória da GPU (como grandes tabelas de incorporação com um grande tamanho de vocabulário ou uma grande camada softmax com um grande número de classes). Nesse caso, tratar esse grande tensor ou operação como uma unidade atômica é ineficiente e impede o equilíbrio da carga de memória.
O paralelismo de tensores também é útil para modelos extremamente grandes nos quais uma tubulação pura simplesmente não é suficiente. Por exemplo, com modelos em escala GPT-3 que exigem particionamento em dezenas de instâncias, uma tubulação de microlote pura é ineficiente porque a profundidade da tubulação se torna muito alta e a sobrecarga se torna proibitivamente grande.
**nota**
O paralelismo de tensores está disponível PyTorch na biblioteca de paralelismo de SageMaker modelos v1.6.0 e versões posteriores.
**Topics**
+ [Como funciona o paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism-how-it-works.md)
+ [Execute um trabalho de treinamento paralelo de modelo SageMaker distribuído com paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md)
+ [Ajuda para modelos tipo transformador Hugging Face](model-parallel-extended-features-pytorch-hugging-face.md)
+ [Mecanismo de classificação ao usar uma combinação de paralelismo de pipeline e paralelismo de tensores](model-parallel-extended-features-pytorch-ranking-mechanism.md)
# Como funciona o paralelismo de tensores
O paralelismo de tensores ocorre no nível de `nn.Modules`; ele particiona módulos específicos no modelo em classificações paralelas de tensores. Isso é um acréscimo à partição existente do *conjunto de módulos* usados no paralelismo de tubulações.
Quando um módulo é particionado por meio de paralelismo de tensores, sua propagação para frente e para trás é distribuída. A biblioteca gerencia a comunicação necessária entre dispositivos para implementar a execução distribuída desses módulos. Os módulos são particionados em várias classificações paralelas de dados. Ao contrário da distribuição tradicional de workloads, cada classificação paralela de dados **não** tem a réplica completa do modelo quando o paralelismo de tensores da biblioteca é usado. Em vez disso, cada classificação paralela de dados pode ter somente uma partição dos módulos distribuídos, além da totalidade dos módulos que não estão distribuídos.
**Exemplo:** considere o paralelismo de tensores em classificações paralelas de dados, em que o grau de paralelismo de dados é 4 e o grau de paralelismo de tensores é 2. Suponha que você tenha um grupo paralelo de dados que contém a seguinte árvore de módulos, depois de particionar o conjunto de módulos:
```
A
├── B
| ├── E
| ├── F
├── C
└── D
├── G
└── H
```
Suponha que o paralelismo de tensores seja compatível com os módulos B, G e H. Um resultado possível da partição paralela de tensores desse modelo poderia ser:
```
dp_rank 0 (tensor parallel rank 0): A, B:0, C, D, G:0, H
dp_rank 1 (tensor parallel rank 1): A, B:1, C, D, G:1, H
dp_rank 2 (tensor parallel rank 0): A, B:0, C, D, G:0, H
dp_rank 3 (tensor parallel rank 1): A, B:1, C, D, G:1, H
```
Cada linha representa o conjunto de módulos armazenados na `dp_rank`, e a notação `X:y` representa a `y`-ésima fração do módulo `X`. Observe o seguinte:
1. O particionamento ocorre em subconjuntos de classificações paralelas de dados, que chamamos `TP_GROUP`, não de todo `DP_GROUP`, para que a partição exata do modelo seja replicada em `dp_rank` 0 e `dp_rank` 2 e, da mesma forma, em `dp_rank` 1 e `dp_rank` 3.
1. Os módulos `E` e não `F` fazem mais parte do modelo, pois seu módulo pai `B` é particionado e qualquer execução que normalmente faz parte `E` e `F` ocorre dentro do módulo `B` (particionado).
1. Embora `H` seja compatível com paralelismo de tensores, neste exemplo ele não é particionado, o que destaca que a partição de um módulo depende da entrada do usuário. O fato de um módulo ser compatível com paralelismo de tensores não significa necessariamente que ele seja particionado.
## Como a biblioteca adapta o paralelismo do tensor ao módulo PyTorch `nn.Linear`
Quando o paralelismo do tensor é executado em classificações paralelas de dados, um subconjunto dos parâmetros, gradientes e estados do otimizador é particionado nos dispositivos paralelos do tensor *para os módulos que são particionados*. Para o resto dos módulos, os dispositivos tensores paralelos operam de forma paralela de dados regular. Para executar o módulo particionado, um dispositivo primeiro coleta as partes necessárias de *todas as amostras de dados* em dispositivos pares no mesmo grupo de paralelismo de tensores. O dispositivo então executa a fração local do módulo em todas essas amostras de dados, seguida por outra rodada de sincronização que combina as partes da saída para cada amostra de dados e retorna as amostras de dados combinadas para a origem GPUs da amostra de dados. A figura a seguir mostra um exemplo desse processo em um módulo particionado `nn.Linear`.
![\[Duas figuras mostrando dois conceitos paralelos de tensores.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-concept.png)
A primeira figura mostra um modelo pequeno com um módulo `nn.Linear` grande com paralelismo de dados nas duas classificações de paralelismo de tensores. O módulo `nn.Linear` é replicado em duas fileiras paralelas.
A segunda figura mostra o paralelismo de tensores aplicado em um modelo maior durante a divisão do módulo `nn.Linear`. Cada `tp_rank` contém metade do módulo linear e a totalidade do resto das operações. Enquanto o módulo linear é executado, cada `tp_rank` coleta a metade relevante de todas as amostras de dados e a passa pela metade do módulo `nn.Linear`. O resultado precisa ser disperso por redução (com a soma como operação de redução) para que cada classificação tenha a saída linear final para suas próprias amostras de dados. O resto do modelo é executado da maneira paralela de dados típica.
# Execute um trabalho de treinamento paralelo de modelo SageMaker distribuído com paralelismo de tensores
Nesta seção, você aprende:
+ Como configurar um SageMaker PyTorch estimador e a opção de paralelismo do SageMaker modelo para usar o paralelismo tensorial.
+ Como adaptar seu script de treinamento usando os módulos estendidos `smdistributed.modelparallel` para paralelismo de tensores.
Para saber mais sobre os `smdistributed.modelparallel` módulos, consulte o [SageMaker modelo parallel APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) na documentação do *SageMaker Python SDK*.
**Topics**
+ [Apenas paralelismo de tensores](#model-parallel-extended-features-pytorch-tensor-parallelism-alone)
+ [Paralelismo de tensores combinado com paralelismo de pipeline](#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism)
## Apenas paralelismo de tensores
A seguir está um exemplo de uma opção de treinamento distribuído para ativar o paralelismo de tensores sozinho, sem paralelismo de pipeline. Configure os `smp_options` dicionários `mpi_options` e para especificar opções de treinamento distribuídas para o SageMaker `PyTorch` estimador.
**nota**
Recursos estendidos de economia de memória estão disponíveis por meio do Deep Learning Containers for PyTorch, que implementa a biblioteca de paralelismo de SageMaker modelos v1.6.0 ou posterior.
**Configurar um SageMaker PyTorch estimador**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"pipeline_parallel_degree": 1, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 4, # tp over 4 devices
"ddp": True
}
}
smp_estimator = PyTorch(
entry_point='your_training_script.py', # Specify
role=role,
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
framework_version='1.13.1',
py_version='py36',
instance_count=1,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
**dica**
Para encontrar uma lista completa de parâmetros para`distribution`, consulte [Parâmetros de configuração para paralelismo de modelos na documentação do SDK](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html) do Python SageMaker.
**Adapte seu roteiro PyTorch de treinamento**
O exemplo de script de treinamento a seguir mostra como adaptar a biblioteca de paralelismo de SageMaker modelos a um script de treinamento. Neste exemplo, presume-se que o script tenha um nome `your_training_script.py`.
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
return F.log_softmax(x, 1)
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by
# the current process, based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
loss.backward()
optimizer.step()
# smdistributed: Initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
if smp.local_rank() == 0:
dataset = datasets.MNIST("../data", train=True, download=False)
smp.barrier()
# smdistributed: Shard the dataset based on data parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64)
# smdistributed: Enable tensor parallelism for all supported modules in the model
# i.e., nn.Linear in this case. Alternatively, we can use
# smp.set_tensor_parallelism(model.fc1, True)
# to enable it only for model.fc1
with smp.tensor_parallelism():
model = Net()
# smdistributed: Use the DistributedModel wrapper to distribute the
# modules for which tensor parallelism is enabled
model = smp.DistributedModel(model)
optimizer = optim.AdaDelta(model.parameters(), lr=4.0)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Paralelismo de tensores combinado com paralelismo de pipeline
Veja a seguir um exemplo de uma opção de treinamento distribuído que permite o paralelismo de tensores combinado com o paralelismo de pipeline. Configure os `smp_options` parâmetros `mpi_options` e para especificar as opções paralelas do modelo com paralelismo de tensor ao configurar um estimador. SageMaker `PyTorch`
**nota**
Recursos estendidos de economia de memória estão disponíveis por meio do Deep Learning Containers for PyTorch, que implementa a biblioteca de paralelismo de SageMaker modelos v1.6.0 ou posterior.
**Configurar um SageMaker PyTorch estimador**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True
}
}
smp_estimator = PyTorch(
entry_point='your_training_script.py', # Specify
role=role,
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
framework_version='1.13.1',
py_version='py36',
instance_count=1,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
**Adapte seu roteiro PyTorch de treinamento**
O exemplo de script de treinamento a seguir mostra como adaptar a biblioteca de paralelismo de SageMaker modelos a um script de treinamento. Observe que o script de treinamento agora inclui o decorador `smp.step`:
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
return F.log_softmax(x, 1)
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by
# the current process, based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: Initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
if smp.local_rank() == 0:
dataset = datasets.MNIST("../data", train=True, download=False)
smp.barrier()
# smdistributed: Shard the dataset based on data parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = Net()
# smdistributed: enable tensor parallelism only for model.fc1
smp.set_tensor_parallelism(model.fc1, True)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = optim.AdaDelta(model.parameters(), lr=4.0)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
# Ajuda para modelos tipo transformador Hugging Face
O paralelismo tensorial da biblioteca de paralelismo de SageMaker modelos oferece suporte para os seguintes modelos do Hugging Face out-of-the-box Transformer:
+ GPT-2, BERT e Ro BERTa (disponível na biblioteca de paralelismo de SageMaker modelos v1.7.0 e posterior)
+ GPT-J (disponível na biblioteca de paralelismo de SageMaker modelos v1.8.0 e posterior)
+ GPT-Neo (disponível na biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)
**nota**
Para qualquer outro modelo de Transformers, você precisa usar a API [smdistributed.modelparallel.torch.tp\$1register\$1with\$1module()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tp_register_with_module) para aplicar o paralelismo de tensores.
**nota**
Para usar o paralelismo de tensores para treinar modelos do Hugging Face Transformer, certifique-se de usar os Hugging Face Deep Learning Containers, pois eles têm a biblioteca de paralelismo de modelos v1.7.0 e versões posteriores. PyTorch SageMaker Para obter mais informações, consulte as notas de lançamento da [biblioteca de paralelismo de SageMaker modelos](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html).
## Modelos compatíveis prontos para uso
Para os modelos de transformadores Hugging Face suportados pela biblioteca prontos para uso, você não precisa implementar manualmente ganchos para traduzir o Transformer em camadas de transformador. APIs `smdistributed` [Você pode ativar o paralelismo do tensor usando o gerenciador de contexto smdistributed.modelparallel.torch.tensor\$1parallelism () e agrupando o modelo com [smdistributed.modelparallel.torch](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tensor_parallelism). DistributedModel()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel). Você não precisa registrar manualmente os hooks para paralelismo de tensores usando a API `smp.tp_register`.
A tradução `state_dict` funciona entre Hugging Face Transformers e `smdistributed.modelparallel` pode ser acessada da seguinte forma:
+ `smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_state_dict_to_hf_gpt2(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_hf_state_dict_to_smdistributed_gpt2(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.bert.translate_state_dict_to_hf_bert(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.bert.translate_hf_state_dict_to_smdistributed_bert(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_state_dict_to_hf_roberta(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_hf_state_dict_to_smdistributed_roberta(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_state_dict_to_hf_gptj(state_dict, max_seq_len=None)`(Disponível na biblioteca de paralelismo de SageMaker modelos v1.8.0 e posterior)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj`(Disponível na biblioteca de paralelismo de SageMaker modelos v1.8.0 e posterior)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None)`(Disponível na biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict)`(Disponível na biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)
** Exemplo de uso da função de tradução GPT-2**
Comece com o encapsulamento do modelo conforme mostrado no código a seguir.
```
from transformers import AutoModelForCausalLM
with smp.tensor_parallelism():
model = AutoModelForCausalLM.from_config(hf_gpt2_config)
model = smp.DistributedModel(model)
```
Com base `state_dict` no objeto `DistributedModel`, você pode carregar os pesos no modelo Hugging Face GPT-2 original usando a função `translate_state_dict_to_hf_gpt2` mostrada no código a seguir.
```
from smdistributed.modelparallel.torch.nn.huggingface.gpt2 \
import translate_state_dict_to_hf_gpt2
max_seq_len = 1024
# [... code block for training ...]
if smp.rdp_rank() == 0:
state_dict = dist_model.state_dict()
hf_state_dict = translate_state_dict_to_hf_gpt2(state_dict, max_seq_len)
# can now call model.load_state_dict(hf_state_dict) to the original HF model
```
**Exemplo de uso da função de BERTa tradução Ro**
Da mesma forma, dado um HuggingFace modelo compatível`state_dict`, você pode usar a `translate_hf_state_dict_to_smdistributed` função para convertê-la em um formato legível por`smp.DistributedModel`. Isso pode ser útil em casos de uso de aprendizado por transferência, em que um modelo pré-treinado é carregado em um `smp.DistributedModel` para ajuste fino paralelo ao modelo:
```
from smdistributed.modelparallel.torch.nn.huggingface.roberta \
import translate_state_dict_to_smdistributed
model = AutoModelForMaskedLM.from_config(roberta_config)
model = smp.DistributedModel(model)
pretrained_model = AutoModelForMaskedLM.from_pretrained("roberta-large")
translated_state_dict =
translate_state_dict_to_smdistributed(pretrained_model.state_dict())
# load the translated pretrained weights into the smp.DistributedModel
model.load_state_dict(translated_state_dict)
# start fine-tuning...
```
# Mecanismo de classificação ao usar uma combinação de paralelismo de pipeline e paralelismo de tensores
Esta seção explica como o mecanismo de classificação do paralelismo do modelo funciona com o paralelismo de tensores. Isso foi estendido do [Ranking Basics](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#ranking-basics) for [Principais características da biblioteca de SageMaker paralelismo de modelos](model-parallel-core-features.md). Com o paralelismo de tensores, a biblioteca apresenta três tipos de classificação e grupo de processos: APIs para classificação paralela de `smp.tp_rank()` tensores, classificação paralela de `smp.pp_rank()` pipeline e classificação paralela de dados reduzidos. `smp.rdp_rank()` Os grupos de processos de comunicação correspondentes são tensor parallel group (`TP_GROUP`), pipeline parallel group (`PP_GROUP`) e reduced-data parallel group (`RDP_GROUP`). Esses grupos são definidos da seguinte maneira:
+ Um *grupo paralelo de tensores* (`TP_GROUP`) é um subconjunto uniformemente divisível do grupo paralelo de dados, sobre o qual ocorre a distribuição paralela de módulos por tensores. Quando o grau de paralelismo do pipeline é 1, `TP_GROUP` é o mesmo que model *parallel group* (`MP_GROUP`).
+ Um *grupo paralelo de pipeline* (`PP_GROUP`) é o grupo de processos nos quais o paralelismo de pipeline ocorre. Quando o grau de paralelismo do tensor é 1, `PP_GROUP` é o mesmo que `MP_GROUP`.
+ Um grupo *paralelo de dados reduzidos* (`RDP_GROUP`) é um conjunto de processos que mantêm as mesmas partições de paralelismo de pipeline e as mesmas partições paralelas de tensor e realizam paralelismo de dados entre si. Isso é chamado de grupo paralelo de dados reduzido porque é um subconjunto de todo o grupo de paralelismo de dados, `DP_GROUP`. Para os parâmetros do modelo que são distribuídos dentro do `TP_GROUP`, a operação de gradiente `allreduce` é executada somente para grupos paralelos de dados reduzidos, enquanto para os parâmetros que não são distribuídos, o gradiente `allreduce` ocorre em todo o grupo `DP_GROUP`.
+ Um grupo paralelo de modelo (`MP_GROUP`) se refere a um grupo de processos que armazenam coletivamente o modelo inteiro. Consiste na união dos `PP_GROUP`s de todas as classificações que estão no processo atual `TP_GROUP`. Quando o grau de paralelismo do tensor é 1, `MP_GROUP` é equivalente a `PP_GROUP`. Também é consistente com a definição existente `MP_GROUP` de versões anteriores de `smdistributed`. Observe que a corrente `TP_GROUP` é um subconjunto da corrente `DP_GROUP` e da atual `MP_GROUP`.
*Para saber mais sobre o processo de comunicação APIs na biblioteca de paralelismo de SageMaker modelos, consulte a [API comum e a específica PyTorch](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html#) [na documentação do SDK APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html) para PythonSageMaker .*
![\[Mecanismo de classificação, distribuição de parâmetros e AllReduce operações associadas do paralelismo tensorial.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-ranking-mechanism.png)
Por exemplo, considere grupos de processos para um único nó com 8 GPUs, em que o grau de paralelismo do tensor é 2, o grau de paralelismo do pipeline é 2 e o grau de paralelismo dos dados é 4. A parte central superior da figura anterior mostra um exemplo de modelo com 4 camadas. As partes inferior esquerda e inferior direita da figura ilustram o modelo de 4 camadas distribuídas em 4 GPUs usando paralelismo de tubulação e paralelismo de tensor, onde o paralelismo de tensor é usado para as duas camadas intermediárias. Essas duas figuras inferiores são cópias simples para ilustrar diferentes linhas de limite de grupos. O modelo particionado é replicado para paralelismo de dados em 0-3 e 4-7. GPUs A figura inferior esquerda mostra as definições de `MP_GROUP`, `PP_GROUP` e `TP_GROUP`. A figura inferior direita mostra`RDP_GROUP`,`DP_GROUP`, e `WORLD` sobre o mesmo conjunto de GPUs. Os gradientes das camadas e das fatias da camada que têm a mesma cor são `allreduce` unidos para paralelismo de dados. Por exemplo, a primeira camada (azul claro) transmite as operações `allreduce` em `DP_GROUP`, enquanto a fatia laranja escura na segunda camada só obtém as operações `allreduce` dentro do processo `RDP_GROUP`. As setas vermelhas escuras em negrito representam tensores com o lote inteiro `TP_GROUP`.
```
GPU0: pp_rank 0, tp_rank 0, rdp_rank 0, dp_rank 0, mp_rank 0
GPU1: pp_rank 1, tp_rank 0, rdp_rank 0, dp_rank 0, mp_rank 1
GPU2: pp_rank 0, tp_rank 1, rdp_rank 0, dp_rank 1, mp_rank 2
GPU3: pp_rank 1, tp_rank 1, rdp_rank 0, dp_rank 1, mp_rank 3
GPU4: pp_rank 0, tp_rank 0, rdp_rank 1, dp_rank 2, mp_rank 0
GPU5: pp_rank 1, tp_rank 0, rdp_rank 1, dp_rank 2, mp_rank 1
GPU6: pp_rank 0, tp_rank 1, rdp_rank 1, dp_rank 3, mp_rank 2
GPU7: pp_rank 1, tp_rank 1, rdp_rank 1, dp_rank 3, mp_rank 3
```
Neste exemplo, o paralelismo do pipeline ocorre entre os pares de GPU (0,1), (2,3), (4,5) e (6,7). Além disso, o paralelismo de dados (`allreduce`) ocorre em GPUs 0, 2, 4, 6 e de forma independente em GPUs 1, 3, 5, 7. O paralelismo do tensor ocorre em subconjuntos de `DP_GROUP`s, nos pares de GPU (0,2); (1,3); (4,6) e (5,7).
Para esse tipo de paralelismo híbrido de pipeline e tensor, a matemática para `data_parallel_degree` permanece a mesma de `data_parallel_degree = number_of_GPUs / pipeline_parallel_degree`. A biblioteca calcula ainda mais o grau paralelo de dados reduzido a partir da relação `reduced_data_parallel_degree * tensor_parallel_degree = data_parallel_degree` a seguir.
# Fragmentação de estado do otimizador
A *fragmentação de estado do otimizador* é uma técnica útil de economia de memória que fragmenta o estado do otimizador (o conjunto de pesos que descreve o estado do otimizador) em grupos de dispositivos paralelos de dados. Você pode usar a fragmentação de estado do otimizador sempre que usar um otimizador com estado (como Adam) ou um FP16 otimizador (que armazena ambos FP16 e FP32 cópias dos parâmetros).
**nota**
A fragmentação de estado do otimizador está disponível PyTorch na biblioteca de paralelismo de SageMaker modelos v1.6.0 e versões posteriores.
## Como usar a fragmentação de estado do otimizador
Você pode ativar a *fragmentação de estado do otimizador* definindo `"shard_optimizer_state": True` na configuração `modelparallel`.
Quando esse atributo é ativado, a biblioteca particiona o conjunto de parâmetros do modelo com base no grau de paralelismo de dados. Os gradientes correspondentes à `i`-ésima partição são reduzidos somente na `i`-enésima classificação paralela de dados. No final da primeira chamada para uma função decoradora `smp.step`, o otimizador encapsulado por `smp.DistributedOptimizer` redefine seus parâmetros para serem limitados apenas aos parâmetros correspondentes à partição da classificação paralela de dados atual. Os parâmetros redefinidos são chamados de *parâmetros virtuais* e compartilham o armazenamento subjacente com os parâmetros originais. Durante a primeira chamada para `optimizer.step`, os estados do otimizador são criados com base nesses parâmetros redefinidos, que são fragmentados por causa da partição original. Após a atualização do otimizador, a AllGather operação (como parte da `optimizer.step` chamada) é executada nas classificações paralelas de dados para obter estados de parâmetros consistentes.
**dica**
A fragmentação de estado do otimizador pode ser útil quando o grau de paralelismo de dados é maior que 1 e o modelo tem mais de um bilhão de parâmetros.
O grau de paralelismo de dados é calculado por `(processes_per_host * instance_count / pipeline_parallel_degree)`, e a função `smp.dp_size()` lida com o dimensionamento em segundo plano.
**Configurar um SageMaker PyTorch estimador**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True,
"shard_optimizer_state": True
}
}
```
**Adapte seu roteiro PyTorch de treinamento**
Consulte [Adaptar seu script PyTorch de treinamento](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism-script) na seção *Paralelismo do tensor combinado com paralelismo do pipeline*. Não há nenhuma modificação adicional necessária para o script.
# Ponto de verificação de ativação
O *ponto de verificação de ativação* (ou *ponto de verificação de gradiente*) é uma técnica para reduzir o uso de memória limpando as ativações de determinadas camadas e recomputando-as durante uma passagem para trás. Efetivamente, isso troca o tempo extra de computação pelo uso reduzido da memória. Se um módulo for verificado, no final de uma passagem direta, as entradas e saídas do módulo permanecerão na memória. Quaisquer tensores intermediários que teriam feito parte da computação dentro desse módulo são liberados durante a passagem para frente. Durante a passagem para trás dos módulos com pontos de verificação, esses tensores são recalculados. Nesse ponto, as camadas além desse módulo de ponto de verificação concluíram sua passagem para trás, portanto, o pico de uso da memória com o ponto de verificação pode ser menor.
**nota**
Esse recurso está disponível PyTorch na biblioteca de paralelismo de SageMaker modelos v1.6.0 e versões posteriores.
## Como usar o ponto de verificação de ativação
Com `smdistributed.modelparallel`, você pode usar o ponto de verificação de ativação na granularidade de um módulo. Para todos os módulos `torch.nn`, exceto `torch.nn.Sequential`, você só pode verificar uma árvore de módulos se ela estiver dentro de uma partição do ponto de vista do paralelismo do pipeline. No caso do módulo `torch.nn.Sequential`, cada árvore de módulos dentro do módulo sequencial deve estar completamente dentro de uma partição para que o ponto de verificação de ativação funcione. Ao usar o particionamento manual, esteja ciente dessas restrições.
Ao usar o [particionamento automatizado de modelos](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-core-features.html#model-parallel-automated-model-splitting), você pode encontrar os logs de atribuição de particionamento começando com os logs `Partition assignments:` do trabalho de treinamento. Se um módulo for particionado em várias classificações (por exemplo, com um descendente em uma classificação e outro descendente em uma classificação diferente), a biblioteca ignora a tentativa de verificar o módulo e gera uma mensagem de aviso de que o módulo não será verificado.
**nota**
A biblioteca de paralelismo de SageMaker modelos suporta operações sobrepostas e não `allreduce` sobrepostas em combinação com pontos de verificação.
**nota**
PyTorchA API de ponto de verificação nativa do não é compatível com`smdistributed.modelparallel`.
**Exemplo 1:** O seguinte exemplo de código mostra como usar o ponto de verificação de ativação quando você tem uma definição de modelo em seu script.
```
import torch.nn as nn
import torch.nn.functional as F
from smdistributed.modelparallel.torch.patches.checkpoint import checkpoint
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
# This call of fc1 will be checkpointed
x = checkpoint(self.fc1, x)
x = self.fc2(x)
return F.log_softmax(x, 1)
```
**Exemplo 2:** O seguinte exemplo de código mostra como usar o ponto de verificação de ativação quando você tem um modelo sequencial em seu script.
```
import torch.nn as nn
from smdistributed.modelparallel.torch.patches.checkpoint import checkpoint_sequential
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.seq = nn.Sequential(
nn.Conv2d(1,20,5),
nn.ReLU(),
nn.Conv2d(20,64,5),
nn.ReLU()
)
def forward(self, x):
# This call of self.seq will be checkpointed
x = checkpoint_sequential(self.seq, x)
return F.log_softmax(x, 1)
```
**Exemplo 3:** O código de exemplo a seguir mostra como usar o ponto de verificação de ativação ao importar um modelo pré-construído de uma biblioteca, como Hugging Face PyTorch Transformers. Independentemente de você verificar os módulos sequenciais ou não, faça o seguinte:
1. Embrulhe o modelo em `smp.DistributedModel()`.
1. Defina um objeto para camadas sequenciais.
1. Enrole o objeto da camada sequencial por `smp.set_activation_checkpointig()`.
```
import smdistributed.modelparallel.torch as smp
from transformers import AutoModelForCausalLM
smp.init()
model = AutoModelForCausalLM(*args, **kwargs)
model = smp.DistributedModel(model)
# Call set_activation_checkpointing API
transformer_layers = model.module.module.module.transformer.seq_layers
smp.set_activation_checkpointing(
transformer_layers, pack_args_as_tuple=True, strategy='each')
```
# Ativação e descarregamento
Quando o ponto de verificação de ativação e o paralelismo do pipeline estão ativados e o número de microlotes é maior que um, o *descarregamento de ativação* é um atributo adicional que pode reduzir ainda mais o uso de memória. O descarregamento de ativação move de forma assíncrona as ativações com pontos de verificação correspondentes aos microlotes que não estão sendo executados atualmente na CPU. Logo antes de a GPU precisar das ativações para o retrocesso do microlote, essa funcionalidade recupera previamente as ativações descarregadas da CPU.
**nota**
Esse recurso está disponível PyTorch na biblioteca de paralelismo de SageMaker modelos v1.6.0 e versões posteriores.
## Como usar o descarregamento de ativação
Use o descarregamento de ativação para reduzir o uso de memória quando **o número de microlotes for maior que 1 e o ponto de verificação de ativação estiver ativado** (consulte [Ponto de verificação de ativação](model-parallel-extended-features-pytorch-activation-checkpointing.md)). Quando o ponto de verificação de ativação não é usado, o descarregamento de ativação não tem efeito. Quando usado com apenas um microlote, ele não economiza memória.
Para usar o descarregamento de ativação, defina `"offload_activations": True` para a configuração `modelparallel`.
O descarregamento de ativação move as ativações pontuais nos módulos `nn.Sequential` para a CPU de forma assíncrona. A transferência de dados pelo PCIe link se sobrepõe à computação da GPU. O descarregamento acontece imediatamente, assim que a passagem para frente de uma determinada camada de ponto de verificação é calculada. As ativações são carregadas de volta na GPU pouco antes de serem necessárias para a reversão de um microlote específico. A transferência CPU-GPU também se sobrepõe à computação.
Para ajustar a antecedência com que as ativações são carregadas de volta na GPU, você pode usar o parâmetro de configuração `"activation_loading_horizon"` (o padrão é definido como 4, deve ser `int` maior que 0). Um horizonte de carregamento de ativação maior faria com que as ativações fossem carregadas de volta na GPU mais cedo. Se o horizonte for muito grande, o impacto do descarregamento de ativação na economia de memória pode ser diminuído. Se o horizonte for muito pequeno, as ativações podem não ser carregadas a tempo, reduzindo a quantidade de sobreposição e degradando o performance.
**dica**
O descarregamento de ativação pode ser útil para modelos grandes com mais de cem bilhões de parâmetros.
**Configurar um SageMaker PyTorch estimador**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True,
"offload_activations": True,
"activation_loading_horizon": 4 # optional. default is 4.
}
}
```
# FP16 Treinamento com paralelismo de modelos
Para FP16 treinamento, aplique as seguintes modificações em seu roteiro de treinamento e estimador.
**nota**
Esse recurso está disponível PyTorch na biblioteca de paralelismo de SageMaker modelos v1.10.0 e versões posteriores.
**Adapte seu roteiro PyTorch de treinamento**
1. Envolva seu modelo usando o gerenciador de contexto [smdistributed.modelparallel.torch.model\$1creation()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.model_creation).
```
# fp16_training_script.py
import torch
import smdistributed.modelparallel.torch as smp
with smp.model_creation(
dtype=torch.float16 if args.fp16 else torch.get_default_dtype()
):
model = ...
```
**dica**
Se você estiver usando paralelismo de tensores, adicione `tensor_parallelism=smp.tp_size() > 1` ao gerenciador de contexto `smp.model_creation`. Adicionar essa linha também ajuda a detectar automaticamente se o paralelismo do tensor está ativado ou não.
```
with smp.model_creation(
... ,
tensor_parallelism=smp.tp_size() > 1
):
model = ...
```
1. Ao encapsular o otimizador com `smdistributed.modelparallel.torch.DistributedOptimizer`, defina o argumento `static_loss_scaling` ou `dynamic_loss_scaling`. Por padrão, `static_loss_scaling` está definido como `1.0` e `dynamic_loss_scaling` está definido como `False`. Se você definir `dynamic_loss_scale=True`, poderá alimentar as opções dinâmicas de escalabilidade de perda como um dicionário por meio do argumento `dynamic_loss_args`. Na maioria dos casos, recomendamos que você use a escala de perda dinâmica com as opções padrão. [Para obter mais informações, opções e exemplos da função de encapsulamento do otimizador, consulte smdistributed.modelparallel.torch. DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedoptimizer) API.
O código a seguir é um exemplo de encapsulamento de um objeto `Adadelta` otimizador com escala dinâmica de perda para treinamento. FP16
```
optimizer = torch.optim.Adadelta(...)
optimizer = smp.DistributedOptimizer(
optimizer,
static_loss_scale=None,
dynamic_loss_scale=True,
dynamic_loss_args={
"scale_window": 1000,
"min_scale": 1,
"delayed_shift": 2
}
)
```
**Configurar um SageMaker PyTorch estimador**
Adicione o FP16 parâmetro (`"fp16"`) à configuração de distribuição para paralelismo do modelo ao criar um SageMaker PyTorch objeto estimador. Para obter uma lista completa dos parâmetros de configuração do paralelismo do modelo, consulte [Parâmetros para `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#parameters-for-smdistributed).
```
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled": True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2,
"tensor_parallel_degree": 2,
...,
"fp16": True
}
}
fp16_estimator = PyTorch(
entry_point="fp16_training_script.py", # Specify your train script
...,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": {...}
}
)
fp16_estimator.fit(...)
```
Quando o FP16 treinamento começa, o modelo e o otimizador são agrupados por `FP16_Module` e, `FP16_Optimizer` respectivamente, que são `smdistributed` versões modificadas dos utilitários do [Apex](https://nvidia.github.io/apex/fp16_utils.html#apex-fp16-utils). `FP16_Module`converte o modelo em FP16 dtype e lida com a passagem direta para dentro. FP16
**dica**
Você pode aplicar o recorte de gradiente chamando `clip_master_grads` antes de `optimizer.step`.
```
optimizer.clip_master_grads(max_norm) # max_norm(float or int): max norm of the gradients
```
**dica**
Ao usar `torch.optim.lr_scheduler` e FP16 treinar, você precisa passar `optimizer.optimizer` para o agendador LR em vez do otimizador. Veja o exemplo de código a seguir.
```
from torch.optim.lr_scheduler import StepLR
scheduler = StepLR(
optimizer.optimizer if smp.state.cfg.fp16 else optimizer,
step_size=1,
gamma=args.gamma
)
```
# Support for FlashAttention
Support for FlashAttention é um recurso da biblioteca aplicável apenas ao modelo de *transformador distribuído*, que é um modelo de transformador incluído [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedmodel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedmodel)para treinamento paralelo de modelos. Esse atributo também é compatível com [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md).
A [FlashAttention](https://github.com/HazyResearch/flash-attention)biblioteca só oferece suporte a modelos quando `attention_head_size` é definida com um valor múltiplo de 8 e menor que 128. Portanto, ao treinar um transformador distribuído e garantir que ele FlashAttention funcione corretamente, você deve ajustar os parâmetros para que o tamanho da cabeça de atenção atenda aos requisitos. Para obter mais informações, consulte também [Instalação e recursos](https://github.com/HazyResearch/flash-attention#installation-and-features) no *FlashAttention GitHubrepositório.*
Por exemplo, suponha que você configure um modelo Transformador com `hidden_width=864` e `num_heads=48`. O tamanho da cabeça de FlashAttention é calculado como`attention_head_size = hidden_width / num_heads = 864 / 48 = 18`. Para habilitar FlashAttention, você precisa ajustar o `num_heads` parâmetro para`54`, de forma que `attention_head_size = hidden_width / num_heads = 864 / 54 = 16` seja um múltiplo de 8.
# Execute um trabalho de treinamento SageMaker distribuído com paralelismo de modelos
Saiba como executar um trabalho de treinamento paralelo de modelo com seu próprio script de treinamento usando o SDK do SageMaker Python com a biblioteca de paralelismo de modelos. SageMaker
Há três cenários de uso para executar um trabalho de SageMaker treinamento.
1. Você pode usar um dos contêineres de aprendizado AWS profundo pré-construídos para TensorFlow e. PyTorch Essa opção é recomendada se for a primeira vez que você usa a biblioteca paralela de modelos. Para encontrar um tutorial sobre como executar um trabalho de treinamento paralelo de SageMaker modelos, consulte os exemplos de cadernos em [PyTorch treinamento com a biblioteca de paralelismo de modelos da Amazon SageMaker AI](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel).
1. Você pode estender os contêineres pré-criados para lidar com quaisquer requisitos funcionais adicionais para seu algoritmo ou modelo que a imagem pré-criada do SageMaker Docker não suporte. Para encontrar um exemplo de como você pode estender um contêiner predefinido, consulte [Estenda uma imagem de contêiner predefinida](prebuilt-containers-extend.md).
1. Você pode adaptar seu próprio contêiner Docker para trabalhar com SageMaker IA usando o kit de [ferramentas SageMaker de treinamento](https://github.com/aws/sagemaker-training-toolkit). Por exemplo, consulte [Adaptando seu próprio contêiner de treinamento](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html).
Para ver as opções 2 e 3 na lista anterior, consulte [Estenda um contêiner Docker pré-construído que contém a biblioteca paralela SageMaker de modelos distribuídos](model-parallel-sm-sdk.md#model-parallel-customize-container) para saber como instalar a biblioteca paralela de modelos em um contêiner Docker estendido ou personalizado.
Em todos os casos, você inicia seu trabalho de treinamento configurando um `PyTorch` estimador SageMaker `TensorFlow` or para ativar a biblioteca. Para saber mais, consulte os tópicos a seguir.
**Topics**
+ [Etapa 1: modifique seu próprio script de treinamento usando a biblioteca paralela SageMaker de modelos distribuídos](model-parallel-customize-training-script.md)
+ [Etapa 2: Iniciar um Training Job usando o SageMaker Python SDK](model-parallel-sm-sdk.md)
# Etapa 1: modifique seu próprio script de treinamento usando a biblioteca paralela SageMaker de modelos distribuídos
Use esta seção para aprender a personalizar seu script de treinamento para usar os principais recursos da biblioteca de paralelismo de modelos de SageMaker IA da Amazon. *Para usar as funções e os parâmetros de API específicos da biblioteca, recomendamos que você use essa documentação junto com a [biblioteca de modelos SageMaker paralelos na documentação do SDK APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) do PythonSageMaker .*
Os exemplos de scripts de treinamento fornecidos nessas seções são simplificados e projetados para destacar as alterações necessárias que você deve fazer para usar a biblioteca. Para end-to-end exemplos de notebooks executáveis que demonstram como usar um script de PyTorch treinamento TensorFlow ou com a biblioteca de paralelismo de SageMaker modelos, consulte. [Exemplos da biblioteca de paralelismo de modelos de SageMaker IA da Amazon v2](distributed-model-parallel-v2-examples.md)
**Topics**
+ [Divida o modelo do seu script de treinamento usando a biblioteca de SageMaker paralelismo de modelos](#model-parallel-model-splitting-using-smp-lib)
+ [Modificar um script TensorFlow de treinamento](model-parallel-customize-training-script-tf.md)
+ [Modificar um script PyTorch de treinamento](model-parallel-customize-training-script-pt.md)
## Divida o modelo do seu script de treinamento usando a biblioteca de SageMaker paralelismo de modelos
Há duas maneiras de modificar seu script de treinamento para configurar a divisão do modelo: divisão automática ou divisão manual.
### Divisão automatizada de modelos
*Ao usar a biblioteca SageMaker de paralelismo de modelos, você pode aproveitar a *divisão automatizada de modelos, também conhecida como particionamento* automatizado de modelos.* A biblioteca utiliza um algoritmo de particionamento que equilibra a memória, minimiza a comunicação entre dispositivos e otimiza o desempenho. Você pode configurar o algoritmo de particionamento automático para otimizar a velocidade ou a memória.
Também é possível usar a divisão manual do modelo. Recomendamos a divisão automatizada do modelo, a menos que você esteja muito familiarizado com a arquitetura do modelo e tenha uma boa ideia de como particionar seu modelo de forma eficiente.
#### Como funciona
O particionamento automático ocorre durante a primeira etapa de treinamento, quando a função decorada com `smp.step` é chamada pela primeira vez. Nesta chamada, a biblioteca primeiro constrói uma versão do modelo na RAM da CPU (para evitar limitações de memória da GPU) e, em seguida, analisa o grafo do modelo e toma uma decisão de particionamento. Com base nessa decisão, cada partição do modelo é carregada em uma GPU e somente então a primeira etapa é executada. Devido a essas etapas de análise e particionamento, a primeira etapa de treinamento pode levar mais tempo.
Em qualquer estrutura, a biblioteca gerencia a comunicação entre dispositivos por meio de seu próprio back-end, que é otimizado para AWS infraestrutura.
O design de autopartição se adapta às características do framework, e a biblioteca realiza o particionamento no nível de granularidade que é mais natural em cada framework. Por exemplo, em TensorFlow, cada operação específica pode ser atribuída a um dispositivo diferente, enquanto em PyTorch, a atribuição é feita no nível do módulo, onde cada módulo consiste em várias operações. A seção a seguir analisa as especificidades do design em cada framework.
##### Divisão automatizada de modelos com PyTorch
Durante a primeira etapa de treinamento, a biblioteca de paralelismo de modelo internamente executa uma etapa de rastreamento destinada a construir o grafo do modelo e determinar as formas dos tensores e parâmetros. Após essa etapa de rastreamento, a biblioteca constrói uma árvore, que consiste nos objetos `nn.Module` aninhados no modelo, bem como nos dados adicionais coletados do rastreamento, como a quantidade de objetos armazenados `nn.Parameters` e o tempo de execução de cada `nn.Module`.
Em seguida, a biblioteca percorre essa árvore a partir da raiz e executa um algoritmo de particionamento que atribui cada `nn.Module` a um dispositivo, equilibrando a carga computacional (medida pelo tempo de execução do módulo) e o uso de memória (medido pelo tamanho total armazenado de `nn.Parameter` e ativações). Se vários `nn.Modules` compartilham o mesmo `nn.Parameter`, então esses módulos são colocados no mesmo dispositivo para evitar manter várias versões do mesmo parâmetro. Assim que a decisão de particionamento é tomada, os módulos e pesos atribuídos são carregados em seus dispositivos.
Para obter instruções sobre como registrar o `smp.step` decorador em seu script PyTorch de treinamento, consulte[Divisão automatizada com PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16).
##### Divisão automatizada de modelos com TensorFlow
A biblioteca de paralelismo de modelos analisa os tamanhos das variáveis treináveis e a estrutura do gráfico e usa internamente um algoritmo de particionamento gráfico. Este algoritmo determina uma atribuição de dispositivo para cada operação, com o objetivo de minimizar a quantidade de comunicação necessária entre dispositivos, sujeito a duas restrições:
+ Equilibrando o número de variáveis armazenadas em cada dispositivo.
+ Equilibrando o número de operações executadas em cada dispositivo
Se você especificar `speed` para `optimize` (nos parâmetros de paralelismo do modelo no Python SDK), a biblioteca tentará equilibrar o número de operações e objetos `tf.Variable` em cada dispositivo. Caso contrário, ele tenta equilibrar o tamanho total de `tf.Variables`.
Uma vez tomada a decisão de particionamento, a biblioteca cria uma representação serializada do subgráfico que cada dispositivo precisa executar e os importa para cada dispositivo. Durante o particionamento, a biblioteca coloca as operações que consomem o mesmo `tf.Variable` e as operações que fazem parte da mesma camada Keras no mesmo dispositivo. Também respeita as restrições de colocation impostas por. TensorFlow Isso significa que, por exemplo, se houver duas camadas Keras que compartilham um `tf.Variable`, todas as operações que fazem parte dessas camadas são colocadas em um dispositivo único.
Para obter instruções sobre como registrar o `smp.step` decorador em seu script PyTorch de treinamento, consulte[Divisão automatizada com TensorFlow](model-parallel-customize-training-script-tf.md#model-parallel-customize-training-script-tf-23).
##### Comparação da divisão automatizada de modelos entre frameworks
Em TensorFlow, a unidade fundamental de computação é a e TensorFlow representa o modelo como um `tf.Operation` gráfico acíclico direcionado (DAG) de `tf.Operation` s e, portanto, a biblioteca de paralelismo do modelo particiona esse DAG para que cada nó vá para um dispositivo. Crucialmente, os objetos `tf.Operation` são suficientemente ricos em atributos personalizáveis e são universais no sentido de que cada modelo tem a garantia de consistir em um gráfico desses objetos.
PyTorch por outro lado, não tem uma noção equivalente de operação que seja suficientemente rica e universal. A unidade de computação mais próxima PyTorch que tem essas características é uma`nn.Module`, que está em um nível de granularidade muito maior, e é por isso que a biblioteca faz o particionamento nesse nível em. PyTorch
### Divisão manual de modelos
Se você quiser especificar manualmente como particionar seu modelo entre dispositivos, use o gerenciador de contexto do `smp.partition`. Para instruções sobre como configurar o gerenciador de contexto para particionamento manual, consulte as seguintes páginas.
+ [Divisão manual com TensorFlow](model-parallel-customize-training-script-tf.md#model-parallel-customize-training-script-tf-manual)
+ [Divisão manual com PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16-hvd)
Para usar essa opção depois de fazer modificações, na Etapa 2, você precisará definir e definir uma `default_partition` na classe de estimador da estrutura do SDK do Python SageMaker. `auto_partition` `False` Qualquer operação que não seja colocada explicitamente em uma partição por meio do gerenciador de contexto do `smp.partition` é executada no `default_partition`. Nesse caso, a lógica de divisão automatizada é ignorada e cada operação é colocada com base na sua especificação. Com base na estrutura gráfica resultante, a biblioteca de paralelismo de modelos cria automaticamente um cronograma de execução em pipeline.
# Modificar um script TensorFlow de treinamento
Nesta seção, você aprende a modificar scripts de TensorFlow treinamento para configurar a biblioteca de paralelismo de SageMaker modelos para particionamento automático e particionamento manual. Essa seleção de exemplos também inclui um exemplo integrado ao Horovod para modelo híbrido e paralelismo de dados.
**nota**
Para descobrir quais TensorFlow versões são suportadas pela biblioteca, consulte[Estruturas suportadas e Regiões da AWS](distributed-model-parallel-support.md).
As modificações necessárias que você deve fazer em seu script de treinamento para usar a biblioteca estão listadas em [Divisão automatizada com TensorFlow](#model-parallel-customize-training-script-tf-23).
Para saber como modificar seu script de treinamento para usar o modelo híbrido e o paralelismo de dados com o Horovod, consulte [Divisão automatizada com TensorFlow e Horovod para modelo híbrido e paralelismo de dados](#model-parallel-customize-training-script-tf-2.3).
Se você quiser usar o particionamento manual, revise também [Divisão manual com TensorFlow](#model-parallel-customize-training-script-tf-manual).
Os tópicos a seguir mostram exemplos de scripts de treinamento que você pode usar para configurar a biblioteca de paralelismo SageMaker de modelos da para particionamento automático e modelos de particionamento manual. TensorFlow
**nota**
O particionamento automático está habilitado por padrão. A menos que especificado de outra forma, os scripts de exemplo usam particionamento automático.
**Topics**
+ [Divisão automatizada com TensorFlow](#model-parallel-customize-training-script-tf-23)
+ [Divisão automatizada com TensorFlow e Horovod para modelo híbrido e paralelismo de dados](#model-parallel-customize-training-script-tf-2.3)
+ [Divisão manual com TensorFlow](#model-parallel-customize-training-script-tf-manual)
+ [Recursos de framework incompatíveis](#model-parallel-tf-unsupported-features)
## Divisão automatizada com TensorFlow
As seguintes alterações no script de treinamento são necessárias para executar um TensorFlow modelo com a biblioteca SageMaker de paralelismo de modelos:
1. Importe e inicialize a biblioteca com o [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init).
1. Defina um modelo Keras herdando da classe Keras Model [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_tensorflow.html](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_tensorflow.html) em vez da classe Keras Model. Retorne as saídas do modelo do método de chamada do objeto `smp.DistributedModel`. Esteja ciente de que qualquer tensor retornado do método de chamada será transmitido para dispositivos de paralelismo de modelo, acarretando custos de comunicação. Portanto, quaisquer tensores que não são necessários fora do método de chamada (como ativações intermediárias) não devem ser retornados.
1. Defina `drop_remainder=True` no método `tf.Dataset.batch()`. Isso é para garantir que o tamanho do lote seja sempre divisível pelo número de microlotes.
1. Semeie as operações aleatórias no pipeline de dados usando`smp.dp_rank()`, por exemplo, `shuffle(ds, seed=smp.dp_rank())` para garantir a consistência de amostras de dados GPUs que contêm diferentes partições de modelo.
1. Coloque a lógica para frente e para trás em uma step function e decore-a com `smp.step`.
1. Execute o pós-processamento nas saídas em microlotes usando métodos [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput) como `reduce_mean`. A função do [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init) deve ter um valor de retorno que dependa da saída de `smp.DistributedModel`.
1. Se houver uma etapa de avaliação, coloque logicamente a frente (forward) dentro de uma função decorada com `smp.step` e processe os resultados usando a [API do `StepOutput`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput).
[Para saber mais sobre a API SageMaker da biblioteca de paralelismo de modelos, consulte a documentação da API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html)
O script Python a seguir é um exemplo de script de treinamento após as alterações serem feitas.
```
import tensorflow as tf
# smdistributed: Import TF2.x API
import smdistributed.modelparallel.tensorflow as smp
# smdistributed: Initialize
smp.init()
# Download and load MNIST dataset.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(
"MNIST-data-%d" % smp.rank()
)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
# smdistributed: If needed, seed the shuffle with smp.dp_rank(), and drop_remainder
# in batching to make sure batch size is always divisible by number of microbatches
train_ds = (
tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10000, seed=smp.dp_rank())
.batch(256, drop_remainder=True)
)
# smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API
class MyModel(smp.DistributedModel):
def __init__(self):
super(MyModel, self).__init__()
# define layers
def call(self, x, training=None):
# define forward pass and return the model output
model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy")
# smdistributed: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(images, labels):
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
grads = optimizer.get_gradients(loss, model.trainable_variables)
return grads, loss, predictions
@tf.function
def train_step(images, labels):
gradients, loss, predictions = get_grads(images, labels)
# smdistributed: Accumulate the gradients across microbatches
gradients = [g.accumulate() for g in gradients]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# smdistributed: Merge predictions and average losses across microbatches
train_accuracy(labels, predictions.merge())
return loss.reduce_mean()
for epoch in range(5):
# Reset the metrics at the start of the next epoch
train_accuracy.reset_states()
for images, labels in train_ds:
loss = train_step(images, labels)
accuracy = train_accuracy.result()
```
Se você terminar de preparar seu roteiro de treinamento, prossiga para [Etapa 2: Iniciar um Training Job usando o SageMaker Python SDK](model-parallel-sm-sdk.md). Se quiser executar um modelo híbrido e um trabalho de treinamento paralelo de dados, siga para a próxima seção.
## Divisão automatizada com TensorFlow e Horovod para modelo híbrido e paralelismo de dados
Você pode usar a biblioteca de paralelismo de SageMaker modelos com o Horovod para modelos híbridos e paralelismo de dados. Para ler mais sobre como a biblioteca divide um modelo para paralelismo híbrido, consulte [Paralelismo de tubulação (disponível para e) PyTorch TensorFlow](model-parallel-intro.md#model-parallel-intro-pp).
Nesta etapa, vamos nos concentrar em como modificar seu script de treinamento para adaptar a biblioteca de paralelismo de SageMaker modelos.
Para configurar adequadamente seu script de treinamento para adotar a configuração de paralelismo híbrido que você definirá em [Etapa 2: Iniciar um Training Job usando o SageMaker Python SDK](model-parallel-sm-sdk.md), utilize as funções auxiliares da biblioteca, `smp.dp_rank()` e `smp.mp_rank()`, que detectam automaticamente o rank de paralelismo de dados e o rank de paralelismo de modelo, respectivamente.
Para encontrar todas as primitivas de MPI suportadas pela biblioteca, consulte [Noções básicas de MPI na](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#mpi-basics) documentação do SDK para Python SageMaker .
As mudanças necessárias no script são:
+ Adicionando `hvd.allreduce`
+ Variáveis de transmissão após o primeiro lote, conforme exigido pela Horovod
+ Semeando, embaralhando, and/or fragmentando operações no pipeline de dados com. `smp.dp_rank()`
**nota**
Ao usar o Horovod, você não deve solicitar diretamente `hvd.init` no seu script de treinamento. Em vez disso, você precisará `"horovod"` definir como `True` nos parâmetros do SDK `modelparallel` do SageMaker Python em. [Etapa 2: Iniciar um Training Job usando o SageMaker Python SDK](model-parallel-sm-sdk.md) Isso permite que a biblioteca inicialize internamente o Horovod com base nas atribuições de dispositivos das partições do modelo. Chamar `hvd.init()` diretamente em seu script de treinamento pode causar problemas.
**nota**
Usar a API do `hvd.DistributedOptimizer` diretamente em seu script de treinamento pode resultar em performance e velocidade de treinamento ruins, porque a API coloca implicitamente a operação `AllReduce` dentro do `smp.step`. Recomendamos que você use a biblioteca de paralelismo de modelos com o Horovod chamando diretamente `hvd.allreduce` após a chamada `accumulate()` ou `reduce_mean()` nos gradientes retornados `smp.step`, conforme mostrado no exemplo a seguir.
[Para saber mais sobre a API SageMaker da biblioteca de paralelismo de modelos, consulte a documentação da API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html)
```
import tensorflow as tf
import horovod.tensorflow as hvd
# smdistributed: Import TF2.x API
import smdistributed.modelparallel.tensorflow as smp
# smdistributed: Initialize
smp.init()
# Download and load MNIST dataset.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(
"MNIST-data-%d" % smp.rank()
)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
# smdistributed: Seed the shuffle with smp.dp_rank(), and drop_remainder
# in batching to make sure batch size is always divisible by number of microbatches
train_ds = (
tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10000, seed=smp.dp_rank())
.batch(256, drop_remainder=True)
)
# smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API
class MyModel(smp.DistributedModel):
def __init__(self):
super(MyModel, self).__init__()
# define layers
def call(self, x, training=None):
# define forward pass and return model outputs
model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy")
# smdistributed: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(images, labels):
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
grads = optimizer.get_gradients(loss, model.trainable_variables)
return grads, loss, predictions
@tf.function
def train_step(images, labels, first_batch):
gradients, loss, predictions = get_grads(images, labels)
# smdistributed: Accumulate the gradients across microbatches
# Horovod: AllReduce the accumulated gradients
gradients = [hvd.allreduce(g.accumulate()) for g in gradients]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# Horovod: Broadcast the variables after first batch
if first_batch:
hvd.broadcast_variables(model.variables, root_rank=0)
hvd.broadcast_variables(optimizer.variables(), root_rank=0)
# smdistributed: Merge predictions across microbatches
train_accuracy(labels, predictions.merge())
return loss.reduce_mean()
for epoch in range(5):
# Reset the metrics at the start of the next epoch
train_accuracy.reset_states()
for batch, (images, labels) in enumerate(train_ds):
loss = train_step(images, labels, tf.constant(batch == 0))
```
## Divisão manual com TensorFlow
Use gerenciadores de contexto do `smp.partition` para colocar as operações em uma partição específica. Qualquer operação não colocada em nenhum contexto `smp.partition` é colocada no `default_partition`. [Para saber mais sobre a API SageMaker da biblioteca de paralelismo de modelos, consulte a documentação da API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html)
```
import tensorflow as tf
# smdistributed: Import TF2.x API.
import smdistributed.modelparallel.tensorflow as smp
# smdistributed: Initialize
smp.init()
# Download and load MNIST dataset.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(
"MNIST-data-%d" % smp.rank()
)
x_train, x_test = x_train / 255.0, x_test / 255.0
# Add a channels dimension
x_train = x_train[..., tf.newaxis]
x_test = x_test[..., tf.newaxis]
# smdistributed: If needed, seed the shuffle with smp.dp_rank(), and drop_remainder
# in batching to make sure batch size is always divisible by number of microbatches.
train_ds = (
tf.data.Dataset.from_tensor_slices((x_train, y_train))
.shuffle(10000, seed=smp.dp_rank())
.batch(256, drop_remainder=True)
)
# smdistributed: Define smp.DistributedModel the same way as Keras sub-classing API.
class MyModel(smp.DistributedModel):
def __init__(self):
# define layers
def call(self, x):
with smp.partition(0):
x = self.layer0(x)
with smp.partition(1):
return self.layer1(x)
model = MyModel()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name="train_accuracy")
# smdistributed: Define smp.step. Return any tensors needed outside
@smp.step
def get_grads(images, labels):
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
grads = optimizer.get_gradients(loss, model.trainable_variables)
return grads, loss, predictions
@tf.function
def train_step(images, labels):
gradients, loss, predictions = get_grads(images, labels)
# smdistributed: Accumulate the gradients across microbatches
gradients = [g.accumulate() for g in gradients]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# smdistributed: Merge predictions and average losses across microbatches
train_accuracy(labels, predictions.merge())
return loss.reduce_mean()
for epoch in range(5):
# Reset the metrics at the start of the next epoch
train_accuracy.reset_states()
for images, labels in train_ds:
loss = train_step(images, labels)
accuracy = train_accuracy.result()
```
## Recursos de framework incompatíveis
Os seguintes TensorFlow recursos não são compatíveis com a biblioteca:
+ O `tf.GradientTape()` não tem suporte no momento. Você pode usar `Optimizer.get_gradients()` ou `Optimizer.compute_gradients()` em vez disso para calcular gradientes.
+ Atualmente, a API do `tf.train.Checkpoint.restore()` não tem suporte. Para pontos de verificação, use `smp.CheckpointManager` em vez disso, que fornece a mesma API e funcionalidade. Observe que as restaurações do ponto de verificação do `smp.CheckpointManager` devem ocorrer após a primeira etapa.
# Modificar um script PyTorch de treinamento
Nesta seção, você aprende a modificar scripts de PyTorch treinamento para configurar a biblioteca de paralelismo de SageMaker modelos para particionamento automático e particionamento manual.
**nota**
Para descobrir quais PyTorch versões são suportadas pela biblioteca, consulte[Estruturas suportadas e Regiões da AWS](distributed-model-parallel-support.md).
**dica**
Para exemplos de end-to-end cadernos que demonstram como usar um script de PyTorch treinamento com a biblioteca de paralelismo de SageMaker modelos, consulte. [Exemplos da biblioteca de paralelismo de modelos Amazon SageMaker AI v1](distributed-model-parallel-examples.md)
Observe que o particionamento automático está habilitado por padrão. A menos que seja especificado de outra forma, os scripts a seguir utilizam autoparticionamento.
**Topics**
+ [Divisão automatizada com PyTorch](#model-parallel-customize-training-script-pt-16)
+ [Divisão manual com PyTorch](#model-parallel-customize-training-script-pt-16-hvd)
+ [Considerações](#model-parallel-pt-considerations)
+ [Recursos de framework incompatíveis](#model-parallel-pt-unsupported-features)
## Divisão automatizada com PyTorch
As seguintes alterações no script de treinamento são necessárias para executar um script de PyTorch treinamento com a biblioteca SageMaker de paralelismo de modelos da:
1. Importe e inicialize a biblioteca com o [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init).
1. Empacote o modelo com [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedModel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedModel). Esteja ciente de que quaisquer tensores retornados pelo método `forward` do objeto `nn.Module` subjacente serão transmitidos para os dispositivos de paralelismo de modelo, incorrendo em sobrecarga de comunicação. Portanto, quaisquer tensores que não são necessários fora do método de chamada (como ativações intermediárias) não devem ser retornados.
**nota**
Para FP16 treinamento, você precisa usar o gerenciador de contexto [smdistributed.modelparallel.torch.model\$1creation () para empacotar](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html) o modelo. Para obter mais informações, consulte [FP16 Treinamento com paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md).
1. Empacotar o otimizador com [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer).
**nota**
Para FP16 treinamento, você precisa configurar a escala de perda estática ou dinâmica. Para obter mais informações, consulte [FP16 Treinamento com paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md).
1. Use o objeto `DistributedModel` retornado em vez de um modelo de usuário.
1. Coloque a lógica para frente e para trás em uma step function e decore-a com [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#smp.init).
1. Restrinja cada processo ao seu próprio dispositivo por meio de `torch.cuda.set_device(smp.local_rank())`.
1. Mova os tensores de entrada para a GPU usando a API do `.to()` antes da chamada do `smp.step` (veja o exemplo abaixo).
1. Substitua o `torch.Tensor.backward` e o `torch.autograd.backward` pelo `DistributedModel.backward`.
1. Execute o pós-processamento nas saídas em microlotes usando métodos [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput) como `reduce_mean`.
1. Se houver uma etapa de avaliação, coloque logicamente a frente (forward) dentro de uma função decorada com `smp.step` e processe os resultados usando a [API do `StepOutput`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_common_api.html#StepOutput).
1. Defina `drop_last=True` em `DataLoader`. Como alternativa, pule manualmente um lote no ciclo de treinamento se o tamanho do lote não for divisível pelo número de microlotes.
[Para saber mais sobre a API SageMaker da biblioteca de paralelismo de modelos, consulte a documentação da API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html)
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class GroupedNet(nn.Module):
def __init__(self):
super(GroupedNet, self).__init__()
# define layers
def forward(self, x):
# define forward pass and return model outputs
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by the current process,
# based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
dataset = datasets.MNIST("../data", train=True, download=False)
# smdistributed: Shard the dataset based on data-parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = GroupedNet()
optimizer = optim.Adadelta(model.parameters(), lr=4.0)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Divisão manual com PyTorch
Use gerenciadores de contexto do [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/v1.2.0/smd_model_parallel_pytorch.html#smp.DistributedOptimizer) para colocar módulos em dispositivos específicos. Qualquer operação não colocada em qualquer contexto `smp.partition` é colocada no `default_partition`. O `default_partition` precisa ser fornecido se o `auto_partition` estiver definido como `False`. Os módulos criados em um contexto `smp.partition` específico são colocados na partição correspondente.
[Para saber mais sobre a API SageMaker da biblioteca de paralelismo de modelos, consulte a documentação da API.](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html)
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class GroupedNet(nn.Module):
def __init__(self):
super(GroupedNet, self).__init__()
with smp.partition(0):
# define child modules on device 0
with smp.partition(1):
# define child modules on device 1
def forward(self, x):
# define forward pass and return model outputs
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by the current process,
# based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
dataset = datasets.MNIST("../data", train=True, download=False)
# smdistributed: Shard the dataset based on data-parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = GroupedNet()
optimizer = optim.Adadelta(model.parameters(), lr=4.0)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Considerações
Ao configurar um script de PyTorch treinamento usando a biblioteca SageMaker de paralelismo de modelos da, você deve estar ciente do seguinte:
+ Se você estiver usando uma técnica de otimização que depende de normas de gradiente globais, por exemplo, a norma de gradiente de todo o modelo, como algumas variantes do otimizador LAMB ou o clipping global de gradiente, é necessário reunir todas as normas nas partições do modelo para garantir a correção. Você pode usar os tipos de dados básicos de comunicação da biblioteca para fazer isso.
+ Todos os argumentos do `torch.Tensor` para os métodos diretos do `nn.Modules` em seu modelo devem ser usados no cálculo da saída do módulo. Em outras palavras, a biblioteca não suporta o caso em que há um argumento do `torch.Tensor` para um módulo do qual a saída do módulo não depende.
+ O argumento para a chamada `smp.DistributedModel.backward()` deve depender de todas as saídas do modelo. Em outras palavras, não pode haver uma saída da chamada `smp.DistributedModel.forward` que não seja usada no cálculo do tensor que é alimentado na chamada `smp.DistributedModel.backward`.
+ Se houver chamadas `torch.cuda.synchronize()` em seu código, talvez seja necessário ligar `torch.cuda.set_device(smp.local_rank())` imediatamente antes da chamada de sincronização. Caso contrário, contextos CUDA desnecessários podem ser criados no dispositivo 0, o que consumirá desnecessariamente memória.
+ Dado que a biblioteca coloca `nn.Modules` em dispositivos diferentes, os módulos no modelo não devem depender de nenhum estado global que seja modificado dentro de `smp.step`. Qualquer estado que permaneça constante ao longo do treinamento, ou que seja modificado fora de `smp.step` de uma maneira que seja visível para todos os processos, é permitido.
+ Você não precisa mover o modelo para a GPU (por exemplo, usando`model.to(device)`) ao usar a biblioteca. Se você tentar mover o modelo para a GPU antes que o modelo seja particionado (antes da primeira chamada `smp.step`), a chamada de movimentação será ignorada. A biblioteca move automaticamente a parte do modelo atribuída a uma classificação para sua GPU. Quando o treinamento com a biblioteca começar, não mova o modelo para a CPU e o utilize, pois ele não terá os parâmetros corretos para módulos não atribuídos à partição mantida pelo processo. Se você quiser treinar novamente um modelo ou usá-lo para inferência sem a biblioteca depois de treiná-lo usando a biblioteca de paralelismo de modelos, a maneira recomendada é salvar o modelo completo usando nossa API de ponto de verificação e carregá-lo de volta em um módulo normal. PyTorch
+ Se você tem uma lista de módulos de forma que a saída de um alimenta o próximo, substituir essa lista por `nn.Sequential` pode melhorar significativamente a performance.
+ A atualização dos pesos (`optimizer.step()`) precisa ocorrer fora de `smp.step`, porque é nesse momento que toda a passagem de retropropagação é concluída e os gradientes estão prontos. Ao usar um modelo híbrido com paralelismo de modelos e dados, neste ponto, também é garantido o AllReduce término dos gradientes.
+ Ao usar a biblioteca em combinação com o paralelismo de dados, certifique-se de que o número de lotes em todas as classificações paralelas de dados seja o mesmo para que você AllReduce não fique esperando por uma classificação que não esteja participando da etapa.
+ Se você iniciar um trabalho de treinamento usando um tipo de instância ml.p4d (como ml.p4d.24xlarge), é necessário definir a variável do carregador de dados `num_workers=0`. Por exemplo, é possível definir o seu `DataLoader` da seguinte forma.
```
dataloader = torch.utils.data.DataLoader(
data,
batch_size=batch_size,
num_workers=0,
pin_memory=True,
drop_last=True,
shuffle=shuffle,
)
```
+ As entradas para `smp.step` devem ser as entradas do modelo geradas pelo `DataLoader`. Isso ocorre porque divide `smp.step` internamente os tensores de entrada ao longo da dimensão do lote e os canaliza. Isso significa que passar a `DataLoader` si mesmo para a função `smp.step` para gerar as entradas internas do modelo não funciona.
Por exemplo, se definir um `DataLoader` da seguinte forma.
```
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
```
Você deve acessar as entradas do modelo geradas `train_loader` e passá-las para uma função `smp.step` decorada. Não passe `train_loader` diretamente para a função `smp.step`.
```
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
...
_, loss_mb = train_step(model, data, target)
...
@smp.step
def train_step(model, data, target):
...
return output, loss
```
+ Os tensores de entrada `smp.step` devem ser movidos para o dispositivo atual usando a API do `.to()`, que deve ocorrer após a chamada `torch.cuda.set_device(local_rank())`.
Por exemplo, é possível definir a função `train` da seguinte forma. Essa função adiciona `data` e `target` ao dispositivo atual usando a API do `.to()` antes de usar esses tensores de entrada para chamar `train_step`.
```
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by the current process,
# based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
```
Os tensores de entrada para essa função `smp.set` decorada foram movidos para o dispositivo atual na função `train` acima. O modelo *não* precisa ser movido para o dispositivo atual. A biblioteca move automaticamente a parte do modelo atribuída a uma classificação para sua GPU.
```
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
```
## Recursos de framework incompatíveis
Os seguintes PyTorch recursos não são compatíveis com a biblioteca de SageMaker paralelismo de modelos da:
+ Se você usa paralelismo de dados com o [PyTorch DDP](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html) nativo, o módulo [https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html)wrapper não é suportado pela biblioteca. A biblioteca gerencia internamente a integração com o PyTorch DDP, incluindo transmissão de parâmetros e gradiente. AllReduce Ao utilizar a biblioteca, os buffers do módulo são transmitidos apenas uma vez no início do treinamento. Se seu modelo tiver buffers de módulo que precisam ser sincronizados entre grupos paralelos de dados em cada etapa, você pode fazer isso por meio da API do `torch.distributed`, usando o grupo de processos que pode ser obtido por meio de `smp.get_dp_process_group()`.
+ Para treinamento de precisão mista, o módulo `apex.amp` não tem suporte. A maneira recomendada de usar a biblioteca com precisão mista automática é usar `torch.cuda.amp`, com exceção do uso de `smp.amp.GradScaler` em vez da implementação em torch.
+ `torch.jit.ScriptModules` e `ScriptFunctions` não têm suporte de `smp.DistributedModel`.
+ `apex` : `FusedLayerNorm`, `FusedAdam`, `FusedLAMB` e `FusedNovoGrad` do `apex` não têm suporte. Você pode usar as implementações de biblioteca deles por meio `smp.optimizers` e `smp.nn` APIs em vez disso.
# Etapa 2: Iniciar um Training Job usando o SageMaker Python SDK
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
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
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
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
```
**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).
# Apontando pontos de verificação e ajustando um modelo com paralelismo de modelos
A biblioteca de paralelismo de SageMaker modelos fornece pontos de verificação APIs para salvar o estado do modelo e o estado do otimizador divididos pelas várias estratégias de paralelismo do modelo e para carregar pontos de verificação para treinamento contínuo de onde você deseja reiniciar o treinamento e ajustar. Eles APIs também oferecem suporte a opções para salvar parcialmente ou totalmente os estados do modelo e do otimizador.
**Topics**
+ [Pontos de verificação de um modelo distribuído](#distributed-model-parallel-checkpoint)
+ [Ajuste de um modelo distribuído](#distributed-model-parallel-fine-tuning)
## Pontos de verificação de um modelo distribuído
Escolha um dos tópicos a seguir, dependendo da estrutura entre PyTorch e TensorFlow e da versão da biblioteca de paralelismo de SageMaker modelos que você usa.
**Topics**
+ [Apontando um PyTorch modelo distribuído (para a biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)](#model-parallel-extended-features-pytorch-checkpoint)
+ [Apontando um PyTorch modelo distribuído (para a biblioteca de paralelismo de SageMaker modelos entre v1.6.0 e v1.9.0)](#model-parallel-extended-features-pytorch-saving-loading-checkpoints)
+ [Verificando um modelo distribuído TensorFlow](#distributed-model-parallel-checkpoint-tensorflow)
### Apontando um PyTorch modelo distribuído (para a biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)
A biblioteca de paralelismo de SageMaker modelos fornece pontos de verificação APIs para salvar e carregar pontos de verificação completos ou parciais do estado do modelo distribuído e de seu estado otimizador.
**nota**
Esse método de ponto de verificação é recomendado se você usar PyTorch a biblioteca de paralelismo de SageMaker modelos v1.10.0 ou posterior.
**Pontos de verificação parciais**
Para salvar pontos de verificação de um treinamento de modelos com paralelismo de modelos, use a API [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save_checkpoint](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save_checkpoint) com a opção de ponto de verificação parcial definida como true (`partial=True`). Isto salva cada partição de modelos individualmente. Além do modelo e do estado do otimizador, você também pode salvar quaisquer dados personalizados adicionais por meio do argumento `user_content`. O modelo com ponto de verificação, o otimizador e o conteúdo do usuário são salvos como arquivos separados. A chamada de API `save_checkpoint` cria pastas de pontos de verificação na estrutura a seguir.
```
- path
- ${tag}_partial (folder for partial checkpoints)
- model_rankinfo.pt
- optimizer_rankinfo.pt
- fp16_states_rankinfo.pt
- user_content.pt
- $tag (checkpoint file for full checkpoints)
- user_content_$tag (user_content file for full checkpoints)
- newest (a file that indicates the newest checkpoint)
```
Para retomar o treinamento a partir de pontos de verificação parciais, use a API [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.resume_from_checkpoint](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.resume_from_checkpoint) com `partial=True` e especifique o diretório do ponto de verificação e a tag usada ao salvar os pontos de verificação parciais. Observe que o carregamento real dos pesos do modelo ocorre após o particionamento do modelo, durante a primeira execução da step function de treinamento decorada `smdistributed.modelparallel.torch.step`.
Ao salvar um ponto de verificação parcial, a biblioteca também salva a decisão da partição do modelo como arquivos com extensão de arquivo `.pt`. Por outro lado, ao retomar o ponto de verificação parcial, a biblioteca carrega os arquivos de decisão de partição juntos. Depois que a decisão de partição é carregada, não é possível alterar a partição.
O trecho de código a seguir mostra como definir o ponto de verificação APIs em um PyTorch script de treinamento.
```
import smdistributed.modelparallel.torch as smp
model = ...
model = smp.DistributedModel(model)
optimizer = ...
optimizer = smp.DistributedOptimizer(optimizer)
user_content = ... # additional custom data
checkpoint_path = "/opt/ml/checkpoint/model_parallel"
# Save a checkpoint.
smp.save_checkpoint(
path=checkpoint_path,
tag=f"total_steps{total_steps}",
partial=True,
model=model,
optimizer=optimizer,
user_content=user_content
num_kept_partial_checkpoints=5
)
# Load a checkpoint.
# This automatically loads the most recently saved checkpoint.
smp_checkpoint = smp.resume_from_checkpoint(
path=checkpoint_path,
partial=True
)
```
**Pontos de verificação totais**
Para salvar o artefato do modelo final para fins de inferência, use a API `smdistributed.modelparallel.torch.save_checkpoint` com `partial=False`, que combinam as partições do modelo para criar um único artefato do modelo. Observe que isso não combina os estados do otimizador.
Para inicializar o treinamento com pesos específicos, considerando um ponto de verificação completo do modelo, você pode usar a API `smdistributed.modelparallel.torch.resume_from_checkpoint` com `partial=False`. Observe que isso não combina os estados de carregamento do otimizador.
**nota**
Com o paralelismo do tensor, em geral, o `state_dict` deve ser traduzido entre a implantação do modelo original e a implantação `DistributedModel`. Opcionalmente, você pode fornecer a função de tradução `state_dict` como um argumento para o `smdistributed.modelparallel.torch.resume_from_checkpoint`. No entanto, para [Modelos compatíveis prontos para uso](model-parallel-extended-features-pytorch-hugging-face.md#model-parallel-extended-features-pytorch-hugging-face-out-of-the-box), a biblioteca cuida dessa tradução automaticamente.
O código a seguir mostra um exemplo de como usar o ponto de verificação APIs para verificar totalmente um PyTorch modelo treinado com paralelismo de modelos.
```
import smdistributed.modelparallel.torch as smp
model = ...
model = smp.DistributedModel(model)
optimizer = ...
optimizer = smp.DistributedOptimizer(optimizer)
user_content = ... # additional custom data
checkpoint_path = "/opt/ml/checkpoint/model_parallel"
# Save a checkpoint.
smp.save_checkpoint(
path=checkpoint_path,
tag=f"total_steps{total_steps}",
partial=False,
model=model,
optimizer=optimizer,
user_content=user_content
num_kept_partial_checkpoints=5
)
# Load a checkpoint.
# This automatically loads the most recently saved checkpoint.
smp_checkpoint = smp.resume_from_checkpoint(
path=checkpoint_path,
partial=False
)
```
### Apontando um PyTorch modelo distribuído (para a biblioteca de paralelismo de SageMaker modelos entre v1.6.0 e v1.9.0)
A biblioteca de paralelismo de SageMaker modelos fornece funções Python para salvar pontos de verificação parciais ou completos para treinar trabalhos com paralelismo de tensores. O procedimento a seguir mostra como usar o [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save) e [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load) para salvar e carregar um ponto de verificação ao usar o paralelismo de tensores.
**nota**
Esse método de ponto de verificação é recomendado se você usar PyTorch[Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md), e a biblioteca de paralelismo de SageMaker modelos entre v1.6.0 e v1.9.0.
1. Prepare um objeto de modelo e envolva-o com a função wrapper `smp.DistributedModel()` da biblioteca.
```
model = MyModel(...)
model = smp.DistributedModel(model)
```
1. Prepare um otimizador para o modelo. Um conjunto de parâmetros do modelo é um argumento iterável exigido pelas funções do otimizador. Para preparar um conjunto de parâmetros do modelo, você deve processar `model.parameters()` para atribuir parâmetros exclusivos IDs ao modelo individual.
Se houver parâmetros com duplicado IDs no parâmetro do modelo iterável, o carregamento do estado do otimizador com ponto de verificação falhará. Para criar um iterável de parâmetros de modelo exclusivos IDs para seu otimizador, veja o seguinte:
```
unique_params = []
unique_params_set = set()
for p in model.parameters():
if p not in unique_params_set:
unique_params.append(p)
unique_params_set.add(p)
del unique_params_set
optimizer = MyOpt(unique_params, ...)
```
1. Envolva o otimizador usando a função wrapper da biblioteca `smp.DistributedOptimizer()`.
```
optimizer = smp.DistributedOptimizer(optimizer)
```
1. Salve o modelo e o estado do otimizador usando [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.save). Dependendo de como deseja salvar os pontos de verificação, escolha uma das duas opções:
+ **Opção 1:** Salve um modelo parcial em cada `mp_rank` para um único `MP_GROUP`.
```
model_dict = model.local_state_dict() # save a partial model
opt_dict = optimizer.local_state_dict() # save a partial optimizer state
# Save the dictionaries at rdp_rank 0 as a checkpoint
if smp.rdp_rank() == 0:
smp.save(
{"model_state_dict": model_dict, "optimizer_state_dict": opt_dict},
f"/checkpoint.pt",
partial=True,
)
```
Com paralelismo de tensores, a biblioteca salva arquivos com pontos de verificação nomeados no seguinte formato: `checkpoint.pt_{pp_rank}_{tp_rank}`.
**nota**
Com o paralelismo de tensores, certifique-se de configurar a instrução ‘if’ como `if smp.rdp_rank() == 0` em vez de `if smp.dp_rank() == 0`. Quando o estado do otimizador é fragmentado com paralelismo de tensores, todas as classificações de paralelismo de dados reduzidos devem salvar suas próprias partições de estado do otimizador. Usar uma instrução *if* errada para os pontos de verificação pode resultar na paralisação do trabalho de treinamento. *Para obter mais informações sobre como usar `if smp.dp_rank() == 0` sem paralelismo de tensores, consulte [Instruções gerais para salvar e carregar na](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#general-instruction-for-saving-and-loading) documentação do SDK do PythonSageMaker .*
+ **Opção 2:** Salve o modelo completo.
```
if smp.rdp_rank() == 0:
model_dict = model.state_dict(gather_to_rank0=True) # save the full model
if smp.rank() == 0:
smp.save(
{"model_state_dict": model_dict},
"/checkpoint.pt",
partial=False,
)
```
**nota**
Considere o seguinte para um pontos de verificação completos:
Se você definir `gather_to_rank0=True`, todas as outras classificações, exceto `0`, retornarão dicionários vazios.
Para um ponto de verificação completo, você só pode verificar o modelo. Atualmente, não há suporte para pontos de verificação completos dos estados do otimizador.
O modelo completo só precisa ser salvo no `smp.rank() == 0`.
1. Carregue os pontos de verificação usando [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.load). Dependendo de como verificação os pontos na etapa anterior, escolha uma das duas opções a seguir:
+ **Opção 1:** Carregue os pontos de verificação parciais.
```
checkpoint = smp.load("/checkpoint.pt", partial=True)
model.load_state_dict(checkpoint["model_state_dict"], same_partition_load=False)
optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
```
Você pode configurar `same_partition_load=True` no `model.load_state_dict()` para um carregamento mais rápido se souber que a partição não será alterada.
+ **Opção 2:** Carregue os pontos de verificação completos.
```
if smp.rdp_rank() == 0:
checkpoint = smp.load("/checkpoint.pt", partial=False)
model.load_state_dict(checkpoint["model_state_dict"])
```
A condição `if smp.rdp_rank() == 0` não é obrigatória, mas pode ajudar a evitar o carregamento redundante entre diferentes `MP_GROUP`s. O estado completo do otimizador de ponto de verificação atualmente não é suportado pelo paralelismo de tensores.
### Verificando um modelo distribuído TensorFlow
Para salvar um TensorFlow modelo durante o treinamento com o paralelismo de modelos, use as seguintes funções fornecidas pela biblioteca de paralelismo de SageMaker modelos.
+ [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.DistributedModel.save_model](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.DistributedModel.save_model)
+ [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.CheckpointManager](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_tensorflow.html#smp.CheckpointManager)
## Ajuste de um modelo distribuído
O ajuste fino precisa ser configurado em seu script de treinamento. O trecho de código a seguir mostra um exemplo de estrutura de um script de treinamento usando a classe [AutoModelForCausalLM](https://huggingface.co/docs/transformers/main/en/model_doc/auto#transformers.AutoModelForCausalLM) de Hugging Face Transformers com modificações para registrar os módulos e as configurações para ajuste fino. `smdistributed.model.parallel.torch`
**nota**
O ajuste fino de um transformador distribuído (um modelo Transformer empacotado por`smp.DistributedModel()`) com a função [smp.delayed\$1param\$1initialization](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization) ativada requer que o trabalho de ajuste fino seja configurado com um sistema de arquivos for Lustre. FSx Nos casos em que você deseja ajustar um modelo em grande escala com a opção de inicialização retardada de parâmetros, você deve configurar um sistema de arquivos FSx para Lustre.
```
import argparse
from transformers import AutoModelForCausalLM
import smdistributed.modelparallel
import smdistributed.modelparallel.torch as smp
def parse_args():
parser = argparse.ArgumentParser()
# set an arg group for model
model_grp = parser.add_argument_group(
title="model", description="arguments to describe model configuration"
)
... # set up numerous args to parse from the configuration dictionary to the script for training
# add arg for activating fine-tuning
model_grp.add_argument(
"--fine_tune",
type=int,
default=0,
help="Fine-tune model from checkpoint or pretrained model",
)
def main():
"""Main function to train GPT."""
args = parse_args()
... # parse numerous args
if args.fine_tune > 0 and args.delayed_param > 0 and smp.rank() == 0:
pretrained_model = AutoModelForCausalLM.from_pretrained(
args.model_name or args.model_dir
)
model_state_dict = pretrained_model.state_dict()
path = os.path.join(args.model_dir, "fullmodel.pt")
torch.save(model_state_dict, path)
# create a Transformer model and wrap by smp.model_creation()
# with options to configure model parallelism parameters offered by SageMaker AI
with smp.model_creation(
tensor_parallelism=smp.tp_size() > 1 or args.use_distributed_transformer > 0,
zero_init=args.use_distributed_transformer == 0,
dtype=dtype,
distribute_embedding=args.sharded_data_parallel_degree > 1 and smp.tp_size() > 1,
use_alibi=args.alibi > 0,
attention_in_fp32=args.attention_in_fp32 > 0,
fp32_residual_addition=args.residual_addition_in_fp32 > 0,
query_key_layer_scaling=args.query_key_layer_scaling > 0 and args.bf16 < 1,
fused_softmax=args.fused_softmax > 0,
fused_dropout=args.fused_dropout > 0,
fused_bias_gelu=args.fused_bias_gelu > 0,
flash_attention=args.flash_attention > 0,
):
if args.fine_tune > 0 and args.delayed_param == 0:
model = AutoModelForCausalLM.from_pretrained(
args.model_name or args.model_dir
)
else:
model = AutoModelForCausalLM.from_config(model_config)
# wrap the model by smp.DistributedModel() to apply SageMaker model parallelism
model = smp.DistributedModel(
model, trace_device="gpu", backward_passes_per_step=args.gradient_accumulation
)
# wrap the optimizer by smp.DistributedOptimizer() to apply SageMaker model parallelism
optimizer= ... # define an optimizer
optimizer = smp.DistributedOptimizer(
optimizer,
static_loss_scale=None,
dynamic_loss_scale=True,
dynamic_loss_args={"scale_window": 1000, "min_scale": 1, "delayed_shift": 2},
)
# for fine-tuning, use smp.resume_from_checkpoint() to load a pre-trained model
if args.fine_tune > 0 and args.delayed_param > 0:
smp.resume_from_checkpoint(args.model_dir, tag="fullmodel.pt", partial=False)
```
*Para ver um exemplo completo de scripts de treinamento e notebooks Jupyter, consulte os exemplos do [GPT-2 no repositório AI Examples](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel/gpt2). PyTorch SageMaker GitHub*
# Exemplos da biblioteca de paralelismo de modelos Amazon SageMaker AI v1
Esta página fornece uma lista de blogs e notebooks Jupyter que apresentam exemplos práticos da implementação da biblioteca de paralelismo de SageMaker modelos (SMP) v1 para executar trabalhos de treinamento distribuídos em IA. SageMaker
## Blogs e estudos de caso
Os blogs a seguir debatem estudos de caso sobre o uso do SMP v1.
+ [Novas melhorias de desempenho na biblioteca de paralelismo de modelos de SageMaker IA da Amazon](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/), *AWS Machine Learning Blog* (16 de dezembro de 2022)
+ [Treine modelos gigantescos com escalabilidade quase linear usando paralelismo de dados fragmentados no Amazon AI, SageMaker Machine](https://aws.amazon.com/blogs/machine-learning/train-gigantic-models-with-near-linear-scaling-using-sharded-data-parallelism-on-amazon-sagemaker/) *Learning AWS Blog (31 de outubro de 2022)*
## Cadernos de exemplo
Os notebooks de exemplo são fornecidos no [ GitHub repositório de exemplos de SageMaker IA](https://github.com/aws/amazon-sagemaker-examples/tree/master/training/distributed_training/). Para baixar os exemplos, execute o seguinte comando para clonar o repositório e acesse `training/distributed_training/pytorch/model_parallel`:
**nota**
Clone e execute os notebooks de exemplo no SageMaker AI ML a seguir. IDEs
[SageMaker JupyterLab](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-jl.html)(disponível no [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) criado após dezembro de 2023)
[SageMaker Editor de código](https://docs.aws.amazon.com/sagemaker/latest/dg/code-editor.html) (disponível no [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) criado após dezembro de 2023)
[Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) (disponível como uma aplicação no [Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated.html) e criado após dezembro de 2023)
[SageMaker Instâncias de notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nbi.html)
```
git clone https://github.com/aws/amazon-sagemaker-examples.git
cd amazon-sagemaker-examples/training/distributed_training/pytorch/model_parallel
```
**Exemplos de notebooks SMP v1 para PyTorch**
+ [Treine o GPT-2 com escala quase linear usando a técnica de paralelismo de dados fragmentados na biblioteca de paralelismo de modelos SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/smp-train-gpt-sharded-data-parallel.ipynb)
+ [Ajuste o GPT-2 com escala quase linear usando a técnica de paralelismo de dados fragmentados na biblioteca de paralelismo de modelos SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/smp-fine-tune-gpt-sharded-data-parallel.ipynb)
+ [Treine o GPT-Neox-20b com escala quase linear usando a técnica de paralelismo de dados fragmentados na biblioteca de paralelismo de modelos SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt-neox/smp-train-gpt-neox-sharded-data-parallel.ipynb)
+ [Treine o GPT-J 6B usando as técnicas de paralelismo de dados fragmentados e paralelismo de tensores na biblioteca de paralelismo de modelos SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt-j/smp-train-gptj-sharded-data-parallel-tp.ipynb)
+ [Treine o FLAN-T5 com escala quase linear usando a técnica de paralelismo de dados fragmentados na biblioteca de paralelismo de modelos SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/flan-t5/smp-train-t5-sharded-data-parallel.ipynb)
+ [Treine o Falcon com escala quase linear usando a técnica de paralelismo de dados fragmentados na biblioteca de paralelismo de modelos SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/falcon/smp-train-falcon-sharded-data-parallel.ipynb)
**Exemplos de notebooks SMP v1 para TensorFlow**
+ [CNN com TensorFlow 2.3.1 e a biblioteca de paralelismo de SageMaker modelos](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/tensorflow/model_parallel/mnist/tensorflow_smmodelparallel_mnist.html)
+ [HuggingFace com a biblioteca de paralelismo de modelos TensorFlow distribuídos Treinamento em IA SageMaker ](https://github.com/huggingface/notebooks/blob/master/sagemaker/04_distributed_training_model_parallelism/sagemaker-notebook.ipynb)
# SageMaker Melhores práticas de paralelismo de modelos distribuídos
Use as diretrizes a seguir ao executar um trabalho de treinamento distribuído com a biblioteca paralela de SageMaker modelos.
## Configuração correta para um determinado modelo
Ao aumentar a escala verticalmente de um modelo, recomendamos que você consulte a lista a seguir em ordem. Cada item da lista debate a vantagem de usar as técnicas da biblioteca junto com as concessões que podem surgir.
**dica**
Se um modelo pode se encaixar bem usando um subconjunto dos atributos da biblioteca, adicionar mais atributos de paralelismo ao modelo ou de economia de memória geralmente não melhora o desempenho.
**Usando tipos de instância grandes de GPU**
+ No campo do paralelismo de modelos, é melhor usar instâncias poderosas com grandes memórias de GPU para lidar com a sobrecarga das operações de paralelismo de modelos, como particionamento de modelos em vários. GPUs Recomendamos usar as instâncias de `ml.p4d` ou `ml.p3dn` para treinar modelos grandes de DL. Essas instâncias também são equipadas com o Elastic Fabric Adapter (EFA), que fornece maior largura de banda de rede e habilita treinamento em grande escala com paralelismo de modelos.
**Estado do otimizador de fragmentação**
+ O impacto do estado do otimizador de fragmentação depende do número de classificações em paralelo dos dados. Normalmente, um maior grau de paralelismo de dados (proporcional ao tamanho do nó de computação) pode melhorar a eficiência do uso de memória.
Quando você quiser reduzir o tamanho de um cluster, verifique a configuração de fragmentação de estado do otimizador. Por exemplo, um modelo de DL grande com fragmentação de estado do otimizador que cabe em um cluster de computação com 16 GPUs (por exemplo, duas instâncias P4d ou P4de) pode nem sempre caber em um nó com 8 GPUs (por exemplo, uma única instância P4d ou P4de). Isso ocorre porque a memória combinada de 8 GPUs é menor do que a memória combinada de 16 GPUs, e a memória necessária por GPU para fragmentar mais de 8 também GPUs é maior do que a memória por GPU para fragmentar no cenário de 16 GPUs. Como resultado, o aumento no requisito de memória pode não se ajustar no cluster menor.
Para obter mais informações, consulte [Fragmentação de estado do otimizador](model-parallel-extended-features-pytorch-optimizer-state-sharding.md).
**Ponto de verificação de ativação**
+ A eficiência da memória pode ser melhorada usando o ponto de verificação de ativação para um grupo de módulos. Quanto mais você agrupar os módulos, mais eficiente será o uso de memória. Ao realizar ponto de verificação de módulos sequenciais para camadas, o argumento `strategy` da função `smp.set_activation_checkpointing` agrupa as camadas para o ponto de verificação. Por exemplo, o agrupamento de duas ou mais camadas para pontos de verificação é mais eficiente em termos de memória do que o ponto de verificação de uma camada por vez, e isso troca o tempo de computação extra pela redução do uso de memória.
Para obter mais informações, consulte [Ponto de verificação de ativação](model-parallel-extended-features-pytorch-activation-checkpointing.md).
**Paralelismo de tensores**
+ O grau de paralelismo do tensor deve ser uma potência de dois (2, 4, 8,..., 2 n), onde o grau máximo deve ser igual ao número de por nó. GPUs Por exemplo, se você usar um nó com 8 GPUs, os números possíveis para o grau de paralelismo do tensor são 2, 4 e 8. Não recomendamos números arbitrários (como 3, 5, 6 e 7) para o grau de paralelismo de tensores. Quando você usa vários nós, a configuração incorreta do grau de paralelismo de tensores pode resultar na execução do paralelismo de tensores nos nós; isso adiciona uma sobrecarga significativa na comunicação das ativações entre os nós e pode se tornar computacionalmente caro.
Para obter mais informações, consulte [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md).
**Paralelismo de pipeline entre os nós**
+ Você pode executar o paralelismo de pipeline em um nó único e em vários nós. Ao usar o paralelismo do pipeline em combinação com o paralelismo de tensores, recomendamos executar o paralelismo de pipeline em vários nós e manter o paralelismo de tensores em nós individuais.
+ O paralelismo de pipeline vem com os seguintes três botões: `microbatches`, `active_microbatches` e `prescaled_batch`.
+ Quando você usa paralelismo de tensores com paralelismo de pipeline, recomendamos ativar o `prescaled_batch` para que o tamanho do lote por grupo em paralelo do modelo possa ser aumentado para um pipeline eficiente. Quando `prescaled_batch` é ativado, o tamanho do lote definido no script de treinamento se torna `tp_size` vezes o tamanho do lote definido para cada classificação sem `prescaled_batch`.
+ Aumentar o número de `microbatches` ajuda a obter um pipeline eficiente e uma melhor performance. Observe que o tamanho efetivo do microlote é o tamanho do lote dividido pelo número de microlotes. Se você aumentar o número de microlotes enquanto mantém o tamanho do lote constante, cada microlote processa um número menor de amostras.
+ O número de `active_microbatches` é o número máximo de microlotes que estão sendo processados simultaneamente durante o pipeline. Para cada microlote ativo no processo, suas ativações e gradientes ocupam a memória da GPU. Portanto, aumentar o `active_microbatches` consome mais memória da GPU.
+ Se a memória da GPU e da GPU estiverem subutilizadas, aumente o `active_microbatches` para um melhor paralelismo durante o pipeline.
+ Para obter mais informações sobre como usar o paralelismo de tensores com o paralelismo de pipeline, consulte [Paralelismo de tensores combinado com paralelismo de pipeline](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism).
+ Para encontrar descrições dos parâmetros mencionados acima, consulte Parâmetros `smdistributed` na documentação do [SDK](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#parameters-for-smdistributed) do *SageMaker Python*.
**Descarregar ativações para a CPU**
+ Certifique-se de que isso seja usado em combinação com o ponto de verificação de ativação e o paralelismo de pipeline. Para garantir que o descarregamento e o pré-carregamento ocorram no plano de fundo, especifique um valor maior que 1 para o parâmetro de microlotes.
+ Ao descarregar as ativações, talvez você consiga aumentar o `active_microbatches` e, às vezes, igualar o número total de microlotes. Isso depende de quais módulos são determinados como pontos de verificação e como o modelo é particionado.
Para obter mais informações, consulte [Ativação e descarregamento](model-parallel-extended-features-pytorch-activation-offloading.md).
### Configurações de referência
A equipe de treinamento de paralelismo de SageMaker modelos fornece os seguintes pontos de referência com base em experimentos com o modelo GPT-2, o comprimento da sequência de 512 e o tamanho do vocabulário de 50.000.
| O número de parâmetros de modelo | Tipo de instância | Paralelismo de pipeline | Paralelismo de tensores | Fragmentação de estado do otimizador | Ponto de verificação de ativação | Lote pré-escalado | Tamanho do lote |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 10 bilhões | 16 ml.p4d.24xlarge | 1 | 4 | Verdadeiro | Cada camada do transformador | Verdadeiro | batch\$1size=40 |
| 30 bilhões | 16 ml.p4d.24xlarge | 1 | 8 | Verdadeiro | Cada camada do transformador | Verdadeiro | batch\$1size=32 |
| 60 bilhões | 32 ml.p4d.24xlarge | 2 | 8 | Verdadeiro | Cada camada do transformador | Verdadeiro | batch\$1size=56, microbatches=4, active\$1microbatches=2 |
Você pode extrapolar a partir das configurações anteriores para estimar o uso de memória da GPU para a configuração do modelo. Por exemplo, se você aumentar o comprimento da sequência de um modelo com parâmetro de 10 bilhões ou aumentar o tamanho do modelo para 20 bilhões, talvez você queira reduzir o tamanho do lote primeiro. Se o modelo ainda não couber, tente aumentar o grau de paralelismo de tensores.
## Modificar o script de treinamento
+ Antes de usar os recursos da biblioteca SageMaker model parallel em seu script de treinamento, revise[Dicas e armadilhas de configuração da SageMaker Distributed Model Parallelism Library](model-parallel-customize-tips-pitfalls.md).
+ Para iniciar um trabalho de treinamento mais rápido, use o [modo local de SageMaker IA](https://sagemaker.readthedocs.io/en/v2.199.0/overview.html?highlight=local%20mode#local-mode). Isso ajuda você a executar rapidamente um trabalho de treinamento localmente em uma instância de SageMaker notebook. Dependendo da escala da instância de ML na qual a instância do SageMaker notebook está sendo executada, talvez seja necessário ajustar o tamanho do modelo alterando as configurações do modelo, como a largura oculta, o número de camadas do transformador e as cabeças de atenção. Valide se o modelo reduzido funciona bem na instância do caderno antes de usar um cluster grande para treinar o modelo completo.
## Monitorando e registrando um Training Job usando o SageMaker AI Console e a Amazon CloudWatch
[Para monitorar métricas em nível de sistema, como utilização da memória da CPU, utilização da memória da GPU e utilização da GPU, use a visualização fornecida pelo console de IA. SageMaker ](https://console.aws.amazon.com/sagemaker/)
1. No painel de navegação à esquerda, selecione **Treinamento**.
1. Escolha **Trabalhos de treinamento**.
1. No painel principal, escolha o nome da tarefa de treinamento do qual você deseja ver mais detalhes.
1. Procure no painel principal e encontre a seção **Monitoramento** para ver a visualização automatizada.
1. Para ver os logs de tarefa de treinamento, escolha **Visualizar logs** na seção **Monitoramento**. Você pode acessar os registros distribuídos do trabalho de treinamento em CloudWatch. Se você executou o treinamento distribuído de vários nós, você poderá ver vários fluxo de logs com tags no formato **algo-n-1234567890.** O fluxo de logs **algo-1** rastreia os logs de treinamento do nó principal (0º).
Para obter mais informações, consulte [CloudWatch Métricas da Amazon para monitorar e analisar trabalhos de treinamento](training-metrics.md).
## Permissões
Para executar um trabalho de SageMaker treinamento com o paralelismo de modelos ou os [cadernos de exemplo de treinamento SageMaker distribuídos](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/index.html), verifique se você tem as permissões corretas em sua função do IAM, como as seguintes:
+ Para usar [FSx para Lustre](https://aws.amazon.com/fsx/), adicione [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonFSxFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonFSxFullAccess).
+ Para usar o Amazon S3 como um canal de dados, adicione [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonS3FullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonS3FullAccess).
+ Para usar o Docker, crie seu próprio contêiner e envie-o para o Amazon ECR, adicione [https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonEC2ContainerRegistryFullAccess).
+ Para ter acesso total ao uso de todo o conjunto de recursos de SageMaker IA, adicione [https://console.aws.amazon.com/iam/home#/policies/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#/policies/iam/home#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonSageMakerFullAccess).
# Dicas e armadilhas de configuração da SageMaker Distributed Model Parallelism Library
Analise as dicas e armadilhas a seguir antes de usar a biblioteca de SageMaker paralelismo de modelos da Amazon AI. Essa lista inclui dicas que são aplicáveis em todos os frameworks. Para obter TensorFlow dicas PyTorch específicas, consulte [Modificar um script TensorFlow de treinamento](model-parallel-customize-training-script-tf.md) e[Modificar um script PyTorch de treinamento](model-parallel-customize-training-script-pt.md), respectivamente.
## Tamanho do lote e número de microlotes
+ A biblioteca é mais eficiente quando o tamanho do lote é aumentado. Para casos de uso em que o modelo cabe em um dispositivo único, mas pode ser treinado apenas com um tamanho de lote pequeno, o tamanho do lote pode e deve ser aumentado após a integração da biblioteca. O paralelismo de modelos economiza memória para modelos grandes, habilitando o treinamento usando tamanhos do lote que antes não cabiam na memória.
+ Escolher um número de microlotes muito pequenos ou muito grandes pode reduzir a performance. A biblioteca executa cada microlote sequencialmente em cada dispositivo, portanto, o tamanho do microlote (tamanho do lote dividido pelo número de microlotes) deve ser grande o suficiente para utilizar totalmente cada GPU. Ao mesmo tempo, a eficiência do pipeline aumenta com o número de microlotes, portanto, é importante encontrar o equilíbrio certo. Normalmente, um bom ponto de partida é experimentar 2 ou 4 microlotes, aumentando o tamanho do lote até o limite de memória e, em seguida, experimentar tamanhos do lote e números de microlotes maiores. À medida que o número de microlotes aumenta, tamanhos do lote maiores podem se tornar viáveis se um pipeline intercalado for usado.
+ O tamanho do lote deve ser sempre divisível pelo número de microlotes. Observe que, dependendo do tamanho do conjunto de dados, às vezes, o último lote de cada epoch pode ser menor que o resto e esse lote menor também precisa ser divisível pelo número de microlotes. Se não estiver, você pode definir `drop_remainder=True` a `tf.Dataset.batch()` chamada (in TensorFlow) ou definir `drop_last=True` in `DataLoader` (in PyTorch), para que esse último lote pequeno não seja usado. Se você estiver usando uma API diferente para o pipeline de dados, talvez seja necessário ignorar manualmente o último lote sempre que ele não for divisível pelo número de microlotes.
## Particionamento manual
+ Se você usa o particionamento manual, esteja atento aos parâmetros que são consumidos por várias operações e módulos em seu modelo, como a tabela de incorporação nas arquiteturas do transformador. Módulos que compartilham o mesmo parâmetro devem ser colocados no mesmo dispositivo para que estejam corretos. Quando o particionamento automático é usado, a biblioteca aplica automaticamente essa restrição.
## Preparação de dados
+ Se o modelo usar várias entradas, certifique-se de semear as operações aleatórias em seu data pipeline (por exemplo, embaralhar) com `smp.dp_rank()`. Se o conjunto de dados estiver sendo fragmentado de forma determinística em dispositivos em paralelo de dados, certifique-se de que o fragmento seja indexado por `smp.dp_rank()`. Isso irá garantir que a ordem dos dados vistos em todas as classificações que formam uma partição de modelo seja consistente.
## Retornar tensores de `smp.DistributedModel`
+ Qualquer tensor retornado da função `smp.DistributedModel.call` (for TensorFlow) ou `smp.DistributedModel.forward` (for) é transmitido para PyTorch todas as outras classificações, a partir da classificação que calculou esse tensor específico. Como resultado, qualquer tensor que não é necessário fora dos métodos de chamada e encaminhamento (ativações intermediárias, por exemplo) não deve ser retornado, pois isso causa comunicação desnecessária e sobrecarga da memória e prejudica a performance.
## O Decorator do `@smp.step`
+ Se uma função decorada por `smp.step` tiver um argumento de tensor que não tenha uma dimensão de lote, o nome do argumento deverá ser fornecido na lista `non_split_inputs` durante a chamada de `smp.step`. Isso evita que a biblioteca tente dividir o tensor em microlotes. Para obter mais informações, consulte [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html) na documentação de API.
## Atrasar a inicialização do parâmetro
Para modelos muito grandes com mais de 100 bilhões de parâmetros, a inicialização do peso por meio da memória da CPU pode resultar em um out-of-memory erro. Para contornar isso, a biblioteca oferece um gerenciador de contexto `smp.delay_param_initialization`. Isso atrasa a alocação física dos parâmetros até que eles sejam movidos para a GPU durante a primeira execução de uma função decorada por `smp.step`. Isso evita o uso desnecessário de memória da CPU durante a inicialização do treinamento. Use o gerenciador de contexto ao criar um objeto de modelo, conforme exibido no código a seguir.
```
with smp.delay_param_initialization(enabled=True):
model = MyModel()
```
## Paralelismo de tensores para PyTorch
+ Se você estiver usando uma semente para resultados determinísticos, defina a semente baseada em `smp.dp_rank()` (por exemplo, `torch.manual_seed(42 + smp.dp_rank())`). Se você não fizer isso, partições diferentes de um `nn.Parameter` serão inicializadas da mesma forma, afetando a convergência.
+ SageMakerA biblioteca de paralelismo de modelos usa NCCL para implementar os coletivos necessários para a distribuição dos módulos. Especialmente para modelos menores, se muitas chamadas de NCCL forem programadas na GPU ao mesmo tempo, o uso de memória poderá aumentar devido ao espaço adicional usado pela NCCL. Para neutralizar isso, `smp` controla as chamadas de NCCL para que, a qualquer momento, o número de operações contínuas de NCCL seja menor ou igual a um determinado limite. O limite padrão é 8, mas isso pode ser ajustado usando a variável de ambiente `SMP_NCCL_THROTTLE_LIMIT`. Se você observar o uso de memória maior do que o esperado ao usar o paralelismo de tensores, tente reduzir esse limite. No entanto, escolher um limite muito pequeno pode causar perda de taxa de transferência. Para desativar completamente o controle de utilização, você pode definir `SMP_NCCL_THROTTLE_LIMIT=-1`.
+ A seguinte identidade, que é válida quando o grau de paralelismo de tensores é 1, não é válida quando o grau de paralelismo de tensores é maior que 1: `smp.mp_size() * smp.dp_size() == smp.size()`. Isso ocorre porque o grupo em paralelo de tensores faz parte do grupo de paralelismo do modelo e do grupo de paralelismo de dados. Se seu código tiver referências existentes a `mp_rank`, `mp_size`, `MP_GROUP` e assim por diante, e se você quiser trabalhar apenas com o grupo em paralelo do pipeline, talvez seja necessário substituir as referências por `smp.pp_size()`. As seguintes identidades são sempre verdadeiras:
+ `smp.mp_size() * smp.rdp_size() == smp.size()`
+ `smp.pp_size() * smp.dp_size() == smp.size()`
+ `smp.pp_size() * smp.tp_size() * smp.rdp_size() == smp.size()`
+ Uma vez que o wrapper do `smp.DistributedModel` modifica os parâmetros do modelo quando o paralelismo de tensores está ativado, o otimizador deve ser criado após a chamada de `smp.DistributedModel`, com os parâmetros distribuídos. Por exemplo, o seguinte não funciona:
```
## WRONG
model = MyModel()
optimizer = SomeOptimizer(model.parameters())
model = smp.DistributedModel(model) # optimizer now has outdated parameters!
```
Em vez disso, o otimizador deve ser criado com os seguintes parâmetros de `smp.DistributedModel`:
```
## CORRECT
model = smp.DistributedModel(MyModel())
optimizer = SomeOptimizer(model.optimizers())
```
+ Quando um módulo é substituído por sua contraparte distribuída por meio de paralelismo de tensores, o módulo distribuído não herda seus pesos do módulo original e inicializa novos pesos. Isso significa que, por exemplo, se os pesos precisarem ser inicializados em uma chamada específica (por exemplo, por meio de uma chamada de `load_state_dict`), isso precisará acontecer após a chamada de `smp.DistributedModel`, quando a distribuição do módulo ocorrer.
+ Ao acessar diretamente os parâmetros dos módulos distribuídos, observe que o peso não tem o mesmo formato do módulo original. Por exemplo:
```
with smp.tensor_parallelism():
linear = nn.Linear(60, 60)
# will pass
assert tuple(linear.weight.shape) == (60, 60)
distributed_linear = smp.DistributedModel(linear)
# will fail. the number of input channels will have been divided by smp.tp_size()
assert tuple(distributed_linear.module.weight.shape) == (60, 60)
```
+ O uso de `torch.utils.data.distributed.DistributedSampler` é altamente recomendado para paralelismo de tensores. Isso garante que cada classificação em paralelo de dados receba o mesmo número de amostras de dados, o que evita interrupções que possam resultar de diferentes `dp_rank`s realizando um número de etapas diferentes.
+ Se você usar a `join` API da `DistributedDataParallel` classe PyTorch's para lidar com casos em que diferentes classificações paralelas de dados têm números diferentes de lotes, você ainda precisa garantir que as classificações que estão na mesma `TP_GROUP` tenham o mesmo número de lotes; caso contrário, os coletivos de comunicação usados na execução distribuída de módulos podem travar. Classificações que estão em diferentes `TP_GROUP`s podem ter diferentes números de lotes, desde que a API do `join` seja usada.
+ Se você quiser que seu modelo tenha um ponto de verificação e usar o paralelismo de tensores, considere o seguinte:
+ Para evitar paradas e condições de corrida ao salvar e carregar modelos ao usar o paralelismo de tensores, certifique-se de chamar as funções apropriadas dos seguintes estados do modelo e do otimizador dentro de uma classificação de paralelismo de dados reduzidos.
+ Se você estiver fazendo a transição de um script em paralelo do pipeline existente e habilitando o tensor em paralelo para o script, certifique-se de modificar qualquer bloco de `if smp.dp_rank() == 0` usado para salvar e carregar os blocos de `if smp.rdp_rank() == 0`. Caso contrário, isso pode fazer com que a tarefa de treinamento pare.
Para obter mais informações sobre o ponto de verificação de um modelo com paralelismo de tensores, consulte [Pontos de verificação de um modelo distribuído](distributed-model-parallel-checkpointing-and-finetuning.md#distributed-model-parallel-checkpoint).
# Solução de problemas de paralelismo do modelo
Se você encontrar um erro, você pode usar a listagem a seguir para tentar solucionar o problema do seu trabalho de treinamento. Se o problema persistir, entre em contato com o [suporte da AWS](https://aws.amazon.com/premiumsupport).
**Topics**
+ [Considerações sobre o uso do SageMaker Debugger com a Model Parallelism Library SageMaker](#distributed-ts-model-parallel-debugger)
+ [Salvando pontos de verificação](#distributed-ts-model-parallel-checkpoints)
+ [Convergência usando modelos paralelos e TensorFlow](#distributed-ts-model-parallel-tf-convergence)
+ [Trabalhos de treinamento distribuídos parados ou com falhas](#distributed-ts-model-parallel-training-issues)
+ [Recebendo erro NCCL para um PyTorch Training Job](#distributed-ts-model-parallel-nccl-error)
+ [Recebendo `RecursionError` para um PyTorch Training Job](#distributed-ts-model-parallel-super-forward-not-supported)
## Considerações sobre o uso do SageMaker Debugger com a Model Parallelism Library SageMaker
SageMaker O depurador não está disponível para a biblioteca de paralelismo de SageMaker modelos. O depurador está habilitado por padrão para todos os trabalhos SageMaker TensorFlow e trabalhos de PyTorch treinamento, e você pode ver um erro parecido com o seguinte:
```
FileNotFoundError: [Errno 2] No such file or directory: '/opt/ml/checkpoints/metadata.json.sagemaker-uploading
```
Para corrigir esse problema, desabilite o Depurador passando o `debugger_hook_config=False` ao criar um framework `estimator`, conforme mostrado no exemplo a seguir.
```
bucket=sagemaker.Session().default_bucket()
base_job_name="sagemaker-checkpoint-test"
checkpoint_in_bucket="checkpoints"
# The S3 URI to store the checkpoints
checkpoint_s3_bucket="s3://{}/{}/{}".format(bucket, base_job_name, checkpoint_in_bucket)
estimator = TensorFlow(
...
distribution={"smdistributed": {"modelparallel": { "enabled": True }}},
checkpoint_s3_uri=checkpoint_s3_bucket,
checkpoint_local_path="/opt/ml/checkpoints",
debugger_hook_config=False
)
```
## Salvando pontos de verificação
Você pode se deparar com o seguinte erro ao salvar pontos de verificação de um modelo grande na SageMaker IA:
```
InternalServerError: We encountered an internal error. Please try again
```
Isso pode ser causado por uma limitação de SageMaker IA ao fazer o upload do ponto de verificação local para o Amazon S3 durante o treinamento. Para desativar o ponto de verificação na SageMaker IA, use o exemplo a seguir para fazer o upload explícito dos pontos de verificação.
Se você se deparar com o erro anterior, não use `checkpoint_s3_uri` com a SageMaker `estimator` chamada. Ao salvar pontos de verificação para modelos maiores, recomendamos salvar os pontos de verificação em um diretório personalizado e passá-los para a função auxiliar (como um argumento `local_path`).
```
import os
def aws_s3_sync(source, destination):
"""aws s3 sync in quiet mode and time profile"""
import time, subprocess
cmd = ["aws", "s3", "sync", "--quiet", source, destination]
print(f"Syncing files from {source} to {destination}")
start_time = time.time()
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p.wait()
end_time = time.time()
print("Time Taken to Sync: ", (end_time-start_time))
return
def sync_local_checkpoints_to_s3(local_path="/opt/ml/checkpoints", s3_uri=os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))+'/checkpoints'):
""" sample function to sync checkpoints from local path to s3 """
import boto3
#check if local path exists
if not os.path.exists(local_path):
raise RuntimeError("Provided local path {local_path} does not exist. Please check")
#check if s3 bucket exists
s3 = boto3.resource('s3')
if not s3_uri.startswith("s3://"):
raise ValueError(f"Provided s3 uri {s3_uri} is not valid.")
s3_bucket = s3_uri.replace('s3://','').split('/')[0]
print(f"S3 Bucket: {s3_bucket}")
try:
s3.meta.client.head_bucket(Bucket=s3_bucket)
except Exception as e:
raise e
aws_s3_sync(local_path, s3_uri)
return
def sync_s3_checkpoints_to_local(local_path="/opt/ml/checkpoints", s3_uri=os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))+'/checkpoints'):
""" sample function to sync checkpoints from s3 to local path """
import boto3
#try to create local path if it does not exist
if not os.path.exists(local_path):
print(f"Provided local path {local_path} does not exist. Creating...")
try:
os.makedirs(local_path)
except Exception as e:
raise RuntimeError(f"Failed to create {local_path}")
#check if s3 bucket exists
s3 = boto3.resource('s3')
if not s3_uri.startswith("s3://"):
raise ValueError(f"Provided s3 uri {s3_uri} is not valid.")
s3_bucket = s3_uri.replace('s3://','').split('/')[0]
print(f"S3 Bucket: {s3_bucket}")
try:
s3.meta.client.head_bucket(Bucket=s3_bucket)
except Exception as e:
raise e
aws_s3_sync(s3_uri, local_path)
return
```
Uso de funções auxiliares:
```
#base_s3_uri - user input s3 uri or save to model directory (default)
#curr_host - to save checkpoints of current host
#iteration - current step/epoch during which checkpoint is saved
# save checkpoints on every node using local_rank
if smp.local_rank() == 0:
base_s3_uri = os.path.dirname(os.path.dirname(os.getenv('SM_MODULE_DIR', '')))
curr_host = os.environ['SM_CURRENT_HOST']
full_s3_uri = f'{base_s3_uri}/checkpoints/{curr_host}/{iteration}'
sync_local_checkpoints_to_s3(local_path=checkpoint_dir, s3_uri=full_s3_uri)
```
## Convergência usando modelos paralelos e TensorFlow
Quando você usa o treinamento de SageMaker IA em vários nós TensorFlow e a biblioteca de paralelismo de modelos, a perda pode não convergir conforme o esperado, pois a ordem dos arquivos de entrada de treinamento pode ser diferente em cada nó. Isso pode fazer com que diferentes classificações no mesmo grupo de paralelismo do modelo funcionem em arquivos de entrada diferentes, causando inconsistências. Para evitar isso, certifique-se de que os arquivos de entrada sejam ordenados da mesma forma em todas as classificações antes de serem convertidos em TensorFlow conjuntos de dados. Uma maneira de fazer isso é classificar os nomes dos arquivos de entrada no script de treinamento.
## Trabalhos de treinamento distribuídos parados ou com falhas
Se seu trabalho de treinamento apresentar problemas de parada, falhas ou problemas de resposta, leia os itens de solução de problemas a seguir para identificar a causa do problema. Se precisar de mais suporte, entre em contato com a equipe de treinamento SageMaker distribuída por meio do [AWS Support](https://aws.amazon.com/premiumsupport).
+ Se você observar **a paralisação de um trabalho de treinamento distribuído na etapa de inicialização da NCCL**, considere o seguinte:
+ Se você estiver usando uma das instâncias habilitadas para EFA (instâncias `ml.p4d` ou `ml.p3dn`) com uma VPC personalizada e sua sub-rede, certifique-se de que o grupo de segurança usado tenha conexões de entrada e saída para todas as portas de e para o mesmo SG. Geralmente, você também precisa de conexões de saída para qualquer IP como uma regra separada (para acesso à Internet). Para ver instruções sobre como adicionar regras de entrada e saída para comunicação EFA, consulte [SageMaker Parada do trabalho de treinamento distribuído por IA durante a inicialização](distributed-troubleshooting-data-parallel.md#distributed-ts-data-parallel-efa-sg).
+ Se você observar a **paralisação de um trabalho de treinamento distribuído ao verificar pontos de verificação** no modelo completo, isso pode ocorrer porque a chamada `state_dict()` no modelo ou no otimizador não foi feita em todas as classificações com `rdp_rank()==0` (ao usar o paralelismo de tensor) ou `dp_rank()==0` (ao usar apenas o paralelismo de pipeline). Essas classificações precisam se comunicar para construir o ponto de verificação a ser salvo. Problemas de paralisação semelhantes também podem ocorrer quando o otimizador parcial de ponto de verificação `shard_optimizer_state` está ativado.
Para obter mais informações sobre como definir pontos de verificação do paralelismo de um modelo, consulte [Instruções gerais para salvar e carregar](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#general-instruction-for-saving-and-loading) e [Apontando um PyTorch modelo distribuído (para a biblioteca de paralelismo de SageMaker modelos entre v1.6.0 e v1.9.0)](distributed-model-parallel-checkpointing-and-finetuning.md#model-parallel-extended-features-pytorch-saving-loading-checkpoints).
+ Se o trabalho de treinamento falhar com um **erro de memória CUDA**, isso significa que a configuração de treinamento distribuída precisa ser ajustada para se adequar ao modelo no cluster da GPU. Para obter mais informações e práticas recomendadas, consulte [Configuração correta para um determinado modelo](model-parallel-best-practices.md#model-parallel-best-practices-configuration).
+ Se o trabalho de treinamento falhar com um **[erro ECC](https://docs.nvidia.com/deploy/a100-gpu-mem-error-mgmt/index.html) incorrigível**, isso significa que um dos do GPUs cluster está com defeito. Se precisar de suporte técnico, compartilhe o ARN do trabalho com a equipe AWS e reinicie seu trabalho de treinamento a partir de um ponto de verificação, se possível.
+ Em casos raros, uma configuração do trabalho que funcionou anteriormente, mas está próxima dos limites da memória da GPU, pode falhar posteriormente com um cluster diferente devido a um **erro de memória do CUDA**. Isso pode ocorrer porque algumas GPUs têm menos memória disponível do que o normal devido a erros de ECC.
+ Pode ocorrer uma **falha no tempo limite da rede** ao executar uma tarefa de vários nós que não usa tudo GPUs no nó. Para contornar isso, use tudo GPUs no nó para garantir que o `processes_per_host` parâmetro seja definido como o número de GPUs em cada instância. Por exemplo, isso é `processes_per_host=8` para instâncias `ml.p3.16xlarge`, `ml.p3dn.24xlarge`, e `ml.p4d.24xlarge`.
+ Se você achar que seu trabalho de treinamento leva muito tempo durante a fase de download de dados, certifique-se de que o caminho do Amazon S3 que você forneceu `checkpoint_s3_uri` para a SageMaker `Estimator` aula seja exclusivo para o trabalho de treinamento atual. Se esse caminho for reutilizado em vários trabalhos de treinamento executados simultaneamente, todos esses pontos de verificação serão carregados e baixados para o mesmo caminho do Amazon S3 e poderão aumentar significativamente o tempo de carregamento do ponto de verificação.
+ Use FSx o Lustre ao lidar com grandes dados e modelos.
+ [Se seu conjunto de dados for grande e sua busca demorar muito, recomendamos mantê-lo no FSx Lustre.](https://aws.amazon.com/fsx/lustre/)
+ Quando os modelos de treinamento estão além de 10 bilhões de parâmetros, recomendamos o uso do Lustre FSx para pontos de verificação.
+ Depois de criar um sistema de arquivos, aguarde até que o status fique **disponível** antes de iniciar um trabalho de treinamento com ele.
## Recebendo erro NCCL para um PyTorch Training Job
Se você encontrou o erro a seguir, ele pode ser devido à uma execução de processamento que está ficando sem memória da GPU.
```
NCCL error in: ../torch/lib/c10d/ProcessGroupNCCL.cpp:825, unhandled system error, NCCL version 2.7.8
ncclSystemError: System call (socket, malloc, munmap, etc) failed.
```
Você pode resolver isso reduzindo o tamanho do lote ou `active_microbatches`. Se o particionamento automático não estiver resultando em um particionamento bem balanceado, talvez seja necessário considerar o particionamento manual. Para obter mais informações, consulte [Paralelismo de pipeline entre os nós](model-parallel-best-practices.md#model-parallel-best-practices-configuration-pipeline-across-nodes).
## Recebendo `RecursionError` para um PyTorch Training Job
A biblioteca não suporta chamadas `super.forward()` dentro da chamada de avanço de um módulo. Se você usa o `super.forward()`, você poderá receber a seguinte mensagem de erro:
```
RecursionError: maximum recursion depth exceeded
```
Para corrigir o erro, em vez de chamar `super.forward()`, você deve chamar `super()._orig_forward()`.