并行处理 - Python

Question

我正在一个项目中工作，一些过程需要很长时间才能完成（总共> 2小时），并且某些过程显然可以并行化。一些例子是这些：

for n in range(images): 
    entry = ImD.ImageData(width, height) 
    entry.interpolate_points(seeds) 
    entries.append(entry) 

def interpolate_points(self, seeds): 
    points = [] 
    f = [] 
    for i in range(seeds): 
     # Generate a cell position 
     pos_x = random.randrange(self.width) 
     pos_y = random.randrange(self.height) 

     # Save the f(x,y) data 
     x = Utils.translate_range(pos_x, 0, self.width, self.range_min, self.range_max) 
     y = Utils.translate_range(pos_y, 0, self.height, self.range_min, self.range_max) 
     z = Utils.function(x, y) 
     points.append([x, y]) 

     f.append(z) 
    for x in range(self.width): 
     xt = (Utils.translate_range(x, 0, self.width, self.range_min, self.range_max)) 
     for y in range(self.height): 
      yt = (Utils.translate_range(y, 0, self.height, self.range_min, self.range_max)) 
      self.data[x][y] = Utils.shepard_euclidian(points, f, [xt, yt], 3) 

插值点方法需要将缔结相关的时间，因为我把它更多的则40倍，我相信我能有一些这方面的呼叫并行运行的。

def generate_pixel_histogram(self, images, bins): 
    """ 
    Generate a histogram of the image for each pixel, counting 
    the values assumed for each pixel in a specified bins 
    """ 
    max_value = 0.0 
    min_value = 0.0 
    for i in range(len(images)): 
     image = images[i] 
     max_entry = max(max(p[1:]) for p in image.data) 
     min_entry = min(min(p[1:]) for p in image.data) 
     if max_entry > max_value: 
      max_value = max_entry 
     if min_entry < min_value: 
      min_value = min_entry 

    interval_size = (math.fabs(min_value) + math.fabs(max_value))/bins 

    for x in range(self.width): 
     for y in range(self.height): 
      pixel_histogram = {} 
      for i in range(bins+1): 
       key = round(min_value+(i*interval_size), 2) 
       print key 
       pixel_histogram[key] = 0.0 
      for i in range(len(images)): 
       image = images[i] 
       value = round(Utils.get_bin(image.data[x][y], interval_size), 2) 
       pixel_histogram[value] += 1.0/len(images) 
      self.data[x][y] = pixel_histogram 

生成像素直方图的方法是另一种情况。在这里，我有多个图像，并且对于图像的每个位置，我必须生成一个直方图。所以，每个位置都明显独立于其他位置，所以我认为这是一个可以并行化的明显情况。

问题是因为我在Python，Cython等等看multiprocessing，但我没有弄清楚如何应用这是我的代码。我从来没有在实践中使用过多处理，所以我有一些难以将这个概念应用于我的问题。

我已经试过这样：

p = Pool(5) 
for n in range(images): 
    entry = ImD.ImageData(width, height) 
    entries.append(entry) 

p.map(ImD.interpolate_points, entries) 

但它不工作，因为我带班工作。

任何帮助，将不胜感激。 在此先感谢。

Answer 1

你可以尝试多进程的并行映射。这是一种“排队”模式，在这种模式中，您需要完成很多任务，您需要提出一些工作流程，然后才能对其进行处理。

http://docs.python.org/2/library/multiprocessing.html

一个例子（从该页面获取）：

from multiprocessing import Pool 
p = Pool(5) 
def f(x): 
    return x*x 

p.map(f, range(50)) 

这将带来5个工作流程，他们将采取他们的作品从你传递给映射列表。

请注意，没有处理订单保证。