Object detection concepts in TensorFlow - Model Metrics & Evaluation

Metrics & Evaluation - Object detection concepts

Which metric matters for Object Detection and WHY

In object detection, we want to find and correctly label objects in images. The key metrics are Precision, Recall, and Mean Average Precision (mAP).

Precision tells us how many detected objects are actually correct. This helps avoid false alarms.

Recall tells us how many real objects we found. This helps avoid missing objects.

mAP combines precision and recall over different confidence levels and object classes. It gives a single score to compare models.

We use these metrics because object detection is about both finding objects and labeling them correctly. Balancing precision and recall is important depending on the task.

Confusion Matrix for Object Detection

For each object class, we count:

      True Positives (TP): Correctly detected objects.
      False Positives (FP): Wrong detections (wrong class or no object).
      False Negatives (FN): Missed objects.
      True Negatives (TN): Usually not counted in object detection because background is large.
    

Example for one class (e.g., "cat"):

      +----------------+----------------+
      |                | Predicted Cat  |
      |                +--------+-------+
      |                | Yes    | No    |
      +----------------+--------+-------+
      | Actual Cat     | TP=40  | FN=10 |
      +----------------+--------+-------+
      | Not Cat        | FP=5   | TN=945 |
      +----------------+--------+-------+
    

Total samples = TP + FP + FN + TN = 1000

Precision vs Recall Tradeoff with Examples

If we want to avoid false alarms (wrong detections), we focus on high precision. For example, in a security camera detecting intruders, we want to be sure when it says "intruder" it is correct.

If we want to avoid missing objects, we focus on high recall. For example, in self-driving cars detecting pedestrians, missing a person is dangerous.

Increasing precision usually lowers recall and vice versa. We adjust detection confidence thresholds to find the best balance.

What Good vs Bad Metric Values Look Like

Good object detection model:

• Precision and recall both above 0.8 (80%)
• mAP above 0.75 (75%) across classes
• Confusion matrix shows low FP and FN

Bad object detection model:

• Precision below 0.5 (many false alarms)
• Recall below 0.5 (many missed objects)
• mAP below 0.4 (poor overall detection)
• Confusion matrix shows many FP or FN

Common Pitfalls in Object Detection Metrics

• Ignoring class imbalance: Some classes may have few examples, skewing mAP.
• Overfitting: High training mAP but low test mAP means model memorizes training data.
• Data leakage: Test images appearing in training can give falsely high metrics.
• Using accuracy alone: Accuracy is not useful because background dominates and TN is huge.
• Wrong IoU threshold: Intersection over Union (IoU) threshold affects TP/FP counts. Too low or high changes metrics drastically.

Self-Check Question

Your object detection model has 98% accuracy but only 12% recall on detecting pedestrians. Is it good for safety?

Answer: No. The high accuracy is misleading because most of the image is background (true negatives). The low recall means the model misses 88% of pedestrians, which is dangerous for safety. You need to improve recall even if accuracy drops.

Key Result

Mean Average Precision (mAP) balances precision and recall to measure object detection quality effectively.

Practice

1. What is the main goal of object detection in TensorFlow?

easy

A. To find and label objects in images with bounding boxes

B. To generate captions for images

C. To classify images into categories without localization

D. To enhance image resolution

Solution

1. Step 1: Understand object detection task

   Object detection locates objects in images and labels them with boxes.

2. Step 2: Compare options with definition

   Only To find and label objects in images with bounding boxes describes finding and labeling objects with boxes, matching object detection.

3. Final Answer:

   To find and label objects in images with bounding boxes -> Option A

4. Quick Check:

   Object detection = find and label objects [OK]

Hint: Object detection = find + label objects with boxes [OK]

Common Mistakes:

• Confusing object detection with image classification
• Thinking object detection generates captions
• Mixing up image enhancement with detection

2. Which part of an object detection model is responsible for extracting features from images?

easy

A. Head

B. Backbone

C. Loss function

D. Anchor generator

Solution

1. Step 1: Identify model components

   Backbone extracts features; head predicts boxes and classes.

2. Step 2: Match roles to options

   Backbone matches feature extraction role, so Backbone is correct.

3. Final Answer:

   Backbone -> Option B

4. Quick Check:

   Feature extractor = Backbone [OK]

Hint: Backbone extracts features, head predicts boxes [OK]

Common Mistakes:

• Confusing head with feature extractor
• Thinking loss function extracts features
• Mixing anchor generator with backbone

3. Given this TensorFlow code snippet for object detection model summary, what is the output shape of the backbone's last layer?

import tensorflow as tf
base_model = tf.keras.applications.MobileNetV2(input_shape=(224,224,3), include_top=False)
print(base_model.output_shape)

medium

A. (None, 7, 7, 1280)

B. (None, 14, 14, 512)

C. (None, 224, 224, 3)

D. (None, 1, 1, 1000)

Solution

1. Step 1: Understand MobileNetV2 output shape

   MobileNetV2 with include_top=False outputs feature maps of shape (None, 7, 7, 1280) for 224x224 input.

2. Step 2: Match output shape to options

   (None, 7, 7, 1280) matches expected output shape; others do not.

3. Final Answer:

   (None, 7, 7, 1280) -> Option A

4. Quick Check:

   MobileNetV2 backbone output = (None,7,7,1280) [OK]

Hint: MobileNetV2 backbone outputs 7x7x1280 feature maps [OK]

Common Mistakes:

• Confusing input shape with output shape
• Choosing output with wrong spatial dimensions
• Assuming include_top=True output shape

4. Identify the error in this TensorFlow object detection training code snippet:

model.compile(optimizer='adam', loss='categorical_crossentropy')
model.fit(train_images, train_boxes, epochs=5)

medium

A. fit method missing batch_size argument

B. Missing optimizer parameter in compile

C. Using 'categorical_crossentropy' loss instead of a detection loss

D. train_boxes should be train_labels

Solution

1. Step 1: Check loss function suitability

   Object detection needs specialized loss (e.g., localization + classification), not plain categorical_crossentropy.

2. Step 2: Validate other code parts

   Optimizer is given, train_boxes is correct for boxes, batch_size is optional.

3. Final Answer:

   Using 'categorical_crossentropy' loss instead of a detection loss -> Option C

4. Quick Check:

   Detection needs special loss, not categorical_crossentropy [OK]

Hint: Detection needs combined loss, not plain classification loss [OK]

Common Mistakes:

• Using classification loss for detection
• Confusing train_boxes with labels
• Assuming batch_size is mandatory

5. You want to improve an object detection model's accuracy on small objects. Which approach is best to try first?

hard

A. Remove the backbone and use only the head

B. Reduce number of training epochs

C. Use grayscale images instead of color

D. Increase input image resolution and adjust anchor box sizes

Solution

1. Step 1: Understand small object detection challenges

   Small objects need higher resolution and anchors matching their size for better detection.

2. Step 2: Evaluate options for improving small object accuracy

   Increasing resolution and adjusting anchors directly helps; reducing epochs or removing backbone harms performance; grayscale reduces info.

3. Final Answer:

   Increase input image resolution and adjust anchor box sizes -> Option D

4. Quick Check:

   Small objects = higher res + proper anchors [OK]

Hint: Small objects need bigger input and matching anchors [OK]

Common Mistakes:

• Reducing epochs thinking it helps accuracy
• Removing backbone reduces feature quality
• Using grayscale loses color info needed for detection