Python Numpy:当一些向量元素等于零时,矩阵向量乘法不会跳过计算吗?
我最近一直在从事一个项目,其中我的大部分时间都花在将密集矩阵Python Numpy:当一些向量元素等于零时,矩阵向量乘法不会跳过计算吗?,python,numpy,matrix-multiplication,blas,Python,Numpy,Matrix Multiplication,Blas,我最近一直在从事一个项目,其中我的大部分时间都花在将密集矩阵a和稀疏向量v相乘上(请参阅)。在我减少计算的尝试中,我注意到A.dot(v)的运行时不受v的零条目数的影响 为了解释为什么我希望在这种情况下运行时会有所改进,让result=A.dot.v使j=1…v.shape[0]的result[j]=sum_I(A[I,j]*v[j])。如果v[j]=0,则无论值A[:,j]如何,结果[j]=0。在这种情况下,我希望numpy只设置result[j]=0,但不管怎样,它似乎继续计算sum_I(A
a
和稀疏向量v
相乘上(请参阅)。在我减少计算的尝试中,我注意到A.dot(v)
的运行时不受v
的零条目数的影响
为了解释为什么我希望在这种情况下运行时会有所改进,让result=A.dot.v
使j=1…v.shape[0]的result[j]=sum_I(A[I,j]*v[j])。如果v[j]=0
,则无论值A[:,j]
如何,结果[j]=0
。在这种情况下,我希望numpy只设置result[j]=0
,但不管怎样,它似乎继续计算sum_I(A[I,j]*v[j])
我继续写了一个简短的示例脚本来确认下面的行为
import time
import numpy as np
np.__config__.show() #make sure BLAS/LAPACK is being used
np.random.seed(seed = 0)
n_rows, n_cols = 1e5, 1e3
#initialize matrix and vector
A = np.random.rand(n_rows, n_cols)
u = np.random.rand(n_cols)
u = np.require(u, dtype=A.dtype, requirements = ['C'])
#time
start_time = time.time()
A.dot(u)
print "time with %d non-zero entries: %1.5f seconds" % (sum(u==0.0), (time.time() - start_time))
#set all but one entry of u to zero
v = u
set_to_zero = np.random.choice(np.array(range(0, u.shape[0])), size = (u.shape[0]-2), replace=False)
v[set_to_zero] = 0.0
start_time = time.time()
A.dot(v)
print "time with %d non-zero entries: %1.5f seconds" % (sum(v==0.0), (time.time() - start_time))
#what I would really expect it to take
non_zero_index = np.squeeze(v != 0.0)
A_effective = A[::,non_zero_index]
v_effective = v[non_zero_index]
start_time = time.time()
A_effective.dot(v_effective)
print "expected time with %d non-zero entries: %1.5f seconds" % (sum(v==0.0), (time.time() - start_time))
运行此操作,我得到矩阵向量乘法的运行时是相同的,无论我使用密集矩阵u
还是稀疏矩阵v
:
time with 0 non-zero entries: 0.04279 seconds
time with 999 non-zero entries: 0.04050 seconds
expected time with 999 non-zero entries: 0.00466 seconds
我想知道这是不是故意的?或者我在运行矩阵向量乘法的过程中遗漏了什么。就像健全性检查一样:我已经确保
numpy
链接到我机器上的BLAS库,并且两个数组都是C_连续的
(因为numpy调用BLAS显然需要这样做)。对于简单数组,Numpy不执行此类优化,但如果需要,可以使用稀疏矩阵,这样可以改进点积计时。
有关此主题的更多信息,请参阅:如何使用类似于的简单函数进行实验
def dot2(A,v):
ind = np.where(v)[0]
return np.dot(A[:,ind],v[ind])
In [352]: A=np.ones((100,100))
In [360]: timeit v=np.zeros((100,));v[::60]=1;dot2(A,v)
10000 loops, best of 3: 35.4 us per loop
In [362]: timeit v=np.zeros((100,));v[::40]=1;dot2(A,v)
10000 loops, best of 3: 40.1 us per loop
In [364]: timeit v=np.zeros((100,));v[::20]=1;dot2(A,v)
10000 loops, best of 3: 46.5 us per loop
In [365]: timeit v=np.zeros((100,));v[::60]=1;np.dot(A,v)
10000 loops, best of 3: 29.2 us per loop
In [366]: timeit v=np.zeros((100,));v[::20]=1;np.dot(A,v)
10000 loops, best of 3: 28.7 us per loop
完全迭代的Python实现将是:
def dotit(A,v, test=False):
n,m = A.shape
res = np.zeros(n)
if test:
for i in range(n):
for j in range(m):
if v[j]:
res[i] += A[i,j]*v[j]
else:
for i in range(n):
for j in range(m):
res[i] += A[i,j]*v[j]
return res
显然,这不会像编译的dot
那么快,但我希望测试的相对优势仍然适用。对于进一步的测试,您可以在cython
中实现它
请注意,v[j]
测试发生在迭代的深处
对于稀疏的v
(100个元素中有3个)测试可以节省时间:
In [374]: timeit dotit(A,v,True)
100 loops, best of 3: 3.81 ms per loop
In [375]: timeit dotit(A,v,False)
10 loops, best of 3: 21.1 ms per loop
但如果v
密集,则需要花费时间:
In [376]: timeit dotit(A,np.arange(100),False)
10 loops, best of 3: 22.7 ms per loop
In [377]: timeit dotit(A,np.arange(100),True)
10 loops, best of 3: 25.6 ms per loop
这不是BLAS开发人员的问题吗?也许忽略特殊情况更简单,甚至更快。测试和分支可能和简单的乘法一样昂贵。@hpaulj它可能是。我不确定它是否真的应该是内置的,我只是不想让它工作,或者他们不是故意的。下面的答案很有帮助,但我想在文档中确认一下。如果它不是内置的,我可能必须在这一点上自己实现:-/但是
A
和v
必须非常稀疏,才能比np.dot
更快。sparse
乘法是根据特定的数据表示法定制的,它基于几十年前的一篇数学论文。感谢您的这篇文章——它帮助我看到了在迭代过程中深入进行v[j]
测试时的权衡。作为跟进,您是否有理由不在外循环中对范围(m)内的j使用?我想到的循环看起来像:nnz_cols=np.flatnonzero(v);对于nnz_cols中的j:val=0.0;对于范围(n)内的i:val+=A[i,j]*v[j];res[i]=val
?。自由地进行实验。较少的if
测试可能会稍微改变相对时间平衡。