R join on like/grep condition

Question

Sto cercando un modo efficiente per unire 2 data.frames/data.tables sulla colonna di caratteri usando la condizione grep/like/stri_detect.

Sono in grado di utilizzare il pacchetto sqldf con join su like, ma è piuttosto lento. Sui miei 2 dati.tables (5k righe, 20k righe) ci vogliono circa 60 secondi.

Il mio secondo approccio era usare CJ da data.table e dopo che stri_detect_fixed su 2 colonne. Questo approccio è più veloce (16 secondi), ma temo che con i dati in crescita sarà impossibile da usare (aumenta in modo significativo l'utilizzo di ram).

Ho anche provato a farlo in ciclo for, ma era il più lento.

C'è un modo per farlo più veloce in particolare in data.table?

Di seguito incollo il mio esempio:

library(stringi) 
library(data.table) 
library(sqldf) 
data1 <- data.table(col1 = paste0(c("asdasd asdasd 768jjhknmnmnj", 
"78967ggh","kl00896754","kl008jku"),1:10000)) 

data2 <- data.table(col2 = paste0(c("mnj", "12345","kl008","lll1"), 1:10000)) 

system.time(join1 <- data.table(sqldf("select * 
      from data1 a inner join data2 b 
         on a.col1 like '%' || b.col2 || '%'", drv = "SQLite"))) 



system.time(kartezjan <- CJ(col1 = data1[,c("col1"), with = F][[1]], 
          col2 = data2[,c("col2"), with = F][[1]], 
unique = TRUE)[stri_detect_fixed(col1, col2, case_insensitive = FALSE)]) 

Answer 1

L'approccio sqldf è il più veloce sulla mia macchina per i vostri dati di esempio, ma qui è una versione più veloce data.table in caso aiuta.

library(data.table) 
library(sqldf) 

## Example data 
v1 <- paste0(c("asdasd asdasd 768jjhknmnmnj", "78967ggh","kl00896754","kl008jku"), 
    1:10000) 
v2 <- paste0(c("mnj", "12345","kl008","lll1"), 1:10000) 

data1 <- data.table(col1=v1, key="col1") 
data2 <- data.table(col2=v2, key="col2") 


## sqldf version 
system.time(
    ans1 <- data.table(sqldf(
    "select * 
    from data1 a inner join data2 b 
    on instr(a.col1, b.col2)", drv="SQLite")) 
) 

## user system elapsed 
## 17.579 0.036 17.654 


## parallelized data.table version 
suppressMessages(library(foreach)); suppressMessages(library(doParallel)) 
cores <- detectCores() ## I've got 4... 
clust <- makeForkCluster(cores) 
registerDoParallel(clust) 

system.time({ 
    batches <- cores 
    data2[, group:=sort(rep_len(1:batches, nrow(data2)))] 
    ans2 <- foreach(
    i=1:batches, .combine=function(...) rbindlist(list(...)), 
    .multicombine=TRUE, .inorder=FALSE) %dopar% { 
     CJ(col1=data1[, col1], col2=data2[group==i, col2])[, 
     alike:=col1 %like% col2, by=col2][ 
      alike==TRUE][, alike:=NULL][]   
    } 
}) 

## user system elapsed 
## 0.185 0.229 30.295 

stopCluster(clust) 
stopImplicitCluster() 

Sto eseguendo su OSX - potrebbe essere necessario modificare il codice di parallelizzazione per altri sistemi operativi. Inoltre, se i tuoi dati effettivi sono più grandi e la memoria è esaurita, puoi provare i valori più grandi batches.