# torchbearer.callbacks¶

## Base Classes¶

class torchbearer.bases.Callback[source]

Base callback class.

Note

All callbacks should override this class.

load_state_dict(state_dict)[source]

Resume this callback from the given state. Expects that this callback was constructed in the same way.

Parameters: state_dict (dict) – The state dict to reload self Callback
on_backward(state)[source]

Perform some action with the given state as context after backward has been called on the loss.

Parameters: state (dict) – The current state dict of the Trial.
on_checkpoint(state)[source]

Perform some action with the state after all other callbacks have completed at the end of an epoch and the history has been updated. Should only be used for taking checkpoints or snapshots and will only be called by the run method of Trial.

Parameters: state (dict) – The current state dict of the Trial.
on_criterion(state)[source]

Perform some action with the given state as context after the criterion has been evaluated.

Parameters: state (dict) – The current state dict of the Trial.
on_criterion_validation(state)[source]

Perform some action with the given state as context after the criterion evaluation has been completed with the validation data.

Parameters: state (dict) – The current state dict of the Trial.
on_end(state)[source]

Perform some action with the given state as context at the end of the model fitting.

Parameters: state (dict) – The current state dict of the Trial.
on_end_epoch(state)[source]

Perform some action with the given state as context at the end of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
on_end_training(state)[source]

Perform some action with the given state as context after the training loop has completed.

Parameters: state (dict) – The current state dict of the Trial.
on_end_validation(state)[source]

Perform some action with the given state as context at the end of the validation loop.

Parameters: state (dict) – The current state dict of the Trial.
on_forward(state)[source]

Perform some action with the given state as context after the forward pass (model output) has been completed.

Parameters: state (dict) – The current state dict of the Trial.
on_forward_validation(state)[source]

Perform some action with the given state as context after the forward pass (model output) has been completed with the validation data.

Parameters: state (dict) – The current state dict of the Trial.
on_init(state)[source]

Perform some action with the given state as context at the init of a trial instance

Parameters: state (dict) – The current state dict of the Trial.
on_sample(state)[source]

Perform some action with the given state as context after data has been sampled from the generator.

Parameters: state (dict) – The current state dict of the Trial.
on_sample_validation(state)[source]

Perform some action with the given state as context after data has been sampled from the validation generator.

Parameters: state (dict) – The current state dict of the Trial.
on_start(state)[source]

Perform some action with the given state as context at the start of a model fit.

Parameters: state (dict) – The current state dict of the Trial.
on_start_epoch(state)[source]

Perform some action with the given state as context at the start of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
on_start_training(state)[source]

Perform some action with the given state as context at the start of the training loop.

Parameters: state (dict) – The current state dict of the Trial.
on_start_validation(state)[source]

Perform some action with the given state as context at the start of the validation loop.

Parameters: state (dict) – The current state dict of the Trial.
on_step_training(state)[source]

Perform some action with the given state as context after step has been called on the optimiser.

Parameters: state (dict) – The current state dict of the Trial.
on_step_validation(state)[source]

Perform some action with the given state as context at the end of each validation step.

Parameters: state (dict) – The current state dict of the Trial.
state_dict()[source]

Get a dict containing the callback state.

Returns: A dict containing parameters and persistent buffers. dict
class torchbearer.callbacks.callbacks.CallbackList(callback_list)[source]

The CallbackList class is a wrapper for a list of callbacks which acts as a single Callback and internally calls each Callback in the given list in turn.

Parameters: callback_list (list) – The list of callbacks to be wrapped. If the list contains a CallbackList, this will be unwrapped.
CALLBACK_STATES = 'callback_states'
CALLBACK_TYPES = 'callback_types'
append(callback_list)[source]
copy()[source]
load_state_dict(state_dict)[source]

Resume this callback list from the given state. Callbacks must be given in the same order for this to work.

Parameters: state_dict (dict) – The state dict to reload self CallbackList
on_backward(state)[source]

Call on_backward on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_checkpoint(state)[source]

Call on_checkpoint on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_criterion(state)[source]

Call on_criterion on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_criterion_validation(state)[source]

Call on_criterion_validation on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_end(state)[source]

Call on_end on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_end_epoch(state)[source]

Call on_end_epoch on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_end_training(state)[source]

Call on_end_training on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_end_validation(state)[source]

Call on_end_validation on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_forward(state)[source]

Call on_forward on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_forward_validation(state)[source]

Call on_forward_validation on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_init(state)[source]

Call on_init on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_sample(state)[source]

Call on_sample on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_sample_validation(state)[source]

Call on_sample_validation on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_start(state)[source]

Call on_start on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_start_epoch(state)[source]

Call on_start_epoch on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_start_training(state)[source]

Call on_start_training on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_start_validation(state)[source]

Call on_start_validation on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_step_training(state)[source]

Call on_step_training on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
on_step_validation(state)[source]

Call on_step_validation on each callback in turn with the given state.

Parameters: state (dict[str,any]) – The current state dict of the Trial.
state_dict()[source]

Get a dict containing all of the callback states.

Returns: A dict containing parameters and persistent buffers. dict

## Imaging¶

### Main Classes¶

class torchbearer.callbacks.imaging.imaging.CachingImagingCallback(key=x, transform=None, num_images=16)[source]

The CachingImagingCallback is an ImagingCallback which caches batches of images from the given state key up to the required amount before passing this along with state to the implementing class, once per epoch.

Parameters: key (StateKey) – The StateKey containing image data (tensor of size [b, c, w, h]) transform (callable, optional) – A function/transform that takes in a Tensor and returns a transformed version. This will be applied to the image before it is sent to output. num_images – The number of images to cache
on_batch(state)[source]
on_cache(cache, state)[source]

This method should be implemented by the overriding class to return an image from the cache.

Parameters: cache (tensor) – The collected cache of size (num_images, C, W, H) state (dict) – The trial state dict The processed image
on_end_epoch(state)[source]

Perform some action with the given state as context at the end of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
class torchbearer.callbacks.imaging.imaging.FromState(key, transform=None, decorator=<function once_per_epoch>)[source]

The FromState callback is an ImagingCallback which retrieves and image from state when called. The number of times the function is called can be controlled with a provided decorator (once_per_epoch, only_if etc.)

