Annotation quality in Computer Vision - ML Experiment: Train & Evaluate

Experiment - Annotation quality

Problem:You are training an object detection model on images with bounding box annotations. The model's validation accuracy is low because some annotations are incorrect or inconsistent.

Current Metrics:Training mAP: 85%, Validation mAP: 60%

Issue:The model overfits to noisy or wrong annotations, causing poor validation performance.

Your Task

Improve validation mAP to at least 75% by improving annotation quality without changing the model architecture.

Do not change the model architecture or hyperparameters.

Only modify the dataset annotations or data preprocessing.

Hint 1

Hint 2

Hint 3

Hint 4

Solution

Computer Vision

import cv2
import json
import numpy as np

# Load annotations
with open('annotations.json', 'r') as f:
    annotations = json.load(f)

# Function to check and fix bounding boxes
# Ensures boxes are within image bounds and have positive area

def fix_bboxes(annots, img_width, img_height):
    fixed_annots = []
    for obj in annots:
        x_min, y_min, x_max, y_max = obj['bbox']
        # Clamp coordinates
        x_min = max(0, min(x_min, img_width - 1))
        y_min = max(0, min(y_min, img_height - 1))
        x_max = max(0, min(x_max, img_width - 1))
        y_max = max(0, min(y_max, img_height - 1))
        # Fix inverted boxes
        if x_max <= x_min or y_max <= y_min:
            continue  # skip invalid box
        fixed_annots.append({'label': obj['label'], 'bbox': [x_min, y_min, x_max, y_max]})
    return fixed_annots

# Process dataset
fixed_dataset = {}
for img_name, annots in annotations.items():
    img = cv2.imread(f'images/{img_name}')
    if img is None:
        continue
    h, w = img.shape[:2]
    fixed_annots = fix_bboxes(annots, w, h)
    if fixed_annots:
        fixed_dataset[img_name] = fixed_annots

# Save fixed annotations
with open('fixed_annotations.json', 'w') as f:
    json.dump(fixed_dataset, f)

# After fixing annotations, retrain the model with the same code but using fixed_annotations.json
# (Model training code not shown here for brevity)

# Expected improved metrics after retraining:
# Training mAP: 82%
# Validation mAP: 77%

Reviewed and fixed bounding box coordinates to ensure they are within image boundaries.

Removed invalid or zero-area bounding boxes.

Filtered out images with no valid annotations after cleaning.

Used cleaned annotations for retraining the model.

Results Interpretation

Before: Training mAP: 85%, Validation mAP: 60%
After: Training mAP: 82%, Validation mAP: 77%

Cleaning and improving annotation quality reduces overfitting to noisy labels and improves validation performance, demonstrating the importance of good data quality in machine learning.

Bonus Experiment

Try using data augmentation techniques like random cropping and flipping to further improve validation accuracy.

💡 Hint

Augmentation can help the model generalize better by showing varied examples, reducing overfitting.

Practice

1. What does annotation quality in computer vision mainly refer to?

easy

A. How accurate and clear the labels on images are

B. The speed of the model training process

C. The size of the image dataset

D. The type of camera used to capture images

Solution

1. Step 1: Understand the meaning of annotation quality

   Annotation quality means how correct and clear the labels on images are, which helps models learn well.

2. Step 2: Compare options to definition

   Only How accurate and clear the labels on images are matches this meaning. Other options relate to training speed, dataset size, or camera type, which are unrelated.

3. Final Answer:

   How accurate and clear the labels on images are -> Option A

4. Quick Check:

   Annotation quality = accuracy and clarity of labels [OK]

Hint: Annotation quality means label correctness and clarity [OK]

Common Mistakes:

• Confusing annotation quality with dataset size
• Thinking annotation quality is about camera or hardware
• Mixing annotation quality with model training speed

2. Which of the following is the correct way to describe a high-quality annotation in a dataset?

easy

A. Labels are randomly assigned to images

