Accelerate documentation
Profiler
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 :
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))from accelerate import Accelerator, ProfileKwargs
import torch
import torchvision.models as models
model = models.resnet18()
inputs = torch.randn(5, 3, 224, 224)
profile_kwargs = ProfileKwargs(
activities=["cpu"],
record_shapes=True
)
accelerator = Accelerator(cpu=True, kwargs_handlers=[profile_kwargs])
model = accelerator.prepare(model)
with accelerator.profile() as prof:
with torch.no_grad():
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.016msPour 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.
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))model = models.resnet18()
inputs = torch.randn(5, 3, 224, 224)
profile_kwargs = ProfileKwargs(
activities=["cpu"],
profile_memory=True,
record_shapes=True
)
accelerator = Accelerator(cpu=True, kwargs_handlers=[profile_kwargs])
model = accelerator.prepare(model)
with accelerator.profile() 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.332msSi 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) :
# 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")model = models.resnet18()
profile_kwargs = ProfileKwargs(
activities=["cpu", PartialState().device.type],
output_trace_dir="trace"
)
accelerator = Accelerator(kwargs_handlers=[profile_kwargs])
model = accelerator.prepare(model)
inputs = torch.randn(5, 3, 224, 224).to(accelerator.device)
with accelerator.profile() as prof:
model(inputs)
# The trace will be saved to the specified directoryUtiliser 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 sontwait,warmup,active,repeatetskip_first. Le profilateur ignore lesskip_firstpremières étapes, puis attendwaitétapes, effectue ensuite la phase de préchauffage pendant leswarmupétapes suivantes, enregistre activement pendant lesactiveétapes suivantes, puis répète le cycle en commençant parwaitétapes. Le nombre facultatif de cycles est spécifié par le paramètrerepeat; 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 :
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()device_type = PartialState().device.type
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")
profile_kwargs = ProfileKwargs(
activities=["cpu", device_type],
schedule_option={"wait": 5, "warmup": 1, "active": 3, "repeat": 2, "skip_first": 1},
on_trace_ready=trace_handler
)
accelerator = Accelerator(kwargs_handlers=[profile_kwargs])
model = accelerator.prepare(model)
with accelerator.profile() as prof:
for idx in range(8):
model(inputs)
prof.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) :
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))profile_kwargs = ProfileKwargs(
with_flops=True
)
accelerator = Accelerator(kwargs_handlers=[profile_kwargs])
with accelerator.profile() 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.165msConclusion 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