Python中向量的高性能全对全比较

首先介绍一下背景：有几种聚类比较方法依赖于所谓的配对计数。在相同的

n

实体上，我们有两个平面聚类向量

a

和

b

。在对所有可能的实体对进行配对计数时，我们检查它们是否属于两个实体中的同一个集群，或者属于

a

中相同但

b

中不同的集群，或者相反，或者属于两个实体中的不同集群。这样我们得到4个计数，我们称它们为

n11、n10、n01、n00

。这些是不同度量的输入

当实体的数量大约为10000个，并且要比较的集群的数量为几十个或更多时，性能就会成为一个问题，因为每次比较的对数是

10^8

，对于集群的全对全比较，需要执行

10^4

次

对于一个幼稚的Python实现，这真的花了很长时间，所以我转向Cython和numpy。这样，我可以将一次比较的时间缩短到大约

0.9-3.0

秒。在我的例子中，这仍然意味着半天的运行时间。我想知道您是否看到了通过一些聪明的算法或C库，或者其他什么来实现性能的可能性

以下是我的尝试：

1） 这将在不为所有对分配巨大数组的情况下进行计数，获取长度为

n

的2个成员向量

a1、a2

，并返回计数：

cimport cython
import numpy as np
cimport numpy as np

ctypedef np.int32_t DTYPE_t

@cython.boundscheck(False)
def pair_counts(
    np.ndarray[DTYPE_t, ndim = 1] a1,
    np.ndarray[DTYPE_t, ndim = 1] a2,
    ):

    cdef unsigned int a1s = a1.shape[0]
    cdef unsigned int a2s = a2.shape[0]

    cdef unsigned int n11, n10, n01, n00
    n11 = n10 = n01 = n00 = 0
    cdef unsigned int j0

    for i in range(0, a1s - 1):
        j0 = i + 1
        for j in range(j0, a2s):
            if a1[i] == a1[j] and a2[i] == a2[j]:
                n11 += 1
            elif a1[i] == a1[j]:
                n10 += 1
            elif a2[i] == a2[j]:
                n01 += 1
            else:
                n00 += 1

    return n11, n10, n01, n00

2） 首先计算2个集群中每个集群的comembership向量（长度

n*（n-1）/2，每个实体对一个元素），然后计算这些向量的计数。它在每次比较时分配约20-40M内存，但有趣的是，比前一次快。注意：
c
是一个围绕集群的包装类，具有通常的成员向量，但也有一个
c.members
dict，它包含numpy数组中每个集群的实体索引

cimport cython
import numpy as np
cimport numpy as np

@cython.boundscheck(False)
def comembership(c):
    """
    Returns comembership vector, where each value tells if one pair
    of entites belong to the same group (1) or not (0).
    """
    cdef int n = len(c.memberships)
    cdef int cnum = c.cnum
    cdef int ri, i, ii, j, li

    cdef unsigned char[:] cmem = \
        np.zeros((int(n * (n - 1) / 2), ), dtype = np.uint8)

    for ci in xrange(cnum):
        # here we use the members dict to have the indices of entities
        # in cluster (ci), as a numpy array (mi)
        mi = c.members[ci]
        for i in xrange(len(mi) - 1):
            ii = mi[i]
            # this is only to convert the indices of an n x n matrix
            # to the indices of a 1 x (n x (n-1) / 2) vector:
            ri = n * ii - 3 * ii / 2 - ii ** 2 / 2 - 1
            for j in mi[i+1:]:
                # also here, adding j only for having the correct index
                li = ri + j
                cmem[li] = 1

    return np.array(cmem)

def pair_counts(c1, c2):
    p1 = comembership(c1)
    p2 = comembership(c2)
    n = len(c1.memberships)

    a11 = p1 * p2

    n11 = a11.sum()
    n10 = (p1 - a11).sum()
    n01 = (p2 - a11).sum()
    n00 = n - n10 - n01 - n11

    return n11, n10, n01, n00

3） 这是一个纯粹基于numpy的解决方案，它创建了一个
nxn
实体对的comemberships布尔数组。输入是成员向量（
a1、a2
）

编辑：示例数据

import numpy as np

a1 = np.random.randint(0, 1868, 14440, dtype = np.int32)
a2 = np.random.randint(0, 484, 14440, dtype = np.int32)

# to have the members dicts used in example 2:
def get_cnum(a):
    """
    Returns number of clusters.
    """
    return len(np.unique(a))

def get_members(a):
    """
    Returns a dict with cluster numbers as keys and member entities
    as sorted numpy arrays.
    """
    members = dict(map(lambda i: (i, []), range(max(a) + 1)))
    list(map(lambda m: members[m[1]].append(m[0]),
        enumerate(a)))
    members = dict(map(lambda m:
       (m[0], np.array(sorted(m[1]), dtype = np.int)),   
       members.items()))
    return members

members1 = get_members(a1)
members2 = get_members(a2)
cnum1 = get_cnum(a1)
cnum2 = get_cnum(a2)

基于排序的方法有其优点，但可以做得简单得多：

