高效的Python Pandas股票贝塔值计算在多个数据框中

19
我有许多(4000+)股票数据的CSV文件(Date, Open, High, Low, Close),我将它们导入单独的Pandas数据帧中进行分析。我是 Python 的新手,想要计算每个股票的滚动12个月贝塔值。我发现了一个用于计算滚动贝塔值的 post (Python pandas calculate rolling stock beta using rolling apply to groupby object in vectorized fashion),但当在我的代码中使用时需要超过2.5小时!考虑到我可以在不到3分钟的时间内在 SQL 表格中运行完全相同的计算,这个速度太慢了。
如何改善下面代码的性能以使其与 SQL 相匹配呢?我知道 Pandas / python 具备这种能力,目前我的方法是遍历每一行,但我不知道是否有任何聚合方式可以对数据帧执行滚动窗口贝塔值计算。
注意:将 CSV 文件加载到单独的数据帧中并计算每日回报率的前两步仅需要约20秒。所有 CSV 数据帧都存储在名为 'FilesLoaded' 的字典中,例如 'XAO'。
非常感谢您的帮助! 谢谢 :)
import pandas as pd, numpy as np
import datetime
import ntpath
pd.set_option('precision',10)  #Set the Decimal Point precision to DISPLAY
start_time=datetime.datetime.now()

MarketIndex = 'XAO'
period = 250
MinBetaPeriod = period
# ***********************************************************************************************
# CALC RETURNS 
# ***********************************************************************************************
for File in FilesLoaded:
    FilesLoaded[File]['Return'] = FilesLoaded[File]['Close'].pct_change()
# ***********************************************************************************************
# CALC BETA
# ***********************************************************************************************
def calc_beta(df):
    np_array = df.values
    m = np_array[:,0] # market returns are column zero from numpy array
    s = np_array[:,1] # stock returns are column one from numpy array
    covariance = np.cov(s,m) # Calculate covariance between stock and market
    beta = covariance[0,1]/covariance[1,1]
    return beta

#Build Custom "Rolling_Apply" function
def rolling_apply(df, period, func, min_periods=None):
    if min_periods is None:
        min_periods = period
    result = pd.Series(np.nan, index=df.index)
    for i in range(1, len(df)+1):
        sub_df = df.iloc[max(i-period, 0):i,:]
        if len(sub_df) >= min_periods:  
            idx = sub_df.index[-1]
            result[idx] = func(sub_df)
    return result

#Create empty BETA dataframe with same index as RETURNS dataframe
df_join = pd.DataFrame(index=FilesLoaded[MarketIndex].index)    
df_join['market'] = FilesLoaded[MarketIndex]['Return']
df_join['stock'] = np.nan

for File in FilesLoaded:
    df_join['stock'].update(FilesLoaded[File]['Return'])
    df_join  = df_join.replace(np.inf, np.nan) #get rid of infinite values "inf" (SQL won't take "Inf")
    df_join  = df_join.replace(-np.inf, np.nan)#get rid of infinite values "inf" (SQL won't take "Inf")
    df_join  = df_join.fillna(0) #get rid of the NaNs in the return data
    FilesLoaded[File]['Beta'] = rolling_apply(df_join[['market','stock']], period, calc_beta, min_periods = MinBetaPeriod)

# ***********************************************************************************************
# CLEAN-UP
# ***********************************************************************************************
print('Run-time: {0}'.format(datetime.datetime.now() - start_time))
7个回答

19

生成随机股票数据
4000只股票20年的月度数据

dates = pd.date_range('1995-12-31', periods=480, freq='M', name='Date')
stoks = pd.Index(['s{:04d}'.format(i) for i in range(4000)])
df = pd.DataFrame(np.random.rand(480, 4000), dates, stoks)

df.iloc[:5, :5]

这里输入图片描述


滚动函数
返回已准备好应用自定义函数的 groupby 对象
请参见源代码

def roll(df, w):
    # stack df.values w-times shifted once at each stack
    roll_array = np.dstack([df.values[i:i+w, :] for i in range(len(df.index) - w + 1)]).T
    # roll_array is now a 3-D array and can be read into
    # a pandas panel object
    panel = pd.Panel(roll_array, 
                     items=df.index[w-1:],
                     major_axis=df.columns,
                     minor_axis=pd.Index(range(w), name='roll'))
    # convert to dataframe and pivot + groupby
    # is now ready for any action normally performed
    # on a groupby object
    return panel.to_frame().unstack().T.groupby(level=0)

Beta函数
使用OLS回归的封闭形式解
假设列0是市场
参见来源

