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á.
# Principais características da biblioteca de SageMaker paralelismo de modelos
A biblioteca de paralelismo de modelos da Amazon SageMaker AI oferece estratégias de distribuição e técnicas de economia de memória, como paralelismo de dados fragmentados, paralelismo de tensores, particionamento de modelos por camadas para agendamento de pipeline e pontos de verificação. As estratégias e técnicas de paralelismo de modelos ajudam a distribuir modelos grandes em vários dispositivos, otimizando a velocidade de treinamento e o consumo de memória. A biblioteca também fornece funções auxiliares, gerenciadores de contexto e funções de wrapper do Python para adaptar seu script de treinamento para particionamento automático ou manual do seu modelo.
Ao implementar o paralelismo de modelos em seu trabalho de treinamento, você mantém o mesmo fluxo de trabalho em duas etapas mostrado na seção [Executar um trabalho de SageMaker treinamento distribuído com](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-use-api.html) paralelismo de modelos. Para adaptar seu script de treinamento, você adicionará zero ou poucas linhas de código adicionais ao seu script de treinamento. Para iniciar um trabalho de treinamento do script de treinamento adaptado, você precisará definir os parâmetros de configuração da distribuição para ativar os atributos de economia de memória ou para passar valores para o grau de paralelismo.
Para começar com exemplos, consulte os seguintes cadernos Jupyter que demonstram como usar a biblioteca de paralelismo de SageMaker modelos.
+ [PyTorch exemplos de cadernos](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/pytorch/model_parallel)
+ [TensorFlow exemplos de cadernos](https://github.com/aws/amazon-sagemaker-examples/tree/main/training/distributed_training/tensorflow/model_parallel/mnist)
Para se aprofundar nos principais atributos da biblioteca, consulte os tópicos a seguir.
**nota**
As bibliotecas de treinamento SageMaker distribuídas estão disponíveis por meio dos contêineres de aprendizado AWS profundo do Hugging Face e TensorFlow na plataforma de treinamento. PyTorch SageMaker Para utilizar os recursos das bibliotecas de treinamento distribuídas, recomendamos que você use o SDK do SageMaker Python. Você também pode configurar manualmente a sintaxe de solicitação JSON se usar SageMaker APIs por meio do SDK for Python (Boto3) ou. AWS Command Line Interface Em toda a documentação, as instruções e os exemplos se concentram em como usar as bibliotecas de treinamento distribuídas com o SDK do SageMaker Python.
**Importante**
A biblioteca de paralelismo de SageMaker modelos oferece suporte a todos os recursos principais e oferece suporte ao paralelismo de pipeline para PyTorch. TensorFlow
**Topics**
+ [Paralelismo de dados compartilhados](model-parallel-extended-features-pytorch-sharded-data-parallelism.md)
+ [Programação de um modelo](model-parallel-core-features-pipieline-parallelism.md)
+ [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md)
+ [Fragmentação de estado do otimizador](model-parallel-extended-features-pytorch-optimizer-state-sharding.md)
+ [Ponto de verificação de ativação](model-parallel-extended-features-pytorch-activation-checkpointing.md)
+ [Ativação e descarregamento](model-parallel-extended-features-pytorch-activation-offloading.md)
+ [FP16 Treinamento com paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md)
+ [Support for FlashAttention](model-parallel-attention-head-size-for-flash-attention.md)
# Paralelismo de dados compartilhados
O *paralelismo de dados fragmentados* é uma técnica de treinamento distribuído que economiza memória e divide o estado de um modelo (parâmetros do modelo, gradientes e estados do otimizador) em um grupo paralelo de dados. GPUs
**nota**
O paralelismo de dados fragmentados está disponível PyTorch na biblioteca de paralelismo de SageMaker modelos v1.11.0 e versões posteriores.
Ao escalar seu trabalho de treinamento para um grande cluster de GPU, você pode reduzir o espaço de memória por GPU do modelo fragmentando o estado de treinamento do modelo em vários. GPUs Isso traz dois benefícios: você pode ajustar modelos maiores, que de outra forma ficariam sem memória com o paralelismo de dados padrão, ou você pode aumentar o tamanho do lote usando a memória liberada da GPU.
A técnica padrão de paralelismo de dados replica os estados de treinamento no grupo paralelo de dados e GPUs executa a agregação de gradientes com base na operação. `AllReduce` O paralelismo de dados fragmentados modifica o procedimento padrão de treinamento distribuído em paralelo a dados para considerar a natureza fragmentada dos estados do otimizador. Um grupo de classificações nas quais os estados do modelo e do otimizador são fragmentados é chamado de *grupo de fragmentação*. *A técnica de paralelismo de dados fragmentados fragmenta os parâmetros treináveis de um modelo e os gradientes e estados do otimizador correspondentes em todo o grupo de fragmentação. GPUs *
SageMaker A IA alcança o paralelismo de dados fragmentados por meio da implementação de MICs, que é discutida na postagem do AWS blog Escalonamento [quase](https://www.amazon.science/blog/near-linear-scaling-of-gigantic-model-training-on-aws) linear do treinamento de modelos gigantes em. AWS Nessa implementação, você pode definir o grau de fragmentação como um parâmetro configurável, que deve ser menor que o grau de paralelismo de dados. Durante cada passagem para frente e para trás, os MICs recombinam temporariamente os parâmetros do modelo em GPUs toda a operação. `AllGather` Após a passagem para frente ou para trás de cada camada, os MiCS fragmentam os parâmetros novamente para economizar memória da GPU. Durante a passagem para trás, os MICs reduzem os gradientes e, simultaneamente, os fragmentam durante a operação. GPUs `ReduceScatter` Por fim, os MiCS aplicam os gradientes locais reduzidos e fragmentados aos fragmentos de parâmetros locais correspondentes, usando os fragmentos locais dos estados do otimizador. Para reduzir a sobrecarga de comunicação, a biblioteca de paralelismo de SageMaker modelos pré-busca as próximas camadas na passagem para frente ou para trás e sobrepõe a comunicação de rede à computação.
O estado de treinamento do modelo é replicado nos grupos de fragmentação. Isso significa que antes que os gradientes sejam aplicados aos parâmetros, a operação `AllReduce` deve ocorrer nos grupos de fragmentação, além da operação `ReduceScatter` que ocorre dentro do grupo de fragmentação.
Na verdade, o paralelismo de dados fragmentados introduz uma compensação entre a sobrecarga de comunicação e a eficiência da memória da GPU. Usar o paralelismo de dados fragmentados aumenta o custo de comunicação, mas o espaço de memória por GPU (excluindo o uso de memória devido a ativações) é dividido pelo grau de paralelismo de dados fragmentados, portanto, modelos maiores podem caber no cluster de GPU.
**Seleção do grau de paralelismo de dados fragmentados**
Quando você seleciona um valor para o grau de paralelismo de dados fragmentados, o valor deve dividir uniformemente o grau de paralelismo de dados. Por exemplo, para um trabalho de paralelismo de dados de 8 vias, escolha 2, 4 ou 8 para o grau de paralelismo de dados fragmentados. Ao escolher o grau de paralelismo de dados fragmentados, recomendamos que você comece com um número pequeno e aumente gradualmente até que o modelo caiba na memória junto com o tamanho de lote desejado.
**Seleção do tamanho do lote**
Depois de configurar o paralelismo de dados fragmentados, certifique-se de encontrar a configuração de treinamento ideal que possa ser executada com êxito no cluster da GPU. Para treinar modelos de linguagem grande (LLM), comece com o tamanho do lote 1 e aumente-o gradualmente até chegar ao ponto de receber o erro out-of-memory (OOM). Se você encontrar o erro OOM mesmo com o menor tamanho de lote, aplique um grau mais alto de paralelismo de dados fragmentados ou uma combinação de paralelismo de dados fragmentados e paralelismo de tensores.
**Topics**
+ [Como aplicar o paralelismo de dados fragmentados ao seu trabalho de treinamento](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use)
+ [Configurações de referência](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use-config-sample)
+ [Paralelismo de dados fragmentados com coletivos SMDDP](#model-parallel-extended-features-pytorch-sharded-data-parallelism-smddp-collectives)
+ [Treinamento misto de precisão com paralelismo de dados fragmentados](#model-parallel-extended-features-pytorch-sharded-data-parallelism-16bits-training)
+ [Paralelismo de dados fragmentados com paralelismo de tensores](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism)
+ [Dicas e considerações para usar o paralelismo de dados fragmentados](#model-parallel-extended-features-pytorch-sharded-data-parallelism-considerations)
## Como aplicar o paralelismo de dados fragmentados ao seu trabalho de treinamento
Para começar com o paralelismo de dados fragmentados, aplique as modificações necessárias em seu script de treinamento e configure o SageMaker PyTorch estimador com os parâmetros. sharded-data-parallelism-specific Considere também usar valores de referência e exemplos de cadernos como ponto de partida.
### Adapte seu roteiro PyTorch de treinamento
Siga as instruções na [Etapa 1: Modifique um script de PyTorch treinamento](model-parallel-customize-training-script-pt.md) para agrupar os objetos do modelo e do otimizador com os `smdistributed.modelparallel.torch` invólucros dos módulos `torch.nn.parallel` e. `torch.distributed`
**(Opcional) Modificação adicional para registrar os parâmetros externos do modelo**
Se seu modelo for construído com `torch.nn.Module` e usar parâmetros que não estão definidos na classe do módulo, você deve registrá-los manualmente no módulo para que o SMP colete os parâmetros completos enquanto. Para registrar parâmetros em um módulo, use `smp.register_parameter(module, parameter)`.
```
class Module(torch.nn.Module):
def __init__(self, *args):
super().__init__(self, *args)
self.layer1 = Layer1()
self.layer2 = Layer2()
smp.register_parameter(self, self.layer1.weight)
def forward(self, input):
x = self.layer1(input)
# self.layer1.weight is required by self.layer2.forward
y = self.layer2(x, self.layer1.weight)
return y
```
### Configurar o SageMaker PyTorch estimador
Ao configurar um SageMaker PyTorch estimador em[Etapa 2: Iniciar um Training Job usando o SageMaker Python SDK](model-parallel-sm-sdk.md), adicione os parâmetros para paralelismo de dados fragmentados.
Para ativar o paralelismo de dados fragmentados, adicione o `sharded_data_parallel_degree` parâmetro ao Estimador. SageMaker PyTorch Esse parâmetro especifica o número GPUs sobre o qual o estado de treinamento é fragmentado. O valor de `sharded_data_parallel_degree` deve ser um número inteiro entre um e o grau de paralelismo de dados e deve dividir uniformemente o grau de paralelismo de dados. Observe que a biblioteca detecta automaticamente o número de, GPUs portanto, o grau paralelo dos dados. Os parâmetros adicionais a seguir estão disponíveis para configurar o paralelismo de dados fragmentados.
+ `"sdp_reduce_bucket_size"`*(int, default: 5e8)* — Especifica o tamanho dos compartimentos de [gradiente PyTorch DDP em número de elementos](https://pytorch.org/docs/stable/notes/ddp.html#internal-design) do dtype padrão.
+ `"sdp_param_persistence_threshold"`*(int, default: 1e6)*: Especifica o tamanho de um tensor de parâmetros em número de elementos que podem persistir em cada GPU. O paralelismo de dados fragmentados divide cada tensor de parâmetros em um grupo paralelo de GPUs dados. Se o número de elementos no tensor do parâmetro for menor que esse limite, o tensor do parâmetro não será dividido; isso ajuda a reduzir a sobrecarga de comunicação porque o tensor do parâmetro é replicado em dados paralelos. GPUs
+ `"sdp_max_live_parameters"`*(int, default: 1e9)*: Especifica o número máximo de parâmetros que podem estar simultaneamente em um estado de treinamento recombinado durante a passagem para frente e para trás. A busca de parâmetros com a operação `AllGather` é interrompida quando o número de parâmetros ativos atinge o limite determinado. Observe que aumentar esse parâmetro aumenta o espaço ocupado pela memória.
+ `"sdp_hierarchical_allgather"`*(bool, default: True)*: Se definida como `True`, a operação `AllGather` é executada hierarquicamente: ela é executada primeiro em cada nó e depois em todos os nós. Para trabalhos de treinamento distribuídos de vários nós, a operação `AllGather` hierárquica é ativada automaticamente.
+ `"sdp_gradient_clipping"`*(float, padrão: 1.0)*: especifica um limite para recortar o gradiente na norma L2 dos gradientes antes de propagá-los para trás por meio dos parâmetros do modelo. Quando o paralelismo de dados fragmentados é ativado, o recorte de gradiente também é ativado. O limite padrão é `1.0`. Ajuste esse parâmetro se você tiver o problema de gradientes explosivos.
O código a seguir mostra um exemplo de como configurar o paralelismo de dados fragmentados.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled": True,
"parameters": {
# "pipeline_parallel_degree": 1, # Optional, default is 1
# "tensor_parallel_degree": 1, # Optional, default is 1
"ddp": True,
# parameters for sharded data parallelism
"sharded_data_parallel_degree": 2, # Add this to activate sharded data parallelism
"sdp_reduce_bucket_size": int(5e8), # Optional
"sdp_param_persistence_threshold": int(1e6), # Optional
"sdp_max_live_parameters": int(1e9), # Optional
"sdp_hierarchical_allgather": True, # Optional
"sdp_gradient_clipping": 1.0 # Optional
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
smp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.p3.16xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-job"
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Configurações de referência
A equipe de treinamento SageMaker distribuída fornece as seguintes configurações de referência que você pode usar como ponto de partida. Você pode extrapolar a partir das configurações a seguir para experimentar e estimar o uso de memória da GPU para a configuração do seu modelo.
Paralelismo de dados fragmentados com coletivos SMDDP
| Modelo/número de parâmetros | Número de instâncias | Tipo de instância | Comprimento da sequência | Tamanho global do lote | Tamanho do minilote | Grau paralelo de dados fragmentados |
| --- | --- | --- | --- | --- | --- | --- |
| GPT-NEOX-20B | 2 | ml.p4d.24xlarge | 2048 | 64 | 4 | 16 |
| GPT-NEOX-20B | 8 | ml.p4d.24xlarge | 2048 | 768 | 12 | 32 |
Por exemplo, se você aumentar o comprimento da sequência de um modelo de 20 bilhões de parâmetros ou aumentar o tamanho do modelo para 65 bilhões de parâmetros, primeiro precisará tentar reduzir o tamanho do lote. Se o modelo ainda não se adequar ao menor tamanho de lote (o tamanho do lote de 1), tente aumentar o grau de paralelismo do modelo.
Paralelismo de dados fragmentados com paralelismo de tensores e coletivos NCCL
| Modelo/número de parâmetros | Número de instâncias | Tipo de instância | Comprimento da sequência | Tamanho global do lote | Tamanho do minilote | Grau paralelo de dados fragmentados | Tensor de grau paralelo | Ativação e descarregamento |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| GPT-NEOX-65B | 64 | ml.p4d.24xlarge | 2048 | 512 | 8 | 16 | 8 | S |
| GPT-NEOX-65B | 64 | ml.p4d.24xlarge | 4096 | 512 | 2 | 64 | 2 | S |
O uso combinado de paralelismo de dados fragmentados e paralelismo de tensores é útil quando você deseja ajustar um modelo de linguagem grande (LLM) em um cluster de grande escala enquanto usa dados de texto com um comprimento de sequência maior, o que leva ao uso de um tamanho de lote menor e, consequentemente, manipula o uso da memória da GPU para treinar com sequências de texto mais longas. LLMs Para saber mais, consulte [Paralelismo de dados fragmentados com paralelismo de tensores](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism).
Para estudos de caso, benchmarks e mais exemplos de configuração, consulte a postagem do blog [Novas melhorias de desempenho na biblioteca paralela de modelos de SageMaker IA da Amazon](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/).
## Paralelismo de dados fragmentados com coletivos SMDDP
A biblioteca SageMaker de paralelismo de dados oferece primitivas de comunicação coletiva (coletivas SMDDP) otimizadas para a infraestrutura. AWS Ele obtém a otimização adotando um padrão de all-to-all-type comunicação usando o [Elastic Fabric Adapter (](https://aws.amazon.com/hpc/efa/)EFA), resultando em coletivos de alto rendimento e menos sensíveis à latência, transferindo o processamento relacionado à comunicação para a CPU e liberando ciclos de GPU para computação. Em grandes clusters, os coletivos SMDDP podem oferecer melhorias no performance de treinamento distribuído em até 40% em comparação com o NCCL. Para estudos de caso e resultados de benchmark, consulte o blog [Novas melhorias de desempenho na biblioteca de paralelismo de modelos de SageMaker IA da Amazon](https://aws.amazon.com/blogs/machine-learning/new-performance-improvements-in-amazon-sagemaker-model-parallel-library/).
**nota**
O paralelismo de dados fragmentados com SMDDP Collectives está disponível na biblioteca de paralelismo de SageMaker modelos v1.13.0 e posterior e na biblioteca de paralelismo de dados v1.6.0 e posterior. SageMaker Consulte também [Supported configurations](#sharded-data-parallelism-smddp-collectives-supported-config) para usar o paralelismo de dados fragmentados com coletivos SMDDP.
No paralelismo de dados fragmentados, que é uma técnica comumente usada em treinamento distribuído em grande escala, o coletivo `AllGather` é usado para reconstituir os parâmetros da camada fragmentada para cálculos de passagem para frente e para trás, em paralelo com a computação da GPU. Para modelos grandes, realizar a operação `AllGather` com eficiência é fundamental para evitar problemas de gargalo na GPU e diminuir a velocidade de treinamento. Quando o paralelismo de dados fragmentados é ativado, os coletivos SMDDP entram nesses coletivos de performance crítico, melhorando a produtividade do treinamento `AllGather`.
**Treine com coletivos SMDDP**
Quando seu trabalho de treinamento tem o paralelismo de dados fragmentados ativado e atende ao [Supported configurations](#sharded-data-parallelism-smddp-collectives-supported-config), os coletivos SMDDP são ativados automaticamente. Internamente, os coletivos SMDDP otimizam o `AllGather` coletivo para ter desempenho na AWS infraestrutura e recorrem ao NCCL para todos os outros coletivos. Além disso, em configurações incompatíveis, todos os coletivos, inclusive `AllGather`, usam automaticamente o backend NCCL.
Desde a versão 1.13.0 da biblioteca de paralelismo de SageMaker modelos, o `"ddp_dist_backend"` parâmetro é adicionado às opções. `modelparallel` O valor padrão desse parâmetro de configuração é `"auto"`, que usa coletivos SMDDP sempre que possível e, caso contrário, volta para NCCL. Para forçar a biblioteca a sempre usar NCCL, especifique `"nccl"` para o parâmetro de configuração `"ddp_dist_backend"`.
O exemplo de código a seguir mostra como configurar um PyTorch estimador usando o paralelismo de dados fragmentados com o `"ddp_dist_backend"` parâmetro, que é definido como padrão e, portanto, `"auto"` opcional para adição.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled":True,
"parameters": {
"partitions": 1,
"ddp": True,
"sharded_data_parallel_degree": 64
"bf16": True,
"ddp_dist_backend": "auto" # Specify "nccl" to force to use NCCL.
}
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
smd_mp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=8,
instance_type='ml.p4d.24xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-demo",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
**Configurações compatíveis**
A operação `AllGather` com coletivos SMDDP é ativada em trabalhos de treinamento quando todos os requisitos de configuração a seguir são atendidos.
+ O grau de paralelismo de dados fragmentados maior que 1
+ `Instance_count` maior que 1
+ `Instance_type` igual a `ml.p4d.24xlarge`
+ SageMaker contêiner de treinamento para PyTorch v1.12.1 ou posterior
+ A biblioteca SageMaker de paralelismo de dados v1.6.0 ou posterior
+ A biblioteca de paralelismo de SageMaker modelos v1.13.0 ou posterior
**Ajuste de performance e memória**
Os coletivos SMDDP utilizam memória GPU adicional. Há duas variáveis de ambiente para configurar o uso da memória da GPU, dependendo dos diferentes casos de uso de treinamento de modelo.
+ `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES`: Durante a operação SMDDP `AllGather`, o buffer de entrada `AllGather` é copiado em um buffer temporário para comunicação entre nós. A variável `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` controla o tamanho (em bytes) desse buffer temporário. Se o tamanho do buffer temporário for menor que o tamanho do buffer `AllGather` de entrada, o coletivo `AllGather` voltará a usar o NCCL.
+ Valor padrão: 16 \$1 1024 \$1 1024 (16 MB)
+ Valores aceitáveis: qualquer múltiplo de 8192
+ `SMDDP_AG_SORT_BUFFER_SIZE_BYTES`: A variável `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` é dimensionar o buffer temporário (em bytes) para armazenar os dados coletados da comunicação entre nós. Se o tamanho desse buffer temporário for menor que `1/8 * sharded_data_parallel_degree * AllGather input size`, o coletivo `AllGather` volta a usar o NCCL.
+ Valor padrão: 128 \$1 1024 \$1 1024 (128 MB)
+ Valores aceitáveis: qualquer múltiplo de 8192
**Orientação de ajuste sobre as variáveis de tamanho do buffer**
Os valores padrão das variáveis de ambiente devem funcionar bem na maioria dos casos de uso. Recomendamos ajustar essas variáveis somente se o treinamento apresentar o erro out-of-memory (OOM).
A lista a seguir discute algumas dicas de ajuste para reduzir o consumo de memória da GPU dos coletivos SMDDP e, ao mesmo tempo, reter o ganho de performance deles.
+ Ajustar `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES`
+ O tamanho do buffer de entrada `AllGather` é menor para modelos menores. Portanto, o tamanho necessário para `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` pode ser menor para modelos com menos parâmetros.
+ O tamanho do buffer de `AllGather` entrada diminui à medida que `sharded_data_parallel_degree` aumenta, porque o modelo fica mais fragmentado. GPUs Portanto, o tamanho necessário para `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` pode ser menor para trabalhos de treinamento com valores grandes para `sharded_data_parallel_degree`.
+ Ajustar `SMDDP_AG_SORT_BUFFER_SIZE_BYTES`
+ A quantidade de dados coletados da comunicação entre nós é menor para modelos com menos parâmetros. Portanto, o tamanho necessário para `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` pode ser menor para modelos com menor número de parâmetros.
Alguns coletivos podem voltar a usar o NCCL; portanto, você pode não obter o ganho de performance dos coletivos SMDDP otimizados. Se houver memória da GPU adicional disponível para uso, considere aumentar os valores `SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES` e `SMDDP_AG_SORT_BUFFER_SIZE_BYTES` se beneficiar do ganho de performance.
O código a seguir mostra como você pode configurar as variáveis de ambiente anexando-as ao `mpi_options` parâmetro de distribuição do PyTorch estimador.
```
import sagemaker
from sagemaker.pytorch import PyTorch
smp_options = {
.... # All modelparallel configuration options go here
}
mpi_options = {
"enabled" : True, # Required
"processes_per_host" : 8 # Required
}
# Use the following two lines to tune values of the environment variables for buffer
mpioptions += " -x SMDDP_AG_SCRATCH_BUFFER_SIZE_BYTES=8192"
mpioptions += " -x SMDDP_AG_SORT_BUFFER_SIZE_BYTES=8192"
smd_mp_estimator = PyTorch(
entry_point="your_training_script.py", # Specify your train script
source_dir="location_to_your_script",
role=sagemaker.get_execution_role(),
instance_count=8,
instance_type='ml.p4d.24xlarge',
framework_version='1.13.1',
py_version='py3',
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="sharded-data-parallel-demo-with-tuning",
)
smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```
## Treinamento misto de precisão com paralelismo de dados fragmentados
Para economizar ainda mais a memória da GPU com números de ponto flutuante de meia precisão e paralelismo de dados fragmentados, você pode ativar o formato de ponto flutuante de 16 bits (FP16) ou o formato de [ponto flutuante Brain](https://en.wikichip.org/wiki/brain_floating-point_format) (BF16) adicionando um parâmetro adicional à configuração de treinamento distribuído.
**nota**
O treinamento misto de precisão com paralelismo de dados fragmentados está disponível na biblioteca de paralelismo de SageMaker modelos v1.11.0 e versões posteriores.
**Para FP16 treinamento com paralelismo de dados fragmentados**
Para executar o FP16 treinamento com paralelismo de dados fragmentados, adicione `"fp16": True"` ao dicionário de configuração. `smp_options` Em seu script de treinamento, você pode escolher entre as opções de escalonamento de perda estática e dinâmica por meio do módulo `smp.DistributedOptimizer`. Para obter mais informações, consulte [FP16 Treinamento com paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md).
```
smp_options = {
"enabled": True,
"parameters": {
"ddp": True,
"sharded_data_parallel_degree": 2,
"fp16": True
}
}
```
**Para BF16 treinamento com paralelismo de dados fragmentados**
O recurso de paralelismo de dados fragmentados da SageMaker IA oferece suporte ao treinamento em tipos de dados. BF16 O tipo de BF16 dados usa 8 bits para representar o expoente de um número de ponto flutuante, enquanto o tipo de FP16 dados usa 5 bits. Preservar os 8 bits para o expoente permite manter a mesma representação do expoente de um número de ponto flutuante () de precisão única de 32 bits. FP32 Isso torna a conversão entre FP32 e BF16 mais simples e significativamente menos propensa a causar problemas de estouro e subfluxo que surgem com frequência no FP16 treinamento, especialmente ao treinar modelos maiores. Embora os dois tipos de dados usem 16 bits no total, esse aumento na faixa de representação do expoente no BF16 formato prejudica a precisão reduzida. Para treinar modelos grandes, essa precisão reduzida geralmente é considerada uma compensação aceitável para o alcance e a estabilidade do treinamento.
**nota**
Atualmente, o BF16 treinamento funciona somente quando o paralelismo de dados fragmentados é ativado.
Para executar o BF16 treinamento com paralelismo de dados fragmentados, adicione `"bf16": True` ao dicionário de configuração. `smp_options`
```
smp_options = {
"enabled": True,
"parameters": {
"ddp": True,
"sharded_data_parallel_degree": 2,
"bf16": True
}
}
```
## Paralelismo de dados fragmentados com paralelismo de tensores
Se você usa paralelismo de dados fragmentados e também precisa reduzir o tamanho global do lote, considere usar paralelismo de [tensores com paralelismo](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-tensor-parallelism.html) de dados fragmentados. Ao treinar um modelo grande com paralelismo de dados fragmentados em um cluster de computação muito grande (normalmente 128 nós ou mais), até mesmo um pequeno tamanho de lote por GPU resulta em um tamanho de lote global muito grande. Isso pode levar a problemas de convergência ou problemas de baixo performance computacional. Às vezes, não é possível reduzir o tamanho do lote por GPU apenas com o paralelismo de dados fragmentados, quando um único lote já é grande e não pode ser reduzido ainda mais. Nesses casos, usar o paralelismo de dados fragmentados em combinação com o paralelismo de tensores ajuda a reduzir o tamanho global do lote.
A escolha dos graus ideais de dados fragmentados paralelos e tensores paralelos depende da escala do modelo, do tipo de instância e do tamanho global do lote que seja razoável para a convergência do modelo. Recomendamos que você comece com um grau paralelo de baixo tensor para ajustar o tamanho do lote global ao cluster de computação para resolver out-of-memory erros de CUDA e obter o melhor desempenho. Veja os dois exemplos de casos a seguir para saber como a combinação de paralelismo de tensores e paralelismo de dados fragmentados ajuda você a ajustar o tamanho global do lote por meio do agrupamento GPUs para paralelismo do modelo, resultando em um número menor de réplicas do modelo e em um tamanho de lote global menor.
**nota**
Esse recurso está disponível na biblioteca de paralelismo de SageMaker modelos v1.15 e oferece suporte à v1.13.1. PyTorch
**nota**
Esse atributo está disponível para os modelos compatíveis com a funcionalidade de paralelismo de tensores da biblioteca. Para encontrar a lista dos modelos compatíveis, consulte [Ajuda para modelo tipo transformador do Hugging Face](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-extended-features-pytorch-hugging-face.html). Observe também que você precisa passar `tensor_parallelism=True` para o argumento `smp.model_creation` ao modificar seu script de treinamento. Para saber mais, consulte o script de treinamento [https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L793](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L793)no * GitHub repositório de exemplos de SageMaker IA*.
### Exemplo 1
Suponha que queremos treinar um modelo em um cluster de 1536 GPUs (192 nós com 8 GPUs em cada), definindo o grau de paralelismo de dados fragmentados como 32 (`sharded_data_parallel_degree=32`) e o tamanho do lote por GPU como 1, onde cada lote tem um comprimento de sequência de 4096 tokens. Nesse caso, existem 1536 réplicas de modelos, o tamanho do lote global se torna 1536 e cada lote global contém cerca de 6 milhões de tokens.
```
(1536 GPUs) * (1 batch per GPU) = (1536 global batches)
(1536 batches) * (4096 tokens per batch) = (6,291,456 tokens)
```
Adicionar paralelismo de tensor a ele pode diminuir o tamanho global do lote. Um exemplo de configuração pode ser definir o grau paralelo do tensor como 8 e o tamanho do lote por GPU como 4. Isso forma 192 grupos paralelos de tensores ou 192 réplicas de modelo, onde cada réplica do modelo é distribuída em 8. GPUs O tamanho do lote de 4 é a quantidade de dados de treinamento por iteração e por grupo paralelo de tensores; ou seja, cada réplica do modelo consome 4 lotes por iteração. Nesse caso, o tamanho do lote global se torna 768 e cada lote global contém cerca de 3 milhões de tokens. Portanto, o tamanho do lote global é reduzido pela metade em comparação com o caso anterior com apenas o paralelismo de dados fragmentados.
```
(1536 GPUs) / (8 tensor parallel degree) = (192 tensor parallelism groups)
(192 tensor parallelism groups) * (4 batches per tensor parallelism group) = (768 global batches)
(768 batches) * (4096 tokens per batch) = (3,145,728 tokens)
```
### Exemplo 2
Quando o paralelismo de dados fragmentados e o paralelismo de tensores são ativados, a biblioteca primeiro aplica o paralelismo de tensores e fragmenta o modelo em toda essa dimensão. Para cada classificação paralela do tensor, o paralelismo de dados é aplicado conforme `sharded_data_parallel_degree`.
Por exemplo, suponha que queremos definir 32 GPUs com um tensor paralelo de 4 (formando grupos de 4 GPUs), um grau paralelo de dados fragmentados de 4, terminando com um grau de replicação de 2. A atribuição cria oito grupos de GPU com base no grau paralelo do tensor da seguinte forma: `(0,1,2,3)`, `(4,5,6,7)`, `(8,9,10,11)`, `(12,13,14,15)`, `(16,17,18,19)`, `(20,21,22,23)`, `(24,25,26,27)`, `(28,29,30,31)`. Ou seja, quatro GPUs formam um grupo tensor paralelo. Nesse caso, o grupo paralelo de dados reduzido para a 0ª classificação GPUs dos grupos paralelos tensores seria. `(0,4,8,12,16,20,24,28)` O grupo paralelo de dados reduzido é fragmentado com base no grau paralelo de dados fragmentados de 4, resultando em dois grupos de replicação para paralelismo de dados. GPUs`(0,4,8,12)`forme um grupo de fragmentação, que coletivamente contém uma cópia completa de todos os parâmetros para a classificação paralela do 0º tensor, e GPUs `(16,20,24,28)` forme outro grupo desse tipo. Outras classificações paralelas de tensores também têm grupos de fragmentação e replicação semelhantes.
![\[Figura 1: Grupos de paralelismo de tensores.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/sdp_tp_group_tp.jpg)
Figura 1: Grupos de paralelismo de tensores para (nós, grau paralelo de dados fragmentados, grau paralelo do tensor) = (4, 4, 4), onde cada retângulo representa uma GPU com índices de 0 a 31. O paralelismo GPUs de tensores de forma agrupa de TPG a TPG. 0 7 Os grupos de replicação são (\$1TPG0, TPG4\$1, \$1TPG1, TPG5\$1, \$1TPG2, TPG6\$1 e \$1TPG3, TPG7\$1); cada par de grupos de replicação compartilha a mesma cor, mas preenchida de forma diferente.
![\[Figura 2: Grupos de paralelismo de dados fragmentados.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/sdp_tp_group_sdp.jpg)
Figura 2: Grupos de paralelismo de dados fragmentados para (nós, grau paralelo de dados fragmentados, grau paralelo do tensor) = (4, 4, 4), onde cada retângulo representa uma GPU com índices de 0 a 31. O GPUs formulário agrupa o paralelismo de dados fragmentados de SDPG a SDPG. 0 7 Os grupos de replicação são (\$1SDPG0, SDPG4\$1, \$1SDPG1, SDPG5\$1, \$1SDPG2, SDPG6\$1 e \$1SDPG3, SDPG7\$1); cada par de grupos de replicação compartilha a mesma cor, mas é preenchido de forma diferente.
### Como ativar o paralelismo de dados fragmentados com o paralelismo de tensores
Para usar o paralelismo de dados fragmentados com o paralelismo de tensores, você precisa definir ambos `sharded_data_parallel_degree` e `tensor_parallel_degree` na configuração para criar um objeto da classe estimadora`distribution`. SageMaker PyTorch
Você também precisa ativar `prescaled_batch`. Isso significa que, em vez de cada GPU ler seu próprio lote de dados, cada grupo paralelo de tensores lê coletivamente um lote combinado do tamanho de lote escolhido. Efetivamente, em vez de dividir o conjunto de dados em partes iguais ao número de GPUs (ou tamanho paralelo dos dados`smp.dp_size()`), ele se divide em partes iguais ao número de GPUs dividido por `tensor_parallel_degree` (também chamado de tamanho paralelo de dados reduzido). `smp.rdp_size()` Para obter mais detalhes sobre o lote pré-escalado, consulte [Prescaled Batch](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#prescaled-batch) na documentação do *SageMaker Python* SDK. Veja também o exemplo de script de treinamento [https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L164](https://github.com/aws/amazon-sagemaker-examples/blob/main/training/distributed_training/pytorch/model_parallel/gpt2/train_gpt_simple.py#L164)para GPT-2 no repositório de exemplos de *SageMaker IA*. GitHub
O trecho de código a seguir mostra um exemplo de criação de um objeto PyTorch estimador com base no cenário mencionado acima em. [Exemplo 2](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism-ex2)
```
mpi_options = "-verbose --mca orte_base_help_aggregate 0 "
smp_parameters = {
"ddp": True,
"fp16": True,
"prescaled_batch": True,
"sharded_data_parallel_degree": 4,
"tensor_parallel_degree": 4
}
pytorch_estimator = PyTorch(
entry_point="your_training_script.py",
role=role,
instance_type="ml.p4d.24xlarge",
volume_size=200,
instance_count=4,
sagemaker_session=sagemaker_session,
py_version="py3",
framework_version="1.13.1",
distribution={
"smdistributed": {
"modelparallel": {
"enabled": True,
"parameters": smp_parameters,
}
},
"mpi": {
"enabled": True,
"processes_per_host": 8,
"custom_mpi_options": mpi_options,
},
},
source_dir="source_directory_of_your_code",
output_path=s3_output_location
)
```
## Dicas e considerações para usar o paralelismo de dados fragmentados
Considere o seguinte ao usar o paralelismo de dados fragmentados da biblioteca de paralelismo de SageMaker modelos.
+ O paralelismo de dados fragmentados é compatível com o treinamento. FP16 Para realizar o FP16 treinamento, consulte a [FP16 Treinamento com paralelismo de modelos](model-parallel-extended-features-pytorch-fp16.md) seção.
+ O paralelismo de dados fragmentados é compatível com o paralelismo de tensores. Os itens a seguir são o que talvez você precise considerar para usar o paralelismo de dados fragmentados com o paralelismo de tensores.
+ Ao usar paralelismo de dados fragmentados com paralelismo de tensores, as camadas de incorporação também são distribuídas automaticamente pelo grupo paralelo de tensores. Em outras palavras, o parâmetro `distribute_embedding` é definido automaticamente como `True`. Para obter mais informações sobre paralelismo de tensores, consulte [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md).
+ Observe que o paralelismo de dados fragmentados com o paralelismo de tensores atualmente usa os coletivos NCCL como backend da estratégia de treinamento distribuído.
Para saber mais, consulte a seção [Paralelismo de dados fragmentados com paralelismo de tensores](#model-parallel-extended-features-pytorch-sharded-data-parallelism-with-tensor-parallelism).
+ Atualmente, o paralelismo de dados fragmentados é incompatível com o [paralelismo de pipeline](model-parallel-intro.md#model-parallel-intro-pp) ou com a [fragmentação de estado do otimizador](model-parallel-extended-features-pytorch-optimizer-state-sharding.md). Para ativar o paralelismo de dados fragmentados, desative a fragmentação de estado do otimizador e defina o grau paralelo do pipeline como 1.
+ Os atributos de [ponto de verificação de ativação](model-parallel-extended-features-pytorch-activation-checkpointing.md) e [descarregamento de ativação](model-parallel-extended-features-pytorch-activation-offloading.md) são compatíveis com o paralelismo de dados fragmentados.
+ Para usar o paralelismo de dados fragmentados com o acúmulo de gradiente, defina o argumento `backward_passes_per_step` para o número de etapas de acumulação ao agrupar seu modelo com o módulo [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel). Isso garante que a operação `AllReduce` de gradiente nos grupos de replicação do modelo (grupos de fragmentação) ocorra no limite do acúmulo de gradiente.
+ Você pode verificar seus modelos treinados com paralelismo de dados fragmentados usando o ponto de verificação da biblioteca e. APIs `smp.save_checkpoint` `smp.resume_from_checkpoint` Para obter mais informações, consulte [Apontando um PyTorch modelo distribuído (para a biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)](distributed-model-parallel-checkpointing-and-finetuning.md#model-parallel-extended-features-pytorch-checkpoint).
+ O comportamento do parâmetro de configuração [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.delay_param_initialization) muda sob o paralelismo de dados fragmentados. Quando esses dois atributos são ativados simultaneamente, os parâmetros são inicializados imediatamente após a criação do modelo de forma fragmentada, em vez de atrasar a inicialização do parâmetro, para que cada classificação inicialize e armazene seu próprio fragmento de parâmetros.
+ Quando o paralelismo de dados fragmentados é ativado, a biblioteca executa o recorte de gradiente internamente quando a chamada `optimizer.step()` é executada. Você não precisa usar utilitários APIs para recorte de gradiente, como. [https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html](https://pytorch.org/docs/stable/generated/torch.nn.utils.clip_grad_norm_.html) Para ajustar o valor limite para recorte de gradiente, você pode defini-lo por meio do `sdp_gradient_clipping` parâmetro para a configuração do parâmetro de distribuição ao construir o SageMaker PyTorch estimador, conforme mostrado na seção. [Como aplicar o paralelismo de dados fragmentados ao seu trabalho de treinamento](#model-parallel-extended-features-pytorch-sharded-data-parallelism-how-to-use)
# Programação de um modelo
Um dos principais recursos da biblioteca de SageMaker paralelismo de modelos é o paralelismo de *pipeline*, que determina a ordem na qual os cálculos são feitos e os dados são processados nos dispositivos durante o treinamento do modelo. O pipelining é uma técnica para alcançar a verdadeira paralelização no paralelismo do modelo, fazendo com que a GPUs computação seja feita simultaneamente em diferentes amostras de dados e para superar a perda de desempenho devido à computação sequencial. Quando você usa o paralelismo de pipeline, o trabalho de treinamento é executado de forma agrupada em microlotes para maximizar o uso da GPU.
**nota**
O paralelismo de pipeline, também chamado de particionamento de modelo, está disponível para e. PyTorch TensorFlow Para versões compatíveis com os frameworks, consulte [Estruturas suportadas e Regiões da AWS](distributed-model-parallel-support.md).
## Cronograma de execução do pipeline
O pipelining é baseado na divisão de um minilote em microlotes, que são inseridos no pipeline de treinamento one-by-one e seguem um cronograma de execução definido pelo tempo de execução da biblioteca. Um *microlote* é um subconjunto menor de um determinado minilote de treinamento. O cronograma do pipeline determina qual microlote é executado por qual dispositivo em cada intervalo de tempo.
Por exemplo, dependendo do cronograma do pipeline e da partição do modelo, a GPU `i` pode realizar a computação (para frente ou para trás) no microlote, `b` enquanto a GPU `i+1` executa a computação no microlote`b+1`, mantendo as duas ativas ao mesmo tempo. GPUs Durante uma única passagem para frente ou para trás, o fluxo de execução de um único microlote pode visitar o mesmo dispositivo várias vezes, dependendo da decisão de particionamento. Por exemplo, uma operação que está no início do modelo pode ser colocada no mesmo dispositivo que uma operação no final do modelo, enquanto as operações intermediárias estão em dispositivos diferentes, o que significa que esse dispositivo é visitado duas vezes.
A biblioteca oferece dois cronogramas de pipeline diferentes, *simples* e *intercalados, que podem ser configurados* usando o parâmetro `pipeline` no SDK do Python. SageMaker Na maioria dos casos, o pipeline intercalado pode alcançar um melhor desempenho ao utilizá-lo com mais eficiência. GPUs
### Gasoduto intercalado
Em um pipeline intercalado, a execução reversa dos microlotes é priorizada sempre que possível. Isso permite uma liberação mais rápida da memória usada para ativações, usando a memória com mais eficiência. Também permite aumentar o número de microlotes, reduzindo o tempo de inatividade do. GPUs Em estado estacionário, cada dispositivo alterna entre passes para frente e para trás. Isso significa que a passagem para trás de um microlote pode ser executada antes que a passagem para frente de outro microlote termine.
![\[Exemplo de cronograma de execução para o pipeline intercalado acima de 2. GPUs\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-execution.png)
A figura anterior ilustra um exemplo de cronograma de execução para o pipeline intercalado acima de 2. GPUs Na figura, F0 representa a passagem para frente para o microlote 0 e B1 representa a passagem para trás para o microlote 1. A **atualização** representa a atualização do otimizador dos parâmetros. GPU0 sempre prioriza as passagens para trás sempre que possível (por exemplo, executa B0 antes de F2), o que permite limpar a memória usada para ativações anteriores.
### Pipeline simples
Uma tubulação simples, por outro lado, termina de executar a passagem para frente para cada microlote antes de iniciar a passagem para trás. Isso significa que ele apenas canaliza os estágios de passagem para frente e para trás dentro de si. A figura a seguir ilustra um exemplo de como isso funciona, mais de 2 GPUs.
![\[Exemplo de um pipeline executando o avanço de cada microlote antes de iniciar o retrocesso.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/simple-pipeline-execution.png)
### Execução de pipelining em estruturas específicas
Use as seções a seguir para aprender sobre as decisões de agendamento de pipeline específicas da estrutura que a biblioteca de SageMaker paralelismo de modelos faz para e. TensorFlow PyTorch
#### Execução de pipeline com TensorFlow
A imagem a seguir é um exemplo de um TensorFlow gráfico particionado pela biblioteca de paralelismo de modelos, usando a divisão automatizada de modelos. Quando um gráfico é dividido, cada subgráfico resultante é replicado B vezes (exceto para as variáveis), onde B é o número de microlotes. Nesta figura, cada subgráfico é replicado 2 vezes (B=2). Uma operação `SMPInput` é inserida em cada entrada de um subgráfico e uma operação `SMPOutput` é inserida em cada saída. Essas operações se comunicam com o backend da biblioteca para transferir tensores de e para os outros.
![\[Exemplo de um TensorFlow gráfico particionado pela biblioteca de paralelismo de modelos, usando a divisão automatizada de modelos.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-tf.png)
A imagem a seguir é um exemplo de 2 subgráficos divididos com B=2 com operações de gradiente adicionadas. O gradiente de uma operação `SMPInput` é uma operação `SMPOutput` e vice-versa. Isso permite que os gradientes fluam para trás durante a retropropagação.
![\[Exemplo de 2 subgráficos divididos com B=2 com operações de gradiente adicionadas.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/interleaved-pipeline-tf.gif)
Esse GIF demonstra um exemplo de cronograma de execução de pipeline intercalado com B=2 microlotes e 2 subgráficos. Cada dispositivo executa sequencialmente uma das réplicas do subgráfico para melhorar a utilização da GPU. À medida que B cresce, a fração de intervalos de tempo ociosos vai para zero. Sempre que é hora de fazer cálculos (para frente ou para trás) em uma réplica específica do subgráfico, a camada do pipeline sinaliza para as operações azuis correspondentes `SMPInput` começarem a ser executadas.
Depois que os gradientes de todos os microlotes em um único minilote são calculados, a biblioteca combina os gradientes entre microlotes, que podem ser aplicados aos parâmetros.
#### Execução de pipeline com PyTorch
Conceitualmente, o pipelining segue uma ideia semelhante em. PyTorch No entanto, como PyTorch não envolve gráficos estáticos, o PyTorch recurso da biblioteca de paralelismo de modelos usa um paradigma de pipeline mais dinâmico.
Por exemplo TensorFlow, cada lote é dividido em vários microlotes, que são executados um por vez em cada dispositivo. No entanto, o cronograma de execução é gerenciado por meio de servidores de execução lançados em cada dispositivo. Sempre que a saída de um submódulo colocado em outro dispositivo é necessária no dispositivo atual, uma solicitação de execução é enviada ao servidor de execução do dispositivo remoto junto com os tensores de entrada do submódulo. O servidor então executa esse módulo com as entradas fornecidas e retorna a resposta para o dispositivo atual.
Como o dispositivo atual fica ocioso durante a execução do submódulo remoto, a execução local do microlote atual é pausada e o runtime da biblioteca muda a execução para outro microlote no qual o dispositivo atual possa trabalhar ativamente. A priorização dos microlotes é determinada pelo cronograma de pipeline escolhido. Para um cronograma de pipeline intercalado, os microlotes que estão no estágio anterior da computação são priorizados sempre que possível.
# Paralelismo de tensores
O *paralelismo de tensores* é um tipo de paralelismo de modelo no qual pesos, gradientes e estados do otimizador específicos do modelo são divididos entre dispositivos. Em contraste com o paralelismo de tubulação, que mantém os pesos individuais intactos, mas divide o *conjunto* de pesos, o paralelismo de tensores divide os pesos individuais. Isso normalmente envolve computação distribuída de operações, módulos ou camadas específicas do modelo.
O paralelismo do tensor é necessário nos casos em que um único parâmetro consome a maior parte da memória da GPU (como grandes tabelas de incorporação com um grande tamanho de vocabulário ou uma grande camada softmax com um grande número de classes). Nesse caso, tratar esse grande tensor ou operação como uma unidade atômica é ineficiente e impede o equilíbrio da carga de memória.
O paralelismo de tensores também é útil para modelos extremamente grandes nos quais uma tubulação pura simplesmente não é suficiente. Por exemplo, com modelos em escala GPT-3 que exigem particionamento em dezenas de instâncias, uma tubulação de microlote pura é ineficiente porque a profundidade da tubulação se torna muito alta e a sobrecarga se torna proibitivamente grande.
**nota**
O paralelismo de tensores está disponível PyTorch na biblioteca de paralelismo de SageMaker modelos v1.6.0 e versões posteriores.
**Topics**
+ [Como funciona o paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism-how-it-works.md)
+ [Execute um trabalho de treinamento paralelo de modelo SageMaker distribuído com paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md)
+ [Ajuda para modelos tipo transformador Hugging Face](model-parallel-extended-features-pytorch-hugging-face.md)
+ [Mecanismo de classificação ao usar uma combinação de paralelismo de pipeline e paralelismo de tensores](model-parallel-extended-features-pytorch-ranking-mechanism.md)
# Como funciona o paralelismo de tensores
O paralelismo de tensores ocorre no nível de `nn.Modules`; ele particiona módulos específicos no modelo em classificações paralelas de tensores. Isso é um acréscimo à partição existente do *conjunto de módulos* usados no paralelismo de tubulações.
Quando um módulo é particionado por meio de paralelismo de tensores, sua propagação para frente e para trás é distribuída. A biblioteca gerencia a comunicação necessária entre dispositivos para implementar a execução distribuída desses módulos. Os módulos são particionados em várias classificações paralelas de dados. Ao contrário da distribuição tradicional de workloads, cada classificação paralela de dados **não** tem a réplica completa do modelo quando o paralelismo de tensores da biblioteca é usado. Em vez disso, cada classificação paralela de dados pode ter somente uma partição dos módulos distribuídos, além da totalidade dos módulos que não estão distribuídos.
**Exemplo:** considere o paralelismo de tensores em classificações paralelas de dados, em que o grau de paralelismo de dados é 4 e o grau de paralelismo de tensores é 2. Suponha que você tenha um grupo paralelo de dados que contém a seguinte árvore de módulos, depois de particionar o conjunto de módulos:
```
A
├── B
| ├── E
| ├── F
├── C
└── D
├── G
└── H
```
Suponha que o paralelismo de tensores seja compatível com os módulos B, G e H. Um resultado possível da partição paralela de tensores desse modelo poderia ser:
```
dp_rank 0 (tensor parallel rank 0): A, B:0, C, D, G:0, H
dp_rank 1 (tensor parallel rank 1): A, B:1, C, D, G:1, H
dp_rank 2 (tensor parallel rank 0): A, B:0, C, D, G:0, H
dp_rank 3 (tensor parallel rank 1): A, B:1, C, D, G:1, H
```
Cada linha representa o conjunto de módulos armazenados na `dp_rank`, e a notação `X:y` representa a `y`-ésima fração do módulo `X`. Observe o seguinte:
1. O particionamento ocorre em subconjuntos de classificações paralelas de dados, que chamamos `TP_GROUP`, não de todo `DP_GROUP`, para que a partição exata do modelo seja replicada em `dp_rank` 0 e `dp_rank` 2 e, da mesma forma, em `dp_rank` 1 e `dp_rank` 3.
1. Os módulos `E` e não `F` fazem mais parte do modelo, pois seu módulo pai `B` é particionado e qualquer execução que normalmente faz parte `E` e `F` ocorre dentro do módulo `B` (particionado).
1. Embora `H` seja compatível com paralelismo de tensores, neste exemplo ele não é particionado, o que destaca que a partição de um módulo depende da entrada do usuário. O fato de um módulo ser compatível com paralelismo de tensores não significa necessariamente que ele seja particionado.
## Como a biblioteca adapta o paralelismo do tensor ao módulo PyTorch `nn.Linear`
Quando o paralelismo do tensor é executado em classificações paralelas de dados, um subconjunto dos parâmetros, gradientes e estados do otimizador é particionado nos dispositivos paralelos do tensor *para os módulos que são particionados*. Para o resto dos módulos, os dispositivos tensores paralelos operam de forma paralela de dados regular. Para executar o módulo particionado, um dispositivo primeiro coleta as partes necessárias de *todas as amostras de dados* em dispositivos pares no mesmo grupo de paralelismo de tensores. O dispositivo então executa a fração local do módulo em todas essas amostras de dados, seguida por outra rodada de sincronização que combina as partes da saída para cada amostra de dados e retorna as amostras de dados combinadas para a origem GPUs da amostra de dados. A figura a seguir mostra um exemplo desse processo em um módulo particionado `nn.Linear`.
![\[Duas figuras mostrando dois conceitos paralelos de tensores.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-concept.png)
A primeira figura mostra um modelo pequeno com um módulo `nn.Linear` grande com paralelismo de dados nas duas classificações de paralelismo de tensores. O módulo `nn.Linear` é replicado em duas fileiras paralelas.
A segunda figura mostra o paralelismo de tensores aplicado em um modelo maior durante a divisão do módulo `nn.Linear`. Cada `tp_rank` contém metade do módulo linear e a totalidade do resto das operações. Enquanto o módulo linear é executado, cada `tp_rank` coleta a metade relevante de todas as amostras de dados e a passa pela metade do módulo `nn.Linear`. O resultado precisa ser disperso por redução (com a soma como operação de redução) para que cada classificação tenha a saída linear final para suas próprias amostras de dados. O resto do modelo é executado da maneira paralela de dados típica.
# Execute um trabalho de treinamento paralelo de modelo SageMaker distribuído com paralelismo de tensores
Nesta seção, você aprende:
+ Como configurar um SageMaker PyTorch estimador e a opção de paralelismo do SageMaker modelo para usar o paralelismo tensorial.
+ Como adaptar seu script de treinamento usando os módulos estendidos `smdistributed.modelparallel` para paralelismo de tensores.
Para saber mais sobre os `smdistributed.modelparallel` módulos, consulte o [SageMaker modelo parallel APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) na documentação do *SageMaker Python SDK*.
**Topics**
+ [Apenas paralelismo de tensores](#model-parallel-extended-features-pytorch-tensor-parallelism-alone)
+ [Paralelismo de tensores combinado com paralelismo de pipeline](#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism)
## Apenas paralelismo de tensores
A seguir está um exemplo de uma opção de treinamento distribuído para ativar o paralelismo de tensores sozinho, sem paralelismo de pipeline. Configure os `smp_options` dicionários `mpi_options` e para especificar opções de treinamento distribuídas para o SageMaker `PyTorch` estimador.
**nota**
Recursos estendidos de economia de memória estão disponíveis por meio do Deep Learning Containers for PyTorch, que implementa a biblioteca de paralelismo de SageMaker modelos v1.6.0 ou posterior.
**Configurar um SageMaker PyTorch estimador**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"pipeline_parallel_degree": 1, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 4, # tp over 4 devices
"ddp": True
}
}
smp_estimator = PyTorch(
entry_point='your_training_script.py', # Specify
role=role,
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
framework_version='1.13.1',
py_version='py36',
instance_count=1,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
**dica**
Para encontrar uma lista completa de parâmetros para`distribution`, consulte [Parâmetros de configuração para paralelismo de modelos na documentação do SDK](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html) do Python SageMaker.
**Adapte seu roteiro PyTorch de treinamento**
O exemplo de script de treinamento a seguir mostra como adaptar a biblioteca de paralelismo de SageMaker modelos a um script de treinamento. Neste exemplo, presume-se que o script tenha um nome `your_training_script.py`.
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
return F.log_softmax(x, 1)
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by
# the current process, based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
loss.backward()
optimizer.step()
# smdistributed: Initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
if smp.local_rank() == 0:
dataset = datasets.MNIST("../data", train=True, download=False)
smp.barrier()
# smdistributed: Shard the dataset based on data parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64)
# smdistributed: Enable tensor parallelism for all supported modules in the model
# i.e., nn.Linear in this case. Alternatively, we can use
# smp.set_tensor_parallelism(model.fc1, True)
# to enable it only for model.fc1
with smp.tensor_parallelism():
model = Net()
# smdistributed: Use the DistributedModel wrapper to distribute the
# modules for which tensor parallelism is enabled
model = smp.DistributedModel(model)
optimizer = optim.AdaDelta(model.parameters(), lr=4.0)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
## Paralelismo de tensores combinado com paralelismo de pipeline
Veja a seguir um exemplo de uma opção de treinamento distribuído que permite o paralelismo de tensores combinado com o paralelismo de pipeline. Configure os `smp_options` parâmetros `mpi_options` e para especificar as opções paralelas do modelo com paralelismo de tensor ao configurar um estimador. SageMaker `PyTorch`
**nota**
Recursos estendidos de economia de memória estão disponíveis por meio do Deep Learning Containers for PyTorch, que implementa a biblioteca de paralelismo de SageMaker modelos v1.6.0 ou posterior.
**Configurar um SageMaker PyTorch estimador**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True
}
}
smp_estimator = PyTorch(
entry_point='your_training_script.py', # Specify
role=role,
instance_type='ml.p3.16xlarge',
sagemaker_session=sagemaker_session,
framework_version='1.13.1',
py_version='py36',
instance_count=1,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": mpi_options
},
base_job_name="SMD-MP-demo",
)
smp_estimator.fit('s3://my_bucket/my_training_data/')
```
**Adapte seu roteiro PyTorch de treinamento**
O exemplo de script de treinamento a seguir mostra como adaptar a biblioteca de paralelismo de SageMaker modelos a um script de treinamento. Observe que o script de treinamento agora inclui o decorador `smp.step`:
```
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchnet.dataset import SplitDataset
from torchvision import datasets
import smdistributed.modelparallel.torch as smp
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = F.relu(x)
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
x = self.fc1(x)
x = F.relu(x)
x = self.fc2(x)
return F.log_softmax(x, 1)
# smdistributed: Define smp.step. Return any tensors needed outside.
@smp.step
def train_step(model, data, target):
output = model(data)
loss = F.nll_loss(output, target, reduction="mean")
model.backward(loss)
return output, loss
def train(model, device, train_loader, optimizer):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
# smdistributed: Move input tensors to the GPU ID used by
# the current process, based on the set_device call.
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
# Return value, loss_mb is a StepOutput object
_, loss_mb = train_step(model, data, target)
# smdistributed: Average the loss across microbatches.
loss = loss_mb.reduce_mean()
optimizer.step()
# smdistributed: Initialize the backend
smp.init()
# smdistributed: Set the device to the GPU ID used by the current process.
# Input tensors should be transferred to this device.
torch.cuda.set_device(smp.local_rank())
device = torch.device("cuda")
# smdistributed: Download only on a single process per instance.
# When this is not present, the file is corrupted by multiple processes trying
# to download and extract at the same time
if smp.local_rank() == 0:
dataset = datasets.MNIST("../data", train=True, download=False)
smp.barrier()
# smdistributed: Shard the dataset based on data parallel ranks
if smp.dp_size() > 1:
partitions_dict = {f"{i}": 1 / smp.dp_size() for i in range(smp.dp_size())}
dataset = SplitDataset(dataset, partitions=partitions_dict)
dataset.select(f"{smp.dp_rank()}")
# smdistributed: Set drop_last=True to ensure that batch size is always divisible
# by the number of microbatches
train_loader = torch.utils.data.DataLoader(dataset, batch_size=64, drop_last=True)
model = Net()
# smdistributed: enable tensor parallelism only for model.fc1
smp.set_tensor_parallelism(model.fc1, True)
# smdistributed: Use the DistributedModel container to provide the model
# to be partitioned across different ranks. For the rest of the script,
# the returned DistributedModel object should be used in place of
# the model provided for DistributedModel class instantiation.
model = smp.DistributedModel(model)
optimizer = optim.AdaDelta(model.parameters(), lr=4.0)
optimizer = smp.DistributedOptimizer(optimizer)
train(model, device, train_loader, optimizer)
```
# Ajuda para modelos tipo transformador Hugging Face
O paralelismo tensorial da biblioteca de paralelismo de SageMaker modelos oferece suporte para os seguintes modelos do Hugging Face out-of-the-box Transformer:
+ GPT-2, BERT e Ro BERTa (disponível na biblioteca de paralelismo de SageMaker modelos v1.7.0 e posterior)
+ GPT-J (disponível na biblioteca de paralelismo de SageMaker modelos v1.8.0 e posterior)
+ GPT-Neo (disponível na biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)
**nota**
Para qualquer outro modelo de Transformers, você precisa usar a API [smdistributed.modelparallel.torch.tp\$1register\$1with\$1module()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tp_register_with_module) para aplicar o paralelismo de tensores.
**nota**
Para usar o paralelismo de tensores para treinar modelos do Hugging Face Transformer, certifique-se de usar os Hugging Face Deep Learning Containers, pois eles têm a biblioteca de paralelismo de modelos v1.7.0 e versões posteriores. PyTorch SageMaker Para obter mais informações, consulte as notas de lançamento da [biblioteca de paralelismo de SageMaker modelos](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html).
## Modelos compatíveis prontos para uso
Para os modelos de transformadores Hugging Face suportados pela biblioteca prontos para uso, você não precisa implementar manualmente ganchos para traduzir o Transformer em camadas de transformador. APIs `smdistributed` [Você pode ativar o paralelismo do tensor usando o gerenciador de contexto smdistributed.modelparallel.torch.tensor\$1parallelism () e agrupando o modelo com [smdistributed.modelparallel.torch](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tensor_parallelism). DistributedModel()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel). Você não precisa registrar manualmente os hooks para paralelismo de tensores usando a API `smp.tp_register`.
A tradução `state_dict` funciona entre Hugging Face Transformers e `smdistributed.modelparallel` pode ser acessada da seguinte forma:
+ `smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_state_dict_to_hf_gpt2(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_hf_state_dict_to_smdistributed_gpt2(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.bert.translate_state_dict_to_hf_bert(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.bert.translate_hf_state_dict_to_smdistributed_bert(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_state_dict_to_hf_roberta(state_dict, max_seq_len=None)`
+ `smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_hf_state_dict_to_smdistributed_roberta(state_dict)`
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_state_dict_to_hf_gptj(state_dict, max_seq_len=None)`(Disponível na biblioteca de paralelismo de SageMaker modelos v1.8.0 e posterior)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj`(Disponível na biblioteca de paralelismo de SageMaker modelos v1.8.0 e posterior)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None)`(Disponível na biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict)`(Disponível na biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)
** Exemplo de uso da função de tradução GPT-2**
Comece com o encapsulamento do modelo conforme mostrado no código a seguir.
```
from transformers import AutoModelForCausalLM
with smp.tensor_parallelism():
model = AutoModelForCausalLM.from_config(hf_gpt2_config)
model = smp.DistributedModel(model)
```
Com base `state_dict` no objeto `DistributedModel`, você pode carregar os pesos no modelo Hugging Face GPT-2 original usando a função `translate_state_dict_to_hf_gpt2` mostrada no código a seguir.
```
from smdistributed.modelparallel.torch.nn.huggingface.gpt2 \
import translate_state_dict_to_hf_gpt2
max_seq_len = 1024
# [... code block for training ...]
if smp.rdp_rank() == 0:
state_dict = dist_model.state_dict()
hf_state_dict = translate_state_dict_to_hf_gpt2(state_dict, max_seq_len)
# can now call model.load_state_dict(hf_state_dict) to the original HF model
```
**Exemplo de uso da função de BERTa tradução Ro**
Da mesma forma, dado um HuggingFace modelo compatível`state_dict`, você pode usar a `translate_hf_state_dict_to_smdistributed` função para convertê-la em um formato legível por`smp.DistributedModel`. Isso pode ser útil em casos de uso de aprendizado por transferência, em que um modelo pré-treinado é carregado em um `smp.DistributedModel` para ajuste fino paralelo ao modelo:
```
from smdistributed.modelparallel.torch.nn.huggingface.roberta \
import translate_state_dict_to_smdistributed
model = AutoModelForMaskedLM.from_config(roberta_config)
model = smp.DistributedModel(model)
pretrained_model = AutoModelForMaskedLM.from_pretrained("roberta-large")
translated_state_dict =
translate_state_dict_to_smdistributed(pretrained_model.state_dict())
# load the translated pretrained weights into the smp.DistributedModel
model.load_state_dict(translated_state_dict)
# start fine-tuning...
```
# Mecanismo de classificação ao usar uma combinação de paralelismo de pipeline e paralelismo de tensores
Esta seção explica como o mecanismo de classificação do paralelismo do modelo funciona com o paralelismo de tensores. Isso foi estendido do [Ranking Basics](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#ranking-basics) for [Principais características da biblioteca de SageMaker paralelismo de modelos](model-parallel-core-features.md). Com o paralelismo de tensores, a biblioteca apresenta três tipos de classificação e grupo de processos: APIs para classificação paralela de `smp.tp_rank()` tensores, classificação paralela de `smp.pp_rank()` pipeline e classificação paralela de dados reduzidos. `smp.rdp_rank()` Os grupos de processos de comunicação correspondentes são tensor parallel group (`TP_GROUP`), pipeline parallel group (`PP_GROUP`) e reduced-data parallel group (`RDP_GROUP`). Esses grupos são definidos da seguinte maneira:
+ Um *grupo paralelo de tensores* (`TP_GROUP`) é um subconjunto uniformemente divisível do grupo paralelo de dados, sobre o qual ocorre a distribuição paralela de módulos por tensores. Quando o grau de paralelismo do pipeline é 1, `TP_GROUP` é o mesmo que model *parallel group* (`MP_GROUP`).
+ Um *grupo paralelo de pipeline* (`PP_GROUP`) é o grupo de processos nos quais o paralelismo de pipeline ocorre. Quando o grau de paralelismo do tensor é 1, `PP_GROUP` é o mesmo que `MP_GROUP`.
+ Um grupo *paralelo de dados reduzidos* (`RDP_GROUP`) é um conjunto de processos que mantêm as mesmas partições de paralelismo de pipeline e as mesmas partições paralelas de tensor e realizam paralelismo de dados entre si. Isso é chamado de grupo paralelo de dados reduzido porque é um subconjunto de todo o grupo de paralelismo de dados, `DP_GROUP`. Para os parâmetros do modelo que são distribuídos dentro do `TP_GROUP`, a operação de gradiente `allreduce` é executada somente para grupos paralelos de dados reduzidos, enquanto para os parâmetros que não são distribuídos, o gradiente `allreduce` ocorre em todo o grupo `DP_GROUP`.
+ Um grupo paralelo de modelo (`MP_GROUP`) se refere a um grupo de processos que armazenam coletivamente o modelo inteiro. Consiste na união dos `PP_GROUP`s de todas as classificações que estão no processo atual `TP_GROUP`. Quando o grau de paralelismo do tensor é 1, `MP_GROUP` é equivalente a `PP_GROUP`. Também é consistente com a definição existente `MP_GROUP` de versões anteriores de `smdistributed`. Observe que a corrente `TP_GROUP` é um subconjunto da corrente `DP_GROUP` e da atual `MP_GROUP`.
*Para saber mais sobre o processo de comunicação APIs na biblioteca de paralelismo de SageMaker modelos, consulte a [API comum e a específica PyTorch](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_common_api.html#) [na documentação do SDK APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html) para PythonSageMaker .*
![\[Mecanismo de classificação, distribuição de parâmetros e AllReduce operações associadas do paralelismo tensorial.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/distributed/model-parallel/tensor-parallel-ranking-mechanism.png)
Por exemplo, considere grupos de processos para um único nó com 8 GPUs, em que o grau de paralelismo do tensor é 2, o grau de paralelismo do pipeline é 2 e o grau de paralelismo dos dados é 4. A parte central superior da figura anterior mostra um exemplo de modelo com 4 camadas. As partes inferior esquerda e inferior direita da figura ilustram o modelo de 4 camadas distribuídas em 4 GPUs usando paralelismo de tubulação e paralelismo de tensor, onde o paralelismo de tensor é usado para as duas camadas intermediárias. Essas duas figuras inferiores são cópias simples para ilustrar diferentes linhas de limite de grupos. O modelo particionado é replicado para paralelismo de dados em 0-3 e 4-7. GPUs A figura inferior esquerda mostra as definições de `MP_GROUP`, `PP_GROUP` e `TP_GROUP`. A figura inferior direita mostra`RDP_GROUP`,`DP_GROUP`, e `WORLD` sobre o mesmo conjunto de GPUs. Os gradientes das camadas e das fatias da camada que têm a mesma cor são `allreduce` unidos para paralelismo de dados. Por exemplo, a primeira camada (azul claro) transmite as operações `allreduce` em `DP_GROUP`, enquanto a fatia laranja escura na segunda camada só obtém as operações `allreduce` dentro do processo `RDP_GROUP`. As setas vermelhas escuras em negrito representam tensores com o lote inteiro `TP_GROUP`.
```
GPU0: pp_rank 0, tp_rank 0, rdp_rank 0, dp_rank 0, mp_rank 0
GPU1: pp_rank 1, tp_rank 0, rdp_rank 0, dp_rank 0, mp_rank 1
GPU2: pp_rank 0, tp_rank 1, rdp_rank 0, dp_rank 1, mp_rank 2
GPU3: pp_rank 1, tp_rank 1, rdp_rank 0, dp_rank 1, mp_rank 3
GPU4: pp_rank 0, tp_rank 0, rdp_rank 1, dp_rank 2, mp_rank 0
GPU5: pp_rank 1, tp_rank 0, rdp_rank 1, dp_rank 2, mp_rank 1
GPU6: pp_rank 0, tp_rank 1, rdp_rank 1, dp_rank 3, mp_rank 2
GPU7: pp_rank 1, tp_rank 1, rdp_rank 1, dp_rank 3, mp_rank 3
```
Neste exemplo, o paralelismo do pipeline ocorre entre os pares de GPU (0,1), (2,3), (4,5) e (6,7). Além disso, o paralelismo de dados (`allreduce`) ocorre em GPUs 0, 2, 4, 6 e de forma independente em GPUs 1, 3, 5, 7. O paralelismo do tensor ocorre em subconjuntos de `DP_GROUP`s, nos pares de GPU (0,2); (1,3); (4,6) e (5,7).
Para esse tipo de paralelismo híbrido de pipeline e tensor, a matemática para `data_parallel_degree` permanece a mesma de `data_parallel_degree = number_of_GPUs / pipeline_parallel_degree`. A biblioteca calcula ainda mais o grau paralelo de dados reduzido a partir da relação `reduced_data_parallel_degree * tensor_parallel_degree = data_parallel_degree` a seguir.
# Fragmentação de estado do otimizador
A *fragmentação de estado do otimizador* é uma técnica útil de economia de memória que fragmenta o estado do otimizador (o conjunto de pesos que descreve o estado do otimizador) em grupos de dispositivos paralelos de dados. Você pode usar a fragmentação de estado do otimizador sempre que usar um otimizador com estado (como Adam) ou um FP16 otimizador (que armazena ambos FP16 e FP32 cópias dos parâmetros).
**nota**
A fragmentação de estado do otimizador está disponível PyTorch na biblioteca de paralelismo de SageMaker modelos v1.6.0 e versões posteriores.
## Como usar a fragmentação de estado do otimizador
Você pode ativar a *fragmentação de estado do otimizador* definindo `"shard_optimizer_state": True` na configuração `modelparallel`.
Quando esse atributo é ativado, a biblioteca particiona o conjunto de parâmetros do modelo com base no grau de paralelismo de dados. Os gradientes correspondentes à `i`-ésima partição são reduzidos somente na `i`-enésima classificação paralela de dados. No final da primeira chamada para uma função decoradora `smp.step`, o otimizador encapsulado por `smp.DistributedOptimizer` redefine seus parâmetros para serem limitados apenas aos parâmetros correspondentes à partição da classificação paralela de dados atual. Os parâmetros redefinidos são chamados de *parâmetros virtuais* e compartilham o armazenamento subjacente com os parâmetros originais. Durante a primeira chamada para `optimizer.step`, os estados do otimizador são criados com base nesses parâmetros redefinidos, que são fragmentados por causa da partição original. Após a atualização do otimizador, a AllGather operação (como parte da `optimizer.step` chamada) é executada nas classificações paralelas de dados para obter estados de parâmetros consistentes.
**dica**
A fragmentação de estado do otimizador pode ser útil quando o grau de paralelismo de dados é maior que 1 e o modelo tem mais de um bilhão de parâmetros.
O grau de paralelismo de dados é calculado por `(processes_per_host * instance_count / pipeline_parallel_degree)`, e a função `smp.dp_size()` lida com o dimensionamento em segundo plano.
**Configurar um SageMaker PyTorch estimador**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True,
"shard_optimizer_state": True
}
}
```
**Adapte seu roteiro PyTorch de treinamento**
Consulte [Adaptar seu script PyTorch de treinamento](model-parallel-extended-features-pytorch-tensor-parallelism-examples.md#model-parallel-extended-features-pytorch-tensor-and-pipeline-parallelism-script) na seção *Paralelismo do tensor combinado com paralelismo do pipeline*. Não há nenhuma modificação adicional necessária para o script.
# Ponto de verificação de ativação
O *ponto de verificação de ativação* (ou *ponto de verificação de gradiente*) é uma técnica para reduzir o uso de memória limpando as ativações de determinadas camadas e recomputando-as durante uma passagem para trás. Efetivamente, isso troca o tempo extra de computação pelo uso reduzido da memória. Se um módulo for verificado, no final de uma passagem direta, as entradas e saídas do módulo permanecerão na memória. Quaisquer tensores intermediários que teriam feito parte da computação dentro desse módulo são liberados durante a passagem para frente. Durante a passagem para trás dos módulos com pontos de verificação, esses tensores são recalculados. Nesse ponto, as camadas além desse módulo de ponto de verificação concluíram sua passagem para trás, portanto, o pico de uso da memória com o ponto de verificação pode ser menor.
**nota**
Esse recurso está disponível PyTorch na biblioteca de paralelismo de SageMaker modelos v1.6.0 e versões posteriores.
## Como usar o ponto de verificação de ativação
Com `smdistributed.modelparallel`, você pode usar o ponto de verificação de ativação na granularidade de um módulo. Para todos os módulos `torch.nn`, exceto `torch.nn.Sequential`, você só pode verificar uma árvore de módulos se ela estiver dentro de uma partição do ponto de vista do paralelismo do pipeline. No caso do módulo `torch.nn.Sequential`, cada árvore de módulos dentro do módulo sequencial deve estar completamente dentro de uma partição para que o ponto de verificação de ativação funcione. Ao usar o particionamento manual, esteja ciente dessas restrições.
Ao usar o [particionamento automatizado de modelos](https://docs.aws.amazon.com/sagemaker/latest/dg/model-parallel-core-features.html#model-parallel-automated-model-splitting), você pode encontrar os logs de atribuição de particionamento começando com os logs `Partition assignments:` do trabalho de treinamento. Se um módulo for particionado em várias classificações (por exemplo, com um descendente em uma classificação e outro descendente em uma classificação diferente), a biblioteca ignora a tentativa de verificar o módulo e gera uma mensagem de aviso de que o módulo não será verificado.
**nota**
A biblioteca de paralelismo de SageMaker modelos suporta operações sobrepostas e não `allreduce` sobrepostas em combinação com pontos de verificação.
**nota**
PyTorchA API de ponto de verificação nativa do não é compatível com`smdistributed.modelparallel`.
**Exemplo 1:** O seguinte exemplo de código mostra como usar o ponto de verificação de ativação quando você tem uma definição de modelo em seu script.
```
import torch.nn as nn
import torch.nn.functional as F
from smdistributed.modelparallel.torch.patches.checkpoint import checkpoint
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.conv2 = nn.Conv2d(32, 64, 3, 1)
self.fc1 = nn.Linear(9216, 128)
self.fc2 = nn.Linear(128, 10)
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
x = F.max_pool2d(x, 2)
x = torch.flatten(x, 1)
# This call of fc1 will be checkpointed
x = checkpoint(self.fc1, x)
x = self.fc2(x)
return F.log_softmax(x, 1)
```
**Exemplo 2:** O seguinte exemplo de código mostra como usar o ponto de verificação de ativação quando você tem um modelo sequencial em seu script.
```
import torch.nn as nn
from smdistributed.modelparallel.torch.patches.checkpoint import checkpoint_sequential
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.seq = nn.Sequential(
nn.Conv2d(1,20,5),
nn.ReLU(),
nn.Conv2d(20,64,5),
nn.ReLU()
)
def forward(self, x):
# This call of self.seq will be checkpointed
x = checkpoint_sequential(self.seq, x)
return F.log_softmax(x, 1)
```
**Exemplo 3:** O código de exemplo a seguir mostra como usar o ponto de verificação de ativação ao importar um modelo pré-construído de uma biblioteca, como Hugging Face PyTorch Transformers. Independentemente de você verificar os módulos sequenciais ou não, faça o seguinte:
1. Embrulhe o modelo em `smp.DistributedModel()`.
1. Defina um objeto para camadas sequenciais.
1. Enrole o objeto da camada sequencial por `smp.set_activation_checkpointig()`.
```
import smdistributed.modelparallel.torch as smp
from transformers import AutoModelForCausalLM
smp.init()
model = AutoModelForCausalLM(*args, **kwargs)
model = smp.DistributedModel(model)
# Call set_activation_checkpointing API
transformer_layers = model.module.module.module.transformer.seq_layers
smp.set_activation_checkpointing(
transformer_layers, pack_args_as_tuple=True, strategy='each')
```
# Ativação e descarregamento
Quando o ponto de verificação de ativação e o paralelismo do pipeline estão ativados e o número de microlotes é maior que um, o *descarregamento de ativação* é um atributo adicional que pode reduzir ainda mais o uso de memória. O descarregamento de ativação move de forma assíncrona as ativações com pontos de verificação correspondentes aos microlotes que não estão sendo executados atualmente na CPU. Logo antes de a GPU precisar das ativações para o retrocesso do microlote, essa funcionalidade recupera previamente as ativações descarregadas da CPU.
**nota**
Esse recurso está disponível PyTorch na biblioteca de paralelismo de SageMaker modelos v1.6.0 e versões posteriores.
## Como usar o descarregamento de ativação
Use o descarregamento de ativação para reduzir o uso de memória quando **o número de microlotes for maior que 1 e o ponto de verificação de ativação estiver ativado** (consulte [Ponto de verificação de ativação](model-parallel-extended-features-pytorch-activation-checkpointing.md)). Quando o ponto de verificação de ativação não é usado, o descarregamento de ativação não tem efeito. Quando usado com apenas um microlote, ele não economiza memória.
Para usar o descarregamento de ativação, defina `"offload_activations": True` para a configuração `modelparallel`.
O descarregamento de ativação move as ativações pontuais nos módulos `nn.Sequential` para a CPU de forma assíncrona. A transferência de dados pelo PCIe link se sobrepõe à computação da GPU. O descarregamento acontece imediatamente, assim que a passagem para frente de uma determinada camada de ponto de verificação é calculada. As ativações são carregadas de volta na GPU pouco antes de serem necessárias para a reversão de um microlote específico. A transferência CPU-GPU também se sobrepõe à computação.
Para ajustar a antecedência com que as ativações são carregadas de volta na GPU, você pode usar o parâmetro de configuração `"activation_loading_horizon"` (o padrão é definido como 4, deve ser `int` maior que 0). Um horizonte de carregamento de ativação maior faria com que as ativações fossem carregadas de volta na GPU mais cedo. Se o horizonte for muito grande, o impacto do descarregamento de ativação na economia de memória pode ser diminuído. Se o horizonte for muito pequeno, as ativações podem não ser carregadas a tempo, reduzindo a quantidade de sobreposição e degradando o performance.
**dica**
O descarregamento de ativação pode ser útil para modelos grandes com mais de cem bilhões de parâmetros.
**Configurar um SageMaker PyTorch estimador**
```
mpi_options = {
"enabled" : True,
"processes_per_host" : 8, # 8 processes
"custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none "
}
smp_options = {
"enabled":True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2, # alias for "partitions"
"placement_strategy": "cluster",
"tensor_parallel_degree": 2, # tp over 2 devices
"ddp": True,
"offload_activations": True,
"activation_loading_horizon": 4 # optional. default is 4.
}
}
```
# FP16 Treinamento com paralelismo de modelos
Para FP16 treinamento, aplique as seguintes modificações em seu roteiro de treinamento e estimador.
**nota**
Esse recurso está disponível PyTorch na biblioteca de paralelismo de SageMaker modelos v1.10.0 e versões posteriores.
**Adapte seu roteiro PyTorch de treinamento**
1. Envolva seu modelo usando o gerenciador de contexto [smdistributed.modelparallel.torch.model\$1creation()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.model_creation).
```
# fp16_training_script.py
import torch
import smdistributed.modelparallel.torch as smp
with smp.model_creation(
dtype=torch.float16 if args.fp16 else torch.get_default_dtype()
):
model = ...
```
**dica**
Se você estiver usando paralelismo de tensores, adicione `tensor_parallelism=smp.tp_size() > 1` ao gerenciador de contexto `smp.model_creation`. Adicionar essa linha também ajuda a detectar automaticamente se o paralelismo do tensor está ativado ou não.
```
with smp.model_creation(
... ,
tensor_parallelism=smp.tp_size() > 1
):
model = ...
```
1. Ao encapsular o otimizador com `smdistributed.modelparallel.torch.DistributedOptimizer`, defina o argumento `static_loss_scaling` ou `dynamic_loss_scaling`. Por padrão, `static_loss_scaling` está definido como `1.0` e `dynamic_loss_scaling` está definido como `False`. Se você definir `dynamic_loss_scale=True`, poderá alimentar as opções dinâmicas de escalabilidade de perda como um dicionário por meio do argumento `dynamic_loss_args`. Na maioria dos casos, recomendamos que você use a escala de perda dinâmica com as opções padrão. [Para obter mais informações, opções e exemplos da função de encapsulamento do otimizador, consulte smdistributed.modelparallel.torch. DistributedOptimizer](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedoptimizer) API.
O código a seguir é um exemplo de encapsulamento de um objeto `Adadelta` otimizador com escala dinâmica de perda para treinamento. FP16
```
optimizer = torch.optim.Adadelta(...)
optimizer = smp.DistributedOptimizer(
optimizer,
static_loss_scale=None,
dynamic_loss_scale=True,
dynamic_loss_args={
"scale_window": 1000,
"min_scale": 1,
"delayed_shift": 2
}
)
```
**Configurar um SageMaker PyTorch estimador**
Adicione o FP16 parâmetro (`"fp16"`) à configuração de distribuição para paralelismo do modelo ao criar um SageMaker PyTorch objeto estimador. Para obter uma lista completa dos parâmetros de configuração do paralelismo do modelo, consulte [Parâmetros para `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#parameters-for-smdistributed).
```
from sagemaker.pytorch import PyTorch
smp_options = {
"enabled": True,
"parameters": {
"microbatches": 4,
"pipeline_parallel_degree": 2,
"tensor_parallel_degree": 2,
...,
"fp16": True
}
}
fp16_estimator = PyTorch(
entry_point="fp16_training_script.py", # Specify your train script
...,
distribution={
"smdistributed": {"modelparallel": smp_options},
"mpi": {...}
}
)
fp16_estimator.fit(...)
```
Quando o FP16 treinamento começa, o modelo e o otimizador são agrupados por `FP16_Module` e, `FP16_Optimizer` respectivamente, que são `smdistributed` versões modificadas dos utilitários do [Apex](https://nvidia.github.io/apex/fp16_utils.html#apex-fp16-utils). `FP16_Module`converte o modelo em FP16 dtype e lida com a passagem direta para dentro. FP16
**dica**
Você pode aplicar o recorte de gradiente chamando `clip_master_grads` antes de `optimizer.step`.
```
optimizer.clip_master_grads(max_norm) # max_norm(float or int): max norm of the gradients
```
**dica**
Ao usar `torch.optim.lr_scheduler` e FP16 treinar, você precisa passar `optimizer.optimizer` para o agendador LR em vez do otimizador. Veja o exemplo de código a seguir.
```
from torch.optim.lr_scheduler import StepLR
scheduler = StepLR(
optimizer.optimizer if smp.state.cfg.fp16 else optimizer,
step_size=1,
gamma=args.gamma
)
```
# Support for FlashAttention
Support for FlashAttention é um recurso da biblioteca aplicável apenas ao modelo de *transformador distribuído*, que é um modelo de transformador incluído [https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedmodel](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed-modelparallel-torch-distributedmodel)para treinamento paralelo de modelos. Esse atributo também é compatível com [Paralelismo de tensores](model-parallel-extended-features-pytorch-tensor-parallelism.md).
A [FlashAttention](https://github.com/HazyResearch/flash-attention)biblioteca só oferece suporte a modelos quando `attention_head_size` é definida com um valor múltiplo de 8 e menor que 128. Portanto, ao treinar um transformador distribuído e garantir que ele FlashAttention funcione corretamente, você deve ajustar os parâmetros para que o tamanho da cabeça de atenção atenda aos requisitos. Para obter mais informações, consulte também [Instalação e recursos](https://github.com/HazyResearch/flash-attention#installation-and-features) no *FlashAttention GitHubrepositório.*
Por exemplo, suponha que você configure um modelo Transformador com `hidden_width=864` e `num_heads=48`. O tamanho da cabeça de FlashAttention é calculado como`attention_head_size = hidden_width / num_heads = 864 / 48 = 18`. Para habilitar FlashAttention, você precisa ajustar o `num_heads` parâmetro para`54`, de forma que `attention_head_size = hidden_width / num_heads = 864 / 54 = 16` seja um múltiplo de 8.