3

ベクトル内のビンに集計関数（ " sum()"や" "など）を適用するにはどうすればよいですか。max()

それは私が持っている場合です：

  1. 長さNの値xのベクトル
  2. 長さNのビンタグbのベクトル

bは、xの各値がどのビンに属するかを示します。baのすべての可能な値に対して、そのビンに属するxのすべての値に集計関数「func（）」を適用したいと思います。

>> x = [1,2,3,4,5,6]
>> b = ["a","b","a","a","c","c"]

出力は2つのベクトルである必要があります（たとえば、集計関数は積関数です）。

>>(labels, y) = apply_to_bins(values = x, bins = b, func = prod)

labels = ["a","b","c"]
y = [12, 2, 30]

numpy（または単にpython）でこれをできるだけエレガントに実行したいのは、明らかに「forループ」で実行できるからです。

4

6 に答える 6

1

これでpandas groupby

import pandas as pd

def with_pandas_groupby(func, x, b):
    grouped = pd.Series(x).groupby(b)
    return grouped.agg(func)

OPの例を使用して：

>>> x = [1,2,3,4,5,6]
>>> b = ["a","b","a","a","c","c"]
>>> with_pandas_groupby(np.prod, x, b)
a    12
b     2
c    30

スピードに興味があったので、senderlewith_pandas_groupbyの回答にあるいくつかの関数と比較しました。

  • apply_to_bins_groupby

     3 levels,      100 values: 175 us per loop
 3 levels,     1000 values: 1.16 ms per loop
 3 levels,  1000000 values: 1.21 s per loop

10 levels,      100 values: 304 us per loop
10 levels,     1000 values: 1.32 ms per loop
10 levels,  1000000 values: 1.23 s per loop

26 levels,      100 values: 554 us per loop
26 levels,     1000 values: 1.59 ms per loop
26 levels,  1000000 values: 1.27 s per loop

  • apply_to_bins3

     3 levels,      100 values: 136 us per loop
 3 levels,     1000 values: 259 us per loop
 3 levels,  1000000 values: 205 ms per loop

10 levels,      100 values: 297 us per loop
10 levels,     1000 values: 447 us per loop
10 levels,  1000000 values: 262 ms per loop

26 levels,      100 values: 617 us per loop
26 levels,     1000 values: 795 us per loop
26 levels,  1000000 values: 299 ms per loop

  • with_pandas_groupby

     3 levels,      100 values: 365 us per loop
 3 levels,     1000 values: 443 us per loop
 3 levels,  1000000 values: 89.4 ms per loop

10 levels,      100 values: 369 us per loop
10 levels,     1000 values: 453 us per loop
10 levels,  1000000 values: 88.8 ms per loop

26 levels,      100 values: 382 us per loop
26 levels,     1000 values: 466 us per loop
26 levels,  1000000 values: 89.9 ms per loop

したがってpandas、大きなアイテムサイズの場合は最速です。さらに、レベル（ビン）の数は計算時間に大きな影響を与えません。（時間はnumpy配列から計算され、作成する時間pandas.Seriesが含まれていることに注意してください）

私は次のようにデータを生成しました：

def gen_data(levels, size):
    choices = 'abcdefghijklmnopqrstuvwxyz'
    levels = np.asarray([l for l in choices[:nlevels]])
    index = np.random.random_integers(0, levels.size - 1, size)
    b = levels[index]
    x = np.arange(1, size + 1)
    return x, b

そして、次のようにベンチマークを実行しますipython。

In [174]: for nlevels in (3, 10, 26):
   .....:     for size in (100, 1000, 10e5):
   .....:         x, b = gen_data(nlevels, size)
   .....:         print '%2d levels, ' % nlevels, '%7d values:' % size,
   .....:         %timeit function_to_time(np.prod, x, b)
   .....:     print
于 2012-07-28T10:18:40.670 に答える
1

に依存しない興味深いソリューションがいくつかありますgroupby。最初は本当に簡単です：

def apply_to_bins(func, values, bins):
    return zip(*((bin, func(values[bins == bin])) for bin in set(bins)))

これは、グループ化の代わりに「ファンシーインデックス」を使用し、小さな入力に対して適度にうまく機能します。リスト内包に基づくバリエーションは少し良くなります（タイミングについては以下を参照してください）。

def apply_to_bins2(func, values, bins):
    bin_names = sorted(set(bins))
    return bin_names, [func(values[bins == bin]) for bin in bin_names]

これらには、かなり読みやすいという利点があります。どちらも小さな入力よりもうまくいきgroupbyますが、特にビンが多い場合は、大きな入力の方がはるかに遅くなります。彼らのパフォーマンスはO(n_items * n_bins)です。別のnumpyベースのアプローチは、小さな入力の場合は遅くなりますが、大きな入力の場合ははるかに速くなります。特に、ビンがたくさんある大きな入力の場合はそうです。

def apply_to_bins3(func, values, bins):
    bins_argsort = bins.argsort()
    values = values[bins_argsort]
    bins = bins[bins_argsort]
    group_indices = (bins[1:] != bins[:-1]).nonzero()[0] + 1
    groups = numpy.split(values, group_indices)
    return numpy.unique(bins), [func(g) for g in groups]

いくつかのテスト。最初の小さな入力の場合：

>>> def apply_to_bins_groupby(func, x, b):
...         return zip(*[(k, np.product(x[list(v)]))
...                  for k, v in groupby(np.argsort(b), key=lambda i: b[i])])
... 
>>> x = numpy.array([1, 2, 3, 4, 5, 6])
>>> b = numpy.array(['a', 'b', 'a', 'a', 'c', 'c'])
>>> 
>>> %timeit apply_to_bins(numpy.prod, x, b)
10000 loops, best of 3: 31.9 us per loop
>>> %timeit apply_to_bins2(numpy.prod, x, b)
10000 loops, best of 3: 29.6 us per loop
>>> %timeit apply_to_bins3(numpy.prod, x, b)
10000 loops, best of 3: 122 us per loop
>>> %timeit apply_to_bins_groupby(numpy.prod, x, b)
10000 loops, best of 3: 67.9 us per loop

