【数据与安全】- 浮点数精度问题详解

2022-05-10 本文已影响0人拔萝卜占坑

简介

由于计算机存储的规则所致，有些时候浮点数存入和读取出来的值并不相等，同样的数据用单精度（float）和用双精度（double）存储，获取出来的值也会有差异。所以，当我们开发对精度要求比较高的业务场景下，如果不了解，很可能出现直接的经济损失。针对这些问题，接下来用一篇文章来详细讲解这些问题和解决方案。

例子

public static void main(String[] args) {
    double d1 = 0.1;
    double d2 = 0.1f;
    float d3 = 0.1f;
    System.out.println("d1=" + d1);
    System.out.println("d2=" + d2);
    System.out.println("d3=" + d3);
}

输出：

d1=0.1
d2=0.10000000149011612
d3=0.1

第一个问题
为什么d1和d2打印的结果不同，d2打印的值为什么不是0.1，那d2后面149011612又是怎么来的呢？
第二个问题
都说浮点数存在精度问题，当读取的时候会和存入时的值不同，那为何d3打印出来就是0.1呢？难道d3在计算机里存的本来就是0.1？

如果想要解释上面的问题，那么就需先了解浮点数在计算机中的存储方式（遵循IEEE 754（IEEE Standard for Floating-Point Arithmetic）标准）。

十进制数转换为二进制数

整数转二进制
十进制整数转换为二进制整数采用"除2取余，逆序排列"法。
十进制小数转换为二进制小数
十进制小数转换成二进制小数采用"乘2取整，顺序排列"法。具体做法是：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，或者达到所要求的精度为止。然后把取出的整数部分按顺序排列起来，先取的整数作为二进制小数的高位有效位，后取的整数作为低位有效位。
aa.png

浮点数存储格式

IEEE 754规定，对于32位的浮点数（单精度float），最高的1位是符号位s，接着的8位是指数E，剩下的23位为有效数字M。

float.png
对于64位的浮点数（双精度double），最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。

double.png

IEEE 754对有效数字M和指数E的一些特别规定。

1≤M<2，也就是说，M可以写成1.xxxxxx的形式，其中xxxxxx表示小数部分。IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的xxxxxx部分。比如保存1.01的时候，只保存01，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字。

至于指数E，情况就比较复杂。

首先，E为一个无符号整数（unsigned int）。这意味着，如果E为8位，它的取值范围为0 ~ 255；如果E为11位，它的取值范围为0 ~ 2047。但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE 754规定，E的真实值必须再减去一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。
```
比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即10001001。
```
然后，指数E还可以再分成三种情况：
1. E不全为0或不全为1。这时，浮点数就采用上面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第一位的1。
2. E全为0。这时，浮点数的指数E等于1-127（或者1-1023），有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于0的很小的数字。
3. E全为1。这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；如果有效数字M不全为0，表示这个数不是一个数（NaN）。

浮点数舍入规则

而 IEEE 754 就是采用向最近偶数舍入（round to nearest even）的规则。

向丢失精度最小的方向向上/向下舍入
如果向上/向下舍入丢失精度一样，者向偶数舍入

比如0.1的二进制是1.10011001100110011001100110011001100110011001100110011...
根据单精度有效位M长度时23：
1.10011001100110011001100110011001100110011001100110011...，显然向上舍入丢失的精度更小，所以0.1单精度存储为：10011001100110011001101而不是10011001100110011001100

举例

这里以小数0.1以单精度和双精度存储位例进行讲解。首先把0.1转换成二进制的形式是（转换网站）

000110011001100110011001100110011001100110011001100110011...

把0.1以单精度存储
根据上面的存储规则和有效数 M表示规则，需要把0.1表示的二进制向右移动4位，相当于乘以2^4，那么可以得出指数部分应该就是 127 - 4 = 123，二进制就是01111011 ,由于向右移动4位，那么上面二进制变成1.10011001100110011001100110011001100110011001100110011...，由于M的第一位可以不存储，二单精度的有效位是23,那么截取小数点后23位存储下来，其它舍去，在根据浮点数舍入规则最终存入的有效位二进制：10011001100110011001101,加上第一位符号位，那么在0.1在计算机存储为：
```
    0        01111011      10011001100110011001101
符号位(S)     指数位(E)            有效位(M)
```

