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á.
# Usar o seu próprio modelo de aprendizado profundo
**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).
Este guia explica como adaptar seu script de treinamento para um trabalho de treinamento acelerado por compilador. A preparação do seu script de treinamento depende do seguinte:
+ Configurações de treinamento, como treinamento de núcleo único ou distribuído.
+ Frameworks e bibliotecas que você usa para criar o script de treinamento.
Escolha um dos seguintes tópicos, dependendo do framework que você está utilizando:
**Topics**
+ [PyTorch](training-compiler-pytorch-models.md)
+ [TensorFlow](training-compiler-tensorflow.md)
**nota**
Depois de concluir a preparação do script de treinamento, você pode executar um trabalho de SageMaker treinamento usando as classes de estimador da estrutura de SageMaker IA. Para obter mais informações, consulte o tópico anterior em [Ativar compilador SageMaker de treinamento](training-compiler-enable.md).
# 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 `Trainer` de Hugging Face Transformers](#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 `Trainer` de Hugging Face Transformers
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 `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 `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ê tem um script de treinamento que usa PyTorch diretamente, você precisa fazer alterações adicionais em seu script de PyTorch treinamento para implementar PyTorch /XLA. Siga as instruções para modificar seu script para configurar corretamente as primativas PyTorch /XLA.
**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 /XLA: PyTorch `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 de verificação do modelo PyTorch /XLA:
```
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 [Para treinamento em uma única GPU](#training-compiler-pytorch-models-non-trainer-single-gpu) seção anterior, adicione as seguintes alterações para distribuir adequadamente a carga de trabalho. 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 lento em /XLA PyTorch
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ê liga 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 *compilation-and-executions*usos `pl.MpDeviceLoader/pl.ParallelLoader` e `xm.step_closure`
Para obter o melhor desempenho, lembre-se das formas possíveis de iniciar, *compilation-and-executions*conforme descrito em, [Entenda o modo lento em /XLA PyTorch](#training-compiler-pytorch-models-best-practices-lazy-mode) e tente minimizar o número de compilation-and-executions. Idealmente, apenas um compilation-and-execution é necessário por iteração de treinamento e é iniciado 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 preguiçosos deve ser embrulhada usando `xm.add_step_closure()` para evitar o desnecessário. compilation-and-executions
##### Use AMP e otimizadores `syncfree`
O treinamento no modo Automatic Mixed Precision (AMP) acelera significativamente sua velocidade de treinamento ao aproveitar os núcleos tensores da NVIDIA. GPUs 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 otimizadores `syncfree` devem ser combinados para escalonamento/desescalonamento de gradiente `torch_xla.amp.GradScaler`.
**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 (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.
# TensorFlow
Traga seu próprio TensorFlow modelo para a SageMaker IA e execute o trabalho de treinamento com o SageMaker Training Compiler.
## TensorFlow Modelos
SageMaker O Training Compiler otimiza automaticamente as cargas de trabalho de treinamento de modelos criadas com base na TensorFlow API nativa ou na API Keras de alto nível.
**dica**
Para pré-processar seu conjunto de dados de entrada, certifique-se de usar um formato de entrada estática. O formato de entradas dinâmicas pode iniciar a recompilação do modelo e pode aumentar o tempo total de treinamento.
### Usando o Keras (recomendado)
[Para obter a melhor aceleração do compilador, recomendamos usar modelos que sejam subclasses de Keras ( TensorFlow tf.keras.Model).](https://www.tensorflow.org/api_docs/python/tf/keras/Model)
#### Para treinamento em uma única GPU
Não há nenhuma alteração adicional que você precise fazer no script de treinamento.
### Sem o Keras
SageMaker O Training Compiler não oferece suporte à execução antecipada em. TensorFlow Portanto, você deve envolver seu modelo e os loops de treinamento com a TensorFlow função decorator (`@tf.function`) para aproveitar a aceleração do compilador.
SageMaker [O Training Compiler executa uma otimização em nível de gráfico e usa o decorador para garantir que suas TensorFlow funções estejam configuradas para serem executadas no modo gráfico.](https://www.tensorflow.org/guide/intro_to_graphs)
#### Para treinamento em uma única GPU
TensorFlow A versão 2.0 ou posterior tem a execução rápida ativada por padrão, então você deve adicionar o `@tf.function` decorador na frente de cada função usada para construir um modelo. TensorFlow
## TensorFlow Modelos com transformadores Hugging Face
TensorFlow [os modelos com [Hugging Face Transformers](https://huggingface.co/docs/transformers/index) são baseados na API tf.keras.Model. TensorFlow](https://www.tensorflow.org/api_docs/python/tf/keras/Model) O Hugging Face Transformers também fornece classes de modelos pré-treinados TensorFlow para ajudar a reduzir o esforço de configuração de modelos de processamento de linguagem natural (PNL). Depois de criar seu próprio script de treinamento usando a biblioteca Transformers, você pode executar o script de treinamento usando o `HuggingFace` estimador de SageMaker IA com a classe de configuração do SageMaker Training Compiler, conforme mostrado no tópico anterior em. [Execute trabalhos TensorFlow de treinamento com o SageMaker Training Compiler](training-compiler-enable-tensorflow.md)
SageMaker O Training Compiler otimiza automaticamente as cargas de trabalho de treinamento de modelos criadas com base na TensorFlow API nativa ou na API Keras de alto nível, como os modelos de transformadores. TensorFlow
**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 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 de tokenização de transformadores, consulte [Preenchimento e truncamento](https://huggingface.co/docs/transformers/pad_truncation) na documentação de *Transformadores do Hugging Face*.
**Topics**
+ [Como usar o Keras](#training-compiler-tensorflow-models-transformers-keras)
+ [Sem o Keras](#training-compiler-tensorflow-models-transformers-no-keras)
### Como usar o Keras
[Para obter a melhor aceleração do compilador, recomendamos usar modelos que sejam subclasses de Keras ( TensorFlow tf.keras.Model).](https://www.tensorflow.org/api_docs/python/tf/keras/Model) Conforme observado na página [Quick Tour](https://huggingface.co/docs/transformers/quicktour) na *documentação do Hugging Face Transformers*, você pode usar os modelos como modelos Keras regulares. TensorFlow
#### Para treinamento em uma única GPU
Não há nenhuma alteração adicional que você precise fazer no script de treinamento.
#### Para treinamento distribuído
SageMaker A aceleração do Training Compiler funciona de forma transparente para cargas de trabalho com várias GPUs quando o modelo é construído e treinado usando Keras APIs dentro do escopo da chamada. [https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy](https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy)
1. Escolha a estratégia correta de treinamento distribuído.
1. Para várias GPUs de nó único, use `tf.distribute.MirroredStrategy` para configurar a estratégia.
```
strategy = tf.distribute.MirroredStrategy()
```
1. Para várias GPUs de vários nós, adicione o código a seguir para definir adequadamente a configuração de treinamento TensorFlow distribuído antes de criar a estratégia.
```
def set_sm_dist_config():
DEFAULT_PORT = '8890'
DEFAULT_CONFIG_FILE = '/opt/ml/input/config/resourceconfig.json'
with open(DEFAULT_CONFIG_FILE) as f:
config = json.loads(f.read())
current_host = config['current_host']
tf_config = {
'cluster': {
'worker': []
},
'task': {'type': 'worker', 'index': -1}
}
for i, host in enumerate(config['hosts']):
tf_config['cluster']['worker'].append("%s:%s" % (host, DEFAULT_PORT))
if current_host == host:
tf_config['task']['index'] = i
os.environ['TF_CONFIG'] = json.dumps(tf_config)
set_sm_dist_config()
```
Use `tf.distribute.MultiWorkerMirroredStrategy` para configurar a estratégia.
```
strategy = tf.distribute.MultiWorkerMirroredStrategy()
```
1. Usando a estratégia de sua escolha, conclua o modelo.
```
with strategy.scope():
# create a model and do fit
```
### Sem o Keras
Se você quiser trazer modelos personalizados com loops de treinamento personalizados TensorFlow sem o Keras, envolva o modelo e o loop de treinamento com a TensorFlow função decorator (`@tf.function`) para aproveitar a aceleração do compilador.
SageMaker O Training Compiler executa uma otimização em nível de gráfico e usa o decorador para garantir que suas TensorFlow funções estejam configuradas para serem executadas no modo gráfico.
#### Para treinamento em uma única GPU
TensorFlow A versão 2.0 ou posterior tem a execução rápida ativada por padrão, então você deve adicionar o `@tf.function` decorador na frente de cada função usada para construir um modelo. TensorFlow
#### Para treinamento distribuído
Além das alterações necessárias para [Usar o Keras para treinamento distribuído](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-tensorflow-models.html#training-compiler-tensorflow-models-transformers-keras), você precisa garantir que as funções a serem executadas em cada GPU sejam anotadas com `@tf.function`, enquanto as funções de comunicação entre GPUs não forem anotadas. O código de treinamento de exemplo deve se parecer com o seguinte:
```
@tf.function()
def compiled_step(inputs, outputs):
with tf.GradientTape() as tape:
pred=model(inputs, training=True)
total_loss=loss_object(outputs, pred)/args.batch_size
gradients=tape.gradient(total_loss, model.trainable_variables)
return total_loss, pred, gradients
def train_step(inputs, outputs):
total_loss, pred, gradients=compiled_step(inputs, outputs)
if args.weight_decay > 0.:
gradients=[g+v*args.weight_decay for g,v in zip(gradients, model.trainable_variables)]
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
train_loss.update_state(total_loss)
train_accuracy.update_state(outputs, pred)
@tf.function()
def train_step_dist(inputs, outputs):
strategy.run(train_step, args= (inputs, outputs))
```
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.