numpy: najbardziej wydajna częstotliwość liczy się dla unikalnych wartości w tablicy

W numpy/ scipy, czy istnieje skuteczny sposób na uzyskanie liczby częstotliwości dla unikalnych wartości w tablicy?

Coś w tym stylu:

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

(Dla ciebie, użytkowników R tam, po prostu szukam table()funkcji)

Spójrz na 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]

I wtedy:

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

lub:

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

lub jednak chcesz połączyć liczby i unikalne wartości.

Począwszy od Numpy 1.9, najłatwiejszą i najszybszą metodą jest po prostu użycie numpy.unique, która ma teraz return_countsargument słowa kluczowego:

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

Co daje:

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

Szybkie porównanie z 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

Aktualizacja: Metoda wymieniona w pierwotnej odpowiedzi jest przestarzała, zamiast tego powinniśmy użyć nowego sposobu:

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

Oryginalna odpowiedź:

możesz użyć 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.]])

Byłem również tym zainteresowany, więc zrobiłem małe porównanie wydajności (używając perfplot , mojego projektu dla zwierząt domowych). Wynik:

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

jest zdecydowanie najszybszy. (Zwróć uwagę na skalowanie dziennika).

Kod do wygenerowania wykresu:

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

Za pomocą modułu pandy:

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

Jest to zdecydowanie najbardziej ogólne i wydajne rozwiązanie; zaskoczony, że nie został jeszcze opublikowany.

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

W przeciwieństwie do obecnie akceptowanej odpowiedzi, działa na każdym typie danych, który jest sortowalny (nie tylko na dodatnich liczbach całkowitych) i ma optymalną wydajność; jedynym znaczącym wydatkiem jest sortowanie wykonane przez np.unique.

numpy.bincountjest prawdopodobnie najlepszym wyborem. Jeśli tablica zawiera coś poza małymi gęstymi liczbami całkowitymi, przydatne może być zawinięcie jej w następujący sposób:

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

Na przykład:

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

Mimo że zostało już udzielone odpowiedzi, sugeruję inne podejście, które wykorzystuje numpy.histogram. Taka funkcja, biorąc pod uwagę sekwencję, zwraca częstotliwość elementów zgrupowanych w przedziałach .

Uwaga : działa w tym przykładzie, ponieważ liczby są liczbami całkowitymi. Jeśli byłyby to liczby rzeczywiste, to rozwiązanie nie miałoby tak dobrego zastosowania.

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

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

To daje: {1: 5, 2: 3, 5: 1, 25: 1}

Aby policzyć unikalne liczby całkowite - podobne do odpowiedzi Eelco Hoogendoorna, ale znacznie szybsze (współczynnik 5 na mojej maszynie), zwykłem weave.inlinełączyć się numpy.uniquez odrobiną kodu 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

Informacje o profilu

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

Czysta numpywersja Eelco :

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

Uwaga

Jest tu nadmiarowość ( uniquewykonuje również sortowanie), co oznacza, że ​​kod można by prawdopodobnie zoptymalizować, umieszczając uniquefunkcjonalność w pętli c-code.

Stare pytanie, ale chciałbym podać własne rozwiązanie, które okazuje się najszybsze, listzamiast tego używaj normalnegonp.array wejściowego (lub najpierw przenieś do listy), w oparciu o mój test laboratoryjny.

Sprawdź to, jeśli go spotkasz.

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

Na przykład,

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

100000 pętli, najlepiej 3: 2,26 µs na pętlę

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

100000 pętli, najlepiej 3: 8,8 µs na pętlę

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

100000 pętli, najlepiej 3: 5,85 µs na pętlę

Chociaż przyjęta odpowiedź byłaby wolniejsza, a scipy.stats.itemfreqrozwiązanie jest jeszcze gorsze.

Bardziej szczegółowe badanie nie potwierdziło sformułowanych oczekiwań.

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

Nr ref. komentarze poniżej dotyczące pamięci podręcznej i innych skutków ubocznych w pamięci RAM, które wpływają na mały zestaw danych masowo powtarzających się wyników testów.

coś takiego powinno to zrobić:

#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

Również ten poprzedni post na temat Skutecznie liczących unikalne elementy wydaje się bardzo podobny do twojego pytania, chyba że coś mi umknie.

wielowymiarowa liczba częstotliwości, tj. tablice zliczające.

>>> print(color_array    )
  array([[255, 128, 128],
   [255, 128, 128],
   [255, 128, 128],
   ...,
   [255, 128, 128],
   [255, 128, 128],
   [255, 128, 128]], dtype=uint8)


>>> np.unique(color_array,return_counts=True,axis=0)
  (array([[ 60, 151, 161],
    [ 60, 155, 162],
    [ 60, 159, 163],
    [ 61, 143, 162],
    [ 61, 147, 162],
    [ 61, 162, 163],
    [ 62, 166, 164],
    [ 63, 137, 162],
    [ 63, 169, 164],
   array([     1,      2,      2,      1,      4,      1,      1,      2,
         3,      1,      1,      1,      2,      5,      2,      2,
       898,      1,      1,  

import pandas as pd
import numpy as np

print(pd.Series(name_of_array).value_counts())

from collections import Counter
x = array( [1,1,1,2,2,2,5,25,1,1] )
mode = counter.most_common(1)[0][0]