Comment faire pour accélérer rbind?

Je suis censé pour télécharger un tableau à partir de MS-SQL server.

Le nombre de ligne est de plus de 6 millions d'. Le serveur ne peut pas revenir ensemble de données à la fois.

Alors, j'ai écrit un code qui télécharge 10 000 lignes à la fois. et, il lie des lignes de la boucle.

Supposer que getData() fonction renvoie un bloc de données contient 10000 lignes à la fois. (Pseudo-Code)

for(i in 1:600)
{
    tempValue <- getData()
    wannagetValue <- rbind(wannagetValue,tempValue)
    print(i)
}

Le problème est qu'il devient plus lent que le temps passe.

Je pense que l'utilisation rbind de cette manière n'est pas une bonne idée.

Tous les conseils seront très utiles. Je vous remercie à l'avance.

Si vous connaissez la taille de votre éventuel bloc de données va être alors il sera beaucoup plus rapide à pré-allouer et remplissez les valeurs que vous allez. Bien qu'il existe probablement une solution plus rapide à l'aide de différentes structures de données que quelqu'un post.
wannagetValue <- rbind(wannagetValue,getData()); . Qui pourrait accélérer un peu votre code...mais la question principale est de savoir, pourquoi autant de données?
Merci David! Vous m'avez sauvé.. Robert // je n'ai aucune idée~~ tout ce que je sais est qu'il y a de données de plus de 500 GO taille.
Vous faire réaliser que R stocke tout dans la mémoire, à droite? Si vous avez 500 GO de données, vous aurez besoin d'au moins autant de RAM, et idéalement deux fois plus.
Ensemble de données brutes dépassent 500 GO, mais il sera de 5~10 GO totla si elle stocke sous forme de données binaires. En outre, Chaque table contient 1~2 GO. Je peux le traiter séparément. Heureusement, mon ordinateur a 64 GO de mémoire DDR3 ECC RAM. Je ne pense pas que c'est pas assez. En passant, merci pour les conseils.

OriginalL'auteur Keith Park | 2013-10-31

Voici quelques options que je suis sûr que pourrait être mieux:

library(data.table)
library(microbenchmark)

#function to generate your data
getData <- function(){
  data.frame(x=rnorm(10000),y=rnorm(10000),z=rnorm(10000))
}

#using data table's rbindlist each iteration
fDT1 <- function(n){
  dat <- getData()
  for(i in 1:n){
    dat <- rbindlist(list(dat,getData()))
  }
  return(data.frame(dat))
}

#using data table's rbindlist all at once
fDT2 <- function(n){
  return(data.frame(rbindlist(lapply(1:n,function(x) getData()))))
}

#pre-allocating a data frame
fPre <- function(n){
  dat <- data.frame(x=rep(0,n*10000),y=rep(0,n*10000),z=rep(0,n*10000))
  j <- 1
  for(i in 1:n){
    dat[j:(j+10000-1),] <- getData()
    j <- j + 10000
  }
  return(dat)
}

#standard do.call rbind
f2 <- function(n){
  return(do.call(rbind,lapply(1:n,function(x) getData())))
}

#current approach
f <- function(n){
  dat <- getData()
  for(i in 1:n){
    dat <- rbind(dat,getData())
  }
  return(dat)
}

