Question

我正在使用Python多处理，更确切地说是

from multiprocessing import Pool
p = Pool(15)

args = [(df, config1), (df, config2), ...] #list of args - df is the same object in each tuple
res = p.map_async(func, args) #func is some arbitrary function
p.close()
p.join()

这种方法具有巨大的内存消耗;几乎占用了我所有的RAM（此时它变得非常慢，因此使多处理非常无用）。我假设问题是df是一个巨大的对象（一个大的pandas数据帧），它会被复制到每个进程。我尝试使用multiprocessing.Value分享数据帧而不复制

shared_df = multiprocessing.Value(pandas.DataFrame, df)
args = [(shared_df, config1), (shared_df, config2), ...]

（正如Python multiprocessing shared memory中所述），但这给了我TypeError: this type has no size（与Sharing a complex object between Python processes?相同，我很遗憾不理解答案）。

我第一次使用多处理，也许我的理解还不够好。在这种情况下multiprocessing.Value实际上是否正确使用？我已经看到了其他建议（例如队列），但现在有点困惑。有什么选择可以共享内存，在这种情况下哪一个最好？

Answer 1

Value的第一个参数是 typecode_or_type 。这被定义为：

typecode_or_type确定返回对象的类型：它是 ctypes类型或者使用的那种类型的一个字符类型数组模块。 * args被传递给类型的构造函数。

强调我的。所以，你根本无法将一个pandas数据框放在Value中，它必须是a ctypes type。

您可以改为使用multiprocessing.Manager为您的所有进程提供单例数据框实例。有几种不同的方式可以在同一个地方结束 - 最简单的方法就是将数据帧放入经理的Namespace。

from multiprocessing import Manager

mgr = Manager()
ns = mgr.Namespace()
ns.df = my_dataframe

# now just give your processes access to ns, i.e. most simply
# p = Process(target=worker, args=(ns, work_unit))

现在，您的数据框实例可以被任何传递给Manager的引用的进程访问。或者只是传递对Namespace的引用，它更清晰。

我没有/不会涉及的一件事是事件和信号 - 如果你的进程需要等待其他人完成执行，你需要将其添加到。Here is a page中{{1}这些示例还详细介绍了如何使用经理Event。

（请注意，这些都不能解决Namespace是否会带来切实的性能优势，这只是为您提供探索该问题的工具）

Answer 2

您可以使用Array代替Value来存储数据框。

以下解决方案将pandas数据帧转换为将其数据存储在共享内存中的对象：

import numpy as np
import pandas as pd
import multiprocessing as mp
import ctypes

# the origingal dataframe is df, store the columns/dtypes pairs
df_dtypes_dict = dict(list(zip(df.columns, df.dtypes)))

# declare a shared Array with data from df
mparr = mp.Array(ctypes.c_double, df.values.reshape(-1))

# create a new df based on the shared array
df_shared = pd.DataFrame(np.frombuffer(mparr.get_obj()).reshape(df.shape),
                         columns=df.columns).astype(df_dtypes_dict)

如果现在您在各个进程之间共享df_shared，将不会再创建其他副本。对于您而言：

pool = mp.Pool(15)

def fun(config):
    # df_shared is global to the script
    df_shared.apply(config)  # whatever compute you do with df/config

config_list = [config1, config2]
res = p.map_async(fun, config_list)
p.close()
p.join()

如果您使用pandarallel，例如，这也特别有用：

# this will not explode in memory
from pandarallel import pandarallel
pandarallel.initialize()
df_shared.parallel_apply(your_fun, axis=1)

注意：在此解决方案中，您最终得到两个数据帧（df和df_shared），它们消耗两倍的内存，并且初始化时间很长。可能可以直接在共享内存中读取数据。

Answer 3

通过创建data_handler子进程，您可以在进程之间共享熊猫数据帧而没有任何内存开销。此过程从您的非常大的数据框对象接收具有特定数据请求（即行，特定单元格，切片等）的其他子级的调用。只有data_handler进程将您的数据帧保留在内存中，这与诸如Namespace的管理器不同，后者导致该数据帧被复制到所有子进程。请参见下面的工作示例。可以将其转换为池。

需要进度条吗？在这里查看我的答案：https://stackoverflow.com/a/55305714/11186769

import time
import Queue
import numpy as np
import pandas as pd
import multiprocessing
from random import randint

#==========================================================
# DATA HANDLER
#==========================================================

def data_handler( queue_c, queue_r, queue_d, n_processes ):

    # Create a big dataframe
    big_df = pd.DataFrame(np.random.randint(
        0,100,size=(100, 4)), columns=list('ABCD'))

    # Handle data requests
    finished = 0
    while finished < n_processes:

        try:
            # Get the index we sent in
            idx = queue_c.get(False)

        except Queue.Empty:
            continue
        else:
            if idx == 'finished':
                finished += 1
            else:
                try:
                    # Use the big_df here!
                    B_data = big_df.loc[ idx, 'B' ]

                    # Send back some data
                    queue_r.put(B_data)
                except:
                    pass    

# big_df may need to be deleted at the end. 
#import gc; del big_df; gc.collect()

#==========================================================
# PROCESS DATA
#==========================================================

def process_data( queue_c, queue_r, queue_d):

    data = []

    # Save computer memory with a generator
    generator = ( randint(0,x) for x in range(100) )

    for g in generator:

        """
        Lets make a request by sending
        in the index of the data we want. 
        Keep in mind you may receive another 
        child processes return call, which is
        fine if order isnt important.
        """

        #print(g)

        # Send an index value
        queue_c.put(g)

        # Handle the return call
        while True:
            try:
                return_call = queue_r.get(False)
            except Queue.Empty:
                continue
            else:
                data.append(return_call)
                break

    queue_c.put('finished')
    queue_d.put(data)   

#==========================================================
# START MULTIPROCESSING
#==========================================================

def multiprocess( n_processes ):

    combined  = []
    processes = []

    # Create queues
    queue_data = multiprocessing.Queue()
    queue_call = multiprocessing.Queue()
    queue_receive = multiprocessing.Queue()

    for process in range(n_processes): 

        if process == 0:

                # Load your data_handler once here
                p = multiprocessing.Process(target = data_handler,
                args=(queue_call, queue_receive, queue_data, n_processes))
                processes.append(p)
                p.start()

        p = multiprocessing.Process(target = process_data,
        args=(queue_call, queue_receive, queue_data))
        processes.append(p)
        p.start()

    for i in range(n_processes):
        data_list = queue_data.get()    
        combined += data_list

    for p in processes:
        p.join()    

    # Your B values
    print(combined)


if __name__ == "__main__":

    multiprocess( n_processes = 4 )

Answer 4

我发布了使用joblib进行此操作的快速方法，请参见https://stackoverflow.com/a/58514648/12260524

python中的多处理 - 在多个进程之间共享大对象（例如pandas dataframe）

4 个答案: