如何验证混洗算法是否统一？

Question

我有Knuth's shuffling algorithm的简单Python实现：

def knuth_shuffle(ar):
    num = len(ar)
    for i in range(num):
        index = random.randint(0, i)
        ar[i], ar[index] = ar[index], ar[i]
    return ar

如何测试（使用scipy或其他任何包）洗牌确实是统一的？我找到了几个相关的帖子（1，2），但他们没有回答我的问题。一般来说，了解如何执行此类检查会很棒。

Answer 1

编辑：

作为评论中的Paul Hankin，我的原始测试只检查了每个元素落入每个位置的概率，而不是所有排列都是同等可能的，这是一个更强烈的要求。下面的代码段计算每个排列的频率，这是我们应该看到的：

import math
import random

def knuth_shuffle(ar):
    num = len(ar)
    for i in range(num):
        index = random.randint(0, i)
        ar[i], ar[index] = ar[index], ar[i]
    return ar

# This function computes a unique index for a given permutation
# Adapted from https://www.jaapsch.net/puzzles/compindx.htm#perm
def permutation_index(permutation):
    n = len(permutation)
    t = 0
    for i in range(n):
      t = t * (n - i)
      for j in range(i + 1, n):
        if permutation[i] > permutation[j]:
            t += 1
    return t

N = 6  # Test list size
T = 1000  # Trials / number of permutations

random.seed(100)
n_perm = math.factorial(N)
trials = T * n_perm
ar = list(range(N))
freq = [0] * n_perm
for _ in range(trials):
    ar_shuffle = ar.copy()
    knuth_shuffle(ar_shuffle)
    freq[permutation_index(ar_shuffle)] += 1

如果随机播放是统一的，则生成的freq向量的值应根据具有T * N!次试验的二项分布和成功概率1 / (N!)进行分配。以下是上一个示例（使用Seaborn完成）的分布估计图，其中频率值应为1000左右：

我认为看起来好但是，对于定量结果，您需要进行更深入的统计分析，例如Pearson's chi-squared test建议的David Eisenstat。

原始答案：

我将在这里提出一些基本的想法，但我没有最强的统计背景，所以有人可能想要补充或纠正任何错误。

您可以将每个值的频率矩阵放入每个位置进行多次试验：

def knuth_shuffle(ar):
    num = len(ar)
    for i in range(num):
        index = random.randint(0, i)
        ar[i], ar[index] = ar[index], ar[i]
    return ar

N = 100  # Test list size
T = 10000  # Number of trials
ar = list(range(N))
freq = [[0] * N for _ in range(N)]

for _ in range(T):
    ar_shuffle = ar.copy()
    kunth_shuffle(ar_shuffle)
    for i, j in enumerate(ar_shuffle):
        freq[i][j] += 1

一旦你能做到这一点，你可以采取几种方法。一个简单的想法是，如果洗牌是统一的，freq / T应倾向于1 / N，因为T倾向于无穷大。所以你可以使用一个非常大的＆＃34;值T并看到这些值足够接近＆＃34;。或者检查freq / T - 1 / N的标准偏差是否足够小＆＃34;。

这些＆＃34;足够接近＆＃34;并且＆＃34;足够小＆＃34;虽然不是很扎实的概念。基础分析需要更多统计工具。我认为您需要test the hipothesis每个频率值都来自binomial distribution T次试验1 / N成功概率。正如我所说，没有完整解释的背景，这可能不适合它，但如果你真的需要彻底的分析，你可以阅读这个主题。

Answer 2

您可以通过将所有可能的随机数序列注入knuth_shuffle来检查这一点，然后验证您是否只需准备一次。

此代码执行此操作：

import collections
import itertools
import random

def knuth_shuffle(ar, R=random.randint):
    num = len(ar)
    for i in range(num):
        index = R(0, i)
        ar[i], ar[index] = ar[index], ar[i]
    return ar

def fact(i):
    r = 1
    while i > 1:
        r *= i
        i -= 1
    return r

def all_random_seqs(N):
    for r in range(fact(N)):
        seq = []
        for i in range(N):
            seq.append(r % (i+1))
            r //= (i+1)
        it = iter(seq)
        yield lambda x, y: next(it)

for N in range(1, 6):
    print N
    results = collections.Counter()
    for R in all_random_seqs(N):
        a = list('ABCDEFG'[:N])
        knuth_shuffle(a, R)
        results[''.join(a)] += 1
    print 'checking...'
    if len(results) != fact(N):
        print 'N=%d. Not enough results. %s' % (N, results)
    if any(c > 1 for c in results.itervalues()):
        print 'N=%d. Not all permutations unique. %s' % (N, results)
    if any(sorted(c) != list('ABCDEFG'[:N]) for c in results.iterkeys()):
        print 'N=%d. Some permutations are illegal. %s' % (N, results)

此代码检查大小为1,2,3,4,5的输入列表的确切正确性。您可以在N之前再远一点！太大了。

您还希望使用random.randint对代码版本执行完整性检查（例如，生成500次'ABCD'，并确保每次排列至少一次。）

Answer 3

如果您从给定的固定订单中随机洗牌相同的商品，则随机商品中一个固定位置中每个商品的数量应该趋向于相同的值。

下面我将列表0..9洗牌几次并打印输出：

from random import shuffle  # Uses Fischer-Yates

tries = 1_000_000
intcount = 10
first_position_counts = {n:0 for n in ints}
ints = range(intcount)
for _ in range(tries):
    lst = list(ints)   # [0, 1, ...9] In that order
    shuffle(lst)
    first_position_counts[lst[0]] += 1

print(f'{tries} shuffles of the ints 0..{intcount-1} should have each int \n',
      'appear in the first position {tries/intcount} times.')
for item in first_position_counts.items():
    print(' %i: %5i' % item)

运行一次，你可能得到类似的东西：

 0: 99947
 1: 100522
 2: 99828
 3: 100123
 4: 99582
 5: 99635
 6: 99991
 7: 100108
 8: 100172
 9: 100092

再次：

 0: 100049
 1: 99918
 2: 100053
 3: 100285
 4: 100293
 5: 100034
 6: 99861
 7: 99584
 8: 100055
 9: 99868

现在，如果你有数以千计的项目要洗牌，那么它们应该以{{1​​}}排列之一结束，但是n!变大，强大;如果它是“可比较的”，肯定比你的随机数发生器的可能范围更大，那么它就会崩溃。