Büyük bir (70GB), bir satır , metin dosyasına sahibim ve içindeki bir dizgiyi (token) değiştirmek istiyorum. Belirteci <unk>, başka bir sahte belirteçle değiştirmek istiyorum ( eldiven sorunu ).

Denedim sed:

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

ancak çıktı dosyasının corpus.txt.newsıfır baytı var!

Perl kullanarak da denedim:

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

ama yetersiz bellek hatasıyla karşılaştım.

Daha küçük dosyalar için, yukarıdaki komutların ikisi de çalışır.

Nasıl bir dize değiştirebilirim böyle bir dosyadır? Bu ilgili bir soru, ancak cevapların hiçbiri benim için çalıştı.

Düzenleme : Dosyayı sedher biri 10GB'lık (veya her neyse) parçalara bölmek ve her birine uygulamak ve daha sonra bunları birleştirmek cat? bu mantıklı mı? Daha zarif bir çözüm var mı?

Normal metin işleme araçları RAM'e uymayan satırları işlemek için tasarlanmamıştır. Bir kaydı (bir satır) okuyup, işleyerek ve sonucu çıkarıp bir sonraki kayda (satır) geçerek çalışma eğilimindedirler.

Dosyada sıkça görünen ve içinde görünmeyen bir ASCII karakteri varsa <unk>veya <raw_unk>bu durumda, bunu kayıt ayırıcı olarak kullanabilirsiniz. Çoğu araç özel kayıt ayırıcılara izin vermediğinden, bu karakter ve yeni satırlar arasında geçiş yapın. trsatırları değil baytları işler, bu nedenle herhangi bir kayıt büyüklüğünü önemsemez. Diyelim ki ;işe yarıyor:

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

Ayrıca, arama metninde tekrarlanmadığını ve yeterince sık göründüğünü varsayarsak, aradığınız metnin ilk karakterine demir atabilirsiniz. Dosya başlayabiliyorsa unk>, sed '2,$ s/…sahte bir eşleşmeyi önlemek için sed komutunu değiştirin .

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

Alternatif olarak, son karakteri kullanın.

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

Bu tekniğin, sed'nin yeni bir satırla bitmeyen bir dosya üzerinde sorunsuz bir şekilde çalıştığını, yani son kısmi satırı kesmeden ve son bir yeni satır eklemeden işlediğini varsaydığını unutmayın. GNU sed ile çalışır. Dosyanın son karakterini kayıt ayırıcı olarak seçebilirseniz, taşınabilirlik sorunlarından kaçınırsınız.

Böyle büyük bir dosya için, bir olasılık Flex. Olsun unk.l:

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

Sonra derleyin ve yürütün:

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

Böylece tüm dosyayı bir seferde tutacak kadar fiziksel belleğe (RAM) sahip değilsinizdir , ancak 64 bit sistemde tüm dosyayı eşleştirmek için yeterli sanal adres alanına sahipsiniz . Sanal eşlemeler, bu gibi durumlarda basit bir hack olarak yararlı olabilir.

Gerekli işlemlerin tümü Python'a dahil edilmiştir. Birkaç can sıkıcı incelik vardır, ancak C kodu yazmak zorunda kalmaz. Özellikle, dosyayı tamamen kopyalayabilen belleğe kopyalamaktan kaçınmak için özen gösterilmelidir. Artı tarafta, ücretsiz hata raporlama alıyorsunuz (python "istisnalar") :).

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

C versiyonunun daha iyi performans gösterebileceğini düşünüyorum:

#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: yorumlardan gelen önerilere göre değiştirildi. Ayrıca desenli hata düzeltildi <<unk>.

replaceMariadb-server / mysql-server paketinde bir yardımcı program var . Basit dizgilerin yerine geçer (normal ifadeler değil) ve grep / sed / awk'ın replaceumurunda değil \nve \0. Bellek tüketimi herhangi bir giriş dosyasında sabittir (makinemde yaklaşık 400 kb).

Tabii ki kullanmak için bir mysql sunucusu çalıştırmanıza gerek yoktur replace, sadece Fedora'da paketlenir. Diğer dağıtımlar / işletim sistemleri ayrı olarak paketlenmiş olabilir.

GNU grep, tüm satırları belleğe okumak zorunda kalmadan size "ikili" dosyalardaki eşleşmeleri ofsetini gösterebilir. Daha sonra ddbu ofseti okumak, eşleşmeyi atlamak, sonra dosyadan kopyalamaya devam etmek için kullanabilirsiniz.

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"

Hız için, dd1048576 büyüklüğünde bir blok okuma ve bir seferde 1 byte daha küçük bir okumaya böldüm, ancak bu işlem bu kadar büyük bir dosyada hala biraz yavaş olacak. grepÇıkış, örneğin,, 13977:<unk>ve bu değişkenleri okuma ile kolon üzerine bölünür offsetve pattern. posDosyadan kaç baytın kopyalandığını takip etmeliyiz.

İşte diğer seçeneklerden daha iyi performans gösterebilecek tek bir UNIX komut satırı, çünkü iyi performans gösteren bir "blok boyutu" için "av" yazabiliyorsunuz. Bunun sağlam olması için, her X karakterinde en az bir alan bulunduğunu bilmeniz gerekir; burada X, keyfi "blok boyutunuz" dur. Aşağıdaki örnekte 1024 karakterden oluşan bir "blok boyutu" seçtim.

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

