Skip to main content
 首页 » 编程设计

python之使用 einsum 对 numpy 进行进一步优化以进行堆叠矩阵向量乘法

2025年01月19日10birdshome

我有一个使用线性矩阵变换的“粒子传播”的相对简单的案例。

我的粒子分布基本上是一组(“束”)5 维向量。它通常包含 100k 到 1M 这样的向量。

这些向量中的每一个都必须乘以一个矩阵。

目前我想出的解决方案如下。

粒子是这样创建的,协方差矩阵在这里显示为对角线,但这是为了一个相对简单的例子:

# Edit: I now use np.random_intel linking to MKL for improved performances 
d = np.random.multivariate_normal( 
    [0.0, 
     0.0, 
     0.0, 
     0.0, 
     0.0 
     ], 
    np.array([ 
        [1.0, 0.0, 0.0, 0.0, 0.0], 
        [0.0, 1.0, 0.0, 0.0, 0.0], 
        [0.0, 0.0, 1.0, 0.0, 0.0], 
        [0.0, 0.0, 0.0, 1.0, 0.0], 
        [0.0, 0.0, 0.0, 0.0, 0.1] 
    ]), 
    int(1e5) 
) 

传播矩阵很简单

D = np.array([[1, 10, 0, 0],  
          [0, 1, 0, 0], 
          [0, 0, 1, 0], 
          [0, 0, 0, 1]]) 

我对 einsum 的解决方案是

r = np.einsum('ij,kj->ik', d[:, 0:4], D) 

(请注意,我在这里滑动以仅获取向量的前四个坐标,但原因无关)。

Is there a way to make this significantly faster?

我对所有细节都不是很清楚,但这里有一些想法:

  • einsum 默认情况下不调用 BLAS,但使用内部 SSE 优化,有没有一种方法可以用纯 BLAS 调用来表达我的问题,从而使其更快?
  • 显然 einsum 的最新版本有一个 optimize 选项,可以在更广泛的情况下打开以回退到 BLAS 调用。我试过了,它不会改变执行时间。
  • 使用 PyPy 和 numpy 会更好吗?

我测试了@Divakar 的建议,它确实更快(10M 粒子):

%%timeit 
r = d[:, 0:4].dot(D.T) 
# 541 ms ± 9.44 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) 

与我的初始相比

%%timeit -n 1 -r 1 
r = np.einsum('ij,kj->ik', d[:, 0:4], D, optimize=True) 
# 1.74 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 

可能影响最终答案的直接相关问题:

How can I deal with 'lost' particles?

在单个粒子矩阵乘法之后,我将检查一些坐标的上限,例如(r 是上一步的结果:

selected = (r[:, 0] < 0.1) & (r[:, 1] < 0.1) 
ind = np.where(selected) 
r[ind] 

然后应用r[ind]的下一轮矩阵乘法。

有些事情我不太清楚:

  • 这是最有效的吗?
  • 它不会创建太多副本吗?
  • “保留”未选择的粒子(并无论如何增加它们)同时跟踪它们丢失的事实(通过 mask )不是更好吗?这是更多的乘法运算,但可以将所有内容保存在一个对象中,无需进一步分配并保持所有内容对齐?

请您参考如下方法:

为了进一步提高@Divakar 建议的代码的性能,我宁愿建议使用 PyTorch图书馆。与使用 NumPy arrays 的普通点积 (np.dot()) 相比,这会给您超过 2 个数量级的加速。 (对于您的情况,从 ms 到微秒;稍后会详细介绍)

首先,我将演示如何在 NumPy 和 PyTorch 中执行此操作. (因为 PyTorch 与 NumPy ndarray 共享相同的内存,所以我们不需要做额外的工作)


时间

# setup inputs 
In [61]: d = np.random.multivariate_normal( 
    ...:     [0.0, 
    ...:      0.0, 
    ...:      0.0, 
    ...:      0.0, 
    ...:      0.0 
    ...:      ], 
    ...:     np.array([ 
    ...:         [1.0, 0.0, 0.0, 0.0, 0.0], 
    ...:         [0.0, 1.0, 0.0, 0.0, 0.0], 
    ...:         [0.0, 0.0, 1.0, 0.0, 0.0], 
    ...:         [0.0, 0.0, 0.0, 1.0, 0.0], 
    ...:         [0.0, 0.0, 0.0, 0.0, 0.1] 
    ...:     ]), 
    ...:     int(1e5) 
    ...: ) 
 
In [62]: d.dtype 
Out[62]: dtype('float64') 
 
In [63]: D = np.array([[1, 10, 0, 0],  
    ...:           [0, 1, 0, 0], 
    ...:           [0, 0, 1, 0], 
    ...:           [0, 0, 0, 1]], dtype=np.float64) 
    ...:            
 
In [64]: DT = D.T 
 
In [65]: DT.dtype 
Out[65]: dtype('float64') 
 
 
# create input tensors in PyTorch 
In [66]: d_tensor = torch.DoubleTensor(d[:, 0:4]) 
 
In [67]: DT_tensor = torch.DoubleTensor(DT) 
 
# float64 tensors 
In [69]: type(d_tensor), type(DT_tensor) 
Out[69]: (torch.DoubleTensor, torch.DoubleTensor) 
 
# dot/matmul using `np.dot()` 
In [73]: np_dot = np.dot(d[:, 0:4], DT) 
 
# matmul using `torch.matmul()` 
In [74]: torch_matmul = torch.matmul(d_tensor, DT_tensor) 
 
# sanity check!! :) 
In [75]: np.allclose(np_dot, torch_matmul) 
Out[75]: True 

现在是时候采用不同的方法了!

In [5]: %timeit r = np.einsum('ij,kj->ik', d[:, 0:4], D) 
2.63 ms ± 97.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 
 
In [6]: %timeit r = d[:, 0:4].dot(D.T) 
1.56 ms ± 47.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) 
 
In [7]: %timeit r = np.einsum('ij,kj->ik', d[:, 0:4], D, optimize=True) 
2.73 ms ± 136 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 
 
# over 2 orders of magnitude faster :) 
In [14]: %timeit torch_matmul = torch.matmul(d_tensor, DT_tensor) 
87 µs ± 7.71 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each) 

需要注意的一件重要事情是我们需要在 NumPy ndarray 中具有相同的数据类型和 PyTorch张量。 (这里我使用了 np.float64,因为 np.random.multivariate_normal 返回了 float64 值。所以,我向上转换了 D 矩阵到 float64。相应地,在创建 PyTorch 张量时,我使用了 torch.DoubleTensor 相当于 np.float64。这是一种数据类型匹配必须才能获得相同的结果,尤其是在处理 float 时)。


因此,关键要点是 PyTorch Tensor操作比 NumPy ndarray 快数量级操作。