Recap and final exam

Ten modules to go from a Sobel kernel slid over a synthetic image to a fine-tuned ResNet50 read through Grad-CAM. Here is the course condensed, then the threads that run through it, then the exam that closes it.

The course at a glance

Module	What to retain
1. Convolution and filters	A convolution is a weighted sum on a sliding window; the kernel is shared across positions, which cuts parameters by two orders of magnitude versus a dense layer
2. Stride, padding, receptive field	Output size $\lfloor (n + 2p - k)/s \rfloor + 1$; same keeps size when $s=1$; receptive field grows with depth and stride
3. Pooling and downsampling	Max pooling keeps the strongest activation, GAP replaces the flatten + dense head; strided conv is a learned pooling
4. LeNet and AlexNet	The modern CNN skeleton is already in LeNet; AlexNet added ReLU, dropout, augmentation, GPU to reach ImageNet scale
5. VGG and small filters	Two stacked 3×3 = one 5×5 with fewer parameters and one extra non-linearity; parameters live in the head, activations live in the body
6. ResNet and residuals	Plain stacks degrade past a depth; the shortcut makes identity trivial and gradients flow; ResNet50 is the default backbone
7. Inception and MobileNet	Parallel branches (Inception) and depthwise separable convolutions (MobileNet) cut compute; FLOPs are not latency
8. Image augmentation	Flip, crop, jitter, Cutout, Mixup teach invariance; never augment away a label; augmentation as layers of the model runs on GPU
9. Transfer and fine-tuning	Two phases: frozen head, then staged unfreeze with a smaller rate; trainable=False does not freeze BatchNorm — pass training=False
10. Grad-CAM and saliency	Heatmap from the last conv weighted by class gradients; reveals Clever Hans models that look at the background; a heatmap is a hypothesis, not a proof

The threads running through the course

Every convolutional network is a stack of the same three moves: sliding weighted sum, non-linearity, spatial reduction. LeNet, VGG, ResNet, Inception, MobileNet, EfficientNet — the differences are in the ordering, the block shape, the shortcut policy and the way the reduction is done. Once you can predict a layer's output shape and parameter count by hand, every architecture in the field reads like a variation on a theme, and the paper's claimed contribution becomes easy to spot.

Training mode is not inference mode, and the framework will not warn you. Dropout is on in one, off in the other. Batch normalisation uses batch statistics, then running statistics. Augmentation runs at training, not at inference. Data augmentation as a set of model layers, training=False on a frozen backbone, model.eval() in PyTorch — these are three faces of the same discipline. Skipping any of them corrupts a model without raising an exception. It is the single most common bug in this course and it goes by a different name in every module.

Compute cost is where you do not look for it. Parameters live in the dense head — Flatten a 7 by 7 by 512 feature map into 4096 and you buy 100 M parameters. Activations live in the body — a batch 64 image at 224 by 224 through the first conv layer of VGG16 consumes 800 MB of feature maps. Latency depends on memory bandwidth and kernel launch overhead, not on FLOPs. Every optimisation in modules 5 through 7 (GAP head, bottleneck, depthwise separable, compound scaling) is a targeted answer to one of these three cost centres. Reducing the wrong one gives no speedup.

A metric is not an explanation. Validation accuracy at 91 % told us we had a good waste classifier. Grad-CAM told us that a third of its errors came from looking at the backdrop. The two statements do not contradict each other; they answer different questions. A production-ready computer vision system needs both: a headline accuracy that would make a manager sign off, and an interpretation stack that would make an engineer sleep. Modules 8, 9 and 10 built the second; do not deploy without it.

The final exam

The exam has 40 questions covering all ten modules: computing output sizes and parameter counts by hand, reasoning about the receptive field of a stack of convolutions, choosing between max pooling and strided convolution, reading the layer table of an architecture from LeNet to ResNet, comparing the compute cost of an Inception module and a MobileNet block, spotting a label-corrupting augmentation on a specific dataset, diagnosing the BatchNorm-in-training-mode trap on a frozen backbone, and reading a Grad-CAM heatmap that reveals a Clever Hans effect.

Several questions present situations to diagnose: a summary that does not match your mental parameter count, a network whose training error grows past a certain depth, a fine-tuned model whose validation accuracy collapses after unfreezing, a same padding that produces a shape you did not expect, a MobileNet that is slower than a ResNet on your target device, a Grad-CAM heatmap centred on the shadow of the object. Judgement is what gets assessed, not memorised API signatures.

On success, your certificate of completion is issued immediately; its number can be verified by any third party on the platform.

Before you start

Go back over the table above and, for each row, ask yourself: "what symptom would I see if I got this wrong?". If you can explain why a stack of 3 by 3 convolutions is better than a single 5 by 5, why a frozen backbone can still be silently retrained through its BatchNorm layers, and why a heatmap that highlights the object is reassuring but not proof, you are ready. Good luck.

Final exam

Ready to validate this course?

40 questions drawn at random from the course bank · passing score 70% · verifiable PDF certificate issued immediately on success.

Start the exam

You need to be signed in to your InSkillML account with an active subscription. You can also start the exam from My courses.