J'ai un énorme (70 Go), une ligne , un fichier texte et je veux remplacer une chaîne (jeton) en elle. Je souhaite remplacer le jeton <unk>par un autre jeton factice ( problème de gant ).

J'ai essayé sed:

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

mais le fichier de sortie corpus.txt.newa zéro octet!

J'ai aussi essayé d'utiliser Perl:

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

mais j'ai eu une erreur de mémoire insuffisante.

Pour les fichiers plus petits, les deux commandes ci-dessus fonctionnent.

Comment puis-je remplacer une chaîne est un tel fichier? C'est une question liée, mais aucune des réponses n'a fonctionné pour moi.

Edit : Qu'en est-il de scinder le fichier en morceaux de 10 Go (ou quoi que ce soit) chacun, d'appliquer sedchacun d'eux et de les fusionner ensuite cat? Cela a-t-il du sens? Y a-t-il une solution plus élégante?

Les outils de traitement de texte habituels ne sont pas conçus pour gérer les lignes qui ne rentrent pas dans la RAM. Ils ont tendance à travailler en lisant un enregistrement (une ligne), en le manipulant et en affichant le résultat, puis en passant à l'enregistrement suivant (ligne).

Si un caractère ASCII apparaît fréquemment dans le fichier et n'apparaît pas dans <unk>ou <raw_unk>, vous pouvez l'utiliser comme séparateur d'enregistrement. Comme la plupart des outils n'autorisent pas les séparateurs d'enregistrement personnalisés, permutez entre ce caractère et les nouvelles lignes. trtraite des octets, pas des lignes, de sorte qu'il ne se soucie pas de la taille d'un enregistrement. En supposant que cela ;fonctionne:

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

Vous pouvez également ancrer le premier caractère du texte que vous recherchez, en supposant qu'il ne soit pas répété dans le texte recherché et qu'il apparaisse assez souvent. Si le fichier peut commencer par unk>, modifiez la commande sed sed '2,$ s/…pour éviter une correspondance parasite.

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

Sinon, utilisez le dernier caractère.

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

Notez que cette technique suppose que sed fonctionne de manière transparente sur un fichier qui ne se termine pas par une nouvelle ligne, c'est-à-dire qu'il traite la dernière ligne partielle sans la tronquer ni l'ajout d'une nouvelle ligne. Cela fonctionne avec GNU sed. Si vous pouvez choisir le dernier caractère du fichier comme séparateur d'enregistrement, vous éviterez tout problème de portabilité.

Pour un si gros fichier, une possibilité est Flex. Let unk.lÊtre:

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

Ensuite, compilez et exécutez:

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

Par conséquent, vous ne disposez pas de suffisamment de mémoire physique (RAM) pour contenir le fichier entier en une fois, mais sur un système 64 bits, vous disposez de suffisamment d' espace d'adressage virtuel pour mapper l'ensemble du fichier. Les mappages virtuels peuvent être utiles comme un simple piratage dans des cas comme celui-ci.

Les opérations nécessaires sont toutes incluses dans Python. Il y a plusieurs subtilités gênantes, mais cela évite d'avoir à écrire du code C. En particulier, il faut éviter de copier le fichier en mémoire, ce qui éliminerait complètement le problème. Sur le plan positif, vous obtenez un rapport d’erreurs gratuitement (python "exceptions") :).

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

Il existe un replaceutilitaire dans le paquet mariadb-server / mysql-server. Il remplace des chaînes simples (expressions régulières) pas et contrairement à grep / sed / awk replacene se soucie pas \net \0. La consommation de mémoire est constante quel que soit le fichier d'entrée (environ 400 Ko sur ma machine).

Bien sûr, vous n'avez pas besoin de faire tourner un serveur mysql pour l'utiliser replace, il est seulement emballé de cette façon dans Fedora. Il peut être emballé séparément dans d’autres systèmes d’exploitation / systèmes d’exploitation.

Je pense que la version C pourrait fonctionner beaucoup mieux:

#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: Modifié selon les suggestions des commentaires. Également corrigé un bug avec le motif <<unk>.

GNU greppeut vous montrer le décalage des correspondances dans des fichiers "binaires", sans avoir à lire des lignes entières en mémoire. Vous pouvez ensuite utiliser ddpour lire jusqu’à ce décalage, ignorer la correspondance, puis continuer à copier à partir du fichier.

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"

Pour dddes raisons de rapidité, j'ai scindé le en une grande lecture de la taille de bloc 1048576 et une lecture plus petite d'un octet à la fois, mais cette opération sera encore un peu lente sur un fichier aussi volumineux. La grepsortie est, par exemple, 13977:<unk>et elle est divisée sur les deux points par la lecture en variables offsetet pattern. Nous devons garder trace posdu nombre d'octets déjà copiés du fichier.

