Memberi peringkat item dalam array menggunakan Python / NumPy, tanpa mengurutkan array dua kali

Saya memiliki array angka dan saya ingin membuat array lain yang mewakili peringkat setiap item di array pertama. Saya menggunakan Python dan NumPy.

Sebagai contoh:

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

Inilah metode terbaik yang saya dapatkan:

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

Apakah ada metode yang lebih baik / lebih cepat yang menghindari pengurutan array dua kali?

Gunakan pengiris di sisi kiri pada langkah terakhir:

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

Ini menghindari pengurutan dua kali dengan membalik permutasi pada langkah terakhir.

Gunakan argsort dua kali, pertama untuk mendapatkan urutan larik, lalu untuk mendapatkan peringkat:

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

Saat berhadapan dengan array 2D (atau dimensi yang lebih tinggi), pastikan untuk memberikan argumen sumbu ke argsort untuk diurutkan di atas sumbu yang benar.

Pertanyaan ini sudah berumur beberapa tahun, dan jawaban yang diterima bagus, tetapi saya pikir yang berikut ini masih layak untuk disebutkan. Jika Anda tidak keberatan dengan ketergantungan ini scipy, Anda dapat menggunakan 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])

Fitur yang bagus rankdataadalah bahwa methodargumen menyediakan beberapa opsi untuk menangani hubungan. Misalnya, ada tiga kemunculan 20 dan dua kemunculan 40 di b:

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

Default memberikan peringkat rata-rata ke nilai terikat:

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

method='ordinal' memberikan peringkat berturut-turut:

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

method='min' memberikan peringkat minimum dari nilai terikat ke semua nilai terikat:

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

Lihat docstring untuk opsi lebih lanjut.

Saya mencoba memperluas kedua solusi untuk array A lebih dari satu dimensi, misalkan Anda memproses array baris demi baris (axis = 1).

Saya memperpanjang kode pertama dengan loop pada baris; mungkin itu bisa diperbaiki

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

Dan yang kedua, mengikuti saran k.rooijers, menjadi:

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

Saya secara acak menghasilkan 400 array dengan bentuk (1000,100); kode pertama membutuhkan waktu sekitar 7,5, yang kedua 3,8.

Untuk versi vektor dari peringkat rata-rata, lihat di bawah. Saya suka np.unique, ini benar-benar memperluas cakupan kode apa yang dapat dan tidak dapat di-vektorisasi secara efisien. Selain menghindari loop-for python, pendekatan ini juga menghindari loop ganda implisit di atas '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

Terlepas dari keanggunan dan singkatnya solusi, ada juga pertanyaan tentang kinerja. Ini sedikit patokannya:

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)

Gunakan argsort () dua kali akan melakukannya:

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

Saya mencoba metode di atas, tetapi gagal karena saya memiliki banyak zeores. Ya, bahkan dengan float barang duplikat mungkin penting.

Jadi saya menulis solusi 1D yang dimodifikasi dengan menambahkan langkah pemeriksaan dasi:

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

Saya percaya ini seefisien mungkin.

Saya menyukai metode oleh k.rooijers, tetapi seperti yang ditulis rcoup, angka yang diulang diberi peringkat sesuai dengan posisi array. Ini tidak baik bagi saya, jadi saya memodifikasi versinya untuk memproses peringkat dan menggabungkan angka berulang apa pun menjadi peringkat rata-rata gabungan:

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

Saya harap ini dapat membantu orang lain juga, saya mencoba menemukan solusi lain untuk ini, tetapi tidak dapat menemukan ...

argsort dan slice adalah operasi simetri.

coba iris dua kali, bukan argsort dua kali. karena slice lebih cepat dari argsort

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

Versi yang lebih umum dari salah satu jawaban:

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)

Lihat Bagaimana cara menggunakan numpy.argsort () sebagai indeks di lebih dari 2 dimensi? untuk menggeneralisasi menjadi lebih redup.