Visualizing the process of "flattening" a 2D image grid into a 1D sequence of numbers to feed into Dense Layers.
Neural Network Input
LIVE PROCESSING
Step 1: 2D Matrix16 x 16 x 3
Flattening Row by Row
Step 2: 1D Input Vector768 nodes
Scroll horizontally to view all nodes
Overview
The idea in brief
When you look at an pic, you see a 2D grid of colors. However, standard Artificial Neural Networks (namely Dense or Fully-Connected Layers) are structured to accept just a one-dimensional (1D) array or vector of counts as input. Before a network can "look" at an pic, the pic must undergo Flattening.
Flattening takes a 2D array (or a 3D array for colour pics with height, width and channels) and rearranges it into a single row of counts. A 28×28 grayscale pic turns a vector of 784 vals. A 32×32 RGB pic turns a vector of 32 × 32 × 3 = 3,072 vals. No information is lost — the pixel vals are the same, just reordered into a line — but the spatial structure is destroyed. The network can no longer tell whether two pixels were neighbours in the first pic or on opposite corners.
This loss of spatial information is why convolutional neural networks (CNNs) were developed. A CNN processes the pic as a 2D grid, with filters that slide across the pic and detect local patterns like edges, corners and textures. Each convolutional layer gives a set of feature maps that preserve spatial layout. Just at the very end, after multiple convolutional and pooling layers have compressed the pic into a small, deep stack of feature maps, is the result flattened and fed into a dense layer for classification.
For a simple fully-connected network (no convolutions), flattening is the very first step: the raw pixel vector goes right into the network. This works on small pics like MNIST digits (28×28) but scales poorly: a 224×224 RGB pic would give an input vector of 150,528 vals. And a single dense layer with 1,024 neurons would need over 150 million weights. That param explosion is the real reason CNNs replaced fully-connected networks for pic tasks.
Visualizing the process of "flattening" a 2D image grid into a 1D sequence of numbers to feed into Dense Layers.
Why and how we transform 2D grids of pixels into 1D lists for Neural Networks.
The idea in brief
When you look at an pic, you see a 2D grid of colors. However, standard Artificial Neural Networks (namely Dense or Fully-Connected Layers) are structured to accept just a one-dimensional (1D) array or vector of counts as input. Before a network can "look" at an pic, the pic must undergo Flattening.
Flattening takes a 2D array (or a 3D array for colour pics with height, width and channels) and rearranges it into a single row of counts. A 28×28 grayscale pic turns a vector of 784 vals. A 32×32 RGB pic turns a vector of 32 × 32 × 3 = 3,072 vals. No information is lost — the pixel vals are the same, just reordered into a line — but the spatial structure is destroyed. The network can no longer tell whether two pixels were neighbours in the first pic or on opposite corners.
This loss of spatial information is why convolutional neural networks (CNNs) were developed. A CNN processes the pic as a 2D grid, with filters that slide across the pic and detect local patterns like edges, corners and textures. Each convolutional layer gives a set of feature maps that preserve spatial layout. Just at the very end, after multiple convolutional and pooling layers have compressed the pic into a small, deep stack of feature maps, is the result flattened and fed into a dense layer for classification.
For a simple fully-connected network (no convolutions), flattening is the very first step: the raw pixel vector goes right into the network. This works on small pics like MNIST digits (28×28) but scales poorly: a 224×224 RGB pic would give an input vector of 150,528 vals. And a single dense layer with 1,024 neurons would need over 150 million weights. That param explosion is the real reason CNNs replaced fully-connected networks for pic tasks.
The Core Idea: Unrolling the Grid
Think of a digital pic as a spreadsheet where each cell is a pixel holding a color value. "Flattening" is simply taking the first row of this spreadsheet, placing it down, taking the second row and appending it to the end of the first. And continuing until the whole grid forms a single, long line of counts.
If the pic is colored, it holds three channels: Red, Green. And Blue (RGB). The network needs split input nodes for each color value of each pixel. The math for the total count of inputs is simple: Width × Height × Channels = Total Nodes.
An pic is a grid of counts
Before anything else, a picture has to turn arithmetic. A greyscale pic is a grid of brightness vals from 0 (black) to 255 (white). A colour pic is three such grids stacked — red, green and blue.
A 224×224 colour photograph is therefore a block of counts with shape (224, 224, 3). Or 150,528 vals. That is what the network really gets. There is no pic in there, just a tensor.
Almost each pipeline rescales those vals to 0–1 by dividing by 255. Or standardises them per channel with the dataset's mean and standard deviation. The reason is the same as for tabular data: gradients and initialisation schemes assume inputs of roughly unit scale. And raw 0–255 vals make the first layer's activations far too large.
Why a dense layer is the wrong tool
Feed that pic to an ordinary fully connected layer with 1,000 units and you need 150,528 × 1,000 = 150 million weights in the first layer alone. Three problems follow at once.
It is unaffordable. That many params need enormous data and memory. And most of them will be fitting noise.
It throws away the structure. Flattening the grid into a list destroys the fact that neighbouring pixels are tied. To a dense layer, pixel (0,0) and pixel (0,1) are no more tied than pixel (0,0) and pixel (200,150).
It has to relearn all all over. A dense layer that learns to detect an edge in the top-left corner has learned nothing about edges in the bottom-right. Each position needs its own weights.
Convolution fixes all three at once by making two assumptions about pics that happen to be true.
Local connections and shared weights
Locality. A small filter — often 3×3 — looks at a tiny patch rather than the whole pic. Meaningful visual structure is local: an edge, a corner or a texture is set by a handful of neighbouring pixels.
Weight sharing. That same filter slides across the whole pic. One set of nine weights is applied all over. So a vertical-edge detector learned in one place works in each place.
The arithmetic is startling. A 3×3 filter over 3 input channels is 27 weights plus a bias. Use 64 such filters and the layer has 1,792 params — against 150 million for the dense equivalent. And it works better.
This also gives the network translation equivariance: move the cat two pixels right and the feature map moves two pixels right. The network does not have to see cats in each position to recognise them.
The hierarchy that emerges
Stacking convolution layers builds features of raising abstraction. And this is not a metaphor — it is visible when you inspect trained filters.
Depth
What the filters respond to
Layer 1
Edges at various orientations, colour blobs
Layer 2
Corners, curves, simple textures
Layers 3–4
Repeated patterns, parts — eyes, wheels, letters
Deep layers
Object parts and whole objects
Each layer sees a wider region of the first pic than the last, since each of its inputs now summarised a patch. That growing window is the receptive field. And it is why depth matters: a network needs enough layers for its deepest neurons to see the whole object.
A complete classifier is then: a few convolution and pooling blocks to build features, followed by pooling or flattening. And finally one or two dense layers to turn those features into class scores.
Guided Experiments with This Interactive
Observe the Math:
Look at the right column. For a 16x16 RGB pic, you'll see the 2D matrix labeled 16 x 16 x 3. This means there are 768 individual color vals. Scroll the 1D Input Vector horizontally to see all 768 "nodes" laid out end-to-end!
Toggle Grayscale:
Check the Turn to Grayscale box. Notice how the node count drops by just a factor of 3 (e.g., from 768 to 256). Grayscale pics just have 1 channel (brightness) instead of 3 (RGB), making them much easier for simple neural networks to process.
Adjust the Resolution:
Slide the Resolution to 32x32. Still for this tiny icon-sized pic, an RGB format creates 3,072 nodes. This rapid growth in data is why modern deep learning needs powerful GPUs.
Live Webcam Test:
Switch to the Live Webcam tab. Try moving your hand. Watch how the 2D pic changes and how those changes ripple through the 1D flattened array. Each movement changes hundreds of vals at once across the vector.
The Problem with Flattening
While flattening lets an MLP to process an pic, it destroys spatial relationships. A pixel right above another pixel in 2D might be dozens of indices apart in the 1D array. Standard dense networks struggle to understand that these pixels were at first neighbors.
This exact problem led to the invention of Convolutional Neural Networks (CNNs). It process pics in 2D first before flattening them at the very end!
What to remember
Dense neural network layers just accept 1D lists (vectors) as input.
Flattening is the process of stringing rows of pixels together into a line.
The size of the input layer is $W \times H \times C$ (Channels).
High resolution pics create massive input layers, making them computationally costly.
Flattening is the bridge between raw pic files and the mathematical matrix steps that power Artificial Intelligence.
What each piece adds
Convolution detects patterns and gives feature maps — one per filter, each highlighting where its pattern was found.
ReLU zeroes negative replies. Without a non-linearity, stacked convolutions collapse into a single convolution. And depth buys nothing.
Pooling (or a strided convolution) shrinks the spatial dimensions. It reduces computation, widens the receptive field. And adds a little tolerance to small shifts.
Batch normalisation keeps activations in a stable range, making deeper networks trainable and letting more learning rates.
Global average pooling collapses each feature map to a single count, replacing the huge flatten-then-dense step used by older designs and removing most of their params.
The classifier head maps the final features to class scores. It a softmax turns into probabilities.
Where the assumptions break
Convolution works since of assumptions about pics. And it is worth knowing when they do not hold.
Rotation and scale are not free. Convolution is equivariant to translation, not to rotation or resizing. A network trained on upright faces will struggle with faces at 90°. It is just why rotation and scaling are standard data augmentations.
Global relationships need depth or attention. A 3×3 filter sees three pixels. Relating opposite corners of an pic needs many layers of accumulated receptive field. Vision transformers take the other route, checking all patches right with attention from the first layer — which is why they need more data but capture long-range structure more easily.
Not all grids are pics. Convolution assumes neighbouring positions are tied. Applied to a table of unrelated columns, that assumption is false and the inductive bias is wasted.
From a grid of counts to a class score
A network never sees a picture -- it sees an array. And each layer is arithmetic on that array. This follows one small pic all the way from pixels to a prediction. So that nothing in the pipeline is left as a metaphor.
example_01.pyNumPy
import numpy as np
rng = np.random.default_rng(4)
H, W = 8, 8
img = np.full((H, W), 30.0)
img[1:7, 3:5] = 210.0 # a vertical bar
img += rng.normal(0, 4, (H, W))
img = np.clip(img, 0, 255)
print("STEP 0 -- THE IMAGE IS AN ARRAY. this is the whole input:")
for row in img:
print(" " + " ".join("%3.0f" % v for v in row))
print(" %d numbers. there is no picture anywhere in the process -- the"
% img.size)
print(" picture is what YOUR eye does with these numbers.")
print()
print("STEP 1 -- NORMALISE. divide by 255 and subtract the mean:")
x = img / 255.0
x = (x - x.mean()) / x.std()
print(" after: range %.2f to %.2f, mean %.4f, std %.4f"
% (x.min(), x.max(), x.mean(), x.std()))
print(" this is not cosmetic. gradients scale with the input, so a")
print(" layer fed values in 0..255 gets gradients about %d times larger"
% 255)
print(" than one fed 0..1, and the learning rate that works for one")
print(" diverges for the other.")
print()
KERNELS = {
"vertical edge": np.array([[-1., 0, 1], [-2, 0, 2], [-1, 0, 1]]),
"horizontal edge": np.array([[-1., -2, -1], [0, 0, 0], [1, 2, 1]]),
"bright centre": np.array([[0., -1, 0], [-1, 4, -1], [0, -1, 0]]),
}
Output
Building on the same setup, the next block shows the left cases.
example_02.pyNumPy
import numpy as np
def conv(a, k):
out = np.zeros((a.shape[0] - 2, a.shape[1] - 2))
for i in range(out.shape[0]):
for j in range(out.shape[1]):
out[i, j] = (a[i:i + 3, j:j + 3] * k).sum()
return out
print("STEP 2 -- CONVOLUTION. slide each 3x3 kernel over the array and")
print("record the weighted sum at every position:")
print(" one position, written out in full. the window at (1,2):")
win = x[1:4, 2:5]
k = KERNELS["vertical edge"]
terms = win * k
print(" window: " + " ".join("%6.2f" % v for v in win.reshape(-1)))
print(" kernel: " + " ".join("%6.2f" % v for v in k.reshape(-1)))
print(" products:" + " ".join("%6.2f" % v for v in terms.reshape(-1)))
print(" sum = %.4f" % terms.sum())
print(" that is the entire operation. %d multiplies and %d adds,"
% (9, 8))
print(" repeated at every position, for every kernel.")
print()
maps = {name: conv(x, kk) for name, kk in KERNELS.items()}
print("%-20s %10s %10s %10s" % ("feature map", "shape", "min", "max"))
for name, m in maps.items():
print("%-20s %10s %10.3f %10.3f"
% (name, "%dx%d" % m.shape, m.min(), m.max()))
print(" the maps are %dx%d, not %dx%d: a 3x3 window cannot be centred on"
% (H - 2, W - 2, H, W))
print(" the border, so each convolution shrinks the array by 2. stack 20")
print(" layers without padding and a %dx%d input is gone." % (H, W))
print()
Output
The next block covers the left steps.
example_03.pyNumPy
import numpy as np
print("STEP 3 -- ReLU. keep the positive responses, zero the rest:")
acts = {n: np.maximum(m, 0) for n, m in maps.items()}
ramp = " .:-=+*#%@"
for name in KERNELS:
m = acts[name]
hi = m.max() + 1e-9
print(" %s" % name)
for row in m:
print(" " + "".join(ramp[min(9, int(9 * v / hi))] * 2 for v in row))
print(" the vertical-edge map fires down the left side of the bar, and")
print(" the horizontal-edge map fires along its TOP ONLY -- not its")
print(" bottom. that is the ReLU: before it, the kernel gave a positive")
print(" response going dark-to-light and a negative one going")
print(" light-to-dark, and the ReLU deleted the second. each channel")
print(" after a ReLU means a DIRECTED edge, which is why a real layer")
print(" carries the mirrored kernel as a separate channel to catch the")
print(" bottom.")
print(" nothing here was told what a bar is. these are simply the")
print(" numbers those kernels produce on these pixels.")
print()
Output
The next block continues with the left demonstrations.
example_04.pyNumPy
import numpy as np
print("STEP 4 -- POOL. take the max in each 2x2 block:")
def pool(a):
n = (a.shape[0] // 2) * 2
b = a[:n, :n]
return b.reshape(n // 2, 2, n // 2, 2).max(axis=(1, 3))
pooled = {n: pool(a) for n, a in acts.items()}
print(" %s -> %s per map, %d values in total instead of %d."
% ("%dx%d" % acts["vertical edge"].shape,
"%dx%d" % pooled["vertical edge"].shape,
sum(p.size for p in pooled.values()),
sum(a.size for a in acts.values())))
print(" pooling answers 'was this feature present nearby?' instead of")
print(" 'was it exactly here?'. that is a deliberate loss of position,")
print(" and it is what makes the answer survive the object moving a")
print(" pixel or two.")
print()
Output
Building on the same setup, the next block shows the left cases.
example_05.pyNumPy
import numpy as np
print("STEP 5 -- FLATTEN AND CLASSIFY. concatenate everything into one")
print("vector and multiply by a weight matrix:")
feat = np.concatenate([p.reshape(-1) for p in pooled.values()])
print(" feature vector: %d numbers" % feat.size)
Wc = np.zeros((2, feat.size))
nv = pooled["vertical edge"].size
Wc[0, :nv] = 1.2 # class 0 = "has a vertical bar"
Wc[1, nv:2 * nv] = 1.2 # class 1 = "has a horizontal bar"
logits = Wc @ feat
p = np.exp(logits - logits.max())
p = p / p.sum()
print(" logits: %s" % " ".join("%8.4f" % v for v in logits))
print(" probabilities: %s" % " ".join("%8.4f" % v for v in p))
print(" the network says class %d ('%s') with %.1f%% confidence."
% (int(p.argmax()), ["vertical bar", "horizontal bar"][int(p.argmax())],
100 * p.max()))
print(" and it is right -- but read that %.1f%% carefully. the weights"
% (100 * p.max()))
print(" here were written by hand to be decisive, so the logit gap is")
print(" %.1f and the softmax saturates. a trained network's"
% (logits.max() - logits.min()))
print(" confidence is shaped by its loss and its data, and is a much")
print(" more interesting number than this one.")
Output
The next block covers the left steps.
example_06.pyNumPy
print()
print("EVERY STAGE, AND WHAT IT COST:")
print("%-26s %14s %14s %s"
% ("stage", "values", "parameters", "what it did"))
rows = [("input", img.size, 0, "nothing"),
("normalise", img.size, 0, "rescale"),
("conv, 3 kernels", sum(m.size for m in maps.values()),
3 * 9, "measure"),
("ReLU", sum(m.size for m in maps.values()), 0, "threshold"),
("pool 2x2", sum(pl.size for pl in pooled.values()), 0, "discard position"),
("flatten", feat.size, 0, "reshape"),
("dense -> 2", 2, Wc.size, "decide")]
for name, n, prm, what in rows:
print("%-26s %14d %14d %s" % (name, n, prm, what))
print(" %d parameters in total, %d of them in the last layer alone."
% (3 * 9 + Wc.size, Wc.size))
print()
print("THE ONLY THING THIS EXAMPLE SKIPPED IS TRAINING. the kernels here")
print("were written by hand, and in a real network every one of those %d"
% (3 * 9 + Wc.size))
print("numbers starts random and is adjusted by gradient descent until the")
print("predictions match the labels. nothing else about the pipeline")
print("changes -- the same convolutions, the same ReLU, the same pooling,")
print("the same matrix multiply. learning decides WHICH kernels, never")
print("what a kernel is.")
Output
Questions people ask
Why 3×3 filters almost all over? Two stacked 3×3 layers see the same region as one 5×5 but use fewer params and include an extra non-linearity. VGG set this and it stuck.
Does the input have to be a fixed size? Convolutions do not care. But a flatten-then-dense head does. Global average pooling removes the constraint, which is why modern designs accept varying sizes.
Why normalise pixel vals? Since 0–255 inputs give large activations and awkward gradients. Scaling to 0–1 or standardising per channel is standard.
How many filters should a layer have? Often doubling with depth — 32, 64, 128, 256 — as spatial size shrinks and the count of distinct patterns to represent grows.
Do CNNs see like humans? Not really. They are far more sensitive to texture than to shape. And small adversarial changes invisible to a person can flip a prediction fully.
Are CNNs obsolete now that transformers exist? No. They remain more data-fast, faster on small pics. And the standard choice on limited hardware. Hybrid designs are common.
Recap in one screen
An pic is a grid of counts. Colour adds three channels.
A dense layer on raw pixels needs hundreds of millions of weights and ignores spatial structure.
Convolution assumes locality and shares one small filter across the whole pic, cutting params by orders of magnitude.
Stacked layers build a hierarchy: edges, then textures, then parts, then objects.
Translation is handled naturally. Rotation and scale must come from augmentation.
Recall check
0 of 3
Say the answer out loud before you reveal it — recalling it is what makes it stick, and rereading it is not.
What is meant by “Flattening” here?
What does this module say about “The idea in brief”?
What does this module say about “Preprocessing Parameters”?
Cheat sheet
How Neural Networks Process Images
Unroll a 2D pixel grid into a 1D vector and see what spatial information flattening destroys — and why CNNs exist to avoid it.
Ashish Jangra builds and maintains VizLearn. Every module here is written and the visualisation behind it hand-built, so the numbers in a readout come from the same code that draws the picture. Corrections are genuinely welcome and get priority over everything else — if a page states something wrong, or an animation misrepresents what the algorithm does, get in touch.