배열을 두 번 정렬하지 않고 Python/NumPy를 사용하여 배열의 항목 순위 지정

배열을 두 번 정렬하지 않고 Python/NumPy를 사용하여 배열의 항목 순위 지정

숫자 배열이 있는데 첫 번째 배열에 있는 각 항목의 순위를 나타내는 다른 배열을 만들고 싶습니다.저는 파이썬과 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()]

어레이를 두 번 정렬하지 않는 더 좋고 빠른 방법이 있습니까?

Argsort를 두 번 사용하여 먼저 배열 순서를 얻은 다음 순위를 얻습니다.

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

2D(또는 더 높은 차원) 배열을 다룰 때는 축 인수를 Argsort에 전달하여 올바른 축 위에 정렬해야 합니다.

이 질문은 몇 년 전의 것으로 받아들여진 답변은 훌륭하지만, 다음과 같은 내용은 여전히 언급할 가치가 있다고 생각합니다.에 대한 의존도가 괜찮다면,scipy사용할 수 있습니다.

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

자세한 옵션은 문서 문자열을 참조하십시오.

마지막 단계에서 왼쪽에 있는 고급 인덱싱을 사용합니다.

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

이렇게 하면 마지막 단계에서 순열을 반전시켜 두 번 정렬하지 않아도 됩니다.

사용하다argsort()두 번 하면 됩니다.

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

평균 순위의 벡터화된 버전은 아래를 참조하십시오.저는 np.unique를 좋아합니다. 코드가 효율적으로 벡터화될 수 있는 것과 불가능한 것의 범위를 정말 넓힙니다.루프에 대한 파이썬을 피하는 것 외에도, 이 접근 방식은 '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

어레이를 한 행씩 처리한다고 가정하고(축=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.rooiers의 제안에 따라 두 번째는 다음과 같습니다.

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

모양을 가진 400개의 배열(1000,100)을 무작위로 생성했습니다. 첫 번째 코드는 약 7.5, 두 번째 코드는 3.8이었습니다.

솔루션의 우아함과 짧음 외에도 성능에 대한 문제도 있습니다.다음은 약간의 벤치마크입니다.

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)

위의 방법들을 시도해 보았지만, 저는 제로가 많아서 실패했습니다.예, 플로트를 사용하더라도 중복 항목이 중요할 수 있습니다.

그래서 저는 타이 체크 단계를 추가하여 수정된 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))

저는 그것이 가능한 한 효율적이라고 믿습니다.

argsort 및 slice는 대칭 연산입니다.

Argsort 대신 슬라이스를 두 번 시도합니다.슬라이스가 Argsort보다 빠르기 때문에

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

k.rooijers의 방법이 마음에 들었지만, scoup이 쓴 것처럼 배열 위치에 따라 반복되는 숫자가 순위가 매겨집니다.이것은 저에게 좋지 않았기 때문에, 저는 순위를 후처리하고 반복되는 숫자를 결합된 평균 순위로 병합하도록 버전을 수정했습니다.

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

이것이 다른 사람들에게도 도움이 되기를 바랍니다. 다른 해결책을 찾으려 했지만 찾을 수 없었습니다.

다음 답변 중 하나에 대한 일반 버전:

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)

더 많은 딤으로 일반화하려면 2차원 이상의 인덱스로 numpy.argsort()를 사용하는 방법을 참조하십시오.

언급URL : https://stackoverflow.com/questions/5284646/rank-items-in-an-array-using-python-numpy-without-sorting-array-twice