intorpidito: la frequenza più efficiente conta per valori univoci in un array

In numpy/ scipy, esiste un modo efficiente per ottenere conteggi di frequenza per valori univoci in un array?

Qualcosa del genere:

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

(Per te, R utenti là fuori, sto praticamente cercando la table()funzione)

Dai un'occhiata a 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]

E poi:

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

o:

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

o comunque si desidera combinare i conteggi e i valori univoci.

A partire da Numpy 1.9, il metodo più semplice e veloce è semplicemente quello di utilizzare numpy.unique, che ora ha un return_countsargomento di parole chiave:

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

Che dà:

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

Un rapido confronto con 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

Aggiornamento: il metodo indicato nella risposta originale è obsoleto, dovremmo invece utilizzare il nuovo modo:

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

Risposta originale:

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

Mi interessava anche questo, quindi ho fatto un piccolo confronto delle prestazioni (usando perfplot , un mio progetto per animali domestici). Risultato:

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

è di gran lunga il più veloce. (Notare il ridimensionamento del registro.)

Codice per generare la trama:

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

Utilizzando il modulo Panda:

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

Questa è di gran lunga la soluzione più generale e performante; sorpreso che non sia stato ancora pubblicato.

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

A differenza della risposta attualmente accettata, funziona su qualsiasi tipo di dati che è ordinabile (non solo ints positivi) e ha prestazioni ottimali; l'unica spesa significativa è nell'ordinamento fatto da np.unique.

numpy.bincountè probabilmente la scelta migliore. Se il tuo array contiene qualcosa di diverso da piccoli numeri densi, potrebbe essere utile avvolgerlo in questo modo:

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

Per esempio:

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

Anche se ha già ricevuto una risposta, suggerisco un approccio diverso che si avvale di numpy.histogram. Tale funzione, data una sequenza, restituisce la frequenza dei suoi elementi raggruppati in bin .

Attenzione però : funziona in questo esempio perché i numeri sono numeri interi. Se fossero numeri reali, questa soluzione non si applicherebbe altrettanto bene.

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

Questo ti dà: {1: 5, 2: 3, 5: 1, 25: 1}

Per contare non interi interi - simile alla risposta di Eelco Hoogendoorn ma considerevolmente più veloce (fattore 5 sulla mia macchina), ero solito weave.inlinecombinare numpy.uniquecon un po 'di codice 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

Informazioni sul profilo

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

La numpyversione pura di Eelco :

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

Nota

C'è ridondanza qui ( uniqueesegue anche un ordinamento), il che significa che probabilmente il codice potrebbe essere ulteriormente ottimizzato inserendo la uniquefunzionalità all'interno del ciclo c-code.

Vecchia domanda, ma mi piacerebbe fornire la mia soluzione che risulta essere la più veloce, usare normale listinvece che np.arraycome input (o trasferire prima nell'elenco), in base al mio test al banco.

Dai un'occhiata se lo incontri anche tu.

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

Per esempio,

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

100000 loop, meglio di 3: 2,26 µs per loop

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

100000 loop, meglio di 3: 8,8 µs per loop

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

100000 loop, meglio di 3: 5,85 µs per loop

Mentre la risposta accettata sarebbe più lenta e la scipy.stats.itemfreqsoluzione è ancora peggiore.

Un test più approfondito non ha confermato le aspettative formulate.

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

Ref. commenti di seguito sulla cache e altri effetti collaterali in-RAM che influenzano un piccolo set di dati risultati di test notevolmente ripetitivi.

qualcosa del genere dovrebbe farlo:

#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

Inoltre, questo post precedente su Conteggio efficiente di elementi unici sembra abbastanza simile alla tua domanda, a meno che non mi manchi qualcosa.

conteggio di frequenza multidimensionale, ovvero conteggio di array.

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