繁体   English   中英

Pandas扩展/滚动窗口相关性计算与p值

[英]Pandas expanding/rolling window correlation calculation with p-value

假设我有一个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值是定义一个定制的滚动功能,并通过applygroupby对象

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值,而不是在矢量化速度下扩展窗口吗?

我想不出一个聪明的方法在直接使用rolling熊猫中做到这一点,但请注意,你可以计算给定相关系数的p值。

Pearson的相关系数遵循学生的t分布,你可以通过将p值插入由不完整beta函数scipy.special.betainc定义的cdf来获得p值。 这听起来很复杂,但可以在几行代码中完成。 下面是给定相关系数corr和样本大小n计算p值的函数。 它实际上是基于你一直在使用的scipy的实现

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

corr2_coeff_rowwise列出了如何在行之间进行元素相关。 我们可以将其拆分为两列之间的元素相关性的情况。 因此,我们最终会得到一个使用corr2_coeff_rowwise的循环。 然后,我们会尝试对其进行矢量化,并看到其中有可以进行矢量化的部分:

  1. mean获得平均值。 这可以使用均匀滤波器进行矢量化。
  2. 接下来是获得这些平均值与输入数组中的滑动元素之间的差异。 要移植到矢量化的,我们将使用broadcasting

休息保持不变,从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似乎在这个数据集上花了很长时间,很可能是因为它的步骤#2的内存需求。

  • 使用numba funcs中后的瓶颈,然后转移到与p-VAL计算special.btdtr

暂无
暂无

声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.

 
粤ICP备18138465号  © 2020-2024 STACKOOM.COM