Mixed precision training: Foundations — AI-ML deep dive

Before you can read the parent note on Mixed precision training, you must be able to picture what a "precision format" actually is, why a tiny number can vanish, and what every symbol like $η$ , $g_{t}$ , $S$ , and $cast (\cdot)$ means. We build each one from nothing, in an order where every piece leans only on the pieces before it.

1. A number lives in a box of bits

A bit is a single switch: it is either $0$ or $1$ . That's the whole alphabet a computer has.

To store a "real" number like $0.5$ or $- 6504.25$ , the computer glues a fixed number of bits together and agrees on a rule for reading them. The rule used everywhere in deep learning is called floating point. Think of it like scientific notation you already know:

- 6.02 \times 1 0^{23}

Three separate jobs are hidden in that expression, and floating point stores exactly these three jobs as three groups of bits:

the sign ( $-$ ): is the number positive or negative? → 1 bit.
the exponent ( $1 0^{23}$ ): how big is the number, i.e. where does the decimal point sit? → some bits.
the mantissa (the $6.02$ part, also called the fraction or significand): the actual digits, how precise the number is → the remaining bits.

The parent note's whole table (FP32, FP16, BF16) is just different splits of the same total bits between these three jobs. Keep this picture: exponent = how wide a net; mantissa = how fine the mesh.

2. Range vs. precision — two different limits

These two words get confused, so pin them down with a picture.

Range = the smallest and largest magnitudes the format can reach at all. Set by the exponent bits. If a number is bigger than the max, you get overflow (the value becomes $\infty$ , written inf). If it is smaller than the min, you get underflow (the value collapses to $0$ ).
Precision = the gap between neighbouring representable numbers. Set by the mantissa bits. Numbers that land between two representable neighbours get snapped to the nearest one — this snapping is called rounding.

The parent note quotes:

FP32: 8 exponent + 23 mantissa → range $\sim 1 0^{- 38}$ to $1 0^{38}$ , precision $\sim 1 0^{- 7}$ .
FP16: 5 exponent + 10 mantissa → range $\sim 1 0^{- 8}$ to $\sim 6.5 \times 1 0^{4}$ , precision $\sim 1 0^{- 3}$ .
BF16: 8 exponent + 7 mantissa → FP32's range, but coarser precision $\sim 1 0^{- 2}$ .

Notice BF16 spends its bits on exponent (wide net) rather than mantissa (fine mesh) — that is why it "can't underflow like FP16 but is blurrier." See 1.3.07-Numerical-stability for the general study of when arithmetic quietly breaks like this.

3. Rounding and casting — moving a number between boxes

So when the parent writes $w^{F P 16} = cast (w^{F P 32})$ , it means "copy the master weight into the coarse format for fast computation," accepting a little rounding. When it writes $g^{F P 32} = cast (g^{F P 16})$ , no information is lost — we are only widening the box.

4. The symbols from training itself

Mixed precision sits inside ordinary gradient-descent training, so you must know these symbols cold. Each is a plain object with a picture.

Put together, one step of gradient descent is:

w_{t + 1} = w_{t} - η \cdot g_{t}

Why does $\partial L / \partial w$ (the partial derivative) appear at all, and not some simpler measure? Because we want the direction that changes the loss fastest, and the derivative is precisely the tool that answers "rate of change of one quantity as another wiggles." Nothing else gives you the slope of $L$ in the $w$ direction.

5. The chain rule — why gradients get tiny

The parent note writes:

\frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \cdot \frac{\partial a}{\partial w}

Here $a$ is an activation — the output of some neuron between the input and the loss. The chain rule says: to know how $w$ affects the final loss $L$ , multiply how $w$ affects the nearby activation $a$ by how $a$ affects $L$ .

Why does this cause tiny numbers? In a deep network, $L$ depends on $w$ through many layers, so the gradient is a product of many such factors. Multiply a dozen numbers each around $0.3$ and you get something like $1 0^{- 7}$ — a number that FP16 cannot even represent. That is the exact failure the parent note's loss scaling fixes.

Sign (1 bit), exponent (scale/range), mantissa (digits/precision).

Which bits control range, and which control precision?

Exponent bits control range; mantissa bits control precision.

What is underflow?

A nonzero number smaller than the format's minimum magnitude collapses to

0

What is overflow?

A number larger than the format's maximum becomes inf.

Why can't casting FP16 → FP32 recover lost precision?

The value was already snapped to an FP16 tick; widening the box keeps the snapped value.

w_{t + 1} = w_{t} - η g_{t}

, what is

η

and what is

g_{t}

η

is the learning rate (step size);

g_{t}

is the gradient (slope of loss w.r.t.

w

Why does the product

η \cdot g_{t}

matter for FP16?

If it is smaller than the FP16 mesh (~

1 0^{- 3}

), the weight update rounds away to nothing.

Why does the chain rule make gradients tiny in deep nets?

The gradient is a product of many per-layer factors, and many sub-1 factors multiply down to ~

1 0^{- 7}

What does the loss-scale factor

S

do?

Multiplies the loss (hence every gradient) by a big constant to lift tiny gradients into FP16 range; divided out before the update.

What is a GEMM and why is FP16 fast for it?

A big matrix multiply; Tensor Cores run FP16 GEMMs several times faster than FP32.

Foundations — Mixed precision training

1. A number lives in a box of bits

2. Range vs. precision — two different limits

3. Rounding and casting — moving a number between boxes

4. The symbols from training itself

5. The chain rule — why gradients get tiny

6. Where the speed actually comes from

Prerequisite map

Equipment checklist