为什么从 data.table 中选择列会产生副本？

看来从 data.table 中选择列[.data.table结果产生基础向量的副本。我说的是非常简单的列选择，按名称，没有要计算的表达式j并且没有要子集的行i。更奇怪的是，data.frame 中的列子集似乎没有创建任何副本。我正在使用 data.table 版本 data.table 1.10.4。下面提供了一个包含详细信息和基准的简单示例。我的问题是：

• 难道我做错了什么？
• 这是一个错误还是这是预期的行为？
• 如果这是有意的，那么按列对 data.table 进行子集化并避免额外复制的最佳方法是什么？

预期的用例涉及大型数据集，因此必须避免额外的副本（特别是因为基础 R 似乎已经支持这一点）。

library(data.table)
set.seed(12345)
cpp_dt <- data.table(a = runif(1e6), b = rnorm(1e6), c = runif(1e6))
cols=c("a","c")

## naive / data.frame style of column selection
## leads to a copy of the column vectors in cols
subset_cols_1=function(dt,cols){
  return(dt[,cols,with=F])
}

## alternative syntax, still results in a copy
subset_cols_2=function(dt,cols){
  return(dt[,..cols])
}

## work-around that uses data.frame column selection,
## appears to avoid the copy
subset_cols_3=function(dt,cols){
  setDF(dt)
  subset=dt[,cols]
  setDT(subset)
  setDT(dt)
  return(subset)
}

## another approach that makes a "shallow" copy of the data.table
## then NULLs the not needed columns by reference
## appears to also avoid the copy
subset_cols_4=function(dt,cols){
  subset=dt[TRUE]
  other_cols=setdiff(names(subset),cols)
  set(subset,j=other_cols,value=NULL)
  return(subset)
}

subset_1=subset_cols_1(cpp_dt,cols)
subset_2=subset_cols_2(cpp_dt,cols)
subset_3=subset_cols_3(cpp_dt,cols)
subset_4=subset_cols_4(cpp_dt,cols)

现在让我们看看内存分配并与原始数据进行比较。

.Internal(inspect(cpp_dt)) # original data, keep an eye on 1st and 3d vector
# @7fe8ba278800 19 VECSXP g1c7 [OBJ,MARK,NAM(2),ATT] (len=3, tl=1027)
#   @10e2ce000 14 REALSXP g1c7 [MARK,NAM(2)] (len=1000000, tl=0) 0.720904,0.875773,0.760982,0.886125,0.456481,...
#   @10f1a3000 14 REALSXP g1c7 [MARK,NAM(2)] (len=1000000, tl=0) -0.947317,-0.636669,0.167872,-0.206986,0.411445,...
#   @10f945000 14 REALSXP g1c7 [MARK,NAM(2)] (len=1000000, tl=0) 0.717611,0.95416,0.191546,0.48525,0.539878,...
# ATTRIB: [removed]

Using [.data.table对列进行子集化的方法：

.Internal(inspect(subset_1)) # looks like data.table is making a copy
# @7fe8b9f3b800 19 VECSXP g0c7 [OBJ,NAM(1),ATT] (len=2, tl=1026)
#   @114cb0000 14 REALSXP g0c7 [MARK,NAM(2)] (len=1000000, tl=0) 0.720904,0.875773,0.760982,0.886125,0.456481,...
#   @1121ca000 14 REALSXP g0c7 [NAM(2)] (len=1000000, tl=0) 0.717611,0.95416,0.191546,0.48525,0.539878,...
# ATTRIB: [removed]

仍在使用的另一个语法版本[.data.table并仍在制作副本：

.Internal(inspect(subset_2)) # same, still copy
# @7fe8b6402600 19 VECSXP g0c7 [OBJ,NAM(1),ATT] (len=2, tl=1026)
#   @115452000 14 REALSXP g0c7 [NAM(2)] (len=1000000, tl=0) 0.720904,0.875773,0.760982,0.886125,0.456481,...
#   @1100e7000 14 REALSXP g0c7 [NAM(2)] (len=1000000, tl=0) 0.717611,0.95416,0.191546,0.48525,0.539878,...
# ATTRIB: [removed]

使用一系列setDF， 其次是[.data.frame and setDT。看，向量a and c不再复制！看来基本 R 方法更高效/内存占用更小？

.Internal(inspect(subset_3)) # "[.data.frame" is not making a copy!!
# @7fe8b633f400 19 VECSXP g0c7 [OBJ,NAM(2),ATT] (len=2, tl=1026)
#   @10e2ce000 14 REALSXP g1c7 [MARK,NAM(2)] (len=1000000, tl=0) 0.720904,0.875773,0.760982,0.886125,0.456481,...
#   @10f945000 14 REALSXP g1c7 [MARK,NAM(2)] (len=1000000, tl=0) 0.717611,0.95416,0.191546,0.48525,0.539878,...
# ATTRIB: [removed]

另一种方法是对 data.table 进行浅表复制，然后通过在新 data.table 中引用将所有额外列设为 NULL。同样，没有复制。

.Internal(inspect(subset_4)) # 4th approach seems to also avoid the copy
# @7fe8b924d800 19 VECSXP g0c7 [OBJ,NAM(2),ATT] (len=2, tl=1027)
#   @10e2ce000 14 REALSXP g1c7 [MARK,NAM(2)] (len=1000000, tl=0) 0.720904,0.875773,0.760982,0.886125,0.456481,...
#   @10f945000 14 REALSXP g1c7 [MARK,NAM(2)] (len=1000000, tl=0) 0.717611,0.95416,0.191546,0.48525,0.539878,...
# ATTRIB: [removed]

现在让我们看看这四种方法的基准。它看起来像“[.data.frame”(subset_cols_3）是明显的赢家。

microbenchmark({subset_cols_1(cpp_dt,cols)},
               {subset_cols_2(cpp_dt,cols)},
               {subset_cols_3(cpp_dt,cols)},
               {subset_cols_4(cpp_dt,cols)},
               times=100)

# Unit: microseconds
#                                 expr      min        lq      mean   median        uq       max neval
#  {     subset_cols_1(cpp_dt, cols) } 4772.092 5128.7395 8956.7398 7149.447 10189.397 53117.358   100
#  {     subset_cols_2(cpp_dt, cols) } 4705.383 5107.1690 8977.1816 6680.666  9206.164 53523.191   100
#  {     subset_cols_3(cpp_dt, cols) }  148.659  177.9595  285.4926  250.620   283.414  4422.968   100
#  {     subset_cols_4(cpp_dt, cols) }  193.912  241.9010  531.8308  336.467   384.844 20061.864   100

我已经有一段时间没有思考这个问题了，但现在还是这样。

好问题。但是为什么你需要子集adata.table像那样？我们真的需要看看你在做什么next: 更大的图景。对于这个更大的图景，我们在 data.table 中可能有与基本 R 习惯用法不同的方式。

粗略地说明可能是一个不好的例子：

DT[region=="EU", lapply(.SD, sum), .SDcols=10:20]

而不是采用 R 语言的基本惯用法，即获取一个子集，然后执行下一步操作（此处，apply）在外面的结果上：

apply(DT[DT$region=="EU", 10:20], 2, sum)

总的来说，我们希望鼓励在一个空间内做尽可能多的事情[...]这样 data.table 就会看到i, j and by合而为一[...]操作并可以优化组合。当您对列进行子集化，然后在外部执行下一操作时，需要更多的软件复杂性来优化。在大多数情况下，大部分计算成本都在第一个[...]这减少到相对较小的尺寸。

话虽如此，除了弗兰克的评论之外shallow，我们也在等待，看看如何阿尔特雷普项目平移出来。这改进了基 R 中的引用计数，并且可能使:=可靠地知道正在操作的列是否需要首先进行写时复制。现在，:=总是通过引用更新，因此如果选择某些整个列没有进行深层复制，它会更新两个 data.table（出于这个原因，它是故意进行复制的）。如果:=里面没有使用[...] then [...]始终返回可以安全使用的新结果:=上，目前这是一个相当简单的规则。即使您所做的只是出于某种原因选择了几个整列。

我们确实需要看到更大的图景：您之后在列的子集上做了什么。明确这一点将有助于提高调查 ALTREP 或对此案例进行我们自己的参考计数的优先级。