Tengo un archivo de texto enorme (70 GB), una línea y quiero reemplazar una cadena (token). Quiero reemplazar el token <unk>, con otro token ficticio ( problema de guantes ).

Lo intenté sed:

sed 's/<unk>/<raw_unk>/g' < corpus.txt > corpus.txt.new

¡pero el archivo de salida corpus.txt.newtiene cero bytes!

También intenté usar perl:

perl -pe 's/<unk>/<raw_unk>/g' < corpus.txt > corpus.txt.new

pero recibí un error de falta de memoria.

Para archivos más pequeños, funcionan los dos comandos anteriores.

¿Cómo puedo reemplazar una cadena es un archivo? Esta es una pregunta relacionada, pero ninguna de las respuestas funcionó para mí.

Editar : ¿Qué hay de dividir el archivo en trozos de 10 GB (o lo que sea) cada uno y aplicarlo seden cada uno de ellos y luego fusionarlos cat? ¿Tiene sentido? ¿Hay una solución más elegante?

Las herramientas habituales de procesamiento de texto no están diseñadas para manejar líneas que no caben en la RAM. Tienden a funcionar leyendo un registro (una línea), manipulándolo y generando el resultado, luego continúan con el siguiente registro (línea).

Si hay un carácter ASCII que aparece con frecuencia en el archivo y no aparece en <unk>o <raw_unk>, puede usarlo como separador de registros. Como la mayoría de las herramientas no permiten separadores de registros personalizados, cambie entre ese carácter y las nuevas líneas. trprocesa bytes, no líneas, por lo que no le importa ningún tamaño de registro. Suponiendo que ;funciona:

<corpus.txt tr '\n;' ';\n' |
sed 's/<unk>/<raw_unk>/g' |
tr '\n;' ';\n' >corpus.txt.new

También puede anclar en el primer carácter del texto que está buscando, suponiendo que no se repita en el texto de búsqueda y que aparezca con suficiente frecuencia. Si el archivo puede comenzar con unk>, cambie el comando sed sed '2,$ s/…para evitar una coincidencia espuria.

<corpus.txt tr '\n<' '<\n' |
sed 's/^unk>/raw_unk>/g' |
tr '\n<' '<\n' >corpus.txt.new

Alternativamente, use el último personaje.

<corpus.txt tr '\n>' '>\n' |
sed 's/<unk$/<raw_unk/g' |
tr '\n>' '>\n' >corpus.txt.new

Tenga en cuenta que esta técnica supone que sed opera sin problemas en un archivo que no termina con una nueva línea, es decir, que procesa la última línea parcial sin truncarla y sin agregar una nueva línea final. Funciona con GNU sed. Si puede elegir el último carácter del archivo como separador de registros, evitará cualquier problema de portabilidad.

Para un archivo tan grande, una posibilidad es Flex. Dejar unk.lser:

%%
\<unk\>     printf("<raw_unk>");  
%%

Luego compila y ejecuta:

$ flex -o unk.c  unk.l
$ cc -o unk -O2 unk.c -lfl
$ unk < corpus.txt > corpus.txt.new

Por lo tanto, no tiene suficiente memoria física (RAM) para contener todo el archivo a la vez, pero en un sistema de 64 bits tiene suficiente espacio de direcciones virtuales para mapear todo el archivo. Las asignaciones virtuales pueden ser útiles como un simple hack en casos como este.

Todas las operaciones necesarias están incluidas en Python. Hay varias sutilezas molestas, pero evita tener que escribir código C. En particular, se debe tener cuidado para evitar copiar el archivo en la memoria, lo que anularía completamente el punto. En el lado positivo, obtienes informes de errores de forma gratuita ("excepciones" de Python) :).

#!/usr/bin/python3
# This script takes input from stdin
# (but it must be a regular file, to support mapping it),
# and writes the result to stdout.

search = b'<unk>'
replace = b'<raw_unk>'


import sys
import os
import mmap

# sys.stdout requires str, but we want to write bytes
out_bytes = sys.stdout.buffer

mem = mmap.mmap(sys.stdin.fileno(), 0, access=mmap.ACCESS_READ)
i = mem.find(search)
if i < 0:
    sys.exit("Search string not found")

# mmap object subscripts to bytes (making a copy)
# memoryview object subscripts to a memoryview object
# (it implements the buffer protocol).
view = memoryview(mem)

out_bytes.write(view[:i])
out_bytes.write(replace)
out_bytes.write(view[i+len(search):])

Hay una replaceutilidad en el paquete mariadb-server / mysql-server. Reemplaza cadenas simples (no expresiones regulares) y, a diferencia de grep / sed / awk, replaceno le importa \ny \0. El consumo de memoria es constante con cualquier archivo de entrada (aproximadamente 400 kb en mi máquina).

Por supuesto, no necesita ejecutar un servidor mysql para usarlo replace, solo está empaquetado de esa manera en Fedora. Otras distribuciones / sistemas operativos pueden tenerlo empaquetado por separado.

