파이썬 - 멀티 프로세싱은 순차적 인 것보다 느리다

Question

이것이 나의 첫 번째 멀티 프로세싱 구현이다. 나는 순차적 인 접근 방식으로 코드를 실행했고 20 초 정도의 레코드를 처리하는 데 30 초 정도 걸린다. 하지만 각 키가 레코드 집합을 가진 사전을 만들고 모든 키에 대해 pool.map을 사용하여 함수를 적용하려고했습니다. 이제는 각 프로세스마다 각 코어를 할당하지만 2 분 이상 처리 할 수 ​​있습니다. 누군가 나를 최적화하도록 도울 수 있습니까?

def f(values): 
    data1 = itertools.combinations(values,2) 
    tuple_attr =('Age', 'Workclass', 'Fnlwgt', 'Education', 'Education-num', 'marital-status', 'Occupation', 'Relationship', 'Race', 'Sex', 'Capital-gain', 'Capital-loss', 'Hours-per-week', 'Native country', 'Probability', 'Id') 
    new = ((tuple_attr[i] for i, t in enumerate(zip(*pair)) if t[0]!=t[1]) for pair in data1) 
    skt = set(frozenset(temp) for temp in new) 
    newset = set(s for s in skt if not any(p < s for p in skt)) 

    empty = frozenset(" ") 
    tr_x = set(frozenset(i) for i in empty) 
    tr = set(frozenset(i) for i in empty) 
    for e in newset: 
     tr.clear() 
     tr = tr.union(tr_x) 
     tr_x.clear() 
     for x in tr: 
      for a in e: 
       if x == empty: 
        tmp = frozenset(frozenset([a])) 
        tr_x = tr_x.union([tmp]) 
       else : 
        tmp = frozenset(frozenset([a]).union(x)) 
        tr_x = tr_x.union([tmp]) 
     tr.clear() 
     tr = tr.union(tr_x) 
     tr = set(l for l in tr if not any(m < l for m in tr)) 

    return tr 

def main(): 
    p = Pool(len(data)) #number of processes = number of CPUs 
    keys, values= zip(*data.items()) #ordered keys and values 
    processed_values= p.map(f, values) 
    result= dict(zip(keys, processed_values)) 
    p.close() # no more tasks 
    p.join() # wrap up current tasks 
    print(result) 


if __name__ == '__main__': 
    import csv 
    dicchunk = {*****} #my dictionary 
    main() 

Answer 1

나는 multiprocessing 한 번이를 실행하는 테스트 프로그램을 만들어, 한 번없이 :하지만 많은하여,

multi: 191.249588966 
non-multi: 225.774535179 

multiprocessing가 빠르다 : 여기

def main(data): 
    p = Pool(len(data)) #number of processes = number of CPUs 
    keys, values= zip(*data.items()) #ordered keys and values 
    start = time.time() 
    processed_values= p.map(f, values) 
    result= dict(zip(keys, processed_values)) 
    print("multi: {}".format(time.time() - start)) 
    p.close() # no more tasks 
    p.join() # wrap up current tasks 

    start = time.time() 
    processed_values = map(f, values) 
    result2 = dict(zip(keys, processed_values)) 
    print("non-multi: {}".format(time.time() - start)) 
    assert(result == result2) 

출력의 예상대로. 그 이유는 하위 목록 중 일부는 다른 사람보다 (몇 분) 정도 더 오래 걸릴 수 있기 때문입니다. 가장 큰 하위 목록을 처리하는 데 시간이 오래 걸리지는 않습니다.

작업자 함수에 일부 추적을 추가하여이를 보여줍니다. 나는 작업자의 시작에서 시간을 절약하고, 끝에서 그것을 인쇄했다. 당신은 순차적 인 대 약 44 초 절약하고, 그래서 당신이 볼 수 있듯이

<Process(PoolWorker-4, started daemon)> is done. Took 0.940237998962 seconds 
<Process(PoolWorker-2, started daemon)> is done. Took 1.28068685532 seconds 
<Process(PoolWorker-1, started daemon)> is done. Took 42.9250118732 seconds 
<Process(PoolWorker-3, started daemon)> is done. Took 193.635578156 seconds 

이, 노동자가 작업의 매우 불평등 한 양을하고있다 : 여기에 출력합니다.