Ich habe eine riesige (70 GB), einzeilige Textdatei und möchte eine Zeichenfolge (Token) ersetzen. Ich möchte das Token <unk>durch ein anderes Dummy-Token ersetzen ( Handschuhproblem ).

Ich habe versucht sed:

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

aber die ausgabedatei corpus.txt.newhat null bytes!

Ich habe auch versucht mit Perl:

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

Aber ich habe einen Speicherfehler.

Bei kleineren Dateien funktionieren beide oben genannten Befehle.

Wie kann ich einen String ersetzen, der eine solche Datei ist? Dies ist eine verwandte Frage, aber keine der Antworten hat für mich funktioniert.

Bearbeiten : Wie wäre es, wenn Sie die Datei in Stücke von jeweils 10 GB (oder was auch immer) aufteilen und sedauf jedes einzelne anwenden und sie dann zusammenführen cat? Ist das sinnvoll? Gibt es eine elegantere Lösung?

Die üblichen Textverarbeitungstools sind nicht für die Verarbeitung von Zeilen konzipiert, die nicht in den Arbeitsspeicher passen. Sie arbeiten in der Regel, indem sie einen Datensatz (eine Zeile) lesen, bearbeiten, das Ergebnis ausgeben und dann mit dem nächsten Datensatz (Zeile) fortfahren.

Wenn ein ASCII-Zeichen in der Datei häufig vorkommt und nicht in <unk>oder angezeigt wird <raw_unk>, können Sie es als Datensatztrennzeichen verwenden. Da die meisten Tools keine benutzerdefinierten Datensatztrennzeichen zulassen, wechseln Sie zwischen diesem Zeichen und Zeilenumbrüchen. trverarbeitet Bytes, keine Zeilen, daher ist es egal, wie groß der Datensatz ist. Angenommen, das ;funktioniert:

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

Sie können auch das erste Zeichen des gesuchten Texts ankern, vorausgesetzt, es wird im Suchtext nicht wiederholt und es wird häufig genug angezeigt. Wenn die Datei möglicherweise mit beginnt unk>, ändern Sie den Befehl sed in sed '2,$ s/…, um eine falsche Übereinstimmung zu vermeiden.

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

Alternativ können Sie auch das letzte Zeichen verwenden.

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

Beachten Sie, dass diese Technik davon ausgeht, dass sed nahtlos mit einer Datei arbeitet, die nicht mit einem Zeilenumbruch endet, dh, dass sie die letzte Teilzeile verarbeitet, ohne sie abzuschneiden und ohne einen abschließenden Zeilenumbruch anzufügen. Es funktioniert mit GNU sed. Wenn Sie das letzte Zeichen der Datei als Datensatztrennzeichen auswählen können, vermeiden Sie Portabilitätsprobleme.

Eine Möglichkeit für eine so große Datei ist Flex. Sei unk.l:

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

Dann kompilieren und ausführen:

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

Sie haben also nicht genug physischen Speicher (RAM), um die gesamte Datei auf einmal zu speichern, aber auf einem 64-Bit-System haben Sie genug virtuellen Adressraum, um die gesamte Datei zuzuordnen. In solchen Fällen können virtuelle Zuordnungen als einfacher Hack nützlich sein.

Die notwendigen Operationen sind alle in Python enthalten. Es gibt einige ärgerliche Feinheiten, aber es wird vermieden, C-Code schreiben zu müssen. Insbesondere muss darauf geachtet werden, dass die Datei nicht in den Speicher kopiert wird, da dies den Punkt völlig zunichte macht. Auf der positiven Seite erhalten Sie eine kostenlose Fehlerberichterstattung (Python "Ausnahmen") :).

#!/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):])

Das replacePaket mariadb-server / mysql-server enthält ein Hilfsprogramm. Es ersetzt einfache Zeichenketten (keine regulären Ausdrücke) und replacekümmert sich im Gegensatz zu grep / sed / awk nicht um \nund \0. Der Speicherverbrauch ist bei jeder Eingabedatei konstant (ca. 400 KB auf meinem Computer).

Natürlich brauchen Sie keinen MySQL-Server, um es zu benutzen replace, es ist nur so in Fedora gepackt. Andere Distributionen / Betriebssysteme haben es möglicherweise separat verpackt.

Ich denke, die C-Version könnte viel besser abschneiden:

#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: Geändert nach Vorschlägen aus den Kommentaren. Auch Fehler mit dem Muster behoben <<unk>.

GNU grepkann Ihnen den Versatz von Übereinstimmungen in "binären" Dateien anzeigen, ohne dass Sie ganze Zeilen in den Speicher einlesen müssen. Sie können dann ddbis zu diesem Offset lesen, die Übereinstimmung überspringen und mit dem Kopieren aus der Datei fortfahren.

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"

Aus ddGründen der Geschwindigkeit habe ich das in einen großen Lesevorgang mit Blockgröße 1048576 und einen kleineren Lesevorgang mit jeweils 1 Byte aufgeteilt, aber dieser Vorgang wird bei einer so großen Datei immer noch etwas langsam sein. Die grepAusgabe ist zum Beispiel, 13977:<unk>und diese wird durch das Einlesen in Variablen offsetund auf den Doppelpunkt aufgeteilt pattern. Wir müssen nachverfolgen, poswie viele Bytes bereits aus der Datei kopiert wurden.

Hier ist eine weitere einzelne UNIX-Befehlszeile, die möglicherweise eine bessere Leistung als andere Optionen erbringt, da Sie nach einer "Blockgröße" suchen können, die eine gute Leistung erbringt. Um robust zu sein, müssen Sie wissen, dass Sie in jedem X-Zeichen mindestens ein Leerzeichen haben, wobei X Ihre willkürliche "Blockgröße" ist. Im folgenden Beispiel habe ich eine "Blockgröße" von 1024 Zeichen gewählt.

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

Hier fängt fold bis zu 1024 Bytes ein, aber das -s stellt sicher, dass es in einem Leerzeichen bricht, wenn es seit der letzten Pause mindestens eins gibt.

Der sed Befehl liegt bei Ihnen und macht das, was Sie erwarten.

Dann "entfaltet" der Befehl tr die Datei und konvertiert die eingefügten Zeilenumbrüche zurück in nichts.

Sie sollten versuchen, größere Blöcke zu verwenden, um festzustellen, ob diese schneller sind. Anstelle von 1024 können Sie auch 10240 und 102400 und 1048576 für die Option -w verwenden.

Hier ist ein Beispiel für jeden Schritt, bei dem alle N in Kleinbuchstaben umgewandelt werden:

[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

Sie müssen eine neue Zeile an das Ende der Datei anfügen, falls eine vorhanden ist, da diese mit dem Befehl tr entfernt wird.

Verwenden perl

Eigene Puffer verwalten

Mit IO::Handle's können Sie setvbufdie Standardpuffer verwalten, oder Sie können Ihre eigenen Puffer mit sysreadund verwalten syswrite. Überprüfen Sie perldoc -f sysreadund perldoc -f syswritefür weitere Informationen, im Wesentlichen überspringen sie io gepuffert.

Hier rollen wir unsere eigenen Puffer-E / A, aber wir machen es manuell und willkürlich auf 1024 Bytes. Wir öffnen auch die Datei für RW, damit wir alle auf einmal auf derselben FH ausführen können.

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

Wenn du diesen Weg gehen willst

1. Achten Sie darauf , <unk>und <raw_unk>sind die gleichen Byte - Größe.
2. Sie können sicherstellen, dass unsere gepufferte Methode die CHUNKSIZEGrenze nicht überschreitet , wenn Sie mehr als 1 Byte ersetzen.

Sie könnten versuchen, bbe ( Binärblock-Editor ), ein " sedfür Binärdateien".

Ich hatte gute Erfolge bei der Verwendung einer 7-GB-Textdatei ohne EOLZeichen, bei der mehrere Vorkommen einer Zeichenfolge durch eine Zeichenfolge unterschiedlicher Länge ersetzt wurden. Ohne Optimierungsversuch ergab sich ein durchschnittlicher Verarbeitungsdurchsatz von> 50 MB / s.

Mit perlkönnen Sie mit Datensätzen mit fester Länge arbeiten, z.

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

Und ich hoffe, dass es nicht <unk>zwei dieser 100-MB-Datensätze gibt.

Hier ist ein kleines Go-Programm, das die Aufgabe ausführt ( 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)
    }
}

Bauen Sie go build unk.goes einfach mit und führen Sie es als ./unk <input >output.

BEARBEITEN:

Entschuldigung, ich habe nicht gelesen, dass alles in einer Zeile steht, also habe ich jetzt versucht, die Datei zeichenweise zu lesen.

EDIT II:

Wendet den gleichen Fix wie beim C-Programm an.

Dies ist möglicherweise zu viel für eine 70-GB-Datei und ein einfaches Suchen und Ersetzen. Mit dem Hadoop MapReduce-Framework können Sie Ihr Problem jedoch sofort kostenlos lösen (wählen Sie die Option "Einzelner Knoten", wenn Sie es für die lokale Ausführung einrichten) zukünftig auf unendliche Kapazität skaliert, ohne dass Sie Ihren Code ändern müssen.

Das offizielle Tutorial unter https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html verwendet (extrem einfaches) Java, Sie finden jedoch Client-Bibliotheken für Perl oder Welche Sprache auch immer Sie verwenden möchten.

Wenn Sie also später feststellen, dass Sie komplexere Vorgänge mit 7000 GB Textdateien ausführen und dies 100 Mal pro Tag tun müssen, können Sie die Arbeitslast auf mehrere Knoten verteilen, die Sie bereitstellen oder die automatisch von einer Cloud für Sie bereitgestellt werden. Hadoop-Cluster.

Für alle vorherigen Vorschläge muss die gesamte Datei gelesen und die gesamte Datei geschrieben werden. Dies dauert nicht nur lange, sondern erfordert auch 70 GB freien Speicherplatz.

1) Wenn ich Dir richtig verstehe konkreten Fall wäre es akzeptabel, ersetzen <unk> mit einem anderen String der gleichen Länge?

2a) Gibt es mehrere Vorkommen? 2b) Wenn ja, wie viele?

Ich bin mir sicher, dass Sie dieses Problem bereits gelöst haben und ich würde gerne wissen, welche Lösung Sie verwendet haben.

Ich würde eine Lösung vorschlagen (höchstwahrscheinlich in C), die die BLÖCKE der Datei liest, die jeweils nach der Zeichenfolge suchen, wobei mögliche Blocküberschneidungen berücksichtigt werden. Einmal gefunden, ersetzen Sie die Zeichenkette mit der gleichen Länge alternativ und schreiben Sie nur diesen BLOCK. Fortsetzung für die bekannte Anzahl der Vorkommen oder bis zum Ende der Datei. Dies würde nur wenige Schreibvorgänge und höchstens das Doppelte erfordern (wenn jeder Vorgang auf zwei Blöcke aufgeteilt wurde). Dies würde KEINEN zusätzlichen Platz erfordern!

Wenn wir einen Mindestbetrag von <unk>(wie von Zipfs Gesetz erwartet) haben,

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