Python—装载阵列的多重处理

我正在使用griddata“挂载”具有大量形状和形状的数组 我想知道我是否可以在我的4个内核上计算每个内核的函数（在每个片上），以加速这个过程

import numpy

size = 8.
Y=(arange(2000))
X=(arange(2000))
(xx,yy)=meshgrid(X,Y)

array=zeros((Y.shape[0],X.shape[0],size))

array[:,:,0] = 0
array[:,:,1] = X+Y
array[:,:,2] = X**2+Y**2+X+Y
array[:,:,3] = X**3+Y**3+X**2+Y**2+X+Y

array[:,:,4] = X**4+Y**4+X**3+Y**3+X**2+Y**2+X+Y
array[:,:,5] = X**5+Y**5+X**4+Y**4+X**3+Y**3+X**2+Y**2+X+Y
array[:,:,6] = X**6+Y**6+X**5+Y**5+X**4+Y**4+X**3+Y**3+X**2+Y**2+X+Y
array[:,:,6] = X**7+Y**7+X**6+Y**6+X**5+Y**5+X**4+Y**4+X**3+Y**3+X**2+Y**2+X+Y

所以这里我想用第一个核计算数组[：，：，0]&数组[：，：，1]，然后用第二个核计算数组[：，：，2]&数组[：，：，3]

----以后编辑---

不同的“切片”之间没有联系……我的不同功能是独立的

array[:,:,0] = 0
array[:,:,1] = X+Y
array[:,:,2] = X*np.cos(X)+Y*np.sin(Y)
array[:,:,3] = X**3+np.sin(X)+X**2+Y**2+np.sin(Y)
...

---

您可以尝试使用

多处理.Pool

：

from multiprocessing import Pool
import numpy as np

size = 8.
Y=(np.arange(2000))
X=(np.arange(2000))
(xx,yy)=np.meshgrid(X,Y)

array=np.zeros((Y.shape[0],X.shape[0],size))

def func(i): # you need to call a function with Pool
    array_=np.zeros((Y.shape[0],X.shape[0]))
    for j in range(1,i):
        array_+=X**j+Y**j
    return array_

if __name__ == '__main__':
    p = Pool(4) # if you have 4 cores in your processor
    result=p.map(func, range(1,8))
    for i in range(1,8):
        array[::,::,i]=result[i-1]

请记住，python中的多处理不会共享内存，这就是为什么必须创建数组并在代码末尾添加for循环的原因。 由于您的应用程序（具有这些维度）不需要大量的计算时间，因此使用这种方法可能会比较慢。您还将创建所有变量的多个副本，这可能会导致内存溢出。 您还应该仔细检查我编写的

func

，因为我没有完全验证它是否完成了它应该做的事情：）

三件事：

最重要的问题是

您的NumPy版本可能已经在使用多个内核。我不知道该如何检查，或者如果绝对必要的话，看看Numexpr库

关于您可能遇到的XY问题中的“Y”-您正在重新计算可以重复使用的数据：

---

如果要在数据数组上应用单个函数，则使用例如

多处理.Pool

是一个很好的解决方案，前提是计算的输入和输出都相对较小

您需要对两个输入数组执行许多不同的计算，这将导致为每一个计算返回一个数组

由于单独的进程不共享内存，因此X和Y阵列在启动时必须传输到每个工作进程。每次计算的结果（也是一个与X和Y大小相同的numpy数组）都必须返回给父进程

根据阵列的大小和内核的数量，通过进程间通信（“IPC”）在工作进程和父进程之间传输所有这些阵列的开销将花费时间，从而降低使用多个内核的优势

请记住，父进程必须侦听并处理来自所有工作进程的IPC请求。因此，您已经将瓶颈从计算转移到了通信

因此，在这种情况下，多处理实际上并不能提高性能。这取决于实际问题的细节（核心数量、阵列大小、物理内存量等）

---

您必须使用实际数组大小的

池

或

过程

进行一些仔细的性能测量。

对于第三点，这只是一个示例，我不能重复计算。在这种情况下，请询问您的实际问题。我的意思是，我的不同函数之间没有联系。不过，您应该检查第二点。的确，Numpy大量使用多处理。尝试使用Numpy函数计算所需的内容。在ubuntu中，您可以通过htop在windows中通过任务管理器查看处理器的活动。@MrE根据所使用的BLAS库，类似于

numpy.dot

的内容可能会被并行化。如果

导入numpy.core.\u dotblas

成功，那么您就有了一个快速的BLAS实现。很抱歉，在我的情况下，我的函数之间没有链接…所以我不能写：“对于范围（1，i）中的j:array\uj+=Xj+Yj”，然后您可以对每个函数使用

多处理.Process

：它将启动一个独立的（仍然没有共享内存）处理数组的每个维度，您将必须通过收集各种retun（例如，使用队列）来重新构建数组（就像我所做的那样）。如果您对不同的数组大量使用相同的函数，那么这项工作可能是值得的。如果您认为它可以工作，我可以帮助您编写多处理部分的代码。谢谢您的帮助，但是当我计算有无多处理的时间时……我发现没有多处理我会更快：s–在您的情况下，是的，这是很有可能的。Python中的多处理对于应该同时运行的长任务和重复任务非常有用，而不是小任务。正如@E先生所说，现在提高执行时间的唯一方法是简化数学和分组计算。

import numpy

size = 8
Y=(arange(2000))
X=(arange(2000))
(xx,yy)=meshgrid(X,Y)

array = zeros((Y.shape[0], X.shape[0], size))

array[..., 0] = 0    
for i in range(1, size):
    array[..., 1] = X ** i + Y ** i + array[..., i - 1]