Почему plyr так медленно?

Я думаю, что неправильно использую plyr. Может кто-нибудь скажет мне, является ли это "эффективным" plyr-кодом?

require(plyr)
plyr <- function(dd) ddply(dd, .(price), summarise, ss=sum(volume)) 

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

Я проверил несколько методов агрегирования - и нашел себя в ожидании всего дня.

Когда я наконец получил результаты назад, я обнаружил огромный разрыв между методом plyr и другими, что заставляет меня думать, что я сделал что-то мертвое.

Я запустил следующий код (я думал, что проверю новый пакет фреймворка, когда был на нем):

require(plyr)
require(data.table)
require(dataframe)
require(rbenchmark)
require(xts)

plyr <- function(dd) ddply(dd, .(price), summarise, ss=sum(volume)) 
t.apply <- function(dd) unlist(tapply(dd$volume, dd$price, sum))
t.apply.x <- function(dd) unlist(tapply(dd[,2], dd[,1], sum))
l.apply <- function(dd) unlist(lapply(split(dd$volume, dd$price), sum))
l.apply.x <- function(dd) unlist(lapply(split(dd[,2], dd[,1]), sum))
b.y <- function(dd) unlist(by(dd$volume, dd$price, sum))
b.y.x <- function(dd) unlist(by(dd[,2], dd[,1], sum))
agg <- function(dd) aggregate(dd$volume, list(dd$price), sum)
agg.x <- function(dd) aggregate(dd[,2], list(dd[,1]), sum)
dtd <- function(dd) dd[, sum(volume), by=(price)]

obs <- c(5e1, 5e2, 5e3, 5e4, 5e5, 5e6, 5e6, 5e7, 5e8)
timS <- timeBasedSeq('20110101 083000/20120101 083000')

bmkRL <- list(NULL)

for (i in 1:5){
  tt <- timS[1:obs[i]]

  for (j in 1:8){
    pxl <- seq(0.9, 1.1, by= (1.1 - 0.9)/floor(obs[i]/(11-j)))
    px <- sample(pxl, length(tt), replace=TRUE)
    vol <- rnorm(length(tt), 1000, 100)

    d.df <- base::data.frame(time=tt, price=px, volume=vol)
    d.dfp <- dataframe::data.frame(time=tt, price=px, volume=vol)
    d.matrix <- as.matrix(d.df[,-1])
    d.dt <- data.table(d.df)

    listLabel <- paste('i=',i, 'j=',j)

    bmkRL[[listLabel]] <- benchmark(plyr(d.df), plyr(d.dfp), t.apply(d.df),     
                         t.apply(d.dfp), t.apply.x(d.matrix), 
                         l.apply(d.df), l.apply(d.dfp), l.apply.x(d.matrix),
                         b.y(d.df), b.y(d.dfp), b.y.x(d.matrix), agg(d.df),
                         agg(d.dfp), agg.x(d.matrix), dtd(d.dt),
          columns =c('test', 'elapsed', 'relative'),
          replications = 10,
          order = 'elapsed')
  }
}

Тест должен был проверить до 5e8, но потребовалось слишком много времени - в основном из-за plyr. 5e5 в итоговой таблице показана проблема:

$`i= 5 j= 8`
                  test  elapsed    relative
15           dtd(d.dt)    4.156    1.000000
6        l.apply(d.df)   15.687    3.774543
7       l.apply(d.dfp)   16.066    3.865736
8  l.apply.x(d.matrix)   16.659    4.008422
4       t.apply(d.dfp)   21.387    5.146054
3        t.apply(d.df)   21.488    5.170356
5  t.apply.x(d.matrix)   22.014    5.296920
13          agg(d.dfp)   32.254    7.760828
14     agg.x(d.matrix)   32.435    7.804379
12           agg(d.df)   32.593    7.842397
10          b.y(d.dfp)   98.006   23.581809
11     b.y.x(d.matrix)   98.134   23.612608
9            b.y(d.df)   98.337   23.661453
1           plyr(d.df) 9384.135 2257.972810
2          plyr(d.dfp) 9384.448 2258.048123

Правильно ли это? Почему plyr 2250x медленнее, чем data.table? И почему использование нового пакета фреймов данных не изменилось?

Информация о сеансе:

> sessionInfo()
R version 2.15.1 (2012-06-22)
Platform: x86_64-apple-darwin9.8.0/x86_64 (64-bit)

locale:
[1] en_US.UTF-8/en_US.UTF-8/en_US.UTF-8/C/en_US.UTF-8/en_US.UTF-8

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

other attached packages:
[1] xts_0.8-6        zoo_1.7-7        rbenchmark_0.3   dataframe_2.5    data.table_1.8.1     plyr_1.7.1      

loaded via a namespace (and not attached):
[1] grid_2.15.1    lattice_0.20-6 tools_2.15.1 

Ответ 1

Почему это так медленно? Небольшое исследование, в котором размещена публикация почтовой группы с августа 2011 года, где @hadley, автор пакета, указывает

Это недостаток того, как ddply всегда работает с данными кадры. Это будет немного быстрее, если вы используете обобщение вместо data.frame(потому что data.frame очень медленный), но я все еще думаю о том, как преодолеть это фундаментальное ограничение ddply Подход.


