What Is a Neural Network?

A neural network is not a model of the brain. It is a chain of simple, adjustable transformations, stacked so that each one operates on the output of the last. Chollet is blunt about the terminology: the name is a reference to neurobiology, and he says two names that could equally have been chosen are layered representations learning and hierarchical representations learning. The "deep" in deep learning is not a claim about depth of understanding - it stands for the number of layers stacked on top of each other.

This article builds the object from the bottom up: what one layer is, why a non-linearity between layers is mathematically necessary rather than decorative, and what depth actually buys. The central argument is settled with a proof and a worked example small enough to check on paper.

A. A layer is a parameterised transformation

A dense layer takes a vector in, multiplies it by a matrix, adds a bias, and applies a function element-wise:

$$\mathbf{a} = g(W\mathbf{x} + \mathbf{b}) .$$

Three pieces:

• $W$ and $\mathbf{b}$ are the layer's weights - the numbers that get adjusted during training. Everything a network knows lives here.
• $g$ is the activation function, applied to each component independently.
• $\mathbf{x}$ is whatever the previous layer produced.

A network is a stack of these. Chollet's framing is that each layer learns a representation of the data, and depth means successive layers of increasingly useful representations, all learned automatically from exposure to training data rather than hand-designed. This is the contrast with what he calls shallow learning, which extracts one or two layers of representation - say, a pixel histogram followed by a classification rule - and requires a human to decide what those features should be.

B. Why the activation function is not optional

Suppose we drop $g$ and stack two purely linear layers:

$$\mathbf{h} = W^{(1)}\mathbf{x}, \qquad \mathbf{y} = W^{(2)}\mathbf{h} = W^{(2)}\left(W^{(1)}\mathbf{x}\right) = \left(W^{(2)}W^{(1)}\right)\mathbf{x} .$$

Matrix multiplication is associative, so the two matrices collapse into one. Concretely, with

$$W^{(1)} = \begin{bmatrix}2 & 0\\ 0 & 3\end{bmatrix},\qquad W^{(2)} = \begin{bmatrix}1 & 1\\ 0 & 1\end{bmatrix},$$

the composition is

$$W^{(2)}W^{(1)} = \begin{bmatrix}2 & 3\\ 0 & 3\end{bmatrix},$$

a single layer. Add a hundred more linear layers and it is still a single layer. Depth without non-linearity buys nothing at all - not a slightly weaker model, but exactly the same set of representable functions.

The most common activation is the ReLU, $g(z) = \max(0, z)$, which passes positive values through unchanged and clamps negatives to zero. It is barely more than a kink, and that kink is enough.

The figure uses a different two-layer network, without biases. At its starting input both units are on and the network equals its collapsed linear map; drag the first input or second input until a unit switches off, and ReLU parts company with the collapse.

C. A function no single layer can compute

To show that the kink matters, we need a task a linear model provably cannot do. XOR is the standard one: two binary inputs, output $1$ when they differ.

Claim. No function of the form $y = w_1x_1 + w_2x_2 + b$ reproduces this table.

Proof. Suppose one did. Take the rows in turn:

• $(0,0) \mapsto 0$ forces $b = 0$.
• $(1,0) \mapsto 1$ forces $w_1 + b = 1$, so $w_1 = 1$.
• $(0,1) \mapsto 1$ forces $w_2 + b = 1$, so $w_2 = 1$.
• $(1,1) \mapsto 0$ forces $w_1 + w_2 + b = 0$.

Substituting the first three into the fourth gives $1 + 1 + 0 = 2$, and we needed $0$. The contradiction is unavoidable, so no such $w_1, w_2, b$ exist. $\blacksquare$

Geometrically, a linear model can only carve the input space with a single straight boundary, and the two XOR classes sit on opposite diagonals - no line separates them.

D. Two layers, worked by hand

Now add one hidden layer of two ReLU units. The weights below are chosen, not trained, so that every number can be checked:

$$W^{(1)} = \begin{bmatrix}1 & 1\\ 1 & 1\end{bmatrix},\quad \mathbf{b}^{(1)} = \begin{bmatrix}0\\ -1\end{bmatrix},\quad W^{(2)} = \begin{bmatrix}1 & -2\end{bmatrix},\quad b^{(2)} = 0 .$$

Both hidden units compute $x_1 + x_2$; they differ only in their bias, so the first fires whenever the sum is positive and the second only once the sum reaches $2$. The output layer subtracts twice the second from the first.

Take $\mathbf{x} = (1,1)$ step by step:

$$\mathbf{z}^{(1)} = W^{(1)}\mathbf{x} + \mathbf{b}^{(1)} = \begin{bmatrix}1+1+0\\ 1+1-1\end{bmatrix} = \begin{bmatrix}2\\ 1\end{bmatrix},$$ $$\mathbf{a}^{(1)} = \max(0, \mathbf{z}^{(1)}) = \begin{bmatrix}2\\ 1\end{bmatrix}, \qquad y = 1(2) + (-2)(1) = 0 . \checkmark$$

All four inputs:

Exact on all four rows.

Watch row one. The second unit's pre-activation is $-1$, and the ReLU clamps it to $0$. That clamping is the entire source of the network's extra power: it is the one place where the composition stops being linear. Remove it - let $\mathbf{a}^{(1)} = \mathbf{z}^{(1)}$ - and section B's collapse applies again, so the network would once more be unable to compute XOR.

E. What depth actually buys

Chollet gives the clearest picture of this. Imagine a red sheet of paper and a blue one, stacked and then crumpled together into a ball. The ball is your input data; each sheet is a class. The model's job is to find a transformation that uncrumples the ball so the two sheets are cleanly separable again.

A deep network does this incrementally: rather than searching for one enormously complicated transformation, it decomposes the job into a long chain of elementary ones, each a movement your fingers could make on the paper ball. Our XOR network is the smallest possible instance - the hidden layer folds the input space so that the two classes, previously inseparable by any line, become separable by one.

This is why depth is a genuinely different resource from width. Both add parameters, but depth adds composition, and composition is what turns a chain of simple transformations into a complicated one.

Capacity is not understanding. Chollet is careful to add that such a model is essentially a very high-dimensional curve fitted by gradient descent, with enough parameters that it could fit almost anything - train it long enough and it will end up memorising. The ability to represent a function is not the ability to generalise from data, which is the concern of the bias-variance tradeoff.

F. From representation to learning

We chose the XOR weights by hand. Real networks discover them, and the mechanism is a loss function - what Chollet also calls the objective function - that takes the network's prediction and the true target and computes a distance score capturing how badly the network did. Training adjusts the weights to shrink that score.

Getting from "here is a score" to "here is how each of a million weights should change" is the subject of the next article.

Key takeaways

• A layer is a parameterised transformation $g(W\mathbf{x} + \mathbf{b})$; the weights are everything the network knows.
• Stacked linear layers collapse into a single linear layer - $W^{(2)}W^{(1)}$ is just another matrix - so a non-linearity between them is mathematically necessary, not a tuning choice.
• No single linear layer can compute XOR; the four constraints force $1+1+0 = 0$, a contradiction.
• One hidden layer of two ReLU units computes XOR exactly, and the only non-linear step in it is a single clamp of $-1$ to $0$.
• Depth supplies composition: a complicated transformation decomposed into a chain of elementary ones - Chollet's uncrumpling of a folded data manifold.
• Enough capacity to represent a function is not the same as generalising from data.

What's next

We set the XOR weights by hand. Finding them automatically means computing how the loss responds to every weight in the network at once, which is exactly what Backpropagation and Gradient Descent does.