Comme vous pouvez le voir à l'aide de data.table's rbindlist() est une grande amélioration par rapport à la base de la R rbind() et il y a un grand avantage à ajouter les lignes à la fois au lieu de l'interaction, mais cela peut ne pas être possible si il y a des soucis de mémoire. Vous pouvez aussi noter que l'amélioration de la vitesse ne sont nulle part près linéaire en la taille des données augmente.

 > microbenchmark(fDT2(5),fDT1(5),fPre(5),f2(5),f(5),
+                fDT2(25),fDT1(25),fPre(25),f2(25),f(25),
+                fDT2(75),fDT1(75),fPre(75),f2(75),f(75),
+                times=10)
Unit: milliseconds
expr        min         lq     median         uq         max neval
fDT2(5)   18.31207   18.63969   24.09943   25.45590    72.01725    10
fDT1(5)   27.65459   29.25147   36.34158   77.79446    88.82556    10
fPre(5)   34.96257   39.39723   41.24445   43.30319    68.75897    10
f2(5)   30.85883   33.00292   36.29100   43.53619    93.15869    10
f(5)   87.40869   97.97500  134.50600  138.65354   147.67676    10
fDT2(25)   89.42274   99.39819  103.90944  146.44160   156.01653    10
fDT1(25)  224.65745  229.78129  261.52388  280.85499   300.93488    10
fPre(25)  371.12569  412.79876  431.80571  485.37727  1046.96923    10
f2(25)  221.03669  252.08998  265.17357  271.82414   281.47096    10
f(25) 1446.32145 1481.01998 1491.59203 1634.99936  1849.00590    10
fDT2(75)  326.66743  334.15669  367.83848  467.85480   520.27142    10
fDT1(75) 1749.83842 1882.27091 2066.95241 2278.55589  2419.07205    10
fPre(75) 3701.16220 3968.64643 4162.70585 4234.39716  4356.09462    10
f2(75) 1174.47546 1183.98860 1314.64585 1421.09483  1537.42903    10
f(75) 9139.36935 9349.24412 9510.90888 9977.24621 10861.51206    10

+1 - s'il vous plaît ajouter do.call(rbind, lapply(1:25,function(...) getData()))
Bonne idée, merci.
Merci beaucoup pour les informations détaillées.~ cela m'aide beaucoup.

OriginalL'auteur David

4

Comme il a été souligné ci-dessus, R stocke tous ses objets dans la mémoire RAM par défaut, donc avec cette quantité de données, vous allez rencontrer quelques problèmes.

Deux choses que j'aimerais ajouter:
1) en règle générale, si vous ne voulez pas utiliser de données.table, vous pouvez utiliser le rbind.fill fonction de Hadley est plyr paquet, ce qui est assez rapide, trop. Jamais utilisation rbind la façon dont vous l'avez fait ci-dessus, en un "pour" en boucle, en ajoutant chaque ligne séparément. C'forces R pour faire une copie de la trame de données de l'objet à chaque fois que vous ajoutez une ligne, et c'est lent.

2) travailler avec le plus-que-RAM de données avec R, jetez un oeil à la section Grande capacité de mémoire et de capacité de mémoire de données à http://cran.r-project.org/web/views/HighPerformanceComputing.html, peut-être le bigmemory emballage est ce que vous avez besoin.

Ensemble de données brutes dépassent 500 GO, mais il sera de 5~10 GO total si elle stocke sous forme de données binaires. En outre, Chaque table contient 1~2 GO. Je peux le traiter séparément. Heureusement, mon ordinateur a 64 GO de mémoire DDR3 ECC RAM. Je ne pense pas que c'est pas assez. En passant, merci pour les conseils.
Cette question est un peu vieux, mais j'ai toujours trouvé ça en cherchant une solution aujourd'hui, je tiens à ajouter que Hadley, la plus récente de l' dplyr paquet a la fonction bind_rows qui est analogue à rbind.fill. Je comparés et il fonctionne sur 1000x plus rapide que do.call('rbind', ...) sur ma machine. Voir cette question.

OriginalL'auteur coanil
0

Peut-être que vous pourriez faire SELECT COUNT(*) FROM table_name WHERE ... et puis préallouer de l'espace pour votre bloc de données.

En fait, je ne pense pas que l'interrogation de la base de données par 10k lignes est une bonne idée. Essayez d'éviter que par l'exportation des données vers un disque local et de les lire à partir de là. Il permettra d'améliorer la vitesse. Le stockage n'est pas cher, la bande passante du réseau et de la mémoire ne sont pas.

OriginalL'auteur Kendrick Fong

Vous devez vous connecter pour publier un commentaire.