Creo que la versión C podría funcionar mucho mejor:

#include <stdio.h>
#include <string.h>

#define PAT_LEN 5

int main()
{
    /* note this is not a general solution. In particular the pattern
     * must not have a repeated sequence at the start, so <unk> is fine
     * but aardvark is not, because it starts with "a" repeated, and ababc
     * is not because it starts with "ab" repeated. */
    char pattern[] = "<unk>";          /* set PAT_LEN to length of this */
    char replacement[] = "<raw_unk>"; 
    int c;
    int i, j;

    for (i = 0; (c = getchar()) != EOF;) {
        if (c == pattern[i]) {
            i++;
            if (i == PAT_LEN) {
                printf("%s", replacement);
                i = 0;
            }
        } else {
            if (i > 0) {
                for (j = 0; j < i; j++) {
                    putchar(pattern[j]);
                }
                i = 0;
            }
            if (c == pattern[0]) {
                i = 1;
            } else {
                putchar(c);
            }
        }
    }
    /* TODO: fix up end of file if it ends with a part of pattern */
    return 0;
}

EDITAR: modificado de acuerdo con las sugerencias de los comentarios. También se corrigió un error con el patrón <<unk>.

GNU greppuede mostrarle el desplazamiento de coincidencias en archivos "binarios", sin tener que leer líneas completas en la memoria. Luego puede usar ddpara leer hasta este desplazamiento, omitir la coincidencia y luego continuar copiando del archivo.

file=...
newfile=...
replace='<raw_unk>'
grep -o -b -a -F '<unk>' <"$file" |
(   pos=0
    while IFS=$IFS: read offset pattern
    do size=${#pattern}
       let skip=offset-pos
       let big=skip/1048576
       let skip=skip-big*1048576
       dd bs=1048576 count=$big <&3
       dd bs=1 count=$skip <&3
       dd bs=1 count=$size of=/dev/null <&3
       printf "%s" "$replace"
       let pos=offset+size
    done
    cat <&3
) 3<"$file" >"$newfile"

En cuanto a la velocidad, la he dividido dden una gran lectura de tamaño de bloque 1048576 y una lectura más pequeña de 1 byte a la vez, pero esta operación aún será un poco lenta en un archivo tan grande. El grepresultado es, por ejemplo, 13977:<unk>y esto se divide en los dos puntos por la lectura en variables offsety pattern. Tenemos que hacer un seguimiento posde cuántos bytes ya se han copiado del archivo.

Aquí hay otra línea de comando UNIX única que podría funcionar mejor que otras opciones, porque puede "buscar" un "tamaño de bloque" que funcione bien. Para que esto sea robusto, debe saber que tiene al menos un espacio en cada X caracteres, donde X es su "tamaño de bloque" arbitrario. En el siguiente ejemplo, he elegido un "tamaño de bloque" de 1024 caracteres.

fold -w 1024 -s corpus.txt | sed 's/<unk>/<raw_unk>/g' | tr '/n' '/0'

Aquí, el plegado capturará hasta 1024 bytes, pero el -s se asegura de que se rompa en un espacio si hay al menos uno desde el último salto.

El comando sed es tuyo y hace lo que esperas.

Luego, el comando tr "desplegará" el archivo convirtiendo las nuevas líneas que se insertaron de nuevo en nada.

Debería considerar probar tamaños de bloque más grandes para ver si funciona más rápido. En lugar de 1024, puede probar 10240 y 102400 y 1048576 para la opción -w de plegar.

Aquí hay un ejemplo desglosado por cada paso que convierte todas las N en minúsculas:

[root@alpha ~]# cat mailtest.txt
test XJS C4JD QADN1 NSBN3 2IDNEN GTUBE STANDARD ANTI UBE-TEST EMAIL*C.34X test

[root@alpha ~]# fold -w 20 -s mailtest.txt
test XJS C4JD QADN1
NSBN3 2IDNEN GTUBE
STANDARD ANTI
UBE-TEST
EMAIL*C.34X test

[root@alpha ~]# fold -w 20 -s mailtest.txt | sed 's/N/n/g'
test XJS C4JD QADn1
nSBn3 2IDnEn GTUBE
STAnDARD AnTI
UBE-TEST
EMAIL*C.34X test

[root@alpha ~]# fold -w 20 -s mailtest.txt | sed 's/N/n/g' | tr '\n' '\0'
test XJS C4JD QADn1 nSBn3 2IDnEn GTUBE STAnDARD AnTI UBE-TEST EMAIL*C.34X test

Tendrá que agregar una nueva línea al final del archivo si tiene una, porque el comando tr lo eliminará.

Utilizando perl

Administrar tus propios buffers

Puede usar IO::Handle's setvbufpara administrar las memorias intermedias predeterminadas, o puede administrar sus propias memorias intermedias con sysready syswrite. Compruebe perldoc -f sysready perldoc -f syswritepara obtener más información, esencialmente omiten io almacenado en el búfer.

Aquí hacemos rodar nuestro propio buffer IO, pero lo hacemos de forma manual y arbitraria en 1024 bytes. También abrimos el archivo para RW, así que lo hacemos todo en el mismo FH a la vez.

use strict;
use warnings;
use Fcntl qw(:flock O_RDWR);
use autodie;
use bytes;

use constant CHUNK_SIZE => 1024 * 32;

sysopen my $fh, 'file', O_RDWR;
flock($fh, LOCK_EX);

my $chunk = 1;
while ( sysread $fh, my $bytes, CHUNK_SIZE * $chunk ) {
  if ( $bytes =~ s/<unk>/<raw_unk>/g ) {
    seek( $fh, ($chunk-1)* CHUNK_SIZE, 0 );
    syswrite( $fh, $bytes, 1024);
    seek( $fh, $chunk * CHUNK_SIZE, 0 );
  }
  $chunk++;
}

Si vas a ir por esta ruta

1. Asegúrese <unk>y <raw_unk>son el mismo tamaño en bytes.
2. Es posible que desee asegurarse de que nuestro método protegido no cruce el CHUNKSIZElímite, si está reemplazando más de 1 byte.

Puede probar bbe ( editor de bloques binarios ), un " sedpara archivos binarios".

Tuve un buen éxito al usarlo en un archivo de texto de 7GB sin EOLcaracteres, reemplazando múltiples ocurrencias de una cadena con una de diferente longitud. Sin intentar ninguna optimización, dio un rendimiento de procesamiento promedio de> 50 MB / s.

Con perl, podría trabajar con registros de longitud fija como:

perl -pe 'BEGIN{$/=\1e8}
          s/<unk>/<raw_unk>/g' < corpus.txt > corpus.txt.new

Y espero que no haya <unk>más de dos de esos registros de 100 MB.

Aquí hay un pequeño programa Go que realiza la tarea ( unk.go):

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
)

