如何在R中向量化2个循环

Question

我有两个矩阵：

matr1 = [k ; n]
matr2 = [n ; m]

和向量x 。 length(x) = k向量x包含值1 : m

n = 5
m = 3
k = m * n

matr1 <- matrix(sample(seq(0,1, by = 0.1), size = k * n, replace = T), nrow = k, ncol = n )
matr2 <- matrix(sample(seq(0,1, by = 0.1), size = m * n, replace = T), nrow = n, ncol = m)
x <- sample(1:m, size = k, replace = T)

我必须执行以下操作，已使用for循环解决了该操作。

for( i in 1:k){
  for( j in 1:n){
    matr1[i, 1:(n-j+1)] <- matr1[i, 1:(n-j+1)] + 
      matr1[i, 1:(n-j+1)] * matr2[j , x[i]]
  }
}

有某种方法可以向量化它吗？

还是可以使用某些技术来加快计算速度？

PS我考虑使用基本并行化，但是我想找到更多聪明的方法

Answer 1

花了我一段时间找出答案，但是：

foo <- apply(matr2,2,function(x) rev(cumprod(x+1)))
matr3 <- matr1*t(foo[,x])

-证明-

set.seed(100)
n = 5
m = 3
k = m * n

matr1 <- matrix(sample(seq(0,1, by = 0.1), size = k * n, replace = T), nrow = k, ncol = n )
matr2 <- matrix(sample(seq(0,1, by = 0.1), size = m * n, replace = T), nrow = n, ncol = m)
x <- sample(1:m, size = k, replace = T)

foo <- apply(matr2,2,function(x) rev(cumprod(x+1)))
matr3 <- matr1*t(foo[,x])

for( i in 1:k){
  for( j in 1:n){
    matr1[i, 1:(n-j+1)] <- matr1[i, 1:(n-j+1)] + 
      matr1[i, 1:(n-j+1)] * matr2[j , x[i]]
  }
}

all.equal(matr3,matr1)
# TRUE

-说明-

所以花了我一段时间才能正确地解决这个问题，但是这里...假设您的代码并假设i = 1 ，我们基本上可以为j=1编写：

matr1[1,1:5] <- matr1[1,1:5] + matr1[1,1:5] * matr2[1,3]

因此，您从第1行到第1列至第5列，并用原始数字加上这些数字乘以其他数字（在本例中为0.8 ）来更新这些数字。 然后，当j=2 ：

matr1[1,1:4] <- matr1[1,1:4] + matr1[1,1:4] * matr2[2,3]

因此，现在您只获取除n所有列，并以与步骤1相同的方式更新值。最后，应该清楚的模式是matr1[1,1]被更新n次，而matr[1,n]更新1次（仅使用matr2[1,3] 。

我们通过一次性计算所有步骤来利用这种模式。 我们这样做：

foo <- apply(matr2,2,function(x) rev(cumprod(x+1)))

这基本上是一个新表，其中对于matr1[i,]每一列都包含一个数字。 此数字是您之前的代码遇到的所有循环的一个组合。 因此，代替需要5个乘法的matr1[1,1] ，我们现在只需做1。

现在我们有了：

for (i in 1:k) for (j in 1:n) matr1[i,j] <- matr1[i,j] * foo[j,x[i]]

我们可以将其减少为：

for (i in 1:k) matr1[i,] <- matr1[i,] * foo[,x[i]]

因为每次索引时i总是从1:k ，所以我们也可以向量化它：

matr <- matr*t(foo[,x])

我们完成了。

-基准-

我重新运行了我作为证明提供的代码块，但是n=100和m=100 。

您的代码：

# user  system elapsed 
# 6.85    0.00    6.86 

我的代码：

# user  system elapsed 
# 0.02    0.00    0.02 

Answer 2

可以apply kn-grid代替双循环。

suppressOutput <- apply(expand.grid(1:k, 1:n), 1, function(y){
    matr1[y[1], 1:(n-y[2]+1)] <<- matr1[y[1], 1:(n-y[2]+1)] + matr1[y[1], 1:(n-y[2]+1)] * matr2[y[2] , x[y[1]]]
})

在我的机器上节省超过50％的计算时间。 虽然不是很漂亮。