Parameters: key (StateKey) – The StateKey containing the image (tensor of size [c, w, h]) transform (callable, optional) – A function/transform that takes in a Tensor and returns a transformed version. This will be applied to the image before it is sent to output. decorator – A function which will be used to wrap the callback function. once_per_epoch by default
on_batch(state)[source]
class torchbearer.callbacks.imaging.imaging.ImagingCallback(transform=None)[source]

The ImagingCallback provides a generic interface for callbacks which yield images that should be sent to a file, tensorboard, visdom etc. without needing bespoke code. This allows the user to easily define custom visualisations by only writing the code to produce the image.

Parameters: transform (callable, optional) – A function/transform that takes in a Tensor and returns a transformed version. This will be applied to the image before it is sent to output.
on_batch(state)[source]
on_test()[source]

Process this callback for test batches

Returns: self ImagingCallback
on_train()[source]

Process this callback for training batches

Returns: self ImagingCallback
on_val()[source]

Process this callback for validation batches

Returns: self ImagingCallback
process(state)[source]
to_file(filename)[source]

Send images from this callback to the given file

Parameters: filename (str) – the filename to store the image to self ImagingCallback
to_pyplot()[source]

Show images from this callback with pyplot

Returns: self ImagingCallback
to_state(key)[source]

Put images from this callback in state with the given key

Parameters: key (StateKey) – The state key to use for the image self ImagingCallback
to_tensorboard(name='Image', log_dir='./logs', comment='torchbearer')[source]

Direct images from this callback to tensorboard with the given parameters

Parameters: name (str) – The name of the image log_dir (str) – The tensorboard log path for output comment (str) – Descriptive comment to append to path self ImagingCallback
to_visdom(name='Image', log_dir='./logs', comment='torchbearer', visdom_params=None)[source]

Direct images from this callback to visdom with the given parameters

Parameters: name (str) – The name of the image log_dir (str) – The visdom log path for output comment (str) – Descriptive comment to append to path visdom_params (VisdomParams) – Visdom parameter settings object, uses default if None self ImagingCallback
with_handler(handler)[source]

Append the given output handler to the list of handlers

Parameters: handler – A function of image and state which stores the given image in some way self ImagingCallback
class torchbearer.callbacks.imaging.imaging.MakeGrid(key=x, transform=None, num_images=16, nrow=8, padding=2, normalize=False, norm_range=None, scale_each=False, pad_value=0)[source]

The MakeGrid callback is a CachingImagingCallback which calls make grid on the cache with the provided parameters.

Parameters: key (StateKey) – The StateKey containing image data (tensor of size [b, c, w, h]) transform (callable, optional) – A function/transform that takes in a Tensor and returns a transformed version. This will be applied to the image before it is sent to output. num_images – The number of images to cache nrow – See torchvision.utils.make_grid padding – normalize – norm_range – scale_each – pad_value –
on_cache(cache, state)[source]

This method should be implemented by the overriding class to return an image from the cache.

Parameters: cache (tensor) – The collected cache of size (num_images, C, W, H) state (dict) – The trial state dict The processed image

### Deep Inside Convolutional Networks¶

class torchbearer.callbacks.imaging.inside_cnns.ClassAppearanceModel(nclasses, input_size, optimizer_factory=<function ClassAppearanceModel.<lambda>>, steps=1024, logit_key=y_pred, prob_key=None, target=-10, decay=0.001, verbose=0, transform=None)[source]

The ClassAppearanceModel callback implements Figure 1 from Deep Inside Convolutional Networks: Visualising Image Classification Models and Saliency Maps. This is a simple gradient ascent on an image (initialised to zero) with a sum-squares regularizer. Internally this creates a new Trial instance which then performs the optimization.

@article{simonyan2013deep,
title={Deep inside convolutional networks: Visualising image classification models and saliency maps},
author={Simonyan, Karen and Vedaldi, Andrea and Zisserman, Andrew},
journal={arXiv preprint arXiv:1312.6034},
year={2013}
}

Parameters: nclasses (int) – The number of output classes input_size (tuple) – The size to use for the input image optimizer_factory – A function of parameters which returns an optimizer to use logit_key (StateKey) – StateKey storing the class logits prob_key (StateKey) – StateKey storing the class probabilities or None if using logits target (int) – Target class for the optimisation or RANDOM steps (int) – Number of optimisation steps to take decay (float) – Lambda for the L2 decay on the image verbose (int) – Verbosity level to pass to the internal Trial instance transform (callable, optional) – A function/transform that takes in a Tensor and returns a transformed version. This will be applied to the image before it is sent to output
on_batch(state)
target_to_key(key)[source]

## Model Checkpointers¶

class torchbearer.callbacks.checkpointers.Best(filepath='model.{epoch:02d}-{val_loss:.2f}.pt', save_model_params_only=False, monitor='val_loss', mode='auto', period=1, min_delta=0, pickle_module=<sphinx.ext.autodoc.importer._MockObject object>, pickle_protocol=<sphinx.ext.autodoc.importer._MockObject object>)[source]

Model checkpointer which saves the best model according to the given configurations.

Parameters: filepath (str) – Path to save the model file save_model_params_only (bool) – If save_model_params_only=True, only model parameters will be saved so that the results can be loaded into a PyTorch nn.Module. The other option, save_model_params_only=False, should be used only if the results will be loaded into a Torchbearer Trial object later. monitor (str) – Quantity to monitor mode (str) – One of {auto, min, max}. If save_best_only=True, the decision to overwrite the current save file is made based on either the maximization or the minimization of the monitored quantity. For val_acc, this should be max, for val_loss this should be min, etc. In auto mode, the direction is automatically inferred from the name of the monitored quantity. period (int) – Interval (number of epochs) between checkpoints min_delta (float) – If save_best_only=True, this is the minimum improvement required to trigger a save pickle_module (module) – The pickle module to use, default is ‘torch.serialization.pickle’ pickle_protocol (int) – The pickle protocol to use, default is ‘torch.serialization.DEFAULT_PROTOCOL’
load_state_dict(state_dict)[source]

Resume this callback from the given state. Expects that this callback was constructed in the same way.

Parameters: state_dict (dict) – The state dict to reload self Callback
on_checkpoint(state)[source]

Perform some action with the state after all other callbacks have completed at the end of an epoch and the history has been updated. Should only be used for taking checkpoints or snapshots and will only be called by the run method of Trial.

