解决方案

Question

例如，我有两个ndarray，train_dataset的形状为(10000, 28, 28)，val_dateset的形状为(2000, 28, 28)。

除了使用迭代之外，是否有任何有效的方法可以使用numpy数组函数来查找两个ndarrays之间的重叠？

Answer 1

内存允许您使用broadcasting，就像这样 -

val_dateset[(train_dataset[:,None] == val_dateset).all(axis=(2,3)).any(0)]

示例运行 -

In [55]: train_dataset
Out[55]: 
array([[[1, 1],
        [1, 1]],

       [[1, 0],
        [0, 0]],

       [[0, 0],
        [0, 1]],

       [[0, 1],
        [0, 0]],

       [[1, 1],
        [1, 0]]])

In [56]: val_dateset
Out[56]: 
array([[[0, 1],
        [1, 0]],

       [[1, 1],
        [1, 1]],

       [[0, 0],
        [0, 1]]])

In [57]: val_dateset[(train_dataset[:,None] == val_dateset).all(axis=(2,3)).any(0)]
Out[57]: 
array([[[1, 1],
        [1, 1]],

       [[0, 0],
        [0, 1]]])

如果元素是整数，则可以将输入数组中axis=(1,2)的每个块折叠为标量，假设它们是线性索引数，然后有效地使用np.in1d或np.intersect1d找到比赛。

Answer 2

全广播在这里生成10000 * 2000 * 28 * 28 = 150 Mo布尔数组。

为提高效率，您可以：

打包数据，200 ko数组：

