并行处理 - 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 个工作进程，它们将从您传递给 map 的列表中取出他们的作品。

请注意，不保证处理顺序。