Квантильная нормализация в кадре данных pandas

Используя пример набора данных из статьи Википедии:

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

Хорошо, я реализовал метод относительно высокой эффективности.

После завершения эта логика кажется довольно простой, но, тем не менее, я решил опубликовать ее здесь для тех, кто чувствует себя сбитым с толку, как я был, когда я не мог погуглить доступный код.

Код находится на github: Quantile Normalize

Стоит отметить, что и код Айхана, и код Шона используют меньшее среднее значение ранга для связей, но если вы используете normalize.quantiles() пакета R, он будет использовать среднее значение рангов для связей.

Используя приведенный выше пример:

> df

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

> normalize.quantiles(as.matrix(df))

         C1        C2        C3
A  5.666667  5.166667  2.000000
B  2.000000  2.000000  3.000000
C  3.000000  5.166667  4.666667
D  4.666667  3.000000  5.666667

Код ниже дает тот же результат, что и 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())

(Нормализация первого столбца ко второму в качестве эталонного распределения в приведенном выше примере.)

Это незначительная корректировка, но я полагаю, что многие заметили тонкий «недостаток» в ответе @ayhan.

Я внес в него небольшую корректировку, которая дает «правильный» ответ, при этом не прибегая к каким-либо внешним библиотекам для такой чрезвычайно простой функции.

Единственная необходимая корректировка — это раздел [Add interpolated values].

import pandas as pd

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}})

def quant_norm(df):
    ranks = (df.rank(method="first")
              .stack())
    rank_mean = (df.stack()
                   .groupby(ranks)
                   .mean())
    # Add interpolated values in between ranks
    finer_ranks = ((rank_mean.index+0.5).to_list() +
                    rank_mean.index.to_list())
    rank_mean = rank_mean.reindex(finer_ranks).sort_index().interpolate()
    return (df.rank(method='average')
              .stack()
              .map(rank_mean)
              .unstack())
quant_norm(df)

Out[122]: 
         C1        C2        C3
A  5.666667  5.166667  2.000000
B  2.000000  2.000000  3.000000
C  3.000000  5.166667  4.666667
D  4.666667  3.000000  5.666667

Возможно, более надежно использовать медиану в каждой строке, а не среднее значение (на основе кода от Шона. Л):

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

Я новичок в пандах и опаздываю на вопрос, но я думаю, что ответ также может быть полезен. Он основан на отличном ответе от @ayhan:

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) в пример вики:

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

Как указывает @msg, ни одно из решений здесь не учитывает связи. Я сделал пакет Python под названием qnorm, который обрабатывает связи и правильно воссоздает Пример квантильной нормализации из Википедии:

import pandas as pd
import qnorm

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}})

print(qnorm.quantile_normalize(df))
         C1        C2        C3
A  5.666667  5.166667  2.000000
B  2.000000  2.000000  3.000000
C  3.000000  5.166667  4.666667
D  4.666667  3.000000  5.666667

Установка может быть выполнена с помощью pip или conda

pip install qnorm

or

conda config --add channels conda-forge
conda install qnorm