Что касается эффективного кода plyr, я тоже не знал. После того, как группа тестирования параметров и настольная маркировка выглядят так, мы можем сделать лучше.

summarize() в вашей команде является просто вспомогательной функцией, чистой и простой. Мы можем заменить его своей собственной функцией суммы, поскольку она не помогает ни с чем, что еще не так просто, и аргументы .data и .(price) могут быть сделаны более явными. Результатом является

ddply( dd[, 2:3], ~price, function(x) sum( x$volume ) )

summarize может показаться приятным, но он просто не быстрее простого вызова функции. Это имеет смысл; просто посмотрите на нашу небольшую функцию по сравнению с кодом для summarize. Запуск ваших тестов с пересмотренной формулой дает заметный выигрыш. Не думайте, что это означает, что вы неправильно использовали plyr, вы этого не сделали, это просто неэффективно; вы ничего не можете с ним сделать, сделайте так же быстро, как и другие варианты.

По-моему, оптимизированная функция все еще воняет, поскольку она не ясна и должна быть мысленно проанализирована вместе с тем, что все еще смехотворно медленнее по сравнению с data.table(даже с коэффициентом усиления 60%).


В той же нитке, о которой говорилось выше, относительно медленности plyr, упоминается проект plyr2. Со времени первоначального ответа на вопрос автор plyr выпустил dplyr в качестве преемника plyr. Хотя plyr и dplyr объявляются как инструменты для обработки данных, и ваш основной заявленный интерес представляет собой агрегацию, вы все равно можете быть заинтересованы в результатах тестирования нового пакета для сравнения, поскольку он имеет переработанный бэкэнд для повышения производительности.

plyr_Original   <- function(dd) ddply( dd, .(price), summarise, ss=sum(volume))
plyr_Optimized  <- function(dd) ddply( dd[, 2:3], ~price, function(x) sum( x$volume ) )

dplyr <- function(dd) dd %.% group_by(price) %.% summarize( sum(volume) )    

data_table <- function(dd) dd[, sum(volume), keyby=price]

Пакет dataframe был удален из CRAN, а затем из тестов вместе с версиями матричных функций.

Здесь результаты тестирования i=5, j=8:

$`obs= 500,000 unique prices= 158,286 reps= 5`
                  test elapsed relative
9     data_table(d.dt)   0.074    1.000
4          dplyr(d.dt)   0.133    1.797
3          dplyr(d.df)   1.832   24.757
6        l.apply(d.df)   5.049   68.230
5        t.apply(d.df)   8.078  109.162
8            agg(d.df)  11.822  159.757
7            b.y(d.df)  48.569  656.338
2 plyr_Optimized(d.df) 148.030 2000.405
1  plyr_Original(d.df) 401.890 5430.946

Без сомнения, оптимизация немного помогла. Взгляните на функции d.df; они просто не могут конкурировать.

Для небольшой перспективы медленности структуры data.frame здесь представлены микро-тесты времени агрегации данных_table и dplyr с использованием большего тестового набора данных (i=8,j=8).

$`obs= 50,000,000 unique prices= 15,836,476 reps= 5`
Unit: seconds
             expr    min     lq median     uq    max neval
 data_table(d.dt)  1.190  1.193  1.198  1.460  1.574    10
      dplyr(d.dt)  2.346  2.434  2.542  2.942  9.856    10
      dplyr(d.df) 66.238 66.688 67.436 69.226 86.641    10

Кадр данных все еще остается в пыли. И не только это, но истекшее время system.time для заполнения структур данных тестовыми данными:

`d.df` (data.frame)  3.181 seconds.
`d.dt` (data.table)  0.418 seconds.

Как создание, так и агрегация файла data.frame медленнее, чем у data.table.

Работа с data.frame в R медленнее, чем некоторые альтернативы, но поскольку эталонные тесты показывают, что встроенные функции R выдувают воздух из воды. Даже управление data.frame как dplyr делает, что улучшает встроенные функции, не дает оптимальной скорости; где, поскольку data.table быстрее и в создании, и в агрегации, и в data.table делает то, что он делает, работая с /data.frames.

В конце концов...

Plyr медленный из-за того, как он работает и управляет манипуляцией data.frame.

[punt:: см. комментарии к исходному вопросу].


## R version 3.0.2 (2013-09-25)
## Platform: x86_64-pc-linux-gnu (64-bit)
## 
## attached base packages:
## [1] stats     graphics  grDevices utils     datasets  methods   base     
## 
## other attached packages:
## [1] microbenchmark_1.3-0 rbenchmark_1.0.0     xts_0.9-7           
## [4] zoo_1.7-11           data.table_1.9.2     dplyr_0.1.2         
## [7] plyr_1.8.1           knitr_1.5.22        
## 
## loaded via a namespace (and not attached):
## [1] assertthat_0.1  evaluate_0.5.2  formatR_0.10.4  grid_3.0.2     
## [5] lattice_0.20-27 Rcpp_0.11.0     reshape2_1.2.2  stringr_0.6.2  
## [9] tools_3.0.2

Data-Generating gist.rmd