Pre-trained models (VGG, ResNet, MobileNet) in TensorFlow - ML Experiment: Train & Evaluate

Experiment - Pre-trained models (VGG, ResNet, MobileNet)

Problem:You want to classify images into 10 categories using a pre-trained model. Currently, you use VGG16 without fine-tuning. The training accuracy is 95%, but validation accuracy is only 70%.

Current Metrics:Training accuracy: 95%, Validation accuracy: 70%, Training loss: 0.15, Validation loss: 0.85

Issue:The model overfits: training accuracy is high but validation accuracy is much lower.

Your Task

Reduce overfitting and improve validation accuracy to at least 85% while keeping training accuracy below 92%.

Use TensorFlow and Keras only.

Use one of the pre-trained models: VGG16, ResNet50, or MobileNet.

You can add dropout or data augmentation.

Do not change the dataset or number of classes.

Hint 1

Hint 2

Hint 3

Hint 4

Solution

TensorFlow

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.applications import MobileNet
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Load MobileNet base model with pretrained weights, exclude top layers
base_model = MobileNet(weights='imagenet', include_top=False, input_shape=(128, 128, 3))
base_model.trainable = False

# Add new classification head
model = models.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),
    layers.Dropout(0.4),
    layers.Dense(10, activation='softmax')
])

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

# Data augmentation
train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True
)

val_datagen = ImageDataGenerator(rescale=1./255)

# Assume train_images, train_labels, val_images, val_labels are numpy arrays
# For example purposes, placeholders are used here
train_images = tf.cast(255 * tf.random.uniform([1000, 128, 128, 3]), tf.uint8)
train_labels = tf.cast(tf.random.uniform([1000], maxval=10, dtype=tf.int32), tf.int32)
val_images = tf.cast(255 * tf.random.uniform([200, 128, 128, 3]), tf.uint8)
val_labels = tf.cast(tf.random.uniform([200], maxval=10, dtype=tf.int32), tf.int32)

train_generator = train_datagen.flow(train_images, train_labels, batch_size=32)
val_generator = val_datagen.flow(val_images, val_labels, batch_size=32)

# Train model
history = model.fit(train_generator, epochs=15, validation_data=val_generator)

# Unfreeze some base model layers for fine-tuning
base_model.trainable = True
for layer in base_model.layers[:-20]:
    layer.trainable = False

model.compile(optimizer=tf.keras.optimizers.Adam(1e-5), loss='sparse_categorical_crossentropy', metrics=['accuracy'])

history_fine = model.fit(train_generator, epochs=10, validation_data=val_generator)

Switched from VGG16 to MobileNet for a lighter, more generalizable model.

Added dropout layer with rate 0.4 to reduce overfitting.

Applied data augmentation to increase training data variety.

Initially froze base model layers and trained only the new head.

Later unfroze last 20 layers of base model for fine-tuning with low learning rate.

Results Interpretation

Before: Training accuracy 95%, Validation accuracy 70%, high overfitting.

After: Training accuracy 90%, Validation accuracy 87%, much better generalization.

Using a lighter pre-trained model with dropout and data augmentation reduces overfitting and improves validation accuracy. Fine-tuning some layers helps the model adapt better to new data.

Bonus Experiment

Try using ResNet50 with similar dropout and data augmentation to see if validation accuracy improves further.

💡 Hint

ResNet50 has skip connections that help training deeper networks. Freeze base layers first, then fine-tune with a low learning rate.

Practice

1. Which of the following is a key benefit of using pre-trained models like VGG, ResNet, or MobileNet in TensorFlow?

easy

A. They require training from scratch for every new task.

B. They cannot be fine-tuned for new tasks.

C. They only work with text data, not images.

D. They save time by using models already trained on large datasets.

Solution

1. Step 1: Understand what pre-trained models are

   Pre-trained models are AI models trained on large datasets like ImageNet before you use them.

2. Step 2: Identify the main advantage

   Using these models saves time because you don't need to train from zero; you can use their learned features directly.

3. Final Answer:

   They save time by using models already trained on large datasets. -> Option D

4. Quick Check:

   Pre-trained models save time = B [OK]

Hint: Pre-trained means already trained, so saves time [OK]

Common Mistakes:

• Thinking pre-trained models need full retraining
• Believing they only work on text data
• Assuming they cannot be fine-tuned

2. Which of the following is the correct way to load the MobileNetV2 pre-trained model in TensorFlow with weights trained on ImageNet?

easy

A. tf.keras.MobileNetV2(weights='imagenet')

