1. 小数的二进制转换

十进制小数转换成二进制小数采用「乘2取整，顺序排列」法。具体做法是：用 $2$ 乘十进制小数，可以得到积，将积的整数部分取出，再用 $2$ 乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，或者达到所要求的精度为止。

然后把取出的整数部分按顺序排列起来，先取的整数作为二进制小数的高位有效位，后取的整数作为低位有效位。

二进制小数转十进制小数则十分简单。我们知道二进制表示整数时，最低位代表 $2$ 的 $0$ 次方，往高位依次是 $2$ 的 $1$ 次方，$2$ 次方，$3$ 次方。那么对应的，二进制数小数点后面，最高位则是 $2$ 的 $-1$ 次方，如下图所示：

因此：$(0.1101{)}_2=1\cdot 2^{-1}+1\cdot 2^{-2}+0\cdot 2^{-3}+1\cdot 2^{-4}=(0.8125{)}_{10}$。

整数可以使用 $2$ 的非负幂次的有限和来表示，但小数就不一定能够用 $2$ 的负幂次的有限和来表示了，部分情况下可能是无限和。

例如对于小数 $0.6$ 而言，它的二进制形式为 $0.\overline{1001}$，是一个无限循环小数，循环节是 $1001$。

计算机只能识别 $0$ 和 $1$，这就是为什么我们需要讨论十进制小数到二进制小数的转换。注意到在上述的例子中，$0.6$ 转换成二进制后是一个无限循环小数，由于计算机内存有限，无法存储无限长的数字序列，因此在实际存储这类数字时，只能存储小数点后的有限位数。这就意味着，无论如何，存储时都必须进行截断或四舍五入处理，而这种操作会引入所谓的「浮点数精度误差」。

很显然，对于这类小数，能够存储的位数越多，相应的精度就越高。这就是为什么 double 类型相比于 float 类型能提供更高精度的原因。

⚠️ 浮点数存储遵循IEEE 754规范。

为加深理解，我们使用Python来实现一遍：

def decimal_to_binary(decimal, max_step=30):binary = '0.'cnt = 0while decimal != 0 and cnt < max_step:decimal *= 2bit = int(decimal)binary += str(bit)decimal -= bitcnt += 1return binaryprint(decimal_to_binary(0.8125))
print(decimal_to_binary(0.6))

2. 浮点数的二进制转换

粗略地讲，一个浮点数由其整数部分和小数部分组成，在知道小数的进制转换后，我们可以将一个十进制浮点数转换成二进制形式。

以 $10.625$ 为例。只需注意到

$$\begin{array}{rl}10.625& =10+0.625=8+2+0.5+0.125\\ & =2^3+2^1+2^{-1}+2^{-3}\end{array}$$

于是 $(10.625{)}_{10}=(1010.101{)}_2$。我们还可以进一步将其表示成以 $2$ 为底的科学记数法：$1010.101=1.010101\times 2^3$。

一些其他的例子：

$$\begin{array}{rl}3.5& \to 1.11\times 2^1\\ 0.8125& \to 1.101\times 2^{-1}\\ -0.6& \to -1.\overline{0011}\times 2^{-1}\end{array}$$

由此可见，任何（正）十进制浮点数表示成二进制科学记数法以后，一定是 $1$ 点几（尾数）乘以 $2$ 的多少次方（指数）。对于负数来说，就是负 $1$ 点几（尾数）乘以 $2$ 的多少次方（指数）。因此，任意一个二进制浮点数都可以表示成下面的形式：

$$V=(-1{)}^s\times M\times 2^E\text{\hspace{1em}(1)}$$

其中 $s$ 代表符号位（sign），$s=1$ 说明是负数，$s=0$ 说明是正数。$M$ 是尾数（mantissa），$E$ 是指数（exponent）。因此存储一个浮点数只需要存储 $s,M,E$ 这三部分。

---

一些发现：

