Was ist der schnellste Weg, um data.frames in R zusammenzuführen / zu verbinden?

Zum Beispiel (nicht sicher, ob das repräsentativste Beispiel):

N <- 1e6
d1 <- data.frame(x=sample(N,N), y1=rnorm(N))
d2 <- data.frame(x=sample(N,N), y2=rnorm(N))

Das habe ich bisher:

d <- merge(d1,d2)
# 7.6 sec

library(plyr)
d <- join(d1,d2)
# 2.9 sec

library(data.table)
dt1 <- data.table(d1, key="x")
dt2 <- data.table(d2, key="x")
d <- data.frame( dt1[dt2,list(x,y1,y2=dt2$y2)] )
# 4.9 sec

library(sqldf)
sqldf()
sqldf("create index ix1 on d1(x)")
sqldf("create index ix2 on d2(x)")
d <- sqldf("select * from d1 inner join d2 on d1.x=d2.x")
sqldf()
# 17.4 sec

Der Übereinstimmungsansatz funktioniert, wenn im zweiten Datenrahmen für jeden Schlüsselwert im ersten ein eindeutiger Schlüssel vorhanden ist. Wenn der zweite Datenrahmen Duplikate enthält, sind die Übereinstimmungs- und Zusammenführungsansätze nicht identisch. Das Match ist natürlich schneller, da es nicht so viel bewirkt. Insbesondere wird nie nach doppelten Schlüsseln gesucht. (Fortsetzung nach Code)

DF1 = data.frame(a = c(1, 1, 2, 2), b = 1:4)
DF2 = data.frame(b = c(1, 2, 3, 3, 4), c = letters[1:5])
merge(DF1, DF2)
    b a c
  1 1 1 a
  2 2 1 b
  3 3 2 c
  4 3 2 d
  5 4 2 e
DF1$c = DF2$c[match(DF1$b, DF2$b)]
DF1$c
[1] a b c e
Levels: a b c d e

> DF1
  a b c
1 1 1 a
2 1 2 b
3 2 3 c
4 2 4 e

In dem in der Frage veröffentlichten sqldf-Code scheint es, dass Indizes für die beiden Tabellen verwendet wurden, aber tatsächlich werden sie in Tabellen platziert, die überschrieben wurden, bevor die sql-Auswahl jemals ausgeführt wird, und dies erklärt teilweise, warum Es ist so langsam. Die Idee von sqldf ist, dass die Datenrahmen in Ihrer R-Sitzung die Datenbank bilden, nicht die Tabellen in sqlite. Daher sucht der Code jedes Mal, wenn er auf einen nicht qualifizierten Tabellennamen verweist, in Ihrem R-Arbeitsbereich danach - nicht in der Hauptdatenbank von sqlite. Daher wird in der angezeigten select-Anweisung d1 und d2 aus dem Arbeitsbereich in die Hauptdatenbank von sqlite eingelesen, wobei diejenigen mit den Indizes überlastet werden. Infolgedessen wird ein Join ohne Indizes ausgeführt. Wenn Sie die Versionen von d1 und d2 verwenden möchten, die sich in der Hauptdatenbank von sqlite befinden, müssen Sie sie als main.d1 und main bezeichnen. d2 und nicht als d1 und d2. Wenn Sie versuchen, die Ausführung so schnell wie möglich zu gestalten, beachten Sie, dass bei einem einfachen Join keine Indizes für beide Tabellen verwendet werden können, sodass Sie Zeit beim Erstellen eines der Indizes sparen können. Im folgenden Code veranschaulichen wir diese Punkte.

Es lohnt sich zu bemerken, dass die genaue Berechnung einen großen Unterschied machen kann, welches Paket am schnellsten ist. Zum Beispiel führen wir unten eine Zusammenführung und ein Aggregat durch. Wir sehen, dass die Ergebnisse für beide nahezu umgekehrt sind. Im ersten Beispiel vom schnellsten zum langsamsten erhalten wir: data.table, plyr, merge und sqldf, während im zweiten Beispiel sqldf, aggregat, data.table und plyr - fast das Gegenteil des ersten. Im ersten Beispiel ist sqldf 3x langsamer als data.table und im zweiten 200x schneller als plyr und 100-mal schneller als data.table. Unten zeigen wir den Eingabecode, die Ausgabezeiten für die Zusammenführung und die Ausgabezeiten für das Aggregat. Es ist auch erwähnenswert, dass sqldf auf einer Datenbank basiert und daher Objekte verarbeiten kann, die größer als R sind (wenn Sie das Argument dbname von sqldf verwenden), während die anderen Ansätze auf die Verarbeitung im Hauptspeicher beschränkt sind. Wir haben auch sqldf mit sqlite illustriert, aber es unterstützt auch die H2- und PostgreSQL-Datenbanken.