Parameters: state (dict) – The current state dict of the Trial.
on_start(state)[source]

Perform some action with the given state as context at the start of a model fit.

Parameters: state (dict) – The current state dict of the Trial.
state_dict()[source]

Get a dict containing the callback state.

Returns: A dict containing parameters and persistent buffers. dict
class torchbearer.callbacks.checkpointers.Interval(filepath='model.{epoch:02d}-{val_loss:.2f}.pt', save_model_params_only=False, period=1, on_batch=False, pickle_module=<sphinx.ext.autodoc.importer._MockObject object>, pickle_protocol=<sphinx.ext.autodoc.importer._MockObject object>)[source]

Model checkpointer which which saves the model every ‘period’ epochs to the given filepath.

Parameters: filepath (str) – Path to save the model file save_model_params_only (bool) – If save_model_params_only=True, only model parameters will be saved so that the results can be loaded into a PyTorch nn.Module. The other option, save_model_params_only=False, should be used only if the results will be loaded into a Torchbearer Trial object later. period (int) – Interval (number of steps) between checkpoints on_batch (bool) – If true step each batch, if false step each epoch. period – Interval (number of epochs) between checkpoints pickle_module (module) – The pickle module to use, default is ‘torch.serialization.pickle’ pickle_protocol (int) – The pickle protocol to use, default is ‘torch.serialization.DEFAULT_PROTOCOL’
load_state_dict(state_dict)[source]

Resume this callback from the given state. Expects that this callback was constructed in the same way.

Parameters: state_dict (dict) – The state dict to reload self Callback
on_checkpoint(state)[source]

Perform some action with the state after all other callbacks have completed at the end of an epoch and the history has been updated. Should only be used for taking checkpoints or snapshots and will only be called by the run method of Trial.

Parameters: state (dict) – The current state dict of the Trial.
state_dict()[source]

Get a dict containing the callback state.

Returns: A dict containing parameters and persistent buffers. dict
torchbearer.callbacks.checkpointers.ModelCheckpoint(filepath='model.{epoch:02d}-{val_loss:.2f}.pt', save_model_params_only=False, monitor='val_loss', save_best_only=False, mode='auto', period=1, min_delta=0)[source]

Save the model after every epoch. filepath can contain named formatting options, which will be filled any values from state. For example: if filepath is weights.{epoch:02d}-{val_loss:.2f}, then the model checkpoints will be saved with the epoch number and the validation loss in the filename. The torch Trial will be saved to filename.

Parameters: filepath (str) – Path to save the model file save_model_params_only (bool) – If save_model_params_only=True, only model parameters will be saved so that the results can be loaded into a PyTorch nn.Module. The other option, save_model_params_only=False, should be used only if the results will be loaded into a Torchbearer Trial object later. monitor (str) – Quantity to monitor save_best_only (bool) – If save_best_only=True, the latest best model according to the quantity monitored will not be overwritten mode (str) – One of {auto, min, max}. If save_best_only=True, the decision to overwrite the current save file is made based on either the maximization or the minimization of the monitored quantity. For val_acc, this should be max, for val_loss this should be min, etc. In auto mode, the direction is automatically inferred from the name of the monitored quantity. period (int) – Interval (number of epochs) between checkpoints min_delta (float) – If save_best_only=True, this is the minimum improvement required to trigger a save
class torchbearer.callbacks.checkpointers.MostRecent(filepath='model.{epoch:02d}-{val_loss:.2f}.pt', save_model_params_only=False, pickle_module=<sphinx.ext.autodoc.importer._MockObject object>, pickle_protocol=<sphinx.ext.autodoc.importer._MockObject object>)[source]

Model checkpointer which saves the most recent model to a given filepath.

Parameters: filepath (str) – Path to save the model file save_model_params_only (bool) – If save_model_params_only=True, only model parameters will be saved so that the results can be loaded into a PyTorch nn.Module. The other option, save_model_params_only=False, should be used only if the results will be loaded into a Torchbearer Trial object later. pickle_module (module) – The pickle module to use, default is ‘torch.serialization.pickle’ pickle_protocol (int) – The pickle protocol to use, default is ‘torch.serialization.DEFAULT_PROTOCOL’
on_checkpoint(state)[source]

Perform some action with the state after all other callbacks have completed at the end of an epoch and the history has been updated. Should only be used for taking checkpoints or snapshots and will only be called by the run method of Trial.

Parameters: state (dict) – The current state dict of the Trial.

## Logging¶

class torchbearer.callbacks.csv_logger.CSVLogger(filename, separator=', ', batch_granularity=False, write_header=True, append=False)[source]

Callback to log metrics to a given csv file.

Parameters: filename (str) – The name of the file to output to separator (str) – The delimiter to use (e.g. comma, tab etc.) batch_granularity (bool) – If True, write on each batch, else on each epoch write_header (bool) – If True, write the CSV header at the beginning of training append (bool) – If True, append to the file instead of replacing it
on_end(state)[source]

Perform some action with the given state as context at the end of the model fitting.

Parameters: state (dict) – The current state dict of the Trial.
on_end_epoch(state)[source]

Perform some action with the given state as context at the end of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
on_step_training(state)[source]

Perform some action with the given state as context after step has been called on the optimiser.

Parameters: state (dict) – The current state dict of the Trial.
class torchbearer.callbacks.printer.ConsolePrinter(validation_label_letter='v', precision=4)[source]

The ConsolePrinter callback simply outputs the training metrics to the console.

Parameters: validation_label_letter (str) – This is the letter displayed after the epoch number indicating the current phase of training precision (int) – Precision of the number format in decimal places
State Requirements:
on_end_training(state)[source]

Perform some action with the given state as context after the training loop has completed.

Parameters: state (dict) – The current state dict of the Trial.
on_end_validation(state)[source]

Perform some action with the given state as context at the end of the validation loop.

Parameters: state (dict) – The current state dict of the Trial.
on_step_training(state)[source]

Perform some action with the given state as context after step has been called on the optimiser.

Parameters: state (dict) – The current state dict of the Trial.
on_step_validation(state)[source]

Perform some action with the given state as context at the end of each validation step.

