У меня есть огромный (70 ГБ), одна строка , текстовый файл, и я хочу заменить строку (токен) в нем. Я хочу заменить токен <unk>другим фиктивным токеном ( проблема с перчатками ).

Я пробовал sed:

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

но выходной файл corpus.txt.newимеет нулевые байты!

Я также пытался использовать Perl:

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

но я получил ошибку нехватки памяти.

Для файлов меньшего размера обе вышеуказанные команды работают.

Как мне заменить строку таким файлом? Это связанный вопрос, но ни один из ответов не сработал для меня.

Изменить : Как насчет разделения файла на куски по 10 ГБ (или что-то еще) каждый и применения sedк каждому из них, а затем объединить их с cat? Имеет ли это смысл? Есть ли более элегантное решение?

Обычные инструменты обработки текста не предназначены для обработки строк, которые не помещаются в ОЗУ. Они имеют тенденцию работать, читая одну запись (одну строку), манипулируя ею и выводя результат, затем переходя к следующей записи (строке).

Если есть символ ASCII, который часто появляется в файле и отсутствует в <unk>или <raw_unk>, то вы можете использовать его как разделитель записей. Поскольку большинство инструментов не допускают использование пользовательских разделителей записей, поменяйте местами этот символ и символы новой строки. trобрабатывает байты, а не строки, поэтому не имеет значения размер записи. Предположим, что ;работает:

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

Вы также можете привязать первый символ искомого текста, предполагая, что он не повторяется в тексте поиска и появляется достаточно часто. Если файл может начинаться с unk>, измените команду sed, sed '2,$ s/…чтобы избежать ложного совпадения.

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

В качестве альтернативы используйте последний символ.

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

Обратите внимание, что этот метод предполагает, что sed работает незаметно для файла, который не заканчивается новой строкой, то есть обрабатывает последнюю частичную строку, не обрезая ее и не добавляя заключительный символ новой строки. Работает с GNU sed. Если вы можете выбрать последний символ файла в качестве разделителя записей, вы избежите проблем переносимости.

Для такого большого файла одна возможность - Flex. Позвольте unk.lбыть:

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

Затем скомпилируйте и выполните:

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

Таким образом, у вас недостаточно физической памяти (ОЗУ) для одновременного хранения всего файла, но в 64-разрядной системе у вас достаточно виртуального адресного пространства для сопоставления всего файла. Виртуальные отображения могут быть полезны как простой взлом в таких случаях.

Все необходимые операции включены в Python. Есть несколько раздражающих тонкостей, но при этом не нужно писать C-код. В частности, необходимо соблюдать осторожность, чтобы не копировать файл в память, что могло бы полностью устранить проблему. С другой стороны, вы получаете сообщения об ошибках бесплатно (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):])

В replaceпакете mariadb-server / mysql-server есть утилита. Он заменяет простые строки (не регулярных выражений) и в отличие от Grep / SED / AWK replaceне заботится о \nи \0. Потребление памяти постоянно с любым входным файлом (около 400 КБ на моей машине).

Конечно, вам не нужно запускать сервер mysql для его использования replace, он упакован таким образом только в Fedora. Другие дистрибутивы / операционные системы могут быть упакованы отдельно.

Я думаю, что версия C может работать намного лучше:

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

РЕДАКТИРОВАТЬ: Изменено в соответствии с предложениями из комментариев. Также исправлена ​​ошибка с рисунком <<unk>.

GNU grepможет показывать смещение совпадений в «двоичных» файлах, не считывая целые строки в памяти. Затем вы можете использовать ddдля считывания до этого смещения, пропустить совпадение, а затем продолжить копирование из файла.

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"

Для скорости я разделил ddна большое чтение размера блока 1048576 и меньшее чтение на 1 байт за раз, но эта операция все еще будет немного медленной для такого большого файла. grepВыход, например, 13977:<unk>и это делится на толстой кишке путем чтения в переменных offsetи pattern. Мы должны отслеживать, posсколько байтов уже скопировано из файла.

Вот еще одна командная строка UNIX, которая может работать лучше, чем другие опции, потому что вы можете «искать» «размер блока», который работает хорошо. Чтобы это было надежно, вам нужно знать, что у вас есть хотя бы один пробел в каждых символах X, где X - ваш произвольный «размер блока». В приведенном ниже примере я выбрал «размер блока» из 1024 символов.

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

