Question

我在R中有一个大型数据集（比如＆gt; 40,000行和> 20个分类列），我重复进行了子集，所以我想尽可能加快速度。它需要是一个通用函数（每个分类列都有一些离散数量的可能值，比如字符串格式）。

每次I子集时，我需要识别满足多个逻辑集成员条件的行子集（例如，> 10个条件）。即，我需要检查多个列并检查该列中的值是否与某个集合成员资格匹配（因此使用%in%）。

# simple dataset example
library(dplyr)
num_col <- 15
num_row <- 100000
dat_list <- list()
for (i in 1:num_col) {
  dat_list[[i]] <- data_frame(sample(letters[1:10], size = num_row, r = T))
}
dat <- bind_cols(dat_list)
names(dat) <- paste0("col", seq(15))

我已经浏览过互联网了很多，但还没有找到我正在寻找的性能讨论。我主要使用dplyr进行编码，如果data.table中有明显的性能改进，请致歉。我在两者之间尝试了一些简单的基准测试（但没有使用任何data.table索引等等）并且如果一个更快则不明显。

我考虑的示例选项（因为我在data.table不是很好，我从这里排除了data.table选项）：

base_filter <- function(dat) {
  for (i in 1:7) {
    col_name <- paste0('col', i)
    dat <- dat[dat[[col_name]] %in% sample(letters[1:10], size = 4), ]
  }
  dat
}
dplyr_filter1 <- function(dat) {
  for (i in 1:7) {
    col_name <- paste0('col', i)
    dat <- filter_(dat,
                   .dots = interp(~ colname %in% vals,
                          colname = as.name(col_name),
                          vals = sample(letters[1:10], size = 4)))
  }
  dat
}
dplyr_filter2 <- function(dat) {
  dots_filter <- list()
  for (i in 1:7) {
    col_name <- paste0('col', i)
    dots_filter[[i]] <- interp(~ colname %in% vals,
                               colname = as.name(col_name),
                               vals = sample(letters[1:10], size = 4))
  }
  filter_(dat, .dots = dots_filter)
}

注意：实际上，在我的真实数据集中，dplyr_filter2实际上最快。我还尝试了dtplyr或将我的数据转换为data.table，但这似乎比没有更慢。
注意：另一方面，实际上，当数据行数较少且列数较少时，基本R函数优于dplyr示例（可能是由于复制速度？）。

因此，我想问一下，在多个（集合成员资格）条件下对分类数据框进行子集化的一般，最有效的方法是什么。如果可能的话，解释原因的机制？这个答案对于较小的数据集有何不同？它取决于复制时间或搜索时间吗？

有用的相关链接

Answer 1

了解您不想使用data.table。只是提供一些时间供以下参考。通过索引，可以更快地执行子集化，并且可以在data.table中轻松完成2个表的内部联接。

# simple dataset example
library(dplyr)
library(lazyeval)
set.seed(0L)
num_col <- 15
num_row <- 100000
dat_list <- list()
for (i in 1:num_col) {
    dat_list[[i]] <- data_frame(sample(letters[1:10], size = num_row, r = T))
}
dat <- bind_cols(dat_list)
names(dat) <- paste0("col", seq(15))

selection <- lapply(1:7, function(n) sample(letters[1:10], size = 4))

base_filter <- function(df) {
    for (i in 1:7) {
        col_name <- paste0('col', i)
        df <- df[df[[col_name]] %in% selection[[i]], ]
    }
    df
}

dplyr_filter1 <- function(df) {
    for (i in 1:7) {
        col_name <- paste0('col', i)
        df <- filter_(df,
            .dots = interp(~ colname %in% vals,
                colname = as.name(col_name),
                vals = selection[[i]]))
    }
    df
}

dplyr_filter2 <- function(df) {
    dots_filter <- list()
    for (i in 1:7) {
        col_name <- paste0('col', i)
        dots_filter[[i]] <- interp(~ colname %in% vals,
            colname = as.name(col_name),
            vals = selection[[i]])
    }
    filter_(df, .dots = dots_filter)
}


library(data.table)

#convert data.frame into data.table
dt <- data.table(dat, key=names(dat)[1:7])

#create the sets of selection
dtSelection <- data.table(expand.grid(selection, stringsAsFactors=FALSE))


library(microbenchmark)
microbenchmark(
    base_filter(dat),
    dplyr_filter1(dat),
    dplyr_filter2(dat),
    dt[dtSelection, nomatch=0],   #perform inner join between dataset and selection
    times=5L)

#Unit: milliseconds
#                         expr       min        lq      mean    median        uq       max neval
#             base_filter(dat) 27.084801 27.870702 35.849261 32.045900 32.872601 59.372301     5
#           dplyr_filter1(dat) 23.130100 24.114301 26.922081 24.860701 29.804301 32.701002     5
#           dplyr_filter2(dat) 29.641101 30.686002 32.363681 31.103000 31.884701 38.503601     5
# dt[dtSelection, nomatch = 0]  3.626001  3.646201  3.829341  3.686601  3.687001  4.500901     5

Answer 2

除了chinsoon12的替代品之外，要考虑的一件事是避免在每次迭代中对data.frame进行子集化。所以，而不是

f0 = function(x, cond)
{
    for(j in seq_along(x)) x = x[x[[j]] %in% cond[[j]], ]
    return(x)
}

一种替代方法是累积是否在最终子集中包含每一行的逻辑向量：

f1 = function(x, cond)
{
    i = rep_len(TRUE, nrow(x))
    for(j in seq_along(x)) i = i & (x[[j]] %in% cond[[j]])
    return(x[i, ])
}

或另一种方法是迭代减少比较量，但是通过减少行索引而不是data.frame本身：

f2 = function(x, cond)
{
    i = 1:nrow(x)
    for(j in seq_along(x)) i = i[x[[j]][i] %in% cond[[j]]]
    return(x[i, ])
}

与数据进行比较：

set.seed(1821)
dat = as.data.frame(replicate(30, sample(c(letters, LETTERS), 5e5, TRUE), FALSE), 
                    stringsAsFactors = FALSE)
conds = replicate(ncol(dat), sample(c(letters, LETTERS), 48), FALSE)

system.time({ ans0 = f0(dat, conds) })
#   user  system elapsed 
#   3.44    0.28    3.86 
system.time({ ans1 = f1(dat, conds) })
#   user  system elapsed 
#   0.66    0.01    0.68 
system.time({ ans2 = f2(dat, conds) })
#   user  system elapsed 
#   0.34    0.01    0.39

identical(ans0, ans1)
#[1] TRUE
identical(ans1, ans2)
#[1] TRUE

使用多个条件对R中的分类数据进行子集化的快速方法

2 个答案: