R: подмножество данных .table на основе целочисленного столбца

Просто интересно, есть ли способ сглаживания подмножества data.table. В основном у меня большой стол с миллионистыми рядами и сотнями колос. Я хочу подмножить его на основе целочисленного col/s, имеющего значение между диапазоном, определенным мной.

Мне было интересно, установил ли соответствующий столбец в качестве ключа это бинарный поиск, но затем не уверен, могу ли я найти строки между диапазоном значений.

Продуманный пример ниже.

> 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

может ли это быть сделано?

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

Спасибо! -Abhi

Ответ 1

Если вы установите ключ на a (это займет некоторое время (14,7 секунды на моей машине для n=1e7), то вы можете использовать скользящие соединения для определения начала и конца интересующего вас региона.

# 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

Теперь он "быстрый", но потому, что мы потратили время раньше, установив ключ.

Добавление подхода @eddi для бенчмаркинга

 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

Подход Eddi немного безопаснее, поскольку он заботится о допуске с плавающей точкой.

Ответ 2

Выполнение setkey здесь было бы дорогостоящим (даже если бы вы использовали быстрый порядок в 1.8.11), так как он также должен перемещать данные (по ссылке).

Однако вы можете обойти этот случай, используя функцию floor. В принципе, если вы хотите, чтобы все числа в [1,2] (Примечание: здесь указаны здесь 1 и 2), то floor будет предоставлять значение "1" для всех этих значений. То есть вы можете:

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

Это эквивалентно выполнению dt[a >= 1 & a <=2] и в два раза быстрее.

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

identical(t1,t2) # [1] TRUE

Однако, поскольку вы не хотите равенства, вы можете использовать хак для вычитания допуска = .Machine$double.eps^0.5 из столбца a. Если значение находится в диапазоне [1, 1+tolerance), то оно по-прежнему считается равным 1. И если оно больше, то оно больше не 1 (внутренне). То есть, это наименьшее число > 1, которое машина может идентифицировать как не 1. Итак, если вы вычитаете "а" по допуску, все числа, которые внутренне представлены как "1", станут < 1 и floor(.) приведет к 0. Итак, вы получите диапазон > 1 и < 2 вместо этого. То есть

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

даст эквивалентный результат как dt[a>1 & a<2].

Если вам нужно сделать это повторно, возможно, создание нового столбца с помощью этой функции floor и клавиши установки в столбце integer может помочь:

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

Теперь вы можете запросить любой диапазон, который вы хотите, используя двоичный поиск:

> 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

Ответ 3

Если у вас есть набор ключей, ваши данные сортируются, поэтому просто найдите конечные точки и найдите точки между ними:

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]

Это будет немного медленнее, чем подход Arun floor, поскольку он делает 2 соединения, но с плюсовой стороны вы можете подключать любые цифры, которые вам нравятся.

Ответ 4

Я не эксперт data.table, но из того, что я понимаю, причина key search setkey(dt, b) ; dt['a'] настолько велика, потому что он использует двоичный поиск вместо векторного сканирования. Это невозможно для числовых столбцов, где подмножество требует двоичных операторов.

Единственная альтернатива - сделать что-то вроде:

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

Что, интересно, быстрее, чем:

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

Но так как вы можете просто сохранить подмножество как отдельную таблицу данных. В любом случае, я не вижу в этом большого количества приложений.