B. Labels are written in a different language than the model expects

C. Labels are missing for most images

D. Labels match the true content of images clearly and correctly

Solution

1. Step 1: Define high-quality annotation

   High-quality annotation means labels clearly and correctly match the true content of images.

2. Step 2: Evaluate each option

   Labels match the true content of images clearly and correctly fits this definition. Options A, B, and C describe poor or incorrect labeling practices.

3. Final Answer:

   Labels match the true content of images clearly and correctly -> Option D

4. Quick Check:

   High-quality annotation = correct and clear labels [OK]

Hint: Good labels match image content clearly and correctly [OK]

Common Mistakes:

• Choosing random or missing labels as correct
• Ignoring label language compatibility
• Assuming any label is good regardless of accuracy

3. Given this Python code snippet checking annotation quality, what will be the output?

annotations = ['cat', 'dog', 'dog', 'cat']
true_labels = ['cat', 'dog', 'cat', 'cat']
correct = sum(a == t for a, t in zip(annotations, true_labels))
accuracy = correct / len(true_labels)
print(round(accuracy, 2))

medium

A. 1.00

B. 0.50

C. 0.75

D. 0.25

Solution

1. Step 1: Compare each annotation with true label

   Positions: 0(cat=cat) correct, 1(dog=dog) correct, 2(dog=cat) wrong, 3(cat=cat) correct. So 3 correct out of 4.

2. Step 2: Calculate accuracy

   Accuracy = 3 correct / 4 total = 0.75. Rounded to 2 decimals is 0.75.

3. Final Answer:

   0.75 -> Option C

4. Quick Check:

   Accuracy = 3/4 = 0.75 [OK]

Hint: Count matches, divide by total, round result [OK]

Common Mistakes:

• Counting all annotations as correct
• Dividing by wrong total length
• Not rounding the output

4. This code is meant to calculate annotation accuracy but has a bug. What is the error?

annotations = ['car', 'bike', 'car']
true_labels = ['car', 'car', 'car']
correct = 0
for i in range(len(annotations)):
    if annotations[i] = true_labels[i]:
        correct += 1
accuracy = correct / len(true_labels)
print(accuracy)

medium

A. Using '=' instead of '==' in the if condition

B. Dividing by length of annotations instead of true_labels

C. Not initializing correct to zero

D. Using print without parentheses

Solution

1. Step 1: Identify syntax error in if condition

   The if statement uses '=' which is assignment, not comparison. It should be '==' to compare values.

2. Step 2: Check other parts

   Correct is initialized, division is by correct length, and print uses parentheses correctly. So only '=' is wrong.

3. Final Answer:

   Using '=' instead of '==' in the if condition -> Option A

4. Quick Check:

   Comparison needs '==' not '=' [OK]

Hint: Use '==' for comparison, '=' is assignment [OK]

Common Mistakes:

• Confusing '=' with '==' in conditions
• Thinking division length is wrong
• Ignoring syntax errors in if statements

5. You have a dataset with images labeled for object detection. Some labels are missing bounding boxes, and some boxes are misplaced. How should you improve annotation quality before training a model?

hard

A. Ignore errors and train the model directly

B. Manually review and correct missing or wrong bounding boxes

C. Remove all images with any label issues without replacement

D. Add random bounding boxes to all images

Solution

1. Step 1: Understand impact of missing or wrong labels

   Missing or misplaced bounding boxes reduce annotation quality and hurt model learning.

2. Step 2: Choose best action to fix quality

   Manually reviewing and correcting labels improves quality. Ignoring or removing data blindly or adding random boxes harms quality.

3. Final Answer:

   Manually review and correct missing or wrong bounding boxes -> Option B

4. Quick Check:

   Fix labels manually to improve quality [OK]

Hint: Fix missing/wrong labels manually before training [OK]

Common Mistakes:

• Ignoring label errors thinking model will learn anyway
• Removing too much data without fixing
• Adding random labels that confuse the model