Accelerate documentation

Profiler

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.16.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Profiler

Profiler é uma ferramenta que permite a coleta de métricas de desempenho durante o treinamento e a inferência. A API de gerenciador de contexto do Profiler pode ser usada para entender melhor quais operadores do modelo são os mais custosos, examinar suas formas de entrada e rastros de pilha, estudar a atividade dos kernels do dispositivo e visualizar o rastro de execução. Ele fornece insights sobre o desempenho do seu modelo, permitindo que você o otimize e melhore.

Este guia explica como usar o PyTorch Profiler para medir o tempo e o consumo de memória dos operadores do modelo e como integrar isso com o Accelerate. Abordaremos vários casos de uso e forneceremos exemplos para cada um.

Usando o profiler para analisar o tempo de execução

O Profiler permite verificar quais operadores foram chamados durante a execução de um intervalo de código envolvido por um gerenciador de contexto do profiler.

Vamos ver como podemos usar o profiler para analisar o tempo de execução:

PyTorch
Accelerate
import torch
import torchvision.models as models
from torch.profiler import profile, record_function, ProfilerActivity

model = models.resnet18()
inputs = torch.randn(5, 3, 224, 224)

with profile(activities=[ProfilerActivity.CPU], record_shapes=True) as prof:
    model(inputs)

print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=10))

A saída da tabela resultante (omitindo algumas colunas):

---------------------------------  ------------  ------------  ------------  ------------  
                             Name      Self CPU     CPU total  CPU time avg    # of Calls  
---------------------------------  ------------  ------------  ------------  ------------  
                     aten::conv2d     171.000us      52.260ms       2.613ms            20  
                aten::convolution     227.000us      52.089ms       2.604ms            20  
               aten::_convolution     270.000us      51.862ms       2.593ms            20  
         aten::mkldnn_convolution      51.273ms      51.592ms       2.580ms            20  
                 aten::batch_norm     118.000us       7.059ms     352.950us            20  
     aten::_batch_norm_impl_index     315.000us       6.941ms     347.050us            20  
          aten::native_batch_norm       6.305ms       6.599ms     329.950us            20  
                 aten::max_pool2d      40.000us       4.008ms       4.008ms             1  
    aten::max_pool2d_with_indices       3.968ms       3.968ms       3.968ms             1  
                       aten::add_     780.000us     780.000us      27.857us            28  
---------------------------------  ------------  ------------  ------------  ------------  
Self CPU time total: 67.016ms

Para obter uma granularidade mais fina dos resultados e incluir as formas de entrada dos operadores, passe group_by_input_shape=True (observação: isso exige executar o profiler com record_shapes=True):

print(prof.key_averages(group_by_input_shape=True).table(sort_by="cpu_time_total", row_limit=10))

Usando o profiler para analisar o consumo de memória

O Profiler também pode exibir a quantidade de memória (usada pelos tensores do modelo) que foi alocada (ou liberada) durante a execução dos operadores do modelo. Para habilitar a funcionalidade de perfil de memória, passe profile_memory=True.

PyTorch
Accelerate
model = models.resnet18()
inputs = torch.randn(5, 3, 224, 224)

with profile(activities=[ProfilerActivity.CPU],
        profile_memory=True, record_shapes=True) as prof:
    model(inputs)

print(prof.key_averages().table(sort_by="self_cpu_memory_usage", row_limit=10))

A saída da tabela resultante (omitindo algumas colunas):

---------------------------------  ------------  ------------  ------------  
                             Name       CPU Mem  Self CPU Mem    # of Calls  
---------------------------------  ------------  ------------  ------------  
                      aten::empty      94.85 Mb      94.85 Mb           205  
    aten::max_pool2d_with_indices      11.48 Mb      11.48 Mb             1  
                      aten::addmm      19.53 Kb      19.53 Kb             1  
                       aten::mean      10.00 Kb      10.00 Kb             1  
              aten::empty_strided         492 b         492 b             5  
                        aten::cat         240 b         240 b             6  
                        aten::abs         480 b         240 b             4  
              aten::masked_select         120 b         112 b             1  
                         aten::ne          61 b          53 b             3  
                         aten::eq          30 b          30 b             1  
---------------------------------  ------------  ------------  ------------  
Self CPU time total: 69.332ms

Se você precisa de um ou dois números agregados para o rastreamento de experimentos em vez de uma tabela completa de operadores, combine o profiler com as estatísticas de memória em tempo de execução expostas pelo PyTorch. Isso geralmente é suficiente para registrar o uso de memória de pico por execução:

import torch
from accelerate import Accelerator, PartialState, ProfileKwargs

# Resolve the device type/module (cuda, xpu, ...) instead of hardcoding CUDA
device_type = PartialState().device.type
device_module = getattr(torch, device_type)


def summarize_memory_stats():
    return {
        "peak_allocated_mb": device_module.max_memory_allocated() / 1024**2,
        "peak_reserved_mb": device_module.max_memory_reserved() / 1024**2,
    }


