web-dev-qa-db-ja.com

Pandas p値を使用した拡張/ローリングウィンドウ相関計算

2つの列間のピアソン相関のローリングまたは拡張を計算するDataFrameがあるとします。

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関数を拡張する方法がわかりません。

ベクトル化された速度でウィンドウを拡張してp値を取得するためにnumpyを利用する方向に誰かが私を向けることはできますか？

pythonpandasnumpyoptimizationvectorization
14
M Horsley

pandasを直接使用してrollingでこれを行うための賢い方法は考えられませんでしたが、相関係数を指定するとp値を計算できることに注意してください。

ピアソンの相関係数はスチューデントのt分布に従い、不完全なベータ関数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)

これは完全なベクトル化された派手なソリューションではないかもしれませんが、相関を何度も計算するよりも数十倍高速である必要があります。

5
AlCorreia

アプローチ＃1

corr2_coeff_rowwise 行間の要素ごとの相関を行う方法をリストします。 2つの列間の要素ごとの相関の場合にそれを細かくすることができます。そのため、corr2_coeff_rowwiseを使用するループが発生します。次に、それをベクトル化して、ベクトル化できる部分があることを確認します。

  1. meanを使用して平均値を取得します。これは、均一フィルターを使用してベクトル化できます。
  2. 次は、入力配列からのスライド要素に対するこれらの平均値の違いを取得することでした。ベクトル化されたものに移植するには、broadcastingを使用します。

Restは同じままで、pearsonrからの2つの出力から最初の出力を取得します。

2番目の出力を取得するには、 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

したがって、pandasシリーズからの入力から最終的な出力を取得するには-

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関数を使用した後のボトルネックは、special.btdtrを使用してp-val計算に移行します。

3
Divakar