Effizient replizieren Matrizen in R

Ich habe eine matrix und suchen nach einer effizienten Art und Weise zu replizieren, n-mal (wobei n die Anzahl der Beobachtungen im Datensatz). Zum Beispiel, wenn ich eine matrix A

A <- matrix(1:15, nrow=3)

dann will ich eine Ausgabe der form

rbind(A, A, A, ...) #n times.

Offensichtlich gibt es viele Möglichkeiten, zu konstruieren, eine so große matrix, zum Beispiel mit Hilfe eines for Schleife oder apply oder ähnliche Funktionen. Jedoch der Aufruf an die "matrix-replication-Funktion" findet in der Kern meiner Optimierungs-Algorithmus, wo es heißt Zehntausende von malen während einer Ausführung meines Programms. Daher, Schleifen anwenden-Typ-Funktionen und ähnliches, sind nicht effizient genug. (Eine solche Lösung würde im Grunde bedeuten, dass ein loop über n wird durchgeführt, Zehntausende von Zeiten, das ist natürlich ineffizient.) Ich habe bereits versucht, den normalen rep Funktion, aber noch nicht einen Weg gefunden, wie ordnen Sie die Leistung von rep in eine matrix der gewünschten Form.

Die Lösung
do.call("rbind", replicate(n, A, simplify=F))
ist auch zu ineffizient, weil rbind ist zu oft verwendet in diesem Fall. (Dann werden etwa 30% der gesamten Laufzeit meines Programms aufgewendet wird, die rbinds.)

Weiß jemand eine bessere Lösung?

rbind ist nur einmal benutzt in der do.call Weg. es ist die Replikation, die wahrscheinlich bogging it down.
Getestet habe ich es mit Rprofund rbind dauerte etwa doppelt so viel Zeit wie replicate. Ich war auch überrascht.

InformationsquelleAutor Wolfgang Pößnecker | 2012-10-23

matrix r replication

Zwei weitere Lösungen:

Die erste ist eine Abwandlung des Beispiel in der Frage

do.call("rbind", rep(list(A), n))

Das zweite bezieht sich abrollen der matrix, die sich replizieren, und wiederzusammensetzen.

matrix(rep(t(A),n), ncol=ncol(A), byrow=TRUE)

Da der Wirkungsgrad ist, was angefordert wurde, benchmarking notwendig ist

library("rbenchmark")
A <- matrix(1:15, nrow=3)
n <- 10

benchmark(rbind(A, A, A, A, A, A, A, A, A, A),
          do.call("rbind", replicate(n, A, simplify=FALSE)),
          do.call("rbind", rep(list(A), n)),
          apply(A, 2, rep, n),
          matrix(rep(t(A),n), ncol=ncol(A), byrow=TRUE),
          order="relative", replications=100000)

gibt:

                                                 test replications elapsed
1                 rbind(A, A, A, A, A, A, A, A, A, A)       100000    0.91
3                   do.call("rbind", rep(list(A), n))       100000    1.42
5  matrix(rep(t(A), n), ncol = ncol(A), byrow = TRUE)       100000    2.20
2 do.call("rbind", replicate(n, A, simplify = FALSE))       100000    3.03
4                                 apply(A, 2, rep, n)       100000    7.75
  relative user.self sys.self user.child sys.child
1    1.000      0.91        0         NA        NA
3    1.560      1.42        0         NA        NA
5    2.418      2.19        0         NA        NA
2    3.330      3.03        0         NA        NA
4    8.516      7.73        0         NA        NA

Also die Schnellste ist die raw - rbind nennen, aber das setzt Voraus n ist fest und bekannt Voraus. Wenn n ist nicht behoben, dann der Schnellste ist do.call("rbind", rep(list(A), n). Diese wurden für eine 3x5-matrix und 10 Replikationen. Verschieden große Matrizen geben könnten unterschiedlicher reihenfolbg.

EDIT:

Für n=600, die Ergebnisse sind in einer anderen Reihenfolge (ohne die explizite rbind version):

A <- matrix(1:15, nrow=3)
n <- 600

benchmark(do.call("rbind", replicate(n, A, simplify=FALSE)),
          do.call("rbind", rep(list(A), n)),
          apply(A, 2, rep, n),
          matrix(rep(t(A),n), ncol=ncol(A), byrow=TRUE),
          order="relative", replications=10000)

geben

                                                 test replications elapsed
4  matrix(rep(t(A), n), ncol = ncol(A), byrow = TRUE)        10000    1.74
3                                 apply(A, 2, rep, n)        10000    2.57
2                   do.call("rbind", rep(list(A), n))        10000    2.79
1 do.call("rbind", replicate(n, A, simplify = FALSE))        10000    6.68
  relative user.self sys.self user.child sys.child
4    1.000      1.75        0         NA        NA
3    1.477      2.54        0         NA        NA
2    1.603      2.79        0         NA        NA
1    3.839      6.65        0         NA        NA

Wenn Sie die ausdrückliche rbind version, es ist etwas schneller als die do.call("rbind", rep(list(A), n)) version, aber nicht viel, und langsamer als die apply oder matrix Versionen. So eine Verallgemeinerung auf beliebige n nicht erforderlich, ein Verlust der Geschwindigkeit in diesem Fall.

Wow, vielen Dank! Jedoch, meine eigenen kleinen benchmark zeigte, dass die matrix-Versionen sind effizienter als die rbind Anrufe für größere n, sagen wir n = 600. In diesem Fall, die version mit der matrix(rep(t(...-Aufruf war höchst effizient.

InformationsquelleAutor Brian Diggs

6

Wahrscheinlich ist dies effizienter:
```
apply(A, 2, rep, n)
```
Wie ich schon vorher sagte, diese Methode führt nicht zum richtigen Ergebnis. Versuchen Sie es einfach selbst: A <- matrix(1:15, nrow=3); n <- 2; rbind(A,A); matrix(rep(A, n), ncol = ncol(A), byrow = TRUE) nicht das gleiche... edit: warum kann ich nicht erstellen, die Zeilenumbrüche in einem Kommentar?
Sorry, mein Fehler. Siehe das update meiner Antwort.
Danke, das ist schon eine Verbesserung. Ich bin noch auf der Suche, um noch schneller zu Lösungen, wenn. 😉

InformationsquelleAutor Sven Hohenstein
2

Gibt es auch auf diese Weise:
```
rep(1, n) %x% A
```
auch wenn Sie tun möchten ein "jede" version der Replikation, bei der jede Zeile der A wiederholt n mal dann ist es einfach: A %x% rep(1, n).

InformationsquelleAutor stofer
0

was über die Umwandlung in ein array, den Inhalt replizieren und erstellen Sie eine neue matrix mit der aktualisierten Anzahl der Zeilen?
```
A <- matrix(...)
n = 2 # just a test

a = as.integer(A)
multi.a = rep(a,n)
multi.A = matrix(multi.a,nrow=nrow(A)*n,byrow=T)
```
Ich habe gerade versucht, und es hat das gleiche problem wie die Antwort oben: dein Vorschlag hat leider nicht ergeben das richtige Ergebnis.

InformationsquelleAutor Valentin Ruano
0

Können Sie die Indizierung
```
A[rep(seq(nrow(A)), n), ]
```
InformationsquelleAutor konvas

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.