Training history and visualization in TensorFlow

Introduction

Training history helps us see how well a model learns over time. Visualization makes it easy to understand the model's progress and spot problems.

You want to check if your model is improving during training.

You want to compare training and validation performance to detect overfitting.

You want to decide when to stop training based on the learning curves.

You want to share model training results with others in a clear way.

Syntax

TensorFlow

history = model.fit(x_train, y_train, epochs=10, validation_data=(x_val, y_val))

import matplotlib.pyplot as plt
plt.plot(history.history['loss'], label='train loss')
plt.plot(history.history['val_loss'], label='val loss')
plt.legend()
plt.show()

The fit() method returns a History object that stores training details.

history.history is a dictionary with keys like 'loss' and 'val_loss' for each epoch.

Examples

Train the model for 5 epochs without validation data.

TensorFlow

history = model.fit(x_train, y_train, epochs=5)

Train with 20% of training data used for validation.

TensorFlow

history = model.fit(x_train, y_train, epochs=10, validation_split=0.2)

Plot training and validation accuracy over epochs.

TensorFlow

plt.plot(history.history['accuracy'], label='train accuracy')
plt.plot(history.history['val_accuracy'], label='val accuracy')
plt.legend()
plt.show()

Sample Model

This code trains a small neural network on the XOR problem and shows how loss and accuracy change over 20 epochs. It also prints the final accuracy.

TensorFlow

import tensorflow as tf
from tensorflow.keras import layers, models
import matplotlib.pyplot as plt

# Prepare simple data: XOR problem
x_train = [[0,0],[0,1],[1,0],[1,1]]
y_train = [0,1,1,0]

