Every few years a technology stops being a research curiosity and becomes plumbing — invisible, load-bearing, assumed. The convolutional neural network crossed that line more than a decade ago, and yet most architects still meet it as a black box: something that “sees” a plan. This piece takes the box apart. Not to demystify for its own sake, but because the practitioners who will thrive are the ones who can name the filter, check its output geometry, and tell a genuine edge from a hallucinated one.

←TODAY: In 2025 a one-dimensional CNN read microwave-reflection spectra from a multimode cavity to estimate water level, beating MLP, SVR and random-forest baselines (MDPI Electronics 2025, 15(16), article 3734).
→3012: By the Zurich-3012 horizon, no drawing enters an archive without a provenance stamp naming which model read it and how sure it was.
Fulcrum: A convolution is arithmetic you can audit; that auditability is the only thing separating a measured feature from a confident guess.

What it is: A convolutional neural network is a stack of small, learnable filters that slide across an image, plus the machinery to train them. Strip away the biology and one convolution is a dot product you can check by hand. A filter — typically 3×3 or 5×5 — parks on a patch of pixels, multiplies its weights against that patch, sums the result, and writes a single number into a feature map. Slide, repeat, cover the image. That is the whole atomic operation. Everything grand about deep vision is this move, stacked.

Why it works: Two structural facts carry the entire design, and both are checkable. The first is weight sharing: the same filter is reused across the whole image, so a CNN needs orders of magnitude fewer parameters than a dense network on the same pixels — the reason it scales to real photographs instead of choking on them. The second is that the output geometry is exact. As PAZ’s own concept panel states it, O = (I − F + 2P) / S + 1, where I is input size, F filter size, P padding and S stride. A 32×32 input with a 3×3 filter, stride 1, no padding gives a 30×30 map — no mystery, just the same span-and-support logic you use sizing a beam grid. Between convolutions sits a pointwise non-linearity, almost always ReLU (negatives clipped to zero), then pooling — max or average over a small window — which downsamples the map, buys spatial invariance, and cuts the compute before the next layer.

Here is where the field earned its confidence. In 2015 Thomas Wiatowski and Helmut Bölcskei formalised the deep filter cascade as a semi-discrete frame and proved progressive translation invariance and stability under small deformations. The intuition — that stacking filters buys robustness — is not a hope pinned to a leaderboard; it is a theorem. For an engineer that distinction matters more than any accuracy figure. A benchmark tells you a network worked once; a stability theorem tells you why the class of networks holds.

Origins: The CNN did not start in a computer. It started in a cat. In 1962 David Hubel and Torsten Wiesel pushed microelectrodes into the visual cortex of an anaesthetised cat and found neurons that fired only when a bright bar crossed the retina at a particular angle — simple cells tuned to edges, complex cells that held their response as the edge moved. Vision was built in layers: orientation, then combination, then object. Kunihiko Fukushima read that finding and built the Neocognitron in 1980, a stack of artificial simple and complex layers — the direct structural ancestor, the load-bearing frame every later CNN inherits. Yann LeCun made it learn from data with backpropagation, and by 1998 his LeNet-5 was reading account numbers on cheques and ZIP codes on American mail: the first CNN that earned its keep in production. Then the idea sat quietly for a decade, respected and unused — too hungry for data and compute.

The dam broke in 2012. Alex Krizhevsky, Ilya Sutskever and Geoffrey Hinton trained a deep CNN on two consumer GPUs, added ReLU, dropout and data augmentation, and cut the ImageNet error rate almost in half overnight. That is the AlexNet moment, and the modern deep-learning era begins on that leaderboard. Two lineages followed and still shape practice: VGGNet (Simonyan & Zisserman, Oxford, 2014) proved depth from small stacked 3×3 filters beats a few large ones — a clean, repeatable grid engineers still reach for; and ResNet (He et al., Microsoft Research, 2015) added residual skip-connections that let gradients travel past 100-plus layers without vanishing — the moment connection that finally let the tower rise without buckling.

In practice: A Swiss studio does not run ImageNet. It points a convolution stack at a structural question. Damage identification from vibration images, shear-wall layout generation, crack detection on cast concrete, point-cloud segmentation on site scans — each is the same machine aimed at a drawing instead of a cat photo. The 2025 MDPI Electronics water-level study (article 3734) is the pattern in miniature: a one-dimensional CNN (CNN-1D) reading microwave-reflection spectra from a multimode cavity to supplement a conventional physical sensor, benchmarked against three baselines — a multilayer perceptron (MLP), a support-vector regressor (SVR) and a random forest (RF) — and chosen because the convolution found structure in the spectrum the flat models missed. When a student says “the model sees the plan,” the honest move is to open the first-layer filters and show them — it sees edges, then corners, then rooms, in that order, because that is what Hubel’s cat did to a doorframe and what you do glancing at a section.

Atelier: The office risk with any convnet reading your drawings is not that it fails loudly — it is that it answers confidently on a plan it never really parsed, and no one logged which model gave the answer or how sure it was. This week, before you trial any vision tool on floor plans or facade scans, set one policy: every model output that touches a deliverable gets stamped with the model name, the input hash, and a confidence value, stored beside the result. That single line of provenance is the difference between an audited feature and a future error with a head start.

Hack: Check the output geometry of every layer before you trust a single feature map — the same arithmetic that sizes a beam grid tells you exactly what shape each convolution emits, and a mismatch here is the most common silent bug in a fresh network. The lesson is pure math: implement the span-and-support formula and read it back.

def conv_out(I, F, P, S):
    return (I - F + 2*P) // S + 1

print(conv_out(32, 3, 0, 1))   # 30  -> 32x32, 3x3, stride 1, no pad
print(conv_out(224, 3, 1, 1))  # 224 -> VGG same-padding keeps the grid

Run it and the two lines tell the whole story: valid convolution shrinks the map by F−1; padding of 1 on a 3×3 holds it steady — which is precisely why VGGNet could stack sixteen layers without the image collapsing to nothing.

Move: The next building the CNN touches is your own. Learn the small network first — its filters, its formula, its stability proof — because the tall ones are only the same move stacked. Before you adopt any vision model into a workflow, run the geometry check above on its first three layers, confirm the shapes match the paper, and demand a provenance stamp on every output. Name the filter, check the arithmetic, and you will always be able to tell a real edge from a hallucinated one.