Voici une autre ligne de commande UNIX unique qui peut fonctionner mieux que d’autres options, car vous pouvez "rechercher" une "taille de bloc" performante. Pour que cela soit robuste, vous devez savoir que vous avez au moins un espace dans chaque X caractères, où X est votre "taille de bloc" arbitraire. Dans l'exemple ci-dessous, j'ai choisi une "taille de bloc" de 1024 caractères.

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

Ici, fold se chargera jusqu'à 1024 octets, mais le -s s'assurera qu'il saute sur un espace s'il y en a au moins un depuis la dernière pause.

La commande sed est à vous et fait ce que vous attendez.

Ensuite, la commande tr "déplie" le fichier en convertissant les nouvelles lignes insérées.

Vous devriez envisager d’essayer des blocs plus grands pour voir s’il fonctionne plus rapidement. Au lieu de 1024, vous pouvez essayer 10240, 102400 et 1048576 pour l'option -w de fold.

Voici un exemple décomposé à chaque étape qui convertit tous les N en minuscules:

[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

Vous devrez ajouter une nouvelle ligne à la toute fin du fichier, le cas échéant, car la commande tr le supprimera.

En utilisant perl

Gérer vos propres tampons

Vous pouvez utiliser IO::Handle« s setvbufpour gérer les tampons par défaut, ou vous pouvez gérer vos propres tampons avec sysreadet syswrite. Vérifiez perldoc -f sysreadet perldoc -f syswritepour plus d’informations, essentiellement, ils sautent la mémoire tampon io.

Ici, nous lançons notre propre tampon IO, mais nous le faisons manuellement et arbitrairement sur 1024 octets. Nous ouvrons également le fichier pour RW, donc nous le faisons tous en même temps sur le même FH.

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 vous allez suivre cette voie

1. Assurez-vous <unk>que <raw_unk>la taille en octets est identique.
2. Vous voudrez peut-être vous assurer que notre méthode en mémoire tampon ne dépasse pas la CHUNKSIZElimite si vous remplacez plus d'un octet.

Vous pouvez essayer bbe ( éditeur de blocs binaires ), un " sedpour les fichiers binaires".

J'ai eu du succès à l'utiliser sur un fichier texte de 7 Go sans EOLcaractères, remplaçant plusieurs occurrences d'une chaîne par une autre de longueur différente. Sans aucune tentative d'optimisation, le débit de traitement moyen était supérieur à 50 Mo / s.

Avec perl, vous pouvez travailler avec des enregistrements de longueur fixe comme:

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

Et espérons qu’il n’y aura pas de <unk>débordement entre deux de ces enregistrements de 100 Mo.

Voici un petit programme Go qui effectue la tâche ( 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)
    }
}

Il suffit de le construire avec go build unk.goet l’exécuter en tant que ./unk <input >output.

MODIFIER:

Désolé, je n'ai pas lu que tout est dans une ligne, alors j'ai essayé de lire le fichier caractère par caractère maintenant.

EDIT II:

Appliqué même correctif que pour le programme C.

Cela peut être excessif pour un fichier de 70 Go et une simple recherche et remplacement, mais le framework Hadoop MapReduce résoudrait votre problème sans aucun frais (choisissez l’option 'Noeud unique' lors de la configuration pour l’exécuter localement) - et peut être mise à l'échelle à une capacité infinie à l'avenir sans avoir à modifier votre code.

Le tutoriel officiel à l' adresse https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html utilise Java (extrêmement simple) mais vous pouvez trouver des bibliothèques clientes pour Perl ou quelle que soit la langue que vous avez envie d'utiliser.

Par conséquent, si, par la suite, vous réalisez des opérations plus complexes sur des fichiers texte de 7 000 Go, et que vous devez le faire 100 fois par jour, vous pouvez répartir la charge de travail sur plusieurs nœuds que vous avez provisionnés ou qui sont automatiquement provisionnés par un cloud. cluster Hadoop basé.

Toutes les suggestions précédentes nécessitent de lire le fichier entier et de l'écrire au complet. Cela prend non seulement beaucoup de temps, mais nécessite également 70 Go d'espace libre.

1) serait-il correctement Si je vous comprends cas spécifique acceptable pour remplacer <UNK> avec une autre chaîne de la même longueur?

2a) Y a-t-il plusieurs occurrences? 2b) Si oui, savez-vous combien?

Je suis sûr que vous avez déjà résolu ce problème de l'année en cours et j'aimerais savoir quelle solution vous avez utilisée.

Je proposerais une solution (probablement en C) qui lirait les BLOCS du fichier en cherchant chacun la chaîne en tenant compte du croisement possible des blocs. Une fois la substitution trouvée, remplacez la chaîne par la longueur SAME en alternance et écrivez uniquement ce BLOCK. Continuant pour le nombre connu d'occurrences ou jusqu'à la fin du fichier. Cela nécessiterait aussi peu que le nombre d'occurrences écrites et au plus le double (si chaque occurrence était divisée en 2 blocs). Cela ne nécessiterait AUCUN espace supplémentaire!

Si nous avons un montant minimum de <unk>(comme prévu par la loi de Zipf),

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