ฉันมีขนาดใหญ่ (70GB) หนึ่งบรรทัดไฟล์ข้อความและฉันต้องการแทนที่สตริง (โทเค็น) ในนั้น ฉันต้องการแทนที่โทเค็น<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

แต่ฉันได้รับข้อผิดพลาดหน่วยความจำไม่เพียงพอ

สำหรับไฟล์ขนาดเล็กคำสั่งทั้งสองข้างต้นจะใช้งานได้

ฉันจะแทนที่สตริงเป็นไฟล์ดังกล่าวได้อย่างไร นี่เป็นคำถามที่เกี่ยวข้อง แต่ไม่มีคำตอบสำหรับฉันเลย

แก้ไข : สิ่งที่เกี่ยวกับการแยกไฟล์ในกลุ่มของ 10GBs (หรืออะไรก็ได้) และนำไปใช้sedกับแต่ละคนแล้วรวมกับพวกเขาcat? มันสมเหตุสมผลไหม มีวิธีแก้ปัญหาที่สง่างามกว่านี้ไหม?

เครื่องมือประมวลผลข้อความตามปกติไม่ได้ออกแบบมาเพื่อจัดการกับสายที่ไม่พอดีกับ RAM พวกเขามีแนวโน้มที่จะทำงานโดยการอ่านหนึ่งระเบียน (หนึ่งบรรทัด) จัดการกับมันและส่งออกผลลัพธ์จากนั้นดำเนินการไปยังระเบียนถัดไป (บรรทัด)

หากมีอักขระ 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 ทำงานได้อย่างราบรื่นบนไฟล์ที่ไม่ได้จบด้วยการขึ้นบรรทัดใหม่นั่นคือมันจะประมวลผลบางส่วนของบรรทัดสุดท้ายโดยไม่ตัดทอนและไม่ต้องต่อท้าย newline สุดท้าย มันทำงานร่วมกับ GNU sed หากคุณสามารถเลือกอักขระสุดท้ายของไฟล์เป็นตัวคั่นเร็กคอร์ดคุณจะหลีกเลี่ยงปัญหาการพกพา

สำหรับไฟล์ขนาดใหญ่ความเป็นไปได้อย่างหนึ่งคือเฟล็กซ์ อนุญาต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 โดยเฉพาะอย่างยิ่งการดูแลเป็นสิ่งจำเป็นเพื่อหลีกเลี่ยงการคัดลอกไฟล์ในหน่วยความจำซึ่งจะเอาชนะจุดทั้งหมด ในด้านบวกคุณจะได้รับรายงานข้อผิดพลาดฟรี (หลาม "ข้อยกเว้น") :)

#!/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 อาจทำงานได้ดีขึ้นมาก:

#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>ข้อผิดพลาดคงยังมีรูปแบบ

มีreplaceยูทิลิตี้ในแพ็คเกจ mariadb-server / mysql-server มันแทนที่สตริงง่าย (ไม่แสดงออกปกติ) และแตกต่างจาก grep / sed / awk replaceไม่สนใจเกี่ยวกับและ\n \0การใช้หน่วยความจำคงที่เมื่อมีไฟล์อินพุต (ประมาณ 400kb บนเครื่องของฉัน)

แน่นอนคุณไม่จำเป็นต้องเรียกใช้เซิร์ฟเวอร์ mysql เพื่อที่จะใช้replaceมันเป็นแพคเกจแบบนั้นใน Fedora เท่านั้น distros / ระบบปฏิบัติการอื่น ๆ อาจแยกบรรจุเป็นชุด

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'

ที่นี่โฟลด์จะคว้าได้สูงสุด 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::Handle's 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. คุณอาจต้องการตรวจสอบให้แน่ใจว่าวิธีการบัฟเฟอร์ของเราไม่ข้ามCHUNKSIZEขอบเขตหากคุณเปลี่ยนมากกว่า 1 ไบต์

คุณสามารถลองbbe (ตัวแก้ไขบล็อกไบนารี ) ซึ่งเป็น " sedสำหรับไฟล์ไบนารี"

