在R中随机重新排列矩阵的补丁。

huangapple
go评论99阅读模式
英文:

Randomly rearranging patches of a matrix in R

问题

我正在尝试随机重新排列矩阵中的补丁。这需要针对较大的矩阵和小补丁进行操作，因此使用for循环似乎不是一种实现的选项。假设我有一个数据矩阵如下：

  1. data <- matrix(1:16, nrow = 4)

输出如下所示：

  1.      [,1] [,2] [,3] [,4]
  2. [1,]    1    5    9   13
  3. [2,]    2    6   10   14
  4. [3,]    3    7   11   15
  5. [4,]    4    8   12   16

我现在想选择2x2的补丁并随机重新排列它们，以便输出可能看起来像这样：

  1.      [,1] [,2] [,3] [,4]
  2. [1,]   11   15    3    7
  3. [2,]   12   16    4    8
  4. [3,]    9   13    1    5
  5. [4,]   10   14    2    6

到目前为止，我通过创建一个包含按正确顺序的索引的数字的矩阵，并对其进行重新排列来实现这一点，但是对于每个补丁在新的空矩阵中重新分配在存在数万个补丁时会变得非常耗时。

英文:

I am trying to randomly rearrange patches in a matrix. This will need to be done for larger matrices and small patches, so a for loop does not seem to be an option to achieve this. Let's say I have a data matrix like this:

data &lt;- matrix(1:16, nrow = 4)

The output looks like

  1.      [,1] [,2] [,3] [,4]
  2. [1,]    1    5    9   13
  3. [2,]    2    6   10   14
  4. [3,]    3    7   11   15
  5. [4,]    4    8   12   16

I now want to select 2x2 patches and rearrange them randomly, so that the output may look like this

  1.      [,1] [,2] [,3] [,4]
  2. [1,]   11   15    3    7
  3. [2,]   12   16    4    8
  4. [3,]    9   13    1    5
  5. [4,]   10   14    2    6

I achieved this so far by creating a matrix containing numbers corresponding to the index in correct order, and rearranged, but the reassignment to a new, empty matrix in a for loop for each patch gets quite time consuming when there are tens of thousands of patches.

答案1

得分: 4

以下是翻译好的代码部分：

  1. 这是一种你可以使用的方法。我假设子矩阵块可以均匀地划分成矩阵。
  3. data <- matrix(1:16, nrow = 4)
  5. # 矩阵维度
  6. nr <- nrow(data)
  7. nc <- ncol(data)
  9. # 块的宽度和高度
  10. width <- 2L
  11. height <- 2L
  13. # 矩阵维度与块维度的比率
  14. rr <- nr / height
  15. cr <- nc / width
  17. m <- matrix(1L, height, width)
  19. # 创建块索引
  20. (blocks <- matrix(seq(rr * cr), rr, cr) %x% m)
  22.      [,1] [,2] [,3] [,4]
  23. [1,]    1    1    3    3
  24. [2,]    1    1    3    3
  25. [3,]    2    2    4    4
  26. [4,]    2    2    4    4
  28. # 创建随机块索引
  29. set.seed(5)
  30. (r_blocks <- matrix(sample(rr * cr), rr, cr) %x% m)
  32.      [,1] [,2] [,3] [,4]
  33. [1,]    2    2    1    1
  34. [2,]    2    2    1    1
  35. [3,]    3    3    4    4
  36. [4,]    3    3    4    4
  38. # 通过匹配随机块位置与原始位置来创建新矩阵
  39. # 并索引到原始矩阵
  41. matrix(data[ave(r_blocks, r_blocks, FUN = \(v) which(blocks == v[1]))], dim(data))
  43.      [,1] [,2] [,3] [,4]
  44. [1,]    3    7    1    5
  45. [2,]    4    8    2    6
  46. [3,]    9   13   11   15
  47. [4,]   10   14   12   16
英文:

