NumPy浮点数比较技巧

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个文章开发实战，手把手教大家学习《NumPy浮点数比较：避免直接等号判断》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

在处理NumPy浮点数数组时，由于浮点数的内在精度问题，直接使用`==`进行相等性判断往往不可靠。本文将详细介绍如何利用`numpy.isclose`函数，通过设置绝对容差（`atol`）和相对容差（`rtol`），实现对浮点数数组的健壮且灵活的近似相等比较，从而有效解决不同精度浮点数间的比较难题，确保数据处理的准确性。

引言：浮点数比较的陷阱

浮点数在计算机内部的表示方式决定了它们无法精确表示所有实数。因此，即使两个浮点数在数学上应该相等，由于计算或存储过程中的微小差异，它们在计算机中可能略有不同。例如，0.1 + 0.2在Python中并不精确等于0.3。当涉及到NumPy数组时，这种问题变得尤为突出，尤其是在需要比较来自不同源或经过不同计算路径的浮点数数组时。

考虑以下场景：

import numpy as np

e = np.array([0.8292222222222225, 0.1310000000000003]) 
print(e[0])
# 输出: 0.8292222222222225

print(e[0] == 0.829225)
# 输出: False

尽管0.8292222222222225和0.829225在肉眼看来非常接近，但直接的==操作符会返回False，因为它们的二进制表示不完全相同。用户可能希望将这些值视为“相等”，以进行逻辑判断或数据筛选。在这种情况下，我们需要的不是改变浮点数的底层精度（np.set_printoptions仅影响显示，不改变数值本身），而是进行一种“近似相等”的比较。

numpy.isclose：解决方案的核心

为了解决浮点数比较的固有问题，NumPy提供了numpy.isclose函数。这个函数允许我们在一定的容差范围内判断两个数组的对应元素是否“足够接近”，从而避免了直接相等性判断的局限性。

numpy.isclose的基本语法如下：

numpy.isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)

• a, b: 待比较的两个NumPy数组（或标量）。
• rtol (relative tolerance): 相对容差。它表示两个值之间的允许最大相对差异。默认值为1e-05。
• atol (absolute tolerance): 绝对容差。它表示两个值之间的允许最大绝对差异。默认值为1e-08。
• equal_nan: 布尔值，如果为True，则NaN与NaN被视为相等。

isclose的判断逻辑是：如果abs(a - b) <= (atol + rtol * abs(b))，则认为a和b是接近的。这意味着，当b的值很大时，相对容差rtol起主导作用；当b的值接近零时，绝对容差atol起主导作用。

理解容差参数：atol与rtol

选择合适的容差值是使用numpy.isclose的关键。

1. 绝对容差 (atol): atol指定了两个数值之间允许的最大绝对差值。它适用于以下情况：

   • 当比较的数值非常接近零时。
   • 当你知道允许的最大误差是一个固定的绝对量时。 例如，如果你希望两个值在小数点后5位是相同的，你可以设置atol=1e-5。

2. 相对容差 (rtol): rtol指定了两个数值之间允许的最大相对差值。它适用于以下情况：

   • 当比较的数值大小差异很大时，例如一个在1000量级，另一个在0.001量级。
   • 当误差与数值本身的大小成比例时。 例如，rtol=1e-5意味着允许的误差是较大数据值的万分之一。

通常情况下，我们同时使用atol和rtol，以覆盖各种数值范围。

实践示例

让我们使用numpy.isclose来解决前面提到的浮点数比较问题。

import numpy as np

a = np.array([0.8292222222222225, 0.1310000000000003])
b = np.array([0.8293, 0.132]) # 另一个数组，包含略有不同的值

print("原始数组 a:", a)
print("原始数组 b:", b)

# 示例 1: 使用较大的绝对容差 (atol=1e-3)
# 允许的误差范围较大，例如小数点后3位以内
print("\n使用 atol=1e-3 进行比较:")
result_1e3 = np.isclose(a, b, atol=1e-3)
print(result_1e3)
# 预期输出: [ True  True]
# 解释: 0.82922... 和 0.8293 差值约 0.00007，小于 0.001 (1e-3)。
#       0.13100... 和 0.132 差值约 0.001，等于 0.001 (1e-3)。

