并行化numpy的矢量运算

Question

让我们使用，例如，numpy.sin()

下面的代码将返回正弦的值的阵列a的每个值：

import numpy 
a = numpy.arange(1000000) 
result = numpy.sin(a) 

但是我的机具有32个内核，所以我想利用它们。 （对于像numpy.sin()之类的东西，开销可能不值得，但是我实际上想要使用的功能相当复杂一些，并且我将使用大量的数据。）

这是最好的（阅读：最聪明或最快）方法：

from multiprocessing import Pool 
if __name__ == '__main__': 
    pool = Pool() 
    result = pool.map(numpy.sin, a) 

还是有更好的方法来做到这一点？

Answer 1

有是一个更好的办法：numexpr

略从他们的主页改写：

这是一个多线程的虚拟机用C写的，分析的表达，更有效地改写他们，并编译它们飞入代码，获得接近最佳并行性能的内存和cpu有界操作。

例如，在我的4核心机器中，评估一个正弦比numpy略快四倍。

In [1]: import numpy as np 
In [2]: import numexpr as ne 
In [3]: a = np.arange(1000000) 
In [4]: timeit ne.evaluate('sin(a)') 
100 loops, best of 3: 15.6 ms per loop  
In [5]: timeit np.sin(a) 
10 loops, best of 3: 54 ms per loop 

文档，包括支持的函数here。你必须检查或给我们更多的信息，看看你的更复杂的功能可以通过numexpr来评估。

Answer 2

SciPy的实际上有关于这个问题在这里一个非常好的书面记录：http://wiki.scipy.org/ParallelProgramming

Answer 3

嗯，这是一种有趣的注意，如果你运行下面的命令：

import numpy 
from multiprocessing import Pool 
a = numpy.arange(1000000)  
pool = Pool(processes = 5) 
result = pool.map(numpy.sin, a) 

UnpicklingError: NEWOBJ class argument has NULL tp_new 

没想到的是，有啥继续，以及：

>>> help(numpy.sin) 
    Help on ufunc object: 

sin = class ufunc(__builtin__.object) 
| Functions that operate element by element on whole arrays. 
| 
| To see the documentation for a specific ufunc, use np.info(). For 
| example, np.info(np.sin). Because ufuncs are written in C 
| (for speed) and linked into Python with NumPy's ufunc facility, 
| Python's help() function finds this page whenever help() is called 
| on a ufunc. 

yep numpy.sin在c中实现，因此您不能直接在多处理中使用它。

，所以我们有另一个函数把它包起来

PERF：

import time 
import numpy 
from multiprocessing import Pool 

def numpy_sin(value): 
    return numpy.sin(value) 

a = numpy.arange(1000000) 
pool = Pool(processes = 5) 

start = time.time() 
result = numpy.sin(a) 
end = time.time() 
print 'Singled threaded %f' % (end - start) 
start = time.time() 
result = pool.map(numpy_sin, a) 
pool.close() 
pool.join() 
end = time.time() 
print 'Multithreaded %f' % (end - start) 


$ python perf.py 
Singled threaded 0.032201 
Multithreaded 10.550432 

哇，没想到，要么，我们甚至使用python的功能以及那里有对于初学者几个问题如果它只是一个包装器与一个纯c函数，并且也是复制值的开销，那么默认情况下多处理器不会共享数据，因为每个值都需要前后复制。

也指出，如果得到适当的细分我们的数据：

import time 
import numpy 
from multiprocessing import Pool 

def numpy_sin(value): 
    return numpy.sin(value) 

a = [numpy.arange(100000) for _ in xrange(10)] 
pool = Pool(processes = 5) 

start = time.time() 
result = numpy.sin(a) 
end = time.time() 
print 'Singled threaded %f' % (end - start) 
start = time.time() 
result = pool.map(numpy_sin, a) 
pool.close() 
pool.join() 
end = time.time() 
print 'Multithreaded %f' % (end - start) 

$ python perf.py 
Singled threaded 0.150192 
Multithreaded 0.055083 

那么，我们能从这个取，多是伟大的，但我们应该始终测试，有时比较一下它的速度更快，有时它更慢，取决于如何其使用...

授予您没有使用numpy.sin但另一个函数我建议您首先验证确实多处理会加快计算速度，也许前后复制值的开销可能会影响到您。

无论哪种方式，我还认为，使用pool.map是多线程代码是最好的，最安全的方法...

我希望这有助于。