Skip to main content
 首页 » 编程设计

Python multiprocessing.Pool 忽略类方法

2024年10月25日18softidea

我最近为我的研究编写了一个包含类的程序,并且我尝试对其进行并行化。当我将 Python 2.7 的 multiprocessing.Process 与 JoinableQueue 和托管数据一起使用时,我的程序最终会因已停用的进程而挂起。

import multiprocessing as mp 
import traceback 
 
class Paramfit(object): 
    def __init__(self): 
        pass 
 
    def _calc_bond(self, index): 
        # Calculate data 
 
    def _calc_parallel(self, index): 
        self._calc_bond(index) 
 
    def run(self): 
        for ts, force in itertools.izip(self.coortrj, self.forcevec): 
        try: 
            consumers = [mp.Process(target=self._calc_parallel, 
                         args=(force,)) for i in range(nprocs)] 
            for w in consumers: 
                w.start() 
 
            # Enqueue jobs 
            for i in range(self.totalsites): 
                self.tasks.put(i) 
 
            # Add a poison pill for each consumer 
            for i in range(nprocs): 
                self.tasks.put(None) 
 
            self.tasks.close() 
            self.tasks.join() 
 
    #       for w in consumers: 
    #           w.join() 
        except: 
            traceback.print_exc() 

_calc_parallel 调用一些其他类方法。

我什至尝试使用 multiprocessing.Pool 为此目的使用 copy_reg 选项,如在 http://bytes.com/topic/python/answers/552476-why-cant-you-pickle-instancemethods 的其他地方找到的那样.

import multiprocessing as mp 
import traceback 
 
class Paramfit(object): 
    def __init__(self): 
        pass 
 
    def _calc_bond(self, index): 
        # Calculate data 
 
    def _use_force(force): 
        # Calculate data 
 
    def _calc_parallel(self, index, force): 
        self._calc_bond(index) 
        self._use_force(force) 
 
    def run(self): 
        try: 
            pool = mp.Pool(processes=nprocs, maxtasksperchild=2) 
            args = itertools.izip(range(self.totalsites), itertools.repeat(force)) 
            pool.map_async(self._calc_parallel, args) 
            pool.close() 
            pool.join() 
        except: 
            traceback.print_exc() 

然而,pool.map_async 似乎并没有调用 self._calc_parallel。我知道在这两种情况下(进程和池),我都忽略了一些东西,但我不太清楚是什么。我通常处理超过 40,000 个元素。

感谢您的帮助。

更新

阅读其他几篇文章后,我还尝试了 pathos.multiprocessing。

import pathos.multiprocessing as mp 
class Paramfit(object): 
    def __init__(self): 
        pass 
 
    def _calc_bond(self, index): 
        # Calculate data 
 
    def _use_force(force): 
        # Calculate data 
 
    def _calc_parallel(self, index, force): 
        self._calc_bond(index) 
        self._use_force(force) 
 
    def run(self): 
        try: 
            pool = mp.ProcessingPool(nprocs) 
            args = itertools.izip(range(self.totalsites), itertools.repeat(force)) 
            pool.amap(lambda x: self._calc_parallel(*x), args) 
        except: 
            traceback.print_exc() 

而且,与我之前的尝试一样,这似乎也可以在不调用方法的情况下快速完成。

更新 2

我决定修改代码,将庞大的类拆分为更小、更易于管理的组件。但是,如果我使用 pathos.multiprocessing,我会遇到与之前发布的情况不同的情况(请参阅 link)。我的新代码现在有一个可用于计算的对象,然后通过它的方法应该返回一个值。

import itertools 
import pandas as pd 
import pathos.multiprocessing as mp 
 
class ForceData(object): 
    def __init__(self, *args, **kwargs): 
        # Setup data 
        self.value = pd.DataFrame() 
    def calculateBondData(self, index): 
        # Calculation 
        return self.value 
    def calculateNonBondedData(self, index): 
        # Calculation 
        return self.value 
    def calculateAll(self, index): 
        # Because self.value is a pandas.DataFrame, changed internally 
        self.calculateBondData(index) 
        self.calculateNonBondedData(index) 
        return self.value 
 
class ForceMatrix(object): 
    def __init__(self, *args, **kwargs): 
        # Initialize data 
        self._matrix = pd.DataFrame() 
    def map(self, data): 
        for value in data.get(): 
            for i, j in itertools.product(value.index, repeat=2): 
                self._matrix.loc[[i], [j]] += value.values 
 
def calculate(self, *args, **kwargs): 
    # Setup initial information. 
    fd = ForceData() 
    matrix = ForceMatrix() 
    pool = mp.ProcessingPool() 
    data = pool.amap(fd.calculateAll, range(x)) 
    matrix.map(data, force) 
    return matrix 

我认为一个单独的函数func(dataobj, force),但这似乎也没有帮助。按照目前的速度,我估计单个处理器上的完整计算需要 1000 多个小时,这对于应该更快的东西来说太长了。

更新 3 (4/30/15)

