voici un exemple qui utilise fread de data.table 1.8.7

les exemples viennent de la page d'aide à fread , avec les minuteries sur mon Windows XP Core 2 duo E8400.

library(data.table)
# Demo speedup
n=1e6
DT = data.table( a=sample(1:1000,n,replace=TRUE),
                 b=sample(1:1000,n,replace=TRUE),
                 c=rnorm(n),
                 d=sample(c("foo","bar","baz","qux","quux"),n,replace=TRUE),
                 e=rnorm(n),
                 f=sample(1:1000,n,replace=TRUE) )
DT[2,b:=NA_integer_]
DT[4,c:=NA_real_]
DT[3,d:=NA_character_]
DT[5,d:=""]
DT[2,e:=+Inf]
DT[3,e:=-Inf]

standard lire.tableau 1519150920"

write.table(DT,"test.csv",sep=",",row.names=FALSE,quote=FALSE)
cat("File size (MB):",round(file.info("test.csv")$size/1024^2),"\n")    
## File size (MB): 51 

system.time(DF1 <- read.csv("test.csv",stringsAsFactors=FALSE))        
##    user  system elapsed 
##   24.71    0.15   25.42
# second run will be faster
system.time(DF1 <- read.csv("test.csv",stringsAsFactors=FALSE))        
##    user  system elapsed 
##   17.85    0.07   17.98

lecture optimisée.tableau 1519150920"

system.time(DF2 <- read.table("test.csv",header=TRUE,sep=",",quote="",  
                          stringsAsFactors=FALSE,comment.char="",nrows=n,                   
                          colClasses=c("integer","integer","numeric",                        
                                       "character","numeric","integer")))


##    user  system elapsed 
##   10.20    0.03   10.32

fread

require(data.table)
system.time(DT <- fread("test.csv"))                                  
 ##    user  system elapsed 
##    3.12    0.01    3.22

sqldf

require(sqldf)

system.time(SQLDF <- read.csv.sql("test.csv",dbname=NULL))             

##    user  system elapsed 
##   12.49    0.09   12.69

# sqldf as on SO

f <- file("test.csv")
system.time(SQLf <- sqldf("select * from f", dbname = tempfile(), file.format = list(header = T, row.names = F)))

##    user  system elapsed 
##   10.21    0.47   10.73

ff / ffdf

 require(ff)

 system.time(FFDF <- read.csv.ffdf(file="test.csv",nrows=n))   
 ##    user  system elapsed 
 ##   10.85    0.10   10.99

en résumé:

##    user  system elapsed  Method
##   24.71    0.15   25.42  read.csv (first time)
##   17.85    0.07   17.98  read.csv (second time)
##   10.20    0.03   10.32  Optimized read.table
##    3.12    0.01    3.22  fread
##   12.49    0.09   12.69  sqldf
##   10.21    0.47   10.73  sqldf on SO
##   10.85    0.10   10.99  ffdf

je n'ai pas vu cette question initialement et posé une question similaire, quelques jours plus tard. Je vais retirer ma question précédente, mais j'ai pensé ajouter une réponse ici pour expliquer comment j'ai utilisé sqldf() pour faire ceci.

il y a eu petite discussion quant à la meilleure façon d'importer 2Go ou plus de données de texte dans un cadre de données R. Hier, j'ai écrit un post de blog à propos de l'utilisation sqldf() pour importer le les données dans SQLite comme une zone de transit, et puis le sucking de SQLite dans R. cela fonctionne vraiment bien pour moi. J'ai pu extraire 2 Go (3 colonnes, lignes 40mm) de données en moins de 5 minutes. Par contre, la commande read.csv a été exécutée toute la nuit et n'a jamais été exécutée.

Voici mon code de test:

configurer les données d'essai:

bigdf <- data.frame(dim=sample(letters, replace=T, 4e7), fact1=rnorm(4e7), fact2=rnorm(4e7, 20, 50))
write.csv(bigdf, 'bigdf.csv', quote = F)

j'ai redémarré R avant d'exécuter la routine d'importation suivante:

library(sqldf)
f <- file("bigdf.csv")
system.time(bigdf <- sqldf("select * from f", dbname = tempfile(), file.format = list(header = T, row.names = F)))

I laissez la ligne suivante fonctionner toute la nuit, mais il n'a jamais terminé:

system.time(big.df <- read.csv('bigdf.csv'))

étrangement, personne n'a répondu à la partie inférieure de la question pendant des années, même s'il s'agit d'une question importante -- data.frame s sont simplement des listes avec les bons attributs, donc si vous avez de grandes données, vous ne voulez pas utiliser as.data.frame ou similaire pour une liste. Il est beaucoup plus rapide de simplement "transformer" une liste en un cadre de données en place:

attr(df, "row.names") <- .set_row_names(length(df[[1]]))
class(df) <- "data.frame"

cela ne fait pas de copie des données de sorte qu'il est immédiat (contrairement à toutes les autres méthodes). Il suppose que vous avez déjà mis names() sur la liste en conséquence.

