Bounding box handling in PyTorch - Model Metrics & Evaluation

Metrics & Evaluation - Bounding box handling

Which metric matters for Bounding box handling and WHY

When working with bounding boxes in tasks like object detection, the key metric is Intersection over Union (IoU). IoU measures how much the predicted box overlaps with the true box. It is important because it tells us how accurate the box placement is. A higher IoU means the predicted box closely matches the real object location.

Other metrics like Precision and Recall are also important to understand how many objects are correctly detected (Recall) and how many predicted boxes are correct (Precision).

Confusion matrix for bounding box detection

      +-----------------------+
      |       Confusion       |
      |-----------------------|
      | TP: Correct boxes     |
      | FP: Wrong boxes       |
      | FN: Missed objects    |
      +-----------------------+
    

Here, TP means predicted boxes with IoU above a threshold (e.g., 0.5) with ground truth. FP means predicted boxes with low IoU or no matching object. FN means objects with no predicted box.

Precision vs Recall tradeoff in bounding box handling

If you want to avoid false alarms (wrong boxes), focus on high precision. For example, in a security camera, you want to be sure detected objects are real.

If you want to catch all objects, even if some are wrong, focus on high recall. For example, in wildlife monitoring, missing an animal is worse than a few false detections.

Balancing precision and recall is key. IoU threshold affects this: a higher threshold means stricter matching, increasing precision but lowering recall.

Good vs Bad metric values for bounding box handling

• Good: IoU >= 0.5 for most boxes, Precision and Recall above 0.8 means boxes are accurate and most objects detected.
• Bad: IoU mostly below 0.3, Precision or Recall below 0.5 means boxes are poorly placed or many objects missed.

Common pitfalls in bounding box metrics

• Using accuracy alone is misleading because many images have few objects, so predicting no boxes can give high accuracy.
• Not setting a proper IoU threshold can confuse metric interpretation.
• Data leakage: testing on images seen during training inflates metrics.
• Overfitting: very high training IoU but low test IoU means model memorizes boxes, not generalizes.

Self-check question

Your model has 98% accuracy but only 12% recall on detecting objects with bounding boxes. Is it good for production? Why or why not?

Answer: No, it is not good. High accuracy can happen if most images have no objects and the model predicts no boxes. Low recall means it misses most objects, which is bad for detection tasks.

Key Result

IoU is the key metric for bounding box accuracy; balance precision and recall to ensure good detection quality.

Practice

1. What do the four numbers in a bounding box usually represent in PyTorch object detection tasks?

easy

A. Width, height, depth, and color

B. Center x, center y, width, height

C. Top-left corner x and y, width, height

D. Left, top, right, bottom coordinates of the box

Solution

1. Step 1: Understand bounding box format

   Bounding boxes in PyTorch detection models are often represented by four numbers indicating the edges: left (x_min), top (y_min), right (x_max), and bottom (y_max).

2. Step 2: Compare options with standard format

   Left, top, right, bottom coordinates of the box matches this format exactly, while others describe different formats or unrelated values.

3. Final Answer:

   Left, top, right, bottom coordinates of the box -> Option D

4. Quick Check:

   Bounding box = left, top, right, bottom [OK]

Hint: Remember bounding box edges are left, top, right, bottom [OK]

Common Mistakes:

• Confusing center coordinates with edges
• Mixing width and height with coordinates
• Assuming depth or color are part of bounding box

2. Which PyTorch tensor shape correctly represents a batch of 5 bounding boxes, each with 4 coordinates?

easy

A. torch.Size([5, 4])

B. torch.Size([4, 5])

C. torch.Size([5])

D. torch.Size([4])

Solution

1. Step 1: Identify bounding box tensor shape

   Each bounding box has 4 coordinates. For 5 boxes, the tensor shape should be (5, 4), meaning 5 rows (boxes) and 4 columns (coordinates).

2. Step 2: Match options with correct shape

   torch.Size([5, 4]) matches (5, 4). torch.Size([4, 5]) reverses dimensions, and C and D are one-dimensional, which is incorrect.

3. Final Answer:

   torch.Size([5, 4]) -> Option A

4. Quick Check:

   Batch size 5 and 4 coords = (5, 4) [OK]

Hint: Batch size first, coordinates second in tensor shape [OK]

Common Mistakes:

• Swapping batch and coordinate dimensions
• Using 1D tensor for multiple boxes
• Confusing number of boxes with number of coordinates