Here is one approach you might use. I'm assuming that the submatrix blocks divide evenly into the matrix.

  1. data &lt;- matrix(1:16, nrow = 4)
  3. # Matrix dimensions
  4. nr &lt;- nrow(data)
  5. nc &lt;- ncol(data)
  7. # Block width and height
  8. width &lt;- 2L
  9. height &lt;- 2L
  11. # Matrix dimension by block dimension ratios
  12. rr &lt;- nr / height
  13. cr &lt;- nc / width
  15. m &lt;- matrix(1L, height, width)
  17. # Create block indices
  18. (blocks &lt;- matrix(seq(rr * cr), rr, cr) %x% m)
  20.      [,1] [,2] [,3] [,4]
  21. [1,]    1    1    3    3
  22. [2,]    1    1    3    3
  23. [3,]    2    2    4    4
  24. [4,]    2    2    4    4
  26. # Create random block indices
  27. set.seed(5)
  28. (r_blocks &lt;- matrix(sample(rr * cr), rr, cr) %x% m)
  30.      [,1] [,2] [,3] [,4]
  31. [1,]    2    2    1    1
  32. [2,]    2    2    1    1
  33. [3,]    3    3    4    4
  34. [4,]    3    3    4    4
  36. # Create new matrix by matching the random block positions against the original positions
  37. # and index against orginal matrix
  38.     
  39. matrix(data[ave(r_blocks, r_blocks, FUN = \(v) which(blocks == v[1]))], dim(data))
  41.      [,1] [,2] [,3] [,4]
  42. [1,]    3    7    1    5
  43. [2,]    4    8    2    6
  44. [3,]    9   13   11   15
  45. [4,]   10   14   12   16

答案2

得分: 3

以下是使用线性索引和嵌套的sequence调用的方法。它可以几乎立即重新排列一个700x700的矩阵。

  1. set.seed(211972494)
  3. rearrange <- function(x, n = 2L) {
  4.   d <- dim(x)
  5.   n2 <- n^2
  6.   x[i[,sample(length(x)/n2)]] <- x[
  7.     i <- matrix(
  8.       sequence(
  9.         rep(n, length(x)/n),
  10.         sequence(
  11.           rep(n, length(x)/n2),
  12.           sequence(
  13.             rep(d[1]/n, d[2]/n),
  14.             seq(1, length(x), n*d[1]),
  15.             n
  16.           ), d[1]
  17.         )
  18.       ), n2
  19.     )
  20.   ]
  21.   x
  22. }

测试：

  1. rearrange(matrix(1:16, 4))
  2. #>      [,1] [,2] [,3] [,4]
  3. #> [1,]   11   15    3    7
  4. #> [2,]   12   16    4    8
  5. #> [3,]    1    5    9   13
  6. #> [4,]    2    6   10   14
  8. rearrange(matrix(1:54, 6), 3L)
  9. #>      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
  10. #> [1,]    4   10   16    1    7   13   19   25   31
  11. #> [2,]    5   11   17    2    8   14   20   26   32
  12. #> [3,]    6   12   18    3    9   15   21   27   33
  13. #> [4,]   22   28   34   37   43   49   40   46   52
  14. #> [5,]   23   29   35   38   44   50   41   47   53
  15. #> [6,]   24   30   36   39   45   51   42   48   54

计时较大的矩阵：

  1. system.time(rearrange(matrix(1:700^2, 700)))
  2. #>    user  system elapsed 
  3. #>    0.02    0.00    0.02
  5. system.time(rearrange(matrix(1:700^2, 700), 7L))
  6. #>    user  system elapsed 
  7. #>       0       0       0

另一个选项使用kronecker。这个方法可能稍微慢一些，但逻辑可能更容易理解。

  1. rearrange2 <- function(x, n = 2L) {
  2.   x[i[,sample(length(x)/n^2)]] <- x[
  3.     i <- matrix(
  4.       order(kronecker(array(seq_along(x), dim(x)/n), matrix(1L, n, n))),
  5.       n^2
  6.     )
  7.   ]
  8.   x
  9. }
  11. x <- matrix(1:700^2, 700)
  12. s <- rep(1:200, each = 2)
  13. i <- 0L
  15. microbenchmark::microbenchmark(
  16.   rearrange = rearrange(x),
  17.   rearrange2 = rearrange2(x),
  18.   check = "equal",
  19.   setup = set.seed(s[i <- i + 1L])
  20. )
  21. #> Unit: milliseconds
  22. #>        expr     min       lq     mean   median       uq     max neval
  23. #>   rearrange 12.4906 12.88795 14.03972 13.13315 13.81755 20.0663   100
  24. #>  rearrange2 33.5341 33.93110 36.86671 34.79870 38.44955 74.1596   100
英文:

Here is an approach using linear indexing with nested sequence calls. It can rearrange a 700x700 matrix almost instantly.

  1. set.seed(211972494)
  3. rearrange &lt;- function(x, n = 2L) {
  4.   d &lt;- dim(x)
  5.   n2 &lt;- n^2
  6.   x[i[,sample(length(x)/n2)]] &lt;- x[
  7.     i &lt;- matrix(
  8.       sequence(
  9.         rep(n, length(x)/n),
  10.         sequence(
  11.           rep(n, length(x)/n2),
  12.           sequence(
  13.             rep(d[1]/n, d[2]/n),
  14.             seq(1, length(x), n*d[1]),
  15.             n
  16.           ), d[1]
  17.         )
  18.       ), n2
  19.     )
  20.   ]
  21.   x
  22. }

