Eu tenho um arquivo de texto enorme (70 GB), uma linha , e quero substituir uma string (token) nele. Quero substituir o token <unk>por outro fictício ( problema de luva ).

Eu tentei sed:

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

mas o arquivo de saída corpus.txt.newpossui zero bytes!

Eu também tentei usar perl:

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

mas recebi um erro de falta de memória.

Para arquivos menores, os dois comandos acima funcionam.

Como posso substituir uma string é um arquivo? Esta é uma pergunta relacionada, mas nenhuma das respostas funcionou para mim.

Editar : Que tal dividir o arquivo em pedaços de 10 GB (ou o que for) cada um e aplicar sedem cada um deles e depois mesclá-los cat? Isso faz sentido? Existe uma solução mais elegante?

As ferramentas usuais de processamento de texto não foram projetadas para lidar com linhas que não cabem na RAM. Eles tendem a trabalhar lendo um registro (uma linha), manipulando-o e produzindo o resultado, depois prosseguindo para o próximo registro (linha).

Se houver um caractere ASCII que apareça com frequência no arquivo e não apareça em <unk>ou <raw_unk>, você poderá usá-lo como separador de registros. Como a maioria das ferramentas não permite separadores de registros personalizados, troque entre esse caractere e as novas linhas. trprocessa bytes, não linhas, por isso não se importa com nenhum tamanho de registro. Supondo que ;funcione:

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

Você também pode ancorar no primeiro caractere do texto que está procurando, supondo que ele não seja repetido no texto de pesquisa e apareça com frequência suficiente. Se o arquivo começar unk>, altere o comando sed sed '2,$ s/…para evitar uma correspondência falsa.

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

Como alternativa, use o último caractere.

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

Observe que essa técnica pressupõe que sed opera perfeitamente em um arquivo que não termina com uma nova linha, ou seja, que processa a última linha parcial sem truncá-la e sem anexar uma nova linha final. Funciona com o GNU sed. Se você puder escolher o último caractere do arquivo como separador de registros, evitará qualquer problema de portabilidade.

Para um arquivo tão grande, uma possibilidade é o Flex. Let unk.lbe:

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

Em seguida, compile e execute:

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

Portanto, você não tem memória física (RAM) suficiente para armazenar o arquivo inteiro de uma só vez, mas em um sistema de 64 bits, você tem espaço de endereço virtual suficiente para mapear o arquivo inteiro. Os mapeamentos virtuais podem ser úteis como um simples hack em casos como este.

As operações necessárias estão todas incluídas no Python. Existem várias sutilezas irritantes, mas evita a necessidade de escrever código C. Em particular, é necessário cuidado para evitar a cópia do arquivo na memória, o que anularia totalmente o argumento. No lado positivo, você obtém relatórios de erros gratuitamente ("exceções" em 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):])

Há um replaceutilitário no pacote mariadb-server / mysql-server. Ele substitui cadeias simples (não expressões regulares) e, diferentemente do grep / sed / awk, replacenão se importa com \ne \0. O consumo de memória é constante em qualquer arquivo de entrada (cerca de 400kb na minha máquina).

Claro que você não precisa rodar um servidor mysql para usá- replacelo, ele é empacotado dessa maneira no Fedora. Outras distribuições / sistemas operacionais podem ser embalados separadamente.

Eu acho que a versão C pode ter um desempenho muito melhor:

#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: Modificado de acordo com as sugestões dos comentários. Também foi corrigido o erro com o padrão <<unk>.

O GNU greppode mostrar o deslocamento de correspondências em arquivos "binários", sem a necessidade de ler linhas inteiras na memória. Você pode usar ddpara ler esse deslocamento, pular a partida e continuar copiando do arquivo.

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"

Para ddaumentar a velocidade, dividi a leitura em um tamanho grande de bloco 1048576 e uma leitura menor de 1 byte por vez, mas essa operação ainda será um pouco lenta em um arquivo tão grande. A grepsaída é, por exemplo,, 13977:<unk>e isso é dividido em dois pontos pela leitura em variáveis offsete pattern. Temos que acompanhar posquantos bytes já foram copiados do arquivo.

Aqui está outra linha de comando UNIX que pode ter um desempenho melhor do que outras opções, porque você pode "procurar" um "tamanho de bloco" com bom desempenho. Para que isso seja robusto, você precisa saber que possui pelo menos um espaço em cada caractere X, onde X é o seu "tamanho de bloco" arbitrário. No exemplo abaixo, escolhi um "tamanho do bloco" de 1024 caracteres.

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

