Ho un enorme (70 GB), una riga , file di testo e voglio sostituire una stringa (token) in esso. Voglio sostituire il token <unk>, con un altro token fittizio ( problema con i guanti ).

Ho provato sed:

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

ma il file di output corpus.txt.newha zero byte!

Ho anche provato a usare perl:

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

ma ho riscontrato un errore di memoria esaurita.

Per file più piccoli, funzionano entrambi i comandi precedenti.

Come posso sostituire una stringa è un tale file? Questa è una domanda correlata, ma nessuna delle risposte ha funzionato per me.

Modifica : che ne dici di dividere il file in blocchi di 10 GB (o altro) ciascuno e applicarlo sedsu ognuno di essi e poi unirli con cat? Ha senso? C'è una soluzione più elegante?

I soliti strumenti di elaborazione del testo non sono progettati per gestire linee che non rientrano nella RAM. Tendono a funzionare leggendo un record (una riga), manipolandolo e producendo il risultato, quindi procedendo al record successivo (riga).

Se c'è un carattere ASCII che appare frequentemente nel file e non appare in <unk>o <raw_unk>, allora puoi usarlo come separatore del record. Poiché la maggior parte degli strumenti non consente separatori di record personalizzati, scambia tra quel personaggio e le nuove righe. trelabora byte, non righe, quindi non si preoccupa di alcuna dimensione del record. Supponendo che funzioni ;:

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

Puoi anche ancorare il primo carattere del testo che stai cercando, supponendo che non sia ripetuto nel testo di ricerca e appaia abbastanza frequentemente. Se il file può iniziare con unk>, modifica il comando sed in sed '2,$ s/…per evitare una corrispondenza spuria.

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

In alternativa, usa l'ultimo carattere.

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

Si noti che questa tecnica presuppone che sed operi senza interruzioni su un file che non termina con una nuova riga, ovvero che elabora l'ultima riga parziale senza troncarla e senza aggiungere una nuova riga finale. Funziona con GNU sed. Se riesci a scegliere l'ultimo carattere del file come separatore del record, eviterai qualsiasi problema di portabilità.

Per un file così grande, una possibilità è Flex. Lascia che unk.lsia:

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

Quindi compilare ed eseguire:

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

Quindi non hai abbastanza memoria fisica (RAM) per contenere l'intero file in una volta, ma su un sistema a 64 bit hai abbastanza spazio di indirizzi virtuali per mappare l'intero file. I mapping virtuali possono essere utili come un semplice hack in casi come questo.

Le operazioni necessarie sono tutte incluse in Python. Esistono diverse sottigliezze fastidiose, ma evita di dover scrivere il codice C. In particolare, è necessario prestare attenzione per evitare di copiare il file in memoria, il che annullerebbe completamente il punto. Tra i lati positivi, si ottiene gratuitamente la segnalazione degli errori ("eccezioni" di 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):])

C'è replaceun'utilità nel pacchetto mariadb-server / mysql-server. Sostituisce stringhe semplici (non espressioni regolari) e, a differenza di grep / sed / awk, replacenon si preoccupa di \ne \0. Il consumo di memoria è costante con qualsiasi file di input (circa 400kb sulla mia macchina).

Naturalmente non è necessario eseguire un server mysql per replacepoterlo utilizzare , è solo impacchettato in quel modo in Fedora. Altre distribuzioni / sistemi operativi potrebbero averlo impacchettato separatamente.

Penso che la versione C potrebbe funzionare molto meglio:

#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;
}

EDIT: modificato in base ai suggerimenti dei commenti. Corretto anche bug con il modello <<unk>.

GNU greppuò mostrare l'offset delle corrispondenze nei file "binari", senza dover leggere intere righe in memoria. È quindi possibile utilizzare ddper leggere fino a questo offset, saltare la corrispondenza, quindi continuare a copiare dal file.

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"

Per velocità, ho diviso ddin una lettura grande di 1048576 blocchi e una lettura più piccola di 1 byte alla volta, ma questa operazione sarà ancora un po 'lenta su un file così grande. L' grepoutput è, ad esempio, 13977:<unk>e questo è diviso sui due punti dalla lettura in variabili offsete pattern. Dobbiamo tenere traccia posdi quanti byte sono già stati copiati dal file.

Ecco un'altra riga di comando UNIX che potrebbe funzionare meglio di altre opzioni, perché puoi "cercare" una "dimensione del blocco" che funzioni bene. Perché questo sia robusto devi sapere che hai almeno uno spazio in ogni X caratteri, dove X è la tua "dimensione del blocco" arbitraria. Nell'esempio seguente ho scelto una "dimensione del blocco" di 1024 caratteri.

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