def pair_counts(a, b):
    n = a.shape[0]  # also b.shape[0]

    counts_a = np.bincount(a)
    counts_b = np.bincount(b)
    sorter_a = np.argsort(a)

    n11 = 0
    same_a_offset = np.cumsum(counts_a)
    for indices in np.split(sorter_a, same_a_offset):
        b_check = b[indices]
        n11 += np.count_nonzero(b_check == b_check[:,None])

    n11 = (n11-n) // 2
    n10 = (np.sum(counts_a**2) - n) // 2 - n11
    n01 = (np.sum(counts_b**2) - n) // 2 - n11
    n00 = n**2 - n - n11 - n10 - n01

    return n11, n10, n01, n00

如果在Cython中有效地编码此方法，则将获得另一个加速比（可能是~20倍）


编辑：

我找到了一种完全矢量化过程并降低时间复杂度的方法：

def sizes2count(a, n):
    return (np.inner(a, a) - n) // 2

def pair_counts_vec_nlogn(a, b):
    # Size of "11" clusters (a[i]==a[j] & b[i]==b[j])
    ab = a * b.max() + b  # make sure max(a)*max(b) fits the dtype!
    _, sizes = np.unique(ab, return_counts=True)

    # Calculate the counts for each type of pairing
    n = len(a)  # also len(b)
    n11 = sizes2count(sizes, n)
    n10 = sizes2count(np.bincount(a), n) - n11
    n01 = sizes2count(np.bincount(b), n) - n11
    n00 = n**2 - n - n11 - n10 - n01

    return n11, n10, n01, n00

def pair_counts_vec_linear(a, b):
    # Label "11" clusters (a[i]==a[j] & b[i]==b[j])
    ab = a * b.max() + b

    # Calculate the counts for each type of pairing
    n = len(a)  # also len(b)
    n11 = sizes2count(np.bincount(ab), n)
    n10 = sizes2count(np.bincount(a), n) - n11
    n01 = sizes2count(np.bincount(b), n) - n11
    n00 = n**2 - n - n11 - n10 - n01

    return n11, n10, n01, n00

有时O（n log（n））算法比线性算法快，因为线性算法使用
max（a）*max（b）
存储。命名可能会有所改进，我对术语不太熟悉。
要在线性时间内比较两个聚类
A
和
B
：

在
A
中遍历集群。让每个集群的大小为
a_i
。
A
中相同簇中的对总数是所有
A_i*（A_i-1）/2的总和

根据
B
中的簇对每个A簇进行分区。让每个分区的大小为
bj
。
A
和
B
中相同簇中的对总数是所有
B_j*（B_j-1）/2
的总和
两者之间的差异是A中属于同一簇但不属于B的对的总数
迭代
B
中的客户，以获得
B
中相同集群中的对总数，并从（2）中减去结果，以获得
B
中相同集群中的对，而不是
A
上述3个结果的总和是A或B中相同的对数。从n*（n-1）/2中减去，得到A和B中不同簇中的对总数
步骤（2）中的分区是通过为B创建字典映射项->集群，然后查找每个a集群中的每个项来完成的。如果要交叉比较大量聚类，只需为每个聚类计算一次这些映射并保留它们，就可以节省大量时间。
您不需要对这些对进行枚举和计数

相反，计算一个混淆矩阵，其中包含第一个聚类的每个聚类与第二个聚类的每个聚类的交集大小（这是所有对象上的一个循环），然后使用方程
n*（n-1）/2
计算该矩阵中的对数

这将您的运行时间从O（n^2）减少到O（n），因此它应该会给您带来相当大的加速。
您可以添加一个我们可以使用的代表性示例吗？当然，给我一点时间，我会补充说，并行化可能是一种方法。。。对于这样的操作，你的GPU可能比你的CPU还要快，这可以为你节省大量的时间，在你第一次尝试时，你没有键入
i
和
j
。也许GPU加速Python最简单的方法就是使用Numba（但我个人不认为我能给出一个例子）酷，它至少比我的解决方案快50-100倍。有了cython，我不能提高很多，但它已经足够快了。你的第二个版本我稍后会测试。非常感谢你！谢谢，好主意！我实现了它，实际上比@user6758673解决方案慢，但可能只是因为我构建混淆矩阵的代码太草率。使用numpy int数组，在
array[c1][c2]
处递增，其中
c1
和
c2
是对象的集群号。谢谢@Matt！这实际上与@anonymousse解决方案几乎相同，看起来还可以，尽管最后我一直使用user6758673解决方案，这也带来了很大的改进。
def sizes2count(a, n):
    return (np.inner(a, a) - n) // 2

def pair_counts_vec_nlogn(a, b):
    # Size of "11" clusters (a[i]==a[j] & b[i]==b[j])
    ab = a * b.max() + b  # make sure max(a)*max(b) fits the dtype!
    _, sizes = np.unique(ab, return_counts=True)

    # Calculate the counts for each type of pairing
    n = len(a)  # also len(b)
    n11 = sizes2count(sizes, n)
    n10 = sizes2count(np.bincount(a), n) - n11
    n01 = sizes2count(np.bincount(b), n) - n11
    n00 = n**2 - n - n11 - n10 - n01

    return n11, n10, n01, n00

def pair_counts_vec_linear(a, b):
    # Label "11" clusters (a[i]==a[j] & b[i]==b[j])
    ab = a * b.max() + b

    # Calculate the counts for each type of pairing
    n = len(a)  # also len(b)
    n11 = sizes2count(np.bincount(ab), n)
    n10 = sizes2count(np.bincount(a), n) - n11
    n01 = sizes2count(np.bincount(b), n) - n11
    n00 = n**2 - n - n11 - n10 - n01

    return n11, n10, n01, n00