web-dev-qa-db-ja.com

pandas統計的有意性を持つ列相関

pandasデータフレーム、df、列間の相関関係を取得するdf.1およびdf.2

出力でNaNを含む行をカウントしたくないのですが、これはpandas組み込み相関が行います。しかし、pvalueまたは標準エラーを出力することも必要です。これは組み込みでは出力されません。

SciPyはNaNに巻き込まれたようですが、重要性を報告していると思います。

データの例:

     1           2
0    2          NaN
1    NaN         1
2    1           2
3    -4          3
4    1.3         1
5    NaN         NaN
17
wolfsatthedoor

@Shashankが提供する回答は素晴らしいです。ただし、純粋なpandasでソリューションが必要な場合は、次のようにすることができます。

import pandas as pd
from pandas.io.data import DataReader
from datetime import datetime
import scipy.stats  as stats


gdp = pd.DataFrame(DataReader("GDP", "fred", start=datetime(1990, 1, 1)))
vix = pd.DataFrame(DataReader("VIXCLS", "fred", start=datetime(1990, 1, 1)))

#Do it with a pandas regression to get the p value from the F-test
df = gdp.merge(vix,left_index=True, right_index=True, how='left')
vix_on_gdp = pd.ols(y=df['VIXCLS'], x=df['GDP'], intercept=True)
print(df['VIXCLS'].corr(df['GDP']), vix_on_gdp.f_stat['p-value'])

結果:

-0.0422917932738 0.851762475093

統計関数と同じ結果:

#Do it with stats functions. 
df_clean = df.dropna()
stats.pearsonr(df_clean['VIXCLS'], df_clean['GDP'])

結果:

  (-0.042291793273791969, 0.85176247509284908)

より多くの変数に拡張するために、Iいループベースのアプローチを提供します:

#Add a third field
oil = pd.DataFrame(DataReader("DCOILWTICO", "fred", start=datetime(1990, 1, 1))) 
df = df.merge(oil,left_index=True, right_index=True, how='left')

#construct two arrays, one of the correlation and the other of the p-vals
rho = df.corr()
pval = np.zeros([df.shape[1],df.shape[1]])
for i in range(df.shape[1]): # rows are the number of rows in the matrix.
    for j in range(df.shape[1]):
        JonI        = pd.ols(y=df.icol(i), x=df.icol(j), intercept=True)
        pval[i,j]  = JonI.f_stat['p-value']

Rhoの結果:

             GDP    VIXCLS  DCOILWTICO
 GDP         1.000000 -0.042292    0.870251
 VIXCLS     -0.042292  1.000000   -0.004612
 DCOILWTICO  0.870251 -0.004612    1.000000

Pvalの結果:

 [[  0.00000000e+00   8.51762475e-01   1.11022302e-16]
  [  8.51762475e-01   0.00000000e+00   9.83747425e-01]
  [  1.11022302e-16   9.83747425e-01   0.00000000e+00]]
11
BKay

scipy.stats 相関関数を使用して、p値を取得できます。

たとえば、ピアソン相関などの相関を探している場合は、 pearsonr 関数を使用できます。

from scipy.stats import pearsonr
pearsonr([1, 2, 3], [4, 3, 7])

出力する

(0.7205766921228921, 0.48775429164459994)

Tupleの最初の値は相関値で、2番目の値はp値です。

あなたの場合、パンダのdropna関数を使用してNaN値を最初に削除できます。

df_clean = df[['column1', 'column2']].dropna()
pearsonr(df_clean['column1'], df_clean['column2'])
23

一度にすべてのp値を計算するには、以下の_calculate_pvalues_関数を使用できます。

