Batch normalization in TensorFlow - ML Experiment: Train & Evaluate

Experiment - Batch normalization

Problem:Train a neural network to classify handwritten digits from the MNIST dataset.

Current Metrics:Training accuracy: 98%, Validation accuracy: 85%, Training loss: 0.05, Validation loss: 0.45

Issue:The model shows overfitting: training accuracy is very high but validation accuracy is much lower.

Your Task

Reduce overfitting by improving validation accuracy to at least 90% while keeping training accuracy below 95%.

You can only add batch normalization layers after each dense layer.

Do not change the model architecture or dataset.

Keep the number of epochs and batch size the same.

Hint 1

Hint 2

Hint 3

Solution

TensorFlow

import tensorflow as tf
from tensorflow.keras import layers, models

# Load MNIST data
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()

# Normalize pixel values
X_train = X_train.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0

# Flatten images
X_train = X_train.reshape(-1, 28*28)
X_test = X_test.reshape(-1, 28*28)

# Build model with batch normalization
model = models.Sequential([
    layers.Dense(128, input_shape=(28*28,)),
    layers.BatchNormalization(),
    layers.Activation('relu'),
    layers.Dense(64),
    layers.BatchNormalization(),
    layers.Activation('relu'),
    layers.Dense(10, activation='softmax')
])

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

# Train model
history = model.fit(X_train, y_train, epochs=10, batch_size=32, validation_split=0.2, verbose=0)

# Evaluate on test data
loss, accuracy = model.evaluate(X_test, y_test, verbose=0)

print(f'Test accuracy: {accuracy*100:.2f}%', f'Test loss: {loss:.4f}')

Added BatchNormalization layers after each Dense layer and before activation.

Kept the same model architecture and training parameters.

Normalized input data and flattened images as before.

Results Interpretation

Before batch normalization: Training accuracy was 98%, validation accuracy 85%, showing overfitting.

After batch normalization: Training accuracy reduced to 93%, validation accuracy improved to 91%, with lower validation loss.

Batch normalization helps reduce overfitting by normalizing layer inputs, which stabilizes training and improves generalization.

Bonus Experiment

Try adding dropout layers after batch normalization to see if validation accuracy improves further.

💡 Hint

Dropout randomly disables neurons during training, which can further reduce overfitting.

Practice

1. What is the main purpose of BatchNormalization in a TensorFlow model?

easy

A. To add noise to the inputs for regularization

B. To normalize the inputs of a layer to speed up and stabilize training

C. To increase the learning rate automatically during training

D. To reduce the size of the model by removing neurons

Solution

1. Step 1: Understand batch normalization role

   Batch normalization normalizes inputs to a layer to keep data distribution stable during training.

2. Step 2: Identify its effect on training

   This normalization speeds up training and helps avoid issues like vanishing or exploding gradients.

3. Final Answer:

   To normalize the inputs of a layer to speed up and stabilize training -> Option B

4. Quick Check:

   BatchNormalization normalizes inputs [OK]

Hint: BatchNormalization normalizes inputs to stabilize training [OK]

Common Mistakes:

• Thinking it reduces model size
• Confusing it with learning rate adjustment
• Assuming it adds noise for regularization

2. Which of the following is the correct way to add a batch normalization layer after a dense layer in TensorFlow?

easy

A. model.add(tf.keras.layers.BatchNormalization(64)) before model.add(tf.keras.layers.Dense())

B. model.add(tf.keras.layers.Dense(64, batch_normalization=True))

C. model.add(tf.keras.layers.BatchNormalization()) after model.add(tf.keras.layers.Dense(64))

D. model.add(tf.keras.layers.Dense(64)) with batch_norm=True parameter

Solution

1. Step 1: Recall batch normalization usage

   BatchNormalization is a separate layer added after Dense, not a parameter inside Dense.

2. Step 2: Check syntax correctness

   model.add(tf.keras.layers.BatchNormalization()) after model.add(tf.keras.layers.Dense(64)) correctly adds BatchNormalization after Dense with no extra parameters.

3. Final Answer:

   model.add(tf.keras.layers.BatchNormalization()) after model.add(tf.keras.layers.Dense(64)) -> Option C

4. Quick Check:

   BatchNormalization is a separate layer added after Dense [OK]

Hint: BatchNormalization is a separate layer, not a Dense parameter [OK]

Common Mistakes:

• Trying to pass batch_normalization as Dense parameter
• Adding BatchNormalization before Dense layer
• Passing units to BatchNormalization layer

3. What will be the output shape of the following TensorFlow model snippet?

model = tf.keras.Sequential([
  tf.keras.layers.Dense(10, input_shape=(20,)),
  tf.keras.layers.BatchNormalization(),
  tf.keras.layers.Activation('relu')
])
output_shape = model.output_shape

medium

A. (None, 10)

B. (None, 20)

C. (10, None)

D. (20, 10)

Solution

1. Step 1: Analyze Dense layer output

   Dense(10) with input shape (20,) outputs shape (None, 10), where None is batch size.

2. Step 2: Check BatchNormalization and Activation effect

   BatchNormalization and Activation do not change shape, so output remains (None, 10).

3. Final Answer:

   (None, 10) -> Option A

4. Quick Check:

   Dense output shape = (None, 10) [OK]

Hint: BatchNormalization keeps shape same as previous layer output [OK]

Common Mistakes:

• Confusing input shape with output shape
• Assuming BatchNormalization changes output shape
• Mixing batch size dimension with feature dimension

4. Identify the error in this TensorFlow code snippet using batch normalization:

model = tf.keras.Sequential()
model.add(tf.keras.layers.BatchNormalization(input_shape=(32,)))
model.add(tf.keras.layers.Dense(64))
model.add(tf.keras.layers.Activation('relu'))

medium

A. BatchNormalization should not be the first layer with input_shape

B. Activation should be before BatchNormalization

C. Dense layer must come before BatchNormalization

D. BatchNormalization layer should come after Dense layer, not before

Solution

1. Step 1: Check layer order logic

   BatchNormalization normalizes outputs of previous layer, so it should come after Dense, not before.

2. Step 2: Validate input shape usage

   Input shape should be specified in first layer that processes input, usually Dense or Conv layer.

3. Final Answer:

   BatchNormalization layer should come after Dense layer, not before -> Option D

4. Quick Check:

   BatchNormalization follows Dense layer [OK]

Hint: BatchNormalization normalizes outputs, so place it after Dense [OK]

Common Mistakes:

• Placing BatchNormalization as first layer with input_shape
• Putting Activation before BatchNormalization
• Assuming BatchNormalization changes input shape

5. You want to add batch normalization to a convolutional neural network in TensorFlow. Which of the following is the best practice?

hard

A. Add BatchNormalization immediately after each convolutional layer and before activation

B. Add BatchNormalization only after the last convolutional layer

C. Add BatchNormalization before convolutional layers

D. Add BatchNormalization only after activation layers

Solution

1. Step 1: Understand batch normalization placement

   Best practice is to normalize outputs of convolutional layers before applying activation.

2. Step 2: Evaluate options

   Adding BatchNormalization after each conv layer and before activation stabilizes training and improves performance.

3. Final Answer:

   Add BatchNormalization immediately after each convolutional layer and before activation -> Option A

4. Quick Check:

   BatchNormalization follows conv layer, precedes activation [OK]

Hint: Place BatchNormalization after conv layer, before activation [OK]

Common Mistakes:

• Adding BatchNormalization only once at end
• Placing BatchNormalization before conv layers
• Adding BatchNormalization after activation