Python：如何在Python中运行嵌套并行进程？

我有一个交易员交易数据集

df

。 我有两个级别的for循环，如下所示：

smartTrader =[]

for asset in range(len(Assets)):
    df = df[df['Assets'] == asset]
    # I have some more calculations here
    for trader in range(len(df['TraderID'])):
        # I have some calculations here, If trader is successful, I add his ID  
        # to the list as follows
        smartTrader.append(df['TraderID'][trader])

    # some more calculations here which are related to the first for loop.

我想对

资产

中的每项资产进行并行计算，同时我还想对每项资产的每名交易员进行并行计算。完成所有这些计算后，我想根据

smartTrader

列表进行额外的分析

---

这是我第一次尝试并行处理，所以请耐心等待，我感谢您的帮助。

使用

而不是
进行
，使用
映射
：

import functools
smartTrader =[]

m=map( calculations_as_a_function, 
        [df[df['Assets'] == asset] \
                for asset in range(len(Assets))])
functools.reduce(smartTradder.append, m)

从那时起，您可以尝试不同的并行
map
实现，或者如果您使用
pathos
，它提供了
多处理的分支，您可以轻松地嵌套并行映射
Paths
是为方便测试嵌套并行映射的组合而构建的，这些映射是嵌套for循环的直接转换。
它提供了一系列映射，包括阻塞、非阻塞、迭代、异步、串行、并行和分布式

>>> from pathos.pools import ProcessPool, ThreadPool
>>> amap = ProcessPool().amap
>>> tmap = ThreadPool().map
>>> from math import sin, cos
>>> print amap(tmap, [sin,cos], [range(10),range(10)]).get()
[[0.0, 0.8414709848078965, 0.9092974268256817, 0.1411200080598672, -0.7568024953079282, -0.9589242746631385, -0.27941549819892586, 0.6569865987187891, 0.9893582466233818, 0.4121184852417566], [1.0, 0.5403023058681398, -0.4161468365471424, -0.9899924966004454, -0.6536436208636119, 0.2836621854632263, 0.9601702866503661, 0.7539022543433046, -0.14550003380861354, -0.9111302618846769]]

在这里，这个示例使用一个处理池和一个线程池，其中线程映射调用是阻塞的，而处理映射调用是异步的（注意最后一行末尾的
get
）

获取
pathos
此处：
或与：

$pip安装git+https://github.com/uqfoundation/pathos.git@主人
标准python库中的线程可能是最方便的方法：

import threading

def worker(id):
    #Do you calculations here
    return

threads = []
for asset in range(len(Assets)):
    df = df[df['Assets'] == asset]
    for trader in range(len(df['TraderID'])):
        t = threading.Thread(target=worker, args=(trader,))
        threads.append(t)
        t.start()
    #add semaphore here if you need synchronize results for all traders.

嵌套并行可以通过一个允许轻松并行化和分发Python代码的系统优雅地完成

假设您要并行化以下嵌套程序

def inner_calculation(asset, trader):
    return trader

def outer_calculation(asset):
    return  asset, [inner_calculation(asset, trader) for trader in range(5)]

inner_results = []
outer_results = []

for asset in range(10):
    outer_result, inner_result = outer_calculation(asset)
    outer_results.append(outer_result)
    inner_results.append(inner_result)

# Then you can filter inner_results to get the final output.

下面是与上述代码并行的射线代码：


使用
@ray.remote decorator
处理我们希望在其自身进程中并发执行的每个函数。远程函数返回未来（即结果的标识符），而不是结果本身
调用远程函数
f（）
时，使用
remote
修饰符，即
f.remote（）
使用
ids\u to\u vals（）
helper函数将嵌套的id列表转换为值

请注意，程序结构是相同的。您只需添加
remote
，然后使用
ids\u to\u vals（）
helper函数将远程函数返回的未来（id）转换为值

import ray

ray.init()

# Define inner calculation as a remote function.
@ray.remote
def inner_calculation(asset, trader):
    return trader

# Define outer calculation to be executed as a remote function.
@ray.remote(num_return_vals = 2)
def outer_calculation(asset):
    return  asset, [inner_calculation.remote(asset, trader) for trader in range(5)]

# Helper to convert a nested list of object ids to a nested list of corresponding objects.
def ids_to_vals(ids):
    if isinstance(ids, ray.ObjectID):
        ids = ray.get(ids)
    if isinstance(ids, ray.ObjectID):
        return ids_to_vals(ids)
    if isinstance(ids, list):
        results = []
        for id in ids:
            results.append(ids_to_vals(id))
        return results
    return ids

outer_result_ids = []
inner_result_ids = []

for asset in range(10):
    outer_result_id, inner_result_id = outer_calculation.remote(asset)
    outer_result_ids.append(outer_result_id)
    inner_result_ids.append(inner_result_id)

outer_results = ids_to_vals(outer_result_ids)
inner_results = ids_to_vals(inner_result_ids)

与模块相比，使用Ray有许多优点。特别是，相同的代码将在一台机器以及一组机器上运行。有关Ray的更多优点，请参见。
尝试。我不确定在嵌套For循环时如何调用此函数，请提供一个小示例。为什么
asset
是
internal\u calculation
的参数？如果删除该参数，则得到相同的输出。