Testing:

  1. rearrange(matrix(1:16, 4))
  2. #&gt;      [,1] [,2] [,3] [,4]
  3. #&gt; [1,]   11   15    3    7
  4. #&gt; [2,]   12   16    4    8
  5. #&gt; [3,]    1    5    9   13
  6. #&gt; [4,]    2    6   10   14
  8. rearrange(matrix(1:54, 6), 3L)
  9. #&gt;      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
  10. #&gt; [1,]    4   10   16    1    7   13   19   25   31
  11. #&gt; [2,]    5   11   17    2    8   14   20   26   32
  12. #&gt; [3,]    6   12   18    3    9   15   21   27   33
  13. #&gt; [4,]   22   28   34   37   43   49   40   46   52
  14. #&gt; [5,]   23   29   35   38   44   50   41   47   53
  15. #&gt; [6,]   24   30   36   39   45   51   42   48   54

Timing a larger matrix

  1. system.time(rearrange(matrix(1:700^2, 700)))
  2. #&gt;    user  system elapsed 
  3. #&gt;    0.02    0.00    0.02
  5. system.time(rearrange(matrix(1:700^2, 700), 7L))
  6. #&gt;    user  system elapsed 
  7. #&gt;       0       0       0

Another option using kronecker. It's a little slower, but the logic may be easier to follow.

  1. rearrange2 &lt;- function(x, n = 2L) {
  2.   x[i[,sample(length(x)/n^2)]] &lt;- x[
  3.     i &lt;- matrix(
  4.       order(kronecker(array(seq_along(x), dim(x)/n), matrix(1L, n, n))),
  5.       n^2
  6.     )
  7.   ]
  8.   x
  9. }
  11. x &lt;- matrix(1:700^2, 700)
  12. s &lt;- rep(1:200, each = 2)
  13. i &lt;- 0L
  15. microbenchmark::microbenchmark(
  16.   rearrange = rearrange(x),
  17.   rearrange2 = rearrange2(x),
  18.   check = &quot;equal&quot;,
  19.   setup = set.seed(s[i &lt;- i + 1L])
  20. )
  22. #&gt; Unit: milliseconds
  23. #&gt;        expr     min       lq     mean   median       uq     max neval
  24. #&gt;   rearrange 12.4906 12.88795 14.03972 13.13315 13.81755 20.0663   100
  25. #&gt;  rearrange2 33.5341 33.93110 36.86671 34.79870 38.44955 74.1596   100

答案3

得分: 1

以下是您提供的代码的翻译：

  1. # 补丁维度
  2. d1 <- 2
  3. d2 <- 2
  5. # 块矩阵的掩码
  6. msk <- kronecker(
  7.     matrix(seq.int(length(data) / (d1 * d2)), nrow(data) / d1),
  8.     matrix(1, d1, d2)
  9. )
  11. # 洗牌补丁
  12. l <- sample(unname(tapply(data, msk, \(x) matrix(x, d1))))
  14. # 重建矩阵
  15. do.call(
  16.     cbind,
  17.     tapply(
  18.         l,
  19.         ceiling(seq_along(l) / (nrow(data) / d1)),
  20.         \(x) do.call(rbind, x)
  21.     )
  22. )

它可以产生以下结果：

  1.      [,1] [,2] [,3] [,4]
  2. [1,]    9   13    3    7
  3. [2,]   10   14    4    8
  4. [3,]   11   15    1    5
  5. [4,]   12   16    2    6
英文:

You can try the code below

  1. # patch dimensions
  2. d1 &lt;- 2
  3. d2 &lt;- 2
  5. # mask for block matrices
  6. msk &lt;- kronecker(
  7.     matrix(seq.int(length(data) / (d1 * d2)), nrow(data) / d1),
  8.     matrix(1, d1, d2)
  9. )
  11. # shuffle patches
  12. l &lt;- sample(unname(tapply(data, msk, \(x) matrix(x, d1))))
  14. # reconstruct the matrix
  15. do.call(
  16.     cbind,
  17.     tapply(
  18.         l,
  19.         ceiling(seq_along(l) / (nrow(data) / d1)),
  20.         \(x) do.call(rbind, x)
  21.     )
  22. )

and it could produce

  1.      [,1] [,2] [,3] [,4]
  2. [1,]    9   13    3    7
  3. [2,]   10   14    4    8
  4. [3,]   11   15    1    5
  5. [4,]   12   16    2    6

huangapple
  • 本文由 发表于 2023年6月1日 10:15:34
  • 转载请务必保留本文链接：https://go.coder-hub.com/76378276.html
  • matrix
  • r
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定