def beta(df):
    # first column is the market
    X = df.values[:, [0]]
    # prepend a column of ones for the intercept
    X = np.concatenate([np.ones_like(X), X], axis=1)
    # matrix algebra
    b = np.linalg.pinv(X.T.dot(X)).dot(X.T).dot(df.values[:, 1:])
    return pd.Series(b[1], df.columns[1:], name='Beta')

Demonstration

rdf = roll(df, 12)
betas = rdf.apply(beta)

时间控制

enter image description here


验证
将计算结果与 OP 进行比较。

def calc_beta(df):
    np_array = df.values
    m = np_array[:,0] # market returns are column zero from numpy array
    s = np_array[:,1] # stock returns are column one from numpy array
    covariance = np.cov(s,m) # Calculate covariance between stock and market
    beta = covariance[0,1]/covariance[1,1]
    return beta

print(calc_beta(df.iloc[:12, :2]))

-0.311757542437

print(beta(df.iloc[:12, :2]))

s0001   -0.311758
Name: Beta, dtype: float64

请注意第一个单元格
与上面的验证计算结果相同

betas = rdf.apply(beta)
betas.iloc[:5, :5]

评论回复
使用模拟的多个数据框的完整工作示例。


enter image description here

num_sec_dfs = 4000

cols = ['Open', 'High', 'Low', 'Close']
dfs = {'s{:04d}'.format(i): pd.DataFrame(np.random.rand(480, 4), dates, cols) for i in range(num_sec_dfs)}

market = pd.Series(np.random.rand(480), dates, name='Market')

df = pd.concat([market] + [dfs[k].Close.rename(k) for k in dfs.keys()], axis=1).sort_index(1)

betas = roll(df.pct_change().dropna(), 12).apply(beta)

for c, col in betas.iteritems():
    dfs[c]['Beta'] = col

dfs['s0001'].head(20)

enter image description here


1
@cwse 2.3秒是针对240个月和4,000股票的。SQL可以在不到3分钟内完成。Pandas + Numpy可以在不到3秒钟内完成。 - piRSquared
1
@cwse 我刚刚运行了40,000个模拟股票回报,历时240个月,在不到40秒的时间内运行了滚动12个月的贝塔系数。 - piRSquared
1
哇!!太史诗了!谢谢伙计 :) - cwse
哥们儿,你真是个天才!矩阵代数和其他一切……我已经好几年没碰过了! - cwse
2
这看起来非常适合我需要做的事情,我想知道您是否能够发布一个使用DataFrames多级索引的更新解决方案,现在Panel已经被弃用了。谢谢 :) - bgaerber
显示剩余21条评论

9

使用生成器提高内存效率

模拟数据

m, n = 480, 10000
dates = pd.date_range('1995-12-31', periods=m, freq='M', name='Date')
stocks = pd.Index(['s{:04d}'.format(i) for i in range(n)])
df = pd.DataFrame(np.random.rand(m, n), dates, stocks)
market = pd.Series(np.random.rand(m), dates, name='Market')
df = pd.concat([df, market], axis=1)

Beta Calculation

def beta(df, market=None):
    # If the market values are not passed,
    # I'll assume they are located in a column
    # named 'Market'.  If not, this will fail.
    if market is None:
        market = df['Market']
        df = df.drop('Market', axis=1)
    X = market.values.reshape(-1, 1)
    X = np.concatenate([np.ones_like(X), X], axis=1)
    b = np.linalg.pinv(X.T.dot(X)).dot(X.T).dot(df.values)
    return pd.Series(b[1], df.columns, name=df.index[-1])

roll function
这个函数返回一个生成器,它将更加高效地使用内存。

def roll(df, w):
    for i in range(df.shape[0] - w + 1):
        yield pd.DataFrame(df.values[i:i+w, :], df.index[i:i+w], df.columns)

将所有内容整合起来
betas = pd.concat([beta(sdf) for sdf in roll(df.pct_change().dropna(), 12)], axis=1).T

验证

OP beta calc

这里是关于验证的内容。
def calc_beta(df):
    np_array = df.values
    m = np_array[:,0] # market returns are column zero from numpy array
    s = np_array[:,1] # stock returns are column one from numpy array
    covariance = np.cov(s,m) # Calculate covariance between stock and market
    beta = covariance[0,1]/covariance[1,1]
    return beta

实验设置

m, n = 12, 2
dates = pd.date_range('1995-12-31', periods=m, freq='M', name='Date')

