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