Qui, fold prenderà fino a 1024 byte, ma la -s si assicura che si spezzi su uno spazio se ce n'è almeno uno dall'ultima interruzione.

Il comando sed è tuo e fa quello che ti aspetti.

Quindi il comando tr "aprirà" il file convertendo le nuove righe che sono state reinserite in nulla.

Dovresti provare a provare blocchi di dimensioni maggiori per vedere se funziona più velocemente. Invece di 1024, potresti provare 10240 e 102400 e 1048576 per l'opzione -w di fold.

Ecco un esempio suddiviso per ogni passaggio che converte tutte le N in minuscolo:

[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

Dovrai aggiungere una nuova riga alla fine del file se ne ha uno, perché il comando tr lo rimuoverà.

utilizzando perl

Gestire i propri buffer

È possibile utilizzare IO::Handle's setvbufper gestire i buffer predefiniti oppure è possibile gestire i propri buffer con sysreade syswrite. Controllare perldoc -f sysreade perldoc -f syswriteper ulteriori informazioni, essenzialmente saltano io bufferato.

Qui rotoliamo il nostro buffer IO, ma lo facciamo manualmente e arbitrariamente su 1024 byte. Apriamo anche il file per RW, quindi facciamo tutto sullo stesso FH in una volta.

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++;
}

Se hai intenzione di seguire questa strada

1. Assicurarsi <unk>e avere <raw_unk>la stessa dimensione di byte.
2. Potresti voler assicurarti che il nostro metodo bufferizzato non CHUNKSIZEsuperi il limite, se stai sostituendo più di 1 byte.

Potresti provare bbe ( editor di blocchi binari ), un " sedper file binari".

Ho avuto un buon successo usandolo su un file di testo da 7 EOLGB senza caratteri, sostituendo più occorrenze di una stringa con una di diversa lunghezza. Senza tentare di ottimizzare, ha prodotto un throughput di elaborazione medio di> 50 MB / s.

Con perl, potresti lavorare con record a lunghezza fissa come:

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

E spero che non ci saranno <unk>spanning su due di quei record da 100 MB.

Ecco un piccolo programma Go che esegue l'attività ( 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)
    }
}

Costruiscilo go build unk.goed eseguilo come ./unk <input >output.

MODIFICARE:

Siamo spiacenti, non ho letto che tutto è in una riga, quindi ho provato a leggere il file carattere per carattere ora.

EDIT II:

Applicata la stessa correzione del programma C.

Questo potrebbe essere eccessivo per un file da 70 GB e una semplice ricerca e sostituzione, ma il framework Hadoop MapReduce risolverà il tuo problema in questo momento senza alcun costo (scegli l'opzione 'Nodo singolo' quando lo configuri per eseguirlo localmente) - e può essere ridimensionato a capacità infinita in futuro senza la necessità di modificare il codice.

Il tutorial ufficiale su https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html utilizza Java (estremamente semplice) ma puoi trovare librerie client per Perl o qualunque lingua tu voglia usare.

Quindi, se in seguito ti accorgi che stai eseguendo operazioni più complesse su file di testo da 7000 GB e che devi farlo 100 volte al giorno, puoi distribuire il carico di lavoro su più nodi forniti o forniti automaticamente da un cloud- cluster Hadoop basato.

Tutti i suggerimenti precedenti richiedono la lettura dell'intero file e la scrittura dell'intero file. Questo non solo richiede molto tempo, ma richiede anche 70 GB di spazio libero.

1) Se avessi compreso correttamente il tuo caso specifico, sarebbe accettabile sostituire con qualche altra stringa della stessa lunghezza?

2a) Ci sono più ricorrenze? 2b) Se sì, sai quanti?

Sono sicuro che hai già risolto il problema di quest'anno e vorrei sapere quale soluzione hai usato.

Proporrei una soluzione (molto probabilmente in C) che legga i BLOCCHI del file alla ricerca di ciascuno della stringa tenendo conto del possibile passaggio di blocchi. Una volta trovato, sostituire la stringa con la lunghezza SAME alternata e scrivere solo quel BLOCK. Continuando per il numero noto di occorrenze o fino alla fine del file. Ciò richiederebbe solo il numero di occorrenze e al massimo il doppio (se ogni occorrenza fosse divisa tra 2 blocchi). Ciò non richiederebbe ulteriore spazio!

Se abbiamo un importo minimo di <unk>(come previsto dalla legge di Zipf),

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