The Jacobian matrix: Visual walkthrough — AI-ML deep dive

Every symbol below is earned before it is used. If you have never seen $\partial$ or a matrix, start at line one — nothing is assumed.

Step 1 — A function that eats a vector and makes a vector

WHAT. Picture a little machine. On the left are input dials — numbers we can turn. On the right are output bulbs — numbers that light up. We call the whole list of dials $x$ (bold means "a whole list of numbers, stacked"), and the whole list of bulbs $f (x)$ .

WHY. In ordinary school calculus a function takes one number in and gives one number out. But an image has thousands of pixels in; a neural layer has many numbers out. So we need a function

f : n dials (inputs) R^{n} ⟶ m bulbs (outputs) R^{m} .

Here $R^{n}$ just means "a list of $n$ real numbers", and $n$ , $m$ count the dials and bulbs. The arrow $⟶$ reads "maps to".

PICTURE. Two dials on the left, two bulbs on the right, wires connecting each dial to each bulb — because turning any dial can affect any bulb.

Step 2 — Nudge ONE dial, watch ONE bulb

WHAT. Freeze every dial except dial $j$ . Turn dial $j$ by a tiny amount we call $h_{j}$ (the letter $h$ will always mean "a small nudge"; the subscript $j$ says which dial). Watch how much bulb $i$ changes.

WHY. A big twist is confusing — many things move at once. A tiny twist lets us measure a single clean number: the rate at which bulb $i$ brightens per unit of dial- $j$ turn. That rate is the partial derivative:

\frac{\partial f _{i}}{\partial x _{j}} = shrink the nudge h_{j} \to 0 lim \frac{f _{i} ( \dots , x _{j} + h _{j} , \dots ) - f _{i} ( \dots , x _{j} , \dots ) change in bulb i}{size of nudge h _{j}} .

Why the limit $lim$ and not just a small number? Because for any finite nudge the ratio still bends a little (the curve is not perfectly straight). Shrinking $h_{j}$ to zero squeezes out that bend and leaves the exact slope — the tool that answers "instantaneous rate". The curly $\partial$ (not the straight $d$ ) is a flag saying "other dials are held constant."

PICTURE. A curved response of bulb $i$ against dial $j$ ; a short straight tangent line whose steepness is $\partial f_{i} / \partial x_{j}$ .

Step 3 — Small effects simply ADD

WHAT. Now turn all the dials a little at once: nudge $x$ by $h = (h_{1}, \dots, h_{n})$ . Claim: bulb $i$ 's total change is the sum of what each dial did on its own.

f_{i} (x + h) \approx start brightness f_{i} (x) + sum of tiny contributions \frac{\partial f _{i}}{\partial x _{1}} h_{1} + \frac{\partial f _{i}}{\partial x _{2}} h_{2} + \dots + \frac{\partial f _{i}}{\partial x _{n}} h_{n} .

WHY. For tiny nudges the machine behaves like a flat ramp, and on a flat ramp effects don't interfere — dial 1's push and dial 2's push just stack. The wavy $\approx$ ("approximately equals") is honest: this is only exact in the shrinking-nudge limit, but for small $h$ the error is negligible. Each term $(\partial f_{i} / \partial x_{j}) h_{j}$ is "rate $\times$ how far I turned" — a slope times a distance gives a rise. This is linear approximation, first order.

PICTURE. Two ramps in a "brightness landscape"; walking $h_{1}$ east then $h_{2}$ north raises brightness by the two separate rises added together.

Step 4 — A sum of products IS a row times a column

WHAT. That long sum is exactly what a row of numbers times a column of numbers produces:

j = 1 \sum n \frac{\partial f _{i}}{\partial x _{j}} h_{j} = row: the rates for bulb i [\frac{\partial f _{i}}{\partial x _{1}} \frac{\partial f _{i}}{\partial x _{2}} \dots \frac{\partial f _{i}}{\partial x _{n}}] column: the nudges h_{1} h_{2} ⋮ h_{n} = (\nabla f_{i})^{⊤} h .

WHY. The rule for multiplying a row by a column is "pair them up, multiply, add." That is word-for-word our sum. So the messy notation collapses into one tidy product. The row of rates has a name — the gradient of bulb $i$ , written $\nabla f_{i}$ ; here it lies flat (that flat form is written $(\nabla f_{i})^{⊤}$ , "gradient turned on its side").

PICTURE. The row and column sliding together entry-by-entry, each pair multiplied, all products dropped into one running total.

Step 5 — Stack every bulb's row → the Jacobian appears

WHAT. Do Step 4 for all $m$ bulbs at once. Stack the rows on top of each other:

f (x + h) \approx f (x) + J (the Jacobian) (\nabla f_{1})^{⊤} (\nabla f_{2})^{⊤} ⋮ (\nabla f_{m})^{⊤} h .

WHY. One matrix equation now carries all the (bulb, dial) rates. The stacked block is the Jacobian $J$ : row $i$ is bulb $i$ 's gradient, and entry $J_{ij} = \partial f_{i} / \partial x_{j}$ . It has == $m$ rows (bulbs/outputs) and $n$ columns (dials/inputs)==, so $J \in R^{m \times n}$ — exactly the shape that can multiply an $n$ -long nudge column and return an $m$ -long brightness column.

PICTURE. Individual gradient-rows lifting into place to form the full rectangle, then the rectangle times the nudge-column producing the output-change column.

Step 6 — Edge cases: does the picture still hold?

WHAT & WHY. A rule you trust must survive its corners. Check three.

(a) One bulb ( $m = 1$ ). Only one row exists, so $J$ is a single row $= (\nabla f)^{⊤}$ . This is why people confuse Jacobian and gradient: for one output they carry the same numbers, but the Jacobian lies down (row) and the gradient stands up (column).

(b) A "sleeping" dial. If bulb $i$ ignores dial $j$ (e.g. no wire between them), then $\partial f_{i} / \partial x_{j} = 0$ — a genuine zero in the matrix. If every bulb ignores every dial (a constant machine), $J$ is the all-zeros matrix: nudging changes nothing, exactly as the picture predicts.

(c) Square machine, $m = n$ . Now $J$ is a square block and we may ask for its determinant $det J$ . Geometrically $∣ det J ∣$ is the local area/volume stretch — how much a tiny square of dial-space swells into bulb-space. When $m \neq = n$ (most ML layers), $J$ is a rectangle and has no determinant — you cannot ask "how much does area scale" between spaces of different dimension. This stretch factor is the star of Change of variables in integration.

PICTURE. Left: a lone row for $m = 1$ next to its stood-up gradient. Middle: a matrix with a zero entry where a wire is missing. Right: a unit square in $(x, y)$ mapped to a tilted parallelogram whose area is $∣ det J ∣$ .

The one-picture summary

WHAT. The whole journey on one canvas: nudge the dials $h$ , feed it through the rate-table $J$ (stacked gradients), read off the bulb change $J h$ , add it to the starting brightness. The curvy true output and the straight $J h$ prediction agree for small nudges and drift apart for big ones — which is why the Jacobian is a local linear model.

This same product-of-Jacobians, applied layer after layer, is Backpropagation and forward-mode autodiff; its symmetric cousin (second derivatives) is the Hessian matrix.

Recall Feynman retelling — the walkthrough in plain words

Think of a machine with a few dials and a few bulbs. Turn just one dial a hair and see how much one bulb brightens — that single "brightness-per-turn" number is a partial derivative (Step 2). Turn every dial a little and the bulb's total change is just each dial's effect added up (Step 3). "Multiply-each-and-add-them-up" is exactly what a row of numbers times a column of nudges does (Step 4), so each bulb's list of rates becomes a row. Stack one row per bulb and you get a rectangle — the Jacobian — that turns any small twist of dials into the resulting change of bulbs (Step 5). It has one row per bulb and one column per dial. If there is only one bulb it's just a lying-down gradient; missing wires are zeros; and for a square machine the determinant tells you how much a tiny patch of dial-space swells (Step 6). That rectangle is the machine's best straight-line impersonator, right around where you're standing.