Custom callbacks in TensorFlow - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a custom callback class that prints a message at the end of each epoch.

TensorFlow

import tensorflow as tf

class MyCallback(tf.keras.callbacks.Callback):
    def on_epoch_end(self, epoch, logs=None):
        print('Epoch', epoch, 'has ended')

callback = MyCallback()
model.fit(x_train, y_train, epochs=5, callbacks=[[1]])

Drag options to blanks, or click blank then click option'

Acallbacks

BMyCallback

Ccallback

DCallback

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the class name instead of the instance.

Passing an undefined variable.

The instance of the custom callback class is named 'callback', so it should be passed inside the callbacks list.

2fill in blank

medium

Complete the code to stop training early when accuracy reaches 90%.

TensorFlow

import tensorflow as tf

class EarlyStopCallback(tf.keras.callbacks.Callback):
    def on_epoch_end(self, epoch, logs=None):
        if logs.get('accuracy') and logs.get('accuracy') > [1]:
            print('Reached 90% accuracy, stopping training!')
            self.model.stop_training = True

callback = EarlyStopCallback()

Drag options to blanks, or click blank then click option'

A0.9

B90

C0.09

D1.0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 90 instead of 0.9.

Using 1.0 which means 100% accuracy.

Accuracy values are between 0 and 1, so 90% accuracy is 0.9.

3fill in blank

hard

Fix the error in the custom callback to correctly access validation loss after each epoch.

TensorFlow

import tensorflow as tf

class ValLossCallback(tf.keras.callbacks.Callback):
    def on_epoch_end(self, epoch, logs=None):
        val_loss = logs.get([1])
        print(f'Validation loss after epoch {epoch}:', val_loss)

callback = ValLossCallback()

Drag options to blanks, or click blank then click option'

A'val_loss'

B'validation_loss'

C'val-loss'

D'loss_val'

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'validation_loss' which is incorrect.

Using 'val-loss' with a dash instead of underscore.

The correct key for validation loss in logs is 'val_loss'.

4fill in blank

hard

Fill both blanks to create a callback that saves the model weights only when validation accuracy improves.

TensorFlow

import tensorflow as tf

class SaveBestModel(tf.keras.callbacks.Callback):
    def __init__(self):
        super().__init__()
        self.best_acc = 0

    def on_epoch_end(self, epoch, logs=None):
        current_acc = logs.get([1])
        if current_acc and current_acc > self.best_acc:
            self.best_acc = current_acc
            self.model.save_weights([2])

callback = SaveBestModel()

Drag options to blanks, or click blank then click option'

A'val_accuracy'

B'accuracy'

C'best_weights.h5'

D'weights_best.h5'

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'accuracy' instead of 'val_accuracy'.

Saving weights to a generic or unclear filename.

Validation accuracy is accessed with 'val_accuracy', and the weights are saved to 'best_weights.h5'.

5fill in blank

hard

Fill all three blanks to create a callback that logs loss and accuracy to a file after each epoch.

TensorFlow

import tensorflow as tf

class LogToFile(tf.keras.callbacks.Callback):
    def __init__(self, filename):
        super().__init__()
        self.filename = filename

    def on_epoch_end(self, epoch, logs=None):
        loss = logs.get([1])
        acc = logs.get([2])
        with open(self.filename, [3]) as f:
            f.write(f'Epoch {epoch}: loss={loss}, accuracy={acc}\n')

callback = LogToFile('training_log.txt')

Drag options to blanks, or click blank then click option'

A'loss'

B'accuracy'

C'a'

D'w'

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'val_loss' or 'val_accuracy' instead of 'loss' and 'accuracy'.

Opening the file in write mode 'w' which overwrites previous logs.

We get 'loss' and 'accuracy' from logs, and open the file in append mode 'a' to add logs after each epoch.

Practice

1. What is the main purpose of creating a custom callback in TensorFlow?

easy

A. To run your own code at specific points during model training

B. To change the model architecture automatically

C. To increase the dataset size during training

D. To convert the model to a different format

Solution

1. Step 1: Understand what callbacks do

   Callbacks let you add custom actions during training, like logging or stopping early.

2. Step 2: Identify the role of custom callbacks

   Custom callbacks let you run your own code at points like start/end of epochs or batches.

3. Final Answer:

   To run your own code at specific points during model training -> Option A

4. Quick Check:

   Custom callbacks = run code during training [OK]

