生成非连续样本

Question

我们如何有效地从[1,...,N] 中生成k 随机和非连续样本？

(N=10, k=4) 的非期望示例： 2,3,8,10

这不是一个理想的例子，因为2 和3 是连续的。

(N=10, k=4) 的所需示例： 2,6,8,10

这是一个很好的例子，因为每对样本之间的差异都大于1

Answer 1

您可以使样本之间的增量均匀分布在 2 和 N-1 之间（以避免连续和重复的数字）：

N=10;
k=4;
increments = floor(rand(1,k)*(N-2))+2  %// increments allowed are from 2 to N-1 inclusive
out = mod(cumsum(increments), N)+1   %// sum increments

在 python 中相同：

from numpy import cumsum, floor, mod, random
N=5
k=100
increments = floor(random.rand(1,k)*(N-2))+2
out = mod(cumsum(increments), N)+1
print(out)

[ 5.  3.  1.  5.  2.  4.  3.  2.  4.  2.  4.  3.  1.  5.  4.  3.  5.  4.
  2.  5.  4.  2.  5.  2.  4.  1.  5.  4.  1.  5.  3.  1.  3.  2.  4.  1.
  5.  4.  1.  3.  5.  4.  3.  5.  2.  1.  3.  2.  4.  3.  1.  4.  2.  1.
  3.  2.  1.  4.  3.  2.  1.  3.  5.  3.  5.  4.  2.  4.  2.  1.  3.  2.
  1.  3.  5.  2.  5.  4.  3.  1.  4.  1.  4.  3.  5.  4.  2.  1.  5.  2.
  1.  5.  4.  2.  4.  3.  5.  2.  4.  1.]

超过 100 次迭代，即使我将数字限制为 1..5，也没有重复/连续的数字。

Answer 2

不是特别优雅的 python 解决方案：

def nonseq(n, k):
    out = [random.randint(0, n)]
    while len(out) < k:
        x = random.randint(0, n)
        if abs(x - out[-1]) > 1:
            out.append(x)
    return out

Answer 3

正确检查每对样本的 Python 类。但是，您有责任不向它传递一组不可能的数字（例如 N = 10，k = 100）。

>>> class NonConsecutiveSampler(object):
        def __init__(self,N):
                import random
                self.num = N
        def get_samples(self,k):
                possibilities = [i for i in range(1,self.num + 1)]
                samples = []
                while len(samples) < k:
                        r = random.sample(possibilities,1)[0]
                        samples.append(r)
                        for i in range(r - 1, r + 2):
                                if i in possibilities:
                                        possibilities.remove(i)
                samples.sort()
                return samples


>>> n = NonConsecutiveSampler(10)
>>> n.get_samples(4)
[2, 5, 8, 10]
>>> n.get_samples(4)
[1, 5, 7, 10]
>>> n.get_samples(4)
[3, 6, 8, 10]
>>> n.get_samples(4)
[1, 3, 5, 8]

编辑：提高效率

Answer 4

MATLAB 中的解决方案（可能不太优雅）可能是这样的：

N = 10;
k = 4;
out = zeros(1,k);

vec = 1 : N;

for idx = 1 : k
    ind = randi(numel(vec), 1);
    left = max(ind-1, 1); right = min(numel(vec), ind+1);
    out(idx) = vec(ind);
    to_remove = ind;
    if vec(left) == vec(ind)-1 
        to_remove = [to_remove left];
    end
    if vec(right) == vec(ind)+1
        to_remove = [to_remove right];
    end
    vec(to_remove) = [];
end

我们首先声明N 和k，然后声明一个长为k 的零输出数组。然后我们生成一个采样向量vec，它最初从 1 到 N。接下来，对于我们想要放入输出的每个值，我们生成一个随机位置以从向量中采样，然后从左侧和右侧查看位置......确保我们在边界内大批。此外，如果要删除的索引左侧的值与右侧的值彼此相等，我们仅向左或向右删除（感谢烧杯！）

我们使用这个位置并从这个向量中采样，将这个位置的值放到输出中，然后从这个向量中删除这个向量中左边、右边的索引，以及实际的索引本身。这消除了再次从这些值中采样的可能性。我们重复此操作，直到我们用完要放置在输出中的值。

以下是一些试运行：

>> out

out =

     9     7     1     5

>> out

out =

     7     1     4    10

>> out

out =

    10     8     1     6

>> out

out =

    10     4     8     1

Answer 5

我的实现：

def ncsample(population, k):
    import random
    if k > 0:
        i = random.randrange(0, len(population) - 2*(k-1))
        return [population[i]] + ncsample(population[i+2:], k-1)
    else:
        return []

注意：它会一次性随机找到序列（在while循环中没有拒绝采样）。

MATLAB 实现：

function r = ncsample(population, k)
    if k > 0
        i = randi(length(population) - 2*(k-1));
        r = [population(i) ncsample(population((i+2):end), k-1)];
    else
        r = [];
    end
end

一些测试：

>> for i=1:10; fprintf('%s\n',sprintf('%d ', ncsample(1:10, 4))); end
1 5 7 9 
3 5 8 10 
3 5 8 10 
4 6 8 10 
2 6 8 10 
1 4 8 10 
1 4 7 9 
3 6 8 10 
1 6 8 10 
2 4 7 9 

Answer 6

让S 表示所有k 元素向量的集合，其值取自[1,...,N]，没有任何连续值。要在 S 上以 均匀 分布随机抽样，您可以使用拒绝方法：

1. 在更大的采样空间上均匀采样，T。
2. 如果样本属于目标区域S，则接受该样本。否则返回第 1 步（样本被拒绝）。

在 Matlab 中，很容易生成均匀分布的 k 元素向量，其值取自 [1,...,N] 而无需替换（函数 randsample）。所以这被用作样本空间T：

k = 4;
N = 10;
result = [1 1];                         % // just to get while loop started
while any(diff(result)<=1)              % // does not meet condition: try again
    result = sort(randsample(N, k).');  %'// random sample without replacement
end

Answer 7

这是一个递归的优雅版本，我只是添加了对 k 和 N 的检查以避免无限递归，如果 k>N/2 不存在解决方案。

结果保证是随机的。

import random

def myFunc(N,k):
    if k>(N+1)/2:
        return "k to big for N"
    returnValue = sorted(random.sample(range(1,N+1),k))
    toTest = [x - returnValue[i - 1] for i, x in enumerate(returnValue)][1:]
    if 1 in toTest:
        return myFunc(N,k)
    else:
        return returnValue

print myFunc(10,4)

Answer 8

有时生成比您需要的更多的样本然后丢弃不需要的值会更快、更容易。

一个（慢）示例。

vec= randi(100,1,1);
for j = 2:50,
   while(abs(vec(j)-vec(j-1)<2) vec(j)= randi(100,1,1);end;
end

另一种方式。假设您需要 50 个样本

vec = rand(100,100,1);
badindex = find(abs(vec(1:99)-vec(2:100) < 1));
vec(badindex) = vec(badindex-1)+vec(badindex+1);
% if you don't want big values,
vec(vec>100) = vec (vec>100) -100; % to ensure, I hope, that neighbors

% 是不连续的 （这在R 中会更容易）。

Answer 9

sort(randperm(N-(k-1),k))+[0:(k-1)]

这个解决方案背后有一个简单的观察，如果你对你的问题采取任何排序的解决方案并减去[0:(k-1)]，你最终会从N-(k-1)中随机选择k个数字