在多个条件下快速分类R中类别数据的快速方法

Question

I have a large dataset in R (say >40,000 rows and >20 categorical columns) that I repeatedly subset, so I would like to speed this up as much as possible. It needs to be a general function (each categorical column has a discrete number of possible values, say in string format).

Each time I subset, I need to identify the subset of rows that satisfy multiple logical set membership conditions (eg >10 conditions). Ie, I need to check several columns and check if values in that column match a certain set membership (hence the use of %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))

I've looked around the internet and SO a lot, but haven't found the discussion of performance I'm looking for. I mostly code using dplyr , so apologies if there's a clear performance improvement here in data.table ; I've tried some simple benchmarks between the two (but without using any data.table indexing or etc.) and it's not obvious if one is faster.

Example options I've considered (since I'm not great at data.table , I've excluded data.table options from here):

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)
}

Note: In practice, on my real datasets, dplyr_filter2 actually works fastest. I've also tried dtplyr or converting my data to a data.table , but this seems slower than without.
Note: On the other hand, in practice, the base R function outperforms the dplyr examples when data has fewer rows and fewer columns (perhaps due to copying speed?).

Thus, I'd like to ask SO what the general, most efficient way(s) to subset a categorical dataframe under multiple (set membership) conditions is. And if possible, explain the mechanics for why? Does this answer differ for smaller datasets? Does it depend on copying time or search time?

Useful related links

• fast lookup for one key

• using hash tables in R for key-value pairs

Answer 1

Understand that you prefer not to use data.table. Just providing some timings for reference below. With indexing, subsetting can be performed much faster and inner join of the 2 tables can also be done easily in data.table .

# 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

In addition to chinsoon12's alternatives, one thing to consider is to avoid subsetting the data.frame in each iteration. So, instead of

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

one alternative is to accumulate a logical vector of whether to include each row in the final subset:

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, ])
}

or, another alternative, is to iteratively reduce the amount of comparisons, but by reducing the row indices instead of the data.frame itself:

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, ])
}

And a comparison with data:

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