关于熊猫数据框的分位数规范

Question

简单地说，如何在Python中对大熊猫数据框（可能是2,000,000行）应用分位数规范化？

PS。我知道有一个包名为rpy2可能在子跑R，使用R.位数正常化，但事实是，当我用数据设置如下R可以不计算正确的结果：

5.690386092696389541e-05,2.051450375415418849e-05,1.963190184049079707e-05,1.258362869906251862e-04,1.503352476021528139e-04,6.881341586355676286e-06 
8.535579139044583634e-05,5.128625938538547123e-06,1.635991820040899643e-05,6.291814349531259308e-05,3.006704952043056075e-05,6.881341586355676286e-06 
5.690386092696389541e-05,2.051450375415418849e-05,1.963190184049079707e-05,1.258362869906251862e-04,1.503352476021528139e-04,6.881341586355676286e-06 
2.845193046348194770e-05,1.538587781561563968e-05,2.944785276073619561e-05,4.194542899687506431e-05,6.013409904086112150e-05,1.0322e-05 

编辑：

我想要什么：上面显示

给出的数据，如何申请位数标准化按照https://en.wikipedia.org/wiki/Quantile_normalization步骤。

我发现一段代码在Python宣称它可以计算位数归一化：

import rpy2.robjects as robjects 
import numpy as np 
from rpy2.robjects.packages import importr 
preprocessCore = importr('preprocessCore') 


matrix = [ [1,2,3,4,5], [1,3,5,7,9], [2,4,6,8,10] ] 
v = robjects.FloatVector([ element for col in matrix for element in col ]) 
m = robjects.r['matrix'](v, ncol = len(matrix), byrow=False) 
Rnormalized_matrix = preprocessCore.normalize_quantiles(m) 
normalized_matrix = np.array(Rnormalized_matrix) 

的代码正常工作与在代码中使用的样本数据，但是当我测试它与数据定结果出错了。

由于ryp2提供了一个在python子进程中运行R的接口，我直接在R中再次测试它，结果仍然是错误的。因此我认为原因在于R中的方法是错误的。

Answer 1

好吧我自己实施的方法效率比较高。

完成后，这个逻辑看起来很容易，但无论如何，我决定在这里发布它，让任何人都感到困惑，就像当我无法使用可用的代码时一样。

的代码在github上：Quantile Normalize

Answer 2

使用示例数据集从Wikipedia article：

df = pd.DataFrame({'C1': {'A': 5, 'B': 2, 'C': 3, 'D': 4}, 
        'C2': {'A': 4, 'B': 1, 'C': 4, 'D': 2}, 
        'C3': {'A': 3, 'B': 4, 'C': 6, 'D': 8}}) 

df 
Out: 
    C1 C2 C3 
A 5 4 3 
B 2 1 4 
C 3 4 6 
D 4 2 8 

对于每个等级，平均值可以被计算如下：

rank_mean = df.stack().groupby(df.rank(method='first').stack().astype(int)).mean() 

rank_mean 
Out: 
1 2.000000 
2 3.000000 
3 4.666667 
4 5.666667 
dtype: float64 

然后由此产生的系列rank_mean可以用作排名以得到归一化结果的映射：

df.rank(method='min').stack().astype(int).map(rank_mean).unstack() 
Out: 
     C1  C2  C3 
A 5.666667 4.666667 2.000000 
B 2.000000 2.000000 3.000000 
C 3.000000 4.666667 4.666667 
D 4.666667 3.000000 5.666667 

Answer 3

可能使用每行中位数而非平均值更强大（基于Shawn的code。 L）：

def quantileNormalize(df_input): 
    df = df_input.copy() 
    #compute rank 
    dic = {} 
    for col in df: 
     dic[col] = df[col].sort_values(na_position='first').values 
    sorted_df = pd.DataFrame(dic) 
    #rank = sorted_df.mean(axis = 1).tolist() 
    rank = sorted_df.median(axis = 1).tolist() 
    #sort 
    for col in df: 
     # compute percentile rank [0,1] for each score in column 
     t = df[col].rank(pct=True, method='max').values 
     # replace percentile values in column with quantile normalized score 
     # retrieve q_norm score using calling rank with percentile value 
     df[col] = [ np.nanpercentile(rank, i*100) if ~np.isnan(i) else np.nan for i in t ] 
    return df 

Answer 4

下面的代码给出了相同的结果为preprocessCore::normalize.quantiles.use.target，我觉得它比上面的解决方案简单清晰。此外，性能应该可以达到巨大的阵列长度。

import numpy as np 

def quantile_normalize_using_target(x, target): 
    """ 
    Both `x` and `target` are numpy arrays of equal lengths. 
    """ 

    target_sorted = np.sort(target) 

    return target_sorted[x.argsort().argsort()] 

一旦有了pandas.DataFrame容易做到：

quantile_normalize_using_target(df[0].as_matrix(), 
           df[1].as_matrix()) 

（正火第一columnt到第二个如在上面的例子中的参考分布。）

Answer 5

我是熊猫的新手，但问题迟了，但我想答案也可能有用。它建立关从@ayhan伟大answer的：

def quantile_normalize(dataframe, cols, pandas=pd): 

    # copy dataframe and only use the columns with numerical values 
    df = dataframe.copy().filter(items=cols) 

    # columns from the original dataframe not specified in cols 
    non_numeric = dataframe.filter(items=list(filter(lambda col: col not in cols, list(dataframe)))) 


    rank_mean = df.stack().groupby(df.rank(method='first').stack().astype(int)).mean() 

    norm = df.rank(method='min').stack().astype(int).map(rank_mean).unstack() 


    result = pandas.concat([norm, non_numeric], axis=1) 
    return result 

这里的主要区别是更接近一些真实世界的应用。通常你只需要数字数据的矩阵，在这种情况下，原始答案就足够了。

有时候你也有基于文本的数据。这使您可以指定数字数据的列cols，并在这些列上运行分位数标准化。最后，它会将原始数据框中的非数字（或未规范化）列合并回来。

例如如果你添加了一些 '元数据'（char）的wiki例如：

df = pd.DataFrame({ 
    'rep1': [5, 2, 3, 4], 
    'rep2': [4, 1, 4, 2], 
    'rep3': [3, 4, 6, 8], 
    'char': ['gene_a', 'gene_b', 'gene_c', 'gene_d'] 
}, index = ['a', 'b', 'c', 'd']) 

，你可以调用

quantile_normalize(t, ['rep1', 'rep2', 'rep3']) 

得到

rep1  rep2  rep3  char 
a 5.666667 4.666667 2.000000 gene_a 
b 2.000000 2.000000 3.000000 gene_b 
c 3.000000 4.666667 4.666667 gene_c 
d 4.666667 3.000000 5.666667 gene_d