В 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())
Взгляните на 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]])
или, тем не менее, вы хотите совместить счетчики и уникальные значения.
Как и в случае с 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
Обновление: метод, упомянутый в исходном ответе, устарел, вместо него следует использовать новый:
>>> 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.]])
Меня это тоже заинтересовало, поэтому я провел небольшое сравнение производительности (используя 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), 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)'
)
Использование модуля 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(pd.Series(x))
1 5
2 3
25 1
5 1
dtype: int64
Это, безусловно, самое общее и эффективное решение; удивил, что он еще не опубликован.
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))
В отличие от принятого в настоящее время ответа, он работает с любым типом данных, который является сортируемым (не просто позитивным ints), и имеет оптимальную производительность; единственный существенный расход - в сортировке, выполненной np.unique.
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]))
Даже если он уже был дан ответ, я предлагаю другой подход, который использует 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.]))
Старый вопрос, но я хотел бы предоставить собственное решение, которое оказалось бы самым быстрым, вместо np.array в качестве ввода (или переноса в список) используйте обычный list, основанный на моем тестовом стенде.
Проверьте, если вы столкнулись с этим.
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 мкс на петлю
>>>timeit count(np.array([1,1,1,2,2,2,5,25,1,1]))
100000 циклов, лучше всего 3: 8,8 мкс на петлю
>>>timeit count(np.array([1,1,1,2,2,2,5,25,1,1]).tolist())
100000 циклов, лучше всего 3: 5,85 мкс на петлю
Хотя принятый ответ будет медленнее, а решение scipy.stats.itemfreq еще хуже.
Больше indepth тестирование не подтвердило сформулированное ожидание.
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. комментарии ниже о кеше и других побочных эффектах в ОЗУ, которые влияют на небольшой массив данных с множеством повторяющихся результатов.
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}
Чтобы подсчитать уникальные нецелые числа - похожие на Eelco Hoogendoorn, но значительно быстрее (коэффициент 5 на моей машине), я использовал weave.inline для объединения numpy.unique с небольшим количеством 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
Информация о профиле
> %timeit count_unique(data)
> 10000 loops, best of 3: 55.1 µs per loop
Версия Eelco pure numpy:
> %timeit unique_count(data)
> 1000 loops, best of 3: 284 µs per loop
Примечание
Здесь избыточность (unique также выполняет сортировку), что означает, что код, вероятно, может быть дополнительно оптимизирован, помещая функциональность unique внутри цикла c-кода.
что-то вроде этого должно это сделать:
#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
Кроме того, этот предыдущий пост Эффективный подсчет уникальных элементов кажется довольно похожим на ваш вопрос, если я не пропущу что-то.
import pandas as pd
импортировать numpy как np
pd.Series(name_of_array).value_counts()
многомерный подсчет частоты, то есть подсчет массивов.
>>> 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 Counter Counter (x)