Question

下面，我收集了四种方法来完成涉及对更新的Pandas Dataframe进行排序的代码的执行。

我想应用最好的方法来加快代码执行速度。我是否在使用最佳实践？

有人可以分享以下想法吗？

我正在遍历数据帧，因为解决我的问题的过程似乎需要它。使用Dask数据框会大大提高速度吗？
Dask分布式版本是否可以通过设置特定数量的工作者，进程，每个工作者的线程数而受益？人们指出，在某些情况下，最好是增加进程数而不是线程数（反之亦然）。
用于此类代码的最强大的硬件基础架构是什么？在具有更多物理CPU内核的AWS实例上，多处理版本甚至更快。
- 使用Dask Distributed进行Kubernetes / AWS设置会更快吗？
- 是否可以轻松地使其适应本地GPU或在多GPU AWS实例上运行？

这些是供参考的完成时间：

常规“ For”循环：34 seconds
Dask延迟：21 seconds
分布式分布式（本地计算机）：21 seconds
多重处理：10 seconds

from dask.distributed import Client
from multiprocessing import Pool
from dask import delayed
import pandas as pd
import numpy as np
client = Client()
import random
import dask

#Setting original input data that will be used in the functions
alist=['A','B','C','D','E','F','G','H','I']
set_table=pd.DataFrame({"A":alist,
                        "B":[i for i in range(1,10)],
                        "C":[i for i in range(11,20)],
                        "D":[0]*9})

#Assembled random list of combinations   
criteria_list=[]
for i in range(0,10000):
    criteria_list.append(random.sample(alist,6))

#Sorts and filters the original df
def one_filter_sorter(criteria):
    sorted_table=set_table[set_table['A'].isin(criteria)]
    sorted_table=sorted_table.sort_values(['B','C'],ascending=True)
    return sorted_table

#Exists to help the function below. Simplified for this example    
def helper_function(sorted_table,idx):
    if alist.index(sorted_table.loc[idx,'A'])>5:
        return True

#last function that retuns the gathered result    
def two_go_downrows(sorted_table):

    for idx, row in sorted_table.iterrows():
        if helper_function(sorted_table,idx)==True:
            sorted_table.loc[idx,'D'] = 100 - sorted_table.loc[idx,'C']

    res=sorted_table.loc[:,['A','D']].to_dict()
    return res

#--Loop version
result=[]    
for criteria in criteria_list:
    A=one_filter_sorter(criteria)
    B=two_go_downrows(A)
    result.append(B)

#--Multiprocessed version
result=[]    
if __name__ == '__main__':
    pool=Pool(processes=6)
    A=pool.map(one_filter_sorter, criteria)
    B=pool.map(two_go_downrows, A) 
    result.append(B)

#--Delayed version
result=[]    
for criteria in criteria_list:
    A=delayed(one_filter_sorter)(criteria) 
    B=delayed(two_go_downrows)(A) 
    result.append(B)
dask.compute(result)

#--Distributed version
A= client.map(one_filter_sorter,criteria_list) 
B= client.map(two_go_downrows,A)
client.gather(B)

谢谢

通过并行化/多处理来加速Python代码的选项

0 个答案: