Как да паралелизирам изчисление на сума в python numpy?

Разбрах как да паралелизирам сума от масиви с мултипроцесиране, apply_async и обратни извиквания, така че публикувам това тук за други хора. Използвах примерната страница за Parallel Python за класа за обратно извикване Sum, въпреки че Всъщност не използвах този пакет за внедряване. Все пак ми даде идеята да използвам обратни извиквания. Ето опростения код за това, което накрая използвах, и той прави това, което исках да прави.

import multiprocessing
import numpy as np
import thread

class Sum: #again, this class is from ParallelPython's example code (I modified for an array and added comments)
    def __init__(self):
        self.value = np.zeros((1,512*512)) #this is the initialization of the sum
        self.lock = thread.allocate_lock()
        self.count = 0

    def add(self,value):
        self.count += 1
        self.lock.acquire() #lock so sum is correct if two processes return at same time
        self.value += value #the actual summation
        self.lock.release()

def computation(index):
    array1 = np.ones((1,512*512))*index #this is where the array-returning computation goes
    return array1

def summers(num_iters):
    pool = multiprocessing.Pool(processes=8)

    sumArr = Sum() #create an instance of callback class and zero the sum
    for index in range(num_iters):
        singlepoolresult = pool.apply_async(computation,(index,),callback=sumArr.add)

    pool.close()
    pool.join() #waits for all the processes to finish

    return sumArr.value

Също така успях да накарам това да работи с помощта на паралелна карта, която беше предложена в друг отговор. Бях пробвал това по-рано, но не го прилагах правилно. И двата начина работят и мисля, че този отговор обяснява проблема кой метод да се използва (map или apply.async) доста добре. За версията на картата не е необходимо да дефинирате класа Sum и става функцията summers

def summers(num_iters):
    pool = multiprocessing.Pool(processes=8)

    outputArr = np.zeros((num_iters,1,512*512)) #you wouldn't have to initialize these
    sumArr = np.zeros((1,512*512))              #but I do to make sure I have the memory

    outputArr = np.array(pool.map(computation, range(num_iters)))
    sumArr = outputArr.sum(0)

    pool.close() #not sure if this is still needed since map waits for all iterations

    return sumArr

Не съм сигурен, че разбирам проблема. Опитвате ли се просто да разделите списък на набор от работници, да ги накарате да поддържат текуща сума от своите изчисления и да сумират резултата?

#!/bin/env python
import sys
import random
import time
import multiprocessing
import numpy as np

numpows = 5
numitems = 25
nprocs = 4

def expensiveComputation( i ):
  time.sleep( random.random() * 10 )
  return np.array([i**j for j in range(numpows)])

def listsum( l ):
  sum = np.zeros_like(l[0])
  for item in l:
    sum = sum + item
  return sum

def partition(lst, n):
  division = len(lst) / float(n)
  return [ lst[int(round(division * i)): int(round(division * (i + 1)))] for i in xrange(n) ]

def myRunningSum( l ):
  sum = np.zeros(numpows)
  for item in l:
     sum = sum + expensiveComputation(item)
  return sum

if __name__ == '__main__':

  random.seed(1)
  data = range(numitems)

  pool = multiprocessing.Pool(processes=4,)
  calculations = pool.map(myRunningSum, partition(data,nprocs))

  print 'Answer is:', listsum(calculations)
  print 'Expected answer: ', np.array([25.,300.,4900.,90000.,1763020.])

(функцията за разделяне идва от Python: Нарязване на списък на n дяла с почти еднаква дължина )