Maneiras rápidas no R de obter a primeira linha de um quadro de dados agrupada por um identificador [fechado]

Às vezes, preciso obter apenas a primeira linha de um conjunto de dados agrupada por um identificador, como ao recuperar idade e sexo, quando há várias observações por indivíduo. Qual é a maneira mais rápida (ou mais rápida) de fazer isso no R? Usei o agregate () abaixo e suspeito que existem maneiras melhores. Antes de postar essa pergunta, pesquisei um pouco no google, encontrei e tentei o ddply, e fiquei surpreso que era extremamente lento e me deu erros de memória no meu conjunto de dados (400.000 linhas x 16 cols, 7.000 IDs exclusivos), enquanto a versão agregada () foi razoavelmente rápido.

(dx <- data.frame(ID = factor(c(1,1,2,2,3,3)), AGE = c(30,30,40,40,35,35), FEM = factor(c(1,1,0,0,1,1))))
# ID AGE FEM
#  1  30   1
#  1  30   1
#  2  40   0
#  2  40   0
#  3  35   1
#  3  35   1
ag <- data.frame(ID=levels(dx$ID))
ag <- merge(ag, aggregate(AGE ~ ID, data=dx, function(x) x[1]), "ID")
ag <- merge(ag, aggregate(FEM ~ ID, data=dx, function(x) x[1]), "ID")
ag
# ID AGE FEM
#  1  30   1
#  2  40   0
#  3  35   1
#same result:
library(plyr)
ddply(.data = dx, .var = c("ID"), .fun = function(x) x[1,])

ATUALIZAÇÃO: Veja a resposta de Chase e o comentário de Matt Parker sobre o que considero a abordagem mais elegante. Veja a resposta de @Matthew Dowle para a solução mais rápida que usa o data.tablepacote.

A sua coluna de identificação é realmente um fator? Se é de fato numérico, acho que você pode usar a difffunção a seu favor. Você também pode forçá-lo a numérico com as.numeric().

dx <- data.frame(
    ID = sort(sample(1:7000, 400000, TRUE))
    , AGE = sample(18:65, 400000, TRUE)
    , FEM = sample(0:1, 400000, TRUE)
)

dx[ diff(c(0,dx$ID)) != 0, ]

Após a resposta de Steve, existe uma maneira muito mais rápida de data.table:

> # Preamble
> dx <- data.frame(
+     ID = sort(sample(1:7000, 400000, TRUE))
+     , AGE = sample(18:65, 400000, TRUE)
+     , FEM = sample(0:1, 400000, TRUE)
+ )
> dxt <- data.table(dx, key='ID')

> # fast self join
> system.time(ans2<-dxt[J(unique(ID)),mult="first"])
 user  system elapsed 
0.048   0.016   0.064

> # slower using .SD
> system.time(ans1<-dxt[, .SD[1], by=ID])
  user  system elapsed 
14.209   0.012  14.281 

> mapply(identical,ans1,ans2)  # ans1 is keyed but ans2 isn't, otherwise identical
  ID  AGE  FEM 
TRUE TRUE TRUE 

Se você apenas precisa da primeira linha de cada grupo, é muito mais rápido ingressar nessa linha diretamente. Por que criar o objeto .SD de cada vez, apenas para usar a primeira linha dele?

Compare o 0,064 de data.table com "A alternativa de Matt Parker à solução de Chase" (que parecia ser a mais rápida até agora):

> system.time(ans3<-dxt[c(TRUE, dxt$ID[-1] != dxt$ID[-length(dxt$ID)]), ])
 user  system elapsed 
0.284   0.028   0.310 
> identical(ans1,ans3)
[1] TRUE 

Tão ~ 5 vezes mais rápido, mas é uma pequena mesa com menos de 1 milhão de linhas. À medida que o tamanho aumenta, o mesmo acontece com a diferença.

Você não precisa de várias merge()etapas, apenas as aggregate()duas variáveis ​​de interesse:

> aggregate(dx[, -1], by = list(ID = dx$ID), head, 1)
  ID AGE FEM
1  1  30   1
2  2  40   0
3  3  35   1

> system.time(replicate(1000, aggregate(dx[, -1], by = list(ID = dx$ID), 
+                                       head, 1)))
   user  system elapsed 
  2.531   0.007   2.547 