library(plyr)
library(data.table)
library(sqldf)

set.seed(123)
N <- 1e5
d1 <- data.frame(x=sample(N,N), y1=rnorm(N))
d2 <- data.frame(x=sample(N,N), y2=rnorm(N))

g1 <- sample(1:1000, N, replace = TRUE)
g2<- sample(1:1000, N, replace = TRUE)
d <- data.frame(d1, g1, g2)

library(rbenchmark)

benchmark(replications = 1, order = "elapsed",
   merge = merge(d1, d2),
   plyr = join(d1, d2),
   data.table = { 
      dt1 <- data.table(d1, key = "x")
      dt2 <- data.table(d2, key = "x")
      data.frame( dt1[dt2,list(x,y1,y2=dt2$y2)] )
      },
   sqldf = sqldf(c("create index ix1 on d1(x)",
      "select * from main.d1 join d2 using(x)"))
)

set.seed(123)
N <- 1e5
g1 <- sample(1:1000, N, replace = TRUE)
g2<- sample(1:1000, N, replace = TRUE)
d <- data.frame(x=sample(N,N), y=rnorm(N), g1, g2)

benchmark(replications = 1, order = "elapsed",
   aggregate = aggregate(d[c("x", "y")], d[c("g1", "g2")], mean), 
   data.table = {
      dt <- data.table(d, key = "g1,g2")
      dt[, colMeans(cbind(x, y)), by = "g1,g2"]
   },
   plyr = ddply(d, .(g1, g2), summarise, avx = mean(x), avy=mean(y)),
   sqldf = sqldf(c("create index ix on d(g1, g2)",
      "select g1, g2, avg(x), avg(y) from main.d group by g1, g2"))
)

Die Ergebnisse der beiden Benchmark-Aufrufe, die die Zusammenführungsberechnungen vergleichen, sind:

Joining by: x
        test replications elapsed relative user.self sys.self user.child sys.child
3 data.table            1    0.34 1.000000      0.31     0.01         NA        NA
2       plyr            1    0.44 1.294118      0.39     0.02         NA        NA
1      merge            1    1.17 3.441176      1.10     0.04         NA        NA
4      sqldf            1    3.34 9.823529      3.24     0.04         NA        NA

Die Ausgabe des Benchmark-Aufrufs zum Vergleich der aggregierten Berechnungen lautet:

        test replications elapsed  relative user.self sys.self user.child sys.child
4      sqldf            1    2.81  1.000000      2.73     0.02         NA        NA
1  aggregate            1   14.89  5.298932     14.89     0.00         NA        NA
2 data.table            1  132.46 47.138790    131.70     0.08         NA        NA
3       plyr            1  212.69 75.690391    211.57     0.56         NA        NA

Die 132 Sekunden, die in Gabors Ergebnissen für angegeben sind, data.tablesind tatsächlich Timing-Basisfunktionen colMeansund cbind(die Speicherzuweisung und das Kopieren, die durch die Verwendung dieser Funktionen induziert werden). Es gibt auch gute und schlechte Verwendungsmöglichkeiten data.table.

benchmark(replications = 1, order = "elapsed", 
  aggregate = aggregate(d[c("x", "y")], d[c("g1", "g2")], mean),
  data.tableBad = {
     dt <- data.table(d, key = "g1,g2") 
     dt[, colMeans(cbind(x, y)), by = "g1,g2"]
  }, 
  data.tableGood = {
     dt <- data.table(d, key = "g1,g2") 
     dt[, list(mean(x),mean(y)), by = "g1,g2"]
  }, 
  plyr = ddply(d, .(g1, g2), summarise, avx = mean(x), avy=mean(y)),
  sqldf = sqldf(c("create index ix on d(g1, g2)",
      "select g1, g2, avg(x), avg(y) from main.d group by g1, g2"))
  ) 

            test replications elapsed relative user.self sys.self
