python - Python 中的多重处理意外返回 None

Question

我正在尝试在 python 3.6(Anaconda 发行版)中启动多重处理。我已经大量测试了我的内部功能(数值积分)，所以我相信它可以工作。目前给我带来麻烦的是通过正确的范围，因为我得到了一些“无”返回。

import multiprocessing
from multiprocessing import Pool

def chunkwise(t, size=2):
    it = iter(t)
    return zip(*[it]*size)

def sint(tupl):
    print('arg = ',tupl)
    #lower = float(tupl[0])
    #upper = float(tupl[1])
    exit()
    #ans = scipy.integrate.quad(int2,lower,upper) 
    #return ans

n_CPUs = 6 

smin = float(10000)
smax = float(np.inf)
smax_spacing = float(2.5*10**12)
srange = np.linspace(smin,smax_spacing,n_CPUs)

srange = np.append(srange,np.inf)
print('length srange = ',len(srange))
filler=[]

for i in range(len(srange)):
    if i == 0:
        filler.append(float(srange[i]))
    elif srange[i] == srange[-1]:
        filler.append(float(srange[i]))
    else:
        filler.append(float(srange[i]))
        filler.append(float(srange[i]))
srange = np.array(filler)
srange = list(chunkwise(srange))

def main():
    pool = Pool(processes=n_CPUs)
    res1 = pool.map(sint,[(smin,float(smin*2)),  (float(smin*2),float(smin*3))])#srange)
    res = sum(res1)
    pool.close()
    pool.join()
    return res

if __name__ =="__main__":
    result = main()

我的一些调试过程可以在我在这里包含的代码中看到。目前，我只想查看传递给我的 sint() 函数的参数。当我打印结果时，我得到结果

arg = (number,bigger number)
None
arg = (number2, bigger number2)
None

为什么会出现这些“无”？目前，它们的存在导致了代码的非并行版本中不存在的溢出/NaN。有没有办法不让“无”出现？我尝试检查 tupl、lower 和 upper 中是否存在“None”，但 Python 似乎不想识别这些(不会打印我编写的消息“None detector”)。

任何帮助将不胜感激!如果需要更多信息，请告诉我。

Answer 1

一个问题是，多处理会为您编写的所有内容启动一个单独的进程，它完全创建一个单独的 Python 实例，因此您的代码实际上多次运行您放入全局范围内的所有内容。运行您的代码将返回

>>> length srange =  7
>>> length srange =  7

对我来说多次。您需要将其他代码移至单独的函数中，或者仅在 def main() 内部调用它。然而，修复此问题仍然会导致无结果，这似乎是由于您实际上没有在 pool.map 中的映射函数 smin 中返回任何内容。通常，您的结果将是 None 对象(并且 sum 也不能对任何对象求和)，但这里还有另一个问题。您的进程实际上并没有关闭。

这可能是因为你调用 exit，没有返回或任何东西，甚至没有 None。

您没有调用exit来结束映射函数，请查看multiprocessing查看那里的示例。只需使用普通函数作为映射器，无需使用系统调用。

尽管这不是您想要的，但这是一个简单的示例，通过您的示例展示实际运行的多处理代码:

编辑:我没有意识到您发布的大部分内容都不是必需的，我鼓励您在发布问题时制作最少的可验证示例，我已经缩小并更改了我最初发布的内容以进行实际集成，我也鼓励当您提出问题和编写自己的代码时，请使用正确的命名约定，sint 和 tupl 不是异常(exception)的描述性名称。我在这里所做的向您展示了如何使用您提供的相同 scipy 集成实用程序正确并行地进行集成。您可以将 integrated_function 替换为您自己的函数的代码，它的工作原理应该是相同的

from multiprocessing import Pool
from scipy import integrate


def integrated_function(x):
    return x ** 2


def integration_process(integration_range):
    print("thread launched, tuple = ", integration_range)
    lower = float(integration_range[0])
    upper = float(integration_range[1])
    y, err = integrate.quad(integrated_function, lower, upper)
    return y


def main():
    # notice how we put this inside this main function
    n_CPUs = 6
    total_integration_range = 60000
    integration_chunks = 6
    integration_step = total_integration_range / integration_chunks
    integration_ranges = [(i * integration_step, (i + 1) * integration_step) for i in range(integration_chunks)]
    pool = Pool(processes=n_CPUs)
    res1 = pool.map(integration_process, integration_ranges)  # srange)
    res = sum(res1)
    print(res)
    pool.close()
    pool.join()
    return res


if __name__ == "__main__":
    result = main()
    # thread launched, tuple = (0, 10000)
    # thread launched, tuple = (10000, 20000)
    # thread launched, tuple = (20000, 30000)
    # thread launched, tuple = (30000, 40000)
    # thread launched, tuple = (40000, 50000)
    # thread launched, tuple = (50000, 60000)
    # 72000000000000.0

如果您的函数足够复杂并且集成足够大，则多处理的开销应该足够低，以使其更快，请注意，使用线程内打印会导致您不希望的速度减慢，因此在调试之外我会鼓励您不要打印。

编辑:由于他们想要进行无限集成，我还将在此发布我的想法和代码附录，而不是将其留在注释中。

从技术上讲，即使具有无限积分范围，您实际上也不是无限积分，近似无限积分的具体数值方法超出了这个问题的范围，但是因为 scipy.ntegrate.quad是一个用途Gaussian Quadrature为了执行其集成(因此名称为“quad”)，它修复了此问题，并且可以将 np.inf 作为边界。不幸的是，我不知道如何保证此界限的连续性能，完成该界限可能比所有其他集成需要更长的时间，或者可能需要更少的时间，这意味着将工作划分为相等的 block 变得更加困难。但是，您只需要更改积分范围的最后一个界限，即可在范围中包含无穷大。

这个变化看起来像这样:

integration_ranges = [(i * integration_step, (i + 1) * integration_step) for i in range(integration_chunks)]
# we take the last element of the array, and all but the last element of the tuple, 
# and make a new tuple with np.inf as the last element
integration_ranges[-1] = integration_ranges[-1][:-1] + (np.inf,)

完成此操作后，您的最后一个界限应该以无穷大为界，因此您的总积分范围实际上将为 0 -> inf，即使 total_integration_range 不是无穷大