Transfer learning for small datasets in TensorFlow - Model Metrics & Evaluation

Metrics & Evaluation - Transfer learning for small datasets

Which metric matters and WHY

When using transfer learning on small datasets, accuracy is often used to see how well the model predicts. But accuracy alone can be misleading if classes are unbalanced.

We also focus on precision and recall because small datasets can cause the model to miss important cases (low recall) or make many wrong positive predictions (low precision).

F1 score helps balance precision and recall, giving a better overall picture.

Confusion Matrix Example

      Actual \ Predicted | Positive | Negative
      -------------------|----------|---------
      Positive           |    40    |   10
      Negative           |    5     |   45

      Total samples = 100
    

From this matrix:

• True Positives (TP) = 40
• False Negatives (FN) = 10
• False Positives (FP) = 5
• True Negatives (TN) = 45

Precision = 40 / (40 + 5) = 0.89

Recall = 40 / (40 + 10) = 0.80

Accuracy = (40 + 45) / 100 = 0.85

F1 Score = 2 * (0.89 * 0.80) / (0.89 + 0.80) ≈ 0.84

Precision vs Recall Tradeoff

In transfer learning with small data, you might see:

• High precision, low recall: Model is careful and only predicts positive when very sure, but misses many real positives. Good when false alarms are costly.
• High recall, low precision: Model finds most positives but also many false alarms. Good when missing positives is costly.

Example: If you use transfer learning to detect rare diseases from few images, high recall is important to catch all sick patients, even if some healthy are flagged wrongly.

Good vs Bad Metric Values

Good:

• Accuracy above 80% on small data with transfer learning
• Precision and recall both above 75%
• F1 score balanced and close to precision and recall

Bad:

• High accuracy but very low recall (e.g., 98% accuracy but 10% recall)
• Precision very low, causing many false positives
• F1 score much lower than precision or recall, showing imbalance

Common Pitfalls

• Accuracy paradox: High accuracy can hide poor performance on minority classes in small datasets.
• Data leakage: Using test data during training inflates metrics falsely.
• Overfitting: Transfer learning can overfit small data if too many layers are retrained.
• Ignoring class imbalance: Not adjusting for rare classes can mislead metric interpretation.

Self Check

Your transfer learning model on a small dataset has 98% accuracy but only 12% recall on the positive class (e.g., fraud). Is it good for production?

Answer: No. The model misses most positive cases (low recall), which is critical in fraud detection. Despite high accuracy, it fails to catch fraud effectively.

Key Result

For transfer learning on small datasets, balance precision and recall using F1 score to ensure reliable predictions beyond just accuracy.

Practice

1. What is the main reason to use transfer learning when working with small datasets in TensorFlow?

easy

A. To increase the size of the dataset automatically

B. To use a pretrained model's knowledge and avoid training from scratch

C. To reduce the number of layers in the model

D. To train all layers of a model from random weights

Solution

1. Step 1: Understand transfer learning purpose

   Transfer learning uses a pretrained model to leverage learned features from large datasets.

2. Step 2: Relate to small dataset challenges

   Small datasets lack enough data to train deep models well, so using pretrained knowledge helps.

3. Final Answer:

   To use a pretrained model's knowledge and avoid training from scratch -> Option B

4. Quick Check:

   Transfer learning = pretrained knowledge reuse [OK]

Hint: Transfer learning reuses pretrained features for small data [OK]

Common Mistakes:

• Thinking transfer learning increases dataset size
• Believing all layers must be retrained
• Assuming transfer learning reduces model layers

2. Which TensorFlow code snippet correctly freezes the base model layers for transfer learning?

easy

A. base_model.freeze_layers()

B. base_model.trainable = True

C. base_model.trainable = False

D. base_model.layers.freeze()

Solution

1. Step 1: Recall how to freeze layers in TensorFlow

   Setting trainable = False on the base model freezes all its layers.

2. Step 2: Check code options

   Only base_model.trainable = False is valid TensorFlow syntax to freeze layers.

3. Final Answer:

   base_model.trainable = False -> Option C

4. Quick Check:

   Freeze layers = trainable False [OK]

Hint: Set base_model.trainable = False to freeze layers [OK]

Common Mistakes:

• Using trainable = True instead of False
• Calling non-existent freeze_layers() method
• Trying to freeze layers with base_model.layers.freeze()

3. Given this code snippet, what will be the output shape of the model's predictions?

import tensorflow as tf
base_model = tf.keras.applications.MobileNetV2(input_shape=(128,128,3), include_top=False, pooling='avg')
base_model.trainable = False
model = tf.keras.Sequential([
  base_model,
  tf.keras.layers.Dense(10, activation='softmax')
])
model.build((None, 128, 128, 3))
predictions = model(tf.random.uniform((5, 128, 128, 3)))
print(predictions.shape)

medium

A. (5, 1)

B. (5, 128, 128, 3)

C. (5, 1000)

D. (5, 10)

Solution

1. Step 1: Analyze model architecture

   MobileNetV2 outputs pooled features (shape: (None, 1280)) due to pooling='avg'. Then Dense(10) outputs 10 classes.

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

   Input batch size is 5, so output shape is (5, 10) from Dense layer.

3. Final Answer:

   (5, 10) -> Option D

4. Quick Check:

   Batch 5, 10 classes output shape = (5, 10) [OK]

Hint: Output shape matches batch size and last Dense units [OK]

Common Mistakes:

• Confusing input shape with output shape
• Expecting output shape to match input image shape
• Assuming output has 1000 classes from original MobileNet

4. You wrote this code but get an error when training:

base_model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False)
base_model.trainable = False
model = tf.keras.Sequential([
  base_model,
  tf.keras.layers.Dense(5, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(train_data, epochs=3)

What is the likely cause of the error?

medium

A. Missing input shape in base_model causing shape mismatch

B. trainable should be True to train the model

C. Loss function is incorrect for classification

D. Dense layer should have no activation

Solution

1. Step 1: Check base_model input shape requirement

   ResNet50 requires input_shape when include_top=False to build properly.

2. Step 2: Identify error cause

   Without input_shape, model layers don't connect correctly, causing training errors.

3. Final Answer:

   Missing input shape in base_model causing shape mismatch -> Option A

4. Quick Check:

   Input shape needed for base_model [OK]

Hint: Always specify input_shape when include_top=False [OK]

Common Mistakes:

• Not specifying input_shape for pretrained base model
• Thinking trainable must be True to avoid errors
• Changing loss function unnecessarily

5. You have a small dataset of 200 images for a 3-class classification task. Which transfer learning approach is best to get good accuracy quickly?

hard

A. Use a pretrained model, freeze base layers, add new Dense layers, train only new layers

B. Train a new model from scratch with random weights

C. Use a pretrained model and train all layers without freezing

D. Use a pretrained model without adding new layers and train only base layers

Solution

1. Step 1: Consider dataset size and training time

   Small dataset (200 images) benefits from freezing pretrained base to avoid overfitting and long training.

2. Step 2: Choose transfer learning strategy

   Freezing base layers and training new Dense layers adapts model to new task efficiently.

3. Final Answer:

   Use a pretrained model, freeze base layers, add new Dense layers, train only new layers -> Option A

4. Quick Check:

   Freeze base + train new layers = best for small data [OK]

Hint: Freeze base layers, train new layers for small datasets [OK]

Common Mistakes:

• Training all layers on small data causing overfitting
• Training from scratch wasting time and data
• Not adding new layers for the specific task