composer.core.engine#
Engine is a coordinator for running algorithms and resolving ordering conflicts among them for composition.
The order in which algorithms are run matters significantly during composition. For example,
SelectiveBackprop
algorithm runs on the AFTER_DATALOADER
event and must run before any data
augmentations. Engine
runs re-ordering passes to resolve such ordering issues or conflicts.
Note
Currently, the following passes are registered:
LIFO order for events
For the events that follow the
before_*
(e.g.,BEFORE_LOSS
) andafter_*
(e.g.,AFTER_LOSS
) pattern, the ordering of algorithms is reversed for theafter_*
events. For example, four given algorithmsA
,B
,C
andD
will run inABCD
ordering on thebefore_*
event whileDCBA
ordering on theafter_*
event.This allows algorithms to โclean upโ their changes. For example,
LabelSmoothing
will smooth the labels upon onBEFORE_LOSS
event and then restore the original unsmoothed labels onAFTER_LOSS
event.Run Selective Backprop first
SelectiveBackprop
runs after the dataloader returns the batch, and executes an extra forward pass to rank and prune the examples in the batch by loss. To ensure a clean estimate of loss,SelectiveBackprop
should run before any other data augmentations (e.g.,MixUp
) on theAFTER_DATALOADER
event.
Trace#
Traces record whether an algorithm ran at a particular step and event combination and also the order of such executions.
These are logged with the key <algorithm_name>/<event>
.
For example, the algorithm LayerFreezing
, which runs at the end of every epoch on EPOCH_END
,
will emit a series of traces:
[STEP=0][layer_freezing/INIT=0]
[STEP=1][layer_freezing/EPOCH_START=0]
[STEP=1][layer_freezing/BATCH_START=0]
...
[STEP=2][layer_freezing/BATCH_START=0]
...
[STEP=3][layer_freezing/BATCH_START=0]
...
[STEP=3][layer_freezing/EPOCH_END=1] # <-- layer freezing ran on step 3 here!
Classes
Coordinator for running algorithms and resolving ordering conflicts among them for composition. |
|
Record of an algorithm's execution. |
Attributes
- class composer.core.engine.Engine(state, logger)[source]#
Coordinator for running algorithms and resolving ordering conflicts among them for composition.
- Parameters
- close()[source]#
Shutdown the engine.
As part of the shutdown procedure,
close()
andpost_close()
is invoked for each callback. Note thatpost_close()
is invoked only for callbacks that did not raise an exception duringclose()
.This method does not re-raise any exceptions from
close()
andpost_close()
. Instead, these exceptions are logged as errors.
- run_event(event)[source]#
Runs the sequence of algorithms and callbacks (see
Callback
).Filters algorithms by calling each oneโs
match()
method, internally checks for conflicting algorithms, then runs each algorithmโsapply()
method to make in-place changes to thestate
.The default order of execution for algorithms is determined by the provided list. However,
Engine
makes changes to this order internally to resolve ordering conflicts.Returns
Traces
of the execution, a dictionary with keys formatted as<algorithm_name>/<event>
(e.g.,Blurpool/INIT
), and values are an instance ofTrace
.Callbacks are always run after algorithms and do not return a trace.
This method can be called with either the
Event
enum member values or a string of the event name.Examples
>>> engine = Engine(state, logger) >>> engine.run_event(Event.BEFORE_LOSS) OrderedDict() >>> # calling with a string of the event name also works >>> engine.run_event('before_loss') OrderedDict()