Accelerate documentation

Profiler

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Profiler

Profiler est un outil permettant de collecter des métriques de performance pendant l’entraînement et l’inférence. L’API du gestionnaire de contexte de Profiler peut être utilisée pour mieux comprendre quels opérateurs du modèle sont les plus coûteux, examiner leurs formes d’entrée et leurs traces d’appel, étudier l’activité des noyaux sur l’appareil et visualiser la trace d’exécution. Il fournit des informations sur les performances de votre modèle, vous permettant de l’optimiser et de l’améliorer.

Ce guide explique comment utiliser PyTorch Profiler pour mesurer le temps et la consommation mémoire des opérateurs du modèle, et comment l’intégrer avec Accelerate. Nous couvrirons divers cas d’usage et fournirons des exemples pour chacun.

Utilisation du profiler pour analyser le temps d'exécution

Profiler permet de vérifier quels opérateurs ont été appelés pendant l'exécution d'un intervalle de code encapsulé par un gestionnaire de contexte de profiler.

Voyons comment utiliser le profiler pour analyser le temps d’exécution :

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))

La sortie du tableau résultant (en omettant certaines colonnes) :

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

Pour obtenir une granularité plus fine des résultats et inclure les formes des entrées des opérateurs, passez group_by_input_shape=True (note : cela nécessite d’exécuter le profilage avec record_shapes=True) :

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

Utiliser le profiler pour analyser la consommation de mémoire

Profiler peut également afficher la quantité de mémoire (utilisée par les tenseurs du modèle) qui a été allouée (ou libérée) pendant l’exécution des opérateurs du modèle. Pour activer la fonctionnalité de profilage mémoire, passez 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))

La sortie du tableau résultant (en omettant certaines colonnes) :

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

Si vous avez besoin d'un ou deux nombres agrégés pour le suivi des expériences plutôt que d'un tableau complet des opérateurs, combinez le profilageur avec les statistiques de mémoire d'exposition exposées par PyTorch. C'est souvent suffisant pour consommer l'utilisation de mémoire maximale par exécution :

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())

Ce motif conserve la sortie du profilage disponible pour le débogage tout en produisant des valeurs compactes qui peuvent être journalisées dans un traceur d'expériences.

Exportation de la trace chrome

Vous pouvez examiner la séquence des opérateurs et des noyaux CUDA profilés dans le visualiseur de traces 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")

Utiliser Profiler pour analyser les tâches de longue durée

Profiler propose une API supplémentaire pour gérer les tâches de longue durée (comme les boucles d’entraînement). Tracer l’ensemble de l’exécution peut être lent et générer des fichiers de trace très volumineux. Pour éviter cela, utilisez les arguments optionnels suivants :

  • schedule_option : Les options de planification permettent de contrôler le moment où le profilage est actif. C’est utile pour les tâches de longue durée afin d’éviter de collecter trop de données. Les clés disponibles sont wait, warmup, active, repeat et skip_first. Le profilateur ignore les skip_first premières étapes, puis attend wait étapes, effectue ensuite la phase de préchauffage pendant les warmup étapes suivantes, enregistre activement pendant les active étapes suivantes, puis répète le cycle en commençant par wait étapes. Le nombre facultatif de cycles est spécifié par le paramètre repeat ; une valeur nulle signifie que les cycles se poursuivent jusqu’à la fin du profilage.
  • on_trace_ready : spécifie une fonction qui prend une référence au profilage en entrée et qui est appelée par le profilage chaque fois qu'une nouvelle trace est prête.

Pour illustrer le fonctionnement de l'API, considérez l'exemple suivant :

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

Utilisez la formule pour estimer les FLOPs (opérations à virgule flottante) des opérateurs spécifiques (multiplication de matrices et convolution 2D).

Pour mesurer les opérations en virgule flottante (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))

La sortie du tableau résultant (en omettant certaines colonnes) :

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

Conclusion et informations complémentaires

Le PyTorch Profiler est un outil puissant pour analyser les performances de vos modèles. En l’intégrant avec Accelerate, vous pouvez facilement profiler vos modèles et obtenir des informations sur leurs performances, ce qui vous aide à les optimiser et à les améliorer.

Pour plus de détails, consultez la documentation du Profiler PyTorch.

Update on GitHub