为啥 np.hypot 和 np.subtract.outer 与香草广播相比非常快？使用 Numba 并行加速 numpy 进行距离矩阵计算

Posted 2023-03-12

【中文标题】为啥 np.hypot 和 np.subtract.outer 与香草广播相比非常快？使用 Numba 并行加速 numpy 进行距离矩阵计算

【英文标题】：Why np.hypot and np.subtract.outer very fast compared to vanilla broadcast ? Using Numba for speedup numpy in parallel for distance matrix calculation为什么 np.hypot 和 np.subtract.outer 与香草广播相比非常快？使用 Numba 并行加速 numpy 进行距离矩阵计算

【发布时间】：2021-10-06 00:59:15

【问题描述】：

我有两组大的二维点，我需要计算一个距离矩阵。

我需要它在 python 中快速，所以显然我使用了 numpy。我最近了解了 numpy 广播并使用了它，而不是在 python 中循环 numpy 将在 C 中进行。

我真的认为广播是我所需要的，直到我看到其他方法比普通广播更好，我有两种计算距离矩阵的方法，我不明白为什么一种比另一种更好。

我在这里查看https://github.com/numpy/numpy/issues/14761，我得到了矛盾的结果。

以下是计算距离矩阵的两种方法

单元格 [3, 4, 6] 和 [8, 9] 都计算距离矩阵，但是 3+4 使用减法。outer 比使用 vanilla 广播的 8 快得多，而使用 hypot 的 6 比 9 快得多这是简单的方法。我没有尝试在 python 循环中假设它永远不会完成。

我想知道

1.有没有更快的方法来计算距离矩阵（可能是 scikit-learn 或 scipy）？

2。为什么hypot和subtract.outer这么快？

为方便起见，我还附加了 sn-p tp run whole thing 并更改种子以防止缓存重新启动

### Cell 1
import numpy as np

np.random.seed(858442)

### Cell 2
%%time
obs = np.random.random((50000, 2))
interp = np.random.random((30000, 2))

CPU times: user 2.02 ms, sys: 1.4 ms, total: 3.42 ms
Wall time: 1.84 ms

### Cell 3
%%time
d0 = np.subtract.outer(obs[:,0], interp[:,0])

CPU times: user 2.46 s, sys: 1.97 s, total: 4.42 s
Wall time: 4.42 s

### Cell 4
%%time
d1 = np.subtract.outer(obs[:,1], interp[:,1])

CPU times: user 3.1 s, sys: 2.7 s, total: 5.8 s
Wall time: 8.34 s

### Cell 5
%%time
h = np.hypot(d0, d1)

CPU times: user 12.7 s, sys: 24.6 s, total: 37.3 s
Wall time: 1min 6s

### Cell 6
np.random.seed(773228)

### Cell 7
%%time
obs = np.random.random((50000, 2))
interp = np.random.random((30000, 2))

CPU times: user 1.84 ms, sys: 1.56 ms, total: 3.4 ms
Wall time: 2.03 ms

### Cell 8
%%time
d = obs[:, np.newaxis, :] - interp
d0, d1 = d[:, :, 0], d[:, :, 1]

CPU times: user 22.7 s, sys: 8.24 s, total: 30.9 s
Wall time: 33.2 s

### Cell 9
%%time
h = np.sqrt(d0**2 + d1**2)

CPU times: user 29.1 s, sys: 2min 12s, total: 2min 41s
Wall time: 6min 10s

感谢Jérôme Richard here 更新

*** 永远不会让人失望 有一个更快的方法使用numba 它具有即时编译器，可以将 python sn-p 转换为快速机器码，第一次使用它会比后续使用慢一点，因为它会编译。但即使是第一次，njit 也比 (49000, 12000) 矩阵以 9 倍的边距击败了 hypot + minus.outer

各种方法的表现

确保每次运行脚本时使用不同的种子

import sys
import time

import numba as nb
import numpy as np

np.random.seed(int(sys.argv[1]))