> system.time(replicate(1000, {ag <- data.frame(ID=levels(dx$ID))
+ ag <- merge(ag, aggregate(AGE ~ ID, data=dx, function(x) x[1]), "ID")
+ ag <- merge(ag, aggregate(FEM ~ ID, data=dx, function(x) x[1]), "ID")
+ }))
   user  system elapsed 
  9.264   0.009   9.301

Tempos de comparação:

1) Solução de Matt:

> system.time(replicate(1000, {
+ agg <- by(dx, dx$ID, FUN = function(x) x[1, ])
+ # Which returns a list that you can then convert into a data.frame thusly:
+ do.call(rbind, agg)
+ }))
   user  system elapsed 
  3.759   0.007   3.785

2) Solução de remodelação2 de Zach:

> system.time(replicate(1000, {
+ dx <- melt(dx,id=c('ID','FEM'))
+ dcast(dx,ID+FEM~variable,fun.aggregate=mean)
+ }))
   user  system elapsed 
 12.804   0.032  13.019

3) solução data.table de Steve:

> system.time(replicate(1000, {
+ dxt <- data.table(dx, key='ID')
+ dxt[, .SD[1,], by=ID]
+ }))
   user  system elapsed 
  5.484   0.020   5.608 
> dxt <- data.table(dx, key='ID') ## one time step
> system.time(replicate(1000, {
+ dxt[, .SD[1,], by=ID] ## try this one line on own
+ }))
   user  system elapsed 
  3.743   0.006   3.784

4) A solução rápida do Chase usando numérico, não fator ID:

> dx2 <- within(dx, ID <- as.numeric(ID))
> system.time(replicate(1000, {
+ dy <- dx[order(dx$ID),]
+ dy[ diff(c(0,dy$ID)) != 0, ]
+ }))
   user  system elapsed 
  0.663   0.000   0.663

e 5) A alternativa de Matt Parker à solução de Chase, por caráter ou fator ID, que é um pouco mais rápida que a numérica de Chase ID:

> system.time(replicate(1000, {
+ dx[c(TRUE, dx$ID[-1] != dx$ID[-length(dx$ID)]), ]
+ }))
   user  system elapsed 
  0.513   0.000   0.516

Você pode tentar usar o pacote data.table .

Para o seu caso em particular, a vantagem é que é (insanamente) rápido. A primeira vez que fui apresentado a ele, estava trabalhando em objetos data.frame com centenas de milhares de linhas. "Normal" aggregateou ddplymétodos foram tomados ~ 1-2 minutos para serem concluídos (isso foi antes de Hadley introduzir o idata.framemojo ddply). Usando data.table, a operação foi literalmente realizada em questão de segundos.

A desvantagem é que é tão rápido, porque ele recorre à sua tabela de dados (é como um arquivo de dados) por "colunas-chave" e usa uma estratégia de pesquisa inteligente para encontrar subconjuntos de dados. Isso resultará em uma reordenação dos seus dados antes de você coletar estatísticas sobre eles.

Dado que você deseja apenas a primeira linha de cada grupo - talvez a reordenação atrapalhe qual linha é a primeira, e é por isso que pode não ser adequada à sua situação.

De qualquer forma, você terá que julgar se data.tableé apropriado ou não aqui, mas é assim que você o usaria com os dados que você apresentou:

install.packages('data.table') ## if yo udon't have it already
library(data.table)
dxt <- data.table(dx, key='ID')
dxt[, .SD[1,], by=ID]
     ID AGE FEM
[1,]  1  30   1
[2,]  2  40   0
[3,]  3  35   1

Atualização: Matthew Dowle (o principal desenvolvedor do pacote data.table) forneceu uma maneira melhor / mais inteligente / (extremamente) mais eficiente de usar o data.table para resolver esse problema como uma das respostas aqui ... definitivamente verifique isso .

Tente remodelar2

library(reshape2)
dx <- melt(dx,id=c('ID','FEM'))
dcast(dx,ID+FEM~variable,fun.aggregate=mean)

Você poderia tentar

agg <- by(dx, dx$ID, FUN = function(x) x[1, ])
# Which returns a list that you can then convert into a data.frame thusly:
do.call(rbind, agg)

Eu não tenho idéia se isso será mais rápido do que plyr, no entanto.