Penso che sto usando plyr in modo errato. Qualcuno potrebbe dirmi se questo è un codice plyr 'efficiente'?Perché il film è così lento?
require(plyr)
plyr <- function(dd) ddply(dd, .(price), summarise, ss=sum(volume))
Un po 'di contesto: ho un paio di problemi di grande aggregazione e ho notato che erano ognuno prendendo po' di tempo. Nel tentativo di risolvere i problemi, mi sono interessato allo svolgimento delle varie procedure di aggregazione in R.
Ho provato alcuni metodi di aggregazione e mi sono trovato ad aspettare tutto il giorno.
Quando finalmente ho ottenuto risultati, ho scoperto un enorme divario tra il metodo plyr e gli altri - il che mi fa pensare che ho fatto qualcosa di sbagliato.
Ho eseguito il seguente codice (ho pensato di controllare il nuovo pacchetto di dataframe mentre ero a lui):
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')
}
}
Il test è stato supposto per controllare fino a 5E8, ma ci sono voluti troppo a lungo - principalmente a causa di plyr. Il 5e5 la tabella finale mostra il problema:
$`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
È giusto? Perché plyr 2250x è più lento di data.table
? E perché non usare il nuovo pacchetto di frame dati fa la differenza?
Le informazioni di sessione è:
> 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
Per relativamente semplici problemi di manipolazione dei dati/aggregazione, ho trovato tabella di dati di essere estremamente veloce. Se può farlo, non sono affatto sorpreso che sia il chiaro vincitore. Non ho familiarità con 'plyr' per commentarlo. – Joshua
Hai esaminato la documentazione di 'plyr' e' data.table'? Se ricordo male, 'plyr' funziona con base-' R' 'data.frame's. 'data.table' usa una rappresentazione completamente diversa, usando colonne con chiave e un ordinamento digitale efficiente. In questo modo è molto più simile a un database. –
ho dato un'occhiata - ma non riuscivo a capirlo. plyr è più di un po 'più lento ... la famiglia applica, agg, e sono molto veloci - e sono di base. è per questo che ho pensato che dovevo fare qualche errore da principiante con plyr. – ricardo