Computer Vision Pipelines

Follow an image all the way from raw photo to live prediction — collecting and labelling data, augmenting and preprocessing it, transfer-learning a pretrained backbone, running the train/validate loop, evaluating honestly, and deploying for inference.

Learn Computer Vision Pipelines in our free AI & Machine Learning course — a beginner-friendly interactive lesson with worked examples, a practice exercise…

Part of the free AI & Machine Learning course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

🏭 Real-World Analogy: An Assembly Line

A CV pipeline is an assembly line that turns raw photos into predictions. Picture a factory floor with stations in a row:

• Loading dock — photos arrive and get labelled (data collection & labeling).
• Copy station — make varied copies by flipping, cropping and re-colouring (augmentation, training only).
• Standardisation — every photo is resized and its pixels rescaled to the same range (preprocessing).
• Expert inspector — a pretrained backbone that already knows edges and textures examines each photo (transfer learning).
• Sorter — a small classifier head drops each photo into a labelled bin (prediction).
• Quality control — a held-back sample is scored honestly (evaluation), then the line ships (deployment).

If one station is mis-calibrated — say standardisation differs between the factory and the field — every later station produces junk. The whole point of a pipeline is that each stage is reliable and consistent from training through to deployment.

1 Collect, Label, and Split Your Data

Everything starts with labelled data — images paired with the correct answer (the label ). Before any training, you split that data into a train set the model learns from and a validation set you hold back to check progress honestly. A common split is 80/20.

The split below is the simplest possible version — slice a list. Run it and watch which samples land where.

2 Augmentation — Free Variety for Training

Augmentation creates safe, label-preserving copies of training images so the model sees more variety: horizontal flips , random crops , and colour jitter (brightness/contrast). A flipped cat is still a cat, so the label stays the same while the pixels change.

Here's the simplest augmentation — a horizontal flip — written in plain Python so you can see exactly what changes.

3 Preprocessing — Resize and Normalize

Preprocessing makes every image look the same to the model. Two steps dominate: resize (so all images share one width and height the model expects) and normalize (rescale pixels from 0..255 down to a small range like 0..1). Normalizing keeps training stable.

Run the example below to normalize a tiny "image" by hand — every pixel divided by 255.0.

In real projects you don't do this by hand — torchvision.transforms composes resize, crop, tensor-conversion and normalization into one reusable pipeline. The same recipe must run at training, validation, and inference time.

4 Transfer Learning with a Pretrained Backbone

Training a vision model from scratch needs millions of images. Transfer learning avoids that: you take a backbone (like ResNet-50) that already learned generic features — edges, textures, shapes — from ImageNet, and you only replace its final layer (the head ) so it outputs your classes.

Below, Albumentations builds the augmentation pipelines (note: train augments, val does not) and a pretrained ResNet-50 has its head swapped for 5 classes.

5 The Train / Validate Loop

Training runs in epochs — one full pass over the training data. Each epoch you let the model learn from the train set (compute loss, back-propagate, update weights), then validate on the held-back set without learning from it. Watching train loss fall while val accuracy rises tells you it's working; if val accuracy stalls or drops while train keeps improving, the model is overfitting .

6 Evaluate — Beyond Plain Accuracy

Accuracy alone lies on imbalanced data. If 95% of images are "not cancer", a model that always says "not cancer" scores 95% yet catches nothing. So you also look at precision (of the things I flagged, how many were right?), recall (of the things I should have caught, how many did I?), and F1 (their balance). A confusion matrix shows exactly which classes get mixed up.

Metric

Use when…

Accuracy

Classes are balanced

Precision

False positives are costly (spam filter)

Recall

False negatives are costly (medical)

F1

You want one balanced number

mAP

Object detection (IoU-based)

7 Deployment and Inference

Deployment means running the trained model on one new image at a time. The golden rule: apply the exact same preprocessing you used for validation — never the training augmentation — switch to model.eval() , and run a single forward pass. A softmax turns the raw scores into probabilities so you can report a confidence.

🎯 Your Turn 1: Normalize the Pixels

Fill in the blank so every pixel is scaled to the 0..1 range. Use the expected output to check yourself.

🎯 Your Turn 2: Split 75 / 25

Fill in the two slice indices so the first 25% becomes validation and the rest becomes training.

Common Errors (And How to Fix Them)

You normalize with one mean/std (or resize differently) at training but another at inference. The model sees inputs it was never trained on, so accuracy quietly collapses in production.

✅ Fix: define preprocessing once and reuse the identical transform everywhere — train, validate, and deploy.

Flips and crops on your val set make every run report a different, unrealistic score. You can no longer trust the number.

✅ Fix: keep a separate val transform with only Resize + Normalize — no random ops.

Near-duplicate frames of the same scene land in both train and val, or you compute normalization statistics over the whole dataset before splitting. Offline scores look amazing; real-world performance is poor.

✅ Fix: split first, then compute stats only on the train set; group related images so they never straddle the split.

Feeding raw 0..255 pixels makes loss spike to NaN or stall, because the gradients blow up.

✅ Fix: always scale pixels to a small range (0..1, then ImageNet mean/std) before the model.

📋 Quick Reference

Pipeline Stage

Tools

Key Decisions

Collect & label

Label Studio, CVAT

Class balance, label quality

Split

sklearn, slicing

Train/val ratio, no leakage

Augment (train only)

albumentations, torchvision

Flip, crop, colour jitter

Preprocess

torchvision.transforms

Resize, normalize (same everywhere)

Backbone

timm, torchvision.models

ResNet, ViT, EfficientNet

Train/validate

torch, optimizer, loss_fn

Epochs, watch overfitting

Evaluate

sklearn.metrics

F1, mAP, confusion matrix

Deploy

ONNX, TensorRT

Val transform, eval mode, latency

❓ Frequently Asked Questions

🎯 Mini Challenge: Flip an Image

Now with the support faded — only a comment outline is given. Write the augmentation yourself: mirror each row of a nested-list image left to right.

🎉 Lesson Complete!

You can now walk an image down the whole assembly line: collect and split data, augment the training set, preprocess by resizing and normalizing, transfer-learn a pretrained backbone, run the train/validate loop, evaluate beyond plain accuracy, and deploy for inference — all while keeping preprocessing consistent and avoiding leakage.

🚀 Up next: Object Detection — go from "what is in this image?" to "what is where?", drawing labelled boxes around every object.

Practice quiz

Continue this course

• Previous: Policy Gradient Methods
• Next: Object Detection

Related lessons

• Computer Vision Basics