Question

此问题的版本已被提出，但我没有找到满意的答案。

问题：给定一个大的numpy向量，找到重复的向量元素的索引（其变化可以与容差进行比较）。

所以问题是~O（N ^ 2）和内存绑定（至少从当前算法的角度来看）。我想知道为什么我尝试Python的速度比同等的C代码慢100倍或更慢。

import numpy as np
N = 10000
vect = np.arange(float(N))
vect[N/2] = 1
vect[N/4] = 1
dupl = []
print("init done")
counter = 0
for i in range(N):
    for j in range(i+1, N):
        if vect[i] == vect[j]:
            dupl.append(j)
            counter += 1

print("counter =", counter)
print(dupl)
# For simplicity, this code ignores repeated indices 
# which can be trimmed later. Ref output is
# counter = 3
# [2500, 5000, 5000]

我尝试使用numpy迭代器，但它们更糟糕（~x4-5） http://docs.scipy.org/doc/numpy/reference/arrays.nditer.html

使用N = 10,000我在C中获得0.1秒，在Python中获得12秒（上面的代码），在Python中使用np.nditer获得40秒，使用np.ndindex在Python中获得50秒。我把它推到N = 160,000，时间按预期按N ^ 2计算。

Answer 1

由于答案已经停止，没有一个完全令人满意，因此我会发布自己的解决方案。

我的理解是，在这种情况下，使得Python变慢的赋值，而不是我最初认为的嵌套循环。使用库或编译代码消除了分配的需要，并且性能得到显着提高。

from __future__ import print_function
import numpy as np
from numba import jit

N = 10000
vect = np.arange(N, dtype=np.float32)

vect[N/2] = 1
vect[N/4] = 1
dupl = np.zeros(N, dtype=np.int32)

print("init done")
# uncomment to enable compiled function
#@jit
def duplicates(i, counter, dupl, vect):
    eps = 0.01
    ns = len(vect)
    for j in range(i+1, ns):
        # replace if to use approx comparison
        #if abs(vect[i] - vect[j]) < eps:
        if vect[i] == vect[j]:
            dupl[counter] = j
            counter += 1
    return counter

counter = 0
for i in xrange(N):
    counter = duplicates(i, counter, dupl, vect)

print("counter =", counter)
print(dupl[0:counter])

测试

# no jit
$ time python array-test-numba.py
init done
counter = 3
[2500 5000 5000]

elapsed 10.135 s

# with jit
$ time python array-test-numba.py
init done
counter = 3
[2500 5000 5000]

elapsed 0.480 s

编译版本的性能（@jit取消注释）接近C代码性能~0.1 - 0.2秒。也许消除最后一个循环可以进一步提高性能。使用eps进行近似比较时性能差异更大，而编译版本差异很小。

# no jit
$ time python array-test-numba.py
init done
counter = 3
[2500 5000 5000]

elapsed 109.218 s

# with jit
$ time python array-test-numba.py
init done
counter = 3
[2500 5000 5000]

elapsed 0.506 s

这是〜200倍的差异。在实际代码中，我不得不在函数中放置两个循环以及使用具有变量类型的函数模板，因此它有点复杂但不是很多。

Answer 2

Python本身是一种高度动态，缓慢的语言。 numpy中的想法是使用vectorization，并避免显式循环。在这种情况下，您可以使用np.equal.outer。你可以从

开始

a = np.equal.outer(vect, vect)

现在，例如，找到总和：

 >>> np.sum(a)
 10006

要找到相同的 i 的索引，您可以

np.fill_diagonal(a, 0)

>>> np.nonzero(np.any(a, axis=0))[0]
array([   1, 2500, 5000])

<强>时序

def find_vec():
    a = np.equal.outer(vect, vect)
    s = np.sum(a)
    np.fill_diagonal(a, 0)
    return np.sum(a), np.nonzero(np.any(a, axis=0))[0]

>>> %timeit find_vec()
1 loops, best of 3: 214 ms per loop

def find_loop():
    dupl = []
    counter = 0
    for i in range(N):
        for j in range(i+1, N):
             if vect[i] == vect[j]:
                 dupl.append(j)
                 counter += 1
    return dupl

>>> % timeit find_loop()
1 loops, best of 3: 8.51 s per loop

Answer 3

显而易见的问题是你为什么要这样做。 NumPy数组旨在成为不透明的数据结构 - 我的意思是NumPy数组旨在在NumPy系统内创建，然后将操作发送到NumPy子系统以提供结果。即NumPy应该是一个黑盒子，你可以向其投掷请求并输出结果。

所以考虑到上面的代码，我并不感到惊讶NumPy的表现比糟糕的更糟糕。