from pylab import *
N=10000
a=rand(N,28,28)
b=a[[randint(0,N,N//5)]]

packedtype='S'+ str(a.size//a.shape[0]*a.dtype.itemsize) # 'S6272' 
ma=frombuffer(a,packedtype)  # ma.shape=10000
mb=frombuffer(b,packedtype)  # mb.shape=2000

%timeit a[:,None]==b   : 102 s
%timeit ma[:,None]==mb   : 800 ms
allclose((a[:,None]==b).all((2,3)),(ma[:,None]==mb)) : True

通过惰性字符串比较帮助减少内存，首先打破差异：

In [31]: %timeit a[:100]==b[:100]
10000 loops, best of 3: 175 µs per loop

In [32]: %timeit a[:100]==a[:100]
10000 loops, best of 3: 133 µs per loop

In [34]: %timeit ma[:100]==mb[:100]
100000 loops, best of 3: 7.55 µs per loop

In [35]: %timeit ma[:100]==ma[:100]
10000 loops, best of 3: 156 µs per loop

这里给出的解决方案为(ma[:,None]==mb).nonzero().

使用in1d代表(Na+Nb) ln(Na+Nb)复杂度 Na*Nb进行全面比较：
```
%timeit in1d(ma,mb).nonzero()  : 590ms 
```

这里没有大的收获，但渐渐变得更好。

Answer 3

我从Jaime's excellent answer here学到的一个技巧是使用np.void dtype，以便将输入数组中的每一行视为单个元素。这允许您将它们视为一维数组，然后可以将其传递给np.in1d或另一个set routines。

import numpy as np

def find_overlap(A, B):

    if not A.dtype == B.dtype:
        raise TypeError("A and B must have the same dtype")
    if not A.shape[1:] == B.shape[1:]:
        raise ValueError("the shapes of A and B must be identical apart from "
                         "the row dimension")

    # reshape A and B to 2D arrays. force a copy if neccessary in order to
    # ensure that they are C-contiguous.
    A = np.ascontiguousarray(A.reshape(A.shape[0], -1))
    B = np.ascontiguousarray(B.reshape(B.shape[0], -1))

    # void type that views each row in A and B as a single item
    t = np.dtype((np.void, A.dtype.itemsize * A.shape[1]))

    # use in1d to find rows in A that are also in B
    return np.in1d(A.view(t), B.view(t))

例如：

gen = np.random.RandomState(0)

A = gen.randn(1000, 28, 28)
dupe_idx = gen.choice(A.shape[0], size=200, replace=False)
B = A[dupe_idx]

A_in_B = find_overlap(A, B)

print(np.all(np.where(A_in_B)[0] == np.sort(dupe_idx)))
# True

这种方法比Divakar的内存效率更高，因为它不需要广播到(m, n, ...)布尔数组。事实上，如果A和B是行专业，那么根本不需要复制。

为了比较，我略微改编了Divakar和B. M.的解决方案。

def divakar(A, B):
    A.shape = A.shape[0], -1
    B.shape = B.shape[0], -1
    return (B[:,None] == A).all(axis=(2)).any(0)

def bm(A, B):
    t = 'S' + str(A.size // A.shape[0] * A.dtype.itemsize)
    ma = np.frombuffer(np.ascontiguousarray(A), t)
    mb = np.frombuffer(np.ascontiguousarray(B), t)
    return (mb[:, None] == ma).any(0)

基准：

In [1]: na = 1000; nb = 200; rowshape = 28, 28

In [2]: %%timeit A = gen.randn(na, *rowshape); idx = gen.choice(na, size=nb, replace=False); B = A[idx]
divakar(A, B)
   ....: 
1 loops, best of 3: 244 ms per loop

In [3]: %%timeit A = gen.randn(na, *rowshape); idx = gen.choice(na, size=nb, replace=False); B = A[idx]
bm(A, B)
   ....: 
100 loops, best of 3: 2.81 ms per loop

In [4]: %%timeit A = gen.randn(na, *rowshape); idx = gen.choice(na, size=nb, replace=False); B = A[idx]
find_overlap(A, B)
   ....: 
100 loops, best of 3: 15 ms per loop

正如您所看到的，对于小型 n ，BM的解决方案比我的解决方案略快，但np.in1d比测试所有元素的相等性更好（ O（n log） n）而不是 O（n²）复杂性。

In [5]: na = 10000; nb = 2000; rowshape = 28, 28

In [6]: %%timeit A = gen.randn(na, *rowshape); idx = gen.choice(na, size=nb, replace=False); B = A[idx]
bm(A, B)
   ....: 
1 loops, best of 3: 271 ms per loop

In [7]: %%timeit A = gen.randn(na, *rowshape); idx = gen.choice(na, size=nb, replace=False); B = A[idx]
find_overlap(A, B)
   ....: 
10 loops, best of 3: 123 ms per loop

Divakar的解决方案在我的笔记本电脑上对于这种尺寸的阵列是难以处理的，因为它需要生成15GB的中间阵列，而我只有8GB的RAM。

Answer 4

解决方案

def overlap(a,b):
    """
    returns a boolean index array for input array b representing
    elements in b that are also found in a
    """
    a.repeat(b.shape[0],axis=0)
    b.repeat(a.shape[0],axis=0)
    c = aa == bb
    c = c[::a.shape[0]]
    return c.all(axis=1)[:,0]

您可以使用返回的索引数组索引b以提取a

中也包含的元素

b[overlap(a,b)]

解释

为简单起见，我假设您已导入numpy的所有内容，例如：

from numpy import *

所以，例如，给定两个ndarrays

a = arange(4*2*2).reshape(4,2,2)
b = arange(3*2*2).reshape(3,2,2)

我们重复a和b，以便它们具有相同的形状

aa = a.repeat(b.shape[0],axis=0)
bb = b.repeat(a.shape[0],axis=0)

然后我们可以简单地比较aa和bb

的元素

c = aa == bb

最后，通过查看b的每个a个元素，每个第4个元素或shape(a)[0]个元素来获取c中也可以在cc == c[::a.shape[0]]中找到的元素的索引}

True

最后，我们提取一个索引数组，其中只包含子数组中所有元素都为c.all(axis=1)[:,0]的元素

array([True,  True,  True], dtype=bool)

在我们的例子中，我们得到了

要检查，请更改b[0] = array([[50,60],[70,80]])

的第一个元素

array([False,  True,  True], dtype=bool)

我们得到了

>>> import re
>>> re.findall(r'.*?\.\d+|.+', text)
['Reproduction now becomes posited as “natural” production.16',
 ' Fortunati joins Marx in a minute but crucial declension ...']

Answer 5

这个问题来自Google的在线深度学习课程？以下是我的解决方案：

sum = 0 # number of overlapping rows
for i in range(val_dataset.shape[0]): # iterate over all rows of val_dataset
    overlap = (train_dataset == val_dataset[i,:,:]).all(axis=1).all(axis=1).sum()
    if overlap:
        sum += 1
print(sum)

使用自动广播代替迭代。您可以测试性能差异。

检查高维数组的有效方法在Python中的两个ndarray中重叠

5 个答案:

基准：

解决方案

解释