Вопрос по arrays, python, performance, numpy – numpy: наиболее эффективный подсчет частоты для уникальных значений в массиве

169

Вnumpy / scipy, естьefficient способ получить частоту для уникальных значений в массиве?

Что-то в этом роде:

x = array( [1,1,1,2,2,2,5,25,1,1] )
y = freq_count( x )
print y

>> [[1, 5], [2,3], [5,1], [25,1]]

(Для вас, пользователей R, я в основном ищуtable() функция)

Являетсяcollections.Counter(x) достаточно? pylang
Было бы лучше, если бы вы отметили этот ответ как правильный для вашего вопроса:stackoverflow.com/a/25943480/9024698. Poete Maudit

Ваш Ответ

13   ответов
4
import pandas as pd
import numpy as np
x = np.array( [1,1,1,2,2,2,5,25,1,1] )
print(dict(pd.Series(x).value_counts()))

collections.Counter(x) также дают тот же результат. Я считаю, что ОП хочет вывод, который напоминает Rtable функция. ДержатьSeries может быть более полезным.
362

самый простой и быстрый способ - просто использоватьnumpy.unique, который сейчас имеетreturn_counts Ключевой аргумент:

import numpy as np

x = np.array([1,1,1,2,2,2,5,25,1,1])
unique, counts = np.unique(x, return_counts=True)

print np.asarray((unique, counts)).T

Который дает:

 [[ 1  5]
  [ 2  3]
  [ 5  1]
  [25  1]]

Быстрое сравнение сscipy.stats.itemfreq:

In [4]: x = np.random.random_integers(0,100,1e6)

In [5]: %timeit unique, counts = np.unique(x, return_counts=True)
10 loops, best of 3: 31.5 ms per loop

In [6]: %timeit scipy.stats.itemfreq(x)
10 loops, best of 3: 170 ms per loop
Спасибо за обновление! Это сейчас, ИМО, правильный ответ.
@NumesSanguis Какую версию NumPy вы используете? До версии 1.9return_counts ключевого аргумента не существует, что может объяснить исключение. В таком случае,the docs предположить, чтоnp.unique(x, True) эквивалентноnp.unique(x, return_index=True), который не возвращает значения.
Двойной +1 - это проблема, которую я тоже пытаюсь решить.
BAM! Вот почему мы обновляем ... когда мы находим такие ответы. Так долго нюми 1.8. Как мы можем получить это в верхней части списка?
В старых версиях numpy типичная идиома, чтобы получить то же самое, былаunique, idx = np.unique(x, return_inverse=True); counts = np.bincount(idx), Когда эта функция была добавлена (см.here) в некоторых неформальных испытаниях использовалисьreturn_counts разгон в 5 раз быстрее.
2

unique non-integers - аналогично ответу Eelco Hoogendoorn, но значительно быстрее (коэффициент 5 на моей машине), я использовалweave.inline комбинироватьnumpy.unique с небольшим количеством c-кода;

import numpy as np
from scipy import weave

def count_unique(datain):
  """
  Similar to numpy.unique function for returning unique members of
  data, but also returns their counts
  """
  data = np.sort(datain)
  uniq = np.unique(data)
  nums = np.zeros(uniq.shape, dtype='int')

  code="""
  int i,count,j;
  j=0;
  count=0;
  for(i=1; i<Ndata[0]; i++){
      count++;
      if(data(i) > data(i-1)){
          nums(j) = count;
          count = 0;
          j++;
      }
  }
  // Handle last value
  nums(j) = count+1;
  """
  weave.inline(code,
      ['data', 'nums'],
      extra_compile_args=['-O2'],
      type_converters=weave.converters.blitz)
  return uniq, nums

Profile info

> %timeit count_unique(data)
> 10000 loops, best of 3: 55.1 µs per loop

Eelco's purenumpy версия:

> %timeit unique_count(data)
> 1000 loops, best of 3: 284 µs per loop

Note

Здесь избыточность (unique выполняет также сортировку), что означает, что код, вероятно, можно было бы дополнительно оптимизировать, поместивunique функциональность внутри цикла c-кода.

28

поэтому я сделал небольшое сравнение производительности (используяperfplot, мой любимый проект). Результат:

 y = np.bincount(a)
 ii = np.nonzero(y)[0]
 out = np.vstack((ii, y[ii])).T

безусловно самый быстрый. (Обратите внимание на масштабирование журнала.)

enter image description here

Код для генерации сюжета:

import numpy as np
import pandas as pd
import perfplot
from scipy.stats import itemfreq


def bincount(a):
    y = np.bincount(a)
    ii = np.nonzero(y)[0]
    return np.vstack((ii, y[ii])).T


