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á. # Execute treinamento distribuído com a biblioteca de paralelismo de dados distribuídos de SageMaker IA A biblioteca de paralelismo de dados distribuídos de SageMaker IA (SMDDP) amplia os recursos de SageMaker treinamento em modelos de aprendizado profundo com eficiência de escalabilidade quase linear, fornecendo implementações de operações de comunicação coletiva otimizadas para infraestrutura. AWS Ao treinar grandes modelos de machine learning (ML), como grandes modelos de linguagem (LLMs) e modelos de difusão, em um grande conjunto de dados de treinamento, os profissionais de ML usam clusters de aceleradores e técnicas de treinamento distribuídas para reduzir o tempo de treinamento ou resolver restrições de memória para modelos que não cabem em nenhuma memória da GPU. Os profissionais de ML geralmente começam com vários aceleradores em uma única instância e depois escalam para clusters de instâncias à medida que aumentam seus requisitos de workload. Quanto maior o tamanho do cluster, maior é a sobrecarga de comunicação entre os vários nós, o que causa uma queda no desempenho computacional geral. Para resolver esses problemas de sobrecarga e memória, a biblioteca SMDDP oferece o seguinte: + A biblioteca SMDDP otimiza trabalhos de treinamento para infraestrutura de AWS rede e topologia de instância do Amazon SageMaker AI ML. + A biblioteca SMDDP melhora a comunicação entre os nós com implementações `AllReduce` e operações de comunicação `AllGather` coletiva otimizadas para infraestrutura. AWS Para saber mais sobre os detalhes das ofertas da biblioteca SMDDP, acesse [Introdução à biblioteca de paralelismo de dados distribuídos de SageMaker IA](data-parallel-intro.md). Para obter mais informações sobre treinamento com a estratégia paralela de modelos oferecida pela SageMaker IA, consulte também. [Biblioteca de paralelismo de modelos do SageMaker v1.x (arquivada)](model-parallel.md) **Topics** + [Introdução à biblioteca de paralelismo de dados distribuídos de SageMaker IA](data-parallel-intro.md) + [Estruturas e tipos Regiões da AWS de instâncias compatíveis](distributed-data-parallel-support.md) + [Treinamento distribuído com a biblioteca de SageMaker paralelismo de dados distribuídos de IA](data-parallel-modify-sdp.md) + [Exemplos da biblioteca de paralelismo de dados da Amazon SageMaker AI](distributed-data-parallel-v2-examples.md) + [Dicas de configuração para a biblioteca de paralelismo de dados distribuídos de SageMaker IA](data-parallel-config.md) + [Perguntas frequentes sobre a biblioteca de paralelismo de dados distribuídos do Amazon SageMaker AI](data-parallel-faq.md) + [Solução de problemas para treinamento distribuído na Amazon SageMaker AI](distributed-troubleshooting-data-parallel.md) + [SageMaker Notas de lançamento da biblioteca de paralelismo de dados de IA](data-parallel-release-notes.md) # Introdução à biblioteca de paralelismo de dados distribuídos de SageMaker IA A biblioteca SageMaker AI Distributed Data Parallelism (SMDDP) é uma biblioteca de comunicação coletiva que melhora o desempenho computacional do treinamento paralelo de dados distribuídos. A biblioteca SMDDP aborda a sobrecarga de comunicação das principais operações de comunicação coletiva, oferecendo os seguintes itens: 1. A biblioteca oferece opções `AllReduce` otimizadas para AWS. `AllReduce`é uma operação chave usada para sincronizar gradientes GPUs no final de cada iteração de treinamento durante o treinamento de dados distribuídos. 1. A biblioteca oferece opções `AllGather` otimizadas para AWS. `AllGather`é outra operação importante usada no treinamento paralelo de dados fragmentados, que é uma técnica de paralelismo de dados com eficiência de memória oferecida por bibliotecas populares, como a biblioteca SageMaker AI model paralelism (SMP), DeepSpeed Zero Redundancy Optimizer (Zero) e Fully Sharded Data Parallelism (FSDP). PyTorch 1. A biblioteca realiza uma node-to-node comunicação otimizada utilizando totalmente a infraestrutura de AWS rede e a topologia de instâncias do Amazon EC2. A biblioteca SMDDP pode aumentar a velocidade de treinamento oferecendo melhoria de desempenho à medida que você escala seu cluster de treinamento, com eficiência de ajuste de escala quase linear. **nota** As bibliotecas de treinamento distribuídas por SageMaker IA estão disponíveis por meio dos contêineres de aprendizado AWS profundo PyTorch e do Hugging Face na plataforma de treinamento. SageMaker Para usar as bibliotecas, você deve usar o SageMaker Python SDK ou o SageMaker APIs Through 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. ## Operações de comunicação coletiva SMDDP otimizadas para recursos AWS computacionais e infraestrutura de rede A biblioteca SMDDP fornece implementações `AllReduce` e operações `AllGather` coletivas que são otimizadas para recursos AWS computacionais e infraestrutura de rede. ### Operação coletiva do SMDDP `AllReduce` A biblioteca SMDDP alcança a sobreposição ideal da operação `AllReduce` com o retrocesso, melhorando significativamente a utilização da GPU. Ele alcança eficiência de escalonamento quase linear e velocidade de treinamento mais rápida, otimizando as operações do kernel entre e. CPUs GPUs A biblioteca executa `AllReduce` em paralelo enquanto a GPU calcula gradientes sem eliminar ciclos adicionais da GPU, o que faz a biblioteca alcançar treinamento mais rápido. + *Aproveitamentos CPUs*: a biblioteca usa dois CPUs `AllReduce` gradientes, descarregando essa tarefa do. GPUs + *Melhor uso da GPU*: o GPUs foco do cluster nos gradientes de computação, melhorando sua utilização durante o treinamento. A seguir, é apresentado o fluxo de trabalho de alto nível da operação SMDDP `AllReduce`. 1. A biblioteca atribui classificações a GPUs (trabalhadores). 1. Em cada iteração, a biblioteca divide cada lote global pelo número total de operadores (tamanho mundial) e atribui pequenos lotes (fragmentos de lote) aos operadores. + O tamanho do lote global é `(number of nodes in a cluster) * (number of GPUs per node) * (per batch shard)`. + Um fragmento de lote (ou lote pequeno) é um subconjunto do conjunto de dados atribuído a cada GPU (operador) por iteração. 1. A biblioteca inicia um script de treinamento em cada operador. 1. A biblioteca gerencia cópias dos pesos do modelo e gradientes dos operadores ao final de cada iteração. 1. A biblioteca sincroniza os pesos e gradientes do modelo entre os operadores para agregar um único modelo treinado. O diagrama de arquitetura a seguir mostra um exemplo de como a biblioteca configura o paralelismo de dados para um cluster de 3 nós. ![\[Diagrama de arquitetura de SMDDP AllReduce e paralelismo de dados\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/data-parallel/sdp-architecture.png) ### Operação coletiva do SMDDP `AllGather` `AllGather` é uma operação coletiva em que cada operador começa com um buffer de entrada e, em seguida, concatena ou *reúne* os buffers de entrada de todos os outros operadores em um buffer de saída. **nota** A operação `AllGather` coletiva SMDDP está disponível em AWS Deep Learning Containers (DLC) para PyTorch v2.0.1 `smdistributed-dataparallel>=2.0.1` e versões posteriores. `AllGather` é muito usado em técnicas de treinamento distribuído, como paralelismo de dados fragmentados, em que cada operador individual detém uma fração de um modelo ou uma camada fragmentada. Os operadores chamam `AllGather` antes de avançar e retroceder para reconstruir as camadas fragmentadas. Os avanços e retrocessos continuam progressivamente depois que os parâmetros são *todos reunidos*. Durante o retrocesso, cada operador também chama `ReduceScatter` para coletar (reduzir) gradientes e dividi-los (dispersá-los) em fragmentos de gradiente para atualizar a camada fragmentada correspondente. [Para obter mais detalhes sobre o papel dessas operações coletivas no paralelismo de dados fragmentados, consulte a [implementação do paralelismo de dados fragmentados na biblioteca SMP, [ZeRO](https://deepspeed.readthedocs.io/en/latest/zero3.html#) na DeepSpeed documentação, e o blog sobre paralelismo de dados](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-sharded-data-parallelism.html) totalmente fragmentados. PyTorch ](https://engineering.fb.com/2021/07/15/open-source/fsdp/) Como as operações coletivas AllGather são chamadas em cada iteração, elas são as principais responsáveis pela sobrecarga de comunicação da GPU. A computação mais rápida dessas operações coletivas reflete diretamente em um tempo de treinamento mais curto, sem efeitos colaterais na convergência. Para conseguir isso, a biblioteca SMDDP oferece `AllGather` otimizado para [instâncias P4d](https://aws.amazon.com/ec2/instance-types/p4/). O SMDDP `AllGather` usa as seguintes técnicas para melhorar o desempenho computacional em instâncias P4d: 1. Transfere dados entre instâncias (entre nós) por meio da rede [Elastic Fabric Adapter (EFA)](https://aws.amazon.com/hpc/efa/) com uma topologia de malha. O EFA é a solução AWS de rede de baixa latência e alto rendimento. Uma topologia de malha para comunicação de rede entre nós é mais adaptada às características do EFA e AWS da infraestrutura de rede. Em comparação com a topologia em anel NCCL ou árvore que envolve vários saltos de pacotes, o SMDDP evita o acúmulo de latência de vários saltos, pois precisa apenas de um salto. O SMDDP implementa um algoritmo de controle de taxa de rede que equilibra a workload para cada nível de comunicação em uma topologia de malha e atinge uma taxa maior de throughput da rede global. 1. Ele adota uma [biblioteca de cópias de memória de GPU de baixa latência baseada na tecnologia NVIDIA GPUDirect RDMA (GDRCopy)](https://github.com/NVIDIA/gdrcopy) para coordenar o tráfego de rede local e EFA. NVLink GDRCopy, uma biblioteca de cópias de memória de GPU de baixa latência oferecida pela NVIDIA, fornece comunicação de baixa latência entre os processos da CPU e os kernels CUDA da GPU. Com essa tecnologia, a biblioteca SMDDP é capaz de canalizar a movimentação de dados dentro e entre nós. 1. Reduz o uso de multiprocessadores de streaming de GPU para aumentar a potência computacional para executar kernels de modelos. As instâncias P4d e P4de são equipadas com NVIDIA A100 GPUs, cada uma com 108 multiprocessadores de streaming. Enquanto o NCCL usa até 24 multiprocessadores de streaming para executar operações coletivas, o SMDDP usa menos de 9 multiprocessadores de streaming. Os kernels de computação do modelo coletam os multiprocessadores de streaming salvos para uma computação mais rápida. # Estruturas e tipos Regiões da AWS de instâncias compatíveis Antes de usar a biblioteca de paralelismo de dados distribuídos de SageMaker IA (SMDDP), verifique quais são as estruturas de ML e os tipos de instância compatíveis e se há cotas suficientes em sua conta e. AWS Região da AWS ## Frameworks compatíveis As tabelas a seguir mostram as estruturas de aprendizado profundo e suas versões compatíveis com SageMaker IA e SMDDP. A biblioteca SMDDP está disponível nos contêineres do [SageMaker AI Framework, integrada aos contêineres](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) do [Docker distribuídos pela biblioteca de paralelismo de SageMaker modelos (SMP) v2](distributed-model-parallel-support-v2.md#distributed-model-parallel-supported-frameworks-v2) ou pode ser baixada como um arquivo binário. **nota** Para verificar as atualizações e notas da versão mais recentes da biblioteca SMDDP, consulte [SageMaker Notas de lançamento da biblioteca de paralelismo de dados de IA](data-parallel-release-notes.md). **Topics** + [PyTorch](#distributed-data-parallel-supported-frameworks-pytorch) + [PyTorch Relâmpago](#distributed-data-parallel-supported-frameworks-lightning) + [Transformadores Hugging Face](#distributed-data-parallel-supported-frameworks-transformers) + [TensorFlow (obsoleto)](#distributed-data-parallel-supported-frameworks-tensorflow) ### PyTorch | PyTorch versão | Versão da biblioteca SMDDP | SageMaker Imagens do AI Framework Container pré-instaladas com SMDDP | Imagens do Docker da SMP pré-instaladas com a SMDDP | URL do arquivo binário\$1\$1 | | --- | --- | --- | --- | --- | | v2.3.1 | smdistributed-dataparallel==v2.5.0 | Indisponível | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.4.1/cu121/2024-10-09/smdistributed\$1dataparallel-2.5.0-cp311-cp311-linux\$1x86\$164.whl | | v2.3.0 | smdistributed-dataparallel==v2.3.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.3.0-gpu-py311-cu121-ubuntu20.04-sagemaker | Indisponível no momento | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.3.0/cu121/2024-05-23/smdistributed\$1dataparallel-2.3.0-cp311-cp311-linux\$1x86\$164.whl | | v2.2.0 | smdistributed-dataparallel==v2.2.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.2.0-gpu-py310-cu121-ubuntu20.04-sagemaker | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.2.0/cu121/2024-03-04/smdistributed\$1dataparallel-2.2.0-cp310-cp310-linux\$1x86\$164.whl | | v2.1.0 | smdistributed-dataparallel==v2.1.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.1.0-gpu-py310-cu121-ubuntu20.04-sagemaker | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.1.2-gpu-py310-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.1.0/cu121/2024-02-04/smdistributed\$1dataparallel-2.1.0-cp310-cp310-linux\$1x86\$164.whl | | v2.0.1 | smdistributed-dataparallel==v2.0.1 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker | Indisponível | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.1/cu118/2023-12-07/smdistributed\$1dataparallel-2.0.2-cp310-cp310-linux\$1x86\$164.whl | | v2.0.0 | smdistributed-dataparallel==v1.8.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.0-gpu-py310-cu118-ubuntu20.04-sagemaker | Indisponível | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.0/cu118/2023-03-20/smdistributed\$1dataparallel-1.8.0-cp310-cp310-linux\$1x86\$164.whl | | v1.13.1 | smdistributed-dataparallel==v1.7.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.13.1-gpu-py39-cu117-ubuntu20.04-sagemaker | Indisponível | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.13.1/cu117/2023-01-09/smdistributed\$1dataparallel-1.7.0-cp39-cp39-linux\$1x86\$164.whl | | v1.12.1 | smdistributed-dataparallel==v1.6.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.1-gpu-py38-cu113-ubuntu20.04-sagemaker | Indisponível | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.12.1/cu113/2022-12-05/smdistributed\$1dataparallel-1.6.0-cp38-cp38-linux\$1x86\$164.whl | | v1.12.0 | smdistributed-dataparallel==v1.5.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.12.0-gpu-py38-cu113-ubuntu20.04-sagemaker | Indisponível | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.12.0/cu113/2022-07-01/smdistributed\$1dataparallel-1.5.0-cp38-cp38-linux\$1x86\$164.whl | | v1.11.0 | smdistributed-dataparallel==v1.4.1 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:1.11.0-gpu-py38-cu113-ubuntu20.04-sagemaker | Indisponível | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.11.0/cu113/2022-04-14/smdistributed\$1dataparallel-1.4.1-cp38-cp38-linux\$1x86\$164.whl | \$1\$1 Os URLs arquivos binários são para instalar a biblioteca SMDDP em contêineres personalizados. Para obter mais informações, consulte [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). **nota** A biblioteca SMDDP está disponível Regiões da AWS onde os [contêineres do SageMaker AI Framework](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) e as [imagens do SMP Docker](distributed-model-parallel-support-v2.md) estão em serviço. **nota** A biblioteca SMDDP v1.4.0 e posterior funciona como um back-end do paralelismo de dados distribuído ( PyTorch torch.distributed) (torch.parallel). DistributedDataParallel). De acordo com a alteração, os seguintes [smdistributes APIs](https://sagemaker.readthedocs.io/en/stable/api/training/sdp_versions/latest/smd_data_parallel_pytorch.html#pytorch-api) para o pacote PyTorch distribuído foram descontinuados. `smdistributed.dataparallel.torch.distributed` está obsoleto. Em vez disso, use o [pacote torch.distributed.](https://pytorch.org/docs/stable/distributed.html) `smdistributed.dataparallel.torch.parallel.DistributedDataParallel` está obsoleto. Use o [torch.nn.parallel. DistributedDataParallel](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html) Em vez disso, API. *Se você precisar usar as versões anteriores da biblioteca (v1.3.0 ou anterior), consulte a documentação [arquivada de paralelismo de dados distribuídos de SageMaker IA na documentação](https://sagemaker.readthedocs.io/en/stable/api/training/sdp_versions/latest.html#documentation-archive) do SDK do AI Python. SageMaker * ### PyTorch Relâmpago A biblioteca SMDDP está disponível para o PyTorch Lightning nos seguintes contêineres do SageMaker AI Framework PyTorch e nos contêineres SMP Docker. **PyTorch Lightning versão 2** | PyTorch Versão Lightning | PyTorch versão | Versão da biblioteca SMDDP | SageMaker Imagens do AI Framework Container pré-instaladas com SMDDP | Imagens do Docker da SMP pré-instaladas com a SMDDP | URL do arquivo binário\$1\$1 | | --- | --- | --- | --- | --- | --- | | 2.2.5 | 2.3.0 | smdistributed-dataparallel==v2.3.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.3.0-gpu-py311-cu121-ubuntu20.04-sagemaker | Indisponível no momento | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.3.0/cu121/2024-05-23/smdistributed\$1dataparallel-2.3.0-cp311-cp311-linux\$1x86\$164.whl | | 2.2.0 | 2.2.0 | smdistributed-dataparallel==v2.2.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.2.0-gpu-py310-cu121-ubuntu20.04-sagemaker | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.2.0/cu121/2024-03-04/smdistributed\$1dataparallel-2.2.0-cp310-cp310-linux\$1x86\$164.whl | | 2.1.2 | 2.1.0 | smdistributed-dataparallel==v2.1.0 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.1.0-gpu-py310-cu121-ubuntu20.04-sagemaker | 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.1.2-gpu-py310-cu121 | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.1.0/cu121/2024-02-04/smdistributed\$1dataparallel-2.1.0-cp310-cp310-linux\$1x86\$164.whl | | 2.1.0 | 2.0.1 | smdistributed-dataparallel==v2.0.1 | 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker | Indisponível | https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.1/cu118/2023-12-07/smdistributed\$1dataparallel-2.0.2-cp310-cp310-linux\$1x86\$164.whl | **PyTorch Lightning versão 1** | PyTorch Versão Lightning | PyTorch versão | Versão da biblioteca SMDDP | SageMaker Imagens do AI Framework Container pré-instaladas com SMDDP | URL do arquivo binário\$1\$1 | | --- | --- | --- | --- | --- | | 1.7.2 1.7.0 1.6.4 1.6.3 1.5.10 | 1.12.0 | smdistributed-dataparallel==v1.5.0 | 763104351884.dkr.ecr. .amazonaws.com/pytorch-training:1.12.0-gpu-py38-cu113-ubuntu20.04-sagemaker | https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.12.0/cu113/2022-07-01/smdistributed\$1dataparallel-1.5.0-cp38-cp38-linux\$1x86\$164.whl | \$1\$1 Os URLs arquivos binários são para instalar a biblioteca SMDDP em contêineres personalizados. Para obter mais informações, consulte [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). **nota** PyTorch O Lightning e suas bibliotecas de utilitários, como o Lightning Bolts, não estão pré-instalados no. PyTorch DLCs Ao criar um PyTorch estimador de SageMaker IA e enviar uma solicitação de trabalho de treinamento na [Etapa 2](https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel-use-api.html#data-parallel-framework-estimator), você precisa fornecer `requirements.txt` para instalação `pytorch-lightning` e `lightning-bolts` no contêiner de PyTorch treinamento de SageMaker IA. ``` # requirements.txt pytorch-lightning lightning-bolts ``` Para obter mais informações sobre como especificar o diretório de origem para colocar o `requirements.txt` arquivo junto com seu script de treinamento e o envio de um trabalho, consulte [Uso de bibliotecas de terceiros](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) na documentação do *Amazon SageMaker AI Python SDK*. ### Transformadores Hugging Face Os Contêineres de AWS Deep Learning para Hugging Face usam os Contêineres SageMaker de Treinamento TensorFlow como PyTorch 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) ### TensorFlow (obsoleto) **Importante** A biblioteca SMDDP interrompeu o suporte TensorFlow e não está mais disponível para versões TensorFlow posteriores à DLCs v2.11.0. A tabela a seguir lista as versões anteriores DLCs TensorFlow com a biblioteca SMDDP instalada. | TensorFlow versão | Versão da biblioteca SMDDP | | --- | --- | | 2.9.1, 2.10.1, 2.11.0 | smdistributed-dataparallel==v1.4.1 | | 2.8.3 | smdistributed-dataparallel==v1.3.0 | ## Regiões da AWS A biblioteca SMDDP está disponível em todos os Regiões da AWS lugares em que as [imagens do [AWS Deep Learning Containers for SageMaker AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) e do SMP Docker](distributed-model-parallel-support-v2.md) estão em serviço. ## Tipos de instâncias compatíveis A biblioteca SMDDP exige um dos seguintes tipos de instância: | Tipo de instância | | --- | | ml.p3dn.24xlarge\$1 | | ml.p4d.24xlarge | | ml.p4de.24xlarge | **dica** Para executar o treinamento distribuído de forma adequada nos tipos de instâncias habilitados para o EFA, você deve habilitar o tráfego entre as instâncias configurando o grupo de segurança de sua VPC para permitir todo o tráfego de entrada e saída de ida e volta para o próprio grupo de segurança. Para saber como configurar as regras do grupo de segurança, consulte [Etapa 1: preparar um grupo de segurança habilitado para EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) no *Guia do usuário do Amazon EC2*. **Importante** \$1 A biblioteca SMDDP interrompeu o compatibilidade com otimização de suas operações de comunicação coletiva em instâncias P3. Embora você ainda possa utilizar o coletivo `AllReduce` otimizado SMDDP em instâncias `ml.p3dn.24xlarge`, não haverá mais compatibilidade com desenvolvimento para aprimorar o desempenho nesse tipo de instância. Observe que o coletivo `AllGather` otimizado SMDDP se encontra disponível somente para instâncias P4. 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 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. ``` # Treinamento distribuído com a biblioteca de SageMaker paralelismo de dados distribuídos de IA A biblioteca de paralelismo de dados distribuídos de SageMaker IA (SMDDP) foi projetada para facilitar o uso e fornecer integração perfeita com o. PyTorch Ao treinar um modelo de aprendizado profundo com a biblioteca SMDDP em SageMaker IA, você pode se concentrar em escrever seu script de treinamento e modelo de treinamento. Para começar, importe a biblioteca SMDDP para usar suas operações coletivas otimizadas para a AWS. Os tópicos a seguir fornecem instruções sobre o que adicionar ao seu script de treinamento, dependendo da operação coletiva que você deseja otimizar. **Topics** + [Adaptação de seu script de treinamento para usar as operações coletivas do SMDDP](data-parallel-modify-sdp-select-framework.md) + [Lançamento de trabalhos de treinamento distribuídos com SMDDP usando o Python SDK SageMaker](data-parallel-use-api.md) # Adaptação de seu script de treinamento para usar as operações coletivas do SMDDP Os exemplos de scripts de treinamento fornecidos nesta seção são simplificados e destacam somente as alterações necessárias para ativar a biblioteca de paralelismo de dados distribuídos de SageMaker IA (SMDDP) em seu script de treinamento. Para exemplos end-to-end do notebook Jupyter que demonstram como executar um trabalho de treinamento distribuído com a biblioteca SMDDP, consulte. [Exemplos da biblioteca de paralelismo de dados da Amazon SageMaker AI](distributed-data-parallel-v2-examples.md) **Topics** + [Use a biblioteca SMDDP em seu PyTorch script de treinamento](data-parallel-modify-sdp-pt.md) + [Use a biblioteca SMDDP em seu script de treinamento do PyTorch Lightning](data-parallel-modify-sdp-pt-lightning.md) + [Use a biblioteca SMDDP em seu script de TensorFlow treinamento (obsoleto)](data-parallel-modify-sdp-tf2.md) # Use a biblioteca SMDDP em seu PyTorch script de treinamento [A partir da biblioteca SageMaker AI Distributed Data Parallelism (SMDDP) v1.4.0, você pode usar a biblioteca como uma opção de back-end para o pacote distribuído. PyTorch ](https://pytorch.org/tutorials/beginner/dist_overview.html) Para usar o SMDDP `AllReduce` e as operações `AllGather` coletivas, você só precisa importar a biblioteca SMDDP no início do script de treinamento e definir o SMDDP como o back-end dos módulos distribuídos durante a inicialização do grupo de PyTorch processos. Com a única linha de especificação de back-end, você pode manter todos os módulos PyTorch distribuídos nativos e todo o script de treinamento inalterados. [Os trechos de código a seguir mostram como usar a biblioteca SMDDP como back-end de pacotes de treinamento distribuídos PyTorch baseados: distributed [PyTorch data parallel (DDP), full [sharded data paralelism (PyTorch FSDP](https://pytorch.org/docs/stable/fsdp.html))](https://pytorch.org/docs/stable/notes/ddp.html) e Megatron-. [DeepSpeed](https://github.com/microsoft/DeepSpeed)DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed) ## Para PyTorch DDP ou FSDP Inicialize o grupo de processos da seguinte maneira: ``` import torch.distributed as dist import smdistributed.dataparallel.torch.torch_smddp dist.init_process_group(backend="smddp") ``` **nota** (Somente para trabalhos do PyTorch DDP) Atualmente, o `smddp` back-end não oferece suporte à criação de grupos de subprocessos com a API. `torch.distributed.new_group()` Você não pode usar o backend `smddp` simultaneamente com outros backends de grupos de processos, como `NCCL` e `Gloo`. ## Para DeepSpeed ou Megatron- DeepSpeed Inicialize o grupo de processos da seguinte maneira: ``` import deepspeed import smdistributed.dataparallel.torch.torch_smddp deepspeed.init_distributed(dist_backend="smddp") ``` **nota** Para usar o SMDDP `AllGather` com os iniciadores do `mpirun` (`smdistributed` e `pytorchddp`) em [Lançamento de trabalhos de treinamento distribuídos com SMDDP usando o Python SDK SageMaker](data-parallel-use-api.md), você também precisa definir a seguinte variável de ambiente em seu script de treinamento: ``` export SMDATAPARALLEL_OPTIMIZE_SDP=true ``` Para obter orientação geral sobre como escrever um script de treinamento de PyTorch FSDP, consulte [Treinamento avançado de modelos com dados paralelos totalmente fragmentados (FSDP](https://pytorch.org/tutorials/intermediate/FSDP_adavnced_tutorial.html)) na documentação. PyTorch Para obter orientação geral sobre como escrever um script de treinamento de PyTorch DDP, consulte [Getting started with distributed data parallel](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html) na PyTorch documentação. Depois de concluir a adaptação do seu script de treinamento, prossiga para [Lançamento de trabalhos de treinamento distribuídos com SMDDP usando o Python SDK SageMaker](data-parallel-use-api.md). # Use a biblioteca SMDDP em seu script de treinamento do PyTorch Lightning Se você quiser trazer seu script de treinamento do [PyTorchLightning](https://pytorch-lightning.readthedocs.io/en/latest/starter/introduction.html) e executar um trabalho de treinamento paralelo de dados distribuídos em SageMaker IA, você pode executar o trabalho de treinamento com o mínimo de alterações em seu script de treinamento. As mudanças necessárias incluem o seguinte: importar os PyTorch módulos da `smdistributed.dataparallel` biblioteca, configurar as variáveis de ambiente para que o PyTorch Lightning aceite as variáveis de ambiente de SageMaker IA predefinidas pelo kit de ferramentas de SageMaker treinamento e ative a biblioteca SMDDP configurando o back-end do grupo de processos como. `"smddp"` Para saber mais, siga as instruções a seguir que detalham as etapas com exemplos de código. **nota** O suporte ao PyTorch Lightning está disponível na biblioteca paralela de dados SageMaker AI v1.5.0 e versões posteriores. ## PyTorch Lightning == v2.1.0 e == 2.0.1 PyTorch 1. Importe a biblioteca `pytorch_lightning` e os módulos `smdistributed.dataparallel.torch`. ``` import lightning as pl import smdistributed.dataparallel.torch.torch_smddp ``` 1. Instancie o. [LightningEnvironment](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.plugins.environments.LightningEnvironment.html) ``` from lightning.fabric.plugins.environments.lightning import LightningEnvironment env = LightningEnvironment() env.world_size = lambda: int(os.environ["WORLD_SIZE"]) env.global_rank = lambda: int(os.environ["RANK"]) ``` 1. **Para PyTorch DDP** — Crie um objeto da [DDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.DDPStrategy.html)classe com `"smddp"` for `process_group_backend` e for e `accelerator` passe-o `"gpu"` para a classe [Trainer.](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html) ``` import lightning as pl from lightning.pytorch.strategies import DDPStrategy ddp = DDPStrategy( cluster_environment=env, process_group_backend="smddp", accelerator="gpu" ) trainer = pl.Trainer( max_epochs=200, strategy=ddp, devices=num_gpus, num_nodes=num_nodes ) ``` **Para PyTorch FSDP** [— Crie um objeto da [FSDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.FSDPStrategy.html)classe (com a [política de empacotamento](https://pytorch.org/docs/stable/fsdp.html) de escolha) com `"smddp"` for `process_group_backend` e for e passe isso `"gpu"` para `accelerator` a classe Trainer.](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html) ``` import lightning as pl from lightning.pytorch.strategies import FSDPStrategy from functools import partial from torch.distributed.fsdp.wrap import size_based_auto_wrap_policy policy = partial( size_based_auto_wrap_policy, min_num_params=10000 ) fsdp = FSDPStrategy( auto_wrap_policy=policy, process_group_backend="smddp", cluster_environment=env ) trainer = pl.Trainer( max_epochs=200, strategy=fsdp, devices=num_gpus, num_nodes=num_nodes ) ``` Depois de concluir a adaptação do seu script de treinamento, prossiga para [Lançamento de trabalhos de treinamento distribuídos com SMDDP usando o Python SDK SageMaker](data-parallel-use-api.md). **nota** Ao criar um PyTorch estimador de SageMaker IA e enviar uma solicitação de trabalho de treinamento[Lançamento de trabalhos de treinamento distribuídos com SMDDP usando o Python SDK SageMaker](data-parallel-use-api.md), você precisa fornecer `requirements.txt` para instalar `pytorch-lightning` e `lightning-bolts` no contêiner de PyTorch treinamento de SageMaker IA. ``` # requirements.txt pytorch-lightning lightning-bolts ``` Para obter mais informações sobre como especificar o diretório de origem para colocar o `requirements.txt` arquivo junto com seu script de treinamento e o envio de um trabalho, consulte [Uso de bibliotecas de terceiros](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) na documentação do *Amazon SageMaker AI Python SDK*. # Use a biblioteca SMDDP em seu script de TensorFlow treinamento (obsoleto) **Importante** A biblioteca SMDDP interrompeu o suporte TensorFlow e não está mais disponível para versões TensorFlow posteriores à DLCs v2.11.0. Para saber mais sobre TensorFlow DLCs a biblioteca SMDDP instalada, consulte. [Frameworks compatíveis](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks) As etapas a seguir mostram como modificar um script de TensorFlow treinamento para utilizar a biblioteca paralela de dados distribuídos da SageMaker AI.  A biblioteca APIs foi projetada para ser semelhante à Horovod APIs. Para obter detalhes adicionais sobre cada API que a biblioteca oferece TensorFlow, consulte a [documentação da TensorFlow API SageMaker AI distributed data parallel](https://sagemaker.readthedocs.io/en/stable/api/training/smd_data_parallel.html#api-documentation). **nota** SageMaker O AI Distributed Data Parallel é adaptável a scripts de TensorFlow treinamento compostos por módulos `tf` principais, exceto `tf.keras` módulos. SageMaker O AI Distributed Data Parallel não é compatível TensorFlow com a implementação do Keras. **nota** A biblioteca de paralelismo de dados distribuídos de SageMaker IA oferece suporte à Precisão Mista Automática (AMP) pronta para uso. Nenhuma ação adicional é necessária para habilitar o AMP, além das modificações no nível do framework no seu script de treinamento. Se houver gradientes FP16, a biblioteca de paralelismo de dados de SageMaker IA executa sua operação em. `AllReduce` FP16 Para obter mais informações sobre como implementar APIs o AMP em seu script de treinamento, consulte os seguintes recursos: [Frameworks - TensorFlow](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#tensorflow) na documentação de desempenho do *NVIDIA Deep Learning* [Precisão mista automática para aprendizado profundo](https://developer.nvidia.com/automatic-mixed-precision) nos *documentos de desenvolvedores da NVIDIA* [TensorFlow precisão mista APIs](https://www.tensorflow.org/guide/mixed_precision) na *TensorFlowdocumentação* 1. Importe o TensorFlow cliente da biblioteca e inicialize-o. ``` import smdistributed.dataparallel.tensorflow as sdp  sdp.init() ``` 1. Fixe cada GPU em um único `smdistributed.dataparallel` processo com `local_rank`: isso se refere à classificação relativa do processo em um determinado nó. A API `sdp.tensorflow.local_rank()` fornece a classificação local do dispositivo para você. A classificação do nó líder é 0 e as classificações dos nós de processamento são 1, 2, 3 e assim por diante. Isso é invocado no seguinte bloco de código como`sdp.local_rank()`. `set_memory_growth`não está diretamente relacionado à SageMaker IA distribuída, mas deve ser configurado para treinamento distribuído com TensorFlow. ``` gpus = tf.config.experimental.list_physical_devices('GPU') for gpu in gpus:     tf.config.experimental.set_memory_growth(gpu, True) if gpus:     tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU') ``` 1. Escale a taxa de aprendizado pelo número de operadores. A API `sdp.tensorflow.size()` fornece o número de operadores no cluster. Isso é invocado no bloco de código a seguir como `sdp.size()`. ``` learning_rate = learning_rate * sdp.size() ``` 1. Use a biblioteca `DistributedGradientTape` para otimizar as operações `AllReduce` durante o treinamento. Isso envolve `tf.GradientTape`.  ``` with tf.GradientTape() as tape:       output = model(input)       loss_value = loss(label, output)      # SageMaker AI data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape tape = sdp.DistributedGradientTape(tape) ``` 1. Transmita as variáveis iniciais do modelo do nó líder (classificação 0) para todos os nós de processamento (classificações de 1 a n). Isso é necessário para garantir uma inicialização consistente em todas as categorias de operadores. Use a API `sdp.tensorflow.broadcast_variables` depois que as variáveis do modelo e do otimizador forem inicializadas. Isso é invocado no bloco de código a seguir como `sdp.broadcast_variables()`. ``` sdp.broadcast_variables(model.variables, root_rank=0) sdp.broadcast_variables(opt.variables(), root_rank=0) ``` 1. Por fim, modifique seu script para salvar pontos de verificação somente no nó líder. O nó líder tem um modelo sincronizado. Isso também evita que os nós de processamento sobrescrevam os pontos de verificação e possivelmente os corrompam. ``` if sdp.rank() == 0:     checkpoint.save(checkpoint_dir) ``` Veja a seguir um exemplo de script de TensorFlow treinamento para treinamento distribuído com a biblioteca. ``` import tensorflow as tf # SageMaker AI data parallel: Import the library TF API import smdistributed.dataparallel.tensorflow as sdp # SageMaker AI data parallel: Initialize the library sdp.init() gpus = tf.config.experimental.list_physical_devices('GPU') for gpu in gpus:     tf.config.experimental.set_memory_growth(gpu, True) if gpus:     # SageMaker AI data parallel: Pin GPUs to a single library process     tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU') # Prepare Dataset dataset = tf.data.Dataset.from_tensor_slices(...) # Define Model mnist_model = tf.keras.Sequential(...) loss = tf.losses.SparseCategoricalCrossentropy() # SageMaker AI data parallel: Scale Learning Rate # LR for 8 node run : 0.000125 # LR for single node run : 0.001 opt = tf.optimizers.Adam(0.000125 * sdp.size()) @tf.function def training_step(images, labels, first_batch):     with tf.GradientTape() as tape:         probs = mnist_model(images, training=True)         loss_value = loss(labels, probs)     # SageMaker AI data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape     tape = sdp.DistributedGradientTape(tape)     grads = tape.gradient(loss_value, mnist_model.trainable_variables)     opt.apply_gradients(zip(grads, mnist_model.trainable_variables))     if first_batch:        # SageMaker AI data parallel: Broadcast model and optimizer variables        sdp.broadcast_variables(mnist_model.variables, root_rank=0)        sdp.broadcast_variables(opt.variables(), root_rank=0)     return loss_value ... # SageMaker AI data parallel: Save checkpoints only from master node. if sdp.rank() == 0:     checkpoint.save(checkpoint_dir) ``` Depois de concluir a adaptação do seu script de treinamento, prossiga para [Lançamento de trabalhos de treinamento distribuídos com SMDDP usando o Python SDK SageMaker](data-parallel-use-api.md). # Lançamento de trabalhos de treinamento distribuídos com SMDDP usando o Python SDK SageMaker Para executar um trabalho de treinamento distribuído com seu script adaptado do[Adaptação de seu script de treinamento para usar as operações coletivas do SMDDP](data-parallel-modify-sdp-select-framework.md), use a estrutura do SageMaker Python SDK ou estimadores genéricos especificando o script de treinamento preparado como um script de ponto de entrada e a configuração de treinamento distribuído. Nesta página, você aprenderá a usar o [SDK SageMaker AI Python](https://sagemaker.readthedocs.io/en/stable/api/training/index.html) de duas maneiras. + Se você quiser obter uma adoção rápida de seu trabalho de treinamento distribuído em SageMaker IA, configure uma classe de estimador de SageMaker IA [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch)ou [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)estrutura. O estimador da estrutura pega seu script de treinamento e combina automaticamente o URI correto da imagem dos Deep Learning [ PyTorch Containers (DLC) pré-construídos ou do TensorFlow Deep Learning Containers (DLC)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only), considerando o valor especificado para o parâmetro. `framework_version` + Se você quiser estender um dos contêineres pré-criados ou criar um contêiner personalizado para criar seu próprio ambiente de ML com SageMaker IA, use a `Estimator` classe genérica SageMaker AI e especifique o URI da imagem do contêiner Docker personalizado hospedado em seu Amazon Elastic Container Registry (Amazon ECR). Seus conjuntos de dados de treinamento devem ser armazenados no Amazon S3 ou no [ FSx Amazon for](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) Lustre Região da AWS no qual você está lançando seu trabalho de treinamento. Se você usa notebooks Jupyter, você deve ter uma instância de SageMaker notebook ou um aplicativo SageMaker Studio Classic em execução no mesmo. Região da AWS Para obter mais informações sobre como armazenar seus dados de treinamento, consulte a documentação de entradas de [dados do SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#use-file-systems-as-training-input). **dica** Recomendamos que você use o Amazon FSx for Lustre em vez do Amazon S3 para melhorar o desempenho do treinamento. FSx A Amazon tem maior taxa de transferência e menor latência do que o Amazon S3. **dica** Para executar adequadamente o treinamento distribuído nos tipos de instância habilitados para o EFA, você deve habilitar o tráfego entre as instâncias configurando o grupo de segurança da VPC para permitir todo o tráfego de entrada e saída de e para o próprio grupo de segurança. Para saber como configurar as regras do grupo de segurança, consulte [Etapa 1: preparar um grupo de segurança habilitado para EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) no *Guia do usuário do Amazon EC2*. Escolha um dos tópicos a seguir para obter instruções sobre como executar um trabalho de treinamento distribuído do script de treinamento. Depois de iniciar um trabalho de treinamento, você pode monitorar a utilização do sistema e o desempenho do modelo usando [SageMaker Depurador Amazon](train-debugger.md) a Amazon CloudWatch. Enquanto você segue as instruções nos tópicos a seguir para saber mais sobre detalhes técnicos, também recomendamos que você experimente o [Exemplos da biblioteca de paralelismo de dados da Amazon SageMaker AI](distributed-data-parallel-v2-examples.md) para começar. **Topics** + [Use os estimadores da PyTorch estrutura no SDK do Python SageMaker](data-parallel-framework-estimator.md) + [Use o estimador genérico de SageMaker IA para estender contêineres de DLC pré-construídos](data-parallel-use-python-skd-api.md) + [Crie seu próprio contêiner Docker com a biblioteca paralela de dados distribuídos de SageMaker IA](data-parallel-bring-your-own-container.md) # Use os estimadores da PyTorch estrutura no SDK do Python SageMaker Você pode iniciar o treinamento distribuído adicionando o `distribution` argumento aos estimadores da estrutura de SageMaker IA ou. [https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch) Para obter mais detalhes, escolha uma das estruturas suportadas pela biblioteca de paralelismo de dados distribuídos de SageMaker IA (SMDDP) entre as seleções a seguir. ------ #### [ PyTorch ] As seguintes opções de lançador estão disponíveis para iniciar o treinamento PyTorch distribuído. + `pytorchddp`— Essa opção executa `mpirun` e configura as variáveis de ambiente necessárias para executar o treinamento PyTorch distribuído em SageMaker IA. Para usar essa opção, transfira o seguinte dicionário para o parâmetro `distribution`: ``` { "pytorchddp": { "enabled": True } } ``` + `torch_distributed`— Essa opção executa `torchrun` e configura as variáveis de ambiente necessárias para executar o treinamento PyTorch distribuído em SageMaker IA. Para usar essa opção, transfira o seguinte dicionário para o parâmetro `distribution`: ``` { "torch_distributed": { "enabled": True } } ``` + `smdistributed`— Essa opção também é executada`mpirun`, mas com `smddprun` isso configura as variáveis de ambiente necessárias para executar o treinamento PyTorch distribuído em SageMaker IA. ``` { "smdistributed": { "dataparallel": { "enabled": True } } } ``` Se você optar por substituir o NCCL `AllGather` pelo SMDDP `AllGather`, poderá usar todas as três opções. Escolha uma opção que seja mais adequada ao caso de uso. Se você optar por substituir o NCCL `AllReduce` pelo SMDDP `AllReduce`, deverá escolher uma das opções encontradas em `mpirun`: `smdistributed` ou `pytorchddp`. Você também pode adicionar outras opções de MPI da seguinte forma: ``` { "pytorchddp": { "enabled": True, "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION" } } ``` ``` { "smdistributed": { "dataparallel": { "enabled": True, "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION" } } } ``` O exemplo de código a seguir mostra a estrutura básica de um PyTorch estimador com opções de treinamento distribuídas. ``` from sagemaker.pytorch import PyTorch pt_estimator = PyTorch( base_job_name="training_job_name_prefix", source_dir="subdirectory-to-your-code", entry_point="adapted-training-script.py", role="SageMakerRole", py_version="py310", framework_version="2.0.1",     # For running a multi-node distributed training job, specify a value greater than 1     # Example: 2,3,4,..8 instance_count=2,     # Instance types supported by the SageMaker AI data parallel library: # ml.p4d.24xlarge, ml.p4de.24xlarge instance_type="ml.p4d.24xlarge", # Activate distributed training with SMDDP distribution={ "pytorchddp": { "enabled": True } } # mpirun, activates SMDDP AllReduce OR AllGather # distribution={ "torch_distributed": { "enabled": True } } # torchrun, activates SMDDP AllGather # distribution={ "smdistributed": { "dataparallel": { "enabled": True } } } # mpirun, activates SMDDP AllReduce OR AllGather ) pt_estimator.fit("s3://bucket/path/to/training/data") ``` **nota** PyTorch O Lightning e suas bibliotecas de utilitários, como o Lightning Bolts, não estão pré-instalados na IA. SageMaker PyTorch DLCs Crie o arquivo `requirements.txt` a seguir e salve no diretório de origem em que você salva o script de treinamento. ``` # requirements.txt pytorch-lightning lightning-bolts ``` Por exemplo, o diretório de árvore estruturada deve ser semelhante ao seguinte: ``` ├── pytorch_training_launcher_jupyter_notebook.ipynb └── sub-folder-for-your-code ├── adapted-training-script.py └── requirements.txt ``` Para obter mais informações sobre como especificar o diretório de origem para colocar o `requirements.txt` arquivo junto com seu script de treinamento e o envio de um trabalho, consulte [Uso de bibliotecas de terceiros](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) na documentação do *Amazon SageMaker AI Python SDK*. **Considerações para ativar as operações coletivas do SMDDP e usar as opções corretas de inicializador de treinamento distribuído** + SMDDP `AllReduce` e SMDDP `AllGather` não são mutuamente compatíveis no momento. + O SMDDP `AllReduce` é ativado por padrão ao usar `smdistributed` ou `pytorchddp`, que são iniciadores encontrados no `mpirun`, e é usado o NCCL `AllGather`. + O SMDDP `AllGather` é ativado por padrão ao usar o iniciador `torch_distributed` e `AllReduce` volta para o NCCL. + O SMDDP `AllGather` pode ser ativado também com o uso dos iniciadores encontrados em `mpirun` com uma variável de ambiente adicional definida da seguinte forma: ``` export SMDATAPARALLEL_OPTIMIZE_SDP=true ``` ------ #### [ TensorFlow ] **Importante** A biblioteca SMDDP interrompeu o suporte TensorFlow e não está mais disponível para versões TensorFlow posteriores à DLCs v2.11.0. Para saber mais sobre TensorFlow DLCs a biblioteca SMDDP instalada, consulte. [TensorFlow (obsoleto)](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks-tensorflow) ``` from sagemaker.tensorflow import TensorFlow tf_estimator = TensorFlow( base_job_name = "training_job_name_prefix", entry_point="adapted-training-script.py", role="SageMakerRole", framework_version="2.11.0", py_version="py38",     # For running a multi-node distributed training job, specify a value greater than 1 # Example: 2,3,4,..8 instance_count=2,     # Instance types supported by the SageMaker AI data parallel library: # ml.p4d.24xlarge, ml.p3dn.24xlarge, and ml.p3.16xlarge instance_type="ml.p3.16xlarge",     # Training using the SageMaker AI data parallel distributed training strategy distribution={ "smdistributed": { "dataparallel": { "enabled": True } } } ) tf_estimator.fit("s3://bucket/path/to/training/data") ``` ------ # Use o estimador genérico de SageMaker IA para estender contêineres de DLC pré-construídos Você pode personalizar contêineres pré-criados de SageMaker IA ou estendê-los para lidar com quaisquer requisitos funcionais adicionais para seu algoritmo ou modelo que a imagem pré-criada do SageMaker AI Docker não suporte. Para ver um exemplo de como você pode estender um contêiner pré-compilado, consulte [Estender um contêiner pré-compilado](https://docs.aws.amazon.com/sagemaker/latest/dg/prebuilt-containers-extend.html). Para estender um contêiner pré-compilado ou adaptar seu próprio contêiner para usar a biblioteca, você deve usar uma das imagens listadas em [Frameworks compatíveis](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks). **nota** A partir das TensorFlow versões 2.4.1 e PyTorch 1.8.1, o SageMaker AI framework DLCs oferece suporte a tipos de instância habilitados para EFA. Recomendamos que você use as imagens de DLC que contenham TensorFlow 2.4.1 ou posterior e PyTorch 1.8.1 ou posterior. Por exemplo, se você usa PyTorch, seu Dockerfile deve conter uma `FROM` declaração semelhante à seguinte: ``` # SageMaker AI PyTorch image FROM 763104351884.dkr.ecr..amazonaws.com/pytorch-training: ENV PATH="/opt/ml/code:${PATH}" # this environment variable is used by the SageMaker AI PyTorch container to determine our user code directory. ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code # /opt/ml and all subdirectories are utilized by SageMaker AI, use the /code subdirectory to store your user code. COPY train.py /opt/ml/code/train.py # Defines cifar10.py as script entrypoint ENV SAGEMAKER_PROGRAM train.py ``` Você pode personalizar ainda mais seu próprio contêiner Docker para trabalhar com SageMaker IA usando o [kit de ferramentas de SageMaker treinamento](https://github.com/aws/sagemaker-training-toolkit) e o arquivo binário da biblioteca paralela de dados distribuídos de SageMaker IA. Para saber mais, consulte as instruções na seção a seguir. # Crie seu próprio contêiner Docker com a biblioteca paralela de dados distribuídos de SageMaker IA Para criar seu próprio contêiner Docker para treinamento e usar a biblioteca paralela de dados de SageMaker IA, você deve incluir as dependências corretas e os arquivos binários das bibliotecas paralelas distribuídas de SageMaker IA em seu Dockerfile. Esta seção fornece instruções sobre como criar um Dockerfile completo com o conjunto mínimo de dependências para treinamento distribuído em SageMaker IA usando a biblioteca paralela de dados. **nota** Essa opção personalizada do Docker com a biblioteca paralela de dados SageMaker AI como binária está disponível somente para PyTorch. **Para criar um Dockerfile com o kit de ferramentas de SageMaker treinamento e a biblioteca paralela de dados** 1. Comece com uma imagem do Docker da [NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). [Use as versões de desenvolvedor cuDNN que contêm ferramentas de desenvolvimento e tempo de execução CUDA (cabeçalhos e bibliotecas) para criar a partir do código-fonte. PyTorch ](https://github.com/pytorch/pytorch#from-source) ``` FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04 ``` **dica** As imagens oficiais do AWS Deep Learning Container (DLC) são criadas a partir das imagens básicas [NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). Se você quiser usar as imagens de DLC pré-criadas como referências enquanto segue o resto das instruções, consulte [AWS Deep Learning Containers para PyTorch ](https://github.com/aws/deep-learning-containers/tree/master/pytorch) Dockerfiles. 1. Adicione os argumentos a seguir para especificar versões PyTorch e outros pacotes. Além disso, indique os caminhos do bucket do Amazon S3 para a biblioteca paralela de dados de SageMaker IA e outros softwares para usar AWS recursos, como o plug-in Amazon S3. Para usar versões de bibliotecas de terceiros diferentes das fornecidas no exemplo de código a seguir, recomendamos que você consulte os [Dockerfiles oficiais do AWS Deep Learning Container PyTorch para](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) encontrar versões testadas, compatíveis e adequadas para seu aplicativo. URLs Para encontrar o `SMDATAPARALLEL_BINARY` argumento, consulte as tabelas de pesquisa em[Frameworks compatíveis](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks). ``` ARG PYTORCH_VERSION=1.10.2 ARG PYTHON_SHORT_VERSION=3.8 ARG EFA_VERSION=1.14.1 ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl ARG CONDA_PREFIX="/opt/conda" ARG BRANCH_OFI=1.1.3-aws ``` 1. Defina as seguintes variáveis de ambiente para criar adequadamente os componentes de SageMaker treinamento e executar a biblioteca paralela de dados. Você usa essas variáveis para os componentes nas etapas subsequentes. ``` # Set ENV variables required to build PyTorch ENV TORCH_CUDA_ARCH_LIST="7.0+PTX 8.0" ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all" ENV NCCL_VERSION=2.10.3 # Add OpenMPI to the path. ENV PATH /opt/amazon/openmpi/bin:$PATH # Add Conda to path ENV PATH $CONDA_PREFIX/bin:$PATH # Set this enviroment variable for SageMaker AI to launch SMDDP correctly. ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main # Add enviroment variable for processes to be able to call fork() ENV RDMAV_FORK_SAFE=1 # Indicate the container type ENV DLC_CONTAINER_TYPE=training # Add EFA and SMDDP to LD library path ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH" ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH ``` 1. Instale ou atualize `curl`, `wget` e `git` para baixar e criar pacotes nas etapas subsequentes. ``` RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \ apt-get update && apt-get install -y --no-install-recommends \ curl \ wget \ git \ && rm -rf /var/lib/apt/lists/* ``` 1. Instale o [software Elastic Fabric Adapter (EFA) para comunicação](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) de rede do Amazon EC2. ``` RUN DEBIAN_FRONTEND=noninteractive apt-get update RUN mkdir /tmp/efa \ && cd /tmp/efa \ && curl --silent -O https://efa-installer.amazonaws.com/aws-efa-installer-${EFA_VERSION}.tar.gz \ && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \ && cd aws-efa-installer \ && ./efa_installer.sh -y --skip-kmod -g \ && rm -rf /tmp/efa ``` 1. Instale o [Conda](https://docs.conda.io/en/latest/) para lidar com o gerenciamento de pacotes. ``` RUN curl -fsSL -v -o ~/miniconda.sh -O https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh && \ chmod +x ~/miniconda.sh && \ ~/miniconda.sh -b -p $CONDA_PREFIX && \ rm ~/miniconda.sh && \ $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \ $CONDA_PREFIX/bin/conda clean -ya ``` 1. Obtenha, construa PyTorch e instale suas dependências. Construímos [a PyTorch partir do código-fonte](https://github.com/pytorch/pytorch#from-source) porque precisamos ter controle da versão NCCL para garantir a compatibilidade com o plug-in [AWS OFI](https://github.com/aws/aws-ofi-nccl) NCCL. 1. Seguindo as etapas no [dockerfile PyTorch oficial](https://github.com/pytorch/pytorch/blob/master/Dockerfile), instale as dependências de compilação e configure o [ccache](https://ccache.dev/) para acelerar a recompilação. ``` RUN DEBIAN_FRONTEND=noninteractive \ apt-get install -y --no-install-recommends \ build-essential \ ca-certificates \ ccache \ cmake \ git \ libjpeg-dev \ libpng-dev \ && rm -rf /var/lib/apt/lists/* # Setup ccache RUN /usr/sbin/update-ccache-symlinks RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache ``` 1. Instale [PyTorchas dependências comuns e do Linux](https://github.com/pytorch/pytorch#install-dependencies). ``` # Common dependencies for PyTorch RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses # Linux specific dependency for PyTorch RUN conda install -c pytorch magma-cuda113 ``` 1. Clone o [PyTorch GitHubrepositório](https://github.com/pytorch/pytorch). ``` RUN --mount=type=cache,target=/opt/ccache \ cd / \ && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION} ``` 1. Instale e construa uma versão específica do [NCCL.](https://developer.nvidia.com/nccl) Para fazer isso, substitua o conteúdo na pasta NCCL padrão (`/pytorch/third_party/nccl`) pela versão específica da NCCL do repositório NVIDIA. PyTorch A versão NCCL foi definida na etapa 3 deste guia. ``` RUN cd /pytorch/third_party/nccl \ && rm -rf nccl \ && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \ && cd nccl \ && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \ && make pkg.txz.build \ && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1 ``` 1. Crie e instale PyTorch. Esse processo geralmente leva um pouco mais de uma hora para ser concluído. Ele é construído usando a versão NCCL baixada em uma etapa anterior. ``` RUN cd /pytorch \ && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \ python setup.py install \ && rm -rf /pytorch ``` 1. Crie e instale o [plugin OFI NCCL AWS](https://github.com/aws/aws-ofi-nccl). Isso permite o suporte [do libfabric](https://github.com/ofiwg/libfabric) para a biblioteca paralela de dados SageMaker AI. ``` RUN DEBIAN_FRONTEND=noninteractive apt-get update \ && apt-get install -y --no-install-recommends \ autoconf \ automake \ libtool RUN mkdir /tmp/efa-ofi-nccl \ && cd /tmp/efa-ofi-nccl \ && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \ && cd aws-ofi-nccl \ && ./autogen.sh \ && ./configure --with-libfabric=/opt/amazon/efa \ --with-mpi=/opt/amazon/openmpi \ --with-cuda=/usr/local/cuda \ --with-nccl=$CONDA_PREFIX \ && make \ && make install \ && rm -rf /tmp/efa-ofi-nccl ``` 1. Crie e instale [TorchVision](https://github.com/pytorch/vision.git). ``` RUN pip install --no-cache-dir -U \ packaging \ mpi4py==3.0.3 RUN cd /tmp \ && git clone https://github.com/pytorch/vision.git -b v0.9.1 \ && cd vision \ && BUILD_VERSION="0.9.1+cu111" python setup.py install \ && cd /tmp \ && rm -rf vision ``` 1. Instale e configure o OpenSSH. O OpenSSH é necessário para que o MPI se comunique entre contêineres. Permita que o OpenSSH se comunique com contêineres sem solicitar confirmação. ``` RUN apt-get update \ && apt-get install -y --allow-downgrades --allow-change-held-packages --no-install-recommends \ && apt-get install -y --no-install-recommends openssh-client openssh-server \ && mkdir -p /var/run/sshd \ && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \ && echo " StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \ && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \ && rm -rf /var/lib/apt/lists/* # Configure OpenSSH so that nodes can communicate with each other RUN mkdir -p /var/run/sshd && \ sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd RUN rm -rf /root/.ssh/ && \ mkdir -p /root/.ssh/ && \ ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \ cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \ && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config ``` 1. Instale o plug-in PT S3 para acessar com eficiência conjuntos de dados no Amazon S3. ``` RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU} RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt ``` 1. Instale a biblioteca [libboost](https://www.boost.org/). Esse pacote é necessário para conectar em rede a funcionalidade de E/S assíncrona da biblioteca paralela de SageMaker dados AI. ``` WORKDIR / RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \ && tar -xzf boost_1_73_0.tar.gz \ && cd boost_1_73_0 \ && ./bootstrap.sh \ && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \ && cd .. \ && rm -rf boost_1_73_0.tar.gz \ && rm -rf boost_1_73_0 \ && cd ${CONDA_PREFIX}/include/boost ``` 1. Instale as seguintes ferramentas de SageMaker IA para PyTorch treinamento. ``` WORKDIR /root RUN pip install --no-cache-dir -U \ smclarify \ "sagemaker>=2,<3" \ sagemaker-experiments==0.* \ sagemaker-pytorch-training ``` 1. Por fim, instale o binário paralelo de dados SageMaker AI e as dependências restantes. ``` RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \ apt-get update && apt-get install -y --no-install-recommends \ jq \ libhwloc-dev \ libnuma1 \ libnuma-dev \ libssl1.1 \ libtool \ hwloc \ && rm -rf /var/lib/apt/lists/* RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY} ``` 1. Depois de concluir a criação do Dockerfile, consulte [Adaptando seu próprio contêiner de treinamento para aprender a criar o contêiner](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) do Docker, hospedá-lo no Amazon ECR e executar um trabalho de treinamento usando o SDK do Python. SageMaker O código de exemplo a seguir mostra um Dockerfile completo depois de combinar todos os blocos de código anteriores. ``` # This file creates a docker image with minimum dependencies to run SageMaker AI data parallel training FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04 # Set appropiate versions and location for components ARG PYTORCH_VERSION=1.10.2 ARG PYTHON_SHORT_VERSION=3.8 ARG EFA_VERSION=1.14.1 ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl ARG CONDA_PREFIX="/opt/conda" ARG BRANCH_OFI=1.1.3-aws # Set ENV variables required to build PyTorch ENV TORCH_CUDA_ARCH_LIST="3.7 5.0 7.0+PTX 8.0" ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all" ENV NCCL_VERSION=2.10.3 # Add OpenMPI to the path. ENV PATH /opt/amazon/openmpi/bin:$PATH # Add Conda to path ENV PATH $CONDA_PREFIX/bin:$PATH # Set this enviroment variable for SageMaker AI to launch SMDDP correctly. ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main # Add enviroment variable for processes to be able to call fork() ENV RDMAV_FORK_SAFE=1 # Indicate the container type ENV DLC_CONTAINER_TYPE=training # Add EFA and SMDDP to LD library path ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH" ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH # Install basic dependencies to download and build other dependencies RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \ apt-get update && apt-get install -y --no-install-recommends \ curl \ wget \ git \ && rm -rf /var/lib/apt/lists/* # Install EFA. # This is required for SMDDP backend communication RUN DEBIAN_FRONTEND=noninteractive apt-get update RUN mkdir /tmp/efa \ && cd /tmp/efa \ && curl --silent -O https://efa-installer.amazonaws.com/aws-efa-installer-${EFA_VERSION}.tar.gz \ && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \ && cd aws-efa-installer \ && ./efa_installer.sh -y --skip-kmod -g \ && rm -rf /tmp/efa # Install Conda RUN curl -fsSL -v -o ~/miniconda.sh -O https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh && \ chmod +x ~/miniconda.sh && \ ~/miniconda.sh -b -p $CONDA_PREFIX && \ rm ~/miniconda.sh && \ $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \ $CONDA_PREFIX/bin/conda clean -ya # Install PyTorch. # Start with dependencies listed in official PyTorch dockerfile # https://github.com/pytorch/pytorch/blob/master/Dockerfile RUN DEBIAN_FRONTEND=noninteractive \ apt-get install -y --no-install-recommends \ build-essential \ ca-certificates \ ccache \ cmake \ git \ libjpeg-dev \ libpng-dev && \ rm -rf /var/lib/apt/lists/* # Setup ccache RUN /usr/sbin/update-ccache-symlinks RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache # Common dependencies for PyTorch RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses # Linux specific dependency for PyTorch RUN conda install -c pytorch magma-cuda113 # Clone PyTorch RUN --mount=type=cache,target=/opt/ccache \ cd / \ && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION} # Note that we need to use the same NCCL version for PyTorch and OFI plugin. # To enforce that, install NCCL from source before building PT and OFI plugin. # Install NCCL. # Required for building OFI plugin (OFI requires NCCL's header files and library) RUN cd /pytorch/third_party/nccl \ && rm -rf nccl \ && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \ && cd nccl \ && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \ && make pkg.txz.build \ && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1 # Build and install PyTorch. RUN cd /pytorch \ && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \ python setup.py install \ && rm -rf /pytorch RUN ccache -C # Build and install OFI plugin. \ # It is required to use libfabric. RUN DEBIAN_FRONTEND=noninteractive apt-get update \ && apt-get install -y --no-install-recommends \ autoconf \ automake \ libtool RUN mkdir /tmp/efa-ofi-nccl \ && cd /tmp/efa-ofi-nccl \ && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \ && cd aws-ofi-nccl \ && ./autogen.sh \ && ./configure --with-libfabric=/opt/amazon/efa \ --with-mpi=/opt/amazon/openmpi \ --with-cuda=/usr/local/cuda \ --with-nccl=$CONDA_PREFIX \ && make \ && make install \ && rm -rf /tmp/efa-ofi-nccl # Build and install Torchvision RUN pip install --no-cache-dir -U \ packaging \ mpi4py==3.0.3 RUN cd /tmp \ && git clone https://github.com/pytorch/vision.git -b v0.9.1 \ && cd vision \ && BUILD_VERSION="0.9.1+cu111" python setup.py install \ && cd /tmp \ && rm -rf vision # Install OpenSSH. # Required for MPI to communicate between containers, allow OpenSSH to talk to containers without asking for confirmation RUN apt-get update \ && apt-get install -y --allow-downgrades --allow-change-held-packages --no-install-recommends \ && apt-get install -y --no-install-recommends openssh-client openssh-server \ && mkdir -p /var/run/sshd \ && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \ && echo " StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \ && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \ && rm -rf /var/lib/apt/lists/* # Configure OpenSSH so that nodes can communicate with each other RUN mkdir -p /var/run/sshd && \ sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd RUN rm -rf /root/.ssh/ && \ mkdir -p /root/.ssh/ && \ ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \ cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \ && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config # Install PT S3 plugin. # Required to efficiently access datasets in Amazon S3 RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU} RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt # Install libboost from source. # This package is needed for smdataparallel functionality (for networking asynchronous IO). WORKDIR / RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \ && tar -xzf boost_1_73_0.tar.gz \ && cd boost_1_73_0 \ && ./bootstrap.sh \ && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \ && cd .. \ && rm -rf boost_1_73_0.tar.gz \ && rm -rf boost_1_73_0 \ && cd ${CONDA_PREFIX}/include/boost # Install SageMaker AI PyTorch training. WORKDIR /root RUN pip install --no-cache-dir -U \ smclarify \ "sagemaker>=2,<3" \ sagemaker-experiments==0.* \ sagemaker-pytorch-training # Install SageMaker AI data parallel binary (SMDDP) # Start with dependencies RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \ apt-get update && apt-get install -y --no-install-recommends \ jq \ libhwloc-dev \ libnuma1 \ libnuma-dev \ libssl1.1 \ libtool \ hwloc \ && rm -rf /var/lib/apt/lists/* # Install SMDDP RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY} ``` **dica** Para obter mais informações gerais sobre a criação de um Dockerfile personalizado para treinamento em SageMaker IA, consulte [Use seus próprios algoritmos de treinamento](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html). **dica** Se você quiser estender o Dockerfile personalizado para incorporar a biblioteca paralela do modelo SageMaker AI, consulte. [Crie seu próprio contêiner Docker com a biblioteca paralela de modelos SageMaker distribuídos](model-parallel-sm-sdk.md#model-parallel-bring-your-own-container) # Exemplos da biblioteca de paralelismo de dados da Amazon SageMaker AI Esta página fornece notebooks Jupyter que apresentam exemplos de implementação da biblioteca de paralelismo de dados distribuídos de SageMaker IA (SMDDP) para executar trabalhos de treinamento distribuídos em IA. SageMaker ## Blogs e estudos de caso Os blogs a seguir discutem estudos de caso a respeito do uso da biblioteca SMDDP. **Blogs do SMDDP v2** + [Permita um treinamento mais rápido com a biblioteca paralela de dados de SageMaker IA da Amazon](https://aws.amazon.com/blogs/machine-learning/enable-faster-training-with-amazon-sagemaker-data-parallel-library/), *Blog de AWS Machine Learning* (05 de dezembro de 2023) **Blogs da SMDDP v1** + [Como treinei 10 TB para difusão estável em SageMaker IA no](https://medium.com/@emilywebber/how-i-trained-10tb-for-stable-diffusion-on-sagemaker-39dcea49ce32) *Medium* (29 de novembro de 2022) + [Execute o PyTorch Lightning e o PyTorch DDP nativo no Amazon SageMaker Training, com o Amazon Search](https://aws.amazon.com/blogs/machine-learning/run-pytorch-lightning-and-native-pytorch-ddp-on-amazon-sagemaker-training-featuring-amazon-search/), *AWS Machine Learning Blog* (18 de agosto de 2022) + [Treinamento YOLOv5 em AWS with PyTorch and the SageMaker AI Distributed Data Parallel Library](https://medium.com/@sitecao/training-yolov5-on-aws-with-pytorch-and-sagemaker-distributed-data-parallel-library-a196ab01409b), *Medium* (6 de maio de 2022) + [Acelere o treinamento de EfficientNet modelos em SageMaker IA com PyTorch a biblioteca paralela de dados distribuídos de SageMaker IA](https://medium.com/@dangmz/speed-up-efficientnet-model-training-on-amazon-sagemaker-with-pytorch-and-sagemaker-distributed-dae4b048c01a), *Medium* (21 de março de 2022) + [Acelere o EfficientNet treinamento AWS com a biblioteca paralela de dados distribuídos de SageMaker IA](https://towardsdatascience.com/speed-up-efficientnet-training-on-aws-by-up-to-30-with-sagemaker-distributed-data-parallel-library-2dbf6d1e18e8), *Towards Data Science* (12 de janeiro de 2022) + [Hyundai reduz o tempo de treinamento de modelos de ML para modelos de direção autônoma usando Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/hyundai-reduces-training-time-for-autonomous-driving-models-using-amazon-sagemaker/), *AWS Machine Learning Blog* (25 de junho de 2021) + [Treinamento distribuído: Treine o BART/T5 para resumir usando Transformers e Amazon AI, SageMaker o site](https://huggingface.co/blog/sagemaker-distributed-training-seq2seq) Hugging Face (8 de abril de *2021*) ## 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/data_parallel`: **nota** Clone e execute os notebooks de exemplo no SageMaker AI ML a seguir. IDEs [SageMaker AI 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 AI](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/data_parallel ``` **Exemplos de SMDDP v2** + [Treine o Llama 2 usando a biblioteca paralela de dados distribuídos de SageMaker IA (SMDDP) e DeepSpeed](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/data_parallel/deepspeed/llama2/smddp_deepspeed_example.ipynb) + [Treine o Falcon usando a biblioteca paralela de dados distribuídos de SageMaker IA (SMDDP) e o paralelismo de dados PyTorch totalmente fragmentado (FSDP)](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/data_parallel/fully_sharded_data_parallel/falcon/smddp_fsdp_example.ipynb) **Exemplos da SMDDP v1** + [CNN com PyTorch e a biblioteca de SageMaker paralelismo de dados de IA](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/data_parallel/mnist/pytorch_smdataparallel_mnist_demo.ipynb) + [BERT com PyTorch e a biblioteca de SageMaker paralelismo de dados de IA](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/data_parallel/bert/pytorch_smdataparallel_bert_demo.ipynb) + [CNN com TensorFlow 2.3.1 e a biblioteca de paralelismo de dados SageMaker AI](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/tensorflow/data_parallel/mnist/tensorflow2_smdataparallel_mnist_demo.html) + [BERT com TensorFlow 2.3.1 e a biblioteca de SageMaker paralelismo de dados AI](https://sagemaker-examples.readthedocs.io/en/latest/training/distributed_training/tensorflow/data_parallel/bert/tensorflow2_smdataparallel_bert_demo.html) + [HuggingFace Treinamento paralelo de dados distribuídos PyTorch em SageMaker IA - Resposta distribuída a perguntas](https://github.com/huggingface/notebooks/blob/master/sagemaker/03_distributed_training_data_parallelism/sagemaker-notebook.ipynb) + [HuggingFace Treinamento paralelo de dados distribuídos PyTorch em SageMaker IA - resumo de texto distribuído](https://github.com/huggingface/notebooks/blob/master/sagemaker/08_distributed_summarization_bart_t5/sagemaker-notebook.ipynb) + [HuggingFace Treinamento paralelo de dados distribuídos TensorFlow em SageMaker IA](https://github.com/huggingface/notebooks/blob/master/sagemaker/07_tensorflow_distributed_training_data_parallelism/sagemaker-notebook.ipynb) # Dicas de configuração para a biblioteca de paralelismo de dados distribuídos de SageMaker IA Leia as dicas a seguir antes de usar a biblioteca de paralelismo de dados distribuídos de SageMaker IA (SMDDP). Essa lista inclui dicas que são aplicáveis a todos os frameworks. **Topics** + [Pré-processamento de dados](#data-parallel-config-dataprep) + [Nós únicos versus múltiplos](#data-parallel-config-multi-node) + [Eficiência de ajuste de escala de depuração com o Depurador](#data-parallel-config-debug) + [Tamanho do lote](#data-parallel-config-batch-size) + [Opções personalizadas de MPI](#data-parallel-config-mpi-custom) + [Use a Amazon FSx e configure uma capacidade ideal de armazenamento e taxa de transferência](#data-parallel-config-fxs) ## Pré-processamento de dados Se você pré-processa dados durante o treinamento usando uma biblioteca externa que utiliza a CPU, você pode se deparar com um gargalo de CPU porque o AI SageMaker distributed data parallel usa a CPU para operações. `AllReduce` Você pode melhorar o tempo de treinamento movendo as etapas de pré-processamento para uma biblioteca que usa GPUs ou concluindo todo o pré-processamento antes do treinamento. ## Nós únicos versus múltiplos Recomendamos o uso dessa biblioteca com vários nós. A biblioteca pode ser usada com uma configuração de um único host e vários dispositivos (por exemplo, uma única instância de computação de ML com vários GPUs); no entanto, quando você usa dois ou mais nós, a `AllReduce` operação da biblioteca proporciona uma melhoria significativa no desempenho. Além disso, em um único host, NVLink já contribui para a `AllReduce` eficiência no nó. ## Eficiência de ajuste de escala de depuração com o Depurador Você pode usar o Amazon SageMaker Debugger para monitorar e visualizar a utilização da CPU e da GPU e outras métricas de interesse durante o treinamento. Você pode usar as [regras integradas](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html) do Depurador para monitorar problemas de performance de computação, como `CPUBottleneck`, `LoadBalancing` e `LowGPUUtilization`. Você pode especificar essas regras com as [configurações do Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configuration-for-debugging.html) ao definir um estimador de SDK do Amazon Python SageMaker . Se você usa AWS CLI e AWS SDK para Python (Boto3) para treinar em SageMaker IA, você pode habilitar o Debugger conforme mostrado em [Configurar o depurador usando a API da SageMaker Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html). SageMaker [Para ver um exemplo usando o Debugger em um trabalho de SageMaker treinamento, você pode consultar um dos exemplos de cadernos no repositório Notebook Examples. SageMaker GitHub ](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger) [Para saber mais sobre o Debugger, consulte Amazon Debugger. SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/train-debugger.html) ## Tamanho do lote No treinamento distribuído, à medida que mais nós são adicionados, os tamanhos dos lotes devem aumentar proporcionalmente. Para melhorar a velocidade de convergência à medida que você adiciona mais nós ao seu trabalho de treinamento e aumenta o tamanho do lote global, aumente a taxa de aprendizado. Uma maneira de conseguir isso é usar um aquecimento gradual da taxa de aprendizado em que a taxa de aprendizado aumenta de um valor pequeno para um valor grande à medida que o trabalho de treinamento progride. Essa rampa evita um aumento repentino da taxa de aprendizado, permitindo uma convergência íntegra no início do treinamento. Por exemplo, você pode usar uma *regra em escala linear* em que cada vez que o tamanho do minilote é multiplicado por k, a taxa de aprendizado também é multiplicada por k. Para saber mais sobre essa técnica, consulte o paper de pesquisa [Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour](https://arxiv.org/pdf/1706.02677.pdf), Seções 2 e 3. ## Opções personalizadas de MPI A biblioteca paralela de dados distribuídos de SageMaker IA emprega a Interface de Passagem de Mensagens (MPI), um padrão popular para gerenciar a comunicação entre nós em um cluster de alto desempenho, e usa a biblioteca NCCL da NVIDIA para comunicação em nível de GPU. Quando você usa a biblioteca paralela de dados com um TensorFlow ou Pytorch`Estimator`, o respectivo contêiner configura o ambiente MPI e executa o `mpirun` comando para iniciar trabalhos nos nós do cluster. Você pode definir operações MPI personalizadas usando o parâmetro `custom_mpi_options` no `Estimator`. Todas `mpirun` as bandeiras passadas nesse campo são adicionadas ao `mpirun` comando e executadas pela SageMaker IA para treinamento. Por exemplo, você pode definir o parâmetro `distribution` de um `Estimator` usando o seguinte para usar a variável [https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/env.html#nccl-debug](https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/env.html#nccl-debug) para imprimir a versão NCCL no início do programa: ``` distribution = {'smdistributed':{'dataparallel':{'enabled': True, "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION"}}} ``` ## Use a Amazon FSx e configure uma capacidade ideal de armazenamento e taxa de transferência [Ao treinar um modelo em vários nós com paralelismo de dados distribuídos, é altamente recomendável usá-lo FSx para o Lustre.](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) FSx A Amazon é um serviço de armazenamento escalável e de alto desempenho que oferece suporte ao armazenamento compartilhado de arquivos com uma taxa de transferência mais rápida. Usando o FSx armazenamento da Amazon em grande escala, você pode obter uma velocidade de carregamento de dados mais rápida nos nós de computação. Normalmente, com o paralelismo de dados distribuídos, você esperaria que a produtividade total do treinamento escalasse quase linearmente com o número de. GPUs No entanto, se você usar um armazenamento inadequado da FSx Amazon, o desempenho do treinamento poderá diminuir devido à baixa taxa de transferência da Amazon. FSx Por exemplo, se você usar o tipo de [implantação **SCRATCH\$12** do sistema de FSx arquivos da Amazon](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html#fsx-aggregate-perf) com a capacidade mínima de armazenamento de 1,2 TiB, a I/O capacidade de transferência é 240. MB/s. Amazon FSx storage works in a way that you can assign physical storage devices, and the more devices assigned, the larger throughput you get. The smallest storage increment for the SRATCH\$12 type is 1.2 TiB, and the corresponding throughput gain is 240 MB/s Suponha que você tem um modelo para treinar em um cluster de 4 nós em um conjunto de dados de 100 GB. Com um determinado tamanho do lote otimizado para o cluster, suponha que o modelo possa concluir uma epoch em cerca de 30 segundos. Nesse caso, a I/O velocidade mínima necessária é de aproximadamente 3 GB/s (100 GB/30 s). Aparentemente, esse é um requisito de taxa de transferência muito maior do que 240 problemas de MB/s. With such a limited Amazon FSx capacity, scaling your distributed training job up to larger clusters might aggravate I/O gargalo; a taxa de transferência do treinamento de modelos pode melhorar em épocas posteriores à medida que o cache aumenta, mas a taxa de transferência da Amazon FSx ainda pode ser um gargalo. Para aliviar esses problemas de I/O gargalo, você deve aumentar o tamanho do FSx armazenamento da Amazon para obter uma maior capacidade de processamento. Normalmente, para encontrar uma taxa de I/O transferência ideal, você pode experimentar diferentes capacidades de taxa de FSx transferência da Amazon, atribuindo uma taxa de transferência igual ou um pouco menor do que sua estimativa, até descobrir que ela é suficiente para resolver os problemas de gargalo. I/O No caso do exemplo acima mencionado, o FSx armazenamento da Amazon com taxa de GB/s transferência de 2,4 e cache de 67 GB de RAM seria suficiente. Se o sistema de arquivos tiver uma throughput ideal, a throughput de treinamento de modelos deve atingir o máximo imediatamente ou após a primeira epoch, à medida que o cache se acumula. Para saber mais sobre como aumentar os tipos FSx de armazenamento e implantação da Amazon, consulte as seguintes páginas na *documentação do Amazon FSx for Lustre:* + [Como aumentar a capacidade de armazenamento](https://docs.aws.amazon.com/fsx/latest/LustreGuide/managing-storage-capacity.html#increase-storage-capacity) + [Performance do sistema de arquivos agregados](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html#fsx-aggregate-perf) # Perguntas frequentes sobre a biblioteca de paralelismo de dados distribuídos do Amazon SageMaker AI Use o seguinte para encontrar respostas às perguntas mais frequentes sobre a biblioteca SMDDP: **P: Ao usar a biblioteca, como as instâncias `allreduce` de CPU compatíveis são gerenciadas? Preciso criar clusters heterogêneos de CPU-GPU ou o serviço SageMaker AI cria C5s extras para tarefas que usam a biblioteca de SMDDP?** A biblioteca de SMDDP atende apenas a instâncias de GPU, mais especificamente instâncias P4d e P4de com GPUs NVIDIA A100 e EFA. Nenhuma instância adicional de C5 ou CPU é iniciada. Se sua tarefa de treinamento do SageMaker AI for em um cluster P4d de oito nós, serão usadas somente oito instâncias `ml.p4d.24xlarge`. Nenhuma instância adicional é provisionada. **P: Tenho um trabalho de treinamento que leva 5 dias em uma única instância `ml.p3.24xlarge` com um conjunto de hiperparâmetros H1 (taxa de aprendizado, tamanho do lote, otimizador, etc.). Usar a biblioteca de paralelismo de dados do SageMaker AI e um cluster cinco vezes maior é suficiente para alcançar uma aceleração aproximada de cinco vezes? Ou eu tenho que revisitar seus hiperparâmetros de treinamento depois de ativar a biblioteca SMDDP? ** A biblioteca altera o tamanho geral do lote. O novo tamanho geral do lote é dimensionado linearmente com o número de instâncias de treinamento usadas. Como resultado disso, hiperparâmetros, como a taxa de aprendizado, precisam ser alterados para garantir a convergência. **P: A biblioteca SMDDP oferece apoio ao Spot?** Sim. Você pode usar o treinamento gerenciado de spots Você especifica o caminho para o arquivo do ponto de verificação no trabalho de treinamento do SageMaker. Você salva e restaura os pontos de verificação no seu script de treinamento, conforme mencionado nas últimas etapas de [Use a biblioteca SMDDP em seu script de TensorFlow treinamento (obsoleto)](data-parallel-modify-sdp-tf2.md) e [Use a biblioteca SMDDP em seu PyTorch script de treinamento](data-parallel-modify-sdp-pt.md). **P: A biblioteca SMDDP é relevante em uma configuração de um único host e vários dispositivos?** A biblioteca pode ser usada no treinamento de vários dispositivos com um único host, mas a biblioteca oferece melhorias de desempenho somente no treinamento com vários hosts. **P: Onde o conjunto de dados de treinamento deve ser armazenado?** O conjunto de dados de treinamento pode ser armazenado em um bucket do Amazon S3 ou em um drive do Amazon FSx. Consulte este [documento para conhecer vários sistemas de arquivos de entrada compatíveis para um trabalho de treinamento](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html#sagemaker.inputs.FileSystemInput). **P: Ao usar a biblioteca SMDDP, é obrigatório ter dados de treinamento no FSx para Lustre? O Amazon EFS e o Amazon S3 podem ser usados?** Geralmente, recomendamos que você use o Amazon FSx por causa de sua menor latência e maior taxa de throughput. Se você preferir, poderá usar o Amazon EFS ou o Amazon S3. **P: A biblioteca pode ser usada com nós de CPU?** Não. Para encontrar os tipos de instância compatíveis com a biblioteca SMDDP, consulte [Tipos de instâncias compatíveis](distributed-data-parallel-support.md#distributed-data-parallel-supported-instance-types). **P: Quais frameworks e versões de frameworks são atualmente compatíveis com a biblioteca SMDDP na inicialização?** Atualmente, a biblioteca SMDDP é compatível com PyTorch v1.6.0, ou posterior e TensorFlow v2.3.0, ou posterior. Ela não oferece apoio ao TensorFlow 1.x. Para obter mais informações sobre qual versão da biblioteca SMDDP está empacotada em contêineres de aprendizado profundo da AWS, consulte [Notas de lançamento de contêineres de aprendizado profundo](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/dlc-release-notes.html). **P: A biblioteca tem compatibilidade com AMP?** Sim, a biblioteca SMDDP oferece apoio imediato para Precisão mista automática (AMP). Nenhuma ação adicional é necessária para usar o AMP além das modificações no nível do framework no seu script de treinamento. Se os gradientes estiverem em FP16, a biblioteca de paralelismo de dados do SageMaker AI executará a operação `AllReduce` em FP16. Para obter mais informações sobre como implementar as APIs de AMP no seu script de treinamento, consulte os seguintes recursos: + [Frameworks - PyTorch](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#pytorch) na *documentação de desempenho de aprendizado profundo da NVIDIA* + [Frameworks - TensorFlow](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#tensorflow) na *documentação de desempenho de aprendizado profundo da NVIDIA* + [Precisão mista automática para aprendizado profundo](https://developer.nvidia.com/automatic-mixed-precision) nos *documentos de desenvolvedores da NVIDIA* + [Apresentando a precisão mista automática nativa do PyTorch para um treinamento mais rápido em GPUs NVIDIA](https://pytorch.org/blog/accelerating-training-on-nvidia-gpus-with-pytorch-automatic-mixed-precision/) no *blog do PyTorch* + [APIs de precisão mista do TensorFlow](https://www.tensorflow.org/guide/mixed_precision) na *documentação do TensorFlow* **P: Como posso identificar se meu trabalho de treinamento distribuído está lento devido ao gargalo de E/S?** Com um cluster maior, o trabalho de treinamento exige mais throughput de E/S e, portanto, a throughput de treinamento pode levar mais tempo (mais períodos) para atingir o desempenho máximo. Isso indica que a I/O está sendo congestionada e que o cache é mais difícil de construir à medida que você aumenta a escala dos nós (maior exigência de throughput e topologia de rede mais complexa). Para obter mais informações sobre o monitoramento da throughput do Amazon FSx no CloudWatch, consulte Monitoramento do [FSx for Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/monitoring_overview.html) no *Guia do usuário do FSx for Lustre.* **P: Como resolvo gargalos de E/S ao executar um trabalho de treinamento distribuído com paralelismo de dados?** É altamente recomendável que você use o Amazon FSx como seu canal de dados se estiver usando o Amazon S3. Se você já usa o Amazon FSx, mas ainda tem problemas de gargalo de E/S, talvez tenha configurado seu sistema de arquivos Amazon FSx com uma baixa throughput de E/S e uma pequena capacidade de armazenamento. Para obter mais informações sobre como calcular e escolher o dimensionamento certo da capacidade de throughput de E/S, consulte [Use a Amazon FSx e configure uma capacidade ideal de armazenamento e taxa de transferência](data-parallel-config.md#data-parallel-config-fxs). **P: (Para a biblioteca v1.4.0 ou posterior) Como resolvo o erro `Invalid backend` ao inicializar o grupo de processos.** Se você encontrar a mensagem de erro `ValueError: Invalid backend: 'smddp'` ao chamar `init_process_group`, é devido a uma alteração interruptiva na biblioteca SMDDP v1.4.0 e versões posteriores. Você deve importar o cliente PyTorch da biblioteca, `smdistributed.dataparallel.torch.torch_smddp`, que registra `smddp` como backend do PyTorch. Para saber mais, consulte [Use a biblioteca SMDDP em seu PyTorch script de treinamento](data-parallel-modify-sdp-pt.md). **P: (Para a biblioteca SMDDP v1.4.0 ou posterior), gostaria de chamar os coletivos primitivos da interface [https://pytorch.org/docs/stable/distributed.html](https://pytorch.org/docs/stable/distributed.html). Quais primitivas são compatíveis com o backend `smddp`?** Na v1.4.0, a biblioteca SMDDP é compatível com `all_reduce`, `broadcast`, `reduce`, `all_gather`, e `barrier` da interface `torch.distributed`. **P: (Para a biblioteca SMDDP v1.4.0 ou posterior) Essa nova API funciona com outras classes ou bibliotecas personalizadas de DDP como o Apex DDP? ** A biblioteca SMDDP é testada com outras bibliotecas de paralelismo de dados distribuídos de terceiros e implementações de framework que usam os módulos `torch.distribtued`. É possível usar a biblioteca SMDDP com classes personalizadas de DDP desde que a biblioteca seja compatível com as operações de coletivos usadas pelas classes personalizadas de DDP com a biblioteca SMDDP. Consulte a pergunta anterior para obter uma lista dos coletivos compatíveis. Se você tiver esses casos de uso e precisar de compatibilidade adicional, entre em contato com a equipe do SageMaker AI por meio do [AWS Support Center](https://console.aws.amazon.com/support/) ou dos [fóruns de desenvolvedores da AWS para o Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285). **P: A biblioteca SMDDP é compatível com a opção ‘traga seu próprio contêiner’ (BYOC)? Em caso afirmativo, como faço para instalar a biblioteca e executar um trabalho de treinamento distribuído escrevendo um Dockerfile personalizado?** Se você quiser integrar a biblioteca SMDDP e suas dependências mínimas em seu próprio contêiner do Docker, o BYOC é a abordagem certa. Você pode criar seu próprio contêiner usando o arquivo binário da biblioteca. O processo recomendado é escrever um Dockerfile personalizado com a biblioteca e as respectivas dependências, criar o contêiner do Docker, hospedá-lo no Amazon ECR e usar o URI da imagem do ECR para iniciar uma tarefa de treinamento usando a classe genérica de estimadores do SageMaker AI. Para ter mais instruções sobre como preparar um Dockerfile personalizado para treinamento distribuído no SageMaker AI com a biblioteca de SMDDP, consulte [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). # Solução de problemas para treinamento distribuído na Amazon SageMaker AI Se você tiver problemas ao executar um trabalho de treinamento ao usar a biblioteca, use a lista a seguir para tentar solucionar o problema. Se precisar de mais suporte, entre em contato com a equipe de SageMaker IA por meio do [AWS Support Center](https://console.aws.amazon.com/support/) ou dos [fóruns de AWS desenvolvedores do Amazon Amazon SageMaker AI](https://forums.aws.amazon.com/forum.jspa?forumID=285). **Topics** + [Usando dados distribuídos de SageMaker IA paralelamente com o Amazon SageMaker Debugger e os pontos de verificação](#distributed-ts-data-parallel-debugger) + [Um prefixo inesperado anexado às chaves dos parâmetros do modelo](#distributed-ts-data-parallel-pytorch-prefix) + [SageMaker Parada do trabalho de treinamento distribuído por IA durante a inicialização](#distributed-ts-data-parallel-efa-sg) + [SageMaker A IA distribuiu o trabalho de treinamento no final do treinamento](#distributed-ts-data-parallel-stall-at-the-end) + [Observando a degradação da eficiência de escalabilidade devido aos gargalos de produtividade da Amazon FSx](#distributed-ts-data-parallel-fxs-bottleneck) + [SageMaker Trabalho de treinamento distribuído por IA com avisos de depreciação de PyTorch devoluções](#distributed-ts-data-parallel-deprecation-warnings) ## Usando dados distribuídos de SageMaker IA paralelamente com o Amazon SageMaker Debugger e os pontos de verificação Para monitorar gargalos do sistema, criar perfis de operações de estrutura e depurar tensores de saída do modelo para trabalhos de treinamento com IA SageMaker Distributed Data Parallel, use o Amazon Debugger. SageMaker No entanto, ao usar o SageMaker Debugger, o SageMaker AI Distributed Data Parallel e os pontos de verificação de SageMaker IA, você pode ver um erro parecido com o exemplo a seguir. ``` SMDebug Does Not Currently Support Distributed Training Jobs With Checkpointing Enabled ``` Isso ocorre devido a um erro interno entre o Debugger e os pontos de verificação, que ocorre quando você ativa o AI SageMaker Distributed Data Parallel. + Se você habilitar todos os três recursos, o SageMaker Python SDK desativará automaticamente o Debugger passando`debugger_hook_config=False`, o que equivale ao exemplo de estrutura a seguir. `estimator` ``` 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": {"dataparallel": { "enabled": True }}}, checkpoint_s3_uri=checkpoint_s3_bucket, checkpoint_local_path="/opt/ml/checkpoints", debugger_hook_config=False ) ``` + Se você quiser continuar usando o SageMaker AI Distributed Data Parallel e o SageMaker Debugger, uma solução alternativa é adicionar manualmente funções de ponto de verificação ao seu script de treinamento em vez de especificar os `checkpoint_s3_uri` parâmetros e do estimador. `checkpoint_local_path` Para obter mais informações sobre como configurar o ponto de verificação manual em um script de treinamento, consulte [Salvando pontos de verificação](distributed-troubleshooting-model-parallel.md#distributed-ts-model-parallel-checkpoints). ## Um prefixo inesperado anexado às chaves dos parâmetros do modelo Para trabalhos de treinamento PyTorch distribuídos, um prefixo inesperado (`model`por exemplo) pode ser anexado às `state_dict` chaves (parâmetros do modelo). A biblioteca paralela de dados de SageMaker IA não altera nem acrescenta diretamente nenhum nome de parâmetro do modelo quando os trabalhos de PyTorch treinamento salvam artefatos do modelo. O PyTorch treinamento distribuído altera os nomes no `state_dict` para acessar a rede, precedendo o prefixo. Se você encontrar algum problema de falha de modelo devido a nomes de parâmetros diferentes ao usar a biblioteca paralela de dados de SageMaker IA e o ponto de verificação para PyTorch treinamento, adapte o código de exemplo a seguir para remover o prefixo na etapa em que você carrega os pontos de verificação em seu script de treinamento. ``` state_dict = {k.partition('model.')[2]:state_dict[k] for k in state_dict.keys()} ``` Isso considera cada chave `state_dict` como um valor de string, separa a string na primeira ocorrência de `'model.'` e pega o terceiro item da lista (com índice 2) da string particionada. Para obter mais informações sobre o problema do prefixo, consulte um tópico de discussão em [Nomes de parâmetros de prefixo no modelo salvo se treinados por](https://discuss.pytorch.org/t/prefix-parameter-names-in-saved-model-if-trained-by-multi-gpu/494) várias GPUs? no *fórum de PyTorch discussão*. Para obter mais informações sobre os PyTorch métodos para salvar e carregar modelos, consulte [Salvando e carregando modelos entre dispositivos](https://pytorch.org/tutorials/beginner/saving_loading_models.html#saving-loading-model-across-devices) na *PyTorchdocumentação*. ## SageMaker Parada do trabalho de treinamento distribuído por IA durante a inicialização Se seu trabalho de treinamento paralelo de dados distribuídos de SageMaker IA parar durante a inicialização ao usar instâncias habilitadas para EFA, isso pode ser devido a uma configuração incorreta no grupo de segurança da sub-rede VPC usada para o trabalho de treinamento. O EFA exige uma configuração de grupo de segurança adequada para habilitar o tráfego entre os nós. **Para configurar as regras de entrada e saída dos grupos de segurança:** 1. Faça login no Console de gerenciamento da AWS e abra o console da Amazon VPC em. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 1. No painel de navegação à esquerda, escolha **Grupos de Segurança**. 1. Selecione o grupo de segurança vinculado à sub-rede da VPC que você usa para treinamento. 1. Na seção **Detalhes**, copie a **ID do grupo de segurança**. 1. Na guia **Regras de entrada**, selecione **Editar regras de entrada**. 1. Na página **Editar regras de entrada**, faça o seguinte: 1. Escolha **Adicionar regra**. 1. Para **Tipo**, escolha **Todo o tráfego**. 1. Em **Fonte**, escolha **Personalizado**, cole o ID do grupo de segurança na caixa de pesquisa e selecione o grupo de segurança que aparece. 1. Escolha **Salvar regras** para concluir a configuração da regra de entrada para o grupo de segurança. 1. Na guia **Regras de saída**, escolha **Editar regras de saída**. 1. Repita as etapas 6 e 7 para adicionar a mesma regra como regra de saída. Depois de concluir as etapas anteriores para configurar o grupo de segurança com as regras de entrada e saída, execute novamente o trabalho de treinamento e verifique se o problema de interrupção foi resolvido. Para obter mais informações sobre como configurar grupos de segurança, consulte [Grupos de segurança para sua VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) e [Elastic Fabric Adapter](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html). ## SageMaker A IA distribuiu o trabalho de treinamento no final do treinamento Uma das causas raiz dos problemas de paralisação no final do treinamento é uma não-correspondência no número de lotes que são processados por época em diferentes classificações. Todos os workers (GPUs) sincronizam seus gradientes locais na passagem para trás para garantir que todos tenham a mesma cópia do modelo no final da iteração em lote. Se os tamanhos dos lotes forem atribuídos de forma desigual a diferentes grupos de operadores durante a época final do treinamento, o trabalho de treinamento será interrompido. Por exemplo, enquanto um grupo de operadores (grupo A) termina de processar todos os lotes e sai do ciclo de treinamento, outro grupo de operadores (grupo B) começa a processar outro lote e ainda espera que a comunicação do grupo A sincronize os gradientes. Isso faz com que o grupo B espere pelo grupo A, que já concluiu o treinamento e não tem nenhum gradiente para sincronizar. Portanto, ao configurar seu conjunto de dados de treinamento, é importante que cada operador obtenha o mesmo número de amostras de dados para que cada operador passe pelo mesmo número de lotes durante o treinamento. Certifique-se de que cada classificação receba o mesmo número de lotes para evitar esse problema de paralisação. ## Observando a degradação da eficiência de escalabilidade devido aos gargalos de produtividade da Amazon FSx Uma causa potencial da redução da eficiência de escalabilidade é o limite de FSx produtividade. Se você observar uma queda repentina na eficiência de escalabilidade ao mudar para um cluster de treinamento maior, tente usar um sistema de arquivos maior FSx para Lustre com um limite de taxa de transferência mais alto. Para obter mais informações, consulte [Desempenho agregado do sistema de arquivos](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html#fsx-aggregate-perf) e [Gerenciamento da capacidade de armazenamento e taxa de transferência no Guia](https://docs.aws.amazon.com/fsx/latest/LustreGuide/managing-storage-capacity.html) do usuário do *Amazon FSx for Lustre.* ## SageMaker Trabalho de treinamento distribuído por IA com avisos de depreciação de PyTorch devoluções Desde a versão 1.4.0, a biblioteca de paralelismo de dados distribuídos de SageMaker IA funciona como um back-end de distribuídos. PyTorch Devido à alteração significativa do uso da biblioteca com PyTorch, você pode encontrar uma mensagem de aviso de que o `smdistributed` APIs pacote PyTorch distribuído está obsoleto. A mensagem de aviso deve ser semelhante à seguinte: ``` smdistributed.dataparallel.torch.dist is deprecated in the SageMaker AI distributed data parallel library v1.4.0+. Please use torch.distributed and specify 'smddp' as a backend when initializing process group as follows: torch.distributed.init_process_group(backend='smddp') For more information, see the library's API documentation at https://docs.aws.amazon.com/sagemaker/latest/dg/data-parallel-modify-sdp-pt.html ``` Na versão 1.4.0 e posterior, a biblioteca só precisa ser importada uma vez na parte superior do script de treinamento e definida como back-end durante a PyTorch inicialização distribuída. Com a única linha de especificação de back-end, você pode manter seu script de PyTorch treinamento inalterado e usar diretamente os módulos PyTorch distribuídos. Veja [Use a biblioteca SMDDP em seu PyTorch script de treinamento](data-parallel-modify-sdp-pt.md) para saber mais sobre as mudanças mais recentes e a nova forma de usar a biblioteca com PyTorch. # SageMaker Notas de lançamento da biblioteca de paralelismo de dados de IA Consulte as notas de versão a seguir para acompanhar as atualizações mais recentes da biblioteca de paralelismo de dados distribuídos de SageMaker IA (SMDDP). ## A biblioteca de paralelismo de dados distribuídos de SageMaker IA v2.5.0 *Data: 17 de outubro de 2024* **Novos recursos** + Foi adicionado suporte para PyTorch v2.4.1 com CUDA v12.1. **Integração em contêineres Docker distribuídos pela biblioteca de paralelismo de modelos de SageMaker IA (SMP)** Essa versão da biblioteca SMDDP foi migrada para [A biblioteca de paralelismo de SageMaker modelos v2.6.0](model-parallel-release-notes.md#model-parallel-release-notes-20241017). ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121 ``` Para regiões em que as imagens do Docker SMP estão disponíveis, consulte [Regiões da AWS](distributed-model-parallel-support-v2.md#distributed-model-parallel-availablity-zone-v2). **Arquivo binário desta versão** Baixe ou instale a biblioteca usando a seguinte URL: ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.4.1/cu121/2024-10-09/smdistributed_dataparallel-2.5.0-cp311-cp311-linux_x86_64.whl ``` ## A biblioteca de paralelismo de dados distribuídos de SageMaker IA v2.3.0 *Data: 11 de junho de 2024* **Novos recursos** + Foi adicionado suporte para PyTorch v2.3.0 com CUDA v12.1 e Python v3.11. + Foi adicionado suporte para o PyTorch Lightning v2.2.5. Isso é integrado ao contêiner da estrutura de SageMaker IA para PyTorch v2.3.0. + Adicionada a validação do tipo de instância durante a importação para evitar o carregamento da biblioteca SMDDP em tipos de instância não compatíveis. Para obter uma lista de tipos de instância compatíveis com a biblioteca SMDDP, consulte [Estruturas e tipos Regiões da AWS de instâncias compatíveis](distributed-data-parallel-support.md). **Integração com contêineres de estrutura de SageMaker IA** Essa versão da biblioteca SMDDP é migrada para o seguinte contêiner do [SageMaker AI](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) Framework. + PyTorch v2.3.0 ``` 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.3.0-gpu-py311-cu121-ubuntu20.04-sagemaker ``` Para obter uma lista completa das versões da biblioteca SMDDP e dos contêineres pré-criados, consulte [Estruturas e tipos Regiões da AWS de instâncias compatíveis](distributed-data-parallel-support.md). **Arquivo binário desta versão** Baixe ou instale a biblioteca usando a seguinte URL: ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.3.0/cu121/2024-05-23/smdistributed_dataparallel-2.3.0-cp311-cp311-linux_x86_64.whl ``` **Outras alterações** + A biblioteca SMDDP v2.2.0 está integrada ao contêiner da estrutura de SageMaker IA para v2.2.0. PyTorch ## A biblioteca de paralelismo de dados distribuídos de SageMaker IA v2.2.0 *Data: 4 de março de 2024* **Novos recursos** + Foi adicionado suporte para PyTorch v2.2.0 com CUDA v12.1. **Integração em contêineres Docker distribuídos pela biblioteca de paralelismo de modelos de SageMaker IA (SMP)** Essa versão da biblioteca SMDDP foi migrada para [A biblioteca de paralelismo de SageMaker modelos v2.2.0](model-parallel-release-notes.md#model-parallel-release-notes-20240307). ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.2.0-gpu-py310-cu121 ``` Para regiões em que as imagens do Docker SMP estão disponíveis, consulte [Regiões da AWS](distributed-model-parallel-support-v2.md#distributed-model-parallel-availablity-zone-v2). **Arquivo binário desta versão** Baixe ou instale a biblioteca usando a seguinte URL: ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.2.0/cu121/2024-03-04/smdistributed_dataparallel-2.2.0-cp310-cp310-linux_x86_64.whl ``` ## A biblioteca de paralelismo de dados distribuídos de SageMaker IA v2.1.0 *Data: 1.º de março de 2024* **Novos recursos** + Foi adicionado suporte para PyTorch v2.1.0 com CUDA v12.1. **Correções de bugs** + Corrigido o problema de vazamento de memória da CPU em [SMDDP v2.0.1](#data-parallel-release-notes-20231207). **Integração com contêineres de estrutura de SageMaker IA** [Essa versão da biblioteca SMDDP passou no teste de benchmark e foi migrada para o seguinte SageMaker contêiner do AI Framework.](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) + PyTorch v2.1.0 ``` 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.1.0-gpu-py310-cu121-ubuntu20.04-sagemaker ``` **Integração em contêineres Docker distribuídos pela biblioteca de paralelismo de modelos de SageMaker IA (SMP)** Essa versão da biblioteca SMDDP foi migrada para [A biblioteca de paralelismo de SageMaker modelos v2.1.0](model-parallel-release-notes.md#model-parallel-release-notes-20240206). ``` 658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.1.2-gpu-py310-cu121 ``` Para regiões em que as imagens do Docker SMP estão disponíveis, consulte [Regiões da AWS](distributed-model-parallel-support-v2.md#distributed-model-parallel-availablity-zone-v2). **Arquivo binário desta versão** Baixe ou instale a biblioteca usando a seguinte URL: ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.1.0/cu121/2024-02-04/smdistributed_dataparallel-2.1.0-cp310-cp310-linux_x86_64.whl ``` ## A biblioteca de paralelismo de dados distribuídos de SageMaker IA v2.0.1 *Data: 7 de dezembro de 2023* **Novos recursos** + Foi adicionada uma nova implementação SMDDP de operação `AllGather` coletiva otimizada para recursos AWS computacionais e infraestrutura de rede. Para saber mais, consulte [Operação coletiva do SMDDP `AllGather`](data-parallel-intro.md#data-parallel-allgather). + A operação `AllGather` coletiva SMDDP é compatível com PyTorch FSDP e. DeepSpeed Para saber mais, consulte [Use a biblioteca SMDDP em seu PyTorch script de treinamento](data-parallel-modify-sdp-pt.md). + Suporte adicionado para PyTorch v2.0.1 **Problemas conhecidos** + Há um problema de vazamento de memória da CPU devido ao aumento gradual da memória da CPU durante o treinamento com SMDDP `AllReduce` no modo DDP. **Integração com contêineres de estrutura de SageMaker IA** [Essa versão da biblioteca SMDDP passou no teste de benchmark e foi migrada para o seguinte SageMaker contêiner do AI Framework.](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) + PyTorch v2.0.1 ``` 763104351884.dkr.ecr..amazonaws.com/pytorch-training:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker ``` **Arquivo binário desta versão** Baixe ou instale a biblioteca usando a seguinte URL: ``` https://smdataparallel.s3.amazonaws.com/binary/pytorch/2.0.1/cu118/2023-12-07/smdistributed_dataparallel-2.0.2-cp310-cp310-linux_x86_64.whl ``` **Outras alterações** + A partir desta versão, a documentação da biblioteca SMDDP está totalmente disponível neste *Amazon SageMaker AI Developer* Guide. Em favor do guia completo do desenvolvedor para SMDDP v2 incluído no *Amazon SageMaker AI Developer Guide*, a documentação para a [referência adicional para SMDDP v1.x na](https://sagemaker.readthedocs.io/en/stable/api/training/smd_data_parallel.html) documentação do AI *SageMaker Python* SDK não é mais suportada. [Se você ainda precisar da documentação do SMP v1.x, consulte o seguinte resumo da documentação na documentação do Python SageMaker SDK v2.212.0.](https://sagemaker.readthedocs.io/en/v2.212.0/api/training/distributed.html#the-sagemaker-distributed-data-parallel-library)