У меня есть массив чисел, и я бы хотел создать другой массив, который представляет ранг каждого элемента в первом массиве. Я использую 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()]
Есть ли лучшие/более быстрые методы, которые не позволяют сортировать массив дважды?
Используйте нарезку в левой части на последнем шаге:
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 для упорядочения по правильной оси.
Этот вопрос несколько лет, и принятый ответ велик, но я думаю, что все еще стоит упомянуть. Если вы не против зависимости от 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.
Я попытался расширить оба решения для массивов 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.
Для векторизованной версии усредненного ранга см. ниже. Я люблю 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
Использовать argsort() два раза:
>>> array = [4,2,7,1]
>>> ranks = numpy.array(array).argsort().argsort()
>>> ranks
array([2, 1, 3, 0])
Я попробовал вышеуказанные методы, но не смог, потому что у меня было много гейзеров. Да, даже с поплавками могут быть важны повторяющиеся элементы.
Итак, я написал модифицированное одномерное решение, добавив шаг проверки:
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, но, как писал 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. ])
Я надеюсь, что это тоже поможет другим, я попытался найти другое решение для этого, но не смог найти...