由于@MikeMcKerns 的有用见解,我可能已经确定了一个可能的解决方案。在 iMac(四核)或集群的 16 核节点上,我发现,对于没有键的粗粒度(CG)系统,双 itertools.imap 似乎be my best solution (1000 CG sites) clocks in at about 5.2 s per trajectory frame.当我进入一个包含一些债券细节的系统(3000 个 CG 站点代表水)时,我发现在 iMac(使用 1 个内核)上,itertools.imap 后跟 pathos.ThreadingPool .uimap(4 个线程)以大约 85 秒/帧的速度进入;如果我按照@MikeMcKerns 的评论中的建议尝试进程池(4 核 x 2)/线程池(4 线程),计算时间增加了 2.5 倍。在 16 核集群 (32 pp/16 tp) 上,此 CG 系统也运行缓慢(约 160 秒/帧)。在 iMac(1 核/4 线程)上具有 42,778 个站点和大量绑定(bind)的 CG 系统可能会在 58 分钟/帧左右计时。我还没有在集群的 16 核节点上测试这个大型系统,但我不确定使用进程池/线程池是否可以进一步加速它。

示例:

# For a CG system with no bond details 
for i in range(nframes): 
    data1 = itertools.imap(func1, range(nsites)) 
    data2 = itertools.imap(func2, data1) 
    for values in data2: 
        func3(values) 
 
# For a system with bond details 
import pathos.multiprocessing as mp 
 
tpool = mp.ThreadingPool(mp.cpu_count()) 
for i in range(nframes): 
    data1 = itertools.imap(func1, range(nsites)) 
    data2 = tpool.uimap(func2, data1) 
    for values in data2: 
        func3(values) 
 
# Seems to be the slowest in the bunch on iMac and possibly on 16-cores of a node. 
ppool = mp.ProcessingPool(mp.cpu_count() * 2) 
tpool = mp.ThreadingPool(mp.cpu_count()) 
for i in range(nframes): 
    data1 = ppool.uimap(func1, range(nsites)) 
    data2 = tpool.uimap(func2, data1) 
    for values in data2: 
        func3(values) 

我怀疑系统越大,我从多处理中获得的好处就越多。我知道大型 CG 系统(42,778 个站点)大约需要 0.08 秒/站点,而 0.02 秒/站点(3000 个 CG 站点)或 0.05 秒/站点(1000 个站点没有绑定(bind))。

在我努力缩短计算时间的过程中,我发现了可以减少一些计算的区域(例如,global 变量和算法更改),但如果我可以进一步减少它通过全面的多重处理,那就太好了。

请您参考如下方法:

如果您使用的是 python 2.7,您的选择相当有限

这是一个使用池参数调用对象方法的简短示例。

第一个问题是只有定义在模块顶层的函数才能被 pickle。基于 Unix 的系统有办法绕过这个限制,但不应该依赖它。因此,您必须定义一个函数,该函数采用您想要的对象和调用相关方法所需的参数。

例如:

def do_square(args): 
    squarer, x = args # unpack args 
    return squarer.square(x) 

Squarer 类可能如下所示:

class Squarer(object): 
    def square(self, x): 
        return x * x 

现在并行应用平方函数。

if __name__ == "__main__": 
    # all pool work must be done inside the if statement otherwise a recursive  
    # cycle of Pool spawning will be created. 
 
    pool = Pool() 
    sq = Squarer() 
    # create args as a sequence of tuples 
    args = [(sq, i) for i in range(10)] 
    print pool.map(do_square, args) 
 
    pool.close() 
    pool.join() 

请注意,平方器不是有状态的。它接收数据,处理它并返回结果。这是因为 child 的状态与 parent 的状态是分开的。除非使用队列、管道或其他由多处理提供的共享状态类,否则一个中的更改不会反射(reflect)在另一个中。通常,最好从子进程返回计算数据,然后在父进程中对该数据执行某些操作,而不是尝试将数据存储在子进程有权访问的某个共享变量中。

有状态平方器不适用于多处理的示例:

class StatefulSquarer(object): 
 
    def __init__(self): 
        self.results = [] 
 
    def square(self, x): 
        self.results.append(x * x) 
 
if __name__ == "__main__": 
 
    print("without pool") 
    sq = StatefulSquarer() 
    map(do_square, [(sq, i) for i in range(10)]) 
    print(sq.results) 
 
    print("with pool") 
    pool = Pool() 
    sq = StatefulSquarer() 
    pool.map(do_square, [(sq, i) for i in range(10)]) 
    print(sq.results) 
 
    pool.close() 
    pool.join() 

如果你想让这个工作,那么更好的解决方案是这样的:

for result in pool.map(do_square, [(sq, i) for i in range(10)]): 
    sq.results.append(result) 

如果你的类非常大,但不可变怎么办。每次你在 map 中开始一个新任务时,这个巨大的对象都必须被复制到子进程中。但是,您可以通过仅将其复制到子进程一次来节省时间。

from multiprocessing import Pool 
 
def child_init(sq_): 
    global sq 
    sq = sq_ 
 
def do_square(x): 
    return sq.square(x) 
 
class Squarer(object): 
    def square(self, x): 
        return x * x 
 
if __name__ == "__main__": 
    sq = Squarer() 
    pool = Pool(initializer=child_init, initargs=(sq,)) 
 
    print(pool.map(do_square, range(10))) 
 
    pool.close() 
    pool.join()