Python CV ecosystem (OpenCV, PIL, torchvision) in Computer Vision - Model Metrics & Evaluation

Metrics & Evaluation - Python CV ecosystem (OpenCV, PIL, torchvision)

Which metric matters for Python CV ecosystem and WHY

In computer vision tasks using Python libraries like OpenCV, PIL, and torchvision, the choice of metric depends on the task:

• Image classification: Accuracy, Precision, Recall, and F1-score matter to understand how well the model labels images.
• Object detection: Mean Average Precision (mAP) is key to measure how well objects are found and localized.
• Image segmentation: Intersection over Union (IoU) or Dice coefficient show how well the predicted mask matches the true mask.

These metrics help us know if the model or image processing pipeline is working well for the specific vision task.

Confusion matrix example for image classification

      | Predicted Cat | Predicted Dog |
      |---------------|---------------|
      | True Cat: 50  | False Dog: 5  |
      | False Cat: 3  | True Dog: 42  |

      Total samples = 50 + 5 + 3 + 42 = 100

      Precision (Cat) = TP / (TP + FP) = 50 / (50 + 3) = 0.943
      Recall (Cat) = TP / (TP + FN) = 50 / (50 + 5) = 0.909
    

This confusion matrix helps us calculate metrics to evaluate classification quality.

Precision vs Recall tradeoff with examples

In computer vision:

• High Precision: Means fewer false positives. For example, in face recognition, high precision avoids wrongly tagging strangers as known people.
• High Recall: Means fewer false negatives. For example, in medical image analysis, high recall ensures most disease cases are detected.

Choosing which to prioritize depends on the task's risk. Sometimes we want to catch all positives (high recall), sometimes avoid false alarms (high precision).

What good vs bad metric values look like for Python CV tasks

• Good: Accuracy > 90%, Precision and Recall both above 85%, IoU > 0.7 for segmentation, mAP > 0.75 for detection.
• Bad: Accuracy below 60%, Precision or Recall below 50%, IoU below 0.4, mAP below 0.3.

Good metrics mean the model or processing pipeline reliably understands images. Bad metrics mean it struggles and needs improvement.

Common pitfalls in metrics for Python CV ecosystem

• Accuracy paradox: High accuracy can be misleading if classes are imbalanced (e.g., many background images).
• Data leakage: Using test images in training inflates metrics falsely.
• Overfitting indicators: Very high training accuracy but low test accuracy means model memorizes training images, not generalizing.
• Ignoring task-specific metrics: Using only accuracy for detection or segmentation misses important quality aspects.

Self-check question

Your image classification model has 98% accuracy but only 12% recall on the rare class (e.g., cancerous images). Is it good for production? Why or why not?

Answer: No, it is not good. The low recall means the model misses most rare positive cases, which is critical in medical diagnosis. High accuracy is misleading because the rare class is small, so the model mostly predicts the common class correctly but fails to detect important positives.

Key Result

In Python computer vision tasks, choose metrics like accuracy, precision, recall, IoU, or mAP based on the task to correctly evaluate model performance.

Practice

1. Which Python library is best known for fast image and video processing tasks?

easy

A. PIL (Pillow)

B. OpenCV

C. torchvision

D. matplotlib

Solution

1. Step 1: Understand library purposes

   OpenCV is designed for fast image and video processing, widely used in computer vision.

2. Step 2: Compare with other libraries

   PIL is mainly for image editing, torchvision is for ML image datasets, matplotlib is for plotting.

3. Final Answer:

   OpenCV -> Option B

4. Quick Check:

   Fast image/video processing = OpenCV [OK]

Hint: OpenCV = fast image/video tasks, PIL = editing, torchvision = ML prep [OK]

Common Mistakes:

• Confusing PIL as the fastest for video processing
• Thinking torchvision handles video processing
• Assuming matplotlib is for image processing

2. Which of the following is the correct way to read an image using OpenCV in Python?

easy

A. img = cv2.imread('image.jpg')

B. img = Image.open('image.jpg')

C. img = torchvision.io.read_image('image.jpg')

D. img = plt.imread('image.jpg')

Solution

1. Step 1: Identify OpenCV image reading syntax

   OpenCV uses cv2.imread() to load images from files.

2. Step 2: Differentiate from other libraries

   PIL uses Image.open(), torchvision uses torchvision.io.read_image(), matplotlib uses plt.imread().

3. Final Answer:

   img = cv2.imread('image.jpg') -> Option A

4. Quick Check:

   OpenCV image read = cv2.imread() [OK]

Hint: OpenCV reads images with cv2.imread() [OK]

Common Mistakes:

• Using Image.open() which is from PIL, not OpenCV
• Using plt.imread() which is for plotting, not OpenCV
• Confusing torchvision's read_image with OpenCV

3. What will be the shape and color format of the image loaded by this OpenCV code?

import cv2
img = cv2.imread('image.jpg')
print(img.shape)

medium

A. (height, width, 3) with RGB color order

B. (width, height, 3) with BGR color order

C. (width, height, 3) with RGB color order

D. (height, width, 3) with BGR color order

Solution

1. Step 1: Understand OpenCV image shape

   OpenCV loads images as NumPy arrays with shape (height, width, channels).

2. Step 2: Know OpenCV color format

   OpenCV uses BGR color order by default, not RGB.

3. Final Answer:

   (height, width, 3) with BGR color order -> Option D

4. Quick Check:

   OpenCV shape = (H, W, 3), color = BGR [OK]

Hint: OpenCV images: shape (H,W,3), color BGR [OK]

Common Mistakes:

• Assuming RGB color order instead of BGR
• Swapping width and height in shape
• Thinking OpenCV loads grayscale by default

4. This code tries to convert a PIL image to a NumPy array for OpenCV processing but causes an error:

from PIL import Image
import numpy as np
img_pil = Image.open('image.jpg')
img_cv = np.array(img_pil)

What is the likely cause and fix?

medium

A. PIL image must be converted to grayscale first

B. Color channels are in wrong order; convert RGB to BGR after np.array()

C. Use img_pil.convert('RGB') before np.array() to ensure 3 channels

D. No error; code works fine as is

Solution

1. Step 1: Identify PIL image mode issue

   PIL images may not be in RGB mode by default; could be 'P' or 'L' mode causing np.array to have unexpected shape.

2. Step 2: Fix by converting to RGB mode

   Use img_pil.convert('RGB') to ensure 3 color channels before converting to NumPy array.

3. Final Answer:

   Use img_pil.convert('RGB') before np.array() to ensure 3 channels -> Option C

4. Quick Check:

   PIL to NumPy needs RGB mode [OK]

Hint: Convert PIL image to RGB before np.array() [OK]

Common Mistakes:

• Assuming np.array always works without convert()
• Ignoring color channel order differences
• Trying to convert to grayscale unnecessarily

5. You want to prepare an image for a PyTorch model using torchvision transforms. Which sequence correctly converts a PIL image to a tensor normalized for pretrained models?

hard

A. Use torchvision.transforms.ToTensor() then torchvision.transforms.Normalize(mean, std)

B. Use cv2.imread() then convert to tensor manually

C. Use PIL.Image.open() then convert to NumPy array and normalize manually

D. Use torchvision.transforms.Normalize() only on PIL image

Solution

1. Step 1: Understand torchvision transform pipeline

   To prepare images for PyTorch models, convert PIL image to tensor with ToTensor(), which scales pixels to [0,1].

2. Step 2: Normalize tensor with mean and std

   Use Normalize() with pretrained model's mean and std to standardize input.

3. Final Answer:

   Use torchvision.transforms.ToTensor() then torchvision.transforms.Normalize(mean, std) -> Option A

4. Quick Check:

   ToTensor + Normalize = correct PyTorch prep [OK]

Hint: Use ToTensor() then Normalize() for PyTorch image prep [OK]

Common Mistakes:

• Trying to normalize PIL images directly
• Using OpenCV images without conversion
• Skipping normalization step