把0.1以双精度存储（64位）

0          01111111011 1001100110011001100110011001100110011001100110011010
符号位(S)     指数位(E)            有效位(M)

二进制小数转十进制

以上面0.1单精度存储二进制1. 10011001100110011001101进行转换:

2^0 + 2^-1 + 2^-4 + 2^-5 + 2^-8 + 2^-9 + 2^-12 + 2^-13 + 2^-16 + 2^-17 + 2^-20 + 2^-21 + 2^-23
上面加起来的值在乘以指数2^-4就得到0.1存储在计算机的值了。
经过计算上面最终的值是：0.10000000149011612...

浮点数的有效位数

单精度的尾数用23位存储，加上预设的小数点前不做存储的1这一位，那么可以表示的最大数：2^(23+1) = 16777216。因为 10^7 < 16777216 < 10^8，所以说单精度浮点数的有效位数是7位。
双精度的尾数用52位存储，2^(52+1) = 9007199254740992，因为10^16 < 9007199254740992 < 10^17，所以双精度的有效位数是16位。

解释上面的问题

float d1 = 0.1f输出为什么是0.1
根据上面讲解的点数的有效位数,单精度最大保留8位有效数。所以截去多余的就变成0.10000000即为0.1，这里看上去好像没有出现精度问题。
double d1 = 0.1f输出为什么是0.10000000149011612
首先，'0.1f'按照单精度进行存储，读取出来的值赋值给双精度d1，根据上面讲解的点数的有效位数,双精度最大保留17位有效数，截去多余部分：0.10000000149011612
double d1 = 0.1输出为什么是0.1而不是0.10000000149011612
这里0.1按照双精度存储，由于双精度的尾数用52位存储，精度更高，大家可以把52位二进制加起来算一下，把最后得到的数保留17位有效数，看是不是也是 0.1,答案，是肯定的。这里有个简单的方式打印

public static void main(String[] args) {
    System.out.println("aa= " + new BigDecimal(0.1));
}

输出

aa= 0.1000000000000000055511151231257827021181583404541015625

精度丢失

public static void main(String[] args) {
    float d4 = 111111.01111111f;
    System.out.println("d4=" + d4);
}

输出

d4=111111.01

大家可以按照上面的思路转换一下。可以见得，使用浮点数时，如果整数部分越大，小数精度丢失越严重。

精度丢失解决办法

BigDecimal

Java的在使用除法（divide方法）时，应该手动指定精度和舍入的方式。如果不指定精度和舍入方式，在除不尽的时候会报异常。

public static void main(String[] args) {
  System.out.println("aa= " + new BigDecimal("1.0").divide(new   BigDecimal("3.0"),1170,BigDecimal.ROUND_HALF_UP));
}

BigDecimal舍入规则查看：舍入规则

Half

半精度，使用优势：

float16和float相比恰里，总结下来就是两个原因：内存占用更少，计算更快。
内存占用更少：这个是显然可见的，通用的模型 fp16 占用的内存只需原来的一半。memory-bandwidth 减半所带来的好处：
1. 模型占用的内存更小，训练的时候可以用更大的batchsize。
2. 模型训练时，通信量（特别是多卡，或者多机多卡）大幅减少，大幅减少等待时间，加快数据的流通。
计算更快：目前的不少GPU都有针对 fp16 的计算进行优化。论文指出：在近期的GPU中，半精度的计算吞吐量可以是单精度的 2-8 倍

半精度，缺点：

数据溢出问题
舍入误差

BigInteger(不可变的任意精度有符号整数)

这个应该就是表示任意大小的整数类，里面用了一个数组来存储。