3 data.tableGood            1    0.15    1.000      0.16     0.00
5          sqldf            1    1.01    6.733      1.01     0.00
2  data.tableBad            1    1.63   10.867      1.61     0.01
1      aggregate            1    6.40   42.667      6.38     0.00
4           plyr            1  317.97 2119.800    265.12    51.05

packageVersion("data.table")
# [1] ‘1.8.2’
packageVersion("plyr")
# [1] ‘1.7.1’
packageVersion("sqldf")
# [1] ‘0.4.6.4’
R.version.string
# R version 2.15.1 (2012-06-22)

Bitte beachten Sie, dass ich Plyr nicht gut kenne. Bitte erkundigen Sie sich bei Hadley, bevor Sie sich auf die plyrZeitangaben hier verlassen. Beachten Sie auch, dass in data.tabledo die Zeit zum Konvertieren data.tableund Festlegen des Schlüssels für die Fareness enthalten ist.

Diese Antwort wurde aktualisiert, seit sie ursprünglich im Dezember 2010 beantwortet wurde. Die vorherigen Benchmark-Ergebnisse sind unten aufgeführt. Bitte sehen Sie im Versionsverlauf dieser Antwort nach, was sich geändert hat.

              test replications elapsed   relative user.self sys.self
4   data.tableBest            1   0.532   1.000000     0.488    0.020
7            sqldf            1   2.059   3.870301     2.041    0.008
3 data.tableBetter            1   9.580  18.007519     9.213    0.220
1        aggregate            1  14.864  27.939850    13.937    0.316
2  data.tableWorst            1 152.046 285.800752   150.173    0.556
6 plyrwithInternal            1 198.283 372.712406   189.391    7.665
5             plyr            1 225.726 424.296992   208.013    8.004

Für einfache Aufgaben (eindeutige Werte auf beiden Seiten der Verknüpfung) verwende ich match:

system.time({
    d <- d1
    d$y2 <- d2$y2[match(d1$x,d2$x)]
})

Es ist weitaus schneller als das Zusammenführen (auf meinem Computer 0,13 bis 3,37 Sekunden).

Meine Timings:

• merge: 3,32s
• plyr: 0,84 s
• match: 0,12 s

Ich dachte, es wäre interessant, einen Benchmark mit dplyr in der Mischung zu veröffentlichen: (viele Dinge liefen)

            test replications elapsed relative user.self sys.self
5          dplyr            1    0.25     1.00      0.25     0.00
3 data.tableGood            1    0.28     1.12      0.27     0.00
6          sqldf            1    0.58     2.32      0.57     0.00
2  data.tableBad            1    1.10     4.40      1.09     0.01
1      aggregate            1    4.79    19.16      4.73     0.02
4           plyr            1  186.70   746.80    152.11    30.27

packageVersion("data.table")
[1] ‘1.8.10’
packageVersion("plyr")
[1] ‘1.8’
packageVersion("sqldf")
[1] ‘0.4.7’
packageVersion("dplyr")
[1] ‘0.1.2’
R.version.string
[1] "R version 3.0.2 (2013-09-25)"

Gerade hinzugefügt:

dplyr = summarise(dt_dt, avx = mean(x), avy = mean(y))

und richten Sie die Daten für dplyr mit einer Datentabelle ein:

dt <- tbl_dt(d)
dt_dt <- group_by(dt, g1, g2)

Aktualisiert: Ich habe data.tableBad und plyr entfernt und nichts als RStudio geöffnet (i7, 16 GB RAM).

Mit data.table 1.9 und dplyr mit Datenrahmen:

            test replications elapsed relative user.self sys.self
2 data.tableGood            1    0.02      1.0      0.02     0.00
3          dplyr            1    0.04      2.0      0.04     0.00
4          sqldf            1    0.46     23.0      0.46     0.00
1      aggregate            1    6.11    305.5      6.10     0.02

Mit data.table 1.9 und dplyr mit Datentabelle:

            test replications elapsed relative user.self sys.self
