numpy: frekuensi paling efisien dihitung untuk nilai unik dalam sebuah array

Di numpy/ scipy, apakah ada cara yang efisien untuk mendapatkan jumlah frekuensi untuk nilai unik dalam array?

Sesuatu di sepanjang garis ini:

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

(Untuk Anda, pengguna R di luar sana, pada dasarnya saya mencari table()fungsi)

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

Lalu:

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

atau:

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

atau bagaimanapun Anda ingin menggabungkan jumlah dan nilai unik.

Pada Numpy 1.9, metode termudah dan tercepat adalah dengan hanya menggunakan numpy.unique, yang sekarang memiliki return_countsargumen kata kunci:

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

Pemberian yang mana:

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

Perbandingan cepat dengan 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

Pembaruan: Metode yang disebutkan dalam jawaban asli sudah usang, kita harus menggunakan cara baru sebagai gantinya:

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

Jawaban asli:

Anda dapat menggunakan 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.]])

Saya juga tertarik dengan ini, jadi saya melakukan sedikit perbandingan kinerja (menggunakan perfplot , proyek kesayangan saya). Hasil:

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

sejauh ini yang tercepat. (Perhatikan skala log.)

Kode untuk menghasilkan plot:

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

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

Sejauh ini ini adalah solusi yang paling umum dan performan; terkejut belum diposting.

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

Berbeda dengan jawaban yang saat ini diterima, ia bekerja pada semua tipe data yang dapat diurutkan (bukan hanya int positif), dan memiliki kinerja optimal; satu-satunya biaya yang signifikan adalah penyortiran yang dilakukan oleh np.unique.

numpy.bincountmungkin merupakan pilihan terbaik. Jika array Anda mengandung sesuatu selain bilangan bulat kecil, mungkin berguna untuk membungkusnya seperti ini:

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

Sebagai contoh:

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

Meskipun sudah dijawab, saya menyarankan pendekatan berbeda yang memanfaatkan numpy.histogram. Fungsi yang diberi urutan ini mengembalikan frekuensi elemen-elemennya yang dikelompokkan dalam nampan .

Namun waspadalah : ini berfungsi dalam contoh ini karena angka adalah bilangan bulat. Jika mereka di mana bilangan real, maka solusi ini tidak akan berlaku juga.

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

Ini memberi Anda: {1: 5, 2: 3, 5: 1, 25: 1}

Untuk menghitung non-integer unik - mirip dengan jawaban Eelco Hoogendoorn tetapi jauh lebih cepat (faktor 5 pada mesin saya), saya biasa weave.inlinemenggabungkan numpy.uniquedengan sedikit kode-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

Info profil

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

numpyVersi murni Eelco :

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

Catatan

Ada redundansi di sini ( uniquemelakukan pengurutan juga), yang berarti bahwa kode mungkin dapat lebih dioptimalkan dengan meletakkan uniquefungsi di dalam loop kode-c.

Pertanyaan lama, tetapi saya ingin memberikan solusi saya sendiri yang ternyata menjadi yang tercepat, gunakan normal listbukan np.arraysebagai input (atau transfer ke daftar terlebih dahulu), berdasarkan tes bangku saya.

Lihat itu jika Anda menemukannya juga.

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

Sebagai contoh,

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

100000 loop, terbaik 3: 2,26 μs per loop

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

100000 loop, terbaik 3: 8,8 μs per loop

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

100000 loop, terbaik 3: 5,85 μs per loop

Sementara jawaban yang diterima akan lebih lambat, dan scipy.stats.itemfreqsolusinya bahkan lebih buruk.

Pengujian yang lebih mendalam tidak mengkonfirmasi ekspektasi yang dirumuskan.

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. komentar di bawah tentang cache dan efek samping dalam-RAM lainnya yang memengaruhi dataset kecil hasil pengujian berulang secara besar-besaran.

beberapa hal seperti ini harus dilakukan:

#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

Juga, posting sebelumnya tentang penghitungan elemen unik ini secara efisien tampaknya sangat mirip dengan pertanyaan Anda, kecuali saya kehilangan sesuatu.

penghitungan frekuensi multi-dimensi, yaitu penghitungan 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]