B. tf.keras.applications.MobileNetV2(weights='imagenet')

C. tf.keras.applications.MobileNet(weights='imagenet')

D. tf.keras.applications.MobileNetV2(weights='random')

Solution

1. Step 1: Recall the correct TensorFlow module for pre-trained models

   Pre-trained models are loaded from tf.keras.applications, not directly from tf.keras.

2. Step 2: Check the correct model name and weights argument

   The correct model name is MobileNetV2 and weights='imagenet' loads pre-trained weights.

3. Final Answer:

   tf.keras.applications.MobileNetV2(weights='imagenet') -> Option B

4. Quick Check:

   Use tf.keras.applications + correct model name + weights='imagenet' = A [OK]

Hint: Use tf.keras.applications.ModelName(weights='imagenet') [OK]

Common Mistakes:

• Using tf.keras.MobileNetV2 instead of tf.keras.applications.MobileNetV2
• Using wrong model name like MobileNet instead of MobileNetV2
• Setting weights='random' instead of 'imagenet'

3. What will be the output shape of the following code snippet using the ResNet50 model in TensorFlow?

import tensorflow as tf
model = tf.keras.applications.ResNet50(weights='imagenet')
input_shape = (1, 224, 224, 3)
sample_input = tf.random.uniform(input_shape)
output = model(sample_input)
print(output.shape)

medium

A. (1, 7, 7, 2048)

B. (224, 224, 3)

C. (1, 1000)

D. (1, 100)

Solution

1. Step 1: Understand ResNet50 output for ImageNet weights

   ResNet50 with weights='imagenet' outputs predictions for 1000 classes, so output shape is (batch_size, 1000).

2. Step 2: Check input batch size and output shape

   Input batch size is 1, so output shape is (1, 1000).

3. Final Answer:

   (1, 1000) -> Option C

4. Quick Check:

   ResNet50 output shape = (batch_size, 1000) = A [OK]

Hint: Output shape matches number of ImageNet classes (1000) [OK]

Common Mistakes:

• Confusing output with input shape
• Expecting feature map shape instead of final predictions
• Assuming output has spatial dimensions

4. You tried to load the VGG16 model with this code:

model = tf.keras.applications.VGG16(weights='imagenet', include_top=False, input_shape=(28,28,3))

But got an error. What is the likely cause?

medium

A. Input shape must be at least 32x32 with 3 channels when include_top=False.

B. Weights='imagenet' is not supported for VGG16.

C. include_top=False cannot be used with input_shape argument.

D. VGG16 requires grayscale images, so 3 channels is wrong.

Solution

1. Step 1: Check VGG16 input shape requirements

   When include_top=False, VGG16 requires input images at least 32x32 pixels with 3 color channels.

2. Step 2: Verify input shape given

   Input shape (28,28,3) is smaller than 32x32x3 minimum when include_top=False, causing the error.

3. Step 3: Identify common mistake

   Often error happens if input_shape is smaller than 32x32 or channels not 3. The question implies error due to input shape constraints.

4. Final Answer:

   Input shape must be at least 32x32 with 3 channels when include_top=False. -> Option A

5. Quick Check:

   VGG16 input shape min size = 32x32x3 [OK]

Hint: VGG16 needs input ≥32x32x3 if include_top=False [OK]

Common Mistakes:

• Thinking weights='imagenet' is unsupported
• Believing include_top=False forbids input_shape
• Assuming VGG16 uses grayscale images

5. You want to build a fast image classifier for mobile devices using TensorFlow. Which pre-trained model should you choose to balance speed and accuracy?

hard

A. MobileNet, because it is designed for lightweight and fast inference.

B. ResNet50, because it uses residual connections for better training.

C. InceptionV3, because it has the most complex architecture.

D. VGG19, because it has the deepest layers and highest accuracy.

Solution

1. Step 1: Understand model design goals

   VGG19 is large and slow, ResNet50 is accurate but heavier, MobileNet is optimized for mobile with smaller size and speed.

2. Step 2: Match model to mobile device needs

   Mobile devices need fast, lightweight models, so MobileNet fits best for balancing speed and accuracy.

3. Final Answer:

   MobileNet, because it is designed for lightweight and fast inference. -> Option A

4. Quick Check:

   MobileNet = lightweight + fast for mobile [OK]

Hint: MobileNet is made for mobile speed and size [OK]

Common Mistakes:

• Choosing VGG19 for mobile despite size
• Assuming ResNet50 is fastest
• Picking InceptionV3 without speed consideration