# 示例 2: 使用中等绝对容差 (atol=1e-4)
# 允许的误差范围缩小，例如小数点后4位以内
print("\n使用 atol=1e-4 进行比较:")
result_1e4 = np.isclose(a, b, atol=1e-4)
print(result_1e4)
# 预期输出: [ True False]
# 解释: 第一个元素仍为 True。第二个元素 0.13100... 和 0.132 差值约 0.001，大于 0.0001 (1e-4)。

# 示例 3: 使用较小的绝对容差 (atol=1e-5)
# 允许的误差范围进一步缩小，例如小数点后5位以内
print("\n使用 atol=1e-5 进行比较:")
result_1e5 = np.isclose(a, b, atol=1e-5)
print(result_1e5)
# 预期输出: [False False]
# 解释: 第一个元素 0.82922... 和 0.8293 差值约 0.00007，大于 0.00001 (1e-5)。
#       第二个元素 0.13100... 和 0.132 差值约 0.001，远大于 0.00001 (1e-5)。

# 示例 4: 结合 atol 和 rtol
# 假设我们希望在数值较大时使用相对误差，数值较小时使用绝对误差
c = np.array([1000.00001, 0.0000001])
d = np.array([1000.00002, 0.0000002])

print("\n结合 atol 和 rtol 进行比较:")
# 默认 rtol=1e-5, atol=1e-8
result_default = np.isclose(c, d)
print(f"默认容差: {result_default}") # 第一个元素 (1000.00001 vs 1000.00002) 差值 1e-5, 相对误差 1e-5 / 1000 = 1e-8, 满足 rtol。
                                  # 第二个元素 (1e-7 vs 2e-7) 差值 1e-7, 满足 atol=1e-8? 不满足，因为 1e-7 > 1e-8。
                                  # abs(1e-7 - 2e-7) = 1e-7
                                  # atol + rtol * abs(b) = 1e-8 + 1e-5 * 2e-7 = 1e-8 + 2e-12 ≈ 1e-8
                                  # 1e-7 > 1e-8，所以第二个为 False。
# 预期输出: [ True False]

result_custom = np.isclose(c, d, rtol=1e-7, atol=1e-6)
print(f"自定义容差 (rtol=1e-7, atol=1e-6): {result_custom}")
# 预期输出: [ True True]
# 解释: 第一个元素：差值 1e-5。rtol=1e-7, abs(b)=1000.00002。rtol*abs(b) = 1e-7 * 1000 = 1e-4。
#      1e-5 <= (1e-6 + 1e-4) 为 True。
#      第二个元素：差值 1e-7。atol=1e-6。1e-7 <= 1e-6 为 True。

注意事项与最佳实践

1. 理解浮点数本质: 始终记住浮点数不是精确的。numpy.isclose提供的是一种实用的近似比较方法，而不是改变数值本身的精度。
2. 选择合适的容差: 没有一个“万能”的容差值。atol和rtol的选择应基于你的具体应用场景、数据的量级以及对精度的要求。
   • 如果数据集中所有值都接近零，优先考虑atol。
   • 如果数据值范围很广，rtol通常更合适。
   • 在大多数情况下，同时设置atol和rtol是一个稳健的选择。
3. 避免直接修改数据精度: 用户在问题中提到“压缩值以进行相等性检查”，这通常不是处理浮点数比较的正确方法。直接截断或四舍五入浮点数会永久性地丢失信息，并可能引入新的误差，导致后续计算不准确。numpy.isclose通过比较逻辑而非数据修改来解决问题。
4. 性能考量: numpy.isclose是向量化操作，对于大型数组，其性能远优于手动循环比较。

总结

在NumPy中进行浮点数数组的相等性检查时，直接使用==操作符是不可靠的。numpy.isclose函数提供了一个强大而灵活的解决方案，通过引入绝对容差（atol）和相对容差（rtol），允许我们在可接受的误差范围内判断浮点数是否近似相等。理解并正确配置这些容差参数，是确保数值比较准确性和健壮性的关键。

今天关于《NumPy浮点数比较技巧》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！