Parameters: state (dict) – The current state dict of the Trial.
class torchbearer.callbacks.printer.Tqdm(tqdm_module=None, validation_label_letter='v', precision=4, on_epoch=False, **tqdm_args)[source]

The Tqdm callback outputs the progress and metrics for training and validation loops to the console using TQDM. The given key is used to label validation output.

Parameters: tqdm_module – The tqdm module to use. If none, defaults to tqdm or tqdm_notebook if in notebook validation_label_letter (str) – The letter to use for validation outputs. precision (int) – Precision of the number format in decimal places on_epoch (bool) – If True, output a single progress bar which tracks epochs tqdm_args – Any extra keyword args provided here will be passed through to the tqdm module constructor. See github.com/tqdm/tqdm#parameters for more details.
State Requirements:
on_end(state)[source]

Perform some action with the given state as context at the end of the model fitting.

Parameters: state (dict) – The current state dict of the Trial.
on_end_epoch(state)[source]

Perform some action with the given state as context at the end of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
on_end_training(state)[source]

Update the bar with the terminal training metrics and then close.

Parameters: state (dict) – The Trial state
on_end_validation(state)[source]

Update the bar with the terminal validation metrics and then close.

Parameters: state (dict) – The Trial state
on_start(state)[source]

Perform some action with the given state as context at the start of a model fit.

Parameters: state (dict) – The current state dict of the Trial.
on_start_training(state)[source]

Initialise the TQDM bar for this training phase.

Parameters: state (dict) – The Trial state
on_start_validation(state)[source]

Initialise the TQDM bar for this validation phase.

Parameters: state (dict) – The Trial state
on_step_training(state)[source]

Update the bar with the metrics from this step.

Parameters: state (dict) – The Trial state
on_step_validation(state)[source]

Update the bar with the metrics from this step.

Parameters: state (dict) – The Trial state

## Tensorboard, Visdom and Others¶

class torchbearer.callbacks.tensor_board.AbstractTensorBoard(log_dir='./logs', comment='torchbearer', visdom=False, visdom_params=None)[source]

TensorBoard callback which writes metrics to the given log directory. Requires the TensorboardX library for python.

Parameters: log_dir (str) – The tensorboard log path for output comment (str) – Descriptive comment to append to path visdom (bool) – If true, log to visdom instead of tensorboard visdom_params (VisdomParams) – Visdom parameter settings object, uses default if None
close_writer(log_dir=None)[source]

Decrement the reference count for a writer belonging to the given log directory (or the default writer if the directory is not given). If the reference count gets to zero, the writer will be closed and removed.

Parameters: log_dir (str) – the (optional) directory
get_writer(log_dir=None, visdom=False, visdom_params=None)[source]

Get a SummaryWriter for the given directory (or the default writer if the directory is not given). If you are getting a SummaryWriter for a custom directory, it is your responsibility to close it using close_writer.

Parameters: log_dir (str) – the (optional) directory visdom (bool) – If true, return VisdomWriter, if false return tensorboard SummaryWriter visdom_params (VisdomParams) – Visdom parameter settings object, uses default if None the SummaryWriter or VisdomWriter
on_end(state)[source]

Perform some action with the given state as context at the end of the model fitting.

Parameters: state (dict) – The current state dict of the Trial.
on_start(state)[source]

Perform some action with the given state as context at the start of a model fit.

Parameters: state (dict) – The current state dict of the Trial.
class torchbearer.callbacks.tensor_board.TensorBoard(log_dir='./logs', write_graph=True, write_batch_metrics=False, batch_step_size=10, write_epoch_metrics=True, comment='torchbearer', visdom=False, visdom_params=None)[source]

TensorBoard callback which writes metrics to the given log directory. Requires the TensorboardX library for python.

Parameters: log_dir (str) – The tensorboard log path for output write_graph (bool) – If True, the model graph will be written using the TensorboardX library write_batch_metrics (bool) – If True, batch metrics will be written batch_step_size (int) – The step size to use when writing batch metrics, make this larger to reduce latency write_epoch_metrics (bool) – If True, metrics from the end of the epoch will be written comment (str) – Descriptive comment to append to path visdom (bool) – If true, log to visdom instead of tensorboard visdom_params (VisdomParams) – Visdom parameter settings object, uses default if None
on_end(state)[source]

Perform some action with the given state as context at the end of the model fitting.

Parameters: state (dict) – The current state dict of the Trial.
on_end_epoch(state)[source]

Perform some action with the given state as context at the end of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
on_sample(state)[source]

Perform some action with the given state as context after data has been sampled from the generator.

Parameters: state (dict) – The current state dict of the Trial.
on_start_epoch(state)[source]

Perform some action with the given state as context at the start of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
on_step_training(state)[source]

Perform some action with the given state as context after step has been called on the optimiser.

Parameters: state (dict) – The current state dict of the Trial.
on_step_validation(state)[source]

Perform some action with the given state as context at the end of each validation step.

Parameters: state (dict) – The current state dict of the Trial.
class torchbearer.callbacks.tensor_board.TensorBoardImages(log_dir='./logs', comment='torchbearer', name='Image', key=y_pred, write_each_epoch=True, num_images=16, nrow=8, padding=2, normalize=False, norm_range=None, scale_each=False, pad_value=0, visdom=False, visdom_params=None)[source]

The TensorBoardImages callback will write a selection of images from the validation pass to tensorboard using the TensorboardX library and torchvision.utils.make_grid (requires torchvision). Images are selected from the given key and saved to the given path. Full name of image sub directory will be model name + _ + comment.

Parameters: log_dir (str) – The tensorboard log path for output comment (str) – Descriptive comment to append to path name (str) – The name of the image key (StateKey) – The key in state containing image data (tensor of size [c, w, h] or [b, c, w, h]) write_each_epoch (bool) – If True, write data on every epoch, else write only for the first epoch. num_images (int) – The number of images to write nrow – padding – normalize – norm_range – scale_each – pad_value – visdom (bool) – If true, log to visdom instead of tensorboard visdom_params (VisdomParams) – Visdom parameter settings object, uses default if None
on_end_epoch(state)[source]

Perform some action with the given state as context at the end of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
on_step_validation(state)[source]

Perform some action with the given state as context at the end of each validation step.

