Question

这是我要在Python 2.7中使用Numpy进行的操作。假设我有以下定义的数组a：

a = np.array([[1,3,3],[4,5,6],[7,8,1]])

我可以执行a.argmax(0)或a.argmax(1)来获取行/列明智的argmax：

a.argmax(0)
Out[329]: array([2, 2, 1], dtype=int64)
a.argmax(1)
Out[330]: array([1, 2, 1], dtype=int64)

但是，当在a的第一行中有一条领带时，我希望获得两个领带之间随机确定的argmax（默认情况下，只要argmax或argmin）。

去年，有人问一个随机解决Numpy argmax / argmin关系的问题：Select One Element in Each Row of a Numpy Array by Column Indices

但是，该问题针对一维数组。在那里，投票率最高的答案非常适合。还有第二个答案，它也尝试解决多维数组的问题，但不起作用-即它不会返回，对于每一行/列，最大值的索引以及随机解决的联系。

既然我正在处理大型数组，那么最有效的方法是什么？

Answer 1

一种简单的方法是在开始时向所有值添加一个小的随机数，因此您的数据将如下所示：

a = np.array([[1.1827,3.1734,3.9187],[4.8172,5.7101,6.9182],[7.1834,8.5012,1.9818]])

可以通过a = a + np.random.random(a.shape)完成。

如果以后需要恢复原始值，可以执行a.astype(int)来删除小数部分。

Answer 2

一般案例解决方案，每组选择一个

要解决从指定列表范围的数字列表/数字数组中选择随机数的一般情况，我们将使用一个技巧来创建一个统一的rand数组，添加由间隔长度指定的偏移量，然后执行argsort。实现看起来像这样-

def random_num_per_grp(L):
    # For each element in L pick a random number within range specified by it
    r1 = np.random.rand(np.sum(L)) + np.repeat(np.arange(len(L)),L)
    offset = np.r_[0,np.cumsum(L[:-1])]
    return r1.argsort()[offset] - offset

示例案例-

In [217]: L = [5,4,2]

In [218]: random_num_per_grp(L) # i.e. select one per [0-5,0-4,0-2]
Out[218]: array([2, 0, 1])

因此，输出将具有与输入L中相同的元素数，并且第一个输出元素将位于[0,5)中，第二个元素位于[0,4)中，依此类推。

在这里解决问题

要在此处解决问题，我们将使用修改后的版本（具体是在函数的末尾删除偏移量删除部分，就像这样-

def random_num_per_grp_cumsumed(L):
    # For each element in L pick a random number within range specified by it
    # The final output would be a cumsumed one for use with indexing, etc.
    r1 = np.random.rand(np.sum(L)) + np.repeat(np.arange(len(L)),L)
    offset = np.r_[0,np.cumsum(L[:-1])]
    return r1.argsort()[offset]

方法1

一种解决方案可以像这样使用它-

def argmax_per_row_randtie(a):
    max_mask = a==a.max(1,keepdims=1)
    m,n = a.shape
    all_argmax_idx = np.flatnonzero(max_mask)
    offset = np.arange(m)*n
    return all_argmax_idx[random_num_per_grp_cumsumed(max_mask.sum(1))] - offset

验证

让我们对给定的样本进行大量的运行测试，并计算每一行每个索引的出现次数

In [235]: a
Out[235]: 
array([[1, 3, 3],
       [4, 5, 6],
       [7, 8, 1]])

In [225]: all_out = np.array([argmax_per_row_randtie(a) for i in range(10000)])

# The first element (row=0) should have similar probabilities for 1 and 2
In [236]: (all_out[:,0]==1).mean()
Out[236]: 0.504

In [237]: (all_out[:,0]==2).mean()
Out[237]: 0.496

# The second element (row=1) should only have 2
In [238]: (all_out[:,1]==2).mean()
Out[238]: 1.0

# The third element (row=2) should only have 1
In [239]: (all_out[:,2]==1).mean()
Out[239]: 1.0

方法2：使用masking来提高效果

我们可以使用masking并因此避免flatnonzero的目的是像通常使用布尔数组那样获得性能。此外，我们将概括性地覆盖行（轴= 1）和列（轴= 0），以便为我们自己修改，如-

def argmax_randtie_masking_generic(a, axis=1): 
    max_mask = a==a.max(axis=axis,keepdims=True)
    m,n = a.shape
    L = max_mask.sum(axis=axis)
    set_mask = np.zeros(L.sum(), dtype=bool)
    select_idx = random_num_per_grp_cumsumed(L)
    set_mask[select_idx] = True
    if axis==0:
        max_mask.T[max_mask.T] = set_mask
    else:
        max_mask[max_mask] = set_mask
    return max_mask.argmax(axis=axis)

样本在axis=0和axis=1上运行-

In [423]: a
Out[423]: 
array([[1, 3, 3],
       [4, 5, 6],
       [7, 8, 1]])
In [424]: argmax_randtie_masking_generic(a, axis=1)
Out[424]: array([1, 2, 1])

In [425]: argmax_randtie_masking_generic(a, axis=1)
Out[425]: array([2, 2, 1])

In [426]: a[1,1] = 8

In [427]: a
Out[427]: 
array([[1, 3, 3],
       [4, 8, 6],
       [7, 8, 1]])

In [428]: argmax_randtie_masking_generic(a, axis=0)
Out[428]: array([2, 1, 1])

In [429]: argmax_randtie_masking_generic(a, axis=0)
Out[429]: array([2, 1, 1])

In [430]: argmax_randtie_masking_generic(a, axis=0)
Out[430]: array([2, 2, 1])

Answer 3

您可以使用与输入形状相同的随机数数组，但要屏蔽掉该数组，只保留候选对象供选择。

import numpy as np

def rndArgMax(a, axis):
    a_max = a.max(axis, keepdims=True)
    tmp = np.random.random(a.shape) * (a == a_max)
    return tmp.argmax(axis)

a = np.random.randint(0, 3, size=(2, 3, 4))
print(rndArgMax(a, 1))
# array([[1, 1, 2, 1],
#        [0, 1, 1, 1]])

numpy数组：具有随机关系的行/列明智argmax

3 个答案:

一般案例解决方案，每组选择一个

在这里解决问题