使用 Python/NumPy 对数组中的项进行排序，而不对数组进行两次排序

小开

最佳答案

在最后一步中使用左边的 高级索引高级索引:

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

这样可以通过在最后一步中反转排列避免两次排序。

小开

使用 argsort 两次，首先获取数组的顺序，然后获取排名:

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

在处理2D (或更高维度)数组时，一定要将一个轴参数传递给 argsort，以按照正确的轴排序。

小开

假设您逐行处理数组(轴 = 1) ，我试图将这两个解决方案扩展到多个维数组 A。

我对第一个代码进行了扩展，在行上添加了一个循环; 可能还有改进的余地

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。

小开

我尝试了上面的方法，但是失败了，因为我有很多零。是的，即使有浮动重复的项目可能是重要的。

所以我写了一个修改过的1D 解决方案，添加了一个领带检查步骤:

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

我相信这是最有效的方法。

小开

我喜欢 k.rooijers 的方法，但是正如 rcy 所写的，重复的数字是根据数组位置排序的。这对我没有好处，所以我修改了版本，对排名进行后处理，并将任何重复的数字合并为一个综合平均排名:

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

我希望这也可以帮助其他人，我试图找到另一个解决办法，但找不到任何..。

小开

有关平均排名的向量化版本，请参见下文。我喜欢 np.only，它真的扩大了什么代码可以有效地向量化，什么代码不能向量化的范围。除了避免 pythonfor- 循环之外，这种方法还避免了在“ 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

小开

使用 argsort()两次就可以了:

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

小开

这个问题是几年前的了，而且被接受的答案是伟大的，但我认为以下仍然值得一提。如果你不介意对 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])

有关更多选项，请参见 docstring。

小开

除了解决方案的优雅性和短暂性之外，还存在性能问题。以下是一个小小的基准:

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)

小开

Argsort 和 slice 是对称操作。

尝试两次切片而不是两次 argsort。因为切片比 argsort 快

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

小开

其中一个答案的更一般的版本:

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个维度的索引？以推广到更多的暗调。