R: subset data.table basato su una colonna intera

Question

Basta chiedersi se esiste un modo più semplice per impostare un sottoinsieme di data.table. Fondamentalmente ho un grande tavolo con righe milionarie e centinaia di colonne. Voglio suddividerle in base a un numero intero di/e avere un valore compreso tra un intervallo definito da me.

Mi chiedevo se il set della colonna pertinente come la chiave sarebbe la ricerca binaria, ma poi non sono sicuro se riesco a trovare le righe tra un intervallo di valori.

Esempio di esempio sotto.

> n = 1e7 
> dt <- data.table(a=rnorm(n),b=sample(letters,replace=T,n)) 
> system.time(subset(dt, a > 1 & a < 2)) 
    user system elapsed 
    1.596 0.000 1.596 
> system.time(dt[a %between% c(1,2)]) 
    user system elapsed 
    1.168 0.000 1.168 

può fare qualcosa del genere?

setkey(dt,a) 
dt[ ] : get me the rows between 1 and 2 values of the key 

Grazie! -Abhi

Answer 1

Io non sono un esperto di data.table, ma da quello che ho capito il motivo per cui un key ricerca setkey(dt, b) ; dt['a'] è così veloce è perché usa la ricerca binaria, invece di scansione di vettore. Ciò non è possibile per le colonne numeriche in cui la subsetting richiede operatori binari.

L'unica alternativa sarebbe quella di fare qualcosa di simile:

dt[,Between:=ifelse(a > 1 & a < 2, 'yes', 'no')] 
setkey(dt, Between) 
> system.time(dt['yes']) 
    user system elapsed 
    0.04 0.00 0.03 

Il che, curiosamente, è più veloce anche rispetto:

Index = dt[,a > 1 & a < 2] 
> system.time(dt[Index]) 
    user system elapsed 
    0.23 0.00 0.23 

Ma dal momento che si può solo salvare un sottoinsieme come dati separati. tavolo comunque, non vedo che abbia molta applicazione.

Answer 2

Fare un setkey qui sarebbe costoso (anche se si dovesse utilizzare l'ordine veloce in 1.8.11), perché deve spostare i dati (per riferimento) pure.

Tuttavia, è possibile aggirare questo caso utilizzando la funzione floor. In sostanza, se si desidera tutti i numeri in [1,2] (Nota: compresi 1 e 2 qui), quindi floor fornirà un valore di "1" per tutti questi valori. Cioè, si può fare:

system.time(t1 <- dt[floor(a) == 1]) 
# user system elapsed 
# 0.234 0.001 0.238 

Ciò equivale a fare dt[a >= 1 & a <=2] ed è due volte più veloce.

system.time(t2 <- dt[a >= 1 & a <= 2]) 
# user system elapsed 
# 0.518 0.081 0.601 

identical(t1,t2) # [1] TRUE 

Tuttavia, dal momento che non si vuole l'uguaglianza, è possibile utilizzare un hack per sottrarre la tolleranza = .Machine$double.eps^0.5 dalla colonna a. Se il valore è compreso nell'intervallo [1, 1+tolerance), significa che è ancora considerato 1. E se è solo di più, non è più 1 (internamente). Cioè, è il numero più piccolo> 1 che la macchina può identificare come non 1. Quindi, se sottrai 'a' per tolleranza tutti i numeri che sono internamente rappresentati come "1" diventeranno < 1 e floor(.) avranno come risultato 0. Quindi , avrai invece l'intervallo> 1 e < 2. Cioè,

dt[floor(a-.Machine$double.eps^0.5)==1] 

darà il risultato equivalente dt[a>1 & a<2].

---

Se hai di fare questo in modo ripetitivo, allora probabilmente la creazione di una nuova colonna con questa funzione floor e la chiave di impostazione su quella colonna integer potrebbe aiutare:

dt[, fa := as.integer(floor(a-.Machine$double.eps^0.5))] 
system.time(setkey(dt, fa)) # v1.8.11 
# user system elapsed 
# 0.852 0.158 1.043 

Ora, è possibile interrogare qualunque gamma si desidera utilizzare la ricerca binaria:

> system.time(dt[J(1L)]) # equivalent to > 1 & < 2 
# user system elapsed 
# 0.071 0.002 0.076 
> system.time(dt[J(1:4)]) # equivalent to > 1 & < 5 
# user system elapsed 
# 0.082 0.002 0.085 

Answer 3

Se fai impostare la chiave sul a (che richiede un po 'di tempo (14,7 secondi sulla mia macchina per n=1e7), , quindi è possibile utilizzare i join mobili per identificare l'inizio e la fine della regione di interesse.

# thus the following will work. 
dt[seq.int(dt[.(1),.I,roll=-1]$.I, dt[.(2), .I, roll=1]$.I)] 


n = 1e7 
dt <- data.table(a=rnorm(n),b=sample(letters,replace=T,n)) 
system.time(setkey(dt,a)) 
# This does take some time 
# user system elapsed 
# 14.72 0.00 14.73 
library(microbenchmark) 
f1 <- function() t1 <- dt[floor(a) == 1] 
f2 <- function() t2 <- dt[a >= 1 & a <= 2] 
f3 <- function() {t3 <- dt[seq.int(dt[.(1),.I,roll=-1]$.I, dt[.(2), .I, roll=1]$.I)] } 
microbenchmark(f1(),f2(),f3(), times=10) 
# Unit: milliseconds 
# expr  min  lq median  uq  max neval 
# f1() 371.62161 387.81815 394.92153 403.52299 489.61508 10 
# f2() 529.62952 536.23727 544.74470 631.55594 634.92275 10 
# f3() 65.58094 66.34703 67.04747 75.89296 89.10182 10 

Ora è "veloce", ma perché abbiamo trascorso del tempo prima di impostare la chiave.

Aggiunta approccio @ di Eddi per l'analisi comparativa

f4 <- function(tolerance = 1e-7){ # adjust according to your needs 
    start = dt[J(1 + tolerance), .I[1], roll = -Inf]$V1 
    end = dt[J(2 - tolerance), .I[.N], roll = Inf]$V1 
if (start <= end) dt[start:end]} 
microbenchmark(f1(),f2(),f3(),f4(), times=10) 
# Unit: milliseconds 
# expr  min  lq median  uq  max neval 
# f1() 373.3313 391.07479 440.07025 488.54020 491.48141 10 
# f2() 523.2319 530.11218 533.57844 536.67767 629.53779 10 
# f3() 65.6238 65.71617 66.09967 66.56768 83.27646 10 
# f4() 65.8511 66.26432 66.62096 83.86476 87.01092 10 

approccio di Eddi è leggermente più sicuro in quanto si prende cura di tolleranza in virgola mobile.

Answer 4

Se si dispone di un set di chiavi, quindi i dati sono allineati, quindi basta trovare i punti finali e prendere i punti in mezzo:

setkey(dt, a) 
tolerance = 1e-7 # adjust according to your needs 
start = dt[J(1 + tolerance), .I[1], roll = -Inf]$V1 
end = dt[J(2 - tolerance), .I[.N], roll = Inf]$V1 
if (start <= end) dt[start:end] 

Questo sarà un po 'più lento rispetto floor approccio di Arun, dal momento che fa 2 join, ma sul lato positivo è possibile collegare qualsiasi numero che ti piace.