python - 从基于列的数组返回多数加权投票

Question

我有一个矩阵 x与 3 x 3维度和向量 w即 3, :

x = np.array([[1, 2, 1],
              [3, 2 ,1],
              [1, 2, 2]])

w = np.array([0.3, 0.4, 0.3])

我需要生成另一个向量 y这是对 x 每一行的多数票. x的每一列由 w 中的相应值加权.像这样的东西:
为 y[0] ，它应该寻找 X[0] => [1, 2, 1]

值为 1 的列 = 第一和第三 [0,2]

值为 2 = 秒 [1]

的列

值 3 = 无的列

对按其在 X 中的值分组的列的权重(在 w 中)求和:

值为 1 的列的权重总和:0.3 + 0.3 = 0.6

值为 2 的列的权重总和:0.4

值为 3 的列的权重总和:0

由于值为 1 的列的权重总和最高，因此 y[0] = 1 .等等。

Answer 1

如果你懂 broadcasting，你可以用 numpy 来做.缺点是因为代码是矢量化的，所以你做的计算比你需要的要多。如果 w 的大小，这很重要向量非常大。
也许有人想出了一种更简单的方法来写它，但这就是我不用考虑太多的方式。
答案第一:

i = np.arange(3) + 1
m = (x.reshape((1,4,3)) == i.reshape((3,1,1)))
np.argmax(np.sum(m, axis=2).T*w, axis=1) + 1

现在分步讲解... 请注意，从零开始计数通常更好，但我遵循了您的约定。

我添加了一行，因此数组不对称(更容易检查形状)

 In [1]: x = np.array([[1, 2, 1],
    ...:               [3, 2 ,1],
    ...:               [1, 2, 2],
    ...:               [3, 1, 3]])
    ...:
    ...: w = np.array([0.3, 0.4, 0.3])

第一步是拥有索引数组 i .你的约定从一开始。

 In [2]: i = np.arange(3) + 1

棘手的步骤 : 创建一个形状为 (3,4,3) 的数组，其中数组的第 i 个条目是一个 (4,3) 数组，所有条目均为 0 或 1。当且仅当 x == i 时它为 1。这是通过向 x 添加维度来完成的。和 i所以他们可以被广播。操作基本比较x的所有组合和 i , 因为 x 的所有维度匹配大小 = i 的 1 个维度反之亦然:

 In [3]: m = (x.reshape((1,4,3)) == i.reshape((3,1,1)))*1

 In [4]: m
 Out[4]:
 array([[[1, 0, 1],
         [0, 0, 1],
         [1, 0, 0],
         [0, 1, 0]],

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

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

现在您沿行(即轴 = 2)求和以获得每个选择出现在 x 的每一行中的次数(请注意，当您将其与 x 进行比较时，结果会转置):

 In [5]: np.sum(m, axis=2)
 Out[5]:
 array([[2, 1, 1, 1],
        [1, 1, 2, 0],
        [0, 1, 0, 2]])

我希望你已经看到这是怎么回事。可以直接阅读:在x的第一行, 1出现两次和 2出现一次。第二排x ，全部出现一次，在x的第三行, 1出现一次，2出现两次等。

乘以权重:

 In [7]: np.sum(m, axis=2).T*w
 Out[7]: 
 array([[0.6, 0.4, 0. ],
        [0.3, 0.4, 0.3],
        [0.3, 0.8, 0. ],
        [0.3, 0. , 0.6]])

沿行获取最大值(添加一个以符合您的约定):

 In [8]: np.argmax(np.sum(m, axis=2).T*w, axis=1) + 1
 Out[8]: array([1, 2, 2, 3])

特例:领带
在评论中提出了以下案例:

x = np.array([[2, 2, 4, 1]])
w = np.array([0.1, 0.2, 0.3, 0.4])

权重之和为:

[0.1, 0.4, 0., 0.4]

所以在这种情况下没有赢家。从问题中不清楚在这种情况下会做什么。一个可以全拿，一个都不拿……最后可以找这些案例:

final_w = np.sum(m, axis=2).T*w
result = np.argmax(np.sum(m*w, axis=2), axis=0) + 1
special_cases = np.argwhere(np.sum(final_w == np.max(final_w), axis=1) > 1)

注:为了可读性，我使用了reshape方法，但我经常使用 np.expand_dims或 np.newaxis。像这样的东西:

i = np.arange(3) + 1
m = (x[np.newaxis] == i[:, np.newaxis, np.newaxis])
np.argmax(np.sum(m, axis=2).T*w, axis=1) + 1

另一种选择:你也可以使用某种编译代码。例如，在这种情况下，numba 非常容易使用。