[机器翻译] multilingual fairseq-preprocess的两种做法

已于 2022-07-25 21:20:31 修改
阅读量1.3k 收藏 5
点赞数 2
分类专栏： 机器翻译 文章标签： 机器翻译 深度学习 人工智能
于 2022-05-30 23:57:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jokerxsy/article/details/125054739
版权

文章目录

前言

fairseq给出的preprocess代码只支持一个语言对的binarize，而笔者在[机器翻译] 记一次多语言机器翻译模型的训练想要对多个语言对同时进行binarize，过程中能够创建一个共享的词典。
和师兄交流之后，实现这一结果有两种方式：1. 在使用sentencepiece学习bpe之后，就会得到一个共享词表，需要对这个词表进行一些修改，然后作为binarize的参数；2. 不使用bpe得到的词表，而是做两次binarize，第一次是为每一个语言对进行一次binarize，然后得到不同的词表。接着将这些词表进行合并，作为第二次binarize的参数。
本文内容：

  1. 本文记录笔者通过对fairseq-preprocess流程的理解，参考https://github.com/RayeRen/multilingual-kd-pytorch/blob/master/preprocess_universal.py，实现更加简便的、一步到位的多个语言对binarize流程。
  2. 当然，本文也给出了上面所说的第一种的预处理方式。（关于第二种，随缘补充）

内容1基于subword-nmt进行bpe；内容2基于sentence-piece进行bpe。

multilingual fairseq-preprocess1(iwslt14_preprocess_subwordnmt_new_version)

方法简介

该方法通过对fairseq.fairseq_cli.preprocess.py的理解，修改得到一个用于multilingual fairseq-preprocess的代码。
[机器翻译] 记一次多语言机器翻译模型的训练中也记录了类似过程，但由于那个版本(iwslt14_preprocess_old_version)中使用的fairseq版本太老，一般不适用于新版本的fairseq，所以下面给出了解决方案，主要是修改了preprocess_multilingual.py的代码。

脚本运行

bash prepare-iwslt14.sh

具体实现

具体来说，首先在当前目录下创建预处理脚本文件：prepare-iwslt14.sh和preprocess_multilingual.py，这两个文件各自的代码如下：

#!/usr/bin/env bash
#
# Adapted from https://github.com/facebookresearch/MIXER/blob/master/prepareData.sh
echo 'Cloning Moses github repository (for tokenization scripts)...'
git clone https://github.com/moses-smt/mosesdecoder.git

echo 'Cloning Subword NMT repository (for BPE pre-processing)...'
git clone https://github.com/rsennrich/subword-nmt.git

SCRIPTS=mosesdecoder/scripts
TOKENIZER=$SCRIPTS/tokenizer/tokenizer.perl
LC=$SCRIPTS/tokenizer/lowercase.perl
CLEAN=$SCRIPTS/training/clean-corpus-n.perl
BPEROOT=subword-nmt
BPE_TOKENS=30000
prep=iwslt14.tokenized
tmp=$prep/tmp
orig=orig
rm -r $orig
rm -r $tmp
rm -r $prep
mkdir -p $orig $tmp $prep

