巨大な（70GB）1行のテキストファイルがあり、その中の文字列（トークン）を置き換えたいと思います。token <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

しかし、メモリ不足エラーが発生しました。

小さいファイルの場合、上記の両方のコマンドが機能します。

そのようなファイルである文字列を置き換えるにはどうすればよいですか？ これは関連した質問ですが、答えはどれもうまくいきませんでした。

編集：ファイルを10GBのチャンク（または何でも）に分割し、それぞれに適用sedしてからマージするのはcatどうですか？それは理にかなっていますか？よりエレガントなソリューションはありますか？

通常のテキスト処理ツールは、RAMに収まらない行を処理するようには設計されていません。1つのレコード（1行）を読み取り、それを操作して結果を出力し、次のレコード（行）に進むことで動作する傾向があります。

ファイルに頻繁に出現し、<unk>または<raw_unk>に出現しないASCII文字がある場合は、それをレコード区切り文字として使用できます。ほとんどのツールはカスタムレコード区切り文字を許可しないため、その文字と改行を入れ替えます。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で動作します。ファイルの最後の文字をレコード区切り文字として選択できれば、移植性の問題を回避できます。

このような大きなファイルの場合、可能性の1つは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

したがって、ファイル全体を一度に保持するのに十分な物理メモリ（RAM）はありませんが、64ビットシステムでは、ファイル全体をマップするのに十分な仮想アドレススペースがあります。このような場合、仮想マッピングは単純なハックとして役立ちます。

必要な操作はすべてPythonに含まれています。いくつかの迷惑な微妙さがありますが、Cコードを記述する必要はありません。特に、メモリ内のファイルをコピーしないように注意する必要があります。コピーすると、ポイントが完全に無効になります。プラス面では、エラー報告が無料で得られます（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):])

replacemariadb-server / mysql-serverパッケージにはユーティリティがあります。これは、単純な文字列（正規表現ではない）に取って代わるとgrep / sedの/ awkのとは違ってreplace気にしない\nと\0。メモリ消費量は、どの入力ファイルでも一定です（私のマシンでは約400kb）。

もちろんreplace、を使用するためにmysqlサーバーを実行する必要はありません。それは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文字ごとに少なくとも1つのスペースがあることを知っておく必要があります。Xは任意の「ブロックサイズ」です。以下の例では、1024文字の「ブロックサイズ」を選択しました。

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

ここで、foldは最大 1024バイトを取得しますが、-sを使用すると、最後のブレーク以降にスペースが1つ以上ある場合にスペースでブレークするようになります。

sedコマンドはあなたのものであり、あなたが期待することをします。

次に、trコマンドは、ファイルを「展開」して、挿入された改行を何も戻さないように変換します。

より大きなブロックサイズを試して、より高速に実行されるかどうかを検討する必要があります。1024の代わりに、foldの-wオプションに10240と102400と1048576を試すことができます。

すべての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::Handleのをsetvbuf、デフォルトのバッファを管理するために、またはあなたがあなた自身のバッファを管理することができますsysreadし、syswrite。確認perldoc -f sysreadしperldoc -f syswrite、詳細については、基本的にバッファされたioをスキップします。

ここでは、独自のバッファ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. CHUNKSIZE1バイト以上を置き換える場合は、バッファリングされたメソッドが境界を越えないようにする必要があります。

「バイナリファイル用」のbbe（バイナリブロックエディタ）を試すことができsedます。

EOL文字のない7GBテキストファイルで、文字列の複数のオカレンスを異なる長さの1つに置き換えて使用することで、大成功を収めました。最適化を試みることなく、平均処理スループットは50MB / sを超えました。

を使用するとperl、次のような固定長レコードを操作できます。

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

そして<unk>、これらの100MBのレコードのうち2つにまたがってはならないことを願っています。

タスク（unk.go）を実行する小さな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。

編集：

申し訳ありませんが、すべてが1行であるとは読みませんでしたので、ファイルを1文字ずつ読み取ろうとしました。

編集II：

Cプログラムと同じ修正を適用しました。

これは70GBファイルと単純な検索と置換ではやり過ぎかもしれませんが、Hadoop MapReduceフレームワークは今すぐ無料で問題を解決します（ローカルで実行するように設定するときに「単一ノード」オプションを選択します）-コードを変更することなく、将来的に無限の容量に拡張されます。

https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.htmlの公式チュートリアルでは（非常に単純な）Javaを使用していますが、Perlまたは使用したい言語は何でも。

そのため、後で7000GBのテキストファイルでより複雑な操作を実行していることに気付いた場合（これを1日に100回行う必要があります）、ワークロードを、プロビジョニングしたクラウドまたはクラウドによって自動的にプロビジョニングされた複数のノードに分散できます-ベースのHadoopクラスター。

上記の提案はすべて、ファイル全体を読み取り、ファイル全体を書き込む必要があります。これには長い時間がかかるだけでなく、70GBの空き容量も必要です。

1）私はあなたの特定のケースを理解していれば、正しくは、同じ長さのいくつかの他の文字列と<UNK>を交換するにしてもよいでしょうか？

2a）複数回発生していますか？2b）その場合、いくつ知っていますか？

この1年以上の問題は既に解決されていると思いますが、どのソリューションを使用したかを知りたいと思います。

ブロック交差の可能性を考慮して文字列をそれぞれ検索するファイルのブロックを読み取るソリューション（おそらくCで）を提案します。見つかったら、文字列を同じ長さの代替文字列に置き換え、そのブロックのみを書き込みます。既知のオカレンス数の継続、またはファイルの終わりまで。これには、発生回数の書き込みが少なく、最大で2倍の書き込みが必要です（すべての発生が2つのブロックに分割された場合）。これには追加のスペースは必要ありません！

<unk>（Zipfの法則により予想されるように）最小量がある場合、

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