ฉันประสบความสำเร็จในการใช้งานกับไฟล์ข้อความ 7GB โดยไม่มีEOLตัวอักษรแทนที่สตริงที่มีความยาวต่างกันหลายรายการ หากไม่พยายามเพิ่มประสิทธิภาพใด ๆ มันจะทำให้การประมวลผลโดยเฉลี่ย>> 50MB / s

ด้วยperlคุณสามารถทำงานกับบันทึกความยาวคงที่เช่น:

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

และหวังว่าจะไม่มีการ<unk>ขยายไปทั่วทั้งสองระเบียน 100MB เหล่านั้น

นี่คือโปรแกรม 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

แก้ไข:

ขออภัยฉันไม่ได้อ่านว่าทุกอย่างอยู่ในบรรทัดเดียวดังนั้นฉันพยายามอ่านตัวอักษรของไฟล์ทีละตัวอักษร

แก้ไขครั้งที่สอง:

ใช้โปรแกรมแก้ไขเดียวกันกับโปรแกรม C

สิ่งนี้อาจเกินความจำเป็นสำหรับไฟล์ 70GB และการค้นหาและแทนที่อย่างง่าย แต่กรอบงาน Hadoop MapReduce จะช่วยแก้ปัญหาของคุณได้ทันทีโดยไม่ต้องเสียค่าใช้จ่าย (เลือกตัวเลือก 'โหนดเดียว' เมื่อตั้งค่าเพื่อเรียกใช้ภายในเครื่อง) - และสามารถ ปรับขนาดเป็นความจุไม่ จำกัด ในอนาคตโดยไม่จำเป็นต้องแก้ไขโค้ด

กวดวิชาอย่างเป็นทางการที่https://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.htmlใช้ (ง่ายมาก) Java แต่คุณสามารถค้นหาห้องสมุดลูกค้าสำหรับ Perl หรือ ภาษาอะไรก็ตามที่คุณรู้สึกอยากใช้

ดังนั้นหากในภายหลังคุณพบว่าคุณกำลังทำการดำเนินการที่ซับซ้อนมากขึ้นในไฟล์ข้อความ 7000GB - และต้องทำเช่นนี้ 100 ครั้งต่อวัน - คุณสามารถแจกจ่ายภาระงานข้ามหลายโหนดที่คุณจัดเตรียมไว้หรือจัดเตรียมไว้ให้คุณโดยอัตโนมัติ คลัสเตอร์ Hadoop

คำแนะนำก่อนหน้านี้ทั้งหมดต้องการการอ่านไฟล์ทั้งหมดและการเขียนไฟล์ทั้งหมด สิ่งนี้ไม่เพียงใช้เวลานาน แต่ยังต้องการพื้นที่ว่าง 70GB

1) ถ้าฉันเข้าใจกรณีที่คุณระบุอย่างถูกต้องเป็นที่ยอมรับหรือไม่ที่จะแทนที่ด้วยสตริงอื่นของความยาว SAME

2a) มีเหตุการณ์หลายครั้งหรือไม่? 2b) ถ้าเช่นนั้นคุณรู้ว่ามีเท่าไหร่

ฉันแน่ใจว่าคุณได้แก้ไขปัญหาในปีนี้แล้วและฉันต้องการทราบว่าคุณใช้โซลูชันใด

ฉันเสนอวิธีแก้ปัญหา (เป็นไปได้มากที่สุดใน C) ที่จะอ่านบล็อกของไฟล์ที่ค้นหาแต่ละสายสำหรับคำนึงถึงการข้ามบล็อกที่เป็นไปได้ เมื่อพบว่าแทนที่สตริงด้วยความยาว SAME ทางเลือกและเขียนเฉพาะบล็อกนั้น ดำเนินการต่อสำหรับจำนวนเหตุการณ์ที่ทราบหรือจนถึงจุดสิ้นสุดไฟล์ สิ่งนี้จะต้องมีการเขียนจำนวนครั้งน้อยที่สุดและมากที่สุดเป็นสองเท่า (ถ้าการเกิดขึ้นทุกครั้งถูกแบ่งระหว่าง 2 บล็อก) นี้จะต้องไม่มีพื้นที่เพิ่มเติม!

หากเรามีจำนวนขั้นต่ำ<unk>(ตามที่กฎหมายของ Zipf คาดไว้)

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