Convolutional Neural Networks

This cover names the defining hazard of CNN work: the model will train to a mediocre accuracy and never tell you the real ceiling was far higher. Unlike a crash, quiet underperformance gives no error to chase, so the reader needs to recognize the traps by pattern. Framing these as expected dangers sets the right defensive mindset.

The common-mistakes angle works best as a failure manual — each slide is a specific, nameable error plus its fix. The cover lists the lineup so the reader knows they are getting six concrete traps, from a loud shape mismatch to silent overfitting, matching the depth standard the series holds to.

The flatten shape mismatch leads because it is the first wall almost every CNN beginner hits. The dense layer expects a specific input size, but the convolutional stack produced a different flattened volume — you wrote 32*7*7 and pooling actually left 32*8*8. PyTorch raises the unmistakable 'mat1 and mat2 shapes cannot be multiplied' error.

It is a loud failure, which is mercifully better than a silent one, but it stops progress until the arithmetic is fixed. This is the practical consequence of post 3's output-size formula and post 4's 32*7*7 walkthrough: the spatial size at the end of the conv stack must be computed correctly, and the fix slide shows how to make the code compute it for you.

This code slide gives the robust fix for the shape mismatch: stop doing the arithmetic by hand and let the network tell you. Pass one dummy image through the convolutional stack, flatten the result, and read off its size directly. Use that number to build the Linear layer.

The technique is valuable because it survives architecture changes. Add a conv layer, change a stride, or alter the input size, and the hand-computed 32*7*7 silently becomes wrong, but the dummy-forward approach recomputes the correct size automatically. Modeling this habit early saves the reader from the most common and most repeated CNN debugging session.

Forgetting to normalize inputs is a quietly devastating mistake. Raw pixel values in the 0-255 range produce large activations that destabilize gradients, so training either crawls or diverges. The model may still produce a number, but it is far below what the same architecture achieves on normalized data.

The fix is to scale inputs into a small, centered range, typically zero mean and unit variance per channel. The claim that this one transform can be the difference between 70% and 98% accuracy is not hyperbole; normalization is frequently the highest-leverage change a struggling CNN can make. This is why post 4 made normalization the very first step, and why it earns a dedicated mistake slide here.

This code slide shows normalization done properly, using dataset statistics rather than arbitrary values. ToTensor first scales pixels to 0-1, then Normalize subtracts a per-channel mean and divides by a per-channel standard deviation. The example uses the standard ImageNet RGB statistics, which are the right choice when fine-tuning a pretrained model.

Matching the normalization to the data, or to the pretrained model's expectations, is the subtle part. A model pretrained with ImageNet statistics expects inputs centered the same way, so using those exact numbers preserves the value of the pretrained features. Getting this detail right is part of what makes the transfer learning from post 2 actually work.

Building too small a network causes underfitting, a failure mode beginners often misdiagnose as a data problem. With only a handful of filters, the model lacks the capacity to represent the variety of patterns in real images, so both training and test accuracy stall at a low plateau — the telltale sign that the model, not the data, is the bottleneck.

The fix is more capacity, applied in the standard way: more filters per layer and more conv blocks, growing the channel count with depth such as 16 to 32 to 64. This mirrors the feature-hierarchy reasoning from post 1, where deeper layers need more channels to hold more complex parts. The actionable rule is to add capacity and confirm training accuracy can rise before blaming the dataset.

Data augmentation is one of the best defenses against overfitting, but it carries two traps that quietly corrupt results. The first is augmenting the test set: evaluation must happen on clean, unmodified data, or the accuracy number becomes meaningless. The second is applying transforms that change the label.

The label-preserving rule is the subtle one. Horizontally flipping a '6' turns it into something like a '9', and flipping text or road signs produces images whose correct label has changed, so the network learns wrong associations. Augmentation must match the task's invariances — flips are fine for natural objects, harmful for digits and oriented symbols. Choosing transforms thoughtfully is what makes augmentation help rather than hurt.

The compare diagram turns the train-time-versus-test-time distinction into a quick visual reference, because several mistakes in this post share that root cause. At training time you augment images, call model.train(), keep dropout active, and track gradients. At test time you do the opposite on every count.

Presenting it as two columns makes the rule memorable and consolidates three separate concerns — augmentation, mode switching, and gradient tracking — into one decision aid. The asymmetry is the point: the same model must be driven differently in the two phases, and forgetting to switch is exactly the eval-mode mistake the next slide details.

Forgetting model.eval() at test time is a silent accuracy thief. Layers like dropout and batch normalization behave differently during training and inference: dropout randomly zeros activations to regularize, and batch-norm uses the current batch's statistics. Both are correct for training and wrong for evaluation.

Skip the eval call and dropout keeps randomly disabling neurons while batch-norm uses noisy batch statistics instead of stable running averages, so the reported accuracy comes out lower and noisier than the model truly achieves. The model is fine; the measurement is broken. A single model.eval() call fixes it, which is why post 4 included it and this slide isolates why it matters.

This code slide captures the full evaluation ritual in three lines. model.eval() switches dropout off and tells batch-norm to use its running statistics; torch.no_grad() disables gradient tracking, which speeds up inference and saves memory since no backward pass is coming; and model.train() switches back before any further training.

The pairing of eval() and no_grad() is the standard, complementary habit: eval() fixes correctness by setting layer behavior, while no_grad() fixes efficiency by skipping the computation graph. Remembering to switch back to train mode afterward is the easy-to-miss third step that keeps a model from accidentally evaluating in inference mode during its next training phase.

Ignoring overfitting is the failure mode most likely to fool a beginner into thinking they succeeded. On a small dataset a CNN can simply memorize the training examples, driving training accuracy toward 100% while test accuracy stalls far lower. Watching only the training loss hides this entirely.

The fixes form a standard toolkit: data augmentation, dropout, weight decay, and early stopping all constrain memorization, while transfer learning from a pretrained model is usually the single most effective remedy on limited data — exactly the head-swapping pattern from post 2. The diagnostic habit that ties them together is watching the gap between training and validation curves, not the training number alone.

The recap consolidates all six fixes into a single screenshot-able checklist, turning the post into a pre-flight check before trusting any CNN's accuracy: compute the flatten size instead of guessing, normalize inputs every time, add capacity before blaming the data, augment only the training set with label-preserving transforms, use eval and no_grad at test time, and watch the train-versus-validation gap.

The list is intentionally portable across frameworks and tasks. The normalization and capacity items apply to any CNN, while the eval and augmentation habits prevent the most silent damage to your reported numbers. The flatten-size item ties the failure manual back to the shape arithmetic modeled in posts 3 and 4.

The CTA closes both the post and the day, pointing forward to recurrent neural networks as the natural sequel. The framing is deliberate: CNNs handle data with spatial structure on a grid, and the next topic handles data with sequential structure over time — text, audio, and any signal where order and memory matter.

This creates a clean narrative arc across the series. The reader finishes understanding not just what a CNN is, why it mattered, how convolution works, and how to build one, but also how easily it underperforms silently — and is ready to meet a different architecture built for a different kind of structure in Day 45.