自然语言处理之机器翻译：Fairseq：神经机器翻译的评估方法

    import torch
    import torch.nn as nn
    import torch.optim as optim
    
    # 定义编码器
    class Encoder(nn.Module):
    def __init__(self, input_dim, emb_dim, enc_hid_dim, dec_hid_dim, dropout):
        super().__init__()
        self.embedding = nn.Embedding(input_dim, emb_dim)
        self.rnn = nn.GRU(emb_dim, enc_hid_dim, bidirectional=True)
        self.fc = nn.Linear(enc_hid_dim * 2, dec_hid_dim)
        self.dropout = nn.Dropout(dropout)
        
    def forward(self, src):
        embedded = self.dropout(self.embedding(src))
        outputs, hidden = self.rnn(embedded)
        hidden = torch.tanh(self.fc(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1)))
        return outputs, hidden
    
    # 定义解码器
    class Decoder(nn.Module):
    def __init__(self, output_dim, emb_dim, dec_hid_dim, enc_hid_dim, dropout):
        super().__init__()
        self.output_dim = output_dim
        self.embedding = nn.Embedding(output_dim, emb_dim)
        self.rnn = nn.GRU(emb_dim + enc_hid_dim * 2, dec_hid_dim)
        self.fc_out = nn.Linear(emb_dim + dec_hid_dim + enc_hid_dim * 2, output_dim)
        self.dropout = nn.Dropout(dropout)
        
    def forward(self, input, hidden, context):
        input = input.unsqueeze(0)
        embedded = self.dropout(self.embedding(input))
        emb_con = torch.cat((embedded, context), dim=2)
        output, hidden = self.rnn(emb_con, hidden.unsqueeze(0))
        output = torch.cat((embedded.squeeze(0), hidden.squeeze(0), context.squeeze(0)), dim=1)
        prediction = self.fc_out(output)
        return prediction, hidden.squeeze(0)

    from sacrebleu import corpus_bleu
    
    # 假设我们有以下的翻译结果和参考翻译
    translation = ['The', 'cat', 'is', 'on', 'the', 'mat']
    references = [['There', 'is', 'a', 'cat', 'on', 'the', 'mat'], ['A', 'cat', 'is', 'on', 'the', 'mat']]
    
    # 计算BLEU分数
    score = corpus_bleu([translation], [references])
    print(score)

    # 假设我们已经训练了一个模型，并保存在checkpoint.pth
    # 使用Fairseq生成翻译结果
    fairseq-generate data-bin/wmt14.en-fr \
    --path checkpoint.pth \
    --beam 5 \
    --remove-bpe \
    --quiet \
    --score-reference \
    --scoring bleu
    
    # 输出的翻译结果和BLEU分数

    # 下载数据
    wget https://s3.amazonaws.com/fairseq/data/wmt14.en-fr.tar.gz
    tar -xvzf wmt14.en-fr.tar.gz
    
    # 预处理数据
    fairseq-preprocess --source-lang en --target-lang fr \
    --trainpref wmt14.en-fr/train \
    --validpref wmt14.en-fr/newstest2013 \
    --testpref wmt14.en-fr/newstest2014 \
    --destdir data-bin/wmt14.en-fr

    # 训练模型
    fairseq-train data-bin/wmt14.en-fr \
    --arch transformer_iwslt_de_en \
    --share-decoder-input-output-embed \
    --optimizer adam --adam-betas '(0.9, 0.98)' --clip-norm 0.0 \
    --lr 5e-4 --lr-scheduler inverse_sqrt --warmup-updates 4000 \
    --dropout 0.3 --weight-decay 0.0001 \
    --criterion label_smoothed_cross_entropy --label-smoothing 0.1 \
    --max-tokens 3500 --update-freq 2 \
    --save-dir checkpoints/wmt14.en-fr \
    --log-format simple --log-interval 100

    # 生成翻译结果
    fairseq-generate data-bin/wmt14.en-fr \
    --path checkpoints/wmt14.en-fr/checkpoint_best.pt \
    --beam 5 \
    --remove-bpe \
    --quiet \
    --score-reference \
    --scoring bleu
    
    # 输出的翻译结果和BLEU分数

    # 安装Python环境
    # 确保你的系统中已经安装了Python 3.6或更高版本。
    
    # 安装Anaconda
    # 可选，但推荐使用Anaconda来管理Python环境。
    # 下载并安装Anaconda，然后创建一个新的环境。
    conda create -n fairseq_env python=3.8
    conda activate fairseq_env
    
    # 安装Fairseq
    # 使用pip安装Fairseq，确保你的环境中有torch和torchvision。
    pip install fairseq
    
    # 或者，从源代码安装Fairseq
    # 克隆Fairseq的GitHub仓库。
    git clone https://github.com/pytorch/fairseq.git
    cd fairseq
    
    # 安装依赖项
    pip install -r requirements.txt
    
    # 安装Fairseq
    pip install -e .

    # 示例：清洗数据
    import re
    
    def clean_text(text):
    # 去除HTML标签
    text = re.sub(r'<.*?>', '', text)
    # 去除非字母数字字符
    text = re.sub(r'[^a-zA-Z0-9\s]', '', text)
    # 去除过长或过短的句子
    sentences = text.split('\n')
    cleaned_sentences = [s for s in sentences if 10 <= len(s.split()) <= 100]
    return '\n'.join(cleaned_sentences)
    
    # 读取原始数据
    with open('raw_data.txt', 'r') as file:
    raw_text = file.read()
    
    # 清洗数据
    cleaned_text = clean_text(raw_text)
    
    # 保存清洗后的数据
    with open('cleaned_data.txt', 'w') as file:
    file.write(cleaned_text)

    # 使用Fairseq的preprocess.py脚本进行数据预处理
    fairseq-preprocess \
    --source-lang en --target-lang de \
    --trainpref train.raw \
    --validpref valid.raw \
    --testpref test.raw \
    --destdir data-bin \
    --workers 20 \
    --srcdict dict.en.txt \
    --tgtdict dict.de.txt

    # 训练BPE模型
    subword-nmt learn-joint-bpe-and-vocab -s 32000 < train.raw.en train.raw.de > bpe.codes
    
    # 应用BPE模型到数据
    subword-nmt apply-bpe -c bpe.codes < train.raw.en > train.bpe.en
    subword-nmt apply-bpe -c bpe.codes < train.raw.de > train.bpe.de

    # 如果没有提供词汇表，Fairseq会自动构建
    fairseq-preprocess \
    --source-lang en --target-lang de \
    --trainpref train.bpe \
    --validpref valid.bpe \
    --testpref test.bpe \
    --destdir data-bin \
    --workers 20

    # 查看词汇表大小
    wc -l dict.en.txt
    wc -l dict.de.txt

    fairseq-train data-bin/en-de \
    --arch transformer_iwslt_de_en \
    --optimizer adam \
    --adam-betas '(0.9, 0.98)' \
    --lr 0.0005 \
    --lr-scheduler inverse_sqrt \
    --warmup-updates 4000 \
    --dropout 0.3 \
    --weight-decay 0.0001 \
    --criterion label_smoothed_cross_entropy \
    --label-smoothing 0.1 \
    --max-tokens 4096 \
    --update-freq 8 \
    --save-dir checkpoints \
    --log-format simple \
    --log-interval 100

    fairseq-preprocess \
    --source-lang en \
    --target-lang de \
    --trainpref train \
    --validpref valid \
    --testpref test \
    --destdir data-bin/en-de \
    --workers 20

    fairseq-ensemble-models checkpoints/ensemble \
    checkpoints/model1.pt checkpoints/model2.pt checkpoints/model3.pt

    fairseq-quantize \
    --model checkpoints/model.pt \
    --quantization-bitwidth 8 \
    --quantization-type static \
    --quantization-backend fbgemm \
    --save-dir checkpoints/quantized

    from sacrebleu import corpus_bleu
    
    # 假设我们有以下的机器翻译输出和参考译文
    machine_translation = ["The", "cat", "is", "on", "the", "mat"]
    reference_translation = [["There", "is", "a", "cat", "on", "the", "mat"],
                          ["A", "cat", "is", "sitting", "on", "the", "mat"]]
    
    # 计算BLEU分数
    bleu_score = corpus_bleu([machine_translation], [reference_translation])
    print(f"BLEU Score: {bleu_score.score}")

    from ter import ter
    
    # 假设我们有以下的机器翻译输出和参考译文
    machine_translation = "The cat is on the mat"
    reference_translation = "A cat is sitting on the mat"
    
    # 计算TER分数
    ter_score = ter([machine_translation], [reference_translation])
    print(f"TER Score: {ter_score}")

    # 假设我们已经训练了一个模型，并保存在checkpoints目录下
    # 使用Fairseq生成翻译
    fairseq-generate data-bin/wmt14_en_fr \
    --path checkpoints/checkpoint_best.pt \
    --beam 5 \
    --remove-bpe \
    --quiet \
    --score-reference \
    --scoring bleu
    
    # 输出的翻译结果和BLEU分数将直接显示在控制台上

    from sacrebleu import sentence_bleu
    
    # 模型输出
    model_output = "这是一个测试句子。"
    # 参考译文
    reference = ["这是一个测试的句子。"]
    
    # 计算BLEU得分
    bleu_score = sentence_bleu(model_output, [reference]).score
    print(f"Bleu Score: {bleu_score}")

    # 测试数据
    test_data = {
    "en-fr": {
        "model_output": "C'est un test.",
        "reference": ["C'est un test.", "C'est un essai."]
    },
    "en-de": {
        "model_output": "Dies ist ein Test.",
        "reference": ["Dies ist ein Test.", "Dies ist eine Prüfung."]
    },
    "en-ja": {
        "model_output": "これはテストです。",
        "reference": ["これはテストです。", "これは試験です。"]
    }
    }

    # 计算多语言BLEU得分
    bleu_scores = {}
    for lang_pair, data in test_data.items():
    bleu_scores[lang_pair] = sentence_bleu(data["model_output"], data["reference"]).score
    print("BLEU Scores:", bleu_scores)

    # 假设train_data是一个包含英汉翻译对的列表
    # 增加长句训练数据
    long_sentences = [pair for pair in train_data if len(pair[0].split()) > 20]
    train_data += long_sentences * 2  # 增加长句的出现频率

    # 调整Transformer模型的参数
    model = TransformerModel(
    encoder_layers=6,  # 增加编码器层数
    decoder_layers=6,  # 增加解码器层数
    hidden_size=512,   # 调整隐藏层大小
    dropout=0.1        # 调整dropout率
    )

    from nltk.translate.bleu_score import sentence_bleu
    
    reference = [['这', '是', '一个', '例子']]
    candidate = ['这', '是', '一个', '测试']
    
    # 计算BLEU分数
    score = sentence_bleu(reference, candidate)
    print(f'BLEU Score: {score}')

    # 使用Fairseq评估翻译质量
    fairseq-generate data-bin/wmt14_en_fr \
    --path models/wmt14_en_fr/checkpoint_best.pt \
    --beam 5 \
    --remove-bpe \
    --score-reference \
    --scoring bleu