「r<-函数」do.call 的妙用——参数更新

R 中的 do.call() 是我极少用到的一个函数，不过它在很多情况下是蛮有用的，之前我也做过简单的介绍。

它可以在实际调用函数时将参数以列表的形式传入，下面是一个简单的函数：

f <- function(x) print(x^2)

我们可以用下面的方式调用 do.call()：

do.call(f, list(x = 4))
#> [1] 16

大部分情况下这样的用法是啰嗦的，直接 f(4) 其实已经解决上面的问题了。

最近我需要批量更新参数时发现了 do.call() 的好用之处。

在批量建模时可能需要比较对建模函数设定不同的参数，我们以求和函数作为建模函数举例。

假设建模需要 4 个参数，造一个类似的求和函数：

Sum <- function(a = 1, b = 2, c = 3, d = 4) {
  return(sum(a, b, c, d))
}

而我们需要批量运行这个函数，而且只修改其中 3 个参数，另外参数是外部定义的，比如说其他使用这个函数的人。

有可能只使用 a, b, c：

Sum(a = 1, b = 3, c = 5)
#> [1] 13

也可能使用 b, c, d。

Sum(d = 1, b = 3, c = 5)
#> [1] 10

这并不能直接通过 for 循环、apply 之类的操作进行批量调用。我们来看看 do.call() 如何解决这个问题。

我们构建一个参数矩阵：

Args <- expand.grid(
  c(1, 2),
  c(3, 4, 5),
  c(6, 7, 8, 9)
)

Args
#>    Var1 Var2 Var3
#> 1     1    3    6
#> 2     2    3    6
#> 3     1    4    6
#> 4     2    4    6
#> 5     1    5    6
#> 6     2    5    6
#> 7     1    3    7
#> 8     2    3    7
#> 9     1    4    7
#> 10    2    4    7
#> 11    1    5    7
#> 12    2    5    7
#> 13    1    3    8
#> 14    2    3    8
#> 15    1    4    8
#> 16    2    4    8
#> 17    1    5    8
#> 18    2    5    8
#> 19    1    3    9
#> 20    2    3    9
#> 21    1    4    9
#> 22    2    4    9
#> 23    1    5    9
#> 24    2    5    9

假设现在是使用 a, b, c 3 个参数：

colnames(Args) <- c("a", "b", "c")
head(Args)
#>   a b c
#> 1 1 3 6
#> 2 2 3 6
#> 3 1 4 6
#> 4 2 4 6
#> 5 1 5 6
#> 6 2 5 6

创建批处理函数：

batchSum <- function(ArgsMat) {
  args <- list()
  for (i in 1:nrow(ArgsMat)) {
    args_update <- c(args, ArgsMat[i, , drop = FALSE])
    do.call(Sum, args = args_update)
  }
}

为了查看调用效果，我们修改下 Sum() 函数：

Sum <- function(a = 1, b = 2, c = 3, d = 4) {
  message("a:", a, " b:", b, " c:", c, " d:", d)
  return(sum(a, b, c, d))
}

调用参数矩阵试试：

batchSum(Args)
#> a:1 b:3 c:6 d:4
#> a:2 b:3 c:6 d:4
#> a:1 b:4 c:6 d:4
#> a:2 b:4 c:6 d:4
#> a:1 b:5 c:6 d:4
#> a:2 b:5 c:6 d:4
#> a:1 b:3 c:7 d:4
#> a:2 b:3 c:7 d:4
#> a:1 b:4 c:7 d:4
#> a:2 b:4 c:7 d:4
#> a:1 b:5 c:7 d:4
#> a:2 b:5 c:7 d:4
#> a:1 b:3 c:8 d:4
#> a:2 b:3 c:8 d:4
#> a:1 b:4 c:8 d:4
#> a:2 b:4 c:8 d:4
#> a:1 b:5 c:8 d:4
#> a:2 b:5 c:8 d:4
#> a:1 b:3 c:9 d:4
#> a:2 b:3 c:9 d:4
#> a:1 b:4 c:9 d:4
#> a:2 b:4 c:9 d:4
#> a:1 b:5 c:9 d:4
#> a:2 b:5 c:9 d:4

可以看出来整个过程中 d 是没有变的。我们再修改参数矩阵：

colnames(Args) <- c("a", "c", "d")

再次调用函数：

batchSum(Args)
#> a:1 b:2 c:3 d:6
#> a:2 b:2 c:3 d:6
#> a:1 b:2 c:4 d:6
#> a:2 b:2 c:4 d:6
#> a:1 b:2 c:5 d:6
#> a:2 b:2 c:5 d:6
#> a:1 b:2 c:3 d:7
#> a:2 b:2 c:3 d:7
#> a:1 b:2 c:4 d:7
#> a:2 b:2 c:4 d:7
#> a:1 b:2 c:5 d:7
#> a:2 b:2 c:5 d:7
#> a:1 b:2 c:3 d:8
#> a:2 b:2 c:3 d:8
#> a:1 b:2 c:4 d:8
#> a:2 b:2 c:4 d:8
#> a:1 b:2 c:5 d:8
#> a:2 b:2 c:5 d:8
#> a:1 b:2 c:3 d:9
#> a:2 b:2 c:3 d:9
#> a:1 b:2 c:4 d:9
#> a:2 b:2 c:4 d:9
#> a:1 b:2 c:5 d:9
#> a:2 b:2 c:5 d:9

此时 b 是没有变的。

以上我们通过 do.call() 实现了内部函数对外部输入的自动匹配。

该操作我把它实际用在了批量 Keras 模型的调用上：https://github.com/ShixiangWang/sigminer.prediction/blob/f64bcdf7bc8d5d819d48edc4344ed9af8b984738/R/batch_modeling_and_fitting.R#L37-L63，有兴趣的读者可以看一下。