5-8 callbacks

The callbacks in tf.keras is a class, usually specified as a parameter when use model.fit. It provides the extra operations at the starting or the ending of training, each epoch or each batch. These operations include record some log information, change learning rate, early termination of the training, etc.

Likewise, this callbacks parameter is also able to be specified for model.evaluate or model.predict, providing extra operations at the starting or the ending of the evaluation, prediction, or each batch. However this method is rarely used.

For the most cases, the pre-defined callbacks in the sub-module keras.callbacks are sufficient. It is also possible to define child class inheriting keras.callbacks.Callbacks to customize callbacks if necessary.

All the classes of callbacks are inheriting keras.callbacks.Callbacks, which contains two attributes: params and model.

params is a dictionary, which records training parameters (e.g. verbosity, batch size, number of epochs, etc.). model is the reference to the current model.

What’s more, there is an extra argument logs in the certain methods of the callbacks classes, such as on_epoch_begin, on_batch_end. This parameter provides certain information of current epoch or batch and are able to save the computing results. These logs variables are able to transfer among the functions with the same name in these callbacks classes.

1. Pre-defined Callbacks

  • BaseLogger: it calcuates the mean metrics among all batches for each epoch. For those metrics with middle status in staeful_metrics, it uses the final metrics without calculating mean value for all the batches, and the final mean metrics is added to the variable logs. This callback is automatically applied to every Keras model and is applied first.

  • History: a dictionary that records the metrics of each epoch calculated by BaseLogger and is returned by model.fit. This callback is automatically applied to every Keras model after BaseLogger.

  • EarlyStopping: this callback terminates the training if the monitoring metrics are not significantly increased after certain number of epoches.

  • TensorBoard: this callback saves the visualized log of the Tensorboard. It supports visualization of metrics, graphs and parameters in the model.

  • ModelCheckpoint: this callback saves model after each epoch.

  • ReduceLROnPlateau: this callback reduce the learning rate with certain rate if the monitoring metrics are not significantly increased after certain number of epoches.

  • TerminateOnNaN: terminate the training if loss is NaN.

  • LearningRateScheduler: it controls the learning rate before each epoch with given function between the learning rate lr and epoch.

  • CSVLogger: save logs of each epoch in CSV file.

  • ProgbarLogger: print the logs of each epoch into stardard I/O stream.

2. Customized Callbacks

It is possible to write a simple callback through callbacks.LambdaCallback, or write a complicated callback through inheriting base class callbacks.Callback.

Don’t hesitate to read the source code to know more details of the callbacks in tf.Keras.

  1. import numpy as np
  2. import pandas as pd
  3. import tensorflow as tf
  4. from tensorflow.keras import layers,models,losses,metrics,callbacks
  5. import tensorflow.keras.backend as K
  1. # Example of the simple callback using LambdaCallback
  3. import json
  4. json_log = open('../data/keras_log.json', mode='wt', buffering=1)
  5. json_logging_callback = callbacks.LambdaCallback(
  6.     on_epoch_end=lambda epoch, logs: json_log.write(
  7.         json.dumps(dict(epoch = epoch,**logs)) + '\n'),
  8.     on_train_end=lambda logs: json_log.close()
  9. )
  1. # Example of the complicated callback through base class inheritance. This is the source code of LearningRateScheduler.
  3. class LearningRateScheduler(callbacks.Callback):
  5.     def __init__(self, schedule, verbose=0):
  6.         super(LearningRateScheduler, self).__init__()
  7.         self.schedule = schedule
  8.         self.verbose = verbose
  10.     def on_epoch_begin(self, epoch, logs=None):
  11.         if not hasattr(self.model.optimizer, 'lr'):
  12.             raise ValueError('Optimizer must have a "lr" attribute.')
  13.         try:  
  14.             lr = float(K.get_value(self.model.optimizer.lr))
  15.             lr = self.schedule(epoch, lr)
  16.         except TypeError:  # Support for old API for backward compatibility
  17.             lr = self.schedule(epoch)
  18.         if not isinstance(lr, (tf.Tensor, float, np.float32, np.float64)):
  19.             raise ValueError('The output of the "schedule" function '
  20.                              'should be float.')
  21.         if isinstance(lr, ops.Tensor) and not lr.dtype.is_floating:
  22.             raise ValueError('The dtype of Tensor should be float')
  23.         K.set_value(self.model.optimizer.lr, K.get_value(lr))
  24.         if self.verbose > 0:
  25.             print('\nEpoch %05d: LearningRateScheduler reducing learning '
  26.                  'rate to %s.' % (epoch + 1, lr))
  28.     def on_epoch_end(self, epoch, logs=None):
  29.         logs = logs or {}
  30.         logs['lr'] = K.get_value(self.model.optimizer.lr)

Please leave comments in the WeChat official account “Python与算法之美” (Elegance of Python and Algorithms) if you want to communicate with the author about the content. The author will try best to reply given the limited time available.

You are also welcomed to join the group chat with the other readers through replying 加群 (join group) in the WeChat official account.

image.png