在numpy中没有临时性的外部产品的非平凡总和

时间:2013-07-12 21:19:46

标签: python optimization numpy

我希望解决的实际问题是,给定一组 N 单位向量,另一组 M 向量计算每个单位向量的平均值每个 M 向量的点积的绝对值。本质上,这是计算两个矩阵的外积,并用绝对值进行求和和求平均值。

N M 不是太大,这并不难,有很多方法可以继续(见下文)。问题是当 N M 很大时,创建的临时值很大,并且对所提供的方法提供了实际限制。这个计算可以在不创建临时工的情况下完成吗?我遇到的主要困难是由于存在绝对值。是否存在“线程化”此类计算的一般技术?

作为示例,请考虑以下代码

N = 7
M = 5

# Create the unit vectors, just so we have some examples,
# this is not meant to be elegant
phi = np.random.rand(N)*2*np.pi
ctheta = np.random.rand(N)*2 - 1
stheta = np.sqrt(1-ctheta**2)
nhat = np.array([stheta*np.cos(phi), stheta*np.sin(phi), ctheta]).T

# Create the other vectors
m = np.random.rand(M,3)

# Calculate the quantity we desire, here using broadcasting.
S = np.average(np.abs(np.sum(nhat*m[:,np.newaxis,:], axis=-1)), axis=0)

这很好,S现在是一个长度 N 的数组,包含所需的结果。不幸的是,在这个过程中我们创建了一些潜在的巨大阵

的结果
np.sum(nhat*m[:,np.newaxis,:], axis=-1)

M X N 数组。当然,最终结果只是 N 的大小。开始增加 N M 的大小,我们很快就会遇到内存错误。

如上所述,如果不需要绝对值,那么我们可以按照以下步骤进行操作,现在使用einsum()

T = np.einsum('ik,jk,j', nhat, m, np.ones(M)) / M

即使对于非常大的 N M ,这也能很快地发挥作用。对于特定问题,我需要包含abs(),但更通用的解决方案(可能是更通用的ufunc)也会引起关注。

3 个答案:

答案 0 :(得分:3)

根据一些评论,似乎使用cython是最好的方法。我愚蠢地从未考虑过使用cython。事实证明,生成工作代码相对容易。

经过一番搜索,我把以下的cython代码放在​​一起。这是最通用的代码,可能不是编写它的最佳方式,并且可能更有效。即便如此,它只比原始问题中的einsum()代码慢了约25%,所以它不是太糟糕!它已被编写为显式工作,在原始问题中创建的数组(因此输入数组的假定模式) 尽管有这些警告,它确实为原始问题提供了一个合理有效的解决方案,并可以作为类似情况的起点。

import numpy as np
cimport numpy as np
import cython
DTYPE = np.float64
ctypedef np.float64_t DTYPE_t
cdef inline double d_abs (double a) : return a if a >= 0 else -a

@cython.boundscheck(False)
@cython.wraparound(False)
def process_vectors (np.ndarray[DTYPE_t, ndim=2, mode="fortran"] nhat not None,
                     np.ndarray[DTYPE_t, ndim=2, mode="c"] m not None) :
    if nhat.shape[1] != m.shape[1] :
        raise ValueError ("Arrays must contain vectors of the same dimension")
    cdef Py_ssize_t imax = nhat.shape[0]
    cdef Py_ssize_t jmax = m.shape[0]
    cdef Py_ssize_t kmax = nhat.shape[1] # same as m.shape[1]
    cdef np.ndarray[DTYPE_t, ndim=1] S = np.zeros(imax, dtype=DTYPE)
    cdef Py_ssize_t i, j, k
    cdef DTYPE_t val, tmp
    for i in range(imax) :
        val = 0
        for j in range(jmax) :
            tmp = 0
            for k in range(kmax) :
                tmp += nhat[i,k] * m[j,k]
            val += d_abs(tmp)
        S[i] = val / jmax
    return S

答案 1 :(得分:1)

我认为没有任何简单的方法(在Cython等之外)来加速你的确切操作。但是你可能想要考虑一下你是否真的需要计算你在计算什么。对于if而不是绝对值的平均值,你可以使用root mean square,你仍然会以某种方式平均内部产品的数量,但你可以一次性得到它:

rms = np.sqrt(np.einsum('ij,il,kj,kl,k->i', nhat, nhat, m, m, np.ones(M)/M))

这与做:

相同
rms_2 = np.sqrt(np.average(np.einsum('ij,kj->ik', nhat, m)**2, axis=-1))

是的,它并不完全符合您的要求,但我担心它会与您使用矢量化方法一样接近。如果您决定走这条路,请查看np.einsum对大型NM的效果如何:当传递过多参数和索引时,它会陷入困境。

答案 2 :(得分:0)

这有点慢,但不会创建大的中间矩阵。

vals = np.zeros(N)
for i in xrange(N):
    u = nhat[i]
    for v in m:
        vals[i]+=abs(np.dot(u,v))
    vals[i]=vals[i]/M

编辑:移动除以M之外的for循环。

edit2:新想法,为后代保留旧观念和相关评论。

m2 = np.average(m,0)
vals = np.zeros(N)
for i in xrange(N):
    u=nhat[i]
    vals[i]=abs(np.dot(u,m2))

这很快,但有时给出不同的价值,我正在研究为什么,但也许它可以帮助平均时间。

编辑3:啊,这是绝对有价值的东西。 HMM的

>>> S
array([ 0.28620962,  0.65337876,  0.37470707,  0.46500913,  0.49579837,
        0.29348924,  0.27444208,  0.74586928,  0.35789315,  0.3079964 ,
        0.298353  ,  0.42571445,  0.32535728,  0.87505053,  0.25547394,
        0.23964505,  0.44773271,  0.25235646,  0.4722281 ,  0.33003338])
>>> vals
array([ 0.2099343 ,  0.6532155 ,  0.33039334,  0.45366889,  0.48921527,
        0.20467291,  0.16585856,  0.74586928,  0.31234917,  0.22198642,
        0.21013519,  0.41422894,  0.26020981,  0.87505053,  0.1199069 ,
        0.06542492,  0.44145805,  0.08455833,  0.46824704,  0.28483342])

time to compute S: 0.000342130661011 seconds
time to compute vals: 7.29560852051e-05 seconds

编辑4:好吧,如果你的单位向量大多数是正值,那么这应该更快,假设m中的向量总是像你的虚数据中那样是正的。

m2 = np.average(m,0)
vals = np.zeros(N)
for i in xrange(N):
    u=nhat[i]
    if u[0] >= 0 and u[1] >= 0 and u[2] >= 0:
        vals[i] = abs(np.dot(u,m2))
    else:
        for j in xrange(M):
            vals[i]+=abs(np.dot(u,m[j]))
        vals[i]/=M