Bird
Raised Fist0

Implement IoU and Non-Max Suppression for Object Detection

CODINGintermediateInterview freq: high
Choose your preparation mode6 modes available
LearnTraceDebugTrade-offChallenge
🎯
Implement IoU and Non-Max Suppression for Object Detection
30 min · mid
mid

You are tasked with implementing the Intersection over Union (IoU) and Non-Max Suppression (NMS) algorithms for an object detection system. The system processes video frames in real-time, requiring efficient computation to maintain a latency of under 50ms per frame. The input consists of bounding boxes with confidence scores, and the output should be the filtered set of bounding boxes after applying NMS.

Given Info
  • Bounding boxes are represented as (x1, y1, x2, y2) coordinates.
  • Confidence scores are provided for each bounding box.
  • The system must handle up to 1000 bounding boxes per frame.
  • The IoU threshold for NMS is set at 0.5.
  • The implementation must be done using NumPy.
📋
Guided Steps
1/4
Step 1
Calculate Intersection over Union (IoU)
How will you calculate the IoU for two bounding boxes?
💡 Hint
Consider how the areas of intersection and union are computed from the coordinates.
Key Decision
Use vectorized NumPy operations to compute IoU for efficiency.
Interviewer Expectation
Mid: Implements IoU using basic NumPy operations. Senior: Optimizes with vectorization and handles edge cases like non-overlapping boxes.
⚠️Common Wrong Answer
Calculating IoU using nested loops, leading to inefficient O(n^2) complexity.
Step 2
Implement Non-Max Suppression (NMS)
How will you implement NMS to filter out overlapping bounding boxes?
💡 Hint
Think about how to prioritize boxes based on confidence scores.
Key Decision
Sort boxes by confidence and iteratively apply IoU thresholding.
Interviewer Expectation
Mid: Implements basic NMS with sorting and thresholding. Senior: Uses efficient data structures to minimize redundant IoU calculations.
⚠️Common Wrong Answer
Not sorting boxes by confidence, leading to suboptimal suppression.
Step 3
Optimize for Real-Time Processing
What optimizations can you apply to ensure the implementation meets the latency requirement?
💡 Hint
Consider the computational complexity and memory usage of your approach.
Key Decision
Optimize with NumPy vectorization to reduce computational overhead.
Interviewer Expectation
Mid: Identifies basic optimizations like avoiding loops. Senior: Quantifies performance gains and considers memory trade-offs.
⚠️Common Wrong Answer
Ignoring the impact of computational complexity on real-time performance.
Step 4
Handle Edge Cases
How will you ensure your implementation handles edge cases effectively?
💡 Hint
Think about scenarios with no overlap or identical boxes.
Key Decision
Implement checks for edge cases like zero-area boxes.
Interviewer Expectation
Mid: Handles common edge cases. Senior: Anticipates less obvious scenarios and tests extensively.
⚠️Common Wrong Answer
Failing to handle cases where boxes have zero area or are completely outside the frame.
📊
Scoring Rubric
▼ Show
Must Have - 60%
  • Correctly implements IoU calculation using NumPy.
  • Implements NMS with sorting and thresholding.
  • Ensures the solution meets the 50ms latency requirement.
  • Handles edge cases like non-overlapping and zero-area boxes.
Good to Have - 30%
  • Uses vectorized operations to optimize performance.
  • Minimizes redundant IoU calculations in NMS.
  • Provides clear comments and code structure.
  • Includes test cases for various edge scenarios.
Bonus - 10%
  • Quantifies performance improvements with optimizations.
  • Considers memory usage and trade-offs in the implementation.
  • Implements additional features like adjustable IoU thresholds.
✅
Model Answer
▼ Reveal

The ideal solution efficiently implements IoU and NMS using NumPy, ensuring real-time performance by leveraging vectorized operations. It handles edge cases and meets the latency requirement of 50ms per frame.

Key Decisions
  • Calculate IoU using vectorized NumPy operations for efficiency.
  • Sort bounding boxes by confidence scores before applying NMS.
  • Use a threshold to filter out overlapping boxes based on IoU.
  • Optimize the implementation to meet real-time processing constraints.
Anti-patterns
Implementing IoU with nested loops, leading to inefficiency.
Failing to sort boxes by confidence, resulting in suboptimal suppression.
Ignoring edge cases, causing incorrect filtering of boxes.
Not optimizing for real-time performance, exceeding latency limits.

Practice

(1/5)
1. What does the following Python code snippet output when implementing linear regression using gradient descent?
import numpy as np

X = np.array([[1, 2], [3, 4], [5, 6]])
y = np.array([1, 2, 3])
weights = np.zeros(X.shape[1])
learning_rate = 0.01

for _ in range(1):
    predictions = X.dot(weights)
    errors = predictions - y
    gradient = X.T.dot(errors) / len(y)
    weights -= learning_rate * gradient

print(weights)
easy
A. [0.01, 0.02]
B. [0.1, 0.2]
C. [0.03, 0.04]
D. [0.05, 0.06]

Solution

  1. Step 1: Calculate initial predictions and errors

    Initial predictions are [0, 0, 0] since weights are zeros. Errors are [-1, -2, -3].

  2. Step 2: Compute gradient and update weights

    Gradient is [-3, -6]. Updated weights are [0.01, 0.02].

  3. Final Answer:

    Option A -> Option A

  4. Quick Check:

    Initial weights zero, single update step. [OK]
Hint: Initial weights zero, single update step. [OK]
Common Mistakes:
2. In a multi-class classification problem, how should you modify the confusion matrix implementation to handle more than two classes?
medium
A. Use a 2x2 matrix and sum over classes.
B. Use a 3D matrix to capture all interactions.
C. Use separate matrices for each class.
D. Use a matrix of size (n_classes, n_classes).

Solution

  1. Step 1: Understand multi-class needs

    Each class needs its own row and column in the matrix.

  2. Step 2: Choose correct matrix size

    A (n_classes, n_classes) matrix captures all class interactions.

  3. Final Answer:

    Option D -> Option D

  4. Quick Check:

    Multi-class needs (n_classes, n_classes) matrix. [OK]
Hint: Multi-class needs (n_classes, n_classes) matrix. [OK]
Common Mistakes:
3. 
import numpy as np

def ndcg_at_k(r, k):
    dcg_max = dcg_at_k(sorted(r, reverse=True), k)
    if not dcg_max:
        return 0.
    return dcg_at_k(r, k) / dcg_max

relevance_scores = [3, 2, 3, 0, 1, 2]
k = 3
print(ndcg_at_k(relevance_scores, k))
The output is unexpectedly low. What is the most likely cause?
medium
A. The k value is too low.
B. The DCG is calculated incorrectly.
C. The relevance scores are not normalized.
D. The ideal DCG is not calculated correctly.

Solution

  1. Step 1: Check Ideal DCG Calculation

    The ideal DCG should be calculated using the sorted relevance scores.

  2. Step 2: Identify the Error

    If the ideal DCG is not calculated correctly, the NDCG will be incorrect.

  3. Final Answer:

    Option D -> Option D

  4. Quick Check:

    Check ideal DCG calculation. [OK]
Hint: Check ideal DCG calculation. [OK]
Common Mistakes:
4. In a PCA implementation, you need to project data onto the first two principal components. Which approach is correct?
medium
A. Multiply the data matrix by the first two eigenvectors.
B. Multiply the data matrix by the first two eigenvalues.
C. Multiply the covariance matrix by the first two eigenvectors.
D. Multiply the covariance matrix by the first two eigenvalues.

Solution

  1. Step 1: Understand projection in PCA

    Projection involves multiplying the data matrix by the eigenvectors corresponding to the desired components.

  2. Step 2: Eliminate wrong options

    Multiply the data matrix by the first two eigenvalues. is incorrect because eigenvalues are not used for projection. Multiply the covariance matrix by the first two eigenvectors. and D incorrectly use the covariance matrix instead of the data matrix.

  3. Final Answer:

    Option A -> Option A

  4. Quick Check:

    Project data using eigenvectors, not eigenvalues. [OK]
Hint: Project data using eigenvectors, not eigenvalues. [OK]
Common Mistakes:
5. In a dataset with highly imbalanced classes, how should you implement train-test split with stratification to ensure robust model evaluation?
medium
A. Ensure stratification is based on the minority class
B. Use a very small test size to capture rare classes
C. Use random splitting to avoid bias
D. Increase the test size to balance classes

Solution

  1. Step 1: Understand stratification in imbalanced datasets

    Stratification should focus on maintaining the distribution of the minority class.

  2. Step 2: Apply correct strategy

    Ensuring stratification based on the minority class helps in capturing its distribution in both sets.

  3. Final Answer:

    Option A -> Option A

  4. Quick Check:

    Stratify on minority class for balance. [OK]
Hint: Stratify on minority class for balance. [OK]
Common Mistakes:
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard