forma más rápida de copiar las primeras líneas X de un archivo a otro dentro de R?(multiplataforma)

io large-files

Question

No puedo cargar el archivo en la RAM (suponiendo que un usuario pueda querer los primeros mil millones de un archivo con diez mil millones de registros)

esta es mi solución, pero creo que tiene que haber una manera más rápida?

Gracias

# specified by the user
infile <- "/some/big/file.txt"
outfile <- "/some/smaller/file.txt"
num_lines <- 1000
# my attempt
incon <- file( infile , "r")
outcon <- file( outfile , "w")
for ( i in seq( num_lines ) ){
line <- readLines( incon , 1 )
writeLines( line , outcon )
}
close( incon )
close( outcon )

Answer 1

Me gustan las tuberías, ya que podemos usar otras herramientas. Y convenientemente, la interfaz de conexiones (realmente excelente) en R lo admite:

## scratch file
filename <- "foo.txt"
## create a file, no header or rownames for simplicity
write.table(1:50, file=filename, col.names=FALSE, row.names=FALSE)
## sed command: print from first address to second, here 4 to 7
## the -n suppresses output unless selected
cmd <- paste0("sed -n -e ''4,7p'' ", filename)
##print(cmd) # to debug if needed
## we use the cmd inside pipe() as if it was file access so
## all other options to read.csv (or read.table) are available too
val <- read.csv(pipe(cmd), header=FALSE, col.names="selectedRows")
print(val, row.names=FALSE)
## clean up
unlink(filename)

Si ejecutamos esto, obtenemos las filas cuatro a siete como se esperaba:

edd@max:/tmp$ r piper.R
selectedRows
4
5
6
7
edd@max:/tmp$ 

Tenga en cuenta que nuestro uso de sed no hizo suposiciones sobre las estructuras de archivos, además de asumir

• archivo de texto "ascii" estándar para leer en modo texto
• terminaciones de línea CR / LF estándar como ''separadores de registros''

Si asumió archivos binarios con diferentes separadores de registros, podríamos sugerir soluciones diferentes.

También tenga en cuenta que controla el comando pasado a las funciones pipe() . Por lo tanto, si desea las filas 1000004 a 1000007, el uso es exactamente el mismo: solo debe dar la primera y la última fila (de cada segmento, puede haber varias). Y en lugar de read.csv() su readLines() podría usarse igualmente bien.

Por último, sed está disponible en todas partes y, si la memoria sirve, también forma parte de Rtools. La funcionalidad básica de filtrado también se puede obtener con Perl o una serie de otras herramientas.

Answer 2

Normalmente acelero esos bucles leyendo y escribiendo en trozos de, digamos, 1000 líneas. Si num_lines es un múltiplo de 1000, el código se convierte en:

# specified by the user
infile <- "/some/big/file.txt"
outfile <- "/some/smaller/file.txt"
num_lines <- 1000000
# my attempt
incon <- file( infile, "r")
outcon <- file( outfile, "w")
step1 = 1000
nsteps = ceiling(num_lines/step1)
for ( i in 1:nsteps ){
line <- readLines( incon, step1 )
writeLines( line, outcon )
}
close( incon )
close( outcon )

Answer 3

intenta usar

line<-read.csv(infile,nrow=1000)
write(line,file=outfile,append=T)

Answer 4

Puede usar ff::read.table.ffdf para esto. Almacena los datos en el disco duro y no usa ninguna RAM.

library(ff)
infile <- read.table.ffdf(file = "/some/big/file.txt")

Básicamente, puede utilizar la función anterior de la misma manera que base::read.table con la diferencia de que el objeto resultante se almacenará en el disco duro.

También puede usar el argumento nrow y cargar una cantidad específica de filas. La documentación está aquí si quieres leer. Una vez que haya leído el archivo, puede subconjuntar las filas específicas que necesita e incluso convertirlas a data.frames de data.frames si pueden caber en la RAM.

También hay una función write.table.ffdf que le permitirá escribir un objeto ffdf (resultante de read.table.ffdf ) que facilitará aún más el proceso.

Como ejemplo de cómo usar read.table.ffdf (o read.delim.ffdf que es más o menos lo mismo) vea lo siguiente:

