在 R 中生成具有指定样本大小和概率的随机样本数据

Question

我想使用 R 编写一个模型来回答有关概率的一般问题。一般问题如下，然后是我关于如何使用 R 代码回答的具体问题。如果您知道一般问题的答案（与 R 代码分开），并且可以用简单的英语解释基本的统计原理，我也对此感兴趣！

问题：如果我拆分一组 n 个对象，首先通过 4 路拆分器，然后通过 7 路拆分器（导致总共 28 个不同的组），每个拆分器导致随机分布（即对象被大致平均分割），分割的顺序是否会影响最后 28 组的方差。如果我分成 4 再分成 7，那与分成 7 再分成 4 有什么不同？如果一个拆分器的方差大于另一个拆分器，答案是否会改变？

特定的 R 问题：我如何编写模型来回答这个问题？到目前为止，我已经尝试使用sample 和rnorm 来生成示例数据。模拟 4 路分离器看起来像这样：

sample(1:4, size=100000, replace=TRUE)

这基本上就像滚动一个 4 面骰子 100,000 次并记录每个数字的实例数。我可以使用 table 函数对实例求和，这给了我这样的输出：

> table(sample(1:4, size=100000, replace=TRUE))

    1     2     3     4 
25222 24790 25047 24941

现在，我想获取这些输出中的每一个并将它们用作 输入 以进行 7 路拆分。 我尝试将 4 路拆分保存为变量，然后将该向量插入到 size = 变量中，如下所示：

Split4way <- as.vector(table(sample(1:4, size=100000, replace=TRUE)))
as.vector(table(sample(1:7, size=Split4Way, replace=TRUE)))

但是当我这样做时，我得到的不是一个 4 行 7 列的矩阵，而是一个 1 行 7 列的向量。似乎 7 路拆分的“大小”变量仅使用 4 路拆分的 4 个输出中的 1 个，而不是使用其中的 每个。

> as.vector(table(sample(1:7, size = Split4up, replace=TRUE)))
[1] 3527 3570 3527 3511 3550 3480 3588

那么，我如何生成一个表格或列表来显示 4 路拆分和 7 路拆分的所有输出，总共 28 个拆分？

与

是否有一个功能可以让我自定义每个拆分设备的标准偏差？例如，我可以规定 4 路分路器的输出有 x% 的标准偏差，而 7 路分路器的输出有 x% 的标准偏差？

Answer 1

我也在努力解释您对方差和标准差的使用。我能想到的最好的就是不均匀地“分裂”

作为 Allan 代码的替代方案，您可以通过以下方式生成非均匀样本：

# how should the alternatives be weighted (normalised probability is also OK)
a <- c(1, 2, 3, 4)  # i.e. last four times as much as first
b <- c(1, 1, 2, 2, 3, 3, 4)

x <- sample(28, 10000, prob=a %*% t(b), replace=TRUE)

请注意，prob 在sample 中自动归一化（即除以总和）。您可以检查事情是否正常：

• table((x-1) %% 4 + 1) 应该接近 a/sum(a) * 10000
• table((x-1) %/% 4 + 1) 应该接近 b/sum(b) * 10000

Answer 2

我们可以通过编写一个模拟n 对象被传递到拆分器的函数来说明您的设置。

想象对象首先出现在 4 分割器中。让我们随机分配一个从 1 到 4 的数字来确定它的拆分方式。接下来是一个七分流器；我们也可以随机给它分配一个从 1 到 7 的数字，以确定它最终会进入哪个 bin。

设置如下：

                                    Final bins

1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
1  2  3  4  5  6  7  1  2  3  4  5  6  7  1  2  3  4  5  6  7  1  2  3  4  5  6  7  
\__|__|__|__|__|_/   \__|__|__|__|__|_/   \__|__|__|__|__|_/   \__|__|__|__|__|_/  
        |                    |                    |                    |
  seven splitter       seven splitter       seven splitter      seven splitter         
        |                    |                    |                    |
        1                    2                    3                    4
         \___________________|____________________|___________________/
                                        |
                                   four splitter
                                        |
                                      input

我们可以看到，任何唯一的数字对都会导致对象最终进入不同的 bin。

对于第二个设置，我们颠倒了顺序，使七个分离器先出现，但除此之外，每个对象仍然会根据一对唯一的数字获得一个唯一的 bin：

1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
1  2  3  4  1  2  3  4  1  2  3  4  1  2  3  4  1  2  3  4  1  2  3  4  1  2  3  4   
\__|__|__/  \__|__|__/  \__|__|__/  \__|__|__/  \__|__|__/  \__|__|__/  \__|__|__/  
     |           |           |           |           |           |           |
4 splitter  4 splitter  4 splitter  4 splitter  4 splitter  4 splitter  4 splitter 
     |           |           |           |           |           |           |
     1           2           3           4           5           6           7
      \__________|___________|___________|___________|___________|__________/
                                         |
                                     7 splitter
                                         |
                                       input

请注意，我们可以要么绘制随机 1:4 然后随机 1:7，反之亦然，但在任何一种情况下，唯一的对都将确定唯一的斌。对象最终进入的实际 bin 将根据应用两个数字的顺序而变化，但这不会改变每个 bin 将获得 1/28 传入的对象的事实，并且方差将保持不变.

这意味着模拟和比较两种设置，我们只需要对传入的每个对象从 1:4 和 1:7 进行采样，然后以不同的顺序应用这两个数字来计算最终的 bin：

simulate <- function(n) {
  df <- data.frame(fours  = sample(4, n, replace = TRUE),
                   sevens = sample(7, n, replace = TRUE))
  df$four_then_seven <- 7 * (df$fours - 1) + df$sevens
  df$seven_then_four <- 4 * (df$sevens - 1) + df$fours
  return(df)
}

让我们来看看这对于传入的 10 个对象会如何发挥作用：

set.seed(69) # Makes the example reproducible

simulate(10)
#>    fours sevens four_then_seven seven_then_four
#> 1      4      6              27              24
#> 2      1      5               5              17
#> 3      3      7              21              27
#> 4      2      2               9               6
#> 5      4      2              23               8
#> 6      4      3              24              12
#> 7      1      4               4              13
#> 8      3      2              16               7
#> 9      3      7              21              27
#> 10     3      2              16               7

如果我们有 100,000 次抽奖，现在让我们做一个表格，列出每个箱中的数量：

s <- simulate(100000)

seven_four <- table(s$seven_then_four)
seven_four
#> 
#>    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16 
#> 3434 3607 3539 3447 3512 3628 3564 3522 3540 3539 3544 3524 3552 3644 3626 3578 
#>   17   18   19   20   21   22   23   24   25   26   27   28 
#> 3609 3616 3673 3617 3654 3637 3542 3624 3568 3651 3486 3523

four_seven <- table(s$four_then_seven)
four_seven
#> 
#>    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15   16 
#> 3434 3512 3540 3552 3609 3654 3568 3607 3628 3539 3644 3616 3637 3651 3539 3564 
#>   17   18   19   20   21   22   23   24   25   26   27   28 
#> 3544 3626 3673 3542 3486 3447 3522 3524 3578 3617 3624 3523

如果您将这两个表从每个 bin 中的最小数字到最大数字排序，您会发现它们实际上是相同的，除了它们的 bin 上的标签。计数的分布完全不变。这意味着两种情况下的方差/标准差也是相同的：

var(four_seven)
#> [1] 3931.439

var(seven_four)
#> [1] 3931.439

更改方差/标准差的唯一方法是“修复”拆分器，使它们具有相等的概率。