Burada, katlama 1024 bayta kadar çıkacaktır , ancak son aradan sonra en az bir tane olması durumunda -s, bir boşlukta kopmasını sağlar.

Sed komutu sizindir ve beklediğiniz şeyi yapar.

Daha sonra tr komutu, tekrar eklenen yeni satırları hiçbir şeye dönüştürmeyen dosyayı "açacaktır".

Daha hızlı çalışıp çalışmadığını görmek için daha büyük blok boyutlarını denemelisiniz. 1024 yerine -w katlama seçeneği için 10240 ve 102400 ve 1048576'yı deneyebilirsiniz.

İşte tüm N'leri küçük harfe dönüştüren her adım için ayrılmış bir örnek:

[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 komutu onu kaldıracağından eğer varsa, dosyanın sonuna yeni bir satır eklemeniz gerekecek.

kullanma perl

Kendi tamponlarınızı yönetme

Varsayılan arabellekleri yönetmek için IO::Handle's' i kullanabilir setvbufveya kendi arabelleklerinizi sysreadve ile yönetebilirsiniz syswrite. Daha fazla bilgi için kontrol edin perldoc -f sysreadve perldoc -f syswritetemelde tamponlanmış io'yu atlarlar.

Burada kendi arabelleğimizi IO'yu yuvarlıyoruz, ancak manuel olarak ve keyfi olarak 1024 baytta yapıyoruz. Ayrıca dosyayı RW için açıyoruz, böylece aynı FH'de bir seferde hepsini yapıyoruz.

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

Eğer bu rotaya gidecekseniz

1. Emin olun <unk>ve <raw_unk>aynı byte boyutunda.
2. Tampon yöntemimizin CHUNKSIZE1 bayttan fazlasını değiştirirseniz , sınırı geçmediğinden emin olmak isteyebilirsiniz .

Bir " ikili dosyalar için" bbe ( ikili blok editörü ) deneyebilirsiniz sed.

Bir EOLkarakterin 7GB metin dosyasında, karaktersiz, bir dize birden fazla oluşumunu farklı uzunluktaki bir taneyle değiştirerek başarılı oldum . Herhangi bir optimizasyon yapmadan,> 50MB / s'lik ortalama bir işlem hacmi verdi.

İle perlsabit uzunluktaki kayıtlarla çalışabilirsiniz:

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

Ve <unk>bu 100 MB'lık kayıtların ikisinde yayılmayacağını umuyorum .

İşte görevi gerçekleştiren küçük bir Go programı ( 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)
    }
}

Sadece inşa et go build unk.gove çalıştır ./unk <input >output.

DÜZENLE:

Üzgünüm, her şeyin tek bir satırda olduğunu okumadım, bu yüzden dosya karakterini şimdi karakter okumaya çalıştım.

EDIT II:

C programındakilerle aynı düzeltme uygulandı.

Bu, 70GB'lık bir dosya ve basit bir arama ve değiştirme için fazla olabilir, ancak Hadoop MapReduce çerçevesi şu anda sorununuzu ücretsiz olarak çözer (yerel olarak çalıştırmak için ayarlarken 'Tek Düğüm' seçeneğini seçin) - ve Kodunuzu değiştirmenize gerek kalmadan gelecekte sonsuz kapasiteye ölçeklendirilebilir.

Https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html adresindeki resmi kılavuz, Java'yı kullanıyor (ancak son derece basit) ancak Perl veya hangi dili kullanmak istersen.

Böylece daha sonra 7000 GB metin dosyalarında daha karmaşık işlemler yaptığınızı ve bunu günde 100 kez yapmak zorunda kaldığınızı tespit ederseniz, iş yükünü sağladığınız veya sizin için otomatik olarak bir bulut tarafından sağlanan birden fazla düğüme dağıtabilirsiniz. tabanlı Hadoop kümesi.

Önceki önerilerin tümü dosyanın tamamını okumayı ve dosyanın tamamını yazmayı gerektirir. Bu sadece uzun zaman alır, aynı zamanda 70GB boş alan gerektirir.

1) Sizi özel olarak doğru bir şekilde anlarsam, yerine SAME uzunluğunun başka bir dizgisi koymak kabul edilebilir mi?

2a) Çoklu oluşumlar var mı? 2b) Öyleyse kaç tane olduğunu biliyor musunuz?

Eminim bu yıl artı sorunu zaten çözdünüz ve hangi çözümü kullandığınızı bilmek istiyorum.

Olası blok geçişini göz önünde bulundurarak her birini dize araştıran dosyanın BLOCKS'unu okuyacak bir çözüm (en çok C cinsinden) öneririm. Bir kez bulundu dize SAME uzunluğu alternatif ile değiştirin ve sadece bu BLOCK yazın. Bilinen olay sayısı için veya dosyanın sonuna kadar devam ediyor. Bu, oluşma sayısı kadar az yazar ve en fazla iki katına ihtiyaç duyar (her olay 2 blok arasında bölündüyse). Bu ek alan gerektirmez!

Minimum miktarda <unk>tutarımız varsa (Zipf yasasına göre beklendiği gibi),

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