func main() {
    const (
        pattern     = "<unk>"
        replacement = "<raw_unk>"
    )
    var match int
    var char rune
    scanner := bufio.NewScanner(os.Stdin)
    scanner.Split(bufio.ScanRunes)
    for scanner.Scan() {
        char = rune(scanner.Text()[0])
        if char == []rune(pattern)[match] {
            match++
            if match == len(pattern) {
                fmt.Print(replacement)
                match = 0
            }
        } else {
            if match > 0 {
                fmt.Print(string(pattern[:match]))
                match = 0
            }
            if char == rune(pattern[0]) {
                match = 1
            } else {
                fmt.Print(string(char))
            }
        }
    }
    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }
}

Simplemente compílalo go build unk.goy ejecútalo como ./unk <input >output.

EDITAR:

Lo siento, no leí que todo está en una línea, así que intenté leer el archivo carácter por carácter ahora.

EDITAR II:

Se aplicó la misma corrección que al programa C.

Esto puede ser excesivo para un archivo de 70GB y una simple búsqueda y reemplazo, pero el marco Hadoop MapReduce resolvería su problema en este momento sin costo alguno (elija la opción 'Nodo único' cuando lo configure para ejecutarlo localmente), y puede ser escalado a capacidad infinita en el futuro sin la necesidad de modificar su código.

El tutorial oficial en https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html usa Java (extremadamente simple) pero puede encontrar bibliotecas de clientes para Perl o cualquier idioma que quieras usar.

Entonces, si más adelante descubre que está realizando operaciones más complejas en archivos de texto de 7000 GB, y que tiene que hacer esto 100 veces al día, puede distribuir la carga de trabajo en varios nodos que aprovisiona o que se aprovisionan automáticamente para usted en la nube. basado en clúster Hadoop.

Todas las sugerencias anteriores requieren leer el archivo completo y escribir todo el archivo. Esto no solo lleva mucho tiempo, sino que también requiere 70 GB de espacio libre.

1) Si entiendo su caso específico correctamente, ¿sería aceptable reemplazar con alguna otra cadena de la MISMA longitud?

2a) ¿Hay múltiples ocurrencias? 2b) Si es así, ¿sabes cuántos?

Estoy seguro de que ya resolvió este problema de más de un año y me gustaría saber qué solución utilizó.

Propondría una solución (muy probablemente en C) que leería los BLOQUES del archivo buscando cada cadena para tener en cuenta el posible cruce de bloques. Una vez encontrado, reemplace la cadena con la MISMA longitud alternativa y escriba solo ese BLOQUE. Continuando por el número conocido de ocurrencias o hasta el final del archivo. Esto requeriría tan pocas escrituras de número de ocurrencias y, como máximo, el doble (si cada ocurrencia se dividiera entre 2 bloques). ¡Esto no requeriría espacio adicional!

Si tenemos una cantidad mínima de <unk>(como lo espera la ley de Zipf),

awk -v RS="<unk>" -v ORS="<raw_unk>" 1