[comme pour le chargement de grandes données dans R -- personnellement, je les décharge par colonne dans des fichiers binaires et utilise readBin() - qui est de loin la méthode la plus rapide (autre que mmapping) et n'est limité que par la vitesse du disque. L'analyse des fichiers ASCII est en soi lente (même en C) par rapport aux données binaires.]

c'était auparavant demandé sur R-Help 151980920" , donc cela vaut la peine d'examiner.

Je ne sais pas si la mémoire est un problème ici, mais vous pourriez aussi voulez jeter un oeil à la HadoopStreaming package . Ce utilise Hadoop , qui est un MapReduce framework conçu pour traiter de grands ensembles de données. Pour cela, vous utiliserez la fonction hsTableReader. C'est un exemple (mais il a une courbe d'apprentissage pour apprendre Hadoop):

str <- "key1\t3.9\nkey1\t8.9\nkey1\t1.2\nkey1\t3.9\nkey1\t8.9\nkey1\t1.2\nkey2\t9.9\nkey2\"
cat(str)
cols = list(key='',val=0)
con <- textConnection(str, open = "r")
hsTableReader(con,cols,chunkSize=6,FUN=print,ignoreKey=TRUE)
close(con)

L'idée de base ici est de briser l'importation de données en morceaux. On pourrait même aller jusqu'à utiliser l'un des cadres parallèles (par exemple, à la neige) et exécuter le importer des données en parallèle en segmentant le fichier, mais très probablement pour de grands ensembles de données qui ne vous aideront pas car vous rencontrerez des contraintes de mémoire, c'est pourquoi map-reduce est une meilleure approche.

un petit point supplémentaire à mentionner. Si vous avez un fichier très volumineux, vous pouvez à la volée calculer le nombre de lignes (si aucun en-tête) en utilisant (où bedGraph est le nom de votre fichier dans votre répertoire de travail):

>numRow=as.integer(system(paste("wc -l", bedGraph, "| sed 's/[^0-9.]*\([0-9.]*\).*/\1/'"), intern=T))

vous pouvez alors l'utiliser dans read.csv , read.table ...

>system.time((BG=read.table(bedGraph, nrows=numRow, col.names=c('chr', 'start', 'end', 'score'),colClasses=c('character', rep('integer',3)))))
   user  system elapsed 
 25.877   0.887  26.752 
>object.size(BG)
203949432 bytes

souvent, je pense que c'est juste une bonne pratique de garder de plus grandes bases de données à l'intérieur d'une base de données (par exemple Postgres). Je n'utilise pas grand-chose de plus grand que (nrow * ncol) ncell = 10M, ce qui est assez petit, mais je trouve souvent que je veux créer et tenir des graphiques intensifs en mémoire seulement pendant que je recherche à partir de plusieurs bases de données. Dans le futur des ordinateurs portables de 32 Go, certains de ces types de problèmes de mémoire vont disparaître. Mais l'attrait d'utiliser une base de données pour tenir les données et ensuite l'utilisation de la mémoire de R pour le les résultats des requêtes et les graphiques qui en résultent peuvent encore être utiles. Certains avantages sont:

(1) Les données restent chargées dans votre base de données. Vous vous reconnectez simplement dans pgadmin aux bases de données que vous voulez quand vous rallumez votre ordinateur portable.

(2) Il est vrai que R peut effectuer beaucoup plus d'opérations de représentation graphique et statistique que SQL. Mais je pense que SQL est mieux conçu pour interroger de grandes quantités de données que R.

# Looking at Voter/Registrant Age by Decade

library(RPostgreSQL);library(lattice)

con <- dbConnect(PostgreSQL(), user= "postgres", password="password",
                 port="2345", host="localhost", dbname="WC2014_08_01_2014")

Decade_BD_1980_42 <- dbGetQuery(con,"Select PrecinctID,Count(PrecinctID),extract(DECADE from Birthdate) from voterdb where extract(DECADE from Birthdate)::numeric > 198 and PrecinctID in (Select * from LD42) Group By PrecinctID,date_part Order by Count DESC;")

Decade_RD_1980_42 <- dbGetQuery(con,"Select PrecinctID,Count(PrecinctID),extract(DECADE from RegistrationDate) from voterdb where extract(DECADE from RegistrationDate)::numeric > 198 and PrecinctID in (Select * from LD42) Group By PrecinctID,date_part Order by Count DESC;")

with(Decade_BD_1980_42,(barchart(~count | as.factor(precinctid))));
mtext("42LD Birthdays later than 1980 by Precinct",side=1,line=0)

with(Decade_RD_1980_42,(barchart(~count | as.factor(precinctid))));
mtext("42LD Registration Dates later than 1980 by Precinct",side=1,line=0)

au lieu de la mention conventionnelle.table I feel fread est une fonction plus rapide. Spécifier des attributs supplémentaires comme sélectionner seulement les colonnes requises, spécifier colclasses et string comme facteurs réduira le temps d'importer le fichier.

data_frame <- fread("filename.csv",sep=",",header=FALSE,stringsAsFactors=FALSE,select=c(1,4,5,6,7),colClasses=c("as.numeric","as.character","as.numeric","as.Date","as.Factor"))