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á.
# PyTorch
Traga seu próprio PyTorch modelo para a SageMaker IA e execute o trabalho de treinamento com o SageMaker Training Compiler.
**Topics**
+ [PyTorch Modelos com transformadores Hugging Face](#training-compiler-pytorch-models-transformers)
## PyTorch Modelos com transformadores Hugging Face
PyTorch [os modelos com [Hugging Face Transformers](https://huggingface.co/docs/transformers/index) são baseados na API torch.nn.Module. PyTorch](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) O Hugging Face Transformers também fornece aulas de [treinamento](https://huggingface.co/docs/transformers/main_classes/trainer) e modelos pré-treinados para PyTorch ajudar a reduzir o esforço de configuração de modelos de processamento de linguagem natural (PNL). Depois de preparar seu script de treinamento, você pode iniciar um trabalho de treinamento usando a SageMaker IA `PyTorch` ou o `HuggingFace` estimador com a configuração do SageMaker Training Compiler ao prosseguir para o próximo tópico em. [Ativar compilador SageMaker de treinamento](training-compiler-enable.md)
**dica**
Ao criar uma tokenização para um modelo de PNL com o uso de transformações no seu script de treinamento, certifique-se de usar uma forma de tensor de entrada estática especificando `padding='max_length'`. Não use `padding='longest'` porque o preenchimento da sequência mais longa do lote pode alterar a forma do tensor de cada lote de treinamento. A forma de entrada dinâmica pode acionar a recompilação do modelo e aumentar o tempo total de treinamento. Para obter mais informações sobre as opções de preenchimento dos tokenizadores Transformers, consulte [Preenchimento e truncamento](https://huggingface.co/docs/transformers/pad_truncation) na *documentação de Hugging Face Transformers*.
**Topics**
+ [`Modelos de linguagem grandes usando a classe Hugging Face Transformers Trainer`](#training-compiler-pytorch-models-transformers-trainer)
+ [Modelos de linguagem grandes usando PyTorch diretamente (sem a API Hugging Face Transformers Trainer)](#training-compiler-pytorch-models-non-trainer)
### `Modelos de linguagem grandes usando a classe Hugging Face Transformers Trainer`
Se você usa a classe Trainer da biblioteca transformers, não precisa fazer nenhuma alteração adicional em seu script de treinamento. SageMaker O Training Compiler compila automaticamente seu modelo Trainer se você o habilitar por meio da classe estimador. O código a seguir mostra a forma básica de um script de PyTorch treinamento com a API Hugging Face Trainer.
```
from transformers import Trainer, TrainingArguments
training_args=TrainingArguments(**kwargs)
trainer=Trainer(args=training_args, **kwargs)
```
**Topics**
+ [Para treinamento em uma única GPU](#training-compiler-pytorch-models-transformers-trainer-single-gpu)
+ [Para treinamento distribuído](#training-compiler-pytorch-models-transformers-trainer-distributed)
+ [`Melhores práticas para usar o SageMaker Training Compiler com o Trainer`](#training-compiler-pytorch-models-transformers-trainer-best-practices)
#### Para treinamento em uma única GPU
Você não precisa alterar o código quando usar a classe [https://huggingface.co/docs/transformers/main_classes/trainer](https://huggingface.co/docs/transformers/main_classes/trainer).
#### Para treinamento distribuído
**PyTorch v1.11.0 e versões posteriores**
Para executar um treinamento distribuído com o SageMaker Training Compiler, você deve adicionar a `_mp_fn()` função a seguir em seu script de treinamento e encapsular a `main()` função. Ele redireciona as chamadas de `_mp_fn(index)` função do tempo de execução distribuído de SageMaker IA for PyTorch (`pytorchxla`) para a `main()` função do seu script de treinamento.
```
def _mp_fn(index):
main()
```
Essa função aceita o argumento `index` para indicar a classificação da GPU atual no cluster para treinamento distribuído. Para encontrar mais exemplos de scripts, consulte os [scripts de exemplo de modelagem da linguagem Hugging Face Transformers.](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling)
**Para Transformers v4.17 e anteriores com PyTorch v1.10.2 e anteriores**
SageMaker O Training Compiler usa um mecanismo alternativo para iniciar um trabalho de treinamento distribuído, e você não precisa fazer nenhuma modificação em seu script de treinamento. Em vez disso, o SageMaker Training Compiler exige que você passe um script de inicialização de treinamento distribuído por SageMaker IA para o `entry_point` argumento e passe seu script de treinamento para o `hyperparameters` argumento no estimador SageMaker AI Hugging Face.
#### `Melhores práticas para usar o SageMaker Training Compiler com o Trainer`
+ [Certifique-se de usar SyncFree otimizadores definindo o `optim` argumento como `adamw_torch_xla` ao configurar os transformadores. TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments). Veja também [Optimizer](https://huggingface.co/docs/transformers/v4.23.1/en/perf_train_gpu_one#optimizer) na *documentação do Hugging Face Transformers*.
+ Certifique-se de que a taxa de transferência do pipeline de processamento de dados seja maior do que o throughput do treinamento. Você pode ajustar os `preprocessing_num_workers` argumentos `dataloader_num_workers` e os argumentos dos [transformadores. TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments)classe para conseguir isso. Normalmente, eles precisam ser maiores ou iguais ao número de GPUs, mas menores que o número de CPUs.
Depois de concluir a adaptação do seu script de treinamento, prossiga para [Execute trabalhos PyTorch de treinamento com o SageMaker Training Compiler](training-compiler-enable-pytorch.md).
### Modelos de linguagem grandes usando PyTorch diretamente (sem a API Hugging Face Transformers Trainer)
Se você tiver um script de treinamento que seja usado PyTorch diretamente, precisará fazer alterações adicionais em seu script de PyTorch treinamento para implementá-lo PyTorch/XLA. Siga as instruções para modificar seu script para configurar adequadamente os PyTorch/XLA primativos.
**Topics**
+ [Para treinamento em uma única GPU](#training-compiler-pytorch-models-non-trainer-single-gpu)
+ [Para treinamento distribuído](#training-compiler-pytorch-models-non-trainer-distributed)
+ [Melhores práticas para usar o SageMaker Training Compiler com PyTorch/XLA](#training-compiler-pytorch-models-best-practices)
#### Para treinamento em uma única GPU
1. Importe as bibliotecas de otimização.
```
import torch_xla
import torch_xla.core.xla_model as xm
```
1. Altere o dispositivo de destino para XLA em vez de `torch.device("cuda")`
```
device=xm.xla_device()
```
1. Se você estiver usando PyTorch a [Precisão Mista Automática](https://pytorch.org/docs/stable/amp.html) (AMP), faça o seguinte:
1. Substitua `torch.cuda.amp` pelo seguinte:
```
import torch_xla.amp
```
1. Substitua `torch.optim.SGD` e `torch.optim.Adam` por um dos seguintes:
```
import torch_xla.amp.syncfree.Adam as adam
import torch_xla.amp.syncfree.SGD as SGD
```
1. Substitua `torch.cuda.amp.GradScaler` pelo seguinte:
```
import torch_xla.amp.GradScaler as grad_scaler
```
1. Se você não estiver usando AMP, substitua `optimizer.step()` pelo seguinte:
```
xm.optimizer_step(optimizer)
```
1. Se você estiver usando um carregador de dados distribuído, envolva seu carregador de dados na classe s: PyTorch/XLA `ParallelLoader`
```
import torch_xla.distributed.parallel_loader as pl
parallel_loader=pl.ParallelLoader(dataloader, [device]).per_device_loader(device)
```
1. Adicione `mark_step` no final do ciclo de treinamento quando não estiver usando `parallel_loader`:
```
xm.mark_step()
```
1. Para verificar seu treinamento, use o método de ponto PyTorch/XLA de verificação do modelo:
```
xm.save(model.state_dict(), path_to_save)
```
Depois de concluir a adaptação do seu roteiro de treinamento, prossiga para [Execute trabalhos PyTorch de treinamento com o SageMaker Training Compiler](training-compiler-enable-pytorch.md).
#### Para treinamento distribuído
Além das alterações listadas na seção [Para treinamento em uma única GPU](#training-compiler-pytorch-models-non-trainer-single-gpu) anterior, adicione as seguintes alterações para distribuir adequadamente o workload entre as GPUs.
1. Se estiver usando AMP, adicione `all_reduce` depois `scaler.scale(loss).backward()`:
```
gradients=xm._fetch_gradients(optimizer)
xm.all_reduce('sum', gradients, scale=1.0/xm.xrt_world_size())
```
1. Se você precisar definir variáveis para `local_ranks` e`world_size`, use um código semelhante ao seguinte:
```
local_rank=xm.get_local_ordinal()
world_size=xm.xrt_world_size()
```
1. Para qualquer `world_size` (`num_gpus_per_node*num_nodes`) maior que `1`, defina uma amostra de treino que deve ser semelhante ao seguinte:
```
import torch_xla.core.xla_model as xm
if xm.xrt_world_size() > 1:
train_sampler=torch.utils.data.distributed.DistributedSampler(
train_dataset,
num_replicas=xm.xrt_world_size(),
rank=xm.get_ordinal(),
shuffle=True
)
train_loader=torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch_size,
sampler=train_sampler,
drop_last=args.drop_last,
shuffle=False if train_sampler else True,
num_workers=args.num_workers
)
```
1. Faça as seguintes alterações para garantir que você use o `parallel_loader` fornecido pelo módulo`torch_xla distributed` .
```
import torch_xla.distributed.parallel_loader as pl
train_device_loader=pl.MpDeviceLoader(train_loader, device)
```
`train_device_loader`Funciona como um PyTorch carregador normal da seguinte forma:
```
for step, (data, target) in enumerate(train_device_loader):
optimizer.zero_grad()
output=model(data)
loss=torch.nn.NLLLoss(output, target)
loss.backward()
```
Com todas essas mudanças, você deve ser capaz de iniciar o treinamento distribuído com qualquer PyTorch modelo sem a API Transformer Trainer. Observe que essas instruções podem ser usadas tanto para várias GPUs de nó único quanto para várias GPUs de vários nós.
1. **Para PyTorch v1.11.0 e versões posteriores**
Para executar um treinamento distribuído com o SageMaker Training Compiler, você deve adicionar a `_mp_fn()` função a seguir em seu script de treinamento e encapsular a `main()` função. Ele redireciona as chamadas de `_mp_fn(index)` função do tempo de execução distribuído de SageMaker IA for PyTorch (`pytorchxla`) para a `main()` função do seu script de treinamento.
```
def _mp_fn(index):
main()
```
Essa função aceita o argumento `index` para indicar a classificação da GPU atual no cluster para treinamento distribuído. Para encontrar mais exemplos de scripts, consulte os [scripts de exemplo de modelagem da linguagem Hugging Face Transformers.](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling)
**Para Transformers v4.17 e anteriores com PyTorch v1.10.2 e anteriores**
SageMaker O Training Compiler usa um mecanismo alternativo para iniciar um trabalho de treinamento distribuído e exige que você passe um script de inicializador de treinamento distribuído de SageMaker IA para o `entry_point` argumento e passe seu script de treinamento para o `hyperparameters` argumento no estimador SageMaker AI Hugging Face.
Depois de concluir a adaptação do seu script de treinamento, prossiga para [Execute trabalhos PyTorch de treinamento com o SageMaker Training Compiler](training-compiler-enable-pytorch.md).
#### Melhores práticas para usar o SageMaker Training Compiler com PyTorch/XLA
Se você quiser aproveitar o SageMaker Training Compiler em seu script de PyTorch treinamento nativo, convém primeiro se familiarizar com os [PyTorch dispositivos XLA](https://pytorch.org/xla/release/1.9/index.html). As seções a seguir listam algumas das melhores práticas para habilitar o XLA. PyTorch
**nota**
Esta seção de melhores práticas pressupõe que você use os seguintes PyTorch/XLA módulos:
```
import torch_xla.core.xla_model as xm
import torch_xla.distributed.parallel_loader as pl
```
##### Entenda o modo preguiçoso em PyTorch/XLA
Uma diferença significativa entre PyTorch/XLA e o nativo PyTorch é que o PyTorch/XLA sistema é executado no modo lento, enquanto o nativo PyTorch é executado no modo ansioso. Os tensores no modo lazy são espaços reservados para construir o gráfico computacional até que sejam materializados após a conclusão da compilação e avaliação. O PyTorch/XLA sistema cria o gráfico computacional em tempo real quando você chama PyTorch APIs para criar a computação usando tensores e operadores. O gráfico computacional é compilado e executado quando `xm.mark_step()` é chamado explícita ou implicitamente por`pl.MpDeviceLoader/pl.ParallelLoader`, ou quando você solicita explicitamente o valor de um tensor, como, por exemplo, chamando `loss.item()` ou `print(loss)`.
##### Minimize o número de *compilação e execuções* usando `pl. MpDeviceLoader/pl.ParallelLoader`e `xm.step_closure`
Para obter o melhor desempenho, lembre-se das formas possíveis de iniciar a *compilação e as execuções*, conforme descrito em [Entenda o modo preguiçoso em PyTorch/XLA](#training-compiler-pytorch-models-best-practices-lazy-mode) e tente minimizar o número de compilações e execuções. Idealmente, apenas uma compilação e execução é necessária por iteração de treinamento e é iniciada automaticamente pelo `pl.MpDeviceLoader/pl.ParallelLoader`. O `MpDeviceLoader` é otimizado para XLA e sempre deve ser usado, se possível, para obter o melhor desempenho. Durante o treinamento, talvez você queira examinar alguns resultados intermediários, como valores de perda. Nesse caso, a impressão de tensores lazy deve ser empacotada usando-se `xm.add_step_closure()` para evitar compilações e execuções desnecessárias.
##### Use otimizadores AMP e `sem sincronização`
O treinamento no modo Automatic Mixed Precision (AMP) acelera significativamente sua velocidade de treinamento ao aproveitar os núcleos tensores das GPUs NVIDIA. SageMaker O Training Compiler fornece `syncfree` otimizadores otimizados para XLA para melhorar o desempenho do AMP. Atualmente, os três otimizadores `syncfree` a seguir estão disponíveis e devem ser usados, se possível, para obtenção do melhor desempenho.
```
torch_xla.amp.syncfree.SGD
torch_xla.amp.syncfree.Adam
torch_xla.amp.syncfree.AdamW
```
Esses `syncfree` otimizadores devem ser combinados com o `torch_xla.amp.GradScaler` gradiente. scaling/unscaling
**dica**
A partir da PyTorch versão 1.13.1, o SageMaker Training Compiler melhora o desempenho PyTorch/XLA ao permitir a substituição automática dos otimizadores (como SGD, Adam, AdamW) em `torch.optim` ou `transformers.optimization` com as versões sem sincronização deles em (como,,). `torch_xla.amp.syncfree` `torch_xla.amp.syncfree.SGD` `torch_xla.amp.syncfree.Adam` `torch_xla.amp.syncfree.AdamW` Você não precisa alterar as linhas de código nas quais define otimizadores em seu script de treinamento.