Schnelle Wege in R, um die erste Zeile eines Datenrahmens zu erhalten, der nach einem Bezeichner gruppiert ist [closed]

Manchmal muss ich nur die erste Zeile eines Datensatzes abrufen, der nach einem Bezeichner gruppiert ist, z. B. beim Abrufen von Alter und Geschlecht, wenn mehrere Beobachtungen pro Person vorliegen. Was ist ein schneller (oder der schnellste) Weg, dies in R zu tun? Ich habe aggregate () unten verwendet und vermute, dass es bessere Möglichkeiten gibt. Bevor ich diese Frage postete, suchte ich ein bisschen bei Google, fand und probierte ddply und war überrascht, dass es extrem langsam war und mir Speicherfehler in meinem Datensatz (400.000 Zeilen x 16 Spalten, 7.000 eindeutige IDs) und in der aggregate () -Version bescherte war einigermaßen schnell.

(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,])

UPDATE: Siehe Chases Antwort und Matt Parkers Kommentar zu dem, was ich für den elegantesten Ansatz halte. Die schnellste Lösung, die das data.tablePaket verwendet, finden Sie in der Antwort von @Matthew Dowle .

Ist Ihre ID-Spalte wirklich ein Faktor? Wenn es tatsächlich numerisch ist, können Sie die diffFunktion zu Ihrem Vorteil nutzen. Sie könnten es auch zwingen, mit zu numerisch 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, ]

Nach der Antwort von Steve gibt es in data.table einen viel schnelleren Weg:

> # 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 

Wenn Sie lediglich die erste Zeile jeder Gruppe benötigen, können Sie sich viel schneller direkt an diese Zeile anschließen. Warum sollte das SD-Objekt jedes Mal erstellt werden, um nur die erste Zeile zu verwenden?

Vergleichen Sie die 0.064 von data.table mit "Matt Parkers Alternative zu Chases Lösung" (die bisher die schnellste zu sein schien):

> 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 

Also ~ 5 mal schneller, aber es ist ein winziger Tisch mit weniger als 1 Million Zeilen. Mit zunehmender Größe nimmt auch der Unterschied zu.

Sie brauchen nicht mehrere merge()Schritte, nur aggregate()beide Variablen von 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

Vergleichszeitpunkte:

1) Matts Lösung:

> 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) Zachs Reshape2-Lösung:

> 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) Steve's data.table Lösung:

> 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) Chases schnelle Lösung unter Verwendung von Zahlen und nicht von Faktoren 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

und 5) Matt Parkers Alternative zu Chases Lösung für Charakter oder Faktor ID, die etwas schneller ist als Chases numerische Lösung 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

Sie können versuchen, das Paket data.table zu verwenden .

Für Ihren speziellen Fall ist der Vorteil, dass es (wahnsinnig) schnell ist. Als ich zum ersten Mal darauf aufmerksam wurde, arbeitete ich an data.frame-Objekten mit Hunderttausenden von Zeilen. "Normal" aggregateoder ddplyMethoden wurden ~ 1-2 Minuten in Anspruch genommen (dies war, bevor Hadley das idata.frameMojo einführte ddply). Verwendendata.table war die Operation buchstäblich in wenigen Sekunden erledigt.

Der Nachteil ist, dass es so schnell ist, weil es Ihre data.table (es ist wie ein data.frame) nach "Schlüsselspalten" sortiert und eine intelligente Suchstrategie verwendet, um Teilmengen Ihrer Daten zu finden. Dies führt zu einer Neuordnung Ihrer Daten, bevor Sie Statistiken darüber sammeln.

Vorausgesetzt, Sie möchten nur die erste Zeile jeder Gruppe - möglicherweise wird die Neuordnung die erste Zeile durcheinander bringen, weshalb dies in Ihrer Situation möglicherweise nicht angemessen ist.

Wie auch immer, Sie müssen hier beurteilen, ob dies data.tableangemessen ist oder nicht , aber so würden Sie es mit den Daten verwenden, die Sie präsentiert haben:

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

Update: Matthew Dowle (der Hauptentwickler des data.table-Pakets) bietet eine bessere / intelligentere / (extrem) effizientere Möglichkeit, data.table zur Lösung dieses Problems zu verwenden .

Versuchen Sie es mit reshape2

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

Du könntest es versuchen

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)

Ich habe jedoch keine Ahnung, ob dies schneller sein plyrwird.