Ранжирование элементов в массиве с использованием Python/NumPy

Ответ 1

Используйте нарезку в левой части на последнем шаге:

array = numpy.array([4,2,7,1])
temp = array.argsort()
ranks = numpy.empty_like(temp)
ranks[temp] = numpy.arange(len(array))

Это позволяет избежать сортировки дважды путем инвертирования перестановки на последнем шаге.

Ответ 2

Используйте argsort дважды, сначала для получения порядка массива, затем для получения рейтинга:

array = numpy.array([4,2,7,1])
order = array.argsort()
ranks = order.argsort()

При работе с массивами 2D (или более высокой размерности) обязательно передайте аргумент оси argsort для упорядочения по правильной оси.

Ответ 3

Этот вопрос несколько лет, и принятый ответ велик, но я думаю, что все еще стоит упомянуть. Если вы не против зависимости от scipy, вы можете использовать scipy.stats.rankdata:

In [22]: from scipy.stats import rankdata

In [23]: a = [4, 2, 7, 1]

In [24]: rankdata(a)
Out[24]: array([ 3.,  2.,  4.,  1.])

In [25]: (rankdata(a) - 1).astype(int)
Out[25]: array([2, 1, 3, 0])

Хорошей особенностью rankdata является то, что аргумент method предоставляет несколько вариантов обработки связей. Например, три события из 20 и два вхождения 40 в b:

In [26]: b = [40, 20, 70, 10, 20, 50, 30, 40, 20]

По умолчанию присваивается средний ранг связанным значениям:

In [27]: rankdata(b)
Out[27]: array([ 6.5,  3. ,  9. ,  1. ,  3. ,  8. ,  5. ,  6.5,  3. ])

method='ordinal' назначает последовательные ранги:

In [28]: rankdata(b, method='ordinal')
Out[28]: array([ 6.,  2.,  9.,  1.,  3.,  8.,  5.,  7.,  4.])

method='min' присваивает минимальный ранг связанным значения всем связанным значениям:

In [29]: rankdata(b, method='min')
Out[29]: array([ 6.,  2.,  9.,  1.,  2.,  8.,  5.,  6.,  2.])

Дополнительную информацию см. в docstring.

Ответ 4

Я попытался расширить оба решения для массивов A более одного измерения, предположив, что вы обрабатываете массив по строкам (ось = 1).

Я расширил первый код с помощью цикла на строках; возможно, его можно улучшить

temp = A.argsort(axis=1)
rank = np.empty_like(temp)
rangeA = np.arange(temp.shape[1])
for iRow in xrange(temp.shape[0]): 
    rank[iRow, temp[iRow,:]] = rangeA

И второй, следуя предложению k.rooijers, становится:

temp = A.argsort(axis=1)
rank = temp.argsort(axis=1)

Я произвольно сгенерировал 400 массивов с формой (1000 100); первый код занял около 7,5, второй - 3,8.

Ответ 5

Для векторизованной версии усредненного ранга см. ниже. Я люблю np.unique, он действительно расширяет рамки того, что код может и не может быть эффективно векторизован. Помимо исключения python for-loops, этот подход также избегает неявного двойного цикла над 'a'.

import numpy as np

a = np.array( [4,1,6,8,4,1,6])

a = np.array([4,2,7,2,1])
rank = a.argsort().argsort()

unique, inverse = np.unique(a, return_inverse = True)

unique_rank_sum = np.zeros_like(unique)
np.add.at(unique_rank_sum, inverse, rank)
unique_count = np.zeros_like(unique)
np.add.at(unique_count, inverse, 1)

unique_rank_mean = unique_rank_sum.astype(np.float) / unique_count

rank_mean = unique_rank_mean[inverse]

print rank_mean

Ответ 6

Использовать argsort() два раза:

>>> array = [4,2,7,1]
>>> ranks = numpy.array(array).argsort().argsort()
>>> ranks
array([2, 1, 3, 0])

Ответ 7

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

Итак, я написал модифицированное одномерное решение, добавив шаг проверки:

def ranks (v):
    import numpy as np
    t = np.argsort(v)
    r = np.empty(len(v),int)
    r[t] = np.arange(len(v))
    for i in xrange(1, len(r)):
        if v[t[i]] <= v[t[i-1]]: r[t[i]] = r[t[i-1]]
    return r

# test it
print sorted(zip(ranks(v), v))

Я считаю это настолько эффективным, насколько это возможно.

Ответ 8

Мне понравился метод k.rooijers, но, как писал rcoup, повторяющиеся числа оцениваются по позиции массива. Для меня это не помогло, поэтому я модифицировал версию, чтобы постобрачить ряды и объединить любые повторяющиеся числа в объединенный средний ранг:

import numpy as np
a = np.array([4,2,7,2,1])
r = np.array(a.argsort().argsort(), dtype=float)
f = a==a
for i in xrange(len(a)):
   if not f[i]: continue
   s = a == a[i]
   ls = np.sum(s)
   if ls > 1:
      tr = np.sum(r[s])
      r[s] = float(tr)/ls
   f[s] = False

print r  # array([ 3. ,  1.5,  4. ,  1.5,  0. ])

Я надеюсь, что это тоже поможет другим, я попытался найти другое решение для этого, но не смог найти...