Prepare e execute um trabalho de treinamento com o SageMaker Profiler

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.

Etapa 1: Adapte seu script de treinamento usando os módulos SageMaker Profiler Python

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 emCPUs, você não precisa adicionar nenhuma anotação adicional. CPUa criação de perfil também é ativada quando você especifica a configuração de criação de perfil, na qual você praticará. Etapa 2: criar um estimador de SageMaker estrutura e ativar o Profiler SageMaker

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 smprof.annotate() contexto. 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 SageMaker estrutura e ativar o Profiler SageMaker

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

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 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 S3. URI

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

Para usar o SageMaker Profiler em PyTorch imagens de TensorFlow estrutura não listadas ou em SageMaker imagens de estrutura pré-instaladas com SageMaker o Profiler 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

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 listadasSageMaker imagens de estrutura pré-instaladas com SageMaker o Profiler, crie um requirements.txt arquivo e localize-o no caminho especificado para o source_dir parâmetro do estimador da SageMaker estrutura na Etapa 2. Para obter mais informações sobre como configurar um requirements.txt arquivo em geral, consulte Usando bibliotecas de terceiros na documentação do SageMaker Python SDK. No requirements.txt arquivo, adicione um dos caminhos de bucket do S3 para o. SageMaker Arquivos binários do pacote Profiler Python

# 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 Docker personalizado para treinamento, adicione um deles SageMaker Arquivos binários do pacote Profiler Python 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 SageMaker em geral, consulte Adaptar seu próprio contêiner de treinamento.