二维数字派数组中每个元素的计数

Question

想象一下你有一个2D数组(作为NumPy int数组(，如下所示：

[[2,2,3,3],
 [2,3,3,3],
 [3,3,4,4]]

现在，您希望获得相同形状的数组，但您希望将数字替换为其出现次数，而不是原始值。这意味着，数字 2 变为 3，因为它出现了 3 次，3 变成了 7,4 变成了 2s。

所以输出将是：

[[3,3,7,7],
 [3,7,7,7],
 [7,7,2,2]]

我的解决方案是首先创建一个字典，该字典将所有原始值保存为键，并将出现次数保存为值。但是对于形状为 2000x2000 的数组，这似乎很慢。

如何更有效地实现这一目标？

谢谢！

Answer 1

我相信

你应该能够通过在np.unique()中使用return_inverse来留在 NumPy 中：

如果为 True，则还返回唯一数组的索引(对于 指定轴(如果提供(，可用于重建ar 。

>>> import numpy as np
>>> a = np.array([[2,2,3,3],
...               [2,3,3,3],
...               [3,3,4,4]])
>>> _, inv, cts = np.unique(a, return_inverse=True, return_counts=True)
>>> cts[inv].reshape(a.shape)
array([[3, 3, 7, 7],
       [3, 7, 7, 7],
       [7, 7, 2, 2]])

这也适用于平展数组未排序的情况，例如 b = np.array([[1, 2, 4], [4, 4, 1]]) .

Answer 2

一种方法是使用 numpy.unique 提取值计数。

然后转换为字典并使用numpy.vectorize来利用此字典映射。

import numpy as np
A = np.array([[2,2,3,3],
              [2,3,3,3],
              [3,3,4,4]])
d = dict(zip(*np.unique(A.ravel(), return_counts=True)))
res = np.vectorize(d.get)(A)
array([[3, 3, 7, 7],
       [3, 7, 7, 7],
       [7, 7, 2, 2]], dtype=int64)

性能

我看到上面的方法对于 2x2000 数组需要 ~2000 秒，而通过基于collections.Counter字典的方法需要 3 秒。但是PaulPanzer和BradSolomon的纯numpy解决方案仍然更快。

import numpy as np
from collections import Counter
A = np.random.randint(0, 10, (2000, 2000))
MAX_LOOKUP = 2**24
def map_count(A):
    d = dict(zip(*np.unique(A.ravel(), return_counts=True)))
    return np.vectorize(d.get)(A)
def map_count2(A):
    d = Counter(A.ravel())
    return np.vectorize(d.get)(A)
def bs(A):
    _, inv, cts = np.unique(A, return_inverse=True, return_counts=True)
    return cts[inv].reshape(A.shape)
def pp(a):
    mn, mx = a.min(), a.max()
    span = mx-mn+1
    if span > MAX_LOOKUP:
        raise RuntimeError('values spread to wide')
    a = a - mn
    return np.bincount(a.ravel(), None, span)[a]
%timeit map_count(A)   # 1.9 s ± 24.2 ms per loop
%timeit map_count2(A)  # 3 s ± 33.1 ms per loop
%timeit bs(A)          # 887 ms ± 20 ms per loop
%timeit pp(A)          # 149 ms ± 6.32 ms per loop

Answer 3

以下是利用您的值为 int 这一事实的方法：

MAX_LOOKUP = 2**24
def f_pp(a):
    mn, mx = a.min(), a.max()
    span = mx-mn+1
    if span > MAX_LOOKUP:
        raise RuntimeError('values spread to wide')
    a = a - mn
    return np.bincount(a.ravel(), None, span)[a]

时间(主要基于@jpp的工作(：

>>> from timeit import timeit
>>> kwds = dict(globals=globals(), number=3)
>>> 
>>> for l, r in [(0, 10), (0, 1000), (-8000000, 8000000)]:
...     a = np.random.randint(l, r, (2000, 2000))
...     print(l, r)
...     print('mc ', timeit('map_count(a)', **kwds))
...     print('mc2', timeit('map_count2(a)', **kwds))
...     print('bs ', timeit('bs(a)', **kwds))
...     print('pp ', timeit('f_pp(a)', **kwds))
... 
0 10
mc  2.462232475867495
mc2 3.820418732939288
bs  1.266723491018638
pp  0.11216754489578307
0 1000
mc  2.972961534978822
mc2 4.3769155589398
bs  2.1607728030066937
pp  0.14146877988241613
-8000000 8000000
mc  10.753600731957704
mc2 8.373655589064583
bs  2.700256273150444
pp  0.7070535880047828