为什么 apply() 方法比 R 中的 for 循环慢？

Question

作为最佳实践，我正在尝试确定是创建一个函数并在矩阵中apply() 它是否更好，或者是否最好在函数中简单地循环一个矩阵。我尝试了两种方式，并惊讶地发现apply() 速度较慢。任务是获取一个向量并将其评估为正数或负数，然后如果它是正数则返回一个向量，如果它是负数则返回 -1。 mash() 函数循环，squish() 函数被传递给apply() 函数。

million  <- as.matrix(rnorm(100000))

mash <- function(x){
  for(i in 1:NROW(x))
    if(x[i] > 0) {
      x[i] <- 1
    } else {
      x[i] <- -1
    }
    return(x)
}

squish <- function(x){
  if(x >0) {
    return(1)
  } else {
    return(-1)
  }
}


ptm <- proc.time()
loop_million <- mash(million)
proc.time() - ptm


ptm <- proc.time()
apply_million <- apply(million,1, squish)
proc.time() - ptm

loop_million 结果：

user  system elapsed 
0.468   0.008   0.483 

apply_million 结果：

user  system elapsed 
1.401   0.021   1.423 

如果性能下降，使用apply() 比for 循环有什么优势？我的测试有问题吗？我比较了两个结果对象以寻找线索，发现：

> class(apply_million)
[1] "numeric"
> class(loop_million)
[1] "matrix"

这只会加深谜团。 apply() 函数不能接受简单的数字向量，这就是为什么我在开始时使用 as.matrix() 进行转换。但随后它返回一个数字。 for 循环适用于简单的数字向量。它返回一个与传递给它的对象具有相同类的对象。

Answer 1

apply（和 plyr）系列函数的重点不是速度，而是表现力。它们还倾向于防止错误，因为它们消除了循环所需的簿记代码。

最近，有关 stackoverflow 的答案过分强调速度。随着计算机变得越来越快，并且 R-core 优化了 R 的内部结构，您的代码将自行变得越来越快。您的代码将永远不会变得更优雅或更容易理解。

在这种情况下，您可以两全其美：使用矢量化的优雅答案也非常快，(million > 0) * 2 - 1。

Answer 2

正如蔡斯所说：利用矢量化的力量。您在这里比较了两个不好的解决方案。

澄清为什么您的应用解决方案较慢：

在 for 循环中，您实际上使用了矩阵的向量化索引，这意味着没有进行类型转换。我在这里有点粗略，但基本上内部计算忽略了尺寸。它们只是作为属性保存并与表示矩阵的向量一起返回。举例说明：

> x <- 1:10
> attr(x,"dim") <- c(5,2)
> y <- matrix(1:10,ncol=2)
> all.equal(x,y)
[1] TRUE

现在，当您使用 apply 时，矩阵在内部被拆分为 100,000 个行向量，每个行向量（即一个数字）都通过函数传递，最后将结果组合成适当的形式。 apply 函数认为向量在这种情况下是最好的，因此必须连接所有行的结果。这需要时间。

此外，sapply 函数首先使用as.vector(unlist(...)) 将任何内容转换为向量，最后尝试将答案简化为合适的形式。这也需要时间，因此这里的 sapply 可能会更慢。然而，它不在我的机器上。

如果 apply 在这里是一个解决方案（但不是），你可以比较一下：

> system.time(loop_million <- mash(million))
   user  system elapsed 
   0.75    0.00    0.75    
> system.time(sapply_million <- matrix(unlist(sapply(million,squish,simplify=F))))
   user  system elapsed 
   0.25    0.00    0.25 
> system.time(sapply2_million <- matrix(sapply(million,squish)))
   user  system elapsed 
   0.34    0.00    0.34 
> all.equal(loop_million,sapply_million)
[1] TRUE
> all.equal(loop_million,sapply2_million)
[1] TRUE

Answer 3

如果需要，您可以在向量上使用 lapply 或 sapply。但是，为什么不使用适当的工具来完成这项工作，在这种情况下是ifelse()？

> ptm <- proc.time()
> ifelse_million <- ifelse(million > 0,1,-1)
> proc.time() - ptm
   user  system elapsed 
  0.077   0.007   0.093 

> all.equal(ifelse_million, loop_million)
[1] TRUE

为了比较起见，这里是使用 for 循环和 sapply 的两个可比较的运行：

> ptm <- proc.time()
> apply_million <- sapply(million, squish)
> proc.time() - ptm
   user  system elapsed 
  0.469   0.004   0.474 
> ptm <- proc.time()
> loop_million <- mash(million)
> proc.time() - ptm
   user  system elapsed 
  0.408   0.001   0.417 

Answer 4

在这种情况下，进行基于索引的替换比ifelse()、*apply() 系列或循环要快得多：

> million  <- million2 <- as.matrix(rnorm(100000))
> system.time(million3 <- ifelse(million > 0, 1, -1))
   user  system elapsed 
  0.046   0.000   0.044 
> system.time({million2[(want <- million2 > 0)] <- 1; million2[!want] <- -1}) 
   user  system elapsed 
  0.006   0.000   0.007 
> all.equal(million2, million3)
[1] TRUE

让所有这些工具触手可及是非常值得的。您可以使用对您最有意义的一种（因为您需要在数月或数年后理解代码），然后如果计算时间变得过高，则开始转向更优化的解决方案。

Answer 5

for 循环速度优势的更好示例。

for_loop <- function(x){
    out <- vector(mode="numeric",length=NROW(x))
    for(i in seq(length(out)))
        out[i] <- max(x[i,])
    return(out)
    }

apply_loop <- function(x){
    apply(x,1,max)
}

million  <- matrix(rnorm(1000000),ncol=10)
> system.time(apply_loop(million))
  user  system elapsed 
  0.57    0.00    0.56 
> system.time(for_loop(million))
  user  system elapsed 
  0.32    0.00    0.33 

编辑

Eduardo 建议的版本。

max_col <- function(x){
    x[cbind(seq(NROW(x)),max.col(x))]
}

按行

> system.time(for_loop(million))
   user  system elapsed 
   0.99    0.00    1.11 
> system.time(apply_loop(million))
  user  system elapsed 
   1.40    0.00    1.44 
> system.time(max_col(million))
  user  system elapsed 
  0.06    0.00    0.06 

按列

> system.time(for_loop(t(million)))
  user  system elapsed 
  0.05    0.00    0.05 
> system.time(apply_loop(t(million)))
  user  system elapsed 
  0.07    0.00    0.07 
> system.time(max_col(t(million)))
  user  system elapsed 
  0.04    0.00    0.06