按行查找矩阵和向量之间的交集

Question

考虑以下几点：

tmp1 = ['a', 'b', 'c', 'd', 'e']
tmp2 = ['f', 'g', 'h', 'b', 'd']
tmp3 = ['b', 'i', 'j', 'k', 'l']
matr = np.array([tmp1, tmp2, tmp3])

matr

产生一个矩阵：

array([['a', 'b', 'c', 'd', 'e'],
   ['f', 'g', 'h', 'b', 'd'],
   ['b', 'i', 'j', 'k', 'l']], 
  dtype='|S1')

现在，我想知道与向量相交的每一行中的值的总和。说吧，

vec = ['a', 'c', 'f', 'b']
[sum([y in vec for y in row]) for row in matr]

返回，

[3, 2, 1]

这是所需的输出。问题是我的“矩阵”实际上是 ≈ 1000000 x 2200，我有 6700 个向量可以比较。我在这里的解决方案太慢了，无法尝试。

如何改进我的工作？

值得注意的是，matr 内部的值来自一组约 30000 个值，而我拥有完整的一组。我已经考虑了解决方案，我对每个向量制作这 30000 个值的字典，并使用字典在整个矩阵中转换为真/假，然后按行求和。我不确定这是否会有所帮助。

Answer 1

对于matr 和vec 作为数组，这里有一个np.searchsorted -

def count_in_rowwise(matr,vec):
    sidx = vec.argsort()
    idx = np.searchsorted(vec,matr,sorter=sidx)
    idx[idx==len(vec)] = 0
    return (vec[sidx[idx]] == matr).sum(1)

使用相对较小的vec，我们可以对其进行预排序并使用，为我们提供一个计算行数的替代方法，就像这样 -

def count_in_rowwise_v2(matr,vec,assume_sorted=False):
    if assume_sorted==1:
        sorted_vec = vec
    else:
        sorted_vec = np.sort(vec)
    idx = np.searchsorted(sorted_vec,matr)
    idx[idx==len(sorted_vec)] = 0
    return (sorted_vec[idx] == matr).sum(1)

上述解决方案适用于通用输入（数字或字符串等）。为了解决我们特定的字符串情况，我们可以通过使用 np.unique 将字符串转换为数字然后重新使用 count_in_rowwise/count_in_rowwise_v2 来进一步优化它，这将给我们提供第二种方法，就像这样 -

u,ids = np.unique(matr, return_inverse=True)
out = count_in_rowwise(ids.reshape(matr.shape),ids[np.searchsorted(u,vec)])

Answer 2

您可以使用设置交集来加快速度。这是一个比较：

您目前的列表推导解决方案：

%%timeit
print([sum([y in vec for y in row]) for row in matr])
#Output
[3,2,1]
20 µs ± 1.9 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)

在列表理解中设置交集的建议解决方案：

%%timeit
print([len(set(row).intersection(vec)) for row in matr])
#Output:
[3,2,1]
17.8 µs ± 1.46 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)

如果vec也是一个集合，我们会得到更好的效率：

%%timeit
vec = {'a', 'c', 'f', 'b'}
print([len(set(row).intersection(vec)) for row in matr])
#Output:
[3, 2, 1]
16.6 µs ± 1.99 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Answer 3

这是一个简单易读的解决方案，np.isin() (docs)：

np.sum(np.isin(matr, vec), axis=1)

作为奖励，如果您想获得矩阵的哪些元素在向量中，您可以只使用 np.isin() 而无需求和：

>>> np.isin(matr, vec)
array([[ True,  True,  True, False, False],
       [ True, False, False,  True, False],
       [ True, False, False, False, False]])

这说明了为什么沿行求和会产生所需的输出。

Answer 4

让我们看看您当前算法的速度。根据 python wiki，检查一个项目是否在像 y in vec 这样的数组中是 O(n)，这意味着最坏的情况，它必须遍历 vec 中的每个元素。由于您正在检查矩阵的每个元素，因此您的操作总数为numRows * numCols * vecLen，即O(n^3)。

一种更快的方法是为vec 构造一个字典以优化查找，因为字典是O(1) 而不是O(n)，这意味着无论 vec 有多长，它们都可以执行您的签入操作：

vecDict = dict([(x, 1) for x in vec])

因此，您的新时间复杂度为 (numRows * numCols) + vecLen，即 O(n^2)，我认为这是您获取数据的最快速度。

[sum([y in vecDict for y in row]) for row in matr]