• 尾数 $M$ 的最高位总是 $1$，因此实际存储时，只需要存储尾数的小数部分（fraction），即小数点后面的数字。
• $M\in [1,2)$。这是因为，$M$ 最高位是 $1$，所以至少是 $\mathrm{1.000...}$，极端情况下是 $\mathrm{1.111...}$，即 $1+\frac{1}{2}+\frac{1}{4}+...$，即使尾数达到了 $2$，即 $\mathrm{10.000...}$，也会被重新规范化到 $\mathrm{1.000...}$，即 $1$。
• $E\in \mathbb{Z}$，可正可负可为 $0$。
• 注意到 $M\times 2^{-1}\in [0.5,1),M\times 2^1\in [2,4)$。因此，在十进制下，任何小于 $1$ 的数转化成二进制后，其指数一定小于 $0$；任何大于等于 $2$ 的数转化成二进制后，其指数一定大于 $0$。进一步可知，对于任意非零十进制浮点数 $x$，将其转化成二进制后，其指数为 $\lfloor {\log }_2|x|\rfloor$。
• 只考虑正浮点数（负浮点数亦然）。由上一条知，所有指数将所有的正浮点数 $(0,+\infty )$ 划分成若干个互不相交的区间：$(0,+\infty )={\bigcup }_{k=-\infty }^{+\infty }[2^k,2^{k+1})$。设有两个符号相同的十进制浮点数 $x_1,x_2$，它们在二进制下的指数分别为 $k_1,k_2$，且 $k_1>k_2$。若 $x_1,x_2$ 均为正，则 $x_1>x_2$；若 $x_1,x_2$ 均为负，则 $x_1<x_2$。这说明我们可以仅靠指数来比较两个浮点数的大小（前提是指数不同）。
• $M$ 的位数通常决定了浮点数能表示的精度。例如对于十进制小数 $0.6$ 而言，将其转化成二进制后，能存储的尾数位越多，表达自然越精确。$E$ 的位数则决定了浮点数能够表示的数值范围。

3. 浮点数的存储

3.1 以fp32为例

IEEE 754规定的浮点数存储格式如下：

最高位是符号位，$1$ 代表负数，$0$ 代表正数。接下来的若干位是指数位，指数位之后才是尾数位（不存储最高位 $1$）。

以fp32（32-bit floating point，32位浮点数）为例，它拥有 $1$ 位符号位、$8$ 位指数位，$23$ 位尾数位。

$8$ 位有符号整数的取值范围是 $[-128,127]$，可以表示 $256$ 个指数。但实际上，我们前面说过，指数不等时可以仅通过指数来比较两个浮点数的大小。为了简化这个比较手续，考虑采用 $8$ 位无符号整数进行存储，这样就能仅通过字典序来比较两个指数的大小了。在该设定下，指数的取值范围变成了 $[0,255]$。

浮点数中还有三个特殊值：$0,\infty ,\text{NaN}$。IEEE 754规定，需要留一些位置用来表示这些特殊值：$0$ 用来留给 $0$，$255$ 用来留给 $\infty ,\text{NaN}$。挖掉两个位置后，指数的取值范围变成了 $[1,254]$。注意到此时还没有负指数，为了平衡正负指数的个数，这里引入指数偏移量 $c=127$，于是有

$$存储指数-127=实际指数$$

故知实际指数的范围为 $[-126,127]$。

🧑‍💻 一般地，设 $e$ 为指数位的个数，则 $c\triangleq 2^{e-1}-1$。fp32的指数偏移量为 $2^{8-1}-1=127$。

例如，$10.625$ 转化成二进制后指数为 $3$，那么用来存储的指数值为 $127+3=130$，即 $10000010$。尾数部分只需要存储 $010101$，因此 $10.625$ 用fp32表示即为

$$\underset{1个符号位}{\underbrace{0}}\underset{8个指数位}{\underbrace{10000010}}\underset{23个尾数位}{\underbrace{01010100000000000000000}}$$

那反过来该如何操作呢？例如，给定一个fp32格式的浮点数 11000001010011000000000000000000，首先分离出它的符号位、指数位和尾数位：

• 符号位：$1$
• 指数位：$10000010$
• 尾数位：$10011000000000000000000$

由符号位可知这是一个负数，将指数位转换成十进制得到 $130$，因此实际指数为 $130-127=3$。由此可知该浮点数的二进制科学记数法表示为 $-1.10011\times 2^3$，从而

$$-1.10011\times 2^3=-1100.11=-(2^3+2^2+2^{-1}+2^{-2})=-12.75$$

我们还可以用Python来完成这个互相转化的操作：

import structdef binary_to_float(binary_str):assert len(binary_str) == 32, "only support fp32"# 4 bytes, 32 bits.decimal_float = int(binary_str, 2).to_bytes(4, 'big')return struct.unpack('>f', decimal_float)[0]def float_to_binary(value):packed_float = struct.pack('>f', value)binary_str = ''.join(f'{byte:08b}' for byte in packed_float)return binary_strprint(binary_to_float('11000001010011000000000000000000'))
print(float_to_binary(-12.75))

3.2 规约形式与非规约形式

回到 $(1)$ 式，已知 $M\in [1,2)$，设有 $e$ 个指数位，那么存储指数 $E\in [0,2^e-1]$。当 $E\in [1,2^e-2]$ 时，此时 $(1)$ 式又称规约形式。

还是以fp32为例，只考虑正数，在规约形式下