Parameters: state (dict) – The current state dict of the Trial.
class torchbearer.callbacks.tensor_board.TensorBoardProjector(log_dir='./logs', comment='torchbearer', num_images=100, avg_pool_size=1, avg_data_channels=True, write_data=True, write_features=True, features_key=y_pred)[source]

The TensorBoardProjector callback is used to write images from the validation pass to Tensorboard using the TensorboardX library. Images are written to the given directory and, if required, so are associated features.

Parameters: log_dir (str) – The tensorboard log path for output comment (str) – Descriptive comment to append to path num_images (int) – The number of images to write avg_pool_size (int) – Size of the average pool to perform on the image. This is recommended to reduce the overall image sizes and improve latency avg_data_channels (bool) – If True, the image data will be averaged in the channel dimension write_data (bool) – If True, the raw data will be written as an embedding write_features (bool) – If True, the image features will be written as an embedding features_key (StateKey) – The key in state to use for the embedding. Typically model output but can be used to show features from any layer of the model.
on_end_epoch(state)[source]

Perform some action with the given state as context at the end of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
on_step_validation(state)[source]

Perform some action with the given state as context at the end of each validation step.

Parameters: state (dict) – The current state dict of the Trial.
class torchbearer.callbacks.tensor_board.TensorBoardText(log_dir='./logs', write_epoch_metrics=True, write_batch_metrics=False, log_trial_summary=True, batch_step_size=100, comment='torchbearer', visdom=False, visdom_params=None)[source]

TensorBoard callback which writes metrics as text to the given log directory. Requires the TensorboardX library for python.

Parameters: log_dir (str) – The tensorboard log path for output write_epoch_metrics (bool) – If True, metrics from the end of the epoch will be written log_trial_summary (bool) – If True logs a string summary of the Trial batch_step_size (int) – The step size to use when writing batch metrics, make this larger to reduce latency comment (str) – Descriptive comment to append to path visdom (bool) – If true, log to visdom instead of tensorboard visdom_params (VisdomParams) – Visdom parameter settings object, uses default if None
on_end(state)[source]

Perform some action with the given state as context at the end of the model fitting.

Parameters: state (dict) – The current state dict of the Trial.
on_end_epoch(state)[source]

Perform some action with the given state as context at the end of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
on_start(state)[source]

Perform some action with the given state as context at the start of a model fit.

Parameters: state (dict) – The current state dict of the Trial.
on_start_epoch(state)[source]

Perform some action with the given state as context at the start of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
on_step_training(state)[source]

Perform some action with the given state as context after step has been called on the optimiser.

Parameters: state (dict) – The current state dict of the Trial.
static table_formatter(string)[source]
class torchbearer.callbacks.tensor_board.VisdomParams[source]

Class to hold visdom client arguments. Modify member variables before initialising tensorboard callbacks for custom arguments. See: visdom

ENDPOINT = 'events'
ENV = 'main'
HTTP_PROXY_HOST = None
HTTP_PROXY_PORT = None
IPV6 = True
LOG_TO_FILENAME = None
PORT = 8097
RAISE_EXCEPTIONS = None
SEND = True
SERVER = 'http://localhost'
USE_INCOMING_SOCKET = True
torchbearer.callbacks.tensor_board.close_writer(log_dir, logger)[source]

Decrement the reference count for a writer belonging to a specific log directory. If the reference count gets to zero, the writer will be closed and removed.

Parameters: log_dir (str) – the log directory logger – the object releasing the writer
torchbearer.callbacks.tensor_board.get_writer(log_dir, logger, visdom=False, visdom_params=None)[source]

Get the writer assigned to the given log directory. If the writer doesn’t exist it will be created, and a reference to the logger added.

Parameters: log_dir (str) – the log directory logger – the object requesting the writer. That object should call close_writer when its finished visdom (bool) – if true VisdomWriter is returned instead of tensorboard SummaryWriter visdom_params (VisdomParams) – Visdom parameter settings object, uses default if None the SummaryWriter or VisdomWriter object
class torchbearer.callbacks.live_loss_plot.LiveLossPlot(on_batch=False, batch_step_size=10, on_epoch=True, draw_once=False, **kwargs)[source]

Callback to write metrics to LiveLossPlot, a library for visualisation in notebooks

Parameters: on_batch (bool) – If True, batch metrics will be logged. Else batch metrics will not be logged batch_step_size (int) – The number of batches between logging metrics on_epoch (bool) – If True, epoch metrics will be logged every epoch. Else epoch metrics will not be logged draw_once (bool) – If True, draw the plot only at the end of training. Else draw every time metrics are logged kwargs – Keyword arguments for livelossplot.PlotLosses
State Requirements:
on_end(state)[source]

Perform some action with the given state as context at the end of the model fitting.

Parameters: state (dict) – The current state dict of the Trial.
on_start(state)[source]

Perform some action with the given state as context at the start of a model fit.

Parameters: state (dict) – The current state dict of the Trial.

## Early Stopping¶

class torchbearer.callbacks.early_stopping.EarlyStopping(monitor='val_loss', min_delta=0, patience=0, verbose=0, mode='auto')[source]

Callback to stop training when a monitored quantity has stopped improving.

Parameters: monitor (str) – Name of quantity in metrics to be monitored min_delta (float) – Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute change of less than min_delta, will count as no improvement. patience (int) – Number of epochs with no improvement after which training will be stopped. verbose (int) – Verbosity mode, will print stopping info if verbose > 0 mode (str) – One of {auto, min, max}. In min mode, training will stop when the quantity monitored has stopped decreasing; in max mode it will stop when the quantity monitored has stopped increasing; in auto mode, the direction is automatically inferred from the name of the monitored quantity.
State Requirements:
load_state_dict(state_dict)[source]

Resume this callback from the given state. Expects that this callback was constructed in the same way.

Parameters: state_dict (dict) – The state dict to reload self Callback
on_end(state)[source]

Perform some action with the given state as context at the end of the model fitting.

Parameters: state (dict) – The current state dict of the Trial.
on_end_epoch(state)[source]

Perform some action with the given state as context at the end of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
state_dict()[source]

Get a dict containing the callback state.

Returns: A dict containing parameters and persistent buffers. dict
class torchbearer.callbacks.terminate_on_nan.TerminateOnNaN(monitor='running_loss')[source]

Callback which montiors the given metric and halts training if its value is nan or inf.

