使用 Python/NumPy 對數組中的項目進行排名，無需對數組進行兩次排序

Question

我有一個數字數組，我想創建另一個數組來表示第一個數組中每個項目的排名。 我正在使用 Python 和 NumPy。

例如：

array = [4,2,7,1]
ranks = [2,1,3,0]

這是我想出的最好的方法：

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

有沒有更好/更快的方法可以避免對數組進行兩次排序？

Answer 1

使用 argsort 兩次，首先獲取數組的順序，然后獲取排名：

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

處理 2D（或更高維）數組時，請確保將軸參數傳遞給 argsort 以在正確的軸上排序。

Answer 2

這個問題已經有幾年了，接受的答案很好，但我認為以下仍然值得一提。 如果你不介意對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參數提供了幾個處理關系的選項。 例如，在b有 3 次 20 和 2 次 40 ：

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

有關更多選項，請參閱文檔字符串。

Answer 3

在最后一步的左側使用高級索引：

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

這通過反轉最后一步中的排列來避免排序兩次。

Answer 4

有關平均排名的矢量化版本，請參見下文。 我喜歡 np.unique，它確實拓寬了可以和不可以有效矢量化代碼的范圍。 除了避免python for循環之外，這種方法還避免了'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

Answer 5

我嘗試為多維數組 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。

Answer 6

除了解決方案的優雅和簡短之外，還有性能問題。 這是一個小基准：

import numpy as np
from scipy.stats import rankdata
l = list(reversed(range(1000)))

%%timeit -n10000 -r5
x = (rankdata(l) - 1).astype(int)
>>> 128 µs ± 2.72 µs per loop (mean ± std. dev. of 5 runs, 10000 loops each)

%%timeit -n10000 -r5
a = np.array(l)
r = a.argsort().argsort()
>>> 69.1 µs ± 464 ns per loop (mean ± std. dev. of 5 runs, 10000 loops each)

%%timeit -n10000 -r5
a = np.array(l)
temp = a.argsort()
r = np.empty_like(temp)
r[temp] = np.arange(len(a))
>>> 63.7 µs ± 1.27 µs per loop (mean ± std. dev. of 5 runs, 10000 loops each)

Answer 7

使用argsort()兩次即可：

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

Answer 8

我嘗試了上述方法，但失敗了，因為我有很多零。 是的，即使有浮動，重復的項目也可能很重要。

所以我通過添加一個平局檢查步驟編寫了一個修改后的一維解決方案：

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

我相信它盡可能高效。

Answer 9

我喜歡 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. ])

我希望這也可以幫助其他人，我試圖找到其他人的解決方案，但找不到任何......

Answer 10

argsort 和 slice 是對稱操作。

嘗試切片兩次而不是 argsort 兩次。 因為 slice 比 argsort 快

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

Answer 11

答案之一的更一般版本：

In [140]: x = np.random.randn(10, 3)

In [141]: i = np.argsort(x, axis=0)

In [142]: ranks = np.empty_like(i)

In [143]: np.put_along_axis(ranks, i, np.repeat(np.arange(x.shape[0])[:,None], x.shape[1], axis=1), axis=0)

請參閱如何使用 numpy.argsort() 作為超過 2 個維度的索引？ 推廣到更多的暗淡。