Efficacement répliquer les matrices dans la R

J'ai une matrice et cherchez un moyen efficace pour répliquer il n fois (où n est le nombre d'observations dans le jeu de données). Par exemple, si j'ai une matrice A

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

puis j'ai envie d'une sortie de la forme

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

Évidemment, il existe de nombreuses façons de construire une telle matrice de grande taille, par exemple à l'aide d'un for boucle ou apply ou des fonctions similaires. Toutefois, l'appel à la "matrice de la réplication de la fonction" prend place dans le cœur de mon algorithme d'optimisation où il est appelé des dizaines de milliers de fois durant une exécution de mon programme. Par conséquent, les boucles, appliquez-type de fonctions et quelque chose de similaire qui ne sont pas assez efficaces. (Une telle solution serait fondamentalement signifie qu'une boucle sur n est effectuée à des dizaines de milliers de fois, ce qui est évidemment inefficace.) J'ai déjà essayé d'utiliser l'ordinaire rep de la fonction, mais n'ont pas trouvé une façon d'organiser la sortie de rep dans une matrice de format souhaité.

La solution
do.call("rbind", replicate(n, A, simplify=F))
est également trop inefficace, parce que rbind est utilisé trop souvent dans ce cas. (Puis, environ 30% de la durée totale d'utilisation de mon programme sont passé à effectuer les rbinds.)

Quelqu'un sait-il une meilleure solution?

rbind est seulement utilisé une fois dans le do.call façon. c'est la réplication, qui est probablement l'entraînant vers le bas.
Je l'ai testé avec Rprofet rbind a pris environ deux fois plus de temps que replicate. J'ai également été surpris par cela.

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

matrix r replication

Deux autres solutions:

La première est une modification de l'exemple de la question

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

La deuxième consiste à dérouler la matrice, la réplique, et remontage.

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

Depuis l'efficience est ce qui a été demandé, l'étalonnage est nécessaire

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)

qui donne:

                                                 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

De sorte que le plus rapide est le cru rbind appel, mais qui suppose n est fixe et connu à l'avance. Si n n'est pas fixée, le plus rapide est do.call("rbind", rep(list(A), n). Ils ont été pour une 3x5 et de matrice de 10 répétitions. Différentes tailles de matrices peut donner différents ordres.

EDIT:

Pour n=600, les résultats sont dans un ordre différent (en laissant l'explicite 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)

donnant

                                                 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

Si vous incluez l'explicite rbind version, il est légèrement plus rapide que la do.call("rbind", rep(list(A), n)) version, mais pas de beaucoup, et plus lent que le apply ou matrix versions. Donc une généralisation arbitraire n ne nécessite pas une perte de vitesse dans ce cas.

Wow, merci beaucoup! Cependant, mon petit test a montré que la matrice versions sont plus efficaces que les rbind appels pour les plus grands n, disons n = 600. Dans ce cas, la version avec le matrix(rep(t(...-appel a été plus efficace.

InformationsquelleAutor Brian Diggs

6

C'est probablement plus efficace:
```
apply(A, 2, rep, n)
```
- Comme je l'ai déjà dit avant, cette méthode ne permet pas d'obtenir le résultat correct. Il suffit de l'essayer vous-même: A <- matrix(1:15, nrow=3); n <- 2; rbind(A,A); matrix(rep(A, n), ncol = ncol(A), byrow = TRUE) pas la même chose... edit: pourquoi ne puis-je pas créer des retours à la ligne (dans un commentaire?
- Désolé, mon erreur. Voir la mise à jour de ma réponse.
- Merci, c'est déjà une amélioration. Je suis toujours à la recherche pour encore plus de solutions, si. 😉
InformationsquelleAutor Sven Hohenstein
2

Il y a aussi cette façon:
```
rep(1, n) %x% A
```
- aussi, si vous voulez faire un "chaque" version de la réplication où chaque ligne de A est répété n fois, puis il est tout simplement: A %x% rep(1, n).
InformationsquelleAutor stofer
0

que de le transformer en un tableau, de répliquer le contenu et créer une nouvelle matrice avec la mise à jour du nombre de lignes?
```
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)
```
- J'ai juste essayé et il a le même problème que la réponse ci-dessus: votre suggestion n'a malheureusement pas donné le résultat correct.
InformationsquelleAutor Valentin Ruano
0

Vous pouvez utiliser l'indexation
```
A[rep(seq(nrow(A)), n), ]
```
InformationsquelleAutor konvas

Vous devez vous connecter pour publier un commentaire.