ここapply_to_bins3ではうまくいきませんが、それでも最速よりも1桁も遅くなります。大きくなるとより良くなりn_itemsます：

>>> x = numpy.arange(1, 100000)
>>> b_names = numpy.array(['a', 'b', 'c', 'd'])
>>> b = b_names[numpy.random.random_integers(0, 3, 99999)]
>>> 
>>> %timeit apply_to_bins(numpy.prod, x, b)
10 loops, best of 3: 27.8 ms per loop
>>> %timeit apply_to_bins2(numpy.prod, x, b)
10 loops, best of 3: 27 ms per loop
>>> %timeit apply_to_bins3(numpy.prod, x, b)
100 loops, best of 3: 13.7 ms per loop
>>> %timeit apply_to_bins_groupby(numpy.prod, x, b)
10 loops, best of 3: 124 ms per loop

そして、n_bins上がると、最初の2つのアプローチは、ここに表示するのに時間がかかりすぎます（約5秒）。apply_to_bins3ここで明らかに勝者です。 

>>> x = numpy.arange(1, 100000)
>>> bn_product = product(['a', 'b', 'c', 'd', 'e'], repeat=5)
>>> b_names = numpy.array(list(''.join(s) for s in bn_product))
>>> b = b_names[numpy.random.random_integers(0, len(b_names) - 1, 99999)]
>>> 
>>> %timeit apply_to_bins3(numpy.prod, x, b)
10 loops, best of 3: 109 ms per loop
>>> %timeit apply_to_bins_groupby(numpy.prod, x, b)
1 loops, best of 3: 205 ms per loop

全体として、groupbyほとんどの場合はおそらく問題ありませんが、このスレッドで示唆されているように、適切にスケーリングされる可能性は低いです。pure（er）numpyアプローチを使用すると、入力が小さい場合は遅くなりますが、少しだけです。トレードオフは良いものです。

于 2012-07-26T19:58:21.543 に答える
1 
import itertools as it
import operator as op

def apply_to_bins(values, bins, func):
    return {k: func(x[1] for x in v) for k,v in it.groupby(sorted(zip(bins, values), key=op.itemgetter(0)), key=op.itemgetter(0))}

x = [1,2,3,4,5,6]
b = ["a","b","a","a","c","c"]   

print apply_to_bins(x, b, sum) # returns {'a': 8, 'b': 2, 'c': 11}
print apply_to_bins(x, b, max) # returns {'a': 4, 'b': 2, 'c': 6}
于 2012-07-26T11:51:20.863 に答える
1 
>>> from itertools import groupby
>>> x = np.array([1, 2, 3, 4, 5, 6])
>>> zip(*[(k, np.product(x[list(v)]))
...       for k, v in groupby(np.argsort(b), key=lambda i: b[i])])
[('a', 'b', 'c'), (12, 2, 30)]

または、ステップバイステップ：

>>> np.argsort(b)
array([0, 2, 3, 1, 4, 5])

のキーでソートされた順序でのb（または）へのインデックスのリスト。xb

>>> [(k, list(v)) for k, v in groupby(np.argsort(b), key=lambda i: b[i])]
[('a', [0, 2, 3]), ('b', [1]), ('c', [4, 5])]

からのキーでグループ化されたインデックスb。

>>> [(k, x[list(v)]) for k, v in groupby(np.argsort(b), key=lambda i: b[i])]
[('a', array([1, 3, 4])), ('b', array([2])), ('c', array([5, 6]))]

インデックスを使用して、から適切な要素を取得しますx。

>>> [(k, np.product(x[list(v)]))
...  for k, v in groupby(np.argsort(b), key=lambda i: b[i])]
[('a', 12), ('b', 2), ('c', 30)]

適用しnp.productます。

だから、すべてをまとめて、

def apply_to_bins(values, bins, op):
    grouped = groupby(np.argsort(bins), key=lambda i: bins[i])
    applied = [(bin, op(x[list(indices)])) for bin, indices in grouped]
    return zip(*applied)
于 2012-07-26T11:58:34.983 に答える
1

このようなことをする場合は、Pandasパッケージを使用することを強くお勧めします。この種のことを簡単にするデータフレームまたはシリーズで呼び出すことができる素晴らしいgroupby（）メソッドがあります。

例：


In [450]: lst = [1, 2, 3, 1, 2, 3]
In [451]: s = Series([1, 2, 3, 10, 20, 30], lst)
In [452]: grouped = s.groupby(level=0)
In [455]: grouped.sum()
Out[455]: 
1    11
2    22
3    33

于 2012-07-26T13:43:25.763 に答える
0

集計関数funcを合計として表すことができる特殊なケースでは、bincountはよりも高速に見えますpandas。たとえば、funcが積の場合、対数の合計として表すことができ、次のことができます。

x = np.arange( 1000000 )
b = nr.randint( 0, 100, 1000000 )

def apply_to_bincount( values, bins ) :
    logy = np.bincount( bins, weights=np.log( values ) )
    return np.arange(len(logy)), np.exp( logy )

%%timeit
apply_to_bincount( x, b )
10 loops, best of 3: 16.9 ms per loop

%%timeit
with_pandas_groupby( np.prod, x, b )
10 loops, best of 3: 36.2 ms per loop
于 2014-06-21T17:35:28.010 に答える