d0 = np.random.random((49000, 2))
d1 = np.random.random((12000, 2))

def f1(d0, d1):
    print('Numba without parallel')
    res = np.empty((d0.shape[0], d1.shape[0]), dtype=d0.dtype)
    for i in nb.prange(d0.shape[0]):
        for j in range(d1.shape[0]):
            res[i, j] = np.sqrt((d0[i, 0] - d1[j, 0])**2 + (d0[i, 1] - d1[j, 1])**2)
    return res

# Add eager compilation, compiles before hand
@nb.njit((nb.float64[:, :], nb.float64[:, :]), parallel=True)
def f2(d0, d1):
    print('Numba with parallel')
    res = np.empty((d0.shape[0], d1.shape[0]), dtype=d0.dtype)
    for i in nb.prange(d0.shape[0]):
        for j in range(d1.shape[0]):
            res[i, j] = np.sqrt((d0[i, 0] - d1[j, 0])**2 + (d0[i, 1] - d1[j, 1])**2)
    return res

def f3(d0, d1):
    print('hypot + subtract.outer')
    np.hypot(
        np.subtract.outer(d0[:,0], d1[:,0]),
        np.subtract.outer(d0[:,1], d1[:,1])
    )

if __name__ == '__main__':
    s1 = time.time()
    eval(f'sys.argv[2](d0, d1)')
    print(time.time() - s1)

(base) ~/xx@xx:~/xx$ python3 test.py 523432 f3
hypot + subtract.outer
9.79756784439087
(base) xx@xx:~/xx$ python3 test.py 213622 f2
Numba with parallel
0.3393140316009521

如果我发现更快的方法，我会更新这篇文章以进行进一步的开发

【参考方案1】：

首先，d0 和 d1 分别采用了相当大的 50000 x 30000 x 8 = 12 GB。确保您有超过 100 GB 的内存，因为这是整个脚本所需要的！这是大量的内存。如果您没有足够的内存，操作系统将使用存储设备（例如交换）来存储速度较慢的多余数据。实际上，没有理由 Cell-4 比 Cell-3 慢，我猜你已经没有足够的内存来（完全）将d1 存储在 RAM 中，而d0 似乎（大部分）适合内存。当两者都可以放入 RAM 时，我的机器上没有区别（也可以颠倒操作顺序来检查这一点）。这也解释了为什么进一步的操作往往会变慢。

话虽如此，单元 8+9 也较慢，因为它们创建 临时数组 并且需要 更多的内存传递 来计算结果，而不是单元 3+4+5。实际上，表达式np.sqrt(d0**2 + d1**2) 首先在内存中计算d0**2，得到一个新的 12 GB 临时数组，然后计算 d1**2，得到另一个 12 GB 临时数组，然后对两个临时数组求和，生成另一个新的 12 GB 临时数组，最后计算平方根，得到另一个 12 GB 临时数组。这可能需要多达 48 GB 的内存，并且需要 4 次读写内存绑定通道。这效率不高，也不能有效地使用 CPU/RAM（例如 CPU 缓存）。

有一个更快的实现，包括使用 Numba 的 JIT 在 1 遍中并行执行整个计算。这是一个例子：

import numba as nb
@nb.njit(parallel=True)
def distanceMatrix(a, b):
    res = np.empty((a.shape[0], b.shape[0]), dtype=a.dtype)
    for i in nb.prange(a.shape[0]):
        for j in range(b.shape[0]):
            res[i, j] = np.sqrt((a[i, 0] - b[j, 0])**2 + (a[i, 1] - b[j, 1])**2)
    return res

此实现使用 3 倍的内存（仅 12 GB）并且比使用 subtract.outer 的实现快得多。事实上，由于交换，单元格 3+4+5 需要几分钟，而这个需要 1.3 秒！

要点是内存访问和临时数组一样昂贵。在处理巨大的缓冲区时需要避免在内存中使用多次传递，并在执行的计算不是微不足道时（例如通过使用数组块）利用 CPU 缓存。