矩阵的所有行对的相关系数和 p 值答案

【问题标题】：Correlation coefficients and p values for all pairs of rows of a matrix矩阵的所有行对的相关系数和 p 值
【发布时间】：2014-08-17 09:35:23
【问题描述】：

我有一个矩阵data，其中有 m 行和 n 列。我曾经使用np.corrcoef 计算所有行对之间的相关系数：

import numpy as np
data = np.array([[0, 1, -1], [0, -1, 1]])
np.corrcoef(data)

现在我还想看看这些系数的 p 值。 np.corrcoef 不提供这些； scipy.stats.pearsonr 确实如此。但是，scipy.stats.pearsonr 不接受输入矩阵。

有没有一种快速的方法来计算所有行对的系数和 p 值（例如，通过 m 矩阵到达两个 m，其中一个相关系数，另一个具有相应的 p 值），而无需手动遍历所有对？

【问题讨论】：

是否有理由不只遍历行对？这有点笨拙，但代码不是很长，而且很可能不会成为性能问题，因为大部分时间都花在计算 pearsons 上。（即您是指编程时间中的“快速”还是性能中的“快速”。）我建议您采取琐碎的路线并分析实际性能。

标签： python numpy statistics scipy correlation

【解决方案1】：

我今天也遇到了同样的问题。

经过半小时的谷歌搜索，我在 numpy/scipy 库中找不到任何代码可以帮助我做到这一点。

所以我写了自己的corrcoef

import numpy as np
from scipy.stats import pearsonr, betai

def corrcoef(matrix):
    r = np.corrcoef(matrix)
    rf = r[np.triu_indices(r.shape[0], 1)]
    df = matrix.shape[1] - 2
    ts = rf * rf * (df / (1 - rf * rf))
    pf = betai(0.5 * df, 0.5, df / (df + ts))
    p = np.zeros(shape=r.shape)
    p[np.triu_indices(p.shape[0], 1)] = pf
    p[np.tril_indices(p.shape[0], -1)] = p.T[np.tril_indices(p.shape[0], -1)]
    p[np.diag_indices(p.shape[0])] = np.ones(p.shape[0])
    return r, p

def corrcoef_loop(matrix):
    rows, cols = matrix.shape[0], matrix.shape[1]
    r = np.ones(shape=(rows, rows))
    p = np.ones(shape=(rows, rows))
    for i in range(rows):
        for j in range(i+1, rows):
            r_, p_ = pearsonr(matrix[i], matrix[j])
            r[i, j] = r[j, i] = r_
            p[i, j] = p[j, i] = p_
    return r, p

第一个版本使用np.corrcoef的结果，然后根据corrcoef矩阵的三角形上值计算p值。

第二个循环版本只是遍历行，手动执行 pearsonr。

def test_corrcoef():
    a = np.array([
        [1, 2, 3, 4],
        [1, 3, 1, 4],
        [8, 3, 8, 5],
        [2, 3, 2, 1]])

    r1, p1 = corrcoef(a)
    r2, p2 = corrcoef_loop(a)

    assert np.allclose(r1, r2)
    assert np.allclose(p1, p2)

测试通过了，它们是一样的。

def test_timing():
    import time
    a = np.random.randn(100, 2500)

    def timing(func, *args, **kwargs):
        t0 = time.time()
        loops = 10
        for _ in range(loops):
            func(*args, **kwargs)
        print('{} takes {} seconds loops={}'.format(
            func.__name__, time.time() - t0, loops))

    timing(corrcoef, a)
    timing(corrcoef_loop, a)


if __name__ == '__main__':
    test_corrcoef()
    test_timing()

我的 Macbook 针对 100x2500 矩阵的性能

corrcoef 需要 0.06608104705810547 秒 loops=10

corrcoef_loop 需要 7.585600137710571 秒 loops=10

【讨论】：

此代码在 scipy 1.0.0 中失败，因为 beta 函数在弃用后已被删除。应该在 scipy.special 模块中使用 betainc。
感谢这个解决方案，对我帮助很大！请注意，当您比较相同的特征时，此实现中的 pvalue 设置为 0（它在对角线上返回 0）。但是，例如，scipy.stats.pearsonr 在这些情况下会返回 p=1。
@MartinBecker 你的意思是相反的吗？此实现在对角线上返回 1，而 corr, pvalue = scipy.stats.pearsonr(x, x) 中的 pvalue （其中 x 是任何数组）等于 0.0。
@Ouroboroski 是的，我就是这个意思；）谢谢。

【解决方案2】：

最简洁的方法可能是pandas中的内置方法.corr，来获取r：

In [79]:

import pandas as pd
m=np.random.random((6,6))
df=pd.DataFrame(m)
print df.corr()
          0         1         2         3         4         5
0  1.000000 -0.282780  0.455210 -0.377936 -0.850840  0.190545
1 -0.282780  1.000000 -0.747979 -0.461637  0.270770  0.008815
2  0.455210 -0.747979  1.000000 -0.137078 -0.683991  0.557390
3 -0.377936 -0.461637 -0.137078  1.000000  0.511070 -0.801614
4 -0.850840  0.270770 -0.683991  0.511070  1.000000 -0.499247
5  0.190545  0.008815  0.557390 -0.801614 -0.499247  1.000000

使用 t-test 得到 p 值：

In [84]:

n=6
r=df.corr()
t=r*np.sqrt((n-2)/(1-r*r))