以下应该是你想要的，我相信，但是做了NumPy方式：

nrounds

Answer 4

方法＃1

您可以使用triangular matrix模拟矢量化解决方案的迭代器依赖性条件。这基于this post处理涉及iterator dependency的乘法。为了执行vect中每个元素与其所有元素的元素相等，我们可以使用NumPy broadcasting。最后，我们可以使用np.count_nonzero来获取计数，因为它应该在布尔数组的求和方面非常有效。

所以，我们会有这样的解决方案 -

mask = np.triu(vect[:,None] == vect,1)
counter = np.count_nonzero(mask)
dupl = np.where(mask)[1]

如果你只关心点数counter，我们可以再选择两种方法。

方法＃2

我们可以避免使用三角矩阵并简单地得到整个计数，只是减去对角线元素的贡献，只考虑将剩余计数减半，只考虑其中任何一个的贡献。是相同的。

所以，我们会有一个像这样的修改过的解决方案 -

counter = (np.count_nonzero(vect[:,None] == vect) - vect.size)//2

方法＃3

这是一种完全不同的方法，它使用每个独特元素的计数对最终总数的累计贡献这一事实。

所以，考虑到这个想法，我们会有第三种方法 -

count = np.bincount(vect) # OR np.unique(vect,return_counts=True)[1]
idx = count[count>1]
id_arr = np.ones(idx.sum(),dtype=int)
id_arr[0] = 0
id_arr[idx[:-1].cumsum()] = -idx[:-1]+1
counter = np.sum(id_arr.cumsum())

Answer 5

我想知道为什么我尝试Python的速度比同等的C代码慢100倍或更慢。

因为Python程序通常比C程序慢100倍。

您可以在C中实现关键代码路径并提供Python-C绑定，也可以更改算法。您可以使用'255.60'编写O（N）版本，将数组从值反转为索引。

dict

编辑：

如果你需要用abs测试eps（vect [i] - vect [j]）＆lt;然后，您可以将值标准化为eps

import numpy as np
N = 10000
vect = np.arange(float(N))
vect[N/2] = 1
vect[N/4] = 1
dupl = {}
print("init done")
counter = 0
for i in range(N):
    e = dupl.get(vect[i], None)
    if e is None:
        dupl[vect[i]] = [i]
    else:
        e.append(i)
        counter += 1

print("counter =", counter)
print([(k, v) for k, v in dupl.items() if len(v) > 1])

像这样：

abs(vect[i] - vect[j]) < eps ->
abs(vect[i] - vect[j]) / eps < (eps / eps) ->
abs(vect[i]/eps - vect[j]/eps) < 1
int(abs(vect[i]/eps - vect[j]/eps)) = 0

Answer 6

使用numpy_indexed包的此解决方案具有复杂性n Log n，并且是完全向量化的;所以很可能与C表现没有太大的不同。

import numpy_indexed as npi
dpl = np.flatnonzero(npi.multiplicity(vect) > 1)

Answer 7

作为Ami Tavory的答案的替代方案，您可以使用集合包中的Counter来检测重复项。在我的电脑上，它似乎更快。请参阅下面的函数，它也可以找到不同的重复项。

import collections
import numpy as np

def find_duplicates_original(x):
    d = []
    for i in range(len(x)):
        for j in range(i + 1, len(x)):
            if x[i] == x[j]:
                d.append(j)
    return d

def find_duplicates_outer(x):
    a = np.equal.outer(x, x)
    np.fill_diagonal(a, 0)
    return np.flatnonzero(np.any(a, axis=0))

def find_duplicates_counter(x):
    counter = collections.Counter(x)
    values = (v for v, c in counter.items() if c > 1)
    return {v: np.flatnonzero(x == v) for v in values}


n = 10000
x = np.arange(float(n))
x[n // 2] = 1
x[n // 4] = 1

>>>> find_duplicates_counter(x)
{1.0: array([   1, 2500, 5000], dtype=int64)}

>>>> %timeit find_duplicates_original(x)
1 loop, best of 3: 12 s per loop

>>>> %timeit find_duplicates_outer(x)
10 loops, best of 3: 84.3 ms per loop

>>>> %timeit find_duplicates_counter(x)
1000 loops, best of 3: 1.63 ms per loop

Answer 8

这比8秒运行，而代码为18秒，并且不使用任何奇怪的库。它类似于@ vs0的方法，但我更喜欢defaultdict。它应该大约为O（N）。

from collections import defaultdict
dupl = []
counter = 0
indexes = defaultdict(list)
for i, e in enumerate(vect):
    indexes[e].append(i)
    if len(indexes[e]) > 1:
        dupl.append(i)
        counter += 1

numpy数组的有效循环

8 个答案: