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.

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

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.

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.

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.

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.

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.

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 .

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.

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.

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

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

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.

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.

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

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary