34 Steps · Instant PDF Access · Convolutions, Worked Out
The Network Room

Images

A filter is not magic. It is nine numbers and a sliding window.

Thirty-four steps on how a network sees: one 3×3 filter over one patch of pixels, worked by hand; then stride, padding, channels and pooling, each introduced only when the previous one makes it necessary.

$10.00One-time
Teaching A Network To SeeInstant PDF · 34 worked entries
Yes, show me how it sees — Only $10.00

Secure checkout · Instant download · 60-day guarantee

See what's inside ↓

Thirty-four steps from one filter on one patch to a stack that recognises shapes.
Teaching A Network To SeeFrom the book
A 45-page PDF with grids you work on by handWhat you get
34 stepsWorked on printable grids
5 chaptersFilter to full stack
Instant accessEmailed the moment you buy
Any devicePhone, tablet, laptop or print

Thirty-four steps across five chapters — the filter, the parameters, the stack, the feature maps and what the model actually learned.

  • Every convolution worked on a grid small enough to check in the margin
  • The output-size formula applied to every layer of a real architecture
  • Receptive field and parameter count derived side by side
  • A chapter on what a model trained on images does and does not learn

Sound familiar?

You know it's a convolution. You can't say what it computes.

The diagrams all show the same coloured grid sliding over another grid, and none of them show the multiplication. So 'convolution' stays a word, and the parameters — stride, padding, dilation, channels — stay knobs you turn until the shapes agree.

Do it once with real numbers on a 5×5 patch and the whole family collapses into one idea with four settings. After that, reading a model definition is reading, not guessing.

Sample pages

A look inside

Every step works on a grid small enough to print — the input patch, the filter, the multiplication, and the output value in the right place.

Step 04 · The whole idea

One Filter, One Patch, By Hand

  • A 5×5 patch
  • A 3×3 filter
  • Nine multiplications
Time 25 minDo all nine, don't skim

Step 12 · The shape formula

Stride, Padding, Output Size

  • Input size
  • Kernel, stride, padding
  • One formula
Time 20 minPredict before you run

Step 23 · What it learned

Reading A Feature Map

  • A trained filter
  • One image
  • The activations
Time 30 minEdges first, parts later

34 steps in total

Models trained on images reproduce whatever the training set contained. The last chapter is explicit about what that means before you point one at photographs of people.

What's inside

Here's exactly what you'll be able to do

Why this works

It introduces one parameter at a time, and only when the previous example has made it necessary — so nothing is a knob you turn without knowing why.

Grids You Can Print

Every worked example fits on a page. You can do the multiplication in the margin and check it against the printed answer.

One Parameter At A Time

Stride appears when the output is too big. Padding appears when the edges vanish. Each is motivated before it is named.

Honest About Depth

Why stacked small filters beat one big one is derived, not asserted — with the receptive field and the parameter count both written out.

What you get

Everything in this book, listed

A 45-page PDF with grids you work on by handWhat you get
34 stepsWorked on printable grids
5 chaptersFilter to full stack
Instant accessEmailed the moment you buy
Any devicePhone, tablet, laptop or print

Thirty-four steps across five chapters — the filter, the parameters, the stack, the feature maps and what the model actually learned.

  • Every convolution worked on a grid small enough to check in the margin
  • The output-size formula applied to every layer of a real architecture
  • Receptive field and parameter count derived side by side
  • A chapter on what a model trained on images does and does not learn

The offer

See what the filter actually computes.

Teaching A Network To See works one 3×3 filter over one patch by hand, then builds up stride, padding, channels, pooling and depth — thirty-four steps, each on a grid you can check yourself.

Yes, show me how it sees — Only $10.00

Instant digital download. One-time payment of $10.00. Educational material about how neural networks work — not a course, not a certification, and not a promise about employment or salary.

The 60-day guaranteeRead it, run one of the worked examples, and if it does not make the inside of a network clearer than the tutorial you abandoned last week, email us within 60 days for a full refund. No questions, no hard feelings.

Questions

Before you buy

Do I need a GPU?

No. Every worked example is small enough to run on a laptop CPU, and most of them are small enough to do on paper. Training a large model is not what this book is for.

Is this about a specific architecture?

It uses small ones you can follow end to end, then shows you how to read published architectures yourself. Chasing whatever is current this month is not the point.

Does it cover transformers for vision?

Only in passing. Attention over patches is the subject of the sequence book; this one is about convolution, which is still what most image pipelines are built from.

Do I need the first book?

No, though it helps. This one re-derives the arithmetic it needs rather than assuming you remember it.

Will this teach me to build a product?

No. It explains how convolutional networks compute. Turning a model into something that runs for other people is a different book in this series.

Is this a physical book?

No — it's a digital guide (PDF), emailed to you right after purchase. Nothing is shipped.

What if it isn't for me?

You're protected by a 60-day money-back guarantee. Email us within 60 days for a full refund — no questions asked.

One filter, one patch, by hand

Thirty-four steps that turn convolution from a diagram you have seen into arithmetic you can do.

$10.00One-time
Teaching A Network To SeeInstant PDF · 34 worked entries
Yes, show me how it sees — Only $10.00

Secure checkout · Instant download · 60-day guarantee

This is educational material about how neural networks work. It is not a course, a certification, a bootcamp or a career programme, and it makes no promise about employment, salary or professional outcomes of any kind. The code and the worked figures are teaching examples, written for clarity rather than for production: read them, adapt them, and test anything you reuse. Library APIs change often, so the method is what carries over, not the exact call signature. Nothing here is professional, legal or financial advice. Models reproduce the patterns and the biases of the data they are trained on; deploying one that affects people carries responsibilities this book does not cover.