python - 如何根据累积列、当前列和距离对数组中值的最大出现次数进行排序

Question

我有一个有序距离索引数组。

d    
array([[  0.        ,   5.38516481,   8.60232527,   7.61577311,
          3.        ,   4.12310563,  12.36931688],
       [  5.38516481,   0.        ,   5.        ,   7.        ,
          7.07106781,   2.        ,  13.34166406],
       [  8.60232527,   5.        ,   0.        ,   6.164414  ,
          8.77496439,   6.70820393,  10.34408043],
       [  7.61577311,   7.        ,   6.164414  ,   0.        ,
          8.18535277,   8.06225775,  10.04987562],
       [  3.        ,   7.07106781,   8.77496439,   8.18535277,
          0.        ,   6.164414  ,  10.09950494],
       [  4.12310563,   2.        ,   6.70820393,   8.06225775,
          6.164414  ,   0.        ,  13.92838828],
       [ 12.36931688,  13.34166406,  10.34408043,  10.04987562,
         10.09950494,  13.92838828,   0.        ]])
a = np.argsort(d,axis=1)[:,-3:]
a

array([[3, 2, 6],
       [3, 4, 6],
       [0, 4, 6],
       [5, 4, 6],
       [3, 2, 6],
       [2, 3, 6],
       [0, 1, 5]], dtype=int64)

需要从最后一列到第一列累计检查。

我尝试这样做:

unique, counts = numpy.unique(a, return_counts=True)
x = dict(zip(unique, counts))
sorted(x.items(), key = lambda x: x[1],reverse=True)

[(6, 6), (3, 4), (2, 3), (4, 3), (0, 2), (5, 2), (1, 1)]

在上面的元组列表中，(2, 3) 和 (4, 3) 具有相同的计数。但是当我们从最后一列到第一列累积检查时。我需要将列表获取为 (4, 3), (2, 3)，因为 4 出现在列中的 2 之前。

3 个最大出现次数的预期输出:

[6, 3, 4]

为了进行验证，请检查以下内容:

a = np.array([[2, 3, 6],
   [2, 4, 5],
   [0, 4, 3],
   [1, 4, 6],
   [2, 3, 5],
   [3, 2, 6],
   [0, 1, 5]])
unique, counts = numpy.unique(a, return_counts=True)
x = dict(zip(unique, counts))
sorted(x.items(), key = lambda x: x[1],reverse=True)

[(2, 4), (3, 4), (4, 3), (5, 3), (6, 3), (0, 2), (1, 2)]

在上面的列表中，我们需要将列表获取为 (3, 4) then (2, 4) 以及 (5, 3), (6, 3) 和然后 (4, 3) 因为 (5, 3), (6, 3) 出现在最后一列中，先于 4。最后，如果同一列中有相同的计数，例如(5, 3), (6, 3) 对，使距离最大的索引首先出现，如上面的 d 数组所示。
注意:验证矩阵是手动创建的，并且距离不存在，而第一个矩阵是真实的。

请给我通用的解决方案，并且可以适用于任何此类数组。
我尝试编码，但无法获得完成任务的正确逻辑。我知道我沿列应用了 np.argmax() 但我需要累积检查。

如果您不明白问题的任何部分，请发表评论，我会澄清。

Answer 1

以下内容需要 numpy 1.13+，因为它使用新的 axis参数unique .

import numpy as np

a = np.array([[2, 3, 6],
   [2, 4, 5],
   [0, 4, 3],
   [1, 4, 6],
   [2, 3, 5],
   [3, 2, 6],
   [0, 1, 5]]) * 1000 # do not rely on uniques being 0,1,2,3...

# add column indices
ac = np.c_[a.ravel(), np.outer(np.ones((len(a),), a.dtype), np.arange(3)).ravel()]

# find uniq pairs (data, col ind)
uniq, cnts = np.unique(ac, return_counts=True, axis=0)
uniquniq, uniqidx = np.unique(uniq[:, 0], return_inverse=True)

# make grid uniq els x col idx fill with counts
fullcnts = np.zeros((len(uniquniq), 3), dtype=int)
fullcnts[uniqidx, uniq[:, 1]] = cnts
cumcnts = np.cumsum(fullcnts[:, ::-1], axis=-1)

# order by sum and then column cnts as tie breakers
order = np.lexsort((cumcnts[:, 1], cumcnts[:, 0], cumcnts[:, 2]))[::-1]
result = list(zip(uniquniq[order], cumcnts[order, 2]))

# [(3000, 4), (2000, 4), (6000, 3), (5000, 3), (4000, 3), (1000, 2), (0, 2)]

逐行:

1) 我们创建一个看起来像 [(2, 0), (3, 1), (6, 2), (2, 0), (4, 1), (5, 2), ...，即 a 的每个元素及其列索引。

2) 这样我们就可以制作unique按列计算出现次数。例如，为 uniq 元素 (2, 0) 返回的计数将是第零列中 2 的数量。

3)我们现在从唯一对中提取实际的唯一值。 uniqidx与 uniq 相同但每个元素都替换为其在 uniquniq 中的位置(索引)

4)接下来我们构建一个唯一 x 列的表

5) 并将所有计数放在适当的位置

6) 然后我们对计数求和。 (其实没必要用累加，但也没什么坏处)

7) 我们现在拥有对独特内容进行排名所需的所有内容。 lexsort是间接排序，如 argsort ，只有您可以按多个向量排序，首先考虑最后传递的向量。我们把cumcnts[:, 2]其中是总计数，接下来(如果平局)cumcnts[:, 0]这是最后一列的计数，最后是 cumcnts[:, 1]这是最后一列和中间列的总计数。正如(6)中提到的，我们也可以在这里单独使用中间列的计数。

8) lexsort返回一个索引 ( order )，我们用它来按正确的顺序排列唯一值及其计数。