Python Pandas缩短了目前需要约400分钟运行的大型数据集的计算时间

所以，我去了一个黑暗的地方，找出一些可以在这里提供帮助的方法:)

长而短的是脚本结尾处的两个函数，其中p> 500会杀死您。当p <500时，我可以获得一些性能提升，我将在后面详细介绍。

我不是从本质上通过合并和填充数据框来进行迭代，而是采用了从具有所有组合（在上面的示例中为2500行）的数据框开始的方法。然后在右侧工作，并在可能的地方进行矢量化处理。我认为这里有很多改进，但是我无法使其达到预期的效果，因此也许还有其他方面可以有所帮助。

这是我最终得到的代码。从您在问题中输入的内容开始。

import pandas as pd
import numpy as np
import datetime as dt
from scipy import stats
import time

def calc_beta (a_series, b_series) :
    covariance = np.cov (a_series, b_series)
    beta = covariance[0, 1] / covariance[1, 1]
    return beta

dates = [dt.datetime.today().date() - dt.timedelta(days=x) for x in range(2000)]

m_list = [str(i) + 'm' for i in range(0, 15)]
names = [i + j  for i in m_list for j in m_list]

#keys = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
keys = ['A']
values = [pd.DataFrame([np.random.rand(225) for x in range(0, 2000)], index=dates, columns=names) for i in range(0, 10)]

df_dict = dict(zip(keys, values))

combos = ['{}/{}'.format(*np.random.choice(names, 2)) for i in range(750)] + ['{}/{}/{}'.format(*np.random.choice(names, 3)) for i in range(1500)]

#periods = [20, 60, 100, 200, 500, 1000, 2000]   #num of datapoints to use from time series
periods = [20]   #num of datapoints to use from time series
benchmarks = np.random.choice(combos, 25)       #benchmarks to compare combos to

data_dict = {}

for i in list(df_dict.keys()):
    df = df_dict[i]
    mydf =  pd.DataFrame(combos, columns=['name'])
    mydf[['a','b','c','d','e','f']]=mydf.name.str.replace('/', '').str.replace('m', ',').str[0:-1].str.split(',', expand=True)

    def get_series(a):
        if len(a) == 2 :
            l1, l2 = a
            s = df[l1] - df[l2]
            return s.tolist()
        else:
            l1, l2, l3 = a
            s = df[l1] - df[l2] - df[l3]
            return s.tolist()

    mydf['series'] = mydf['name'].apply(lambda x: get_series(x.split('/')))
    mydf['last'] = mydf['series'].str[-1]

    for p in periods:
        _str = str(p)

        mydf['quantile' + _str] =  mydf.apply(lambda x: stats.percentileofscore(x['series'][-p:], x['last']), axis=1)
        mydf['z_score' + _str] = mydf.apply(lambda x: stats.zscore(x['series'][-p:])[-1], axis=1)
        mydf['std' + _str] = mydf.apply(lambda x: np.std(x['series'][-p:]), axis=1)
        mydf['range' + _str] = mydf.apply(lambda x: max(x['series'][-p:]) - min(x['series'][-p:]), axis=1)
        mydf['last_range' + _str] = mydf['last'] / mydf['range' + _str]
        mydf['last_std' + _str] = mydf['last'] / mydf['std' + _str]

        if p > 100 :
            mydf['5d_autocorr' + _str] = mydf.apply(lambda x: pd.Series(x['series'][-p:]).autocorr(-5), axis=1)
        else :
            mydf['5d_autocorr' + _str] = np.nan

        def get_series(a):
            if len(a) == 1 :
                b = df[a[0]]
                return b.tolist()
            elif len(a) == 2 :
                b = df[a[0]] - df[a[1]]
                return b.tolist()
            else:
                b = df[a[0]] - df[a[1]] - df[a[2]]
                return b.tolist()

        for b in benchmarks:
            corr_ticker = '{}_corr{}'.format(b, _str)
            beta_ticker = '{}_beta{}'.format(b, _str)

            b_series = get_series(b.split('/'))[-p:]

            mydf[corr_ticker] = mydf.apply(lambda x: stats.pearsonr(np.array(x['series'][-p:]), np.array(b_series))[0], axis=1)
            mydf[beta_ticker] = mydf.apply(lambda x: calc_beta(np.array(x['series'][-p:]), np.array(b_series)), axis=1)

            if p > 500 :
                mydf[b + '_20rolling_corr_mean' + _str] = mydf.apply(lambda x: pd.Series(x['series'][-p:]).rolling(20).corr(pd.Series(b_series)).mean(), axis=1)
                mydf[b + '_20d_rolling_beta_mean' + _str] =  mydf.apply(lambda x: pd.DataFrame({x['name']: pd.Series(x['series'][-p:]), b : pd.Series(b_series)}).rolling(20) \
                                                                .cov(pd.DataFrame({x['name']: pd.Series(x['series'][-p:]), b : pd.Series(b_series)}) , pairwise=True) \
                                                                .drop([x['name']], axis=1) \
                                                                .unstack(1) \
                                                                .droplevel(0, axis=1) \
                                                                .apply(lambda row: row[x['name']] / row[b], axis=1) \
                                                                .mean(), axis=1)

    data_dict[i] = mydf

我只运行了一组“ A”并更改了时间段。在保持“ A”不变并更改周期的情况下，我得到了如下所示的性能提升。在周期= 400时，我仍然可以获得60％的性能提升。

A 20
Original: Total Time 25.74614143371582
Revised: Total Time 7.026344299316406

A 200
Original: Total Time 25.56810474395752
Revised: Total Time 10.015231847763062

A 400
Original: Total Time 28.221587419509888
Revised: Total Time 11.064109802246094

转到期间501，您的原始代码花费了1121.6251230239868秒。我的差不多。从400到501会增加两个功能的大量时间（每个基准重复一次）。

如果需要这些功能并且必须在分析时进行计算，则应将时间花在这两个功能上。我发现使用pandas系列速度很慢，并且您会注意到我在一次实例中使用scipy模块进行关联，因为这样做值得。如果您可以直接将numpy或scipy模块用于最后两个功能，那么您也会从中看到收益。

另一个要看的地方是我正在使用lambda函数的地方。这仍然像使用for循环一样逐行进行。我正在保存期间序列，因此可以使用以下计算：

def get_series(a):
    if len(a) == 2 :
        l1, l2 = a
        s = df[l1] - df[l2]
        return s.tolist()
    else:
        l1, l2, l3 = a
        s = df[l1] - df[l2] - df[l3]
        return s.tolist()

mydf['series'] = mydf['name'].apply(lambda x: get_series(x.split('/')))

该系列由列表组成，并传递给lambda函数。我希望找到一种通过同时计算所有行来向量化的方法，但是某些函数需要序列，而某些函数则使用列表，因此我可以弄清楚。这是一个例子：

mydf['quantile' + _str] =  mydf.apply(lambda x: stats.percentileofscore(x['series'][-p:], x['last']), axis=1)

如果您能弄清楚如何对其进行矢量化处理，然后将其应用于p> 500的那些函数，将会发现一些节省。

最后，您的代码还是我的代码，真正的问题是后两个功能。其他所有东西都较小，但确实是节省的，并且加起来，但重新思考最后一块可以节省您的时间。

另一个选择是多进程或将其分解到多台计算机上