Convolutional networks for the product and technology leader
How a vision model sees, what resolution and depth cost, when to reuse a pre-trained or foundation model, and why vision features break in production.
A vision product is a chain of choices, each with a price, and the cheapest test is to measure on your own images before you commit.
Computer vision is the part of AI that reads images. It counts stock on shelves, checks parts on a production line, sorts uploaded photos and reads documents. Much of it runs on the convolutional neural network (CNN). The CS231n course notes credit AlexNet, entered in the 2012 ImageNet challenge, as the first work that popularized CNNs in computer vision. Vision transformers and large pre-trained "foundation" models now sit beside them.
Product and technology leaders make vision decisions often. What should the model output: a label, a box or a mask? What resolution do we need, and what does it cost? Do we label thousands of images, or start from someone else's model? CNN or transformer? Can we ship this pre-trained model under its licence? Why did accuracy drop when we changed cameras? These decisions do not need the mathematics. They need a clear picture of what a convolution does, what depth buys, how transfer works and where vision systems break.
This module gives that picture. Every lesson has two layers. The body is for the leader who decides. A short Under the hood section is for the engineer who builds. Lessons 2, 3 and 5 include code that runs on the Python standard library alone and ends in assert lines, so their numbers are checked.
A note on scope. This module does not teach tensors, shapes, matrix multiplication, broadcasting or automatic differentiation. The Tensors module does, and these lessons link to it. It does not teach attention either. Inside the model: attention in the LLMs track does, and the lesson on vision transformers adds only the image-specific part. Image generation is covered in The modalities.
Where the depth lives
Each lesson summarizes an idea and points to the lesson that covers it in full.
| If you want the full depth on | Read |
|---|---|
| How an image batch is stored: shape, channel order, bytes | What a tensor is |
| Why a convolution becomes a matrix multiplication, and how to count its cost | Matrix multiplication |
| Memory for training and the number formats a model can use | Batching, memory and precision |
| How the kernels' weights get their gradients, and what freezing a layer means | Automatic differentiation |
| How attention works, and why its cost grows with the square of the length | Inside the model: attention |
| Labels, splits and leakage for any model | Data: features, labels, splits and leakage |
| Precision, recall and thresholds for any classifier | Measuring a model |
| Training-serving skew, drift and monitoring for any model | ML in production |
| Lower-precision formats for serving | Quantization formats |
| Searching by vector similarity | Embeddings and semantic search |
The knowledge graph
From product question to production
Seven lessons in four steps. Each step links to the Tensors and LLMs lessons it builds on.
1 · What computer vision does
classify · detect · segment · embed
2 · How a convolution sees
kernel · stride · weight sharing
3 · From edges to objects
receptive field · depth · residuals
4 · Transfer learning and labels
freeze · fine-tune · linear probe
5 · CNNs vs. vision transformers
patches as tokens · backbone cost
6 · Vision foundation models
CLIP · DINO · SAM · licences
7 · Shipping vision in production
preprocessing contract · hardware · image shift
resolution, chosen in lesson 2, sets the cost you meet again in lesson 7
Read it as a path from question to production. You frame the product question as one of four vision jobs. You learn how a network sees: one small kernel, then many layers. You reuse someone else's model instead of training from scratch, and pick a backbone family and a foundation model. Then you ship it, where preprocessing, hardware and changing images decide whether it keeps working.
The lessons
- What computer vision does: the four jobs — classification, detection, segmentation and embeddings, and what each costs to label and measure.
- How a convolution sees: one small grid, used everywhere — kernels, stride, padding, weight sharing, and why resolution sets the cost.
- From edges to objects: what depth buys — receptive fields, what layers learn, residual connections, and which layer to reuse.
- Transfer learning and labels: start from someone else's model — frozen features, fine-tuning, linear probes and the labelling budget.
- CNNs vs. vision transformers: picking a backbone — patches as tokens, built-in assumptions, and a backbone table.
- Vision foundation models: CLIP, DINO and SAM — zero-shot classification, reusable pre-trained features, promptable segmentation, and licences.
- Shipping vision in production — the preprocessing contract, hardware sizing and image shift.
Then the recap and real-world examples, with a self-test.
Run the code
The examples for lessons 2, 3 and 5 are in cnns/code/. Run them all with one command.
python3 cnns/code/test_examples.py
The files are lesson2_convolution.py, lesson3_receptive_field.py and lesson5_patches.py. Each ends in assert lines that check the numbers quoted in its lesson. Run a file on its own to see the numbers printed.
Sources
- CS231n course notes, Convolutional Neural Networks (GitHub source, master branch): AlexNet as "the first work that popularized Convolutional Networks in Computer Vision", submitted to the ImageNet ILSVRC challenge in 2012. Read 2026-10.