在python中加速numpy循环？

考虑以下使用numpy数组的代码，这非常慢：

# Intersection of an octree and a trajectory
def intersection(octree, trajectory):
    # Initialize numpy arrays
    ox = octree.get("x")
    oy = octree.get("y")
    oz = octree.get("z")
    oe = octree.get("extent")/2
    tx = trajectory.get("x")
    ty = trajectory.get("y")
    tz = trajectory.get("z")
    result = np.zeros(np.size(ox))
    # Loop over elements
    for i in range(0, np.size(tx)):
        for j in range(0, np.size(ox)):
            if (tx[i] > ox[j]-oe[j] and 
                tx[i] < ox[j]+oe[j] and 
                ty[i] > oy[j]-oe[j] and 
                ty[i] < oy[j]+oe[j] and 
                tz[i] > oz[j]-oe[j] and 
                tz[i] < oz[j]+oe[j]):
                result[j] += 1
    # Finalize
    return result

#八叉树与轨迹的交点
def交叉点（八叉树，轨迹）：
#初始化numpy数组
ox=八叉树。获取（“x”）
oy=八叉树。获取（“y”）
oz=八叉树。获取（“z”）
oe=八叉树。获取（“范围”）/2
tx=轨迹。获取（“x”）
ty=轨迹。获取（“y”）
tz=轨迹。获取（“z”）
结果=np.零（np.大小（ox））
#环绕元件
对于范围（0，np.尺寸（tx））内的i：
对于范围（0，np.尺寸（ox））内的j：
如果（tx[i]>ox[j]-oe[j]和
tx[i]oy[j]-oe[j]和
ty[i]oz[j]-oe[j]和
tz[i]

---

如何重写函数以加速计算？（

np.size（tx）==10000

和

np.size（ox）==100000

）

您正在分配10000个大小为100000的列表。首先要做的是停止对嵌套的

j

循环使用

range

，而是使用生成器版本

xrange

。这将节省您分配所有这些列表的时间和空间

下一步是使用矢量化操作：

for i in xrange(0, np.size(tx)):
    index = (ox-oe < tx[i]) & (ox+oe > tx[i]) & (oy-oe < ty[i]) & (oy+oe > ty[i]) & (oz-oe < tz[i]) & (oz+oe > tz[i])
    result[index] += 1  

X范围（0，np.尺寸（tx））中的i的

指数=（ox oetx[i]）&（oy oety[i]）&（oz oetz[i]）
结果[索引]+=1

在PyPy下运行此代码可能会得到很好的结果：（上的NumPy集成说明）

我认为这将为双循环提供相同的结果，并且速度更快：

for j in xrange(np.size(ox)):
    result[j] += sum( abs(tx-ox[j])<oe[j] & abs(ty-oy[j])<oe[j] & abs(tz-oz[j])<oe[j] )

X范围内j的

（np.尺寸（ox））：
结果[j]+=sum（abs（tx ox[j]）你是否也考虑使用OpenCL？我不需要完整的性能，我只是想要一个原始的速度。从点TX，TY，TZ构建一个<代码> SimPix.Stult.KDTree < /C>，然后在无穷大范数中使用最邻近的查找，在Ox，Oy，Oz中的每个点上，看看是否有足够的点接近。你考虑过使用Cython吗？我已经读过了。给我一点时间，下一个就要来了：）好的，矢量化的形式是（可能需要检查条件），但是，当您修改了您的问题以回应我的原始答案时，部分答案变得无关紧要，即使这仍然是在数据不颠簸的情况下要做的一个很好的初始步骤：）