在量化交易编码中,通常可以把一个策略或者完整算法写成一个类,以便组合在一个完整工程中。 有时这个类的某些方法需要利用并行计算以加速处理,python中一般用进程池(concurrent.future)进行并行计算,以有效加快处理速度
with concurrent.futures.ProcessPoolExecutor(max_workers=3) as executor:
futures = [executor.submit(self.evaluate_item, item) for item in n_list]
for future in concurrent.futures.as_completed(futures):
print(future.result())
self.result.append(future.result())
但进程池的使用比线程池(线程池存在GIL限制,基本无法提升处理速度)要严格,一般在主程序if name == ‘main’:中使用。
能否实现一个通用并行处理器可以加载不同的类,对相近的类方法实施加速处理呢? 可以使用继承关系,让算法类(子类)继承通用并行处理器类(父类)
*FatherMultiPro.py:*
import concurrent.futures
from abc import ABCMeta,abstractmethod
#父类,完成进程池,子类通过重载父类方法调用进程池
class FatherMultiPro:
def __init__(self, n_list):
'''
Constructor
'''
self.result=[]
with concurrent.futures.ProcessPoolExecutor(max_workers=3) as executor:
futures = [executor.submit(**self.evaluate_item**, **item**) for item in n_list]
for future in concurrent.futures.as_completed(futures):
print(future.result())
self.result.append(future.result())
@abstractmethod
**def evaluate_item(self,x):**
pass
def getList(self):
return self.result
#子类
class MyMulti(FatherMultiPro):
def __init__(self,n_list):
self.list=n_list
def sta(self):
super(MyMulti,self).__init__(self.list)
def evaluate_item(self,x):
# 计算总和,这里只是为了消耗时间
print('aaa')
result_item = self.count(x)
# 打印输入和输出结果
return result_item
def count(self,number) :
for i in range(0, 10000000):
i=i+1
return i * number
def getList(self):
return super(MyMulti,self).getList()
*MyMulti.py*
from trade.quant.FatherMultiPro import MyMulti
if __name__ == '__main__':
number_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
mp=MyMulti(number_list)
mp.sta()
print('pp:',mp.getList())
class FatherMultiPro就是一个通用加速器,需要加速的方法可以写成虚拟方法; 算法类(MyMulti.py)只要实现这个虚拟方法,就可以利用并行处理能力进行加速处理。
结果(这里使用了3个进程并行处理 max_workers=3)
aaa
aaa
aaa
aaa
10000000
aaa
20000000
aaa
30000000
aaa
40000000
aaa
60000000
aaa
50000000
aaa
70000000
80000000
90000000
100000000
pp: [10000000, 20000000, 30000000, 40000000, 60000000, 50000000, 70000000, 80000000, 90000000, 100000000]
这是有实际意义的例如,量化方法中,对不同的证券,股票或者其他标的量化策略就可以看成是不同的算法类,可以利用通用加速器分别不同标的时间序列的进行加速处理,提高效率
抛砖引玉,欢迎吐槽