Lesson 31 • Advanced

Computer Vision Pipelines

Build production-ready computer vision systems — from image preprocessing to model evaluation with confusion matrices, precision, recall, and F1 scores.

✅ What You'll Learn

• End-to-end CV pipeline: preprocess → extract → classify
• Image normalization and data augmentation strategies
• Confusion matrices and per-class metrics
• Choosing the right evaluation metric for your task

📷 Building Vision Systems

🎯 Real-World Analogy: A CV pipeline is like a photo processing factory. Raw photos arrive at the loading dock (data ingestion). They go through quality control and standardisation (preprocessing). A team of experts examines them through magnifying glasses (feature extraction with CNNs). Finally, a classifier sorts them into labelled bins (prediction). Each stage must work reliably for the whole factory to produce accurate results.

Production CV systems are more than just a model. They include data pipelines, augmentation strategies, model selection, evaluation frameworks, and monitoring. Getting these right matters more than squeezing an extra 0.1% accuracy from the model itself.

🔑 Popular CNN Backbones

• ResNet-50 — Reliable default, widely supported
• EfficientNet-B0 — Best accuracy/efficiency ratio
• ViT (Vision Transformer) — State-of-the-art with enough data
• ConvNeXt — Modern CNN competing with ViTs

Try It: CV Pipeline

Build a complete image classification pipeline from preprocessing to prediction

Try it Yourself »

Python

import numpy as np

# End-to-End Computer Vision Pipeline
# From raw image to prediction in a structured workflow

np.random.seed(42)

class ImagePreprocessor:
    """Step 1: Normalize, resize, augment"""
    def __init__(self, target_size=(224, 224)):
        self.target_size = target_size
    
    def normalize(self, image):
        """Scale pixel values to [0, 1] and standardize"""
        normalized = image / 255.0
        # ImageNet mean/std normalization
        mean = np.array([0.485, 0.4
...

Try It: Model Evaluation

Compute confusion matrices, precision, recall, and F1 per class

Try it Yourself »

Python

import numpy as np

# CV Model Evaluation: Beyond Accuracy
# Confusion matrices, precision, recall, and mAP

np.random.seed(42)

def confusion_matrix(y_true, y_pred, n_classes):
    cm = np.zeros((n_classes, n_classes), dtype=int)
    for t, p in zip(y_true, y_pred):
        cm[t, p] += 1
    return cm

def classification_metrics(cm, class_names):
    """Calculate per-class precision, recall, F1"""
    results = []
    for i, name in enumerate(class_names):
        tp = cm[i, i]
        fp = cm[
...

⚠️ Common Mistake: Using accuracy alone on imbalanced datasets. If 95% of images are "not cancer", a model that always predicts "not cancer" gets 95% accuracy but is useless. Always check per-class recall for critical applications, and use F1 or mAP for a balanced view.

💡 Pro Tip: For production CV, use torchvision.transforms for preprocessing and timm (PyTorch Image Models) for pretrained backbones. Start with EfficientNet-B0 + ImageNet weights — it gives excellent results with minimal compute. Add test-time augmentation (TTA) for a free 1-2% accuracy boost.

📋 Quick Reference

Pipeline Stage	Tools	Key Decisions
Data Loading	DataLoader, tf.data	Batch size, workers
Preprocessing	torchvision, albumentations	Resize, normalize, augment
Backbone	timm, torchvision	ResNet, ViT, EfficientNet
Head	nn.Linear, nn.Sequential	Dropout, num classes
Evaluation	sklearn.metrics	F1, mAP, confusion matrix
Deployment	ONNX, TensorRT	Latency vs accuracy

🎉 Lesson Complete!

You can now build and evaluate end-to-end computer vision systems! Continue to the next lesson to learn about object detection with YOLO.