307

numpy/で、配列内の一意の値の頻度カウントを取得する効率的な方法はscipyありますか?

これらの線に沿った何か:

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()関数を探しています)

4

16 に答える 16

644

Numpy 1.9の時点で、最も簡単で最速の方法は、単純にを使用することです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
于 2014-09-19T22:54:29.887 に答える
192

見てください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]])

または、カウントと一意の値を組み合わせたい場合。

于 2012-05-24T16:35:46.820 に答える
150

更新:元の回答に記載されている方法は廃止されました。代わりに新しい方法を使用する必要があります。

>>> 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.]])
于 2013-08-13T05:41:20.767 に答える
63

私もこれに興味があったので、少しパフォーマンスを比較しました(私のペットプロジェクトであるperfplotを使用)。結果:

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

断然最速です。(ログスケーリングに注意してください。)

ここに画像の説明を入力してください


プロットを生成するコード:

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), dtype=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


b = perfplot.bench(
    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)],
    xlabel="len(a)",
)
b.save("out.png")
b.show()
于 2017-03-29T14:30:52.380 に答える
41

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
于 2014-07-30T10:25:22.230 に答える
19

これは、これまでで最も一般的でパフォーマンスの高いソリューションです。まだ投稿されていないことに驚いた。

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によって行われるソートにあります。

于 2014-01-14T21:53:12.583 に答える
15

numpy.bincountおそらく最良の選択です。配列に小さな密な整数以外のものが含まれている場合は、次のようにラップすると便利な場合があります。

def count_unique(keys):
    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]))
于 2012-05-24T17:22:05.143 に答える
8

すでに回答済みですが、を利用した別のアプローチをお勧めしますnumpy.histogram。シーケンスが与えられたそのような関数は、ビンにグループ化された要素の頻度を返します。

ただし、注意してください。数値は整数であるため、この例では機能します。それらが実数である場合、このソリューションはそれほどうまく適用されません。

>>> 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.]))
于 2012-11-05T12:22:22.287 に答える
5

古い質問ですが、ベンチテストに基づいて、入力としてlistではなく通常の方法を使用して(または最初にリストに転送して)、最速であることが判明した独自のソリューションを提供したいと思います。np.array

あなたもそれに遭遇した場合はそれをチェックしてください。

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

例えば、

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

100000ループ、ベスト3:ループあたり2.26 µs

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

100000ループ、ベスト3:ループあたり8.8 µs

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

100000ループ、ベスト3:ループあたり5.85 µs

受け入れられた答えは遅くなりますが、scipy.stats.itemfreq解決策はさらに悪くなります。


より詳細なテストでは、定式化された期待値は確認されませんでした。

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

参照。小さなデータセットの大規模な反復テスト結果に影響を与えるキャッシュおよびその他のRAM内の副作用に関する以下のコメント。

于 2014-08-19T06:50:47.687 に答える
5
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()))

これにより、次のようになります:{1:5、2:3、5:1、25:1}

于 2017-05-18T07:56:45.687 に答える
4

ユニークな非整数を数えるために-EelcoHoogendoornの答えに似ていますが、かなり高速です(私のマシンでは5倍)、私は少しのcコードとweave.inline組み合わせていました。numpy.unique

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

プロフィール情報

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

Eelcoの純粋なnumpyバージョン:

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

ノート

ここには冗長性があります(uniqueソートも実行します)。つまり、unique機能をcコードループ内に配置することで、コードをさらに最適化できる可能性があります。

于 2014-04-28T14:59:45.637 に答える
2
import pandas as pd
import numpy as np

print(pd.Series(name_of_array).value_counts())
于 2018-05-31T04:48:13.743 に答える
2

多次元周波数カウント、つまり配列をカウントします。

>>> 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,  
于 2019-06-12T10:30:22.367 に答える
1
from collections import Counter
x = array( [1,1,1,2,2,2,5,25,1,1] )
mode = counter.most_common(1)[0][0]
于 2020-03-02T16:16:27.890 に答える
1

単純な問題のほとんどは複雑になります。これは、Rのorder()のように、両方で統計結果が得られる単純な機能と降順がさまざまなPythonライブラリにないためです。しかし、Pythonのこのような統計的な順序とパラメーターはすべて、パンダで簡単に見つかると考えれば、100か所を探すよりも早く結果を得ることができます。また、Rとパンダは同じ目的で作成されたため、開発は密接に関連しています。この問題を解決するために、私はどこにでも行くことができる次のコードを使用します。

unique, counts = np.unique(x, return_counts=True)
d = {'unique':unique, 'counts':count}  # pass the list to a dictionary
df = pd.DataFrame(d) #dictionary object can be easily passed to make a dataframe
df.sort_values(by = 'count', ascending=False, inplace = True)
df = df.reset_index(drop=True) #optional only if you want to use it further
于 2020-08-26T08:14:26.173 に答える
0

このような何かがそれを行う必要があります:

#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

また、ユニークな要素を効率的に数えるというこの以前の投稿は 、何かが足りない場合を除いて、あなたの質問と非常に似ているようです。

于 2012-05-24T16:32:11.543 に答える