def unique(a):
    unique, counts = np.unique(a, return_counts=True)
    return np.asarray((unique, counts)).T


def unique_count(a):
    unique, inverse = np.unique(a, return_inverse=True)
    count = np.zeros(len(unique), np.int)
    np.add.at(count, inverse, 1)
    return np.vstack((unique, count)).T


def pandas_value_counts(a):
    out = pd.value_counts(pd.Series(a))
    out.sort_index(inplace=True)
    out = np.stack([out.keys().values, out.values]).T
    return out


perfplot.show(
    setup=lambda n: np.random.randint(0, 1000, n),
    kernels=[bincount, unique, itemfreq, unique_count, pandas_value_counts],
    n_range=[2**k for k in range(26)],
    logx=True,
    logy=True,
    xlabel='len(a)'
    )
Я смог запустить ваш код, добавив опциюequality_check=array_sorteq вperfplot.show(), Что было причиной ошибки (в Python 2) былоpd.value_counts (даже с sort = False).
Спасибо за размещение кода для генерации сюжета. Не знал оperfplot до этого момента. Выглядит удобно.
4

но я хотел бы предложить собственное решение, которое оказалось самым быстрым, используйте обычноеlist вместоnp.array в качестве ввода (или передачи в список в первую очередь), основываясь на моем бенч-тесте.

Check it out если вы столкнетесь с этим также.

def count(a):
    results = {}
    for x in a:
        if x not in results:
            results[x] = 1
        else:
            results[x] += 1
    return results

For example,

>>>timeit count([1,1,1,2,2,2,5,25,1,1]) would return:

100000 циклов, лучшее из 3: 2,26 на цикл

>>>timeit count(np.array([1,1,1,2,2,2,5,25,1,1]))

100000 циклов, лучшее из 3: 8,8 на цикл

>>>timeit count(np.array([1,1,1,2,2,2,5,25,1,1]).tolist())

100000 циклов, лучшее из 3: 5,85 на цикл

В то время как принятый ответ будет медленнее, аscipy.stats.itemfreq Решение еще хуже.

Более глубокийtesting did not confirm Сформулированное ожидание.

from zmq import Stopwatch
aZmqSTOPWATCH = Stopwatch()

aDataSETasARRAY = ( 100 * abs( np.random.randn( 150000 ) ) ).astype( np.int )
aDataSETasLIST  = aDataSETasARRAY.tolist()

import numba
@numba.jit
def numba_bincount( anObject ):
    np.bincount(    anObject )
    return

aZmqSTOPWATCH.start();np.bincount(    aDataSETasARRAY );aZmqSTOPWATCH.stop()
14328L

aZmqSTOPWATCH.start();numba_bincount( aDataSETasARRAY );aZmqSTOPWATCH.stop()
592L

aZmqSTOPWATCH.start();count(          aDataSETasLIST  );aZmqSTOPWATCH.stop()
148609L

Ссылка ниже приводятся комментарии к кешу и другим побочным эффектам в оперативной памяти, которые влияют на небольшой набор данных с повторяющимися результатами тестирования.

Да, мое эмпирическое правилоnumpy для всего, что может справиться с небольшими задержками, но потенциально может быть очень большим,lists для небольших наборов данных, где важна задержка, и, конечно,real benchmarking FTW :)
Этот ответ действительно хорош, как показываетnumpy это не обязательно путь.
@ Рейн Ли, интересно. Вы перекрестно проверяли гипотезу списка также для некоторого размера набора данных, не поддерживающего кэширование? Предположим, что в каждом представлении представлено 150 000 случайных элементов, и за один прогон мы измерили немного более точно, как на примереaZmqStopwatch.start();count(aRepresentation);aZmqStopwatch.stop() ?
Провел некоторое тестирование и да, естьhuge differences в реальной производительности набора данных. Тестирование требует более глубокого понимания внутренней механики Python, чем запуск только масштабированных циклов грубой силы и цитирование нереалистичныхin-vitro наносекунд. Как проверено -np.bincount() может быть сделано для обработки 150.000 массив вless than 600 [us] в то время как вышеdef-edcount() в предварительно преобразованном списке его представление заняло более122.000 [us]
21

>>> import pandas as pd
>>> import numpy as np
>>> x = np.array([1,1,1,2,2,2,5,25,1,1])
>>> pd.value_counts(pd.Series(x))
1     5
2     3
25    1
5     1

dtype: int64

@YohanObadia - в зависимости от размера массива, первое преобразование его в серию ускорило выполнение последней операции. Я бы предположил на отметке около 50 000 значений.
pd.Series () не требуется. В остальном хороший пример. Numpy также. Панды могут взять простой список в качестве входных данных.
119

np.bincount:

