|
import shutil |
|
import os, sys |
|
from subprocess import check_call, check_output |
|
import glob |
|
import argparse |
|
import shutil |
|
import pathlib |
|
import itertools |
|
|
|
def call_output(cmd): |
|
print(f"Executing: {cmd}") |
|
ret = check_output(cmd, shell=True) |
|
print(ret) |
|
return ret |
|
|
|
def call(cmd): |
|
print(cmd) |
|
check_call(cmd, shell=True) |
|
|
|
|
|
WORKDIR_ROOT = os.environ.get('WORKDIR_ROOT', None) |
|
|
|
if WORKDIR_ROOT is None or not WORKDIR_ROOT.strip(): |
|
print('please specify your working directory root in OS environment variable WORKDIR_ROOT. Exitting..."') |
|
sys.exit(-1) |
|
|
|
SPM_PATH = os.environ.get('SPM_PATH', None) |
|
|
|
if SPM_PATH is None or not SPM_PATH.strip(): |
|
print("Please install sentence piecence from https://github.com/google/sentencepiece and set SPM_PATH pointing to the installed spm_encode.py. Exitting...") |
|
sys.exit(-1) |
|
|
|
|
|
SPM_MODEL = f'{WORKDIR_ROOT}/sentence.bpe.model' |
|
SPM_VOCAB = f'{WORKDIR_ROOT}/dict_250k.txt' |
|
|
|
SPM_ENCODE = f'{SPM_PATH}' |
|
|
|
if not os.path.exists(SPM_MODEL): |
|
call(f"wget https://dl.fbaipublicfiles.com/fairseq/models/mbart50/sentence.bpe.model -O {SPM_MODEL}") |
|
|
|
|
|
if not os.path.exists(SPM_VOCAB): |
|
call(f"wget https://dl.fbaipublicfiles.com/fairseq/models/mbart50/dict_250k.txt -O {SPM_VOCAB}") |
|
|
|
|
|
|
|
def get_data_size(raw): |
|
cmd = f'wc -l {raw}' |
|
ret = call_output(cmd) |
|
return int(ret.split()[0]) |
|
|
|
def encode_spm(model, direction, prefix='', splits=['train', 'test', 'valid'], pairs_per_shard=None): |
|
src, tgt = direction.split('-') |
|
|
|
for split in splits: |
|
src_raw, tgt_raw = f'{RAW_DIR}/{split}{prefix}.{direction}.{src}', f'{RAW_DIR}/{split}{prefix}.{direction}.{tgt}' |
|
if os.path.exists(src_raw) and os.path.exists(tgt_raw): |
|
cmd = f"""python {SPM_ENCODE} \ |
|
--model {model}\ |
|
--output_format=piece \ |
|
--inputs {src_raw} {tgt_raw} \ |
|
--outputs {BPE_DIR}/{direction}{prefix}/{split}.bpe.{src} {BPE_DIR}/{direction}{prefix}/{split}.bpe.{tgt} """ |
|
print(cmd) |
|
call(cmd) |
|
|
|
|
|
def binarize_( |
|
bpe_dir, |
|
databin_dir, |
|
direction, spm_vocab=SPM_VOCAB, |
|
splits=['train', 'test', 'valid'], |
|
): |
|
src, tgt = direction.split('-') |
|
|
|
try: |
|
shutil.rmtree(f'{databin_dir}', ignore_errors=True) |
|
os.mkdir(f'{databin_dir}') |
|
except OSError as error: |
|
print(error) |
|
cmds = [ |
|
"fairseq-preprocess", |
|
f"--source-lang {src} --target-lang {tgt}", |
|
f"--destdir {databin_dir}/", |
|
f"--workers 8", |
|
] |
|
if isinstance(spm_vocab, tuple): |
|
src_vocab, tgt_vocab = spm_vocab |
|
cmds.extend( |
|
[ |
|
f"--srcdict {src_vocab}", |
|
f"--tgtdict {tgt_vocab}", |
|
] |
|
) |
|
else: |
|
cmds.extend( |
|
[ |
|
f"--joined-dictionary", |
|
f"--srcdict {spm_vocab}", |
|
] |
|
) |
|
input_options = [] |
|
if 'train' in splits and glob.glob(f"{bpe_dir}/train.bpe*"): |
|
input_options.append( |
|
f"--trainpref {bpe_dir}/train.bpe", |
|
) |
|
if 'valid' in splits and glob.glob(f"{bpe_dir}/valid.bpe*"): |
|
input_options.append(f"--validpref {bpe_dir}/valid.bpe") |
|
if 'test' in splits and glob.glob(f"{bpe_dir}/test.bpe*"): |
|
input_options.append(f"--testpref {bpe_dir}/test.bpe") |
|
if len(input_options) > 0: |
|
cmd = " ".join(cmds + input_options) |
|
print(cmd) |
|
call(cmd) |
|
|
|
|
|
def binarize( |
|
databin_dir, |
|
direction, spm_vocab=SPM_VOCAB, prefix='', |
|
splits=['train', 'test', 'valid'], |
|
pairs_per_shard=None, |
|
): |
|
def move_databin_files(from_folder, to_folder): |
|
for bin_file in glob.glob(f"{from_folder}/*.bin") \ |
|
+ glob.glob(f"{from_folder}/*.idx") \ |
|
+ glob.glob(f"{from_folder}/dict*"): |
|
try: |
|
shutil.move(bin_file, to_folder) |
|
except OSError as error: |
|
print(error) |
|
bpe_databin_dir = f"{BPE_DIR}/{direction}{prefix}_databin" |
|
bpe_dir = f"{BPE_DIR}/{direction}{prefix}" |
|
if pairs_per_shard is None: |
|
binarize_(bpe_dir, bpe_databin_dir, direction, spm_vocab=spm_vocab, splits=splits) |
|
move_databin_files(bpe_databin_dir, databin_dir) |
|
else: |
|
|
|
binarize_( |
|
bpe_dir, bpe_databin_dir, direction, |
|
spm_vocab=spm_vocab, splits=[s for s in splits if s != "train"]) |
|
for shard_bpe_dir in glob.glob(f"{bpe_dir}/shard*"): |
|
path_strs = os.path.split(shard_bpe_dir) |
|
shard_str = path_strs[-1] |
|
shard_folder = f"{bpe_databin_dir}/{shard_str}" |
|
databin_shard_folder = f"{databin_dir}/{shard_str}" |
|
print(f'working from {shard_folder} to {databin_shard_folder}') |
|
os.makedirs(databin_shard_folder, exist_ok=True) |
|
binarize_( |
|
shard_bpe_dir, shard_folder, direction, |
|
spm_vocab=spm_vocab, splits=["train"]) |
|
|
|
for test_data in glob.glob(f"{bpe_databin_dir}/valid.*") + glob.glob(f"{bpe_databin_dir}/test.*"): |
|
filename = os.path.split(test_data)[-1] |
|
try: |
|
os.symlink(test_data, f"{databin_shard_folder}/{filename}") |
|
except OSError as error: |
|
print(error) |
|
move_databin_files(shard_folder, databin_shard_folder) |
|
|
|
|
|
def load_langs(path): |
|
with open(path) as fr: |
|
langs = [l.strip() for l in fr] |
|
return langs |
|
|
|
if __name__ == '__main__': |
|
parser = argparse.ArgumentParser() |
|
parser.add_argument("--data_root", default=f"{WORKDIR_ROOT}/ML50") |
|
parser.add_argument("--raw-folder", default='raw') |
|
parser.add_argument("--bpe-folder", default='bpe') |
|
parser.add_argument("--databin-folder", default='databin') |
|
|
|
args = parser.parse_args() |
|
|
|
DATA_PATH = args.data_root |
|
RAW_DIR = f'{DATA_PATH}/{args.raw_folder}' |
|
BPE_DIR = f'{DATA_PATH}/{args.bpe_folder}' |
|
DATABIN_DIR = f'{DATA_PATH}/{args.databin_folder}' |
|
os.makedirs(BPE_DIR, exist_ok=True) |
|
|
|
raw_files = itertools.chain( |
|
glob.glob(f'{RAW_DIR}/train*'), |
|
glob.glob(f'{RAW_DIR}/valid*'), |
|
glob.glob(f'{RAW_DIR}/test*'), |
|
) |
|
|
|
directions = [os.path.split(file_path)[-1].split('.')[1] for file_path in raw_files] |
|
|
|
for direction in directions: |
|
prefix = "" |
|
splits = ['train', 'valid', 'test'] |
|
try: |
|
shutil.rmtree(f'{BPE_DIR}/{direction}{prefix}', ignore_errors=True) |
|
os.mkdir(f'{BPE_DIR}/{direction}{prefix}') |
|
os.makedirs(DATABIN_DIR, exist_ok=True) |
|
except OSError as error: |
|
print(error) |
|
spm_model, spm_vocab = SPM_MODEL, SPM_VOCAB |
|
encode_spm(spm_model, direction=direction, splits=splits) |
|
binarize(DATABIN_DIR, direction, spm_vocab=spm_vocab, splits=splits) |
|
|