3. Given the following PyTorch code, what is the output?

import torch
boxes = torch.tensor([[1, 2, 4, 6], [0, 0, 3, 3]])
widths = boxes[:, 2] - boxes[:, 0]
heights = boxes[:, 3] - boxes[:, 1]
areas = widths * heights
print(areas.tolist())

medium

A. [10, 9]

B. [15, 9]

C. [12, 9]

D. [12, 6]

Solution

1. Step 1: Calculate widths and heights

   For box 1: width = 4 - 1 = 3, height = 6 - 2 = 4. For box 2: width = 3 - 0 = 3, height = 3 - 0 = 3.

2. Step 2: Calculate areas

   Area box 1 = 3 * 4 = 12, area box 2 = 3 * 3 = 9.

3. Final Answer:

   [12, 9] -> Option C

4. Quick Check:

   Area = width * height = [12, 9] [OK]

Hint: Area = (right-left) * (bottom-top) for each box [OK]

Common Mistakes:

• Subtracting coordinates in wrong order
• Mixing width with height values
• Forgetting to multiply widths and heights

4. Identify the error in this PyTorch code snippet for checking if points lie inside bounding boxes:

import torch
boxes = torch.tensor([1, 1, 5, 5])
points = torch.tensor([[3, 3], [6, 6]])
inside = (points[:, 0] >= boxes[:, 0]) & (points[:, 0] <= boxes[:, 2]) & (points[:, 1] >= boxes[:, 1]) & (points[:, 1] <= boxes[:, 3])
print(inside)

medium

A. The comparison between points and boxes tensors will fail due to shape mismatch

B. The logical AND operator '&' cannot be used with tensors

C. The code should use .all() to combine conditions

D. Points coordinates are reversed in the comparisons

Solution

1. Step 1: Check tensor shapes for broadcasting

   Boxes shape is (4,), points shape is (2,2). Comparing points[:, 0] (shape 2) with boxes[:, 0] causes shape mismatch as boxes is 1D.

2. Step 2: Understand broadcasting rules

   Direct element-wise comparison fails because points and boxes dimensions don't align for broadcasting in this code.

3. Final Answer:

   The comparison between points and boxes tensors will fail due to shape mismatch -> Option A

4. Quick Check:

   Shape mismatch causes error in element-wise comparison [OK]

Hint: Check tensor shapes before element-wise comparisons [OK]

Common Mistakes:

• Assuming PyTorch auto-broadcasts all shapes
• Using bitwise operators incorrectly
• Mixing coordinate order in comparisons

5. You want to convert bounding boxes from (left, top, right, bottom) format to (center_x, center_y, width, height) in PyTorch. Which code snippet correctly performs this conversion for a tensor boxes of shape (N, 4)?

hard

A. centers = boxes[:, :2] - boxes[:, 2:]
sizes = boxes[:, 2:] + boxes[:, :2]
converted = torch.cat([centers, sizes], dim=1)

B. centers = (boxes[:, :2] + boxes[:, 2:]) / 2
sizes = boxes[:, 2:] - boxes[:, :2]
converted = torch.cat([centers, sizes], dim=1)

C. centers = boxes[:, 2:] - boxes[:, :2]
sizes = (boxes[:, :2] + boxes[:, 2:]) / 2
converted = torch.cat([sizes, centers], dim=1)

D. centers = boxes[:, :2] * boxes[:, 2:]
sizes = boxes[:, 2:] / boxes[:, :2]
converted = torch.cat([centers, sizes], dim=1)

Solution

1. Step 1: Calculate center coordinates

   Center x and y are the average of left and right, top and bottom: (left + right)/2, (top + bottom)/2, which is (boxes[:, :2] + boxes[:, 2:]) / 2.

2. Step 2: Calculate width and height

   Width and height are right - left and bottom - top: boxes[:, 2:] - boxes[:, :2].

3. Step 3: Concatenate centers and sizes

   Combine centers and sizes along dimension 1 to get (center_x, center_y, width, height).

4. Final Answer:

   centers = (boxes[:, :2] + boxes[:, 2:]) / 2 sizes = boxes[:, 2:] - boxes[:, :2] converted = torch.cat([centers, sizes], dim=1) -> Option B

5. Quick Check:

   Center = avg edges, size = difference edges [OK]

Hint: Center = average edges; size = difference edges [OK]

Common Mistakes:

• Swapping center and size calculations
• Using addition instead of subtraction for sizes
• Concatenating in wrong order