Hint: Callbacks run code during training steps [OK]

Common Mistakes:

• Thinking callbacks change model structure
• Confusing callbacks with data augmentation
• Assuming callbacks convert model formats

2. Which method should you override in a custom callback to execute code at the end of each training epoch?

easy

A. on_train_begin

B. on_epoch_end

C. on_batch_begin

D. on_train_end

Solution

1. Step 1: Recall callback method names

   Common callback methods include on_train_begin, on_epoch_end, on_batch_begin, on_train_end.

2. Step 2: Match method to event

   on_epoch_end runs code after each epoch finishes, which is what the question asks.

3. Final Answer:

   on_epoch_end -> Option B

4. Quick Check:

   End of epoch method = on_epoch_end [OK]

Hint: End of epoch callback method is on_epoch_end [OK]

Common Mistakes:

• Using on_train_begin for epoch end
• Confusing batch and epoch methods
• Overriding on_train_end instead

3. What will be printed after training if this custom callback is used?

import tensorflow as tf
class MyCallback(tf.keras.callbacks.Callback):
    def on_epoch_end(self, epoch, logs=None):
        print(f"Epoch {epoch+1} ended with loss {logs['loss']:.2f}")

model = tf.keras.Sequential([tf.keras.layers.Dense(1)])
model.compile(optimizer='sgd', loss='mse')
model.fit([[1.0]], [[2.0]], epochs=2, callbacks=[MyCallback()])

medium

A. Error because logs is None

B. Epoch 0 ended with loss X\nEpoch 1 ended with loss Y

C. No output printed during training

D. Epoch 1 ended with loss X\nEpoch 2 ended with loss Y (X and Y are numbers)

Solution

1. Step 1: Understand on_epoch_end behavior

   The method prints epoch number +1 and loss from logs after each epoch.

2. Step 2: Check training epochs and output

   Training runs 2 epochs, so prints for epoch 1 and 2 with loss values (numbers).

3. Final Answer:

   Epoch 1 ended with loss X\nEpoch 2 ended with loss Y (X and Y are numbers) -> Option D

4. Quick Check:

   Prints after each epoch with loss [OK]

Hint: Epoch count starts at 0, print adds 1 [OK]

Common Mistakes:

• Assuming epoch numbering starts at 1 internally
• Expecting no print output
• Thinking logs is None causing error

4. Identify the error in this custom callback code that tries to stop training when loss is below 0.1:

class StopCallback(tf.keras.callbacks.Callback):
    def on_epoch_end(self, epoch, logs=None):
        if logs['loss'] < 0.1:
            self.model.stop_training = True

model.fit(x_train, y_train, epochs=10, callbacks=[StopCallback()])

medium

A. on_epoch_end method must return a value

B. stop_training should be called as a method

C. logs dictionary might be None causing KeyError

D. Callback class must inherit from tf.keras.Model

Solution

1. Step 1: Check logs usage

   logs can be None if no metrics are passed, so logs['loss'] may cause KeyError.

2. Step 2: Confirm correct way to stop training

   Setting self.model.stop_training = True is correct; no method call needed.

3. Final Answer:

   logs dictionary might be None causing KeyError -> Option C

4. Quick Check:

   Check logs is not None before accessing [OK]

Hint: Always check logs is not None before using keys [OK]

Common Mistakes:

• Calling stop_training as a method
• Expecting on_epoch_end to return a value
• Inheriting from wrong base class

5. You want to save the model weights only when validation accuracy improves during training. Which custom callback method and logic should you implement?

hard

A. Override on_epoch_end, check logs['val_accuracy'], save weights if improved

B. Override on_train_begin, save weights before training starts

C. Override on_batch_end, save weights after every batch

D. Override on_train_end, save weights after training finishes

Solution

1. Step 1: Identify when to check validation accuracy

   Validation accuracy is updated at epoch end, so on_epoch_end is the right method.

2. Step 2: Implement logic to save weights only if val_accuracy improves

   Inside on_epoch_end, compare current val_accuracy with previous best and save if better.

3. Final Answer:

   Override on_epoch_end, check logs['val_accuracy'], save weights if improved -> Option A

4. Quick Check:

   Save on epoch end if val_accuracy improves [OK]

Hint: Use on_epoch_end to monitor validation metrics [OK]

Common Mistakes:

• Saving weights too often (every batch)
• Saving only before or after all training
• Not checking if accuracy improved before saving