cols = ['Open', 'High', 'Low', 'Close']
dfs = {'s{:04d}'.format(i): pd.DataFrame(np.random.rand(m, 4), dates, cols) for i in range(n)}

market = pd.Series(np.random.rand(m), dates, name='Market')

df = pd.concat([market] + [dfs[k].Close.rename(k) for k in dfs.keys()], axis=1).sort_index(1)

betas = pd.concat([beta(sdf) for sdf in roll(df.pct_change().dropna(), 12)], axis=1).T

for c, col in betas.iteritems():
    dfs[c]['Beta'] = col

dfs['s0000'].head(20)

enter image description here

calc_beta(df[['Market', 's0000']])

0.0020118230147777435

注意:
计算方式相同。


内存效率问题让我深思。这个beta计算器是一样的,但滚动方式却很不同。另一个答案中的面板是将所有内容组合成通用结构的巧妙方法,可以一次又一次地进行计算。使用生成器只在beta计算时使用数据框的切片,然后继续执行。无论如何,我会再次检查计算。 - piRSquared
我最近在Python 3.4中遇到了以下代码问题: "df = pd.concat([market] + [dfs[k].Close.rename(k) for k in dfs.keys()], axis=1).sort_index(1)",似乎字典键的迭代与重命名函数不兼容...我得到了这个错误:TypeError: 'str' object is not callable。我尝试过谷歌搜索解决方案并尝试使用不同的迭代方法,如list()、iter()、items()等来迭代字典,但都无法解决问题!希望您能帮忙!谢谢! - cwse
谢谢您的快速回复!那很整洁,但是在那行还是得到相同错误:'...packages\pandas\core\internals.py",第4391行,在<listcomp>中 items = [func(x) for x in index] TypeError: 'str' object is not callable' 有任何想法吗?谢谢朋友! - cwse
我刚刚用3.5运行了它。 - piRSquared
可能是因为数据框名称是字符串吗?例如,要调用名为CSL的特定股票的数据框,我这样做:print(dfs['CSL'])... 然而,在较新版本的Python上,这个方法运行良好。 - cwse
显示剩余4条评论

3

高效地将输入数据集分成滚动窗口对于优化整体计算非常重要,但beta计算本身的性能也可以显著提高。

以下仅优化将数据集分成滚动窗口的过程:

def numpy_betas(x_name, window, returns_data, intercept=True):
    if intercept:
        ones = numpy.ones(window)

    def lstsq_beta(window_data):
        x_data = numpy.vstack([window_data[x_name], ones]).T if intercept else window_data[[x_name]]
        beta_arr, residuals, rank, s = numpy.linalg.lstsq(x_data, window_data)
        return beta_arr[0]

    indices = [int(x) for x in numpy.arange(0, returns_data.shape[0] - window + 1, 1)]
    return DataFrame(
        data=[lstsq_beta(returns_data.iloc[i:(i + window)]) for i in indices]
        , columns=list(returns_data.columns)
        , index=returns_data.index[window - 1::1]
    )

以下也优化了beta计算本身:
def custom_betas(x_name, window, returns_data):
    window_inv = 1.0 / window
    x_sum = returns_data[x_name].rolling(window, min_periods=window).sum()
    y_sum = returns_data.rolling(window, min_periods=window).sum()
    xy_sum = returns_data.mul(returns_data[x_name], axis=0).rolling(window, min_periods=window).sum()
    xx_sum = numpy.square(returns_data[x_name]).rolling(window, min_periods=window).sum()
    xy_cov = xy_sum - window_inv * y_sum.mul(x_sum, axis=0)
    x_var = xx_sum - window_inv * numpy.square(x_sum)
    betas = xy_cov.divide(x_var, axis=0)[window - 1:]
    betas.columns.name = None
    return betas

比较这两种不同计算方法的性能,可以看出随着beta计算中使用的窗口增大,第二种方法的性能显著优于第一种: enter image description here

将性能与@piRSquared实现的性能进行比较,自定义方法需要大约350毫秒来评估,而@piRSquared的实现需要超过2秒。


2

在 @piRSquared 的实现基础上,进一步优化了速度和内存。代码也更加简化以提高清晰度。

“Original Answer”翻译成中文为“最初的回答”。

from numpy import nan, ndarray, ones_like, vstack, random
from numpy.lib.stride_tricks import as_strided
from numpy.linalg import pinv
from pandas import DataFrame, date_range

def calc_beta(s: ndarray, m: ndarray):
  x = vstack((ones_like(m), m))
  b = pinv(x.dot(x.T)).dot(x).dot(s)
  return b[1]

