python中视频帧的多处理

Question

我是 python 多处理的新手。我想从一小时长的视频文件的每一帧中提取特征。处理每一帧大约需要 30 毫秒。我认为多处理是一个好主意，因为每一帧都是独立于所有其他帧进行处理的。

我想将特征提取的结果存储在自定义类中。

我阅读了一些示例，最终按照此处的建议使用了多处理和队列。结果令人失望，现在每帧大约需要 1000 毫秒来处理。我猜我产生了大量的开销。

有没有更有效的方法来并行处理帧并收集结果？

为了说明，我整理了一个虚拟示例。

import multiprocessing as mp
from multiprocessing import Process, Queue
import numpy as np
import cv2

def main():
    #path='path\to\some\video.avi'
    coordinates=np.random.random((1000,2))
    #video = cv2.VideoCapture(path)
    listOf_FuncAndArgLists=[]

    for i in range(50):
        #video.set(cv2.CAP_PROP_POS_FRAMES,i)
        #img_frame_original = video.read()[1]
        #img_frame_original=cv2.cvtColor(img_frame_original, cv2.COLOR_BGR2GRAY)
        img_frame_dummy=np.random.random((300,300)) #using dummy image for this example
        frame_coordinates=coordinates[i,:]
        listOf_FuncAndArgLists.append([parallel_function,frame_coordinates,i,img_frame_dummy])

    queues=[Queue() for fff in listOf_FuncAndArgLists] #create a queue object for each function
    jobs = [Process(target=storeOutputFFF,args=[funcArgs[0],funcArgs[1:],queues[iii]]) for iii,funcArgs in enumerate(listOf_FuncAndArgLists)]
    for job in jobs: job.start() # Launch them all
    for job in jobs: job.join() # Wait for them all to finish
    # And now, collect all the outputs:
    return([queue.get() for queue in queues])         

def storeOutputFFF(fff,theArgs,que): #add a argument to function for assigning a queue
    print 'MULTIPROCESSING: Launching %s in parallel '%fff.func_name
    que.put(fff(*theArgs)) #we're putting return value into queue

def parallel_function(frame_coordinates,i,img_frame_original):
    #do some image processing that takes about 20-30 ms
    dummyResult=np.argmax(img_frame_original)
    return(resultClass(dummyResult,i))

class resultClass(object):
    def __init__(self,maxIntensity,i):
        self.maxIntensity=maxIntensity
        self.i=i

if __name__ == '__main__':
    mp.freeze_support()
    a=main()
    [x.maxIntensity for x in a]

Answer 1

（常规）Python 中的并行处理有点麻烦：在其他语言中，我们只使用线程，但 GIL 造成了这个问题，并且使用多处理在移动数据时会产生很大的开销。我发现细粒度的并行性（相对）很难做到，而在单个进程中处理需要 10 秒（或更长时间）的“块”工作可能会更加直接。

并行处理你的问题的一个更简单的方法 - 如果你在 UNIXy 系统上 - 是制作一个 python 程序来处理命令行上指定的视频片段（即开始的帧号，以及一些帧来处理），然后使用GNU 并行工具一次处理多个段。第二个 python 程序可以整合文件集合的结果，或者从 stdin 读取结果，从parallel. 这种方式意味着处理代码不需要执行其自己的并行性，但它确实需要对输入文件进行多次访问并从中点开始提取帧。（这也可以扩展到跨多台机器工作，而无需更改 python...）

如果您需要纯Python解决方案，则可以以类似的方式使用Using multiprocessing.Pool.map：映射元组列表（例如，(file, startframe, endframe)），然后在函数中打开文件并处理该段。