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 PyTorch 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-pytorch-pysdk) + [Usando a operação `CreateTrainingJob` da API SageMaker AI](#training-compiler-enable-pytorch-api) ## Usando o SDK do SageMaker Python SageMaker O Training Compiler for PyTorch está disponível por meio das classes de estimadores de [https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-estimator)estrutura [https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)e SageMaker IA. Para ativar o SageMaker Training Compiler, adicione o `compiler_config` parâmetro aos estimadores de SageMaker IA. 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 pela PyTorch ou 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** O PyTorch suporte nativo está disponível no SageMaker Python SDK v2.121.0 e versões posteriores. Certifique-se de atualizar o SDK do SageMaker Python adequadamente. **nota** A partir da PyTorch v1.12.0, os contêineres do SageMaker Training Compiler para estão disponíveis. PyTorch Observe que os contêineres do SageMaker Training Compiler não PyTorch são pré-embalados com Hugging Face Transformers. Se precisar instalar a biblioteca no contêiner, certifique-se de adicionar o arquivo `requirements.txt` no diretório de origem ao enviar um trabalho de treinamento. Para PyTorch v1.11.0 e anteriores, use as versões anteriores dos contêineres do SageMaker Training Compiler para Hugging Face e. PyTorch Para obter uma lista completa de versões de framework e informações de contêiner correspondentes, consulte [Estruturas compatíveis](training-compiler-support.md#training-compiler-supported-frameworks). Para obter informações adequadas ao seu caso de uso, consulte uma das opções a seguir. ### Para treinamento em uma única GPU ------ #### [ PyTorch v1.12.0 and later ] Para compilar e treinar um PyTorch modelo, configure um PyTorch estimador de SageMaker IA com o SageMaker Training Compiler, conforme mostrado no exemplo de código a seguir. **nota** Esse PyTorch suporte nativo está disponível no SageMaker AI Python SDK v2.120.0 e versões posteriores. Certifique-se de atualizar o SDK do SageMaker AI Python. ``` from sagemaker.pytorch import PyTorch, 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 learning rate learning_rate=learning_rate_native/batch_size_native*batch_size hyperparameters={ "n_gpus": 1, "batch_size": batch_size, "learning_rate": learning_rate } pytorch_estimator=PyTorch( entry_point='train.py', source_dir='path-to-requirements-file', # Optional. Add this if need to install additional packages. instance_count=1, instance_type='ml.p3.2xlarge', framework_version='1.13.1', py_version='py3', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) pytorch_estimator.fit() ``` ------ #### [ Hugging Face Transformers with PyTorch v1.11.0 and before ] Para compilar e treinar um modelo de transformador PyTorch, configure um SageMaker estimador SageMaker AI Hugging Face com o Training Compiler, conforme mostrado no exemplo de código a seguir. ``` 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 learning rate learning_rate=learning_rate_native/batch_size_native*batch_size hyperparameters={ "n_gpus": 1, "batch_size": batch_size, "learning_rate": learning_rate } pytorch_huggingface_estimator=HuggingFace( entry_point='train.py', instance_count=1, instance_type='ml.p3.2xlarge', transformers_version='4.21.1', pytorch_version='1.11.0', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) pytorch_huggingface_estimator.fit() ``` Para preparar seu script de treinamento, consulte as páginas a seguir. + [Para treinamento em uma única GPU](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-single-gpu)[de um PyTorch modelo usando a API Hugging Face Transformers Trainer](https://huggingface.co/docs/transformers/main_classes/trainer) + [Para treinamento em uma única GPU](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-single-gpu)[de um PyTorch modelo sem a API Hugging Face Transformers Trainer](https://huggingface.co/transformers/main_classes/trainer.html) Para encontrar end-to-end exemplos, consulte os seguintes cadernos: + [Compile e treine um modelo Hugging Face Transformers Trainer para perguntas e respostas com o conjunto de dados do AD SQu](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/albert-base-v2/albert-base-v2.html) + [Compile e treine um modelo Hugging Face `BERT` Transformer com o conjunto de dados SST usando o Training Compiler SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/bert-base-cased/bert-base-cased-single-node-single-gpu.html) + [Compile e treine um modelo de treinamento de classificação binária com o SST2 conjunto de dados para treinamento de nó único em GPU](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/roberta-base/roberta-base.html) ------ ### Para treinamento distribuído ------ #### [ PyTorch v1.12 ] Para a PyTorch versão 1.12, você pode executar um treinamento distribuído com o SageMaker Training Compiler adicionando a `pytorch_xla` opção especificada ao `distribution` parâmetro da classe do estimador de SageMaker IA PyTorch. **nota** Esse PyTorch suporte nativo está disponível no SageMaker AI Python SDK v2.121.0 e versões posteriores. Certifique-se de atualizar o SDK do SageMaker AI Python. ``` from sagemaker.pytorch import PyTorch, 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 } pytorch_estimator=PyTorch( entry_point='your_training_script.py', source_dir='path-to-requirements-file', # Optional. Add this if need to install additional packages. instance_count=instance_count, instance_type=instance_type, framework_version='1.13.1', py_version='py3', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), distribution ={'pytorchxla' : { 'enabled': True }}, disable_profiler=True, debugger_hook_config=False ) pytorch_estimator.fit() ``` **dica** Para preparar seu roteiro de treinamento, consulte [PyTorch](training-compiler-pytorch-models.md) ------ #### [ Transformers v4.21 with PyTorch v1.11 ] Para a PyTorch versão 1.11 e versões posteriores, o SageMaker Training Compiler está disponível para treinamento distribuído com a `pytorch_xla` opção especificada no parâmetro. `distribution` ``` 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 } pytorch_huggingface_estimator=HuggingFace( entry_point='your_training_script.py', instance_count=instance_count, instance_type=instance_type, transformers_version='4.21.1', pytorch_version='1.11.0', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), distribution ={'pytorchxla' : { 'enabled': True }}, disable_profiler=True, debugger_hook_config=False ) pytorch_huggingface_estimator.fit() ``` **dica** Para preparar seu script de treinamento, consulte as páginas a seguir. [Para treinamento distribuído](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-distributed)[de um PyTorch modelo usando a API Hugging Face Transformers Trainer](https://huggingface.co/transformers/main_classes/trainer.html) [Para treinamento distribuído](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-distributed)[de um PyTorch modelo sem a API Hugging Face Transformers Trainer](https://huggingface.co/transformers/main_classes/trainer.html) ------ #### [ Transformers v4.17 with PyTorch v1.10.2 and before ] Para a versão compatível da PyTorch v1.10.2 e anteriores, o SageMaker Training Compiler requer um mecanismo alternativo para iniciar um trabalho de treinamento distribuído. Para executar o treinamento distribuído, o SageMaker Training Compiler exige que você passe um script de inicialização de treinamento distribuído de SageMaker IA para o `entry_point` argumento e passe seu script de treinamento para o `hyperparameters` argumento. O exemplo de código a seguir mostra como configurar um estimador SageMaker AI Hugging Face aplicando as alterações necessárias. ``` 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 training_script="your_training_script.py" hyperparameters={ "n_gpus": num_gpus, "batch_size": batch_size, "learning_rate": learning_rate, "training_script": training_script # Specify the file name of your training script. } pytorch_huggingface_estimator=HuggingFace( entry_point='distributed_training_launcher.py', # Specify the distributed training launcher script. instance_count=instance_count, instance_type=instance_type, transformers_version='4.17.0', pytorch_version='1.10.2', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) pytorch_huggingface_estimator.fit() ``` O script Inicializador deve ser semelhante ao seguinte: Ele empacota seu script de treinamento e configura o ambiente de treinamento distribuído, dependendo do tamanho da instância de treinamento de sua escolha. ``` # distributed_training_launcher.py #!/bin/python import subprocess import sys if __name__ == "__main__": arguments_command = " ".join([arg for arg in sys.argv[1:]]) """ The following line takes care of setting up an inter-node communication as well as managing intra-node workers for each GPU. """ subprocess.check_call("python -m torch_xla.distributed.sm_dist " + arguments_command, shell=True) ``` **dica** Para preparar seu script de treinamento, consulte as páginas a seguir. [Para treinamento distribuído](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-distributed)[de um PyTorch modelo usando a API Hugging Face Transformers Trainer](https://huggingface.co/transformers/main_classes/trainer.html) [Para treinamento distribuído](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-distributed)[de um PyTorch modelo sem a API Hugging Face Transformers Trainer](https://huggingface.co/transformers/main_classes/trainer.html) **dica** Para encontrar end-to-end exemplos, consulte os seguintes cadernos: [Compile e treine o GPT2 modelo usando a API Transformers Trainer com o SST2 conjunto de dados para treinamento de várias GPUs de nó único](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_single_node/language-modeling-multi-gpu-single-node.html) [Compile e treine o GPT2 modelo usando a API Transformers Trainer com o SST2 conjunto de dados para treinamento de vários nós e várias GPUs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_multiple_node/language-modeling-multi-gpu-multi-node.html) ------ 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 `pytorch_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. **nota** Para executar um treinamento distribuído com o SageMaker Training Compiler e a PyTorch versão 1.10.2 e anteriores, especifique o nome do arquivo de um script de inicialização para esse parâmetro. O script do lançador deve estar preparado para empacotar seu script de treinamento e configurar o ambiente de treinamento distribuído. Para obter mais informações, veja os cadernos de seguintes exemplos: [Compile e treine o GPT2 modelo usando a API Transformers Trainer com o SST2 conjunto de dados para treinamento de várias GPUs de nó único](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_single_node/language-modeling-multi-gpu-single-node.html) [Compile e treine o GPT2 modelo usando a API Transformers Trainer com o SST2 conjunto de dados para treinamento de vários nós e várias GPUs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_multiple_node/language-modeling-multi-gpu-multi-node.html) + `source_dir` (str): Opcional. Adicione isso se precisar instalar pacotes adicionais. Para instalar pacotes, você precisa preparar um arquivo `requirements.txt` nesse diretório. + `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 `pytorch_version` (str): Obrigatório. Especifique a PyTorch 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 estimador SageMaker AI Hugging Face, você deve especificar e. `transformers_version` `pytorch_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). **nota** Para executar um treinamento distribuído com o SageMaker Training Compiler e a PyTorch versão 1.10.2 e anteriores, você precisa adicionar um parâmetro adicional,`"training_script"`, para especificar seu script de treinamento, conforme mostrado no exemplo de código anterior. + `compiler_config`(TrainingCompilerConfig objeto) — Necessário para ativar o SageMaker Training Compiler. 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`. + `distribution` (dict): Opcional. Para executar um trabalho de treinamento distribuído com o SageMaker Training Compiler, adicione`distribution = { 'pytorchxla' : { 'enabled': True }}`. **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 a operação `CreateTrainingJob` da 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://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). ``` "AlgorithmSpecification": { "TrainingImage": "" }, "HyperParameters": { "sagemaker_training_compiler_enabled": "true", "sagemaker_training_compiler_debug_mode": "false", "sagemaker_pytorch_xla_multi_worker_enabled": "false" // set to "true" for distributed training } ``` 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).