假设我有一个DataFrame,要在其上计算两列之间的滚动或扩展Pearson相关性
import numpy as np
import pandas as pd
import scipy.stats as st
df = pd.DataFrame({'x': np.random.rand(10000), 'y': np.random.rand(10000)})
借助内置的pandas
功能,计算此速度非常快
expanding_corr = df['x'].expanding(50).corr(df['y'])
rolling_corr = df['x'].rolling(50).corr(df['y'])
但是,如果我希望获得与这些关联相关的p值,我能做的最好的事情就是定义一个自定义滚动函数并将apply
传递给groupby
对象
def custom_roll(df, w, **kwargs):
v = df.values
d0, d1 = v.shape
s0, s1 = v.strides
a = np.lib.stride_tricks.as_strided(v, (d0 - (w - 1), w, d1), (s0, s0, s1))
rolled_df = pd.concat({
row: pd.DataFrame(values, columns=df.columns)
for row, values in zip(df.index[(w-1):], a)
})
return rolled_df.groupby(level=0, **kwargs)
c_df = custom_roll(df, 50).apply(lambda df: st.pearsonr(df['x'], df['y']))
c_df
现在包含适当的相关性,重要的是它们包含相关的p值。
但是,与内置的pandas
方法相比,该方法非常慢,这意味着它不适合,因为实际上我在优化过程中计算了数千次相关性。此外,我不确定如何扩展custom_roll
函数来扩展窗口。
有人能指出我朝着利用numpy
获取矢量化速度扩展窗口上的p值的方向吗?
答案 0 :(得分:4)
我想不出一个聪明的方法直接在rolling
的熊猫中做到这一点,但是请注意,给定相关系数,您可以计算出p值。
Pearson的相关系数服从Student的t分布,您可以通过将p值插入不完全beta函数scipy.special.betainc
定义的cdf来获得p值。听起来很复杂,但是可以用几行代码完成。以下是在给定相关系数corr
和样本大小n
的情况下计算p值的函数。它实际上是基于您一直在使用的scipy's implementation。
import pandas as pd
from scipy.special import betainc
def pvalue(corr, n=50):
df = n - 2
t_squared = corr**2 * (df / ((1.0 - corr) * (1.0 + corr)))
prob = betainc(0.5*df, 0.5, df/(df+t_squared))
return prob
然后您可以将此功能应用于已经具有的相关值。
rolling_corr = df['x'].rolling(50).corr(df['y'])
pvalue(rolling_corr)
它可能不是完美的矢量化numpy解决方案,但比一遍又一遍地计算相关性要快几十倍。
答案 1 :(得分:3)
方法1
corr2_coeff_rowwise
列出了如何在行之间进行元素相关的关联。我们可以将其简化为两列之间元素相关的情况。因此,我们最终将得到一个使用corr2_coeff_rowwise
的循环。然后,我们将尝试对其进行矢量化处理,然后查看其中的某些部分可以进行矢量化处理:
mean
获取平均值。可以使用统一过滤器将其矢量化。broadcasting
。 Rest保持不变,以从pearsonr
的两个输出中获得第一个。
要获得第二个输出,我们返回到source code
。给定第一个系数输出,这应该很简单。
因此,考虑到这些,我们最终会得到这样的东西-
import scipy.special as special
from scipy.ndimage import uniform_filter
def sliding_corr1(a,b,W):
# a,b are input arrays; W is window length
am = uniform_filter(a.astype(float),W)
bm = uniform_filter(b.astype(float),W)
amc = am[W//2:-W//2+1]
bmc = bm[W//2:-W//2+1]
da = a[:,None]-amc
db = b[:,None]-bmc
# Get sliding mask of valid windows
m,n = da.shape
mask1 = np.arange(m)[:,None] >= np.arange(n)
mask2 = np.arange(m)[:,None] < np.arange(n)+W
mask = mask1 & mask2
dam = (da*mask)
dbm = (db*mask)
ssAs = np.einsum('ij,ij->j',dam,dam)
ssBs = np.einsum('ij,ij->j',dbm,dbm)
D = np.einsum('ij,ij->j',dam,dbm)
coeff = D/np.sqrt(ssAs*ssBs)
n = W
ab = n/2 - 1
pval = 2*special.btdtr(ab, ab, 0.5*(1 - abs(np.float64(coeff))))
return coeff,pval
因此,要从熊猫系列的输入中获取最终输出-
out = sliding_corr1(df['x'].to_numpy(copy=False),df['y'].to_numpy(copy=False),50)
方法2
与Approach #1
非常相似,但是我们将使用numba
来提高内存效率,以取代先前方法中的步骤2。
from numba import njit
import math
@njit(parallel=True)
def sliding_corr2_coeff(a,b,amc,bmc):
L = len(a)-W+1
out00 = np.empty(L)
for i in range(L):
out_a = 0
out_b = 0
out_D = 0
for j in range(W):
d_a = a[i+j]-amc[i]
d_b = b[i+j]-bmc[i]
out_D += d_a*d_b
out_a += d_a**2
out_b += d_b**2
out00[i] = out_D/math.sqrt(out_a*out_b)
return out00
def sliding_corr2(a,b,W):
am = uniform_filter(a.astype(float),W)
bm = uniform_filter(b.astype(float),W)
amc = am[W//2:-W//2+1]
bmc = bm[W//2:-W//2+1]
coeff = sliding_corr2_coeff(a,b,amc,bmc)
ab = W/2 - 1
pval = 2*special.btdtr(ab, ab, 0.5*(1 - abs(np.float64(coeff))))
return coeff,pval
方法3
与上一个非常相似,除了我们将所有系数工作推到numba
-
@njit(parallel=True)
def sliding_corr3_coeff(a,b,W):
L = len(a)-W+1
out00 = np.empty(L)
for i in range(L):
a_mean = 0.0
b_mean = 0.0
for j in range(W):
a_mean += a[i+j]
b_mean += b[i+j]
a_mean /= W
b_mean /= W
out_a = 0
out_b = 0
out_D = 0
for j in range(W):
d_a = a[i+j]-a_mean
d_b = b[i+j]-b_mean
out_D += d_a*d_b
out_a += d_a*d_a
out_b += d_b*d_b
out00[i] = out_D/math.sqrt(out_a*out_b)
return out00
def sliding_corr3(a,b,W):
coeff = sliding_corr3_coeff(a,b,W)
ab = W/2 - 1
pval = 2*special.btdtr(ab, ab, 0.5*(1 - np.abs(coeff)))
return coeff,pval
时间-
In [181]: df = pd.DataFrame({'x': np.random.rand(10000), 'y': np.random.rand(10000)})
In [182]: %timeit sliding_corr2(df['x'].to_numpy(copy=False),df['y'].to_numpy(copy=False),50)
100 loops, best of 3: 5.05 ms per loop
In [183]: %timeit sliding_corr3(df['x'].to_numpy(copy=False),df['y'].to_numpy(copy=False),50)
100 loops, best of 3: 5.51 ms per loop
注意:
sliding_corr1
似乎在此数据集上花费的时间很长,很可能是由于其第二步的内存需求。
使用numba函数的瓶颈,然后使用special.btdtr
转移到p-val计算。