profile_kwargs = ProfileKwargs(
    activities=["cpu", device_type],
    profile_memory=True,
    record_shapes=True,
)

accelerator = Accelerator(kwargs_handlers=[profile_kwargs])

device_module.reset_peak_memory_stats()

with accelerator.profile() as prof:
    model(inputs)

print(prof.key_averages().table(sort_by=f"self_{device_type}_memory_usage", row_limit=10))
print(summarize_memory_stats())

Esse padrão mantém a saída do profiler disponível para depuração, ao mesmo tempo em que produz valores compactos que podem ser registrados em um rastreador de experimentos.

Exportando rastro do Chrome

Você pode examinar a sequência de operadores e kernels CUDA perfis no visualizador de rastreamento do Chrome (chrome://tracing):

profile_export

PyTorch
Accelerate
# Pick the available accelerator (cuda, xpu, ...) instead of hardcoding CUDA
device = torch.accelerator.current_accelerator()
device_activity = getattr(ProfilerActivity, device.type.upper())

model = models.resnet18().to(device)
inputs = torch.randn(5, 3, 224, 224).to(device)

with profile(activities=[ProfilerActivity.CPU, device_activity]) as prof:
    model(inputs)

prof.export_chrome_trace("trace.json")

Usando o Profiler para Analisar Tarefas de Longa Duração

O Profiler oferece uma API adicional para lidar com jobs de longa duração (como loops de treinamento). Rastrear toda a execução pode ser lento e resultar em arquivos de trace muito grandes. Para evitar isso, use os argumentos opcionais:

  • schedule_option: As opções de agendamento permitem controlar quando o profiling está ativo. Isso é útil para jobs de longa duração para evitar a coleta de dados em excesso. As chaves disponíveis são wait, warmup, active, repeat e skip_first. O profiler ignorará os primeiros skip_first passos, em seguida aguardará por wait passos, depois fará o warmup nos próximos warmup passos, então fará o registro ativo nos próximos active passos e, por fim, repetirá o ciclo começando com wait passos. O número opcional de ciclos é especificado com o parâmetro repeat; o valor zero significa que os ciclos continuarão até que o profiling seja finalizado.
  • on_trace_ready: especifica uma função que recebe uma referência para o profiler como entrada e é chamada pelo profiler sempre que um novo trace está pronto.

Para ilustrar como a API funciona, considere o seguinte exemplo:

PyTorch
Accelerate
from torch.profiler import schedule

my_schedule = schedule(
    skip_first=1,
    wait=5,
    warmup=1,
    active=3,
    repeat=2
)

def trace_handler(p):
    output = p.key_averages().table(sort_by=f"self_{device.type}_time_total", row_limit=10)
    print(output)
    p.export_chrome_trace("/tmp/trace_" + str(p.step_num) + ".json")

with profile(
    activities=[ProfilerActivity.CPU, device_activity],
    schedule=my_schedule,
    on_trace_ready=trace_handler
) as p:
    for idx in range(8):
        model(inputs)
        p.step()

FLOPS

Use a fórmula para estimar os FLOPs (operações de ponto flutuante) de operadores específicos (multiplicação de matrizes e convolução 2D).

Para medir operações de ponto flutuante (FLOPS):

PyTorch
Accelerate
with profile(
    activities=[ProfilerActivity.CPU, device_activity],
    with_flops=True
) as prof:
    model(inputs)

print(prof.key_averages().table(sort_by="flops", row_limit=10))

A saída da tabela resultante (omitindo algumas colunas):

-------------------------------------------------------  ------------  ------------  ------------  
                                                   Name      Self CPU     Self CUDA    Total FLOPs  
-------------------------------------------------------  ------------  ------------  ------------  
                                           aten::conv2d     197.000us       0.000us  18135613440.000  
                                            aten::addmm     103.000us      17.000us     5120000.000  
                                              aten::mul      29.000us       2.000us          30.000  
                                      aten::convolution     409.000us       0.000us            --  
                                     aten::_convolution     253.000us       0.000us            --  
                                aten::cudnn_convolution       5.465ms       2.970ms            --  
                                        cudaEventRecord     138.000us       0.000us            --  
                                  cudaStreamIsCapturing      43.000us       0.000us            --  
                                  cudaStreamGetPriority      40.000us       0.000us            --  
                       cudaDeviceGetStreamPriorityRange      10.000us       0.000us            --  
-------------------------------------------------------  ------------  ------------  ------------  
Self CPU time total: 21.938ms
Self CUDA time total: 4.165ms

Conclusão e Mais Informações

O PyTorch Profiler é uma ferramenta poderosa para analisar o desempenho dos seus modelos. Ao integrá-lo ao Accelerate, você pode perfilar seus modelos com facilidade e obter insights sobre o desempenho deles, o que ajuda a otimizar e melhorar os modelos.

Para mais informações detalhadas, consulte a documentação do PyTorch Profiler.

Update on GitHub