numpy: la frecuencia más eficiente cuenta para valores únicos en una matriz

En numpy/ scipy, ¿hay una manera eficiente de obtener conteos de frecuencia para valores únicos en una matriz?

Algo en este sentido:

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

(Para ustedes, usuarios de R, básicamente estoy buscando la table()función)

Echa un vistazo 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]

Y entonces:

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 como quiera combinar los recuentos y los valores únicos.

A partir de Numpy 1.9, el método más fácil y rápido es simplemente usar numpy.unique, que ahora tiene un return_countsargumento de palabra clave:

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

Lo que da:

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

Una comparación rápida 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

Actualización: El método mencionado en la respuesta original está en desuso, en su lugar deberíamos usar la nueva forma:

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

Respuesta original:

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

También estaba interesado en esto, así que hice una pequeña comparación de rendimiento (usando perfplot , un proyecto mío mío). Resultado:

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

Es, con mucho, el más rápido. (Tenga en cuenta la escala de registro).

Código para generar 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)",
)

Usando el módulo de pandas:

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

Esta es, con mucho, la solución más general y eficaz; sorprendido no ha sido publicado todavía.

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 diferencia de la respuesta actualmente aceptada, funciona en cualquier tipo de datos que se pueda ordenar (no solo en entradas positivas), y tiene un rendimiento óptimo; el único gasto significativo está en la clasificación realizada por np.unique.

numpy.bincountEs probablemente la mejor opción. Si su matriz contiene algo además de pequeños enteros densos, podría ser útil envolverla de esta manera:

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

Por ejemplo:

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

Aunque ya ha sido respondido, sugiero un enfoque diferente que hace uso de numpy.histogram. Dicha función, dada una secuencia, devuelve la frecuencia de sus elementos agrupados en contenedores .

Sin embargo, tenga cuidado : funciona en este ejemplo porque los números son enteros. Si fueran números reales, entonces esta solución no se aplicaría tan bien.

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

Esto le da: {1: 5, 2: 3, 5: 1, 25: 1}

Para contar números no enteros únicos , similar a la respuesta de Eelco Hoogendoorn pero considerablemente más rápido (factor 5 en mi máquina), solía weave.inlinecombinarme numpy.uniquecon un poco de código 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

Información de perfil

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

La numpyversión pura de Eelco :

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

Nota

Aquí hay redundancia (también se uniquerealiza una ordenación), lo que significa que el código probablemente podría optimizarse aún más al poner la uniquefuncionalidad dentro del bucle de código C.

Antigua pregunta, pero me gustaría proporcionar mi propia solución que resulte ser la más rápida, usar normal en listlugar de np.arraycomo entrada (o transferir a la lista en primer lugar), según mi prueba de banco.

Compruébalo si te encuentras con él también.

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

Por ejemplo,

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

100000 bucles, lo mejor de 3: 2.26 µs por bucle

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

100000 bucles, lo mejor de 3: 8.8 µs por bucle

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

100000 bucles, lo mejor de 3: 5.85 µs por bucle

Si bien la respuesta aceptada sería más lenta, y la scipy.stats.itemfreqsolución es aún peor.

Una prueba más profunda no confirmó la expectativa formulada.

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

Árbitro. Los comentarios a continuación sobre el caché y otros efectos secundarios en la RAM que influyen en un pequeño conjunto de datos son resultados de pruebas masivamente repetitivos.

algo como esto debería hacerlo:

#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

Además, esta publicación anterior sobre el conteo eficiente de elementos únicos parece bastante similar a su pregunta, a menos que me falte algo.

recuento de frecuencia multidimensional, es decir, recuento de matrices.

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