import scipy.stats as ss
ss.t.cdf(t, n-2)
Out[84]:
array([[ 1.        ,  0.2935682 ,  0.817826  ,  0.23004382,  0.01585695,
         0.64117917],
       [ 0.2935682 ,  1.        ,  0.04363408,  0.17836685,  0.69811422,
         0.50661121],
       [ 0.817826  ,  0.04363408,  1.        ,  0.39783538,  0.06700715,
         0.8747497 ],
       [ 0.23004382,  0.17836685,  0.39783538,  1.        ,  0.84993082,
         0.02756579],
       [ 0.01585695,  0.69811422,  0.06700715,  0.84993082,  1.        ,
         0.15667393],
       [ 0.64117917,  0.50661121,  0.8747497 ,  0.02756579,  0.15667393,
         1.        ]])
In [85]:

ss.pearsonr(m[:,0], m[:,1])
Out[85]:
(-0.28277983892175751, 0.58713640696703184)
In [86]:
#be careful about the difference of 1-tail test and 2-tail test:
0.58713640696703184/2
Out[86]:
0.2935682034835159 #the value in ss.t.cdf(t, n-2) [0,1] cell

您也可以使用您在 OP 中提到的scipy.stats.pearsonr：

In [95]:
#returns a list of tuples of (r, p, index1, index2)
import itertools
[ss.pearsonr(m[:,i],m[:,j])+(i, j) for i, j in itertools.product(range(n), range(n))]
Out[95]:
[(1.0, 0.0, 0, 0),
 (-0.28277983892175751, 0.58713640696703184, 0, 1),
 (0.45521036266021014, 0.36434799921123057, 0, 2),
 (-0.3779357902414715, 0.46008763115463419, 0, 3),
 (-0.85083961671703368, 0.031713908656676448, 0, 4),
 (0.19054495489542525, 0.71764166168348287, 0, 5),
 (-0.28277983892175751, 0.58713640696703184, 1, 0),
 (1.0, 0.0, 1, 1),
#etc, etc

【讨论】：

澄清一下，你原来的函数是计算双边检验的p值，然后除以2得到单边检验的p值，对吗？是的，在你 7 年前的帖子之后，这仍然没有在 numpy 和 scipy 中实现

【解决方案3】：

有点老套，可能效率低下，但我认为这可能是您正在寻找的：

import scipy.spatial.distance as dist

import scipy.stats as ss

# Pearson's correlation coefficients
print dist.squareform(dist.pdist(data, lambda x, y: ss.pearsonr(x, y)[0]))    

# p-values
print dist.squareform(dist.pdist(data, lambda x, y: ss.pearsonr(x, y)[1]))

Scipy's pdist 是一个非常有用的函数，主要用于查找 n 维空间中的观测值之间的成对距离。

但它允许用户定义可调用的“距离度量”，可用于执行任何类型的成对操作。结果以压缩的距离矩阵形式返回，可以使用Scipy's 'squareform' function轻松将其更改为方阵形式。

【讨论】：

您可以使用metric='correlation'，而不是传递您自己的Python函数来计算相关系数，它等于（1 - 相关系数），并且用C编码（所以应该更有效)。
他也在寻找 p 值。如果您使用内置的相关指标，您将无法获得 p 值。
您可以相当容易地从相关系数中得出 p 值（参见 jingchao 的答案和 here）
（也是CT Zhu的回答）
这种方法满足了我的需求，而且对我来说似乎很简单。请遵循最适合您的任何答案。

【解决方案4】：

如果你不必使用pearson correlation coefficient，你可以使用spearman correlation coefficient，因为它返回相关矩阵和p值（注意前者要求你的数据是正态分布的，而spearman相关是非参数度量，因此不假设数据的正态分布）。示例代码：

from scipy import stats
import numpy as np

data = np.array([[0, 1, -1], [0, -1, 1], [0, 1, -1]])
print 'np.corrcoef:', np.corrcoef(data)
cor, pval = stats.spearmanr(data.T)
print 'stats.spearmanr - cor:\n', cor
print 'stats.spearmanr - pval\n', pval

【讨论】：

【解决方案5】：

这与 MATLAB 中的 corrcoef 性能完全相同：

要使用此功能，您需要安装 pandas 和 scipy。

# Compute correlation correfficients matrix and p-value matrix
# Similar function as corrcoef in MATLAB
# dframe: pandas dataframe
def corrcoef(dframe):

    fmatrix = dframe.values
    rows, cols = fmatrix.shape

    r = np.ones((cols, cols), dtype=float)
    p = np.ones((cols, cols), dtype=float)

    for i in range(cols):
        for j in range(cols):
            if i == j:
                r_, p_ = 1., 1.
            else:
                r_, p_ = pearsonr(fmatrix[:,i], fmatrix[:,j])

            r[j][i] = r_
            p[j][i] = p_

    return r, p

【讨论】：

【解决方案6】：

这是@CT Zhu 回答的最小版本。我们不需要pandas，因为可以直接从numpy 计算相关性，这应该更快，因为我们不需要转换为数据帧的步骤

import numpy as np
import scipy.stats as ss

def corr_significance_two_sided(cc, nData):
    # We will divide by 0 if correlation is exactly 1, but that is no problem
    # We would simply set the test statistic to be infinity if it evaluates to NAN
    with np.errstate(divide='ignore'):
        t = -np.abs(cc) * np.sqrt((nData - 2) / (1 - cc**2))
        t[t == np.nan] = np.inf
        return ss.t.cdf(t, nData - 2) * 2  # multiply by two to get two-sided p-value

x = np.random.uniform(0, 1, (8, 1000))
cc = np.corrcoef(x)
pVal = corr_significance_two_sided(cc, 1000)

【讨论】：