Aqui, o fold pega até 1024 bytes, mas o -s garante que ele se quebre em um espaço se houver pelo menos um desde a última interrupção.

O comando sed é seu e faz o que você espera.

Em seguida, o comando tr "desdobra" o arquivo, convertendo as novas linhas que foram inseridas novamente em nada.

Você deve tentar tamanhos de bloco maiores para ver se o desempenho é mais rápido. Em vez de 1024, você pode tentar 10240 e 102400 e 1048576 para a opção -w de fold.

Aqui está um exemplo dividido por cada etapa que converte todos os Ns em 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

Você precisará adicionar uma nova linha no final do arquivo, se houver uma, porque o comando tr a removerá.

Usando perl

Gerenciando seus próprios buffers

Você pode usar IO::Handle's setvbufpara gerenciar os buffers padrão ou gerenciar seus próprios buffers com sysreade syswrite. Verifique perldoc -f sysreade, perldoc -f syswritepara obter mais informações, essencialmente eles ignoram o buffer io.

Aqui rolamos nossa própria E / S de buffer, mas fazemos isso manualmente e arbitrariamente em 1024 bytes. Também abrimos o arquivo para o RW, então fazemos tudo no mesmo FH de uma só 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++;
}

Se você estiver indo por esta rota

1. Certifique-se <unk>e <raw_unk>são do mesmo tamanho byte.
2. Convém garantir que nosso método em buffer não ultrapasse os CHUNKSIZElimites, se você estiver substituindo mais de 1 byte.

Você pode tentar o bbe ( editor de bloco binário ), um " sedpara arquivos binários".

Tive um bom sucesso usando-o em um arquivo de texto de 7 GB sem EOLcaracteres, substituindo várias ocorrências de uma string por uma de comprimento diferente. Sem tentar qualquer otimização, obteve uma taxa de transferência média de processamento de> 50MB / s.

Com perl, você pode trabalhar com registros de comprimento fixo, como:

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

E espero que não haja <unk>s abrangendo dois desses registros de 100 MB.

Aqui está um pequeno programa Go que executa a tarefa ( 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)
    }
}

Apenas construa go build unk.goe execute como ./unk <input >output.

EDITAR:

Desculpe, eu não li que tudo está em uma linha, então tentei ler o arquivo caractere por caractere agora.

EDIÇÃO II:

Aplicou a mesma correção do programa C.

Pode ser um exagero para um arquivo de 70 GB e pesquisa e substituição simples, mas a estrutura do Hadoop MapReduce resolveria seu problema agora sem nenhum custo (escolha a opção 'Único nó' ao configurá-lo para executá-lo localmente) - e poderá ser dimensionado para capacidade infinita no futuro sem a necessidade de modificar seu código.

O tutorial oficial em https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html usa Java (extremamente simples), mas você pode encontrar bibliotecas clientes para Perl ou qualquer idioma que você queira usar.

Portanto, se, posteriormente, você descobrir que está executando operações mais complexas em arquivos de texto de 7000 GB - e precisando fazer isso 100 vezes por dia -, poderá distribuir a carga de trabalho entre vários nós que você provisiona ou que são provisionados automaticamente por uma nuvem - cluster Hadoop baseado em

Todas as sugestões anteriores exigem a leitura do arquivo inteiro e a gravação do arquivo inteiro. Isso não leva muito tempo, mas também requer 70 GB de espaço livre.

1) Se eu entendi corretamente o seu caso específico, seria aceitável substituir por alguma outra string do mesmo comprimento?

2a) Existem múltiplas ocorrências? 2b) Se sim, você sabe quantos?

Tenho certeza de que você já resolveu esse problema de mais de um ano e gostaria de saber qual solução você usou.

Eu proporia uma solução (provavelmente em C) que leria os BLOCOS do arquivo pesquisando cada uma pela string, levando em consideração o possível cruzamento de blocos. Uma vez encontrada, substitua a string pelo mesmo comprimento alternativo e escreva apenas esse BLOCK. Continuando pelo número conhecido de ocorrências ou até o final do arquivo. Isso exigiria apenas o número de gravações de ocorrências e no máximo duas vezes isso (se todas as ocorrências fossem divididas em 2 blocos). Isso não exigiria espaço adicional!

Se tivermos um valor mínimo de <unk>(como esperado pela lei de Zipf),

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