http://docs.scipy.org/doc/numpy/reference/generated/numpy.bincount.html

import numpy as np
x = np.array([1,1,1,2,2,2,5,25,1,1])
y = np.bincount(x)
ii = np.nonzero(y)[0]

А потом:

zip(ii,y[ii]) 
# [(1, 5), (2, 3), (5, 1), (25, 1)]

или же:

np.vstack((ii,y[ii])).T
# array([[ 1,  5],
         [ 2,  3],
         [ 5,  1],
         [25,  1]])

или, тем не менее, вы хотите объединить количество и уникальные значения.

Привет! Это не сработало бы, если бы элементы x имели тип d, отличный от int.
Это не сработает, если они будут отличны от неотрицательных целых, и будет очень неэффективно в пространстве, если они удалены.
В numpy версии 1.10 я обнаружил, что для подсчета целых чисел он примерно в 6 раз быстрее, чем np.unique. Также обратите внимание, что он также учитывает отрицательные числа, если заданы правильные параметры.
1

#create 100 random numbers
arr = numpy.random.random_integers(0,50,100)

#create a dictionary of the unique values
d = dict([(i,0) for i in numpy.unique(arr)])
for number in arr:
    d[j]+=1   #increment when that value is found

Кроме того, этот предыдущий пост наЭффективно считая уникальные элементы кажется, очень похоже на ваш вопрос, если только я что-то упустил.

Связанный вопрос в некотором роде похож, но похоже, что он работает с более сложными типами данных. Abe
14

numpy.bincount это, наверное, лучший выбор. Если ваш массив содержит что-то кроме маленьких плотных целых чисел, может быть полезно обернуть его примерно так:

    uniq_keys = np.unique(keys)
    bins = uniq_keys.searchsorted(keys)
    return uniq_keys, np.bincount(bins)

Например:

>>> x = array([1,1,1,2,2,2,5,25,1,1])
>>> count_unique(x)
(array([ 1,  2,  5, 25]), array([5, 3, 1, 1]))
108

метод, упомянутый в исходном ответе, устарел, вместо него следует использовать новый:

>>> import numpy as np
>>> x = [1,1,1,2,2,2,5,25,1,1]
>>> np.array(np.unique(x, return_counts=True)).T
    array([[ 1,  5],
           [ 2,  3],
           [ 5,  1],
           [25,  1]])

Оригинальный ответ:

ты можешь использоватьscipy.stats.itemfreq

>>> from scipy.stats import itemfreq
>>> x = [1,1,1,2,2,2,5,25,1,1]
>>> itemfreq(x)
/usr/local/bin/python:1: DeprecationWarning: `itemfreq` is deprecated! `itemfreq` is deprecated and will be removed in a future version. Use instead `np.unique(..., return_counts=True)`
array([[  1.,   5.],
       [  2.,   3.],
       [  5.,   1.],
       [ 25.,   1.]])
Это медленно для версий до 0.14, хотя.
Я предпочитаю, чтобы оригинальный вопросник изменил принятый ответ с первого на этот, чтобы увеличить его видимость
Похоже, самый питонический подход на сегодняшний день. Кроме того, я столкнулся с проблемами с & quot; объектом, слишком глубоким для нужного массива & quot; проблемы с np.bincount на матрицах 100k x 100k.
7

что на него уже дан ответ, я предлагаю другой подход, который используетnumpy.histogram, Такая функция заданной последовательности возвращает частоту ее элементовgrouped in bins.

Beware though: это работает в этом примере, потому что числа являются целыми числами. Если бы они, где реальные цифры, то это решение не будет применяться так же приятно.

>>> from numpy import histogram
>>> y = histogram (x, bins=x.max()-1)
>>> y
(array([5, 3, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       1]),
 array([  1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.,
        12.,  13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  21.,  22.,
        23.,  24.,  25.]))
17

Удивлен, он еще не был опубликован.

import numpy as np

def unique_count(a):
    unique, inverse = np.unique(a, return_inverse=True)
    count = np.zeros(len(unique), np.int)
    np.add.at(count, inverse, 1)
    return np.vstack(( unique, count)).T

print unique_count(np.random.randint(-10,10,100))

В отличие от принятого в настоящее время ответа, он работает с любым типом данных, который можно сортировать (не только с положительными целевыми значениями), и имеет оптимальную производительность; единственный значительный расход заключается в сортировке, выполняемой np.unique.

не работает:AttributeError: 'numpy.ufunc' object has no attribute 'at'
Вам нужен NumPy 1,8
Более простой метод будет вызыватьnp.bincount(inverse)
Хорошо, тогда я устарел, извините
0

импортировать NumPy как NP

pd.Series (name_of_array) .value_counts ()

Похожие вопросы