#writting a file on my current directory
#note that there is no standard number of columns
sink(file=''test.txt'')
cat(''foo , foo, foo/n'')
cat(''foo, foo/n'')
cat(''bar bar , bar/n'')
sink()
#read it with read.delim.ffdf or read.table.ffdf
read.delim.ffdf(file=''test.txt'', sep=''/n'', header=F)

Salida:

ffdf (all open) dim=c(3,1), dimorder=c(1,2) row.names=NULL
ffdf virtual mapping
PhysicalName VirtualVmode PhysicalVmode AsIs VirtualIsMatrix PhysicalIsMatrix PhysicalElementNo PhysicalFirstCol PhysicalLastCol PhysicalIsOpen
V1 V1 integer integer FALSE FALSE FALSE 1 1 1 TRUE
ffdf data
V1
1 foo , foo, foo
2 foo, foo
3 bar bar , bar 

Si está utilizando un archivo txt, esta es una solución general ya que cada línea terminará con un carácter /n .

Answer 5

El sistema operativo es el mejor nivel para realizar grandes manipulaciones de archivos. Esto es rápido y viene con un punto de referencia (que parece importante, dado que el afiche preguntó por un método más rápido):

# create test file in shell
echo "hello
world" > file.txt
for i in {1..29}; do cat file.txt file.txt > file2.txt && mv file2.txt file.txt; done
wc -l file.txt
# about a billion rows

Esto toma unos segundos para miles de millones de filas. Cambia de 29 a 32 para obtener unos diez mil millones.

Luego, en R, usando diez millones de filas de los mil millones (cientos de millones de forma demasiado lenta para compararla con la solución del póster)

# in R, copy first ten million rows of the billion
system.time(
system("head -n 10000000 file.txt > out.txt")
)
# posters solution
system.time({
infile <- "file.txt"
outfile <- "out.txt"
num_lines <- 1e7
incon <- file( infile , "r")
outcon <- file( outfile , "w")
for ( i in seq( num_lines )) {
line <- readLines( incon , 1 )
writeLines( line , outcon )
}
close( incon )
close( outcon )
})

Y los resultados en un MacBook Pro de rango medio, hace un par de años.

Rscript head.R
user system elapsed
1.349 0.164 1.581
user system elapsed
620.665 3.614 628.260

Estaría interesado en ver qué tan rápido son las otras soluciones.

Answer 6

La respuesta "correcta" o la mejor para esto sería usar un lenguaje que funcione mucho más fácilmente con Filehandles. Por ejemplo, aunque perl es un lenguaje feo de muchas maneras, aquí es donde brilla. Python también puede hacer esto muy bien, de una manera más detallada.

Sin embargo, usted ha declarado explícitamente que quiere cosas en R. En primer lugar, supondré que esto podría no ser un CSV u otro archivo plano delimitado.

Use el readr la biblioteca. Dentro de esa biblioteca, use read_lines() . Algo así (primero, obtenga el n. ° de líneas en todo el archivo, usando algo como lo que se muestra aquí ):

library(readr)
# specified by the user
infile <- "/some/big/file.txt"
outfile <- "/some/smaller/file.txt"
num_lines <- 1000
# readr attempt
# num_lines_tot is found via the method shown in the link above
num_loops <- ceiling(num_lines_tot / num_lines)
incon <- file( infile , "r")
outcon <- file( outfile , "w")
for ( i in seq(num_loops) ){
lines <- read_lines(incon, skip= (i - 1) * num_lines,
n_max = num_lines)
writeLines( lines , outcon )
}
close( incon )
close( outcon )

Algunas cosas a tener en cuenta:

1. No hay una manera agradable y conveniente de escribir en el readr la biblioteca que sea tan genérico como parezca desear. (Hay, por ejemplo, write_delim , pero no especificó delimitado).
2. Toda la información que está en las encarnaciones previas del "outfile" se perderá. No estoy seguro de si pretendía abrir "outfile" en el modo de agregar ( "a" ), pero sospecho que sería útil.
3. He encontrado que cuando trabajo con archivos de gran tamaño como este, a menudo querré filtrar los datos, al abrirlos así. Hacer la copia simple parece extraño. Tal vez quieres hacer más?
4. Si tenía un archivo delimitado, querría ver read_csv o read_delim dentro del paquete readr .

