torch.profiler

Overview

PyTorch Profiler is a tool that allows the collecton of the performance metrics during the training and inference. Profiler’s context manager API can be used to better understand what model operators are the most expensive, examine their input shapes and stack traces, study device kernel activity and visualize the execution trace.

Note

An earlier version of the API in torch.autograd module is considered legacy and will be deprecated.

API Reference

class torch.profiler.profile(*, activities=None, schedule=None, on_trace_ready=None, record_shapes=False, profile_memory=False, with_stack=False, with_flops=False, use_cuda=None)

Profiler context manager.

Args:

• activities - list of activity groups (CPU, CUDA) to use in profiling, supported values: torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA; default value: ProfilerActivity.CPU and (when available) ProfilerActivity.CUDA;

• schedule - callable that takes step (int) as a single parameter and returns ProfilerAction value that specifies the profiler action to perform at each step;

• on_trace_ready - callable that is called at each step when schedule returns ProfilerAction.RECORD_AND_SAVE during the profiling;

• record_shapes - save information about operator’s input shapes;

• profile_memory - track tensor memory allocation/deallocation;

• with_stack - record source information (file and line number) for the ops;

• with_flops - use formula to estimate the FLOPS of specific operators (matrix multiplication and 2D convolution);

• use_cuda - (deprecated, use activities).

Note

Use torch.profiler.schedule to generate the callable schedule. Non-default schedules are useful when profiling long training jobs and allow the user to obtain multiple traces at the different iterations of the training process. The default schedule simply records all the events continuously for the duration of the context manager.

Note

Use torch.profiler.tensorboard_trace_handler to generate result files for TensorBoard:

on_trace_ready=torch.profiler.tensorboard_trace_handler(dir_name)

After profiling, result files can be found in the specified directory. Use the command:

tensorboard --log_dir=dir_name

to see the results in TensorBoard. For more information, see Pytorch Profiler

Note

Enabling shape and stack tracing results in additional overhead.

Examples:

with torch.profiler.profile(
    activities=[
        torch.profiler.ProfilerActivity.CPU,
        torch.profiler.ProfilerActivity.CUDA]
) as p:
    code_to_profile()
print(p.key_averages().table(
    sort_by="self_cuda_time_total", row_limit=-1))

Using the profiler’s schedule, on_trace_ready and step functions:

# Non-default profiler schedule allows user to turn profiler on and off
# on different iterations of the training loop;
# trace_handler is called every time a new trace becomes available
def trace_handler(prof):
    print(prof.key_averages().table(
        sort_by="self_cuda_time_total", row_limit=-1))
    # prof.export_chrome_trace("/tmp/test_trace_" + str(prof.step_num) + ".json")

with torch.profiler.profile(
    activities=[
        torch.profiler.ProfilerActivity.CPU,
        torch.profiler.ProfilerActivity.CUDA],

    # In this example with wait=1, warmup=1, active=2,
    # profiler will skip the first step/iteration,
    # start warming up on the second, record
    # the third and the forth iterations,
    # after which the trace will become available
    # and on_trace_ready (when set) is called;
    # the cycle repeats starting with the next step

    schedule=torch.profiler.schedule(
        wait=1,
        warmup=1,
        active=2),
    on_trace_ready=trace_handler
    # on_trace_ready=torch.profiler.tensorboard_trace_handler('./log')
    # used when outputting for tensorboard
    ) as p:
        for iter in range(N):
            code_iteration_to_profile(iter)
            # send a signal to the profiler that the next iteration has started
            p.step()

events()

Returns the list of unaggregated profiler events, to be used in the trace callback or after the profiling is finished

export_chrome_trace(path)

Exports the collected trace in Chrome JSON format.

export_stacks(path, metric='self_cpu_time_total')

Save stack traces in a file in a format suitable for visualization.

Args:

• path - save stacks file to this location;

• metric - metric to use: “self_cpu_time_total” or “self_cuda_time_total”

Note

Example of using FlameGraph tool:

• git clone https://github.com/brendangregg/FlameGraph

• cd FlameGraph

• ./flamegraph.pl –title “CPU time” –countname “us.” profiler.stacks > perf_viz.svg

key_averages(group_by_input_shape=False, group_by_stack_n=0)

Averages events, grouping them by operator name and (optionally) input shapes and stack. Note: to use shape/stack functionality make sure to set record_shapes/with_stack when creating profiler context manager.

step()

Signals the profiler that the next profiling step has started.

torch.profiler.schedule(*, wait, warmup, active, repeat=0)

Returns a callable that can be used as profiler schedule argument. The profiler will wait for wait steps, then do the warmup for the next warmup steps, then do the active recording for the next active steps and then repeat the cycle starting with the next step. The number of cycles is specified by the repeat parameter. When the parameter’s value is zero, the cycles will continue until the profiling is finished.

torch.profiler.tensorboard_trace_handler(dir_name, worker_name=None)

Outputs tracing files to directory of dir_name, then that directory can be directly delivered to tensorboard as logdir. worker_name should be unique for each worker in distributed scenario, it will be set to ‘[hostname]_[pid]’ by default.