Parameters: monitor (str) – The name of the metric to monitor
State Requirements:
on_end_epoch(state)[source]

Perform some action with the given state as context at the end of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
on_step_training(state)[source]

Perform some action with the given state as context after step has been called on the optimiser.

Parameters: state (dict) – The current state dict of the Trial.
on_step_validation(state)[source]

Perform some action with the given state as context at the end of each validation step.

Parameters: state (dict) – The current state dict of the Trial.

class torchbearer.callbacks.gradient_clipping.GradientClipping(clip_value, params=None)[source]

Parameters: clip_value (float or int) – maximum allowed value of the gradients The gradients are clipped in the range [-clip_value, clip_value] params (Iterable[Tensor] or Tensor, optional) – an iterable of Tensors or a single Tensor that will have gradients normalized, otherwise this is retrieved from state
State Requirements:
on_backward(state)[source]

Between the backward pass (which computes the gradients) and the step call (which updates the parameters), clip the gradient.

Parameters: state (dict) – The Trial state
on_start(state)[source]

If params is None then retrieve from the model.

Parameters: state (dict) – The Trial state
class torchbearer.callbacks.gradient_clipping.GradientNormClipping(max_norm, norm_type=2, params=None)[source]

Parameters: max_norm (float or int) – max norm of the gradients norm_type (float or int) – type of the used p-norm. Can be 'inf' for infinity norm. params (Iterable[Tensor] or Tensor, optional) – an iterable of Tensors or a single Tensor that will have gradients normalized, otherwise this is retrieved from state
State Requirements:
on_backward(state)[source]

Between the backward pass (which computes the gradients) and the step call (which updates the parameters), clip the gradient.

Parameters: state (dict) – The Trial state
on_start(state)[source]

If params is None then retrieve from the model.

Parameters: state (dict) – The Trial state

## Learning Rate Schedulers¶

class torchbearer.callbacks.torch_scheduler.CosineAnnealingLR(T_max, eta_min=0, last_epoch=-1, step_on_batch=False)[source]
Parameters: step_on_batch (bool) – If True, step will be called on each training iteration rather than on each epoch
See:
PyTorch CosineAnnealingLR
class torchbearer.callbacks.torch_scheduler.ExponentialLR(gamma, last_epoch=-1, step_on_batch=False)[source]
Parameters: step_on_batch (bool) – If True, step will be called on each training iteration rather than on each epoch
See:
PyTorch ExponentialLR
class torchbearer.callbacks.torch_scheduler.LambdaLR(lr_lambda, last_epoch=-1, step_on_batch=False)[source]
Parameters: step_on_batch (bool) – If True, step will be called on each training iteration rather than on each epoch
See:
PyTorch LambdaLR
class torchbearer.callbacks.torch_scheduler.MultiStepLR(milestones, gamma=0.1, last_epoch=-1, step_on_batch=False)[source]
Parameters: step_on_batch (bool) – If True, step will be called on each training iteration rather than on each epoch
See:
PyTorch MultiStepLR
class torchbearer.callbacks.torch_scheduler.ReduceLROnPlateau(monitor='val_loss', mode='min', factor=0.1, patience=10, verbose=False, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-08, step_on_batch=False)[source]
Parameters: monitor (str) – The name of the quantity in metrics to monitor. (Default value = ‘val_loss’) step_on_batch (bool) – If True, step will be called on each training iteration rather than on each epoch
See:
PyTorch ReduceLROnPlateau
class torchbearer.callbacks.torch_scheduler.StepLR(step_size, gamma=0.1, last_epoch=-1, step_on_batch=False)[source]
Parameters: step_on_batch (bool) – If True, step will be called on each training iteration rather than on each epoch
See:
PyTorch StepLR
class torchbearer.callbacks.torch_scheduler.TorchScheduler(scheduler_builder, monitor=None, step_on_batch=False)[source]
on_end_epoch(state)[source]

Perform some action with the given state as context at the end of each epoch.

Parameters: state (dict) – The current state dict of the Trial.
on_sample(state)[source]

Perform some action with the given state as context after data has been sampled from the generator.

Parameters: state (dict) – The current state dict of the Trial.
on_start(state)[source]

Perform some action with the given state as context at the start of a model fit.

Parameters: state (dict) – The current state dict of the Trial.
on_start_training(state)[source]

Perform some action with the given state as context at the start of the training loop.

Parameters: state (dict) – The current state dict of the Trial.
on_step_training(state)[source]

Perform some action with the given state as context after step has been called on the optimiser.

Parameters: state (dict) – The current state dict of the Trial.

## Learning Rate Finders¶

class torchbearer.callbacks.lr_finder.CyclicLR(base_lr=0.001, max_lr=0.006, step_size=2000, mode='triangular', scale_fn=None, scale_mode='cycle', gamma=1.0)[source]

Learning rate finder that cyclicly varies the rate. Based off of the keras implementation referenced in the paper.

@inproceedings{smith2017cyclical,
title={Cyclical learning rates for training neural networks},
author={Smith, Leslie N},
booktitle={2017 IEEE Winter Conference on Applications of Computer Vision (WACV)},
pages={464--472},
year={2017},
organization={IEEE}
}

Parameters: base_lr (float / list) – Float or list of floats for the base (min) learning rate for each optimiser parameter group max_lr (float / list) – Float or list of floats for the max learning rate for each optimiser parameter group step_size (int / list) – int or list of ints for the step size (half cyclic period) for each optimiser parameter group mode (str) – One of (triangular, triangular2, exp_range) - the mode to use scale_fn (function) – Scale function for learning rates over time. Default is defined by mode. scale_mode (str) – One of (cycle, iterations). Argument passed to the scale function each step gamma (float) – Scaling factor for exp_range mode
next_lr(epoch_count, group_id)[source]
on_sample(state)[source]

Perform some action with the given state as context after data has been sampled from the generator.

Parameters: state (dict) – The current state dict of the Trial.
on_start(state)[source]

Perform some action with the given state as context at the start of a model fit.

Parameters: state (dict) – The current state dict of the Trial.
on_step_training(state)[source]

Perform some action with the given state as context after step has been called on the optimiser.

Parameters: state (dict) – The current state dict of the Trial.
update_lrs()[source]

## Weight Decay¶

class torchbearer.callbacks.weight_decay.L1WeightDecay(rate=0.0005, params=None)[source]

