并行处理- 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)

但它不起作用，因为我使用的是class。

任何帮助都将不胜感激。提前谢谢。

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个工作流程，它们将从您传递给map的列表中获取他们的作品。

请注意，没有保证处理顺序。