Answer 7

Pruebe la utilidad principal. Debe estar disponible en todos los sistemas operativos compatibles con R (en Windows se supone que tiene Rtools instalados y que el directorio Rtools bin está en su ruta). Por ejemplo, para copiar las primeras 100 líneas de in.dat a out.dat:

shell("head -n 100 in.dat > out.dat")

Answer 8

Solución C ++

No es demasiado difícil escribir algún código de C ++ para esto:

#include <fstream>
#include <R.h>
#include <Rdefines.h>
extern "C" {
// [[Rcpp::export]]
SEXP dump_n_lines(SEXP rin, SEXP rout, SEXP rn) {
// no checks on types and size
std::ifstream strin(CHAR(STRING_ELT(rin, 0)));
std::ofstream strout(CHAR(STRING_ELT(rout, 0)));
int N = INTEGER(rn)[0];
int n = 0;
while (strin && n < N) {
char c = strin.get();
if (c == ''/n'') ++n;
strout.put(c);
}
strin.close();
strout.close();
return R_NilValue;
}
}

Cuando se guarda como su yourfile.cpp , puede hacer

Rcpp::sourceCpp(''yourfile.cpp'')

Desde RStudio no tienes que cargar nada. En la consola, deberás cargar Rcpp. Probablemente tengas que instalar Rtools en Windows.

R-code más eficiente

Al leer bloques más grandes en lugar de líneas simples, su código también se acelerará:

dump_n_lines2 <- function(infile, outfile, num_lines, block_size = 1E6) {
incon <- file( infile , "r")
outcon <- file( outfile , "w")
remain <- num_lines
while (remain > 0) {
size <- min(remain, block_size)
lines <- readLines(incon , n = size)
writeLines(lines , outcon)
# check for eof:
if (length(lines) < size) break
remain <- remain - size
}
close( incon )
close( outcon )
}

Punto de referencia

lines <- "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean commodo
imperdiet nunc, vel ultricies felis tincidunt sit amet. Aliquam id nulla eu mi
luctus vestibulum ac at leo. Integer ultrices, mi sit amet laoreet dignissim,
orci ligula laoreet diam, id elementum lorem enim in metus. Quisque orci neque,
vulputate ultrices ornare ac, interdum nec nunc. Suspendisse iaculis varius
dapibus. Donec eget placerat est, ac iaculis ipsum. Pellentesque rhoncus
maximus ipsum in hendrerit. Donec finibus posuere libero, vitae semper neque
faucibus at. Proin sagittis lacus ut augue sagittis pulvinar. Nulla fermentum
interdum orci, sed imperdiet nibh. Aliquam tincidunt turpis sit amet elementum
porttitor. Aliquam lectus dui, dapibus ut consectetur id, mollis quis magna.
Donec dapibus ac magna id bibendum."
lines <- rep(lines, 1E6)
writeLines(lines, con = "big.txt")
infile <- "big.txt"
outfile <- "small.txt"
num_lines <- 1E6L
library(microbenchmark)
microbenchmark(
solution0(infile, outfile, num_lines),
dump_n_lines2(infile, outfile, num_lines),
dump_n_lines(infile, outfile, num_lines)
)

Resultados en (solución0 es la solución original de OP):

Unit: seconds
expr min lq mean median uq max neval cld
solution0(infile, outfile, num_lines) 11.523184 12.394079 12.635808 12.600581 12.904857 13.792251 100 c
dump_n_lines2(infile, outfile, num_lines) 6.745558 7.666935 7.926873 7.849393 8.297805 9.178277 100 b
dump_n_lines(infile, outfile, num_lines) 1.852281 2.411066 2.776543 2.844098 2.965970 4.081520 100 a 

La solución de c ++ probablemente puede acelerarse leyendo en grandes bloques de datos a la vez. Sin embargo, esto hará que el código sea mucho más complejo. A menos que esto sea algo que tendría que hacer de forma regular, probablemente me quedaría con la solución R pura.

Observación : cuando sus datos son tabulares, puede usar mi paquete LaF para leer líneas y columnas arbitrarias de su conjunto de datos sin tener que leer todos los datos en la memoria.