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á.
# Execute trabalhos TensorFlow de treinamento com o SageMaker Training Compiler
Você pode usar qualquer uma das interfaces de SageMaker IA para executar um trabalho de treinamento com o SageMaker Training Compiler: Amazon SageMaker Studio Classic, Amazon SageMaker Notebook Instances e. AWS SDK para Python (Boto3) AWS Command Line Interface
**Topics**
+ [Usando o SDK do SageMaker Python](#training-compiler-enable-tensorflow-pysdk)
+ [Usando o SDK SageMaker AI Python e estendendo os contêineres de Deep Learning do SageMaker AI Framework](#training-compiler-enable-tensorflow-sdk-extend-container)
+ [Ativar o compilador de SageMaker treinamento usando a operação da `CreateTrainingJob` API SageMaker AI](#training-compiler-enable-tensorflow-api)
## Usando o SDK do SageMaker Python
Para ativar o SageMaker Training Compiler, adicione o `compiler_config` parâmetro ao estimador SageMaker AI TensorFlow ou Hugging Face. Importe a classe `TrainingCompilerConfig` e passe uma instância dela para o parâmetro `compiler_config`. Os exemplos de código a seguir mostram a estrutura das classes de estimadores de SageMaker IA com o SageMaker Training Compiler ativado.
**dica**
Para começar com os modelos pré-construídos fornecidos pelas bibliotecas TensorFlow e Transformers, tente usar os tamanhos de lote fornecidos na tabela de referência em. [Modelos testados](training-compiler-support.md#training-compiler-tested-models)
**nota**
SageMaker O Training Compiler for TensorFlow está disponível por meio dos estimadores da SageMaker estrutura AI [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)e [Hugging Face](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-estimator).
Para obter informações adequadas ao seu caso de uso, consulte uma das opções a seguir.
### Para treinamento em uma única GPU
------
#### [ TensorFlow ]
```
from sagemaker.tensorflow import TensorFlow, TrainingCompilerConfig
# the original max batch size that can fit into GPU memory without compiler
batch_size_native={{12}}
learning_rate_native=float('{{5e-5}}')
# an updated max batch size that can fit into GPU memory with compiler
batch_size={{64}}
# update the global learning rate
learning_rate=learning_rate_native/batch_size_native*batch_size
hyperparameters={
"n_gpus": 1,
"batch_size": batch_size,
"learning_rate": learning_rate
}
tensorflow_estimator=TensorFlow(
entry_point='{{train.py}}',
instance_count=1,
instance_type='{{ml.p3.2xlarge}}',
framework_version='{{2.9.1}}',
hyperparameters=hyperparameters,
compiler_config=TrainingCompilerConfig(),
disable_profiler=True,
debugger_hook_config=False
)
tensorflow_estimator.fit()
```
Para preparar seu script de treinamento, consulte as páginas a seguir.
+ [Para treinamento em uma única GPU](training-compiler-tensorflow.md#training-compiler-tensorflow-models-keras-single-gpu)de um modelo construído usando TensorFlow Keras (`tf.keras.*`).
+ [Para treinamento em uma única GPU](training-compiler-tensorflow.md#training-compiler-tensorflow-models-no-keras-single-gpu)de um modelo construído usando TensorFlow módulos (`tf.*`excluindo os módulos TensorFlow Keras).
------
#### [ Hugging Face Estimator with TensorFlow ]
```
from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig
# the original max batch size that can fit into GPU memory without compiler
batch_size_native={{12}}
learning_rate_native=float('{{5e-5}}')
# an updated max batch size that can fit into GPU memory with compiler
batch_size={{64}}
# update the global learning rate
learning_rate=learning_rate_native/batch_size_native*batch_size
hyperparameters={
"n_gpus": 1,
"batch_size": batch_size,
"learning_rate": learning_rate
}
tensorflow_huggingface_estimator=HuggingFace(
entry_point='{{train.py}}',
instance_count=1,
instance_type='{{ml.p3.2xlarge}}',
transformers_version='4.21.1',
tensorflow_version='2.6.3',
hyperparameters=hyperparameters,
compiler_config=TrainingCompilerConfig(),
disable_profiler=True,
debugger_hook_config=False
)
tensorflow_huggingface_estimator.fit()
```
Para preparar seu script de treinamento, consulte as páginas a seguir.
+ [Para treinamento em uma única GPU](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-keras-single-gpu)de um modelo TensorFlow Keras com Hugging Face Transformers
+ [Para treinamento em uma única GPU](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-no-keras-single-gpu)de uma TensorFlow modelo com Hugging Face Transformers
------
### Para treinamento distribuído
------
#### [ Hugging Face Estimator with TensorFlow ]
```
from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig
# choose an instance type, specify the number of instances you want to use,
# and set the num_gpus variable the number of GPUs per instance.
instance_count={{1}}
instance_type='{{ml.p3.8xlarge}}'
num_gpus={{4}}
# the original max batch size that can fit to GPU memory without compiler
batch_size_native={{16}}
learning_rate_native=float('{{5e-5}}')
# an updated max batch size that can fit to GPU memory with compiler
batch_size={{26}}
# update learning rate
learning_rate=learning_rate_native/batch_size_native*batch_size*num_gpus*instance_count
hyperparameters={
"n_gpus": num_gpus,
"batch_size": batch_size,
"learning_rate": learning_rate
}
tensorflow_huggingface_estimator=HuggingFace(
entry_point='{{train.py}}',
instance_count=instance_count,
instance_type=instance_type,
transformers_version='4.21.1',
tensorflow_version='2.6.3',
hyperparameters=hyperparameters,
compiler_config=TrainingCompilerConfig(),
disable_profiler=True,
debugger_hook_config=False
)
tensorflow_huggingface_estimator.fit()
```
**dica**
Para preparar seu script de treinamento, consulte as páginas a seguir.
[Para treinamento distribuído](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-keras-distributed)de um modelo TensorFlow Keras com Hugging Face Transformers
[Para treinamento distribuído](training-compiler-tensorflow.md#training-compiler-tensorflow-models-transformers-no-keras-distributed)de uma TensorFlow modelo com Hugging Face Transformers
------
A lista a seguir é o conjunto mínimo de parâmetros necessários para executar um trabalho de SageMaker treinamento com o compilador.
**nota**
Ao usar o estimador SageMaker AI Hugging Face, você deve especificar os parâmetros,,`hyperparameters`, e `compiler_config` para ativar o `transformers_version` Training `tensorflow_version` Compiler. SageMaker Você não pode usar `image_uri` para especificar manualmente os contêineres de aprendizado profundo integrados ao Training Compiler que estão listados em [Estruturas compatíveis](training-compiler-support.md#training-compiler-supported-frameworks).
+ `entry_point` (str): Obrigatório. Especifique o nome do arquivo do seu script de treinamento.
+ `instance_count` (int): Obrigatório. Especifique o número de instâncias.
+ `instance_type` (str): Obrigatório. Especifique o tipo de instância.
+ `transformers_version`(str) — Exigido somente ao usar o estimador SageMaker AI Hugging Face. Especifique a versão da biblioteca Hugging Face Transformers suportada pelo Training Compiler. SageMaker Para encontrar as versões disponíveis, consulte [Estruturas compatíveis](training-compiler-support.md#training-compiler-supported-frameworks).
+ `framework_version` ou `tensorflow_version` (str): Obrigatório. Especifique a TensorFlow versão compatível com o SageMaker Training Compiler. Para encontrar as versões disponíveis, consulte [Estruturas compatíveis](training-compiler-support.md#training-compiler-supported-frameworks).
**nota**
Ao usar o TensorFlow estimador de SageMaker IA, você deve especificar. `framework_version`
Ao usar o estimador SageMaker AI Hugging Face, você deve especificar e. `transformers_version` `tensorflow_version`
+ `hyperparameters` (dict): Opcional. Especifique hiperparâmetros para o trabalho de treinamento `n_gpus`, `batch_size` e. `learning_rate` Ao ativar o SageMaker Training Compiler, experimente lotes maiores e ajuste a taxa de aprendizado adequadamente. Para encontrar estudos de caso sobre o uso do compilador e tamanhos de lote ajustados para melhorar a velocidade de treinamento, consulte [Modelos testados](training-compiler-support.md#training-compiler-tested-models) e [SageMaker Exemplos de notebooks e blogs de compilador de treinamento](training-compiler-examples-and-blogs.md).
+ `compiler_config`(TrainingCompilerConfig objeto) — Obrigatório. Inclua esse parâmetro para ativar o SageMaker Training Compiler. Veja a seguir os parâmetros para a classe `TrainingCompilerConfig`.
+ `enabled` (bool): Opcional. Especifique `True` ou `False` ative ou desative o SageMaker Training Compiler. O valor padrão é `True`.
+ `debug` (bool): Opcional. Para receber logs de treinamento mais detalhados de seus trabalhos de treinamento acelerados por compilador, altere-os para `True`. No entanto, o registro adicional pode aumentar a sobrecarga e retardar o trabalho de treinamento compilado. O valor padrão é `False`.
**Atenção**
Se você ativar o SageMaker Debugger, isso poderá afetar o desempenho do SageMaker Training Compiler. Recomendamos que você desative o Debugger ao executar o SageMaker Training Compiler para garantir que não haja impacto no desempenho. Para obter mais informações, consulte [Considerações](training-compiler-tips-pitfalls.md#training-compiler-tips-pitfalls-considerations). Para desativar as funcionalidades do Depurador, adicione os dois argumentos a seguir ao estimador.
```
disable_profiler=True,
debugger_hook_config=False
```
Se o trabalho de treinamento com o compilador for iniciado com êxito, você receberá os seguintes logs durante a fase de inicialização do trabalho:
+ Com `TrainingCompilerConfig(debug=False)`
```
Found configuration for Training Compiler
Configuring SM Training Compiler...
```
+ Com `TrainingCompilerConfig(debug=True)`
```
Found configuration for Training Compiler
Configuring SM Training Compiler...
Training Compiler set to debug mode
```
## Usando o SDK SageMaker AI Python e estendendo os contêineres de Deep Learning do SageMaker AI Framework
AWS Deep Learning Containers (DLC) para TensorFlow uso em versões adaptadas TensorFlow que incluem mudanças na estrutura de código aberto TensorFlow . Os [SageMaker AI Framework Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) são otimizados para a AWS infraestrutura subjacente e a Amazon SageMaker AI. Com a vantagem de usar o DLCs, a integração do SageMaker Training Compiler adiciona mais melhorias de desempenho em relação à nativa TensorFlow. Além disso, você pode criar um contêiner de treinamento personalizado estendendo a imagem do DLC.
**nota**
Atualmente, esse recurso de personalização do Docker está disponível apenas para. TensorFlow
Para estender e personalizar a SageMaker IA TensorFlow DLCs para seu caso de uso, use as instruções a seguir.
### Crie um Dockerfile.
Use o modelo Dockerfile a seguir para estender o DLC SageMaker AI TensorFlow . Você deve usar a imagem SageMaker AI TensorFlow DLC como imagem base do seu contêiner Docker. Para encontrar a imagem do TensorFlow DLC SageMaker AI URIs, consulte [Estruturas suportadas](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-support.html#training-compiler-supported-frameworks).
```
# SageMaker AI TensorFlow Deep Learning Container image
FROM 763104351884.dkr.ecr.{{}}.amazonaws.com/tensorflow-training:{{}}
ENV PATH="/opt/ml/code:${PATH}"
# This environment variable is used by the SageMaker AI container
# to determine user code directory.
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code
# Add more code lines to customize for your use-case
...
```
Para mais informações, consulte [Etapa 2: Como criar e fazer upload dos scripts de treinamento do Dockerfile e do Python](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step2).
Considere as seguintes armadilhas ao estender o SageMaker AI Framework: DLCs
+ Não desinstale nem altere explicitamente a versão dos TensorFlow pacotes nos contêineres de SageMaker IA. Isso faz com que os TensorFlow pacotes AWS otimizados sejam substituídos por TensorFlow pacotes de código aberto, o que pode resultar na degradação do desempenho.
+ Cuidado com os pacotes que têm uma TensorFlow versão ou um sabor específico como dependência. Esses pacotes podem desinstalar implicitamente os pacotes AWS otimizados TensorFlow e instalar pacotes de código aberto TensorFlow .
[Por exemplo, há um problema conhecido de que as bibliotecas [tensorflow/models e [tensorflow/text](https://github.com/tensorflow/text)](https://github.com/tensorflow/models) sempre tentam reinstalar o código aberto. TensorFlow](https://github.com/tensorflow/models/issues/9267) Se você precisar instalar essas bibliotecas para escolher uma versão específica para seu caso de uso, recomendamos que você consulte os Dockerfiles do SageMaker AI TensorFlow DLC para v2.9 ou posterior. Os caminhos para os Dockerfiles geralmente estão no seguinte formato: `tensorflow/training/docker//py3//Dockerfile.gpu`. Nos Dockerfiles, você deve encontrar as linhas de código para reinstalar o TensorFlow binário AWS gerenciado (especificado para a variável de `TF_URL` ambiente) e outras dependências em ordem. A seção de Reinstalar deve se parecer com o seguinte exemplo:
```
# tf-models does not respect existing installations of TensorFlow
# and always installs open source TensorFlow
RUN pip3 install --no-cache-dir -U \
tf-models-official=={{x.y.z}}
RUN pip3 uninstall -y tensorflow tensorflow-gpu \
; pip3 install --no-cache-dir -U \
${TF_URL} \
tensorflow-io=={{x.y.z}} \
tensorflow-datasets=={{x.y.z}}
```
### Compile e envie para o ECR
Para compilar e enviar seu contêiner do Docker para o Amazon ECR, siga as instruções nos links a seguir.
+ [Etapa 3: Compilar o contêiner](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step3)
+ [Etapa 4: Testar o contêiner](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step4)
+ [Etapa 5: Enviar o contêiner para o Amazon ECR](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step5)
### Execute usando o SageMaker Python SDK Estimator
Use o estimador da TensorFlow estrutura de SageMaker IA como de costume. Você deve especificar `image_uri` para usar o novo contêiner que você hospedou no Amazon ECR.
```
import sagemaker, boto3
from sagemaker import get_execution_role
from sagemaker.tensorflow import TensorFlow, TrainingCompilerConfig
account_id = boto3.client('sts').get_caller_identity().get('Account')
ecr_repository = {{'tf-custom-container-test'}}
tag = {{':latest'}}
region = boto3.session.Session().region_name
uri_suffix = 'amazonaws.com'
byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format(
account_id, region, uri_suffix, ecr_repository + tag
)
byoc_image_uri
# This should return something like
# 111122223333.dkr.ecr.us-east-2.amazonaws.com/tf-custom-container-test:latest
estimator = TensorFlow(
image_uri=image_uri,
role=get_execution_role(),
base_job_name='{{tf-custom-container-test-job}}',
instance_count=1,
instance_type='{{ml.p3.8xlarge}}'
compiler_config=TrainingCompilerConfig(),
disable_profiler=True,
debugger_hook_config=False
)
# Start training
estimator.fit()
```
## Ativar o compilador de SageMaker treinamento usando a operação da `CreateTrainingJob` API SageMaker AI
SageMaker As opções de configuração do Training Compiler devem ser especificadas por meio do `HyperParameters` campo `AlgorithmSpecification` e na sintaxe da solicitação para a operação da [`CreateTrainingJob`API](https://amazonaws.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html).
```
"AlgorithmSpecification": {
"TrainingImage": "{{}}"
},
"HyperParameters": {
"sagemaker_training_compiler_enabled": "true",
"sagemaker_training_compiler_debug_mode": "false"
}
```
Para encontrar uma lista completa de imagens de contêiner de aprendizado profundo URIs que têm o SageMaker Training Compiler implementado, consulte[Estruturas compatíveis](training-compiler-support.md#training-compiler-supported-frameworks).