Real-time processing patterns in Computer Vision - ML Experiment: Train & Evaluate

Experiment - Real-time processing patterns

Problem:You want to build a computer vision model that detects objects in video frames in real-time. Currently, the model processes frames too slowly, causing lag and missed detections.

Current Metrics:Processing speed: 5 frames per second (fps), Accuracy: 85%

Issue:The model is accurate but too slow for real-time use. Real-time requires at least 15 fps to appear smooth.

Your Task

Increase the processing speed to at least 15 fps while keeping accuracy above 80%.

You cannot reduce the dataset size.

You must keep the model architecture similar (no complete redesign).

You can adjust model parameters and processing pipeline.

Hint 1

Hint 2

Hint 3

Hint 4

Solution

Computer Vision

import cv2
import time
import numpy as np
from tensorflow.keras.applications.mobilenet_v2 import MobileNetV2, preprocess_input, decode_predictions
from tensorflow.keras.preprocessing.image import img_to_array

# Load a lightweight pre-trained model
model = MobileNetV2(weights='imagenet')

# Open video capture (0 for webcam)
cap = cv2.VideoCapture(0)

# Reduce frame size for faster processing
frame_width, frame_height = 224, 224

frame_count = 0
start_time = time.time()

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # Resize frame to model input size
    small_frame = cv2.resize(frame, (frame_width, frame_height))

    # Prepare image for model
    image = cv2.cvtColor(small_frame, cv2.COLOR_BGR2RGB)
    image = img_to_array(image)
    image = np.expand_dims(image, axis=0)
    image = preprocess_input(image)

    # Predict
    preds = model.predict(image, verbose=0)
    decoded = decode_predictions(preds, top=1)[0][0]
    label = f"{decoded[1]}: {decoded[2]*100:.1f}%"

    # Show label on original frame
    cv2.putText(frame, label, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,255,0), 2)

    cv2.imshow('Real-time Object Detection', frame)

    frame_count += 1
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

end_time = time.time()

fps = frame_count / (end_time - start_time)
print(f"Average FPS: {fps:.2f}")

cap.release()
cv2.destroyAllWindows()

Reduced input frame size to 224x224 pixels to speed up processing.

Used MobileNetV2, a lightweight model optimized for speed.

Removed unnecessary preprocessing steps to streamline pipeline.

Results Interpretation

Before: 5 fps, 85% accuracy

After: 18 fps, 82% accuracy

Reducing input size and using a lightweight model can greatly improve real-time processing speed with only a small drop in accuracy. This trade-off is common in real-time computer vision.

Bonus Experiment

Try applying model quantization to further speed up inference without losing accuracy.

💡 Hint

Use TensorFlow Lite to convert the model to a quantized version and measure FPS and accuracy again.

Practice

1. What is the main goal of real-time processing patterns in computer vision?

easy

A. To process data quickly frame-by-frame for instant reaction

B. To store large amounts of video data for later analysis

C. To improve image quality by adding complex filters

D. To train deep learning models offline with big datasets

Solution

1. Step 1: Understand real-time processing purpose

   Real-time processing means handling data immediately as it arrives, without delay.

2. Step 2: Match goal with options

   To process data quickly frame-by-frame for instant reaction matches this by focusing on quick frame-by-frame processing for instant reaction.

3. Final Answer:

   To process data quickly frame-by-frame for instant reaction -> Option A

4. Quick Check:

   Real-time = instant frame processing [OK]

Hint: Real-time means instant frame-by-frame handling [OK]

Common Mistakes:

• Confusing real-time with offline batch processing
• Thinking real-time means better image quality only
• Assuming real-time requires heavy model training

2. Which code snippet correctly represents a simple real-time frame processing loop in Python?

easy

A. def process_frames():
frame = camera.read()
process(frame)

B. for frame in camera:
process(frame)
break

C. while True:
frame = camera.read()
process(frame)

D. if camera.has_frame():
frame = camera.get_frame()
process(frame)

Solution

1. Step 1: Identify continuous frame reading

   Real-time processing requires a loop that continuously reads frames, which is done by 'while True'.

2. Step 2: Check frame reading and processing

   while True: frame = camera.read() process(frame) reads a frame each loop and processes it, matching real-time pattern.

3. Final Answer:

   while True:\n frame = camera.read()\n process(frame) -> Option C

4. Quick Check:

   Continuous loop with frame read = while True: frame = camera.read() process(frame) [OK]

Hint: Real-time loops use while True to read frames continuously [OK]

Common Mistakes:

• Using for loop with break stops continuous processing
• Not looping continuously to read frames
• Defining function without loop does not process frames real-time

3. Given this code snippet for real-time video processing, what will be printed?

import time
frames_processed = 0
start = time.time()
while frames_processed < 3:
    # Simulate frame capture and processing
    time.sleep(0.1)
    frames_processed += 1
end = time.time()
print(round(end - start, 1))

medium

A. 0.1

B. 0.3

C. 3.0

D. 1.0

Solution

1. Step 1: Understand loop timing

   The loop runs 3 times, each time sleeping for 0.1 seconds simulating processing delay.

2. Step 2: Calculate total time

   Total sleep time = 3 * 0.1 = 0.3 seconds, plus minimal overhead, rounded to 0.3.

3. Final Answer:

   0.3 -> Option B

4. Quick Check:

   3 frames * 0.1s sleep = 0.3s [OK]

Hint: Multiply loop count by sleep time for total delay [OK]

Common Mistakes:

• Confusing sleep time with total time
• Ignoring loop count in calculation
• Assuming print shows frames_processed instead of time

4. Identify the error in this real-time frame processing code and select the fix:

while True:
    frame = camera.read()
    if frame is None:
        break
    process(frame)
    time.sleep(0.5)

medium

A. Remove time.sleep to avoid slowing real-time processing

B. Add frame = camera.get_frame() before processing

C. Change break to continue to skip None frames

D. Add a counter to stop after 10 frames

Solution

1. Step 1: Analyze time.sleep impact

   time.sleep(0.5) pauses half a second each frame, slowing real-time processing.

2. Step 2: Choose fix to maintain speed

   Removing time.sleep allows faster frame processing, essential for real-time.

3. Final Answer:

   Remove time.sleep to avoid slowing real-time processing -> Option A

4. Quick Check:

   Sleep delays break real-time speed [OK]

Hint: Avoid sleep delays in real-time loops for speed [OK]

Common Mistakes:

• Adding unnecessary frame calls
• Using break instead of continue incorrectly
• Adding counters changes loop logic, not error

5. You want to build a real-time object detection system for a self-driving car. Which approach best balances speed and accuracy?

hard

A. Use a very deep model with many layers for highest accuracy, ignoring speed

B. Store all frames and process them later in batch mode

C. Process every 10th frame to reduce load but risk missing objects

D. Use a lightweight neural network model optimized for fast inference on each frame

Solution

1. Step 1: Understand real-time needs in self-driving

   System must react instantly, so speed is critical, but accuracy cannot be ignored.

2. Step 2: Evaluate options for speed and accuracy

   Use a lightweight neural network model optimized for fast inference on each frame uses a lightweight model optimized for fast inference, balancing both needs well.

3. Final Answer:

   Use a lightweight neural network model optimized for fast inference on each frame -> Option D

4. Quick Check:

   Lightweight fast model = best real-time balance [OK]

Hint: Choose fast, lightweight models for real-time tasks [OK]

Common Mistakes:

• Choosing very deep models that are too slow
• Skipping frames loses important info
• Batch processing is not real-time