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á.

# Prepare e execute um trabalho de treinamento com o SageMaker Profiler
<a name="profiler-prepare"></a>

A configuração para executar um trabalho de treinamento com o SageMaker Profiler consiste em duas etapas: adaptar o script de treinamento e configurar o iniciador do trabalho de SageMaker treinamento.

**Topics**
+ [Etapa 1: Adapte seu script de treinamento usando os módulos SageMaker Profiler Python](#profiler-prepare-training-script)
+ [Etapa 2: criar um estimador de estrutura de SageMaker IA e ativar o Profiler SageMaker](#profiler-profilerconfig)
+ [(Opcional) Instale o pacote SageMaker Profiler Python](#profiler-install-python-package)

## Etapa 1: Adapte seu script de treinamento usando os módulos SageMaker Profiler Python
<a name="profiler-prepare-training-script"></a>

Para começar a capturar as execuções do kernel GPUs enquanto o trabalho de treinamento está em execução, modifique seu script de treinamento usando os módulos do SageMaker Profiler Python. Importe a biblioteca e adicione os métodos `start_profiling()` e `stop_profiling()` para definir o início e o fim da criação de perfil. Você também pode usar anotações personalizadas opcionais para adicionar marcadores no script de treinamento para visualizar as atividades do hardware durante operações específicas em cada etapa.

Observe que os anotadores extraem operações de. GPUs Para operações de criação de perfil em CPUs, você não precisa adicionar nenhuma anotação adicional. A criação de perfil de CPU também é ativada quando você especifica a configuração de criação de perfil, a qual você praticará em [Etapa 2: criar um estimador de estrutura de SageMaker IA e ativar o Profiler SageMaker](#profiler-profilerconfig).

**nota**  
Definir o perfil de um trabalho de treinamento completo não é o uso mais eficiente dos recursos. Recomendamos traçar o perfil de no máximo 300 etapas de um trabalho de treinamento.

**Importante**  
O lançamento em [14 de dezembro de 2023](profiler-release-notes.md#profiler-release-notes-20231214) envolve uma alteração significativa. O nome do pacote SageMaker Profiler Python foi alterado `smppy` de para. `smprof` Isso é efetivo nos [contêineres do SageMaker AI Framework](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) para TensorFlow v2.12 e versões posteriores.  
Se você usa uma das versões anteriores dos [contêineres do SageMaker AI Framework](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only), como a TensorFlow v2.11.0, o pacote Profiler SageMaker Python ainda estará disponível como. `smppy` Se você não tiver certeza sobre qual versão ou nome do pacote deve usar, substitua a instrução de importação do pacote SageMaker Profiler pelo seguinte trecho de código.  

```
try:
    import smprof 
except ImportError:
    # backward-compatability for TF 2.11 and PT 1.13.1 images
    import smppy as smprof
```

**Abordagem 1.** Use o gerenciador de contexto `smprof.annotate` para anotar funções completas

Você pode agrupar funções completas com o gerenciador de contexto `smprof.annotate()`. Esse wrapper é recomendado se você quiser criar perfis por funções em vez de linhas de código. O script de exemplo a seguir mostra como implementar o gerenciador de contexto para encapsular o ciclo de treinamento e as funções completas em cada iteração.

```
import smprof

SMProf = smprof.SMProfiler.instance()
config = smprof.Config()
config.profiler = {
    "EnableCuda": "1",
}
SMProf.configure(config)
SMProf.start_profiling()

for epoch in range(args.epochs):
    if world_size > 1:
        sampler.set_epoch(epoch)
    tstart = time.perf_counter()
    for i, data in enumerate(trainloader, 0):
        with smprof.annotate({{"step_"+str(i)}}):
            inputs, labels = data
            inputs = inputs.to("cuda", non_blocking=True)
            labels = labels.to("cuda", non_blocking=True)
    
            optimizer.zero_grad()
    
            with smprof.annotate({{"Forward"}}):
                outputs = net(inputs)
            with smprof.annotate({{"Loss"}}):
                loss = criterion(outputs, labels)
            with smprof.annotate({{"Backward"}}):
                loss.backward()
            with smprof.annotate({{"Optimizer"}}):
                optimizer.step()

SMProf.stop_profiling()
```

**Abordagem 2.** Use `smprof.annotation_begin()` e `smprof.annotation_end()` para anotar uma linha de código específica nas funções

Você também pode definir anotações para traçar o perfil de linhas de código específicas. Você pode definir o ponto inicial e final exatos da criação de perfil no nível das linhas de código individuais, não pelas funções. Por exemplo, no script a seguir, o `step_annotator` é definido no início de cada iteração e termina no final da iteração. Enquanto isso, outros anotadores detalhados para cada operação são definidos e envolvem as operações de destino em cada iteração.

```
import smprof

SMProf = smprof.SMProfiler.instance()
config = smprof.Config()
config.profiler = {
    "EnableCuda": "1",
}
SMProf.configure(config)
SMProf.start_profiling()

for epoch in range(args.epochs):
    if world_size > 1:
        sampler.set_epoch(epoch)
    tstart = time.perf_counter()
    for i, data in enumerate(trainloader, 0):
        step_annotator = smprof.annotation_begin({{"step_" + str(i)}})

        inputs, labels = data
        inputs = inputs.to("cuda", non_blocking=True)
        labels = labels.to("cuda", non_blocking=True)
        optimizer.zero_grad()

        forward_annotator = smprof.annotation_begin({{"Forward"}})
        outputs = net(inputs)
        smprof.annotation_end(forward_annotator)

        loss_annotator = smprof.annotation_begin({{"Loss"}})
        loss = criterion(outputs, labels)
        smprof.annotation_end(loss_annotator)

        backward_annotator = smprof.annotation_begin({{"Backward"}})
        loss.backward()
        smprof.annotation_end(backward_annotator)

        optimizer_annotator = smprof.annotation_begin({{"Optimizer"}})
        optimizer.step()
        smprof.annotation_end(optimizer_annotator)

        smprof.annotation_end(step_annotator)

SMProf.stop_profiling()
```

Depois de anotar e configurar os módulos de iniciação do profiler, salve o script para enviar usando um inicializador de tarefas de SageMaker treinamento na próxima Etapa 2. O iniciador de exemplo presume que o script de treinamento seja chamado de `train_with_profiler_demo.py`.

## Etapa 2: criar um estimador de estrutura de SageMaker IA e ativar o Profiler SageMaker
<a name="profiler-profilerconfig"></a>

O procedimento a seguir mostra como preparar um estimador de estrutura de SageMaker IA para treinamento usando o SDK do Python SageMaker .

1. Configure um objeto `profiler_config` usando os módulos `ProfilerConfig` e `Profiler` da seguinte forma:

   ```
   from sagemaker import ProfilerConfig, Profiler
   profiler_config = ProfilerConfig(
       profile_params = Profiler(cpu_profiling_duration=3600)
   )
   ```

   A seguir está a descrição do módulo `Profiler` e do argumento.
   +  `Profiler`: O módulo para ativar o SageMaker Profiler com o trabalho de treinamento.
     +  `cpu_profiling_duration`(int): especifique a duração do tempo em segundos para a criação de perfil. CPUs O padrão é 3600 segundos. 

1. Crie um estimador de estrutura de SageMaker IA com o `profiler_config` objeto criado na etapa anterior. O código a seguir mostra um exemplo de criação de um PyTorch estimador. Se você quiser criar um TensorFlow estimador, importe `sagemaker.tensorflow.TensorFlow` em vez disso e especifique uma das [TensorFlowversões](profiler-support.md#profiler-support-frameworks-tensorflow) suportadas pelo SageMaker Profiler. Para obter mais informações sobre os tipos de instâncias compatível com as estruturas, consulte [SageMaker Imagens da estrutura de IA pré-instaladas com SageMaker o Profiler](profiler-support.md#profiler-support-frameworks).

   ```
   import sagemaker
   from sagemaker.pytorch import PyTorch
   
   estimator = PyTorch(
       framework_version="{{2.0.0}}",
       role=sagemaker.get_execution_role(),
       entry_point="{{train_with_profiler_demo.py}}", # your training job entry point
       source_dir={{source_dir}}, # source directory for your training script
       output_path={{output_path}},
       base_job_name="{{sagemaker-profiler-demo}}",
       hyperparameters={{hyperparameters}}, # if any
       instance_count={{1}}, # Recommended to test with < 8
       instance_type={{ml.p4d.24xlarge}},
       profiler_config={{profiler_config}}
   )
   ```

1. Inicie o trabalho de treinamento executando o método `fit`. Com o `wait=False`, você pode silenciar os logs de trabalhos de treinamento e deixá-los em execução em segundo plano.

   ```
   estimator.fit(wait=False)
   ```

Durante a execução do trabalho de treinamento ou após a conclusão do trabalho, você pode ir para o próximo tópico em [Abra o aplicativo SageMaker Profiler UI](profiler-access-smprofiler-ui.md) e começar a explorar e visualizar os perfis salvos.

Se você quiser acessar diretamente os dados do perfil salvos no bucket do Amazon S3, use o script a seguir para recuperar o URI do S3.

```
import os
# This is an ad-hoc function to get the S3 URI
# to where the profile output data is saved
def get_detailed_profiler_output_uri(estimator):
    config_name = None
    for processing in estimator.profiler_rule_configs:
        params = processing.get("RuleParameters", dict())
        rule = config_name = params.get("rule_to_invoke", "")
        if rule == "DetailedProfilerProcessing":
            config_name = processing.get("RuleConfigurationName")
            break
    return os.path.join(
        estimator.output_path, 
        estimator.latest_training_job.name, 
        "rule-output",
        config_name,
    )

print(
    f"Profiler output S3 bucket: ", 
    get_detailed_profiler_output_uri(estimator)
)
```

## (Opcional) Instale o pacote SageMaker Profiler Python
<a name="profiler-install-python-package"></a>

Para usar o SageMaker Profiler em PyTorch imagens de TensorFlow estrutura não listadas ou em [SageMaker Imagens da estrutura de IA pré-instaladas com SageMaker o Profiler](profiler-support.md#profiler-support-frameworks) seu próprio contêiner Docker personalizado para treinamento, você pode instalar o SageMaker Profiler usando um dos. [SageMaker Arquivos binários do pacote Profiler Python](profiler-support.md#profiler-python-package)

**Opção 1: instalar o pacote SageMaker Profiler ao iniciar um trabalho de treinamento**

[Se você quiser usar o SageMaker Profiler para treinar trabalhos usando PyTorch TensorFlow imagens não listadas[SageMaker Imagens da estrutura de IA pré-instaladas com SageMaker o Profiler](profiler-support.md#profiler-support-frameworks), crie um `requirements.txt` arquivo e localize-o no caminho especificado para o `source_dir` parâmetro do estimador da estrutura de SageMaker IA na Etapa 2.](#profiler-profilerconfig) Para obter mais informações sobre como configurar um `requirements.txt` arquivo em geral, consulte Como [usar bibliotecas de terceiros](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#using-third-party-libraries) na documentação do *SDK do SageMaker Python*. No arquivo `requirements.txt`, adicione um dos caminhos de bucket do S3 para o [SageMaker Arquivos binários do pacote Profiler Python](profiler-support.md#profiler-python-package).

```
# requirements.txt
https://smppy.s3.amazonaws.com/{{tensorflow/cu112/smprof-0.3.332-cp39-cp39-linux_x86_64.whl}}
```

**Opção 2: instalar o pacote SageMaker Profiler em seus contêineres personalizados do Docker**

Se você usa um contêiner do Docker personalizado para treinamento, adicione um dos [SageMaker Arquivos binários do pacote Profiler Python](profiler-support.md#profiler-python-package) ao seu Dockerfile.

```
# Install the smprof package version compatible with your CUDA version
RUN pip install https://smppy.s3.amazonaws.com/{{tensorflow/cu112/smprof-0.3.332-cp39-cp39-linux_x86_64.whl}}
```

Para obter orientação sobre como executar um contêiner Docker personalizado para treinamento em SageMaker IA em geral, consulte [Adaptar seu próprio contêiner de treinamento](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html).