# Build a small model
model = models.Sequential([
    layers.Dense(4, activation='relu', input_shape=(2,)),
    layers.Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train model and save history
history = model.fit(x_train, y_train, epochs=20, verbose=0)

# Plot loss and accuracy
plt.figure(figsize=(10,4))
plt.subplot(1,2,1)
plt.plot(history.history['loss'], label='loss')
plt.title('Training Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()

plt.subplot(1,2,2)
plt.plot(history.history['accuracy'], label='accuracy')
plt.title('Training Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()

plt.tight_layout()
plt.show()

# Print final accuracy
final_acc = history.history['accuracy'][-1]
print(f'Final training accuracy: {final_acc:.2f}')

Important Notes

Validation data helps check if the model is learning patterns or just memorizing.

If training loss goes down but validation loss goes up, the model might be overfitting.

Plotting metrics after training gives a clear picture of model behavior.

Summary

Training history stores loss and accuracy for each epoch.

Visualizing history helps understand model learning and spot issues.

Use matplotlib to plot training and validation metrics easily.

Practice

1. What does the history.history object store after training a TensorFlow model?

easy

A. The dataset used for training

B. The model's architecture details

C. Loss and accuracy values for each epoch during training

D. The optimizer's internal state

Solution

1. Step 1: Understand what history.history contains

   After training, TensorFlow's model.fit() returns a history object that stores metrics like loss and accuracy for each epoch.

2. Step 2: Identify the correct stored data

   The history.history dictionary holds lists of loss and accuracy values recorded at each epoch for training and validation.

3. Final Answer:

   Loss and accuracy values for each epoch during training -> Option C

4. Quick Check:

   Training metrics stored in history.history = Loss and accuracy values for each epoch during training [OK]

Hint: Remember: history stores metrics per epoch, not model or data [OK]

Common Mistakes:

• Confusing history with model architecture
• Thinking history stores the dataset
• Assuming history holds optimizer state

2. Which of the following is the correct way to plot training and validation accuracy from a TensorFlow history object using matplotlib?

easy

A. plt.plot(history.history['accuracy']); plt.plot(history.history['val_accuracy'])

B. plt.plot(history['accuracy']); plt.plot(history['val_accuracy'])

C. plt.plot(history.accuracy); plt.plot(history.val_accuracy)

D. plt.plot(history.accuracy()); plt.plot(history.val_accuracy())

Solution

1. Step 1: Recall how to access metrics in history object

   The history object stores metrics in a dictionary under history.history. Access keys like 'accuracy' and 'val_accuracy' as dictionary keys.

2. Step 2: Use matplotlib to plot lists from the dictionary

   Use plt.plot() with history.history['accuracy'] and history.history['val_accuracy'] to plot training and validation accuracy.

3. Final Answer:

   plt.plot(history.history['accuracy']); plt.plot(history.history['val_accuracy']) -> Option A

4. Quick Check:

   Access metrics via history.history['key'] for plotting [OK]

Hint: Always access metrics with history.history['metric_name'] [OK]

Common Mistakes:

• Using dot notation instead of dictionary keys
• Calling metrics as functions
• Accessing history directly without .history

3. Given the following code snippet, what will be the output of print(history.history['loss']) after training for 3 epochs?

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
history = model.fit(x_train, y_train, epochs=3, validation_data=(x_val, y_val))
print(history.history['loss'])

medium

A. A list of 3 loss values, one per epoch

B. An error because 'loss' key does not exist

C. A single float value of final loss

D. [0.8, 0.6, 0.4]

Solution

1. Step 1: Understand what history.history['loss'] contains

   It stores the loss values recorded at the end of each epoch during training as a list.

2. Step 2: Predict the output after 3 epochs

   Since training runs for 3 epochs, the list will have 3 float values representing loss per epoch, not just one or a fixed list.

3. Final Answer:

   A list of 3 loss values, one per epoch -> Option A

4. Quick Check:

   Loss per epoch stored as list = A list of 3 loss values, one per epoch [OK]

Hint: Loss history is a list with one value per epoch [OK]

Common Mistakes:

• Expecting a single float instead of a list
• Assuming fixed loss values without training
• Thinking 'loss' key is missing

4. Identify the error in this code snippet that tries to plot training and validation loss:

import matplotlib.pyplot as plt
plt.plot(history['loss'])
plt.plot(history['val_loss'])
plt.show()

medium

A. plt.plot() cannot plot lists

B. history should be accessed as history.history, not directly

C. Missing plt.title() causes error

D. No error, code runs fine

Solution

1. Step 1: Check how history metrics are accessed

   The history object stores metrics inside the history attribute, so direct access like history['loss'] is incorrect.

2. Step 2: Correct the access to history.history['loss']

   To fix, use history.history['loss'] and history.history['val_loss'] for plotting.

3. Final Answer:

   history should be accessed as history.history, not directly -> Option B

4. Quick Check:

   Access metrics via history.history, not history [OK]

Hint: Use history.history to access metrics, not history alone [OK]

Common Mistakes:

• Accessing history metrics directly
• Assuming plt.plot can't plot lists
• Thinking missing title causes error

5. You trained a model for 10 epochs but notice the validation loss increases after epoch 5 while training loss decreases. How can visualizing the training history help you decide the next step?

hard

A. It suggests increasing the learning rate to fix validation loss

B. It confirms the model is perfect, so no changes needed

C. It means the training data is incorrect and should be discarded

D. It shows overfitting, so you might stop training early or add regularization

Solution

1. Step 1: Interpret the training and validation loss curves

   When training loss decreases but validation loss increases, it indicates the model is overfitting the training data.

2. Step 2: Decide actions based on visualization

   Visualizing history helps identify overfitting, suggesting to stop early, add dropout, or use regularization to improve generalization.

3. Final Answer:

   It shows overfitting, so you might stop training early or add regularization -> Option D

4. Quick Check:

   Increasing validation loss with decreasing training loss = overfitting [OK]

Hint: Watch for validation loss rising while training loss falls [OK]

Common Mistakes:

• Ignoring validation loss trends
• Increasing learning rate without reason
• Assuming data is wrong without checking