来自 joblib 的多处理不会并行化？

Question

由于我从 python3.5 移动到 3.6，使用 joblib 的并行计算并没有减少计算时间。以下是安装的库版本：-python：3.6.3-joblib：0.11-numpy：1.14.0

基于一个非常著名的例子，我在下面给出了一个示例代码来重现这个问题：

import time
import numpy as np
from joblib import Parallel, delayed

def square_int(i):
    return i * i

ndata = 1000000 
ti = time.time()
results = []    
for i in range(ndata):
    results.append(square_int(i))

duration = np.round(time.time() - ti,4)
print(f"standard computation: {duration} s" )

for njobs in [1,2,3,4] :
    ti = time.time()  
    results = []
    results = Parallel(n_jobs=njobs, backend="multiprocessing")\
        (delayed(square_int)(i) for i in range(ndata))
    duration = np.round(time.time() - ti,4)
    print(f"{njobs} jobs computation: {duration} s" )

我得到以下输出：

• 标准计算：0.2672 秒
• 1 个作业计算：352.3113 秒
• 2 个作业计算：6.9662 秒
• 3 个作业计算：7.2556 秒
• 4 个作业计算：7.097 秒

当我将 ndata 的数量增加 10 倍并删除 1 个核心计算时，我得到了这些结果：

• 标准计算：2.4739 秒
• 2 个作业计算：77.8861 秒
• 3 个作业计算：79.9909 秒
• 4 个作业计算：83.1523 秒

有没有人知道我应该调查哪个方向？

Answer 1

我认为主要原因是并行的开销超过了好处。换句话说，您square_int太简单了，无法通过并行获得任何性能改进。这square_int很简单，在进程之间传递输入和输出可能比执行函数花费更多的时间square_int。

我通过创建一个square_int_batch函数修改了你的代码。它大大减少了计算时间，尽管它仍然比串行实现要多。

import time
import numpy as np
from joblib import Parallel, delayed

def square_int(i):
    return i * i

def square_int_batch(a,b):
    results=[]
    for i in range(a,b):
        results.append(square_int(i))
    return results

ndata = 1000000 
ti = time.time()
results = []    
for i in range(ndata):
    results.append(square_int(i))

# results = [square_int(i) for i in range(ndata)]

duration = np.round(time.time() - ti,4)
print(f"standard computation: {duration} s" )

batch_num = 3
batch_size=int(ndata/batch_num)

for njobs in [2,3,4] :
    ti = time.time()  
    results = []
    a = list(range(ndata))
#     results = Parallel(n_jobs=njobs, )(delayed(square_int)(i) for i in range(ndata))
#     results = Parallel(n_jobs=njobs, backend="multiprocessing")(delayed(
    results = Parallel(n_jobs=njobs)(delayed(
        square_int_batch)(i*batch_size,(i+1)*batch_size) for i in range(batch_num))
    duration = np.round(time.time() - ti,4)
    print(f"{njobs} jobs computation: {duration} s" )

计算时间是

standard computation: 0.3184 s
2 jobs computation: 0.5079 s
3 jobs computation: 0.6466 s
4 jobs computation: 0.4836 s

其他一些有助于减少时间的建议。

1. results = [square_int(i) for i in range(ndata)]在您的特定情况下使用列表理解替换 for 循环，它更快。我测试过。
2. 设置batch_num为合理的大小。该值越大，开销越大。batch_num在我的情况下，当超过 1000时，它开始变得明显变慢。
3. 我使用默认后端loky而不是multiprocessing. 它稍微快一点，至少在我的情况下。

从其他一些 SO 问题中，我了解到多处理适用于CPU 密集型任务，对此我没有官方定义。你可以自己探索一下。