WeightDecay callback which uses an L1 norm with the given rate and parameters. If params is None (default) then the parameters will be retrieved from the model.

Parameters: rate (float) – The decay rate or lambda params (Iterable[Tensor] or Tensor, optional) – an iterable of Tensors or a single Tensor that will have gradients normalized, otherwise this is retrieved from state
State Requirements:
class torchbearer.callbacks.weight_decay.L2WeightDecay(rate=0.0005, params=None)[source]

WeightDecay callback which uses an L2 norm with the given rate and parameters. If params is None (default) then the parameters will be retrieved from the model.

Parameters: rate (float) – The decay rate or lambda params (Iterable[Tensor] or Tensor, optional) – an iterable of Tensors or a single Tensor that will have gradients normalized, otherwise this is retrieved from state
State Requirements:
class torchbearer.callbacks.weight_decay.WeightDecay(rate=0.0005, p=2, params=None)[source]

Create a WeightDecay callback which uses the given norm on the given parameters and with the given decay rate. If params is None (default) then the parameters will be retrieved from the model.

Parameters: rate (float) – The decay rate or lambda p (int) – The norm level params (Iterable[Tensor] or Tensor, optional) – an iterable of Tensors or a single Tensor that will have gradients normalized, otherwise this is retrieved from state
State Requirements:
on_criterion(state)[source]

Calculate the decay term and add to state[‘loss’].

Parameters: state (dict) – The Trial state
on_start(state)[source]

Retrieve params from state[‘model’] if required.

Parameters: state (dict) – The Trial state

## Weight / Bias Initialisation¶

class torchbearer.callbacks.init.KaimingNormal(a=0, mode='fan_in', nonlinearity='leaky_relu', modules=None, targets=['Conv', 'Linear', 'Bilinear'])[source]

Kaiming Normal weight initialisation. Uses torch.nn.init.kaiming_normal_ on the weight attribute of the filtered modules.

@inproceedings{he2015delving,
title={Delving deep into rectifiers: Surpassing human-level performance on imagenet classification},
author={He, Kaiming and Zhang, Xiangyu and Ren, Shaoqing and Sun, Jian},
booktitle={Proceedings of the IEEE international conference on computer vision},
pages={1026--1034},
year={2015}
}

Parameters: modules (Iterable[nn.Module] or nn.Module, optional) – an iterable of nn.Modules or a single nn.Module that will have weights initialised, otherwise this is retrieved from the model targets (list[String]) – A list of lookup strings to match which modules will be initialised
See:
PyTorch kaiming_normal_
class torchbearer.callbacks.init.KaimingUniform(a=0, mode='fan_in', nonlinearity='leaky_relu', modules=None, targets=['Conv', 'Linear', 'Bilinear'])[source]

Kaiming Uniform weight initialisation. Uses torch.nn.init.kaiming_uniform_ on the weight attribute of the filtered modules.

@inproceedings{he2015delving,
title={Delving deep into rectifiers: Surpassing human-level performance on imagenet classification},
author={He, Kaiming and Zhang, Xiangyu and Ren, Shaoqing and Sun, Jian},
booktitle={Proceedings of the IEEE international conference on computer vision},
pages={1026--1034},
year={2015}
}

Parameters: modules (Iterable[nn.Module] or nn.Module, optional) – an iterable of nn.Modules or a single nn.Module that will have weights initialised, otherwise this is retrieved from the model targets (list[String]) – A list of lookup strings to match which modules will be initialised
See:
PyTorch kaiming_uniform_
class torchbearer.callbacks.init.LsuvInit(data_item, weight_lambda=None, needed_std=1.0, std_tol=0.1, max_attempts=10, do_orthonorm=True)[source]

Layer-sequential unit-variance (LSUV) initialization as described in All you need is a good init and modified from the code by ducha-aiki. To be consistent with the paper, LsuvInit should be preceeded by a ZeroBias init on the Linear and Conv layers.

@article{mishkin2015all,
title={All you need is a good init},
author={Mishkin, Dmytro and Matas, Jiri},
journal={arXiv preprint arXiv:1511.06422},
year={2015}
}

Parameters: data_item (torch.Tensor) – A representative data item to put through the model weight_lambda (lambda) – A function that takes a module and returns the weight attribute. If none defaults to module.weight. needed_std – See paper, where needed_std is always 1.0 std_tol – See paper, Tol_{var} max_attempts – See paper, T_{max} do_orthonorm – See paper, first pre-initialise with orthonormal matricies
State Requirements:
on_init(state)[source]

Perform some action with the given state as context at the init of a trial instance

Parameters: state (dict) – The current state dict of the Trial.
class torchbearer.callbacks.init.WeightInit(initialiser=<function WeightInit.<lambda>>, modules=None, targets=['Conv', 'Linear', 'Bilinear'])[source]

Base class for weight initialisations. Performs the provided function for each module when on_init is called.

Parameters: initialiser (lambda) – a function which initialises an nn.Module inplace modules (Iterable[nn.Module] or nn.Module, optional) – an iterable of nn.Modules or a single nn.Module that will have weights initialised, otherwise this is retrieved from the model targets (list[String]) – A list of lookup strings to match which modules will be initialised
State Requirements:
on_init(state)[source]

Perform some action with the given state as context at the init of a trial instance

Parameters: state (dict) – The current state dict of the Trial.
class torchbearer.callbacks.init.XavierNormal(gain=1, modules=None, targets=['Conv', 'Linear', 'Bilinear'])[source]

Xavier Normal weight initialisation. Uses torch.nn.init.xavier_normal_ on the weight attribute of the filtered modules.

@inproceedings{glorot2010understanding,
title={Understanding the difficulty of training deep feedforward neural networks},
author={Glorot, Xavier and Bengio, Yoshua},
booktitle={Proceedings of the thirteenth international conference on artificial intelligence and statistics},
pages={249--256},
year={2010}
}

Parameters: modules (Iterable[nn.Module] or nn.Module, optional) – an iterable of nn.Modules or a single nn.Module that will have weights initialised, otherwise this is retrieved from the model targets (list[String]) – A list of lookup strings to match which modules will be initialised
See:
PyTorch xavier_normal_
class torchbearer.callbacks.init.XavierUniform(gain=1, modules=None, targets=['Conv', 'Linear', 'Bilinear'])[source]