Здесь, fold будет захватывать до 1024 байтов, но -s гарантирует, что он будет разбит на пробел, если есть хотя бы один с момента последнего разрыва.

Команда sed ваша и делает то, что вы ожидаете.

Затем команда tr "раскроет" файл, преобразуя новые строки, которые были вставлены обратно, в ничто.

Вы должны попробовать использовать блоки большего размера, чтобы увидеть, работает ли он быстрее. Вместо 1024 вы можете попробовать 10240 и 102400 и 1048576 для опции -w сгиба.

Вот пример с разбивкой по каждому шагу, который преобразует все N в нижний регистр:

[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

Вам нужно будет добавить новую строку в самый конец файла, если он есть, потому что команда tr удалит его.

С помощью perl

Управление своими собственными буферами

Вы можете использовать IO::Handles setvbufдля управления буферами по умолчанию, или вы можете управлять своими собственными буферами с помощью sysreadи syswrite. Проверьте perldoc -f sysreadи perldoc -f syswriteдля получения дополнительной информации, по существу, они пропускают буферизованные io.

Здесь мы запускаем наш собственный буферный ввод-вывод, но мы делаем это вручную и произвольно на 1024 байтах. Мы также открываем файл для RW, поэтому делаем все это одновременно на одном и том же 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++;
}

Если вы собираетесь идти по этому маршруту

1. Убедитесь в том , <unk>и <raw_unk>имеют тот же размер байт.
2. Возможно, вы захотите убедиться, что наш буферизованный метод не пересекает CHUNKSIZEграницу, если вы заменяете более 1 байта.

Вы можете попробовать bbe ( редактор двоичных блоков ), « sedдля двоичных файлов».

Я имел хороший успех, используя его в текстовом файле размером 7 ГБ без EOLсимволов, заменив несколько вхождений строки одной длины. Без попыток какой-либо оптимизации средняя скорость обработки составила> 50 МБ / с.

С помощью perlвы можете работать с записями фиксированной длины, такими как:

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

И надеюсь, что <unk>эти две записи по 100 МБ не будут охватывать вас.

Вот небольшая программа Go, которая выполняет задачу ( 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)
    }
}

Просто создайте его go build unk.goи запустите как ./unk <input >output.

РЕДАКТИРОВАТЬ:

Извините, я не читал, что все в одной строке, поэтому я пытался читать файл символ за символом.

РЕДАКТИРОВАТЬ II:

Применяется то же исправление, что и к программе на Си.

Это может быть излишним для файла объемом 70 ГБ и простым поиском и заменой, но среда Hadoop MapReduce решит вашу проблему прямо сейчас без каких-либо затрат (выберите опцию «Единый узел» при настройке для ее локального запуска) - и это может быть масштабируется до бесконечной емкости в будущем без необходимости изменять ваш код.

Официальное руководство по адресу https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html использует (чрезвычайно простую) Java, но вы можете найти клиентские библиотеки для Perl или какой бы язык вы не хотели использовать.

Таким образом, если позже вы обнаружите, что выполняете более сложные операции с текстовыми файлами объемом 7000 ГБ - и должны делать это 100 раз в день - вы можете распределить рабочую нагрузку по нескольким узлам, которые вы предоставляете или которые автоматически предоставляются вам облачным на основе кластера Hadoop.

Все предыдущие предложения требуют чтения всего файла и записи всего файла. Это не только занимает много времени, но и требует 70 ГБ свободного места.

1) Если я вас понимаю конкретный случай, правильно было бы приемлемо заменить <УНК> с какой-либо другой строки той же длины?

2а) Есть ли несколько случаев? 2b) Если да, то знаете, сколько?

Я уверен, что вы уже решили эту проблему года плюс, и я хотел бы знать, какое решение вы использовали.

Я бы предложил решение (скорее всего, на С), которое бы считывало БЛОКИ файла, ища по каждой строке, с учетом возможного пересечения блоков. Как только найден, замените строку с той же длины чередуется и записать только этот блок. Продолжая в течение известного числа случаев или до конца файла. Это потребует всего лишь записи числа событий и не более чем вдвое (если каждое вхождение было разделено между 2 блоками). Это не потребует никакого дополнительного места!

Если у нас есть минимальное количество <unk>(как ожидается, согласно закону Ципфа),

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