• 最小值： $M=1,E=1-127=-126$，故 $V=2^{-126}\approx 1.18\times 10^{-38}$。
• 最大值： $M=1+2^{-1}+\cdots +2^{-23}=2-2^{-23},E=254-127=127$，故 $V=(2-2^{-23})\cdot 2^{127}\approx 3.40\times 10^{38}$

很显然，fp32无法表示低于最小值的数，低于最小值的数会被视为 $0$（下溢）。同样地，高于最大值的数会被视为 $\infty$（上溢）。

更具体地：

• 用 $M=0,E=0$ 来表示 $0$。
• 用 $M=0,E=2^e-1$ 来表示 $\infty$。
• 用 $M\ne 0,E=2^e-1$ 来表示 $\text{NaN}$。

为了让fp32能表示低于最小值的数（即更接近0的数），并且让从最小规约数向 $0$ 的过渡更加平滑，非规约数便由此引入。这种设计使得浮点数系统能够更细致地处理接近零的小数值。

我们先思考一下，如何让fp32来表示小于 $2^{-126}$ 的数呢？显然存储指数 $E$ 已经达到了最小值 $1$，而 $M\in [1,2)$，将 $M$ 的隐含最高位由 $1$ 改为 $0$，从而 $M\in [0,1)$，我们便可以表示比最小规约数还要小的数。

IEEE 754规定，非规约数的实际存储指数为 $0$，而计算公式则为 $1-c$，其中 $c$ 为指数偏移量。并且 $M\in (0,1)$。当 $E=0,M\ne 0$ 时，则按照非规约数来解析fp32。

我们来计算一下非规约形式下的最小值和最大值：

• 最小值： $M=2^{-23},E=0$，$V=2^{-23}\cdot 2^{-126}=2^{-149}\approx 1.4\times 10^{-45}$。
• 最大值： $M=2^{-1}+2^{-2}+\cdots +2^{-23}=1-2^{-23},E=0$，$V=(1-2^{-23})\cdot 2^{-126}\approx 2^{-126}$。

---

我们还可以进一步计算得到一般形式下的一些结论。设一个浮点数有 $e$ 个指数位和 $f$ 个尾数位，令 $c\triangleq 2^{e-1}-1$，则：

• 规约形式下的最小值：$2^{1-c}$。
• 规约形式下的最大值：$(2-2^{-f})\cdot 2^c$。
• 非规约形式下的最小值：$2^{1-c-f}$。
• 非规约形式下的最大值：$(1-2^{-f})\cdot 2^{1-c}$。

可以看出有以下等式成立：

$$非规约形式下的最小值+非规约形式下的最大值=规约形式下的最小值$$

关于特殊值的一些结论：

$E$	$M$	形式
$[1,2^e-2]$	$[1,2)$	规约形式
$0$	$(0,1)$	非规约形式
$0$	$0$	零
$2^e-1$	$0$	无穷
$2^e-1$	$\ne 0$	NaN

4. 各种类型的浮点数

名称	指数位	尾数位
FP16（半精度浮点数）	$5$	$10$
BF16（Brain Floating）	$8$	$7$
FP32（单精度浮点数）	$8$	$23$
FP64（双精度浮点数）	$11$	$52$
FP128（四精度浮点数）	$15$	$112$

5. BF16和FP16的区别

先使用之前得到的公式计算一下规约形式下的最小值和最大值：

类型	Min	Max
FP16	$2^{-14}\approx 6.10\times 10^{-5}$	$(2-2^{-10})\cdot 2^{15}=65504$
BF16	$2^{-126}\approx 1.18\times 10^{-38}$	$(2-2^{-7})\cdot 2^{127}\approx 3.39\times 10^{38}$

• BF16和FP32的指数位相同，像是从FP32中截取了前16位一样。也正是因为指数位相同，使得BF16的数值范围与FP32相似。
• BF16相比FP16的数值范围更大，但是精度会更低（深度学习中，数值范围的重要性是远大于数值精度的）。
• FP16的数值范围过小，容易造成溢出。
• FP16更多用于需要较高精度但数值范围要求不是特别严格的场合，如某些图形处理和较轻量级的神经网络模型推理。

---

Ref

[1] https://blog.csdn.net/u013250861/article/details/131152163
[2] https://www.paddlepaddle.org.cn/documentation/docs/zh/dev_guides/amp_precision/amp_op_dev_guide_cn.html
[3] https://cloud.tencent.com/developer/article/1473541
[4] https://www.runoob.com/w3cnote/decimal-decimals-are-converted-to-binary-fractions.html
[5] https://leokongwq.github.io/2017/08/19/computer-how-float-stored.html