Xavier Uniform weight initialisation. Uses torch.nn.init.xavier_uniform_ on the weight attribute of the filtered modules.

@inproceedings{glorot2010understanding,
title={Understanding the difficulty of training deep feedforward neural networks},
author={Glorot, Xavier and Bengio, Yoshua},
booktitle={Proceedings of the thirteenth international conference on artificial intelligence and statistics},
pages={249--256},
year={2010}
}

Parameters: modules (Iterable[nn.Module] or nn.Module, optional) – an iterable of nn.Modules or a single nn.Module that will have weights initialised, otherwise this is retrieved from the model targets (list[String]) – A list of lookup strings to match which modules will be initialised
See:
PyTorch xavier_uniform_
class torchbearer.callbacks.init.ZeroBias(modules=None, targets=['Conv', 'Linear', 'Bilinear'])[source]

Zero initialisation for the bias attributes of filtered modules. This is recommended for use in conjunction with weight initialisation schemes.

Parameters: modules (Iterable[nn.Module] or nn.Module, optional) – an iterable of nn.Modules or a single nn.Module that will have weights initialised, otherwise this is retrieved from the model targets (list[String]) – A list of lookup strings to match which modules will be initialised

## Decorators¶

class torchbearer.callbacks.decorators.LambdaCallback(func)[source]
on_lambda(state)[source]
torchbearer.callbacks.decorators.add_to_loss(func)[source]

The add_to_loss() decorator is used to initialise a Callback with the value returned from func being added to the loss

Parameters: func (function) – The function(state) to decorate Initialised callback which adds the returned value from func to the loss Callback
torchbearer.callbacks.decorators.bind_to(target)[source]
torchbearer.callbacks.decorators.count_args(fcn)[source]
torchbearer.callbacks.decorators.on_backward(func)[source]

The on_backward() decorator is used to initialise a Callback with on_backward() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_backward() calling func Callback
torchbearer.callbacks.decorators.on_checkpoint(func)[source]

The on_checkpoint() decorator is used to initialise a Callback with on_checkpoint() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_checkpoint() calling func Callback
torchbearer.callbacks.decorators.on_criterion(func)[source]

The on_criterion() decorator is used to initialise a Callback with on_criterion() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_criterion() calling func Callback
torchbearer.callbacks.decorators.on_criterion_validation(func)[source]

The on_criterion_validation() decorator is used to initialise a Callback with on_criterion_validation() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_criterion_validation() calling func Callback
torchbearer.callbacks.decorators.on_end(func)[source]

The on_end() decorator is used to initialise a Callback with on_end() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_end() calling func Callback
torchbearer.callbacks.decorators.on_end_epoch(func)[source]

The on_end_epoch() decorator is used to initialise a Callback with on_end_epoch() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_end_epoch() calling func Callback
torchbearer.callbacks.decorators.on_end_training(func)[source]

The on_end_training() decorator is used to initialise a Callback with on_end_training() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_end_training() calling func Callback
torchbearer.callbacks.decorators.on_end_validation(func)[source]

The on_end_validation() decorator is used to initialise a Callback with on_end_validation() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_end_validation() calling func Callback
torchbearer.callbacks.decorators.on_forward(func)[source]

The on_forward() decorator is used to initialise a Callback with on_forward() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_forward() calling func Callback
torchbearer.callbacks.decorators.on_forward_validation(func)[source]

The on_forward_validation() decorator is used to initialise a Callback with on_forward_validation() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_forward_validation() calling func Callback
torchbearer.callbacks.decorators.on_sample(func)[source]

The on_sample() decorator is used to initialise a Callback with on_sample() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_sample() calling func Callback
torchbearer.callbacks.decorators.on_sample_validation(func)[source]

The on_sample_validation() decorator is used to initialise a Callback with on_sample_validation() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_sample_validation() calling func Callback
torchbearer.callbacks.decorators.on_start(func)[source]

The on_start() decorator is used to initialise a Callback with on_start() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_start() calling func Callback
torchbearer.callbacks.decorators.on_start_epoch(func)[source]

The on_start_epoch() decorator is used to initialise a Callback with on_start_epoch() calling the decorated function

Args: func (function): The function(state) to decorate
Returns: Initialised callback with on_start_epoch() calling func Callback
torchbearer.callbacks.decorators.on_start_training(func)[source]

The on_start_training() decorator is used to initialise a Callback with on_start_training() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_start_training() calling func Callback
torchbearer.callbacks.decorators.on_start_validation(func)[source]

The on_start_validation() decorator is used to initialise a Callback with on_start_validation() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_start_validation() calling func Callback
torchbearer.callbacks.decorators.on_step_training(func)[source]

The on_step_training() decorator is used to initialise a Callback with on_step_training() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_step_training() calling func Callback
torchbearer.callbacks.decorators.on_step_validation(func)[source]

The on_step_validation() decorator is used to initialise a Callback with on_step_validation() calling the decorated function

Parameters: func (function) – The function(state) to decorate Initialised callback with on_step_validation() calling func Callback
torchbearer.callbacks.decorators.once(fcn)[source]

Decorator to fire a callback once in the lifetime of the callback. If the callback is a class method, each instance of the class will fire only once. For functions, only the first instance will fire (even if more than one function is present in the callback list).

Parameters: fcn (function) – the torchbearer callback function to decorate. the decorator
torchbearer.callbacks.decorators.once_per_epoch(fcn)[source]

Decorator to fire a callback once (on the first call) in any given epoch. If the callback is a class method, each instance of the class will fire once per epoch. For functions, only the first instance will fire (even if more than one function is present in the callback list).

Note

The decorated callback may exhibit unusual behaviour if it is reused

Parameters: fcn (function) – the torchbearer callback function to decorate. the decorator
torchbearer.callbacks.decorators.only_if(condition_expr)[source]

Decorator to fire a callback only if the given conditional expression function returns True. The conditional expression can be a function of state or self and state. If the decorated function is not a class method (i.e. it does not take state) the decorated function will be passed instead. This enables the storing of temporary variables.

Parameters: condition_expr (function(self, state) or function(self)) – a function/lambda which takes state and optionally self that must evaluate to true for the decorated torchbearer callback to be called. The state object passed to the callback will be passed as an argument to the condition function. the decorator