我正在编写一个必须计算大量特征值问题的代码（典型的矩阵维数是几百个）。我想知道是否可以使用IPython.parallel模块来加速该过程。作为一名前MATLAB用户和Python新手，我正在寻找类似于MATLAB的parfor ......
在网上学习了一些教程后，我编写了一个简单的代码来检查它是否能加速计算，我发现它没有，并且经常会减慢它（取决于案例）。我想，我可能会忽略其中的一点，也许scipy.linalg.eig的实现方式是它使用所有可用的内核，并尝试并行化它，我会中断引擎管理。
这是'parralel'代码：
import numpy as np
from scipy.linalg import eig
from IPython import parallel
#create the matrices
matrix_size = 300
matrices = {}
for i in range(100):
matrices[i] = np.random.rand(matrix_size, matrix_size)
rc = parallel.Client()
lview = rc.load_balanced_view()
results = {}
#compute the eigenvalues
for i in range(len(matrices)):
asyncresult = lview.apply(eig, matrices[i], right=False)
results[i] = asyncresult
for i, asyncresult in results.iteritems():
results[i] = asyncresult.get()
非并行化变体：
#no parallel
for i in range(len(matrices)):
results[i] = eig(matrices[i], right=False)
两者的CPU时间差异非常微妙。如果在特征值问题之上，并行化函数必须进行更多的矩阵运算，它将开始永远持续，即至少比非并行化变量长5倍。
我是对的，特征值问题并不适合这种并行化，还是我错过了重点？
非常感谢！
根据moarningsun的建议，我尝试在修复eig的线程数时运行mkl.set_num_threads。对于500乘500的矩阵，最小50次重复设置如下：
No of. threads minimum time(timeit) CPU usage(Task Manager)
=================================================================
1 0.4513775764796151 12-13%
2 0.36869288559927327 25-27%
3 0.34014644287680085 38-41%
4 0.3380558903450037 49-53%
5 0.33508234276183657 49-53%
6 0.3379019065051807 49-53%
7 0.33858615048501406 49-53%
8 0.34488405094054997 49-53%
9 0.33380300334101776 49-53%
10 0.3288481198342197 49-53%
11 0.3512653110685733 49-53%
除了一个线程案例外，没有实质性区别（可能50个样本有点小......）。我仍然认为我错过了这一点，并且可以做很多事情来提高性能，但不确定如何。 这些是在4核计算机上运行的，启用了超线程，可以提供4个虚拟核心。
感谢您的任何意见！
答案 0 :(得分：3)
有趣的问题。因为我认为应该可以实现更好的缩放，我用一个小的“基准”调查了性能。通过此测试，我将单线程和多线程eig（通过MKL LAPACK / BLAS例程传递的多线程）与IPython并行化eig的性能进行了比较。为了看看它会有什么不同，我改变了视图类型，引擎数量和MKL线程，以及在引擎上分配矩阵的方法。
以下是旧AMD双核系统的结果：
m_size=300, n_mat=64, repeat=3
+------------------------------------+----------------------+
| settings | speedup factor |
+--------+------+------+-------------+-----------+----------+
| func | neng | nmkl | view type | vs single | vs multi |
+--------+------+------+-------------+-----------+----------+
| ip_map | 2 | 1 | direct_view | 1.67 | 1.62 |
| ip_map | 2 | 1 | loadb_view | 1.60 | 1.55 |
| ip_map | 2 | 2 | direct_view | 1.59 | 1.54 |
| ip_map | 2 | 2 | loadb_view | 0.94 | 0.91 |
| ip_map | 4 | 1 | direct_view | 1.69 | 1.64 |
| ip_map | 4 | 1 | loadb_view | 1.61 | 1.57 |
| ip_map | 4 | 2 | direct_view | 1.15 | 1.12 |
| ip_map | 4 | 2 | loadb_view | 0.88 | 0.85 |
| parfor | 2 | 1 | direct_view | 0.81 | 0.79 |
| parfor | 2 | 1 | loadb_view | 1.61 | 1.56 |
| parfor | 2 | 2 | direct_view | 0.71 | 0.69 |
| parfor | 2 | 2 | loadb_view | 0.94 | 0.92 |
| parfor | 4 | 1 | direct_view | 0.41 | 0.40 |
| parfor | 4 | 1 | loadb_view | 1.62 | 1.58 |
| parfor | 4 | 2 | direct_view | 0.34 | 0.33 |
| parfor | 4 | 2 | loadb_view | 0.90 | 0.88 |
+--------+------+------+-------------+-----------+----------+
如您所见，不同设置的性能增益差别很大，最多为常规多线程eig的1.64倍。在这些结果中，您使用的parfor函数表现不佳，除非在引擎上禁用MKL线程（使用view.apply_sync(mkl.set_num_threads, 1)）。
改变矩阵大小也给出了值得注意的差异。在ip_map上使用direct_view加速4个引擎和MKL线程与常规多线程eig的比较：
n_mat=32, repeat=3
+--------+----------+
| m_size | vs multi |
+--------+----------+
| 50 | 0.78 |
| 100 | 1.44 |
| 150 | 1.71 |
| 200 | 1.75 |
| 300 | 1.68 |
| 400 | 1.60 |
| 500 | 1.57 |
+--------+----------+
显然对于相对较小的矩阵存在性能损失，对于中间大小，加速是最大的，对于较大的矩阵，加速再次降低。在我看来，我可以获得1.75的性能提升，这将使IPython.parallel值得使用。
我之前在英特尔双核笔记本电脑上做过一些测试，但我得到了一些有趣的结果，显然笔记本电脑过热了。但在该系统上，加速通常略低，大约1.5-1.6。
现在我认为你的问题的答案应该是：这取决于。性能增益取决于硬件，BLAS / LAPACK库，问题大小和部署IPython.parallel的方式，以及其他可能我不知道的事情。最后但并非最不重要的是，它是否值得，还取决于你认为有多大的性能提升是值得的。
我使用的代码：
from __future__ import print_function
from numpy.random import rand
from IPython.parallel import Client
from mkl import set_num_threads
from timeit import default_timer as clock
from scipy.linalg import eig
from functools import partial
from itertools import product
eig = partial(eig, right=False) # desired keyword arg as standard
class Bench(object):
def __init__(self, m_size, n_mat, repeat=3):
self.n_mat = n_mat
self.matrix = rand(n_mat, m_size, m_size)
self.repeat = repeat
self.rc = Client()
def map(self):
results = map(eig, self.matrix)
def ip_map(self):
results = self.view.map_sync(eig, self.matrix)
def parfor(self):
results = {}
for i in range(self.n_mat):
results[i] = self.view.apply_async(eig, self.matrix[i,:,:])
for i in range(self.n_mat):
results[i] = results[i].get()
def timer(self, func):
t = clock()
func()
return clock() - t
def run(self, func, n_engines, n_mkl, view_method):
self.view = view_method(range(n_engines))
self.view.apply_sync(set_num_threads, n_mkl)
set_num_threads(n_mkl)
return min(self.timer(func) for _ in range(self.repeat))
def run_all(self):
funcs = self.ip_map, self.parfor
n_engines = 2, 4
n_mkls = 1, 2
views = self.rc.direct_view, self.rc.load_balanced_view
times = []
for n_mkl in n_mkls:
args = self.map, 0, n_mkl, views[0]
times.append(self.run(*args))
for args in product(funcs, n_engines, n_mkls, views):
times.append(self.run(*args))
return times
Dunno如果重要但是要启动我在命令行输入的4个IPython并行引擎：
ipcluster start -n 4
希望这会有所帮助：）