2 data.tableGood            1    0.02        1      0.02     0.00
3          dplyr            1    0.02        1      0.02     0.00
4          sqldf            1    0.44       22      0.43     0.02
1      aggregate            1    6.14      307      6.10     0.01

packageVersion("data.table")
[1] '1.9.0'
packageVersion("dplyr")
[1] '0.1.2'

Aus Gründen der Konsistenz ist hier das Original mit all und data.table 1.9 und dplyr unter Verwendung einer Datentabelle:

            test replications elapsed relative user.self sys.self
5          dplyr            1    0.01        1      0.02     0.00
3 data.tableGood            1    0.02        2      0.01     0.00
6          sqldf            1    0.47       47      0.46     0.00
1      aggregate            1    6.16      616      6.16     0.00
2  data.tableBad            1   15.45     1545     15.38     0.01
4           plyr            1  110.23    11023     90.46    19.52

Ich denke, diese Daten sind zu klein für die neuen data.table und dplyr :)

Größerer Datensatz:

N <- 1e8
g1 <- sample(1:50000, N, replace = TRUE)
g2<- sample(1:50000, N, replace = TRUE)
d <- data.frame(x=sample(N,N), y=rnorm(N), g1, g2)

Es dauerte ungefähr 10-13 GB RAM, um die Daten zu speichern, bevor der Benchmark ausgeführt wurde.

Ergebnisse:

            test replications elapsed relative user.self sys.self
1          dplyr            1   14.88        1      6.24     7.52
2 data.tableGood            1   28.41        1     18.55      9.4

Versuchte eine Milliarde, sprengte aber Widder. 32 GB werden es problemlos bewältigen.

[Edit by Arun] (dotcomken, könnten Sie bitte diesen Code ausführen und Ihre Benchmarking-Ergebnisse einfügen? Danke).

require(data.table)
require(dplyr)
require(rbenchmark)

N <- 1e8
g1 <- sample(1:50000, N, replace = TRUE)
g2 <- sample(1:50000, N, replace = TRUE)
d <- data.frame(x=sample(N,N), y=rnorm(N), g1, g2)

benchmark(replications = 5, order = "elapsed", 
  data.table = {
     dt <- as.data.table(d) 
     dt[, lapply(.SD, mean), by = "g1,g2"]
  }, 
  dplyr_DF = d %.% group_by(g1, g2) %.% summarise(avx = mean(x), avy=mean(y))
) 

Gemäß Aruns Anfrage hier die Ausgabe dessen, was Sie mir zur Verfügung gestellt haben:

        test replications elapsed relative user.self sys.self
1 data.table            5   15.35     1.00     13.77     1.57
2   dplyr_DF            5  137.84     8.98    136.31     1.44

Entschuldigung für die Verwirrung, spät in der Nacht kam zu mir.

Die Verwendung von dplyr mit Datenrahmen scheint die weniger effiziente Methode zur Verarbeitung von Zusammenfassungen zu sein. Ist diese Methode, um die genaue Funktionalität von data.table und dplyr mit den enthaltenen Datenstrukturmethoden zu vergleichen? Ich würde es fast vorziehen, das zu trennen, da die meisten Daten bereinigt werden müssen, bevor wir group_by oder die data.table erstellen. Es könnte Geschmackssache sein, aber ich denke, der wichtigste Teil ist, wie effizient die Daten modelliert werden können.

Mithilfe der Zusammenführungsfunktion und ihrer optionalen Parameter:

Innerer Join: Merge (df1, df2) funktioniert für diese Beispiele, da R die Frames automatisch über allgemeine Variablennamen verbindet. Sie möchten jedoch höchstwahrscheinlich Merge (df1, df2, by = "CustomerId") angeben, um sicherzustellen, dass Sie dies tun wurden nur auf den von Ihnen gewünschten Feldern abgeglichen. Sie können auch die Parameter by.x und by.y verwenden, wenn die übereinstimmenden Variablen in den verschiedenen Datenrahmen unterschiedliche Namen haben.

Outer join: merge(x = df1, y = df2, by = "CustomerId", all = TRUE)

Left outer: merge(x = df1, y = df2, by = "CustomerId", all.x = TRUE)

Right outer: merge(x = df1, y = df2, by = "CustomerId", all.y = TRUE)

Cross join: merge(x = df1, y = df2, by = NULL)