在多处理中更新列表字典

Posted 2023-02-16

【中文标题】在多处理中更新列表字典

【英文标题】：Update a dictionary of lists in multiprocessing

【发布时间】：2020-02-20 03:58:15

【问题描述】：

我想计算分隔列表中所有可能对的元素的平均数量。以下脚本运行良好

from itertools import combinations
from operator import itemgetter
from collections import defaultdict

lst = [['A','D','B',],['A','M','N','B'],['A','C','B']]
elms = set(x for l in lst for x in l)

def test1():
    d = defaultdict(list)
    for i in lst:
        combs = list(combinations(i, 2))
        combs_sorted = [sorted(i) for i in combs]
        for j in combs_sorted:
            a = i.index(j[0])
            b = i.index(j[1])
            d[tuple(j)].append(abs((a+1)-b))
    return(d)

d = test1()
d = k: sum(v)/len(v) for k, v in d.items()
for k,v in d.items():
    print(k,v)

结果就是想要的结果。

('A', 'D') 0.0
('A', 'B') 1.3333333333333333
('B', 'D') 2.0
('A', 'M') 0.0
('A', 'N') 1.0
('M', 'N') 0.0
('B', 'M') 3.0
('B', 'N') 2.0
('A', 'C') 0.0
('B', 'C') 2.0

但是，当列表和元素的数量大幅增长时，该脚本会非常慢。我尝试在this answer 之后使用多处理

import multiprocess as mp

def init2(child_conn):
    d = defaultdict(list)
    for i in lst:
        combs = list(combinations(i, 2))
        combs_sorted = [sorted(i) for i in combs]
        for j in combs_sorted:
            a = i.index(j[0])
            b = i.index(j[1])
            d[tuple(j)].append(abs((a+1)-b))
    child_conn.send(d)

def test2():
    parent_conn, child_conn = mp.Pipe(duplex=False)
    p = mp.Process(target=init2, args=(child_conn,))
    p.start()
    d = parent_conn.recv()
    p.join()
    return(d)

d = test1()
d = k: sum(v)/len(v) for k, v in d.items()
for k,v in d.items():
    print(k,v)

但这个脚本似乎比上一个更慢。

import time

t = time.process_time()
test1()
print(time.process_time() - t)

6.0000000000004494e-05

t = time.process_time()
test2()
print(time.process_time() - t)

0.017596

如何加快计算速度？

【参考方案1】：

除非它只是用于插图玩具示例，否则我想知道您为什么要费心加速 60 微秒的计算。 您只打开了一个完成所有工作的子进程，因此不应期望性能提升。

即使您打开更多，打开多处理 + 管道的开销与您计算的 60 微秒相比要大得多。

在以下情况下使用多处理有效：

您的基本计算比 mp 开销慢得多。 当您有一个预先创建的工人池等待通信进行一些计算时。使用这种配置（主要在服务器上找到），您只需为通信付费（顺便说一下，通信时间也比您的 60 微秒长）。

因此，归根结底，对于这么短的计算，请使用一个过程。