浮点数累加的精度损失如何避免？

上一讲我们讲到，浮点数0.3在计算机中的表示不是准确的。

但是如果我们有个需求是累加1000万个0.3，该怎么办？

package main

import "fmt"

func main() {
	var sum float64
	var x float64 = 0.3
	for i := 0; i < 10000000; i++ {
		sum += x
	}
	fmt.Println(sum)
}

得到的结果显而易见是不正确的。

得到结果为$2.9999999996692175 \times10^6$，但是我们期望的结果是$3\times10^6$。

一个常见的应用场景是，在一些“积少成多”的计算过程中，比如在机器学习中，我们经常要计算海量样本计算出来的梯度或者 loss，于是会出现几亿个浮点数的相加。每个浮点数可能都差不多大，但是随着累积值的越来越大，就会出现“大数吃小数”的情况。这么大的误差显而易见是无法接受的。

当然，肯定有人已经解决了这个问题，并且已经封装好了库给你使用。但是你真的不想弄清楚这是如何避免精度的损失么？

golang decimal库

首先我们用一些别人封装好的库来实现避免精度的损失。

package main

import (
	"fmt"

	"github.com/shopspring/decimal"
)

func main() {
	var x float64 = 0.3
	sum := decimal.NewFromFloat(0.0)
	for i := 0; i < 10000000; i++ {
		newSum, _ := sum.Float64()
		sum = decimal.NewFromFloat(newSum).Add(decimal.NewFromFloat(x))
	}
	fmt.Println(sum)
}

结果完全正确，精度没有任何损失。

缺点就是很慢，因为库里面多了很多的转换等操作。

这是没有办法的事，所以在高性能的情况下，我们需要自己去实现优化，这就是学习数据结构与算法最大的用处了。

自己实现Kahan Summation

算法逻辑：

• 每次计算过程中，都用一次减法把当前加法计算中损失的精度记录下来
• 然后在后面的循环中，把这个精度损失放在要加的小数上
• 最后再做一次运算

package main

import "fmt"

func main() {
	var sum float64 = 0.0
	var c float64 = 0.0
    var x float64 = 0.3
	for i := 0; i < 10000000; i++ {
		y := x - c
		t := sum + y
		c = (t - sum) - y
		sum = t
	}
	fmt.Println(sum)
}

答案完全正确，是我们想要的结果。

我们将精度损失等变量的值打印出来。

package main

import (
	"fmt"
	"time"
)

func main() {
	var sum float64 = 0.0
	var c float64 = 0.0
	var x float64 = 0.3
	for i := 0; i < 10000000; i++ {
		y := x - c // 减法
		fmt.Printf("y: %.20f\n", y)
		t := sum + y // 相加有精度损失
		fmt.Printf("t: %.20f\n", t)
		c = (t - sum) - y //丢失的精度
		fmt.Printf("c: %.20f\n", c)
		sum = t
		fmt.Printf("sum: %.20f\n", sum)
		time.Sleep(time.Second)
	}
	fmt.Println(sum)
}

通过这么几行代码我们就实现了避免精度损失。所以算法还是蛮重要的哦！