在某个预定义的间隔内使用抽屉绘制随机数，`numpy.random.choice()`

Posted 2023-02-23

【中文标题】在某个预定义的间隔内使用抽屉绘制随机数，`numpy.random.choice()`

【英文标题】：Drawing random numbers with draws in some pre-defined interval, `numpy.random.choice()`

【发布时间】：2018-06-05 14:47:56

【问题描述】：

我想使用numpy.random.choice()，但请确保抽签至少有一定的“间隔”：

作为一个具体的例子，

import numpy as np
np.random.seed(123)
interval = 5
foo = np.random.choice(np.arange(1,50), 5)  ## 5 random draws between array([ 1,  2, ..., 50])
print(foo)
## array([46,  3, 29, 35, 39])

我希望它们至少间隔interval+1，即 5+1=6。在上面的例子中，这个条件不满足：应该有另一个随机抽奖，因为 35 和 39 被 4 隔开，小于 6。

数组array([46, 3, 29, 15, 39]) 没问题，因为所有绘图至少间隔6。

numpy.random.choice(array, size) 在size 中抽取array 的次数。是否有另一个函数用于检查 numpy 数组中元素之间的“间距”？我可以用 if/while 语句编写上述内容，但我不确定如何最有效地检查 numpy 数组中元素的间距。

【参考方案1】：

这是一个在绘制后插入空格的解决方案：

def spaced_choice(low, high, delta, n_samples):
    draw = np.random.choice(high-low-(n_samples-1)*delta, n_samples, replace=False)
    idx = np.argsort(draw)
    draw[idx] += np.arange(low, low + delta*n_samples, delta)
    return draw

示例运行：

spaced_choice(4, 20, 3, 4)
# array([ 5,  9, 19, 13])
spaced_choice(1, 50, 5, 5)
# array([30,  8,  1, 15, 43])

请注意，抽签然后接受或拒绝并重抽的策略可能非常昂贵。在下面的最坏情况示例中，仅10 样本重绘几乎需要半分钟，因为接受/拒绝比率非常差。 insert-the-spaces-afterwards 方法没有此类问题。

两个例子不同方法所需的时间：

low, high, delta, size = 1, 100, 5, 5
add_spaces            0.04245870 ms
redraw                0.11335560 ms
low, high, delta, size = 1, 20, 1, 10
add_spaces            0.03201030 ms
redraw            27881.01527220 ms

代码：

import numpy as np

import types
from timeit import timeit

def f_add_spaces(low, high, delta, n_samples):
    draw = np.random.choice(high-low-(n_samples-1)*delta, n_samples, replace=False)
    idx = np.argsort(draw)
    draw[idx] += np.arange(low, low + delta*n_samples, delta)
    return draw

def f_redraw(low, high, delta, n_samples):
    foo = np.random.choice(np.arange(low, high), n_samples)
    while any(x <= delta for x in np.diff(np.sort(foo))):
        foo = np.random.choice(np.arange(low, high), n_samples)
    return foo

for l, h, k, n in [(1, 100, 5, 5), (1, 20, 1, 10)]:
    print(f'low, high, delta, size = l, h, k, n')
    for name, func in list(globals().items()):
        if not name.startswith('f_') or not isinstance(func, types.FunctionType):
            continue
        print(":16s:16.8f ms".format(name[2:], timeit(
                'f(*args)', globals='f':func, 'args':(l,h,k,n), number=10)*100))

【讨论】：

看起来f_add_spaces() 可能是要走的路。有趣的是，有两种类型的 ValueErrors 接近“边缘情况”，其中间隔/绘制/np.arange() 组合在数学上是不可能的。例如f_add_spaces(1, 100, 24, 5) 给出ValueError: Cannot take a larger sample than population when 'replace=False' 而f_add_spaces(1, 100, 25, 5) 给出ValueError: a must be greater than 0。我得为这些写支票

@ShanZhengYang 我认为行为是正确的，因为在您的两个示例中，值根本不适合：1、26、51、76、101（间隙 > 24）和 1、27 , 53, 79, 105（差距 > 25）。如果您想要更好的错误消息，您可以检查 high - low

"我认为行为是正确的，因为在您的两个示例中，值根本不适合：1、26、51、76、101（间隙 > 24）和 1、27， 53、79、105（差距> 25）。“你是对的（希望之前很清楚）。只是一个有趣的观察，因为它在不同的部分都失败了。第一个发生在File "mtrand.pyx", line 1161, in mtrand.RandomState.choice (numpy/random/mtrand/mtrand.c:18155)，第二个发生在File "mtrand.pyx", line 1115, in mtrand.RandomState.choice (numpy/random/mtrand/mtrand.c:17104)。我会写一个新颖的警告给用户。谢谢！

@ShanZhengYang 哦，我明白了。这是因为在第一种情况下，choice 的第一个参数评估为3，如果我们不要求该范围内的 5 个不同样本，这将是可以的。在第二种情况下，它的计算结果为-1，这在任何情况下都没有意义。

对。这两个错误都来自np.random.choice()。第一个错误发生在np.random.choice(a, size, replace=False) 时a > size。第二个错误发生在a <= 0时。

【参考方案2】：

您可以先对数组进行排序以使所有点按升序排列，然后使用np.diff 查找连续值之间的差异。如果任何差值小于interval，则不满足条件。即

import numpy as np

interval = 5
foo = np.random.choice(np.arange(1,50),5)
while np.any(np.diff(np.sort(foo)) <= interval):
     foo = np.random.choice(np.arange(1,50),5)
print(foo)

这会循环直到你得到一个所有值至少相差interval的numpy数组。

【讨论】：

# condition isn't met. 在这种情况下意味着删除数组中不满足条件的元素，并通过numpy.random.choice() 重新绘制。给定当前代码，用户将从数组中弹出x，并继续绘制直到他们可以继续

我会再次调用随机选择，直到获得满意的数组。请查看更新后的答案。

我建议使用while np.any(np.diff(np.sort(foo)) <= interval): 而不是列表理解。减少数据类型的混洗。此外，OP 希望差异严格大于interval，因此

我担心这可能需要很长时间。如果foo 中的任何一个元素打破了interval 条件，将再进行5 次抽奖。

是的，这个方法可能需要更长的时间，如另一个答案所示。如果您的目标是时间效率，请使用该答案。但是，我确实相信代码也应该是最少的。如果您的数组大小很小，请使用此方法。如果不是，也许另一个答案是更好的方法，但会牺牲更长的代码。