_df = pd.DataFrame({'A':[1,2,3], 'B':[2,5,3], 'C':[5,2,1], 'D':['text',2,3] })
calculate_pvalues(df) 
_
  • 出力はcorr()と同様(ただしp値を使用)です。

    _        A       B       C
    A       0  0.7877  0.1789
    B  0.7877       0  0.6088
    C  0.1789  0.6088       0
    _
  • p値は小数点以下4桁に丸められます

  • 列Dは無視されますテキストが含まれているため。
  • 正確な列を示すこともできます:_calculate_pvalues(df[['A','B','C']]_

以下は関数のコードです。

_from scipy.stats import pearsonr
import pandas as pd

def calculate_pvalues(df):
    df = df.dropna()._get_numeric_data()
    dfcols = pd.DataFrame(columns=df.columns)
    pvalues = dfcols.transpose().join(dfcols, how='outer')
    for r in df.columns:
        for c in df.columns:
            pvalues[r][c] = round(pearsonr(df[r], df[c])[1], 4)
    return pvalues
_
14
toto_tico
rho = df.corr()
rho = rho.round(2)
pval = calculate_pvalues(df) # toto_tico's answer
# create three masks
r1 = rho.applymap(lambda x: '{}*'.format(x))
r2 = rho.applymap(lambda x: '{}**'.format(x))
r3 = rho.applymap(lambda x: '{}***'.format(x))
# apply them where appropriate
rho = rho.mask(pval<=0.1,r1)
rho = rho.mask(pval<=0.05,r2)
rho = rho.mask(pval<=0.01,r3)
rho
# note I prefer readability over the conciseness of code, 
# instead of six lines it could have been a single liner like this:
# [rho.mask(pval<=p,rho.applymap(lambda x: '{}*'.format(x)),inplace=True) for p in [.1,.05,.01]]

Correlations with asterisks

8
tozCSS

関数内のロジックを合計しようとしましたが、これは最も効率的なアプローチではないかもしれませんが、pandas df.corr()と同様の出力を提供します。これを使用するには、コード内の次の関数を呼び出し、データフレームオブジェクトを提供して呼び出しますcorr_pvalue(your_dataframe)

値を小数点以下4桁に丸めました。別の出力が必要な場合は、関数roundで値を変更してください。

from scipy.stats import pearsonr
import numpy as np
import pandas as pd

def corr_pvalue(df):


    numeric_df = df.dropna()._get_numeric_data()
    cols = numeric_df.columns
    mat = numeric_df.values

    arr = np.zeros((len(cols),len(cols)), dtype=object)

    for xi, x in enumerate(mat.T):
        for yi, y in enumerate(mat.T[xi:]):
            arr[xi, yi+xi] = map(lambda _: round(_,4), pearsonr(x,y))
            arr[yi+xi, xi] = arr[xi, yi+xi]

    return pd.DataFrame(arr, index=cols, columns=cols)

私はそれをpandas v0.18.1でテストしました

2
Somendra Joshi

pandas v0.24.0でmethod引数がcorrに追加されました。これで、次のことができます。

_import pandas as pd
import numpy as np
from scipy.stats import pearsonr

df = pd.DataFrame({'A':[1,2,3], 'B':[2,5,3], 'C':[5,2,1]})

df.corr(method=lambda x, y: pearsonr(x, y)[1]) - np.eye(len(df.columns)) 
_
_          A         B         C
A  0.000000  0.787704  0.178912
B  0.787704  0.000000  0.608792
C  0.178912  0.608792  0.000000
_

自己相関は常に_1.0_に設定されるため、必要なnp.eye(len(df.columns))の回避策に注意してください( https://github.com/pandas-dev/pandas/issuesを参照)/25726 )。

2
Fabian Rost

@toto_ticoと@ Somendra-joshiからのすばらしい回答。ただし、不要なNA値は削除されます。このスニペットでは、現在計算中の相関関係に属するNAを削除しています。実際の corr implementation では、同じことを行います。

def calculate_pvalues(df):
    df = df._get_numeric_data()
    dfcols = pd.DataFrame(columns=df.columns)
    pvalues = dfcols.transpose().join(dfcols, how='outer')
    for r in df.columns:
        for c in df.columns:
            if c == r:
                df_corr = df[[r]].dropna()
            else:
                df_corr = df[[r,c]].dropna()
            pvalues[r][c] = pearsonr(df_corr[r], df_corr[c])[1]
    return pvalues
1
Matheus Araujo

これはoztalhaによる非常に便利なコードでした。 rが重要でない場合は、フォーマットを変更しました(2桁に丸められました)。

    rho = data.corr()
    pval = calculate_pvalues(data) # toto_tico's answer
    # create three masks
    r1 = rho.applymap(lambda x: '{:.2f}*'.format(x))
    r2 = rho.applymap(lambda x: '{:.2f}**'.format(x))
    r3 = rho.applymap(lambda x: '{:.2f}***'.format(x))
    r4 = rho.applymap(lambda x: '{:.2f}'.format(x))
    # apply them where appropriate --this could be a single liner
    rho = rho.mask(pval>0.1,r4)
    rho = rho.mask(pval<=0.1,r1)
    rho = rho.mask(pval<=0.05,r2)
    rho = rho.mask(pval<=0.01,r3)
    rho
1
user2730303