for src in ar de es fa he it nl pl; do
    tgt=en
    lang=$src-en

    echo "pre-processing train data..."
    for l in $src $tgt; do
        if [[ ! -f $src-en.tgz ]]; then
            wget https://wit3.fbk.eu/archive/2014-01//texts/$src/en/$src-en.tgz
        fi
        cd $orig
        tar zxvf ../$src-en.tgz
        cd ..

        f=train.tags.$lang.$l
        tok=train.tags.$lang.tok.$l

        cat $orig/$lang/$f | \
        grep -v '<url>' | \
        grep -v '<talkid>' | \
        grep -v '<keywords>' | \
        sed -e 's/<title>//g' | \
        sed -e 's/<\/title>//g' | \
        sed -e 's/<description>//g' | \
        sed -e 's/<\/description>//g' | \
        perl $TOKENIZER -threads 8 -l $l > $tmp/$tok
        echo ""
    done
    perl $CLEAN -ratio 1.5 $tmp/train.tags.$lang.tok $src $tgt $tmp/train.tags.$lang.clean 1 175
    for l in $src $tgt; do
        perl $LC < $tmp/train.tags.$lang.clean.$l > $tmp/train.tags.$lang.$l
    done

    echo "pre-processing valid/test data..."
    for l in $src $tgt; do
        for o in `ls $orig/$lang/IWSLT14.TED*.$l.xml`; do
        fname=${o##*/}
        f=$tmp/${fname%.*}
        echo $o $f
        grep '<seg id' $o | \
            sed -e 's/<seg id="[0-9]*">\s*//g' | \
            sed -e 's/\s*<\/seg>\s*//g' | \
            sed -e "s/\’/\'/g" | \
        perl $TOKENIZER -threads 8 -l $l | \
        perl $LC > $f
        echo ""
        done
    done


    echo "creating train, valid, test..."
    for l in $src $tgt; do
        awk '{if (NR%23 == 0)  print $0; }' $tmp/train.tags.$src-$tgt.$l > $tmp/valid.en-$src.$l
        awk '{if (NR%23 != 0)  print $0; }' $tmp/train.tags.$src-$tgt.$l > $tmp/train.en-$src.$l

        cat $tmp/IWSLT14.TED.dev2010.$src-$tgt.$l \
            $tmp/IWSLT14.TEDX.dev2012.$src-$tgt.$l \
            $tmp/IWSLT14.TED.tst2010.$src-$tgt.$l \
            $tmp/IWSLT14.TED.tst2011.$src-$tgt.$l \
            $tmp/IWSLT14.TED.tst2012.$src-$tgt.$l \
            > $tmp/test.en-$src.$l
    done

    TRAIN=$tmp/train.all
    BPE_CODE=$prep/code
    rm -f $TRAIN
    for l in $src $tgt; do
        cat $tmp/train.en-$src.$l >> $TRAIN
    done
done
echo "learn_bpe.py on ${TRAIN}..."
python $BPEROOT/learn_bpe.py -s $BPE_TOKENS < $TRAIN > $BPE_CODE

for src in ar de es fa he it nl pl; do
    for L in $src $tgt; do
        for f in train.en-$src.$L valid.en-$src.$L test.en-$src.$L; do
            echo "apply_bpe.py to ${f}..."
            python $BPEROOT/apply_bpe.py -c $BPE_CODE < $tmp/$f > $prep/$f
        done
    done
done

rm -r text
mkdir -p text/train_data
mkdir -p text/valid_data
mkdir -p text/test_data
cp iwslt14.tokenized/train.en-* text/train_data/
cp iwslt14.tokenized/valid.en-* text/valid_data/
cp iwslt14.tokenized/test.en-* text/test_data/
python preprocess_multilingual.py --pref=text --destdir=data-bin
  • preprocess_multilingual.py
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""
Data multilingual preprocess: build vocabularies and binarize multilingual training data.
"""

import logging
import os
import shutil
import sys
import typing as tp
from argparse import Namespace
from itertools import zip_longest
import glob
from fairseq import options, tasks, utils
from fairseq.binarizer import (
    AlignmentDatasetBinarizer,
    FileBinarizer,
    VocabularyDatasetBinarizer,
)
from fairseq.data import Dictionary

logging.basicConfig(
    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
    level=os.environ.get("LOGLEVEL", "INFO").upper(),
    stream=sys.stdout,
)
logger = logging.getLogger("fairseq_cli.preprocess")


#####################################################################
# file name tools
#####################################################################


def _train_path(lang, trainpref):
    return "{}{}".format(trainpref, ("." + lang) if lang else "")


def _file_name(prefix, lang):
    fname = prefix
    if lang is not None:
        fname += ".{lang}".format(lang=lang)
    return fname


def _dest_path(prefix, lang, destdir):
    return os.path.join(destdir, _file_name(prefix, lang))


def _dict_path(lang, destdir):
    return _dest_path("dict", lang, destdir) + ".txt"


def dataset_dest_prefix(args, output_prefix, lang):
    base = os.path.join(args.destdir, output_prefix)
    if lang is not None:
        lang_part = f".{args.source_lang}-{args.target_lang}.{lang}"
    elif args.only_source:
        lang_part = ""
    else:
        lang_part = f".{args.source_lang}-{args.target_lang}"

    return "{}{}".format(base, lang_part)


def dataset_dest_file(args, output_prefix, lang, extension):
    return "{}.{}".format(dataset_dest_prefix(args, output_prefix, lang), extension)


#####################################################################
# dictionary tools
#####################################################################


def _build_dictionary(
        filenames,
        task,
        args,
        src=False,
        tgt=False,
):
    assert src ^ tgt
    return task.build_dictionary(
        filenames,
        workers=args.workers,
        threshold=args.thresholdsrc if src else args.thresholdtgt,
        nwords=args.nwordssrc if src else args.nwordstgt,
        padding_factor=args.padding_factor,
    )


#####################################################################
# bin file creation logic
#####################################################################


def _make_binary_dataset(
        vocab: Dictionary,
        input_prefix: str,
        output_prefix: str,
        lang: tp.Optional[str],
        num_workers: int,
        args: Namespace,
):
    logger.info("[{}] Dictionary: {} types".format(lang, len(vocab)))

    binarizer = VocabularyDatasetBinarizer(
        vocab,
        append_eos=True,
    )

    input_file = "{}{}".format(input_prefix, ("." + lang) if lang is not None else "")
    full_output_prefix = dataset_dest_prefix(args, output_prefix, lang)

    final_summary = FileBinarizer.multiprocess_dataset(
        input_file,
        args.dataset_impl,
        binarizer,
        full_output_prefix,
        vocab_size=len(vocab),
        num_workers=num_workers,
    )

    logger.info(f"[{lang}] {input_file}: {final_summary} (by {vocab.unk_word})")


def _make_binary_alignment_dataset(
        input_prefix: str, output_prefix: str, num_workers: int, args: Namespace
):
    binarizer = AlignmentDatasetBinarizer(utils.parse_alignment)

    input_file = input_prefix
    full_output_prefix = dataset_dest_prefix(args, output_prefix, lang=None)

    final_summary = FileBinarizer.multiprocess_dataset(
        input_file,
        args.dataset_impl,
        binarizer,
        full_output_prefix,
        vocab_size=None,
        num_workers=num_workers,
    )

    logger.info(
        "[alignments] {}: parsed {} alignments".format(
            input_file, final_summary.num_seq
        )
    )


#####################################################################
# routing logic
#####################################################################


def _make_dataset(
        vocab: Dictionary,
        input_prefix: str,
        output_prefix: str,
        lang: tp.Optional[str],
        args: Namespace,
        num_workers: int,
):
    if args.dataset_impl == "raw":
        # Copy original text file to destination folder
        output_text_file = _dest_path(
            output_prefix + ".{}-{}".format(args.source_lang, args.target_lang),
            lang,
            args.destdir,
        )
        shutil.copyfile(_file_name(input_prefix, lang), output_text_file)
    else:
        _make_binary_dataset(
            vocab, input_prefix, output_prefix, lang, num_workers, args
        )


def _make_all(lang, vocab, args):
    lng_pair = f"{args.source_lang}-{args.target_lang}"
    _make_dataset( ## iwslt14.tokenized/train.en-ar
        vocab, os.path.join(args.pref, "train_data", f"train.{lng_pair}"), "train", lang, args=args, num_workers=args.workers
    )
    _make_dataset(
        vocab, os.path.join(args.pref, "valid_data", f"valid.{lng_pair}"), "valid", lang, args=args, num_workers=args.workers
    )
    _make_dataset(
        vocab, os.path.join(args.pref, "test_data", f"test.{lng_pair}"), "test", lang, args=args, num_workers=args.workers
    )


def _make_all_alignments(args):
    if args.trainpref and os.path.exists(args.trainpref + "." + args.align_suffix):
        _make_binary_alignment_dataset(
            args.trainpref + "." + args.align_suffix,
            "train.align",
            num_workers=args.workers,
            args=args,
        )
    if args.validpref and os.path.exists(args.validpref + "." + args.align_suffix):
        _make_binary_alignment_dataset(
            args.validpref + "." + args.align_suffix,
            "valid.align",
            num_workers=args.workers,
            args=args,
        )
    if args.testpref and os.path.exists(args.testpref + "." + args.align_suffix):
        _make_binary_alignment_dataset(
            args.testpref + "." + args.align_suffix,
            "test.align",
            num_workers=args.workers,
            args=args,
        )


#####################################################################
# align
#####################################################################


def _align_files(args, src_dict, tgt_dict):
    assert args.trainpref, "--trainpref must be set if --alignfile is specified"
    src_file_name = _train_path(args.source_lang, args.trainpref)
    tgt_file_name = _train_path(args.target_lang, args.trainpref)
    freq_map = {}
    with open(args.alignfile, "r", encoding="utf-8") as align_file:
        with open(src_file_name, "r", encoding="utf-8") as src_file:
            with open(tgt_file_name, "r", encoding="utf-8") as tgt_file:
                for a, s, t in zip_longest(align_file, src_file, tgt_file):
                    si = src_dict.encode_line(s, add_if_not_exist=False)
                    ti = tgt_dict.encode_line(t, add_if_not_exist=False)
                    ai = list(map(lambda x: tuple(x.split("-")), a.split()))
                    for sai, tai in ai:
                        srcidx = si[int(sai)]
                        tgtidx = ti[int(tai)]
                        if srcidx != src_dict.unk() and tgtidx != tgt_dict.unk():
                            assert srcidx != src_dict.pad()
                            assert srcidx != src_dict.eos()
                            assert tgtidx != tgt_dict.pad()
                            assert tgtidx != tgt_dict.eos()
                            if srcidx not in freq_map:
                                freq_map[srcidx] = {}
                            if tgtidx not in freq_map[srcidx]:
                                freq_map[srcidx][tgtidx] = 1
                            else:
                                freq_map[srcidx][tgtidx] += 1
    align_dict = {}
    for srcidx in freq_map.keys():
        align_dict[srcidx] = max(freq_map[srcidx], key=freq_map[srcidx].get)
    with open(
            os.path.join(
                args.destdir,
                "alignment.{}-{}.txt".format(args.source_lang, args.target_lang),
            ),
            "w",
            encoding="utf-8",
    ) as f:
        for k, v in align_dict.items():
            print("{} {}".format(src_dict[k], tgt_dict[v]), file=f)


#####################################################################
# MAIN
#####################################################################


def main(args):
    # setup some basic things
    utils.import_user_module(args)

    os.makedirs(args.destdir, exist_ok=True)

    logger.addHandler(
        logging.FileHandler(
            filename=os.path.join(args.destdir, "preprocess.log"),
        )
    )
    logger.info(args)

    assert (
            args.dataset_impl != "huffman"
    ), "preprocessing.py doesn't support Huffman yet, use HuffmanCodeBuilder directly."

    # build shared dictionaries

    # target = not args.only_source

    train_files = glob.glob('{}/train_data/train.*-*.*'.format(args.pref))
    train_files = [f for f in train_files if len(f.split('.')) in [3, 4, 5]]
    test_files = glob.glob('{}/valid_data/test.*-*.*'.format(args.pref))
    test_files = [f for f in test_files if len(f.split('.')) in [3, 4, 5]]
    valid_files = glob.glob('{}/test_data/valid.*-*.*'.format(args.pref))
    valid_files = [f for f in valid_files if len(f.split('.')) in [3, 4, 5]]
    lng_pairs = set([f.split('/')[-1].split(".")[1] for f in (train_files + test_files + valid_files)])
    task = tasks.get_task(args.task)
    shared_dictionary = _build_dictionary(
        train_files,
        task=task,
        args=args,
        src=True,
    )
    # save dictionaries
    if args.joined_dictionary:
        shared_dictionary.save(os.path.join(args.destdir, "dict.txt"))
    else:
        for lng_pair in lng_pairs:
            src, tgt = lng_pair.split('-')
            tmp_src_dict_path = os.path.join(args.destdir, f'dict.{src}.txt')
            tmp_tgt_dict_path = os.path.join(args.destdir, f'dict.{tgt}.txt')
            if not os.path.exists(tmp_src_dict_path):
                shared_dictionary.save(tmp_src_dict_path)
            if not os.path.exists(tmp_tgt_dict_path):
                shared_dictionary.save(tmp_tgt_dict_path)

    if args.dict_only:
        return

    for lng_pair in lng_pairs:
        src_and_tgt = lng_pair.split('-')
        if len(src_and_tgt) != 2:
            continue
        src, tgt = src_and_tgt
        print("| building: ", src, tgt)
        args.source_lang = src
        args.target_lang = tgt
        _make_all(src, shared_dictionary, args)
        _make_all(tgt, shared_dictionary, args)


    logger.info("Wrote preprocessed data to {}".format(args.destdir))


def cli_main():
    parser = options.get_preprocessing_parser()
    parser.add_argument('--pref', metavar='FP', default=None, help='data prefix')
    args = parser.parse_args()
    main(args)


if __name__ == "__main__":
    cli_main()

对于preprocess_multilingual.py的解释

从fairseq.fairseq_cli.preprocess.py中可以看到：

如果提供srcdict或者tgtdict，则会通过task.load_dictionary(args.srcdict)来读取词典。task.load_dictionary的执行流程为：[fairseq.tasks.translation.TranslationTask]->[fairseq.tasks.fairseq_task.FairseqTask.load_dictionary]->[fairseq.data.dictionary.Dictionary.load]->[fairseq.data.dictionary.Dictionary.add_from_file]。

如果不提供dict，则会通过task.build_dictionary来创建词典，[fairseq.tasks.fairseq_task.FairseqTask.build_dictionary代码如下：

d = Dictionary()
for filename in filenames:
    Dictionary.add_file_to_dictionary(
        filename, d, tokenizer.tokenize_line, workers
    )
d.finalize(threshold=threshold, nwords=nwords, padding_factor=padding_factor)
return d

只要把所有语言对的train data都加入到filenames中，就可以直接创建一个共享的词表，接下来只要用这个词表对所有语言对进行binarize就可以了。因此，修改过程如下：
笔者首先将fairseq.fairseq_cli.preprocess.py复制到当前目录一份，然后修改以下3个函数：

cli_main

def cli_main():
    parser = options.get_preprocessing_parser()
    parser.add_argument('--pref', metavar='FP', default=None, help='data prefix')
    args = parser.parse_args()
    main(args)

main

def main(args):
    # setup some basic things
    utils.import_user_module(args)

    os.makedirs(args.destdir, exist_ok=True)

    logger.addHandler(
        logging.FileHandler(
            filename=os.path.join(args.destdir, "preprocess.log"),
        )
    )
    logger.info(args)

    assert (
            args.dataset_impl != "huffman"
    ), "preprocessing.py doesn't support Huffman yet, use HuffmanCodeBuilder directly."

    # build shared dictionaries

    # target = not args.only_source

    train_files = glob.glob('{}/train.*-*.*'.format(args.pref))
    train_files = [f for f in train_files if len(f.split('.')) in [3, 4, 5]]
    test_files = glob.glob('{}/test.*-*.*'.format(args.pref))
    test_files = [f for f in test_files if len(f.split('.')) in [3, 4, 5]]
    valid_files = glob.glob('{}/valid.*-*.*'.format(args.pref))
    valid_files = [f for f in valid_files if len(f.split('.')) in [3, 4, 5]]
    lng_pairs = set([f.split('/')[-1].split(".")[1] for f in (train_files + test_files + valid_files)])
    task = tasks.get_task(args.task)
    shared_dictionary = _build_dictionary(
        train_files,
        task=task,
        args=args,
        src=True,
    )
    # save dictionaries
    if args.joined_dictionary:
        shared_dictionary.save(os.path.join(args.destdir, "dict.txt"))
    else:
        for lng_pair in lng_pairs:
            src, tgt = lng_pair.split('-')
            tmp_src_dict_path = os.path.join(args.destdir, f'dict.{src}.txt')
            tmp_tgt_dict_path = os.path.join(args.destdir, f'dict.{tgt}.txt')
            if not os.path.exists(tmp_src_dict_path):
                shared_dictionary.save(tmp_src_dict_path)
            if not os.path.exists(tmp_tgt_dict_path):
                shared_dictionary.save(tmp_tgt_dict_path)

    if args.dict_only:
        return

    for lng_pair in lng_pairs:
        src_and_tgt = lng_pair.split('-')
        if len(src_and_tgt) != 2:
            continue
        src, tgt = src_and_tgt
        print("| building: ", src, tgt)
        args.source_lang = src
        args.target_lang = tgt
        _make_all(src, shared_dictionary, args)
        _make_all(tgt, shared_dictionary, args)


    logger.info("Wrote preprocessed data to {}".format(args.destdir))

_make_all

def _make_all(lang, vocab, args):
    lng_pair = f"{args.source_lang}-{args.target_lang}"
    _make_dataset( ## iwslt14.tokenized/train.en-ar
        vocab, os.path.join(args.pref, f"train.{lng_pair}"), "train", lang, args=args, num_workers=args.workers
    )
    _make_dataset(
        vocab, os.path.join(args.pref, f"valid.{lng_pair}"), "valid", lang, args=args, num_workers=args.workers
    )
    _make_dataset(
        vocab, os.path.join(args.pref, f"test.{lng_pair}"), "test", lang, args=args, num_workers=args.workers
    )

multilingual fairseq-preprocess2(iwslt14_preprocess_sentencepiece)

方法简介

该方法在学习bpe之后，就会得到一个共享词表，需要对这个词表进行一些修改，然后作为binarize的参数。
该方法使用sentencepiece进行bpe。

具体实现

generate_split.sh

当前目录有以下文件：
在这里插入图片描述
执行下面脚本，完成数据的划分后，得到下面的文件，其中的train.all用于学习sentencepiece：
在这里插入图片描述

#!/usr/bin/env bash
# Adapted from https://github.com/facebookresearch/MIXER/blob/master/prepareData.sh

echo 'Cloning Moses github repository (for tokenization scripts)...'
git clone git://github.com/moses-smt/mosesdecoder.git

###
# just generate train\test\valid data for iwslt14
# with same simple preprocess steps and without tokenization, because the next step is learn spm
###
SCRIPTS=mosesdecoder/scripts
LC=$SCRIPTS/tokenizer/lowercase.perl
CLEAN=$SCRIPTS/training/clean-corpus-n.perl
tmp=tmp
orig=orig
tgt=en
rm -r $orig
rm -r $tmp
mkdir -p $orig $tmp

for src in ar de es fa he it nl pl; do
    lang=$src-en
    echo "pre-processing train data..."
    for l in $src $tgt; do
        if [[ ! -f $src-en.tgz ]]; then
            wget https://wit3.fbk.eu/archive/2014-01//texts/$src/en/$src-en.tgz
        fi
        cd $orig
        tar zxvf ../$src-en.tgz
        cd ..

        f=train.tags.$lang.$l

        cat $orig/$lang/$f | \
        grep -v '<url>' | \
        grep -v '<talkid>' | \
        grep -v '<keywords>' | \
        grep -v '<transcript>' | \
        sed -e 's/<title>//g' | \
        sed -e 's/<\/title>//g' | \
        sed -e 's/<description>//g' | \
        sed -e 's/<\/description>//g' > $tmp/$f
        echo ""
    done
    for l in $src $tgt; do
        perl $LC < $tmp/train.tags.$lang.$l > $tmp/train.$lang.$l
        rm $tmp/train.tags.$lang.$l
    done
    echo "pre-processing valid/test data..."
    for l in $src $tgt; do
      for o in `ls $orig/$lang/IWSLT14.TED*.$l.xml`; do
        fname=${o##*/}
        f=$tmp/${fname%.*}
        echo $o $f
        grep '<seg id' $o | \
            sed -e 's/<seg id="[0-9]*">\s*//g' | \
            sed -e 's/\s*<\/seg>\s*//g' | \
            sed -e "s/\’/\'/g" | \
        perl $LC > $f
        echo ""
        done
    done

    echo "creating train, valid, test..."
    for l in $src $tgt; do
      mv $tmp/train.$src-$tgt.$l $tmp/train-valid.$src-$tgt.$l
      awk '{if (NR%23 == 0)  print $0; }' $tmp/train-valid.$src-$tgt.$l > $tmp/valid.en-$src.$l
      awk '{if (NR%23 != 0)  print $0; }' $tmp/train-valid.$src-$tgt.$l > $tmp/train.en-$src.$l
      rm $tmp/train-valid.$src-$tgt.$l
      cat $tmp/IWSLT14.TED.dev2010.$src-$tgt.$l \
          $tmp/IWSLT14.TEDX.dev2012.$src-$tgt.$l \
          $tmp/IWSLT14.TED.tst2010.$src-$tgt.$l \
          $tmp/IWSLT14.TED.tst2011.$src-$tgt.$l \
          $tmp/IWSLT14.TED.tst2012.$src-$tgt.$l \
          > $tmp/test.en-$src.$l
      rm $tmp/IWSLT14.TED*.$src-$tgt.$l
    done


    TRAIN=$tmp/train.all
    for l in $src $tgt; do
        cat $tmp/train.en-$src.$l >> $TRAIN
    done
done

echo "counting..."
for src in ar de es fa he it nl pl; do
  for split in train valid test; do
    for l in $src $tgt; do
      wc -l $tmp/$split.en-$src.$l
    done
  done
done

echo "done"

learn_and_encode_spm-iwslt14.sh

学习spm，并apply，得到下面文件，用于binarize。

在这里插入图片描述

#!/usr/bin/env bash
echo 'Cloning fairseq repository...'
git clone git@github.com:facebookresearch/fairseq.git
# learn bpe
bpe=bpe
tmp=tmp
tgt=en
SCRIPTS=mosesdecoder/scripts
CLEAN=$SCRIPTS/training/clean-corpus-n.perl
rm -r $bpe
mkdir -p $bpe

python -u fairseq/scripts/spm_train.py \
  --input=$tmp/train.all \
  --model_prefix=spm.bpe \
  --vocab_size=30000 \
  --character_coverage=1.0 \
  --model_type=bpe \
  --num_threads=45 \
  --shuffle_input_sentence


# apply bpe
for split in train valid test; do
  for src in ar de es fa he it nl pl; do
    echo ${split} en-${src}
    python fairseq/scripts/spm_encode.py \
      --model spm.bpe.model \
      --output_format=piece \
      --inputs ${tmp}/${split}.en-${src}.${src} ${tmp}/${split}.en-${src}.en \
      --outputs ${bpe}/${split}.en-${src}.bpe.unclean.${src} ${bpe}/${split}.en-${src}.bpe.unclean.en
    perl $CLEAN -ratio 1.5 ${bpe}/${split}.en-${src}.bpe.unclean ${src} en ${bpe}/${split}.en-${src}.bpe 1 256
    rm ${bpe}/${split}.en-${src}.bpe.unclean.*
  done
done

binarize.sh

#!/usr/bin/env bash
# create share dict
path=data-bin
rm -r $path
mkdir -p $path

# https://github.com/facebookresearch/fairseq/issues/2110#issue-614837309
cut -f1 spm.bpe.vocab | tail -n +4 | sed "s/$/ 100/g" > $path/dict.txt
#for lang in ar de es fa he it nl pl en; do
#  cp $path/dict.txt $path/dict.${lang}.txt
#done

for src in ar de es fa he it nl pl; do
  echo en-${src}
  fairseq-preprocess \
      --source-lang $src --target-lang en \
      --trainpref bpe/train.en-${src}.bpe \
      --validpref bpe/valid.en-${src}.bpe \
      --testpref bpe/test.en-${src}.bpe \
      --destdir $path \
      --srcdict $path/dict.txt \
      --tgtdict $path/dict.txt
done

参考

https://github.com/RayeRen/multilingual-kd-pytorch/blob/master/data/iwslt/raw/prepare-iwslt14.sh
https://github.com/facebookresearch/fairseq/issues/2110#issue-614837309
https://github.com/facebookresearch/fairseq/tree/main/examples/m2m_100

Muasci
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2
07-18
huggingface下载速度慢，遇到sentence-transformers模型下载失败还是尽量使用进行本地下载改路径的方式。
fairseq读代码系列（二）——多语言的采样过程
rainy_universe的博客
03-20 600
本文旨在根据框架代码来探究一下fairseq是如何根据每个语言向的dataset和指定的max token/max sentence来确定每个batch的batch sampler的。
FAIRSEQ -- fairseq-preprocess command not found
qq_45736022的博客
12-08 2020
fairseq-preprocess command not found 对于新入坑的我们来说是很常见的一条报错，那这条报错基本上是因为没有安装editable。那解决方案也是很简单，在fairseq的官方安装说明中可以找到具体的操作步骤。 cd fairseq pip install editable ./ cd .. 在安装成功后可以在fairseq目录下出现 build 和 ==fairseq.eff-info==这两个新目录，接下来就可以直接使用 fairseq-preprocess 来调用pre
多语言多领域机器翻译系统的搭建
weixin_42288510的博客
06-03 846
多语言多领域机器翻译系统的搭建数据集开发环境数据处理工具数据处理流程分词加目标语标签BPE切分子词关于训练、解码和测试接口封装代码实现数据处理合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 数据集 训练集1：WMT14 Europarl
实习日记（二）：序列建模工具包——Fairseq
可乐的博客
01-17 2403
提示篇：   本篇博客内容较多，建议耐心阅读。 感谢篇：   十分感谢外研在线技术中心算法团队各位老师在我实习期间给予的帮助，好嗨皮的时光，学到了很多东西。【悄悄告诉你们：他们非常耐心 <(￣▽￣)/】 文章目录前言一、Fairseq简介二、Fairseq安装2.1 Fairseq0.9.0版本2.2 Fairseq最新版本（可能会有变化）三、Fairseq命令工具3.0 命令工具概述3.1 Fairseq-preprocess常用命令（一）预处理参数3.2 Fairseq-train(一) 数据
fairseq的使用
热门推荐
不负韶华，加油！
09-29 1万+
fairseq的使用 下载fairseq到本地 项目地址：https://github.com/pytorch/fairseq 运行fairseq项目出现报错： 解决方案： cd到fairseq的文件夹，执行 pip install --editable .
sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2 模型
06-30
这是一个句子转换器模型，它将句子和段落映射到 384 维密集向量空间，可用于聚类或语义搜索等任务，是 sentence_transformers 库的模型之一，官网下载速度缓慢，容易被墙，下载解压后，可以参考此文章进行模型本地...
Davlan/bert-base-multilingual-cased-ner-hrl NER命名实体识别模型
07-25
huggingface上的Davlan/bert-base-multilingual-cased-ner-hrl命名实体识别模型，包含中英等16种语言的人名、地名、组织识别
Language Models are Multilingual Chain-of-Thought Reasoners.pdf
05-18
Language Models are Multilingual Chain-of-Thought Reasoners.pdf
multilingual-react-demo:带有js-lingui的多语言React App
05-14
多语言React演示 带有多语言React App 该项目是通过引导的。
深度学习之基于Yolov7驾驶员疲劳检测系统
2301_79809972的博客
05-17 926
一、项目背景随着汽车保有量的不断增加，驾驶安全问题日益受到人们的关注。驾驶员疲劳驾驶是导致交通事故的重要原因之一。因此，开发一种能够实时监测驾驶员疲劳状态并提前发出预警的系统对于保障驾驶安全具有重要意义。近年来，深度学习技术特别是目标检测技术在计算机视觉领域取得了显著进展，为驾驶员疲劳检测提供了新的解决方案。本项目旨在利用YOLOv7算法，开发一个基于深度学习的驾驶员疲劳检测系统。二、项目目标。
深度学习之基于Matlab汽车目标检测
2301_79810943的博客
05-21 347
一、项目背景与意义随着自动驾驶和智能交通系统的快速发展，汽车目标检测成为了一个关键的技术环节。传统的汽车目标检测方法依赖于人工设计的特征和分类器，这些方法在复杂多变的环境中表现不佳。而基于深度学习的汽车目标检测方法能够自动学习和提取图像中的特征，具有更高的准确率和鲁棒性。因此，基于MATLAB的汽车目标检测项目旨在利用深度学习技术，实现对汽车目标的自动识别和定位，为自动驾驶和智能交通系统提供可靠的技术支持。二、技术架构与实现数据准备：收集包含汽车目标的图像数据，并进行数据标注。
基于python实现的深度学习的车牌识别系统
最新发布
liudefang的专栏
05-21 686
开发语言:Python。
梯度下降、反向传播、激活函数、参数初始化、批量归一化是深度学习中常用的几个概念
不正经的码狗
05-21 158
梯度下降、反向传播、激活函数、参数初始化、批量归一化是深度学习中常用的几个概念。下面我将对这些概念进行简要的凝练解释，并给出相应的例子。
深入理解深度学习中的激活层：Sigmoid和Softmax作为非终结层的应用
qlkaicx的博客
05-21 427
σx11e−xσx1e−x1​这使得它非常适合于二分类问题的输出层，比如预测一个事件发生与否。
深度学习之基于YoloV5行人及车辆多目标跟踪检测系统
2301_79809972的博客
05-21 217
   一、项目背景与目标随着城市交通的日益复杂，对行人和车辆的实时跟踪检测需求愈发迫切。本项目旨在利用深度学习技术，构建一个基于YoloV5的行人及车辆多目标跟踪检测系统，以提高交通监控的智能化水平，确保道路交通安全。二、技术选型与特点技术选型： YoloV5：作为目标检测的核心算法，YoloV5以其高效、准确的特点成为本项目的首选。它能够在保持高精度的同时，实现较快的检测速度，非常适用于实时性要求较高的场景。 深度学习框架：采用PyTorch等深度学习框架作为技术支撑，利用其强大的计算能力和灵活的编程接口
深度学习之基于YoloV5钢材微小缺陷检测系统
2301_79809972的博客
05-21 204
一、项目背景与目标在钢材生产过程中，由于各种因素，钢材表面可能会出现微小缺陷，如裂纹、气孔等。这些缺陷如果不及时发现和处理，将会严重影响钢材的质量和安全性。因此，开发一个能够准确、快速地检测钢材微小缺陷的系统显得尤为重要。本项目旨在利用深度学习技术，具体是YOLOv5算法，构建一个钢材微小缺陷检测系统，以提高钢材生产的质量控制水平。二、技术选型与特点YOLOv5算法：YOLOv5是一种实时目标检测算法，具有高效、准确的特点。
深度学习之基于Django+Tensorflow卷积神经网络车辆车型分类识别系统
2301_79809972的博客
05-21 167
一、项目背景与目标在智能交通和自动驾驶技术日益发展的背景下，车辆车型分类识别技术显得尤为重要。为了满足交通监控、车辆管理等方面的需求，我们开发了基于Django和Tensorflow卷积神经网络的车辆车型分类识别系统。本项目的目标是构建一个高效、准确的系统，能够自动识别并分类不同的车辆车型，以提升交通管理的效率和安全性。二、技术选型Tensorflow：作为深度学习框架，Tensorflow被广泛应用于构建和训练神经网络模型。其强大的生态系统和广泛的应用基础使得它成为本项目的首选框架。
Python - 深度学习系列34 重塑实体识别
yukai08008的博客
05-21 501
transformers 演变出了两个主要分支BERT(Encoder Only)和GPT(Decoder Only)，中间分支的概念相对淡一些。本次的目的在与梳理和重建实体识别模型，来取得更好的效果。
如何用AutoTokenizer和AutoModel加载本地paraphrase-multilingual-MiniLM-L12-v2"模型
03-22
您可以使用以下代码来加载本地的"paraphrase-multilingual-MiniLM-L12-v2"模型： ``` from transformers import AutoTokenizer, AutoModel tokenizer = AutoTokenizer.from_pretrained("paraphrase-multilingual-MiniLM-L12-v2") model = AutoModel.from_pretrained("paraphrase-multilingual-MiniLM-L12-v2") ``` 这将使用AutoTokenizer和AutoModel从本地加载模型。请确保您已经下载了模型并将其保存在正确的路径下。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值