def rolling_calc_beta(s_df: DataFrame, m_df: DataFrame, period: int):
  result = ndarray(shape=s_df.shape, dtype=float)
  l, w = s_df.shape
  ls, ws = s_df.values.strides
  result[0:period - 1, :] = nan
  s_arr = as_strided(s_df.values, shape=(l - period + 1, period, w), strides=(ls, ls, ws))
  m_arr = as_strided(m_df.values, shape=(l - period + 1, period), strides=(ls, ls))
  for row in range(period, l):
    result[row, :] = calc_beta(s_arr[row - period, :], m_arr[row - period])
  return DataFrame(data=result, index=s_df.index, columns=s_df.columns)

if __name__ == '__main__':
  num_sec_dfs, num_periods = 4000, 480

  dates = date_range('1995-12-31', periods=num_periods, freq='M', name='Date')
  stocks = DataFrame(data=random.rand(num_periods, num_sec_dfs), index=dates,
                   columns=['s{:04d}'.format(i) for i in 
                            range(num_sec_dfs)]).pct_change()
  market = DataFrame(data=random.rand(num_periods), index=dates, columns= 
              ['Market']).pct_change()
  betas = rolling_calc_beta(stocks, market, 12)

%timeit betas = rolling_calc_beta(stocks, market, 12)

335毫秒 ± 2.69毫秒每次循环(7次平均值±标准偏差,每个循环1次)

"Original Answer"翻译成"最初的回答"

2

这是最简单和最快的解决方案

对于我所需的内容,被接受的答案速度太慢了,而且我也不理解那些声称更快的解决方案背后的数学原理。虽然公正地说,他们给出了不同的答案,但可能只是我的问题。

我认为,在 pandas 1.1.4(或至少 .19)中,您不需要制作自定义滚动函数来计算 beta。以下代码假定数据与上述问题的格式相同--一个带有日期索引的 pandas 数据框,其中股票的百分比回报率和市场价值位于名为“Market”的列中。

如果您没有这种格式,我建议将股票回报与市场回报连接起来,以确保具有相同的索引:

# Use .pct_change() only if joining Close data
beta_data = stock_data.join(market_data), how = 'inner').pct_change().dropna()

之后,就只需要将协方差除以方差即可。

ticker_covariance = beta_data.rolling(window).cov()
# Limit results to the stock (i.e. column name for the stock) vs. 'Market' covariance
ticker_covariance = ticker_covariance.loc[pd.IndexSlice[:, stock], 'Market'].dropna()
benchmark_variance = beta_data['Market'].rolling(window).var().dropna()
beta = ticker_covariance / benchmark_variance

注意:如果您有多级索引,则必须删除非日期级别才能使用rolling().apply()解决方案。我仅测试了一个股票和一个市场的情况。如果您有多个股票,则可能需要在.loc之后修改ticker_covariance方程。最后,如果您想计算完整窗口之前的周期的beta值(例如,股票数据开始于1年前,但您使用3年的数据),则可以将上述内容修改为具有相同计算的扩展(而不是滚动)窗口,然后使用.combine_first()合并两者。


0

基于numpy和pandas创建了一个简单的python包finance-calculator,用于计算包括贝塔在内的金融比率。我使用了简单的公式(根据Investopedia的要求):

beta = covariance(returns, benchmark returns) / variance(benchmark returns)

在pandas中,协方差和方差可以直接计算,这使得速度非常快。同时,使用该包中的API也非常简单:

import finance_calculator as fc
beta = fc.get_beta(scheme_data, benchmark_data, tail=False)

如果tail为true,则会给您返回一个日期和beta的数据框,或者最后一个beta值。


-1

但是当您需要在多个股票(n)的日期(m)上进行beta计算时,这些计算将会变得非常笨重,导致(m x n)次计算。

可以通过在多个核心上运行每个日期或股票来缓解一些压力,但这样会导致需要大量硬件。

可用解决方案的主要时间需求是查找方差和协方差,并且应避免(Index和stock)数据中的NaN以便根据pandas==0.23.0进行正确计算。

因此,除非计算已被缓存,否则再次运行将导致愚蠢的举动。

如果不删除NaN,numpy方差和协方差版本也会发生误差,从而导致beta计算错误。

对于大型数据集,必须使用Cython实现。


在我看来,这应该作为对问题的评论发布,因为它并不是一个连贯的答案,只是一些评论的集合。如果您还没有评论特权,那么我建议您去赚取几个声望点数以获取此特权。 - Jean-François Corbett

网页内容由stack overflow 提供, 点击上面的
可以查看英文原文,
原文链接