Convolutional Neural Networks

This cover sets the frame for the whole topic: a convolutional neural network is a neural network purpose-built for data with spatial structure, and the contrast with a dense network is the fastest way in. A plain network sees a 200x200 image as 40,000 independent numbers; a CNN sees it as a picture with geometry that matters.

The post that follows is the 'map' angle. We are not yet arguing why CNNs mattered historically, nor tracing convolution through a concrete example. We are nailing down what a CNN IS and the vocabulary around it, so the why, how, and code posts have solid ground to build on.

The definition slide reframes a CNN as one simple action repeated: slide a small learnable filter across the data and record where it matches. Each filter is a pattern detector, and because the layers stack, the network learns simple patterns first and composes them into complex ones. That compositional structure is the entire reason CNNs work.

The phrase 'anywhere it appears' is doing the quiet work here. A CNN does not learn a separate detector for the top-left and bottom-right of an image; it learns one and applies it everywhere. That idea, parameter sharing, gets its own slide later, but introducing it inside the definition primes the reader for it.

This slide names the assumption that makes a CNN a CNN: nearby pixels are related, distant ones often are not. Rather than forcing a generic network to discover this fact from scratch through millions of examples, a CNN builds the assumption directly into its wiring. The architecture and the data structure are matched.

This matching is the deepest reason CNNs dominate vision. A model whose inductive bias fits the problem learns faster, generalizes better, and needs less data than one that must learn the structure as well as the task. Stating it plainly here sets up the why-it-matters argument in post 2.

The vocabulary slide front-loads the five terms that recur in every later slide and every CNN tutorial the reader will meet: filter, feature map, stride, padding, and pooling. Defining them together gives a glossary to anchor on before any mechanics arrive in post 3.

The term doing the most work is 'feature map' — the output of one filter across the whole image, which beginners often confuse with the filter itself. The filter is the small grid of weights; the feature map is the large grid of responses it produces. Distinguishing them now prevents the most common confusion in post 3's trace.

The flow diagram makes the standard CNN pipeline concrete by walking left to right: raw pixels enter, convolution detects patterns, pooling shrinks the maps, a flatten turns the 2D volume into a vector, and a dense layer produces the prediction. Seeing it as one left-to-right pipeline turns a CNN into a process the reader can trace.

The two halves matter. The conv-and-pool stages are the feature extractor that learns what to look for; the flatten-and-dense stages are the classifier that decides based on those features. This split recurs in post 4's code, where the conv layers and the Linear head are literally separate, and in transfer learning, where you keep the extractor and swap the head.

This slide gives the concrete argument for why fully-connected networks fail on images. Flattening a 200x200 RGB image yields 120,000 inputs; connecting them to even 1000 neurons needs 120 million weights for a single layer. The model is enormous, slow, and prone to overfitting before it learns anything useful.

The second failure is subtler but just as fatal: flattening destroys geometry. Adjacent pixels become unrelated inputs, so the network cannot use the spatial relationships that define what an image is. A CNN solves both problems at once by sharing small filters and preserving the 2D layout, which is exactly the comparison the later slide draws out.

This slide names the three ideas that, together, define a CNN. Local connectivity means each neuron looks at only a small patch, not the whole image. Parameter sharing means the same small filter is reused across every position. Translation invariance is the payoff: a pattern learned once is detected wherever it appears.

These three are not independent tricks; they reinforce each other. Local connectivity makes filters small, parameter sharing makes them reusable, and together they produce translation invariance. Holding all three in mind is the single most useful thing a beginner can take from this post, because every later detail is a consequence of them.

This code slide proves a CNN is not exotic by building one in five readable lines. Conv2d(3, 16, 3) creates 16 filters that each scan a 3-channel input; ReLU adds nonlinearity; MaxPool2d(2) halves the spatial size; Flatten reshapes to a vector; and Linear classifies into 10 classes. The whole architecture from the flow diagram, in code.

Showing it as runnable PyTorch grounds the abstraction. The arguments map directly to the vocabulary slide — kernel_size is the filter size, the pool halves the map — so a reader who learned the words sees them appear as code. The exact flatten size (16*15*15) previews the shape arithmetic that post 4 explains and post 5 flags as a classic bug.

The comparison slide puts the MLP and the CNN side by side so the architectural difference is unmistakable. The dense network connects every input to every neuron, burns millions of weights per layer, ignores 2D geometry, and must relearn a pattern separately for each location. The CNN does the opposite on all four counts.

This side-by-side is the synthesis of the post. Each row on the right is a direct consequence of the three defining ideas: small patches from local connectivity, one reused filter from parameter sharing, preserved layout and any-location detection from translation invariance. It is the slide most worth screenshotting as a one-glance summary of why a CNN is the right tool for images.

This slide introduces the feature hierarchy, the idea that gives depth its purpose in a CNN. Early layers, working on raw pixels, learn to detect edges and simple textures. Middle layers combine edges into parts — an eye, a wheel, a corner. Deep layers assemble parts into whole objects. Each layer's features are built from the previous layer's.

The crucial point is that the network discovers this hierarchy on its own. Nobody hand-codes what an edge filter should look like; training shapes the filters so the most useful patterns emerge. This is the concrete form of 'learned features' that post 2 celebrates as the breakthrough, and it is why simply stacking conv layers produces increasingly abstract representations.

This recap consolidates the five core ideas into a single screenshot-able reference: a CNN slides learnable filters over a grid, relies on local connectivity and parameter sharing, builds feature maps into a hierarchy, uses pooling to shrink and conv to detect, and is built for images rather than flat vectors. Each bullet maps to a slide.

The item doing extra duty is 'local connectivity + parameter sharing,' since those two ideas generate everything else in the post. A reader who remembers only that line can reconstruct why CNNs are efficient, why they preserve geometry, and why they generalize across locations.

The CTA closes the loop and points to post 2's argument. Framing the next post around why this one architecture set off the deep learning revolution gives the reader a concrete reason to continue rather than a generic prompt to follow.

It also sets the day's arc: post 1 was the what, post 2 is the why. Naming that progression helps the reader see the day as a structured lesson rather than disconnected tips, consistent with the standard of the whole series.