Callbacks which add a simple profiler to fastai. Inspired by PyTorch Lightning's SimpleProfiler.
Since simple profiler changes the fastai data loading loop, it is not imported by any of the fastxtend all imports. It needs to be imported seperately:
from fastxtend.callback import simpleprofiler
Note: Simple Profiler is currently untested on distributed training.
Jump here for usage examples.
With Simple Profiler imported, a callback can implement actions on the following events:
after_create: called after theLearneris createdbefore_fit: called before starting training or inference, ideal for initial setup.before_epoch: called at the beginning of each epoch, useful for any behavior you need to reset at each epoch.before_train: called at the beginning of the training part of an epoch.before_draw: called at the beginning of each batch, just before drawing said batch.before_batch: called at the beginning of each batch, just after drawing said batch. It can be used to do any setup necessary for the batch (like hyper-parameter scheduling) or to change the input/target before it goes in the model (change of the input with techniques like mixup for instance).after_pred: called after computing the output of the model on the batch. It can be used to change that output before it's fed to the loss.after_loss: called after the loss has been computed, but before the backward pass. It can be used to add any penalty to the loss (AR or TAR in RNN training for instance).before_backward: called after the loss has been computed, but only in training mode (i.e. when the backward pass will be used)before_step: called after the backward pass, but before the update of the parameters. It can be used to do any change to the gradients before said update (gradient clipping for instance).after_step: called after the step and before the gradients are zeroed.after_batch: called at the end of a batch, for any clean-up before the next one.after_train: called at the end of the training phase of an epoch.before_validate: called at the beginning of the validation phase of an epoch, useful for any setup needed specifically for validation.after_validate: called at the end of the validation part of an epoch.after_epoch: called at the end of an epoch, for any clean-up before the next one.after_fit: called at the end of training, for final clean-up.
To add before_draw as a callable event, first it needs to be added to both lists of fastai events.
if parse(fastai.__version__) >= parse('2.7.0'):
_inner_loop = "before_draw before_batch after_pred after_loss before_backward after_cancel_backward after_backward before_step after_step after_cancel_batch after_batch".split()
else:
_inner_loop = "before_draw before_batch after_pred after_loss before_backward before_step after_step after_cancel_batch after_batch".split()
if parse(fastai.__version__) >= parse('2.7.0'):
_events = L.split('after_create before_fit before_epoch before_train before_draw before_batch after_pred after_loss \
before_backward after_cancel_backward after_backward before_step after_cancel_step after_step \
after_cancel_batch after_batch after_cancel_train after_train before_validate after_cancel_validate \
after_validate after_cancel_epoch after_epoch after_cancel_fit after_fit')
else:
_events = L.split('after_create before_fit before_epoch before_train before_draw before_batch after_pred after_loss \
before_backward before_step after_cancel_step after_step after_cancel_batch after_batch after_cancel_train \
after_train before_validate after_cancel_validate after_validate after_cancel_epoch \
after_epoch after_cancel_fit after_fit')
mk_class('event', **_events.map_dict(),
doc="All possible events as attributes to get tab-completion and typo-proofing")
Next, Callback needs to be modified to be aware of the new event.
@patch
def __call__(self:Callback, event_name):
"Call `self.{event_name}` if it's defined"
_run = (event_name not in _inner_loop or (self.run_train and getattr(self, 'training', True)) or
(self.run_valid and not getattr(self, 'training', False)))
res = None
if self.run and _run: res = getattr(self, event_name, noop)()
if event_name=='after_fit': self.run=True #Reset self.run to True at each end of fit
return res
Then Learner._call_one needs to patch to be aware of the before_draw.
@patch
def _call_one(self:Learner, event_name):
if not hasattr(event, event_name): raise Exception(f'missing {event_name}')
for cb in self.cbs.sorted('order'): cb(event_name)
Finally, Learner.all_batches can be modified to call before_draw when iterating through a dataloader.
@patch
def all_batches(self:Learner):
self.n_iter = len(self.dl)
if hasattr(self, 'simple_profiler'):
self.it = iter(self.dl)
for i in range(self.n_iter):
self("before_draw")
self.one_batch(i, next(self.it))
del(self.it)
else:
for o in enumerate(self.dl): self.one_batch(*o)
While testing hasn't shown any negative side effects of this approach, all_batches only uses the new batch drawing implementation if SimpleProfilerCallback is in the list of callbacks, and reverts back to the original method if not.
The Simple Profiler report contains the following items divided in three Phases (Fit, Train, & Valid)
Fit:
fit: total time fitting the model takes.epoch: duration of both training and validation epochs. Often epoch total time is the same amount of elapsed time as fit.train: duration of each training epoch.validate: duration of each validation epoch.
Train:
draw: time spent waiting for a batch to be drawn. Measured frombefore_drawtobefore_batch. With default prefetching settings, ideally this is as close to instantly as possible.batch: total duration of all batch steps sans drawing the batch. Measured frombefore_batchtoafter_batch.pred: duration of the forward pass and any additional batch modifications. Measured frombefore_batchtoafter_pred.loss: duration of caculating loss. Measured fromafter_predtoafter_loss.backward: duration of the backward pass. Measured frombefore_backwardtobefore_step.step: duration of the optimizer step. Measured frombefore_steptoafter_step.zero_grad: duration of the zero_grad step. Measured fromafter_steptoafter_batch.
Valid:
draw: time spent waiting for a batch to be drawn. Measured frombefore_drawtobefore_batch. With default prefetching settings, ideally this is as close to instantly as possible.batch: total duration of all batch steps sans drawing the batch. Measured frombefore_batchtoafter_batch.pred: duration of the forward pass and any additional batch modifications. Measured frombefore_batchtoafter_pred.loss: duration of caculating loss. Measured fromafter_predtoafter_loss.
learn = Learner(dls, xse_resnet50(n_out=dls.c), metrics=accuracy).to_fp16().profile()
learn.fit_one_cycle(2, 3e-3)
When training a XResNet18, the total time spent drawing while training increases to 20 seconds, twenty percent of total fit time. This is due to Colab's four core CPU and slow disk not being able to prefetch quickly enough, causing the training process to wait on drawing a batch. In contrast in the XSEResNet50 training above, total training draw time was only 8 seconds, two percent of the total fit time.
learn = Learner(dls, xresnet18(n_out=dls.c), metrics=accuracy).to_fp16().profile()
learn.fit_one_cycle(2, 3e-3)
from fastai.test_utils import synth_learner
learn = synth_learner()
learn.show_training_loop()
Logs two tables to active wandb run:
simple_profile_report: formatted report from Simple Profiler Callbacksimple_profile_results: raw results from Simple Profiler Callback