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á.
# SageMaker Práticas recomendadas e considerações sobre o Training Compiler
**Importante**
A Amazon Web Services (AWS) anuncia que não haverá novos lançamentos ou versões do SageMaker Training Compiler. Você pode continuar a utilizar o SageMaker Training Compiler por meio dos AWS Deep Learning Containers (DLCs) existentes para SageMaker treinamento. É importante observar que, embora os existentes DLCs permaneçam acessíveis, eles não receberão mais patches ou atualizações de AWS, de acordo com a [Política de Suporte do AWS Deep Learning Containers Framework](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html).
Analise as seguintes práticas e considerações recomendadas ao usar o SageMaker Training Compiler.
## Práticas recomendadas
Use as diretrizes a seguir para obter os melhores resultados ao executar trabalhos de treinamento com o SageMaker Training Compiler.
**Melhores práticas gerais**
+ Certifique-se de usar um dos [Tipos de instâncias compatíveis](training-compiler-support.md#training-compiler-supported-instance-types) e [Modelos testados](training-compiler-support.md#training-compiler-tested-models).
+ Quando criar um tokenizador para um modelo de PNL usando Transformadores em 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 dinâmica de entrada pode iniciar a recompilação do modelo e pode aumentar o tempo total de treinamento. Para obter mais informações sobre as opções de preenchimento dos tokenizadores Transformadores, consulte [Preenchimento e truncamento](https://huggingface.co/docs/transformers/pad_truncation) na *documentação de Hugging Face Transformers*.
+ Meça a utilização da memória da GPU para garantir que você use o tamanho máximo do lote que cabe na memória da GPU. O Amazon SageMaker Training Compiler reduz o espaço de memória do seu modelo durante o treinamento, o que normalmente permite que você coloque uma memória maior `batch_size` na GPU. Usar um tamanho maior `batch_size` resulta em uma melhor utilização da GPU e reduz o tempo total de treinamento.
Ao ajustar o tamanho do lote, você também precisa ajustá-lo `learning_rate` adequadamente. Por exemplo, se você aumentou o tamanho do lote em um fator de `k`, precisará ajustar `learning_rate` linearmente (multiplicação simples por `k`) ou multiplicar pela raiz quadrada de `k`. Isso é para alcançar o mesmo comportamento de convergência ou similar no tempo de treinamento reduzido. Para obter uma referência sobre `batch_size` testado em modelos mais comuns, consulte [Modelos testados](training-compiler-support.md#training-compiler-tested-models).
+ Para depurar o trabalho de treinamento acelerado pelo compilador, ative o `debug` sinalizador no parâmetro. `compiler_config` Isso permite que a SageMaker IA coloque os registros de depuração nos registros de tarefas de SageMaker treinamento.
```
huggingface_estimator=HuggingFace(
...
compiler_config=TrainingCompilerConfig(debug=True)
)
```
Observe que, se você habilitar a depuração completa do trabalho de treinamento com o compilador, isso poderá adicionar alguma sobrecarga.
**Melhores práticas para PyTorch**
+ Se você trouxer um PyTorch modelo e quiser fazer um ponto de verificação, certifique-se de usar a função de salvamento de modelo do PyTorch /XLA para verificar seu modelo corretamente. Para obter mais informações sobre a função, consulte [https://pytorch.org/xla/release/1.9/index.html#torch_xla.core.xla_model.save](https://pytorch.org/xla/release/1.9/index.html#torch_xla.core.xla_model.save)a *documentação PyTorch sobre dispositivos XLA*.
Para saber como adicionar as modificações ao seu PyTorch script, consulte[Modelos de linguagem grandes usando PyTorch diretamente (sem a API Hugging Face Transformers Trainer)](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer).
Para obter mais informações sobre a aplicação real do uso da função de salvamento de modelo, consulte [Checkpoint Writing and Loading](https://huggingface.co/blog/pytorch-xla#checkpoint-writing-and-loading) in the *Hugging Face PyTorch/XLA TPUs on: blog de treinamento mais rápido* e barato.
+ Para obter o melhor tempo de treinamento para treinamento distribuído, considere o seguinte:
+ Use instâncias com várias GPUs em vez de usar instâncias de gpu única. Por exemplo, uma única instância `ml.p3dn.24xlarge` tem um tempo de treinamento mais rápido em comparação com 8 instâncias `ml.p3.2xlarge`.
+ Use instâncias compatíveis com a EFA, como `ml.p3dn.24xlarge` e `ml.p4d.24xlarge`. Esses tipos de instância aceleraram a velocidade da rede e reduziram o tempo de treinamento.
+ Ajuste o parâmetro `preprocessing_num_workers` para conjuntos de dados, para que o treinamento do modelo não seja atrasado pelo lento pré-processamento.
## Considerações
Considere o seguinte ao usar o SageMaker Training Compiler.
### Degradação do desempenho devido ao registro, pontos de verificação e criação de perfil
+ Evite registrar, apontar e criar perfis de tensores de modelo que levem a avaliações explícitas. Para entender o que é uma avaliação explícita, considere o seguinte exemplo de compilação de código:
```
a = b+c
e = a+d
```
Um compilador interpreta o código da seguinte forma e reduz o espaço de memória da variável `a`:
```
e = b+c+d
```
Agora, considere o seguinte caso em que o código é alterado para adicionar uma função de impressão para a variável `a`:
```
a = b+c
e = a+d
print(a)
```
O compilador faz uma avaliação explícita da variável `a` da seguinte forma:
```
e = b+c+d
a = b+c # Explicit evaluation
print(a)
```
Em PyTorch, por exemplo, evite usar [torch.tensor.items ()](https://pytorch.org/docs/stable/generated/torch.Tensor.item.html), que pode introduzir avaliações explícitas. No aprendizado profundo, essas avaliações explícitas podem causar sobrecarga porque interrompem as operações fundidas em um gráfico de compilação de um modelo e levam à recomputação dos tensores.
Se você ainda quiser avaliar periodicamente o modelo durante o treinamento usando o SageMaker Training Compiler, recomendamos registrar e fazer checkpoints com uma frequência menor para reduzir a sobrecarga devido a avaliações explícitas. Por exemplo, registre a cada 10 épocas em vez de cada época.
+ A compilação de gráficos é executada durante as primeiras etapas do treinamento. Como resultado, espera-se que as primeiras etapas sejam excepcionalmente lentas. No entanto, esse é um custo de compilação único e pode ser amortizado por treinamento por um período mais longo, pois a compilação torna as etapas futuras muito mais rápidas. A sobrecarga inicial de compilação depende do tamanho do modelo, do tamanho dos tensores de entrada e da distribuição das formas dos tensores de entrada.
### Uso incorreto do PyTorch/XLA APIs ao usar PyTorch diretamente
PyTorch/XLA define um conjunto de APIs para substituir parte do treinamento existente PyTorch. APIs Deixar de usá-los adequadamente leva ao fracasso do PyTorch treinamento.
+ Um dos erros mais comuns ao compilar um PyTorch modelo é devido a um tipo de dispositivo incorreto para operadores e tensores. Para compilar adequadamente um PyTorch modelo, certifique-se de usar dispositivos XLA ([https://pytorch.org/xla/release/1.9/index.html](https://pytorch.org/xla/release/1.9/index.html)) em vez de usar CUDA ou misturar dispositivos CUDA e dispositivos XLA.
+ `mark_step()` é uma barreira apenas para o XLA. Não configurá-lo corretamente faz com que um trabalho de treinamento pare.
+ PyTorch/XLA fornece treinamento distribuído adicional. APIs Deixar de programar APIs corretamente faz com que os gradientes sejam coletados incorretamente, o que causa uma falha na convergência do treinamento.
Para configurar adequadamente seu PyTorch script e evitar os usos incorretos da API mencionados acima, consulte. [Modelos de linguagem grandes usando PyTorch diretamente (sem a API Hugging Face Transformers Trainer)](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer)