python - Python 3.7：使用共享变量多处理 for 循环

Question

首先是一些上下文：

我正在尝试编写一个 python 脚本，将灰度图像 (​​.tif) 转换为具有所谓“jet”颜色图的 .jpeg。我设法使用 for 循环来做到这一点，但对于一张图像来说它有点长（要处理数百万像素！），所以我想使用多处理。

我的问题是要将每个灰色像素转换为彩色像素，我必须使用两个变量（光强度的最小值''min_img''和向量''dx_cm''从初始灰度到256比例，对应于喷射颜色图）。

因此，为了将 ''min_img'' 和 ''dx_cm'' 的信息传递给我尝试使用 multiprocessing.Value() 的进程，但作为回报，我得到了错误：

RuntimeError: Synchronized objects should only be shared between processes through inheritance

我从不同的来源尝试了许多不同的东西，无论我的代码版本如何，我都在努力解决这个错误。因此，如果我的代码不干净，我很抱歉，如果有人可以帮助我，我将不胜感激。

我的非工作代码：

import multiprocessing
from PIL import Image
from matplotlib import cm


def fun(gr_list,dx,minp):

    dx_cmp = dx.value
    min_imgp = minp.value

    rgb_res=list()

    for i in range(len(gr_list)):
        rgb_res.extend(cm.jet(round(((gr_list[i]-min_imgp)/dx_cmp)-1))[0:-1])

    return rgb_res


if __name__ == '__main__':

    RGB_list=list()

    n = multiprocessing.cpu_count()

    img = Image.open(r'some_path_to_a.tif')

    Img_grey=list(img.getdata())

    dx_cm = multiprocessing.Value('d',(max(Img_grey)-min(Img_grey))/256)

    min_img = multiprocessing.Value('d',min(Img_grey))

    with multiprocessing.Pool(n) as p:

        RGB_list = list(p.map(fun, (Img_grey,dx_cm,min_img)))

    res = Image.frombytes("RGB", (img.size[0], img.size[1]), bytes([int(0.5 + 255*i) for i in RGB_list]))    

    res.save('rgb_file.jpg')

PS：这是我想并行化的初始 for 循环的示例：

from PIL import Image
from matplotlib import cm


if __name__ == '__main__':

    img = Image.open(r'some_path_to_a.tif')

    Img_grey = list(img.getdata())

    dx_cm = (max(Img_grey)-min(Img_grey))/256

    min_img = min(Img_grey)

    Img_rgb = list()

    for i in range(len(Img_grey)):
        Img_rgb.extend(cm.jet(round(((Img_grey[i]-min_img)/dx_cm)-1))[0:-1])

    res = Image.frombytes("RGB", (img.size[0], img.size[1]), bytes([int(0.5 + 255*i) for i in Img_rgb]))    

    res.save('rgb_file.jpg')

标签： pythonshared-memorypython-multiprocessing

Answer 1

您的fun方法正在循环某个列表，但在这种情况下，它将接收“部分”，即列表中的一个项目，因此它应该只返回其处理的结果。

我已更改工作代码以使用多处理运行。

由于该fun方法返回一个列表，因此p.map将返回一个列表列表（结果列表）并且需要展平，之前使用 listextends方法完成。

尝试使用进程池和线程池多处理，在我的场景中没有任何性能提升。

• 进程多处理：

from PIL import Image
from matplotlib import cm
import multiprocessing


def fun(d):
    part, dx_cm, min_img = d
    return cm.jet(round(((part-min_img)/dx_cm)-1))[0:-1]

if __name__ == '__main__':
    img = Image.open(r'a.tif')
    Img_grey = list(img.getdata())

    def Gen(img_data):
        dx_cm = (max(img_data)-min(img_data))/256
        min_img = min(img_data)
        for part in img_data:
            yield part, dx_cm, min_img

    n = multiprocessing.cpu_count()
    with multiprocessing.Pool(n) as p:
        Img_rgb = [item for sublist in p.map(fun, Gen(Img_grey)) for item in sublist]

    res = Image.frombytes("RGB", (img.size[0], img.size[1]), bytes([int(0.5 + 255*i) for i in Img_rgb]))    
    res.save('b.jpg')

• 线程多处理：

from PIL import Image
from matplotlib import cm
import multiprocessing
from multiprocessing.pool import ThreadPool

if __name__ == '__main__':
    img = Image.open(r'a.tif')
    Img_grey = list(img.getdata())
    dx_cm = (max(Img_grey)-min(Img_grey))/256
    min_img = min(Img_grey)

    def fun(part):
        return cm.jet(round(((part-min_img)/dx_cm)-1))[0:-1]

    n = multiprocessing.cpu_count()
    with ThreadPool(n) as p:
        Img_rgb = [item for sublist in p.map(fun, Img_grey) for item in sublist]

    res = Image.frombytes("RGB", (img.size[0], img.size[1]), bytes([int(0.5 + 255*i) for i in Img_rgb]))    
    res.save('b.jpg')