机器翻译评价指标之BLEU原理介绍及代码实现_知乎 博客 bleu 简单理解

欢迎关注知乎： 世界是我改变的

知乎上的原文链接

一. 原理介绍

BLEU（Bilingual Evaluation Understudy），即双语评估替补。所谓替补就是代替人类来评估机器翻译的每一个输出结果。Bleu score 所做的，给定一个机器生成的翻译，自动计算一个分数，衡量机器翻译的好坏。取值范围是[0, 1],越接近1,表明翻译质量越好。

机器翻译的一大难题是，一句法语句子，可以有多种英文翻译，这些翻译都是非常好的那怎么去评估一个机器翻译系统的质量是不是好呢？这不像图像识别，只有一个正确答案。通常我们有 BLEU score 来解决。

原论文为 BLEU: BLEU原论文

话不多说，先上公式：

• 计算公式
  
  其中，BP是简短惩罚因子，惩罚一句话的长度过短，防止训练结果倾向短句的现象，其表达式为：
  
  还有Pn，是基于n-gram的精确度，其表达公式为：
  
  公式的解释及使用都在以下例子中体现。

• 举个例子（在什么情况下时候BLEU）：

Reference 1 和 Reference 2这两句都是很不错的人工进行的翻译，那么如何利用这两句话对其他机器翻译得出的结果进行评估呢？

一般衡量机器翻译输出质量的方法之一是观察输出结果的每一个词，看其是否出现在参考（也就是人工翻译结果）中，这被称为是机器翻译的精确度。而这样计算得出的精确度很快就能被一个反例打破，那就是：the the the the the the the.

首先 我们要做的是，看机器翻译 MT 的结果中，有多少词在人类的翻译参考中出现：

1. 一种方法叫做 Precision（精确度）：看机器翻译的每一个词，有没有在翻译参考中出现。在上面的案例中，虽然全是 the 是一个非常糟糕的翻译结果，但是 Precision = 7/7 = 1（感觉这种衡量方法不靠谱）
2. 改良后叫做 Modified precision：我们会设定最高权重上限，比如第一句翻译参考中，the 出现了 2 次；第二句中， the 出现了 1 次，那权重上限就是 2。这样 Modified precision = 2/7.

对于1中的计算方式的不足之处进行改良，于是把每一个单词的计分上限定为它在参考句子中出现最多的次数。在reference1中，the出现了两次，在reference2中，the只出现了一次。所以会说单词the的得分上限是2。

有了这个改良后的精确度，我们就说，这个输出句子的得分为2/7，因为在7个词中，我们最多只能给它2分。所以这里分母就是7个词中单词the总共出现的次数，而分子就是单词the出现的计数。我们在达到上限时截断计数，这就是改良后的精确度评估（modified precision measure）。

其次 在 Bleu score 中，我们不仅关注 单词，还关注词组（其实就是相邻的词对 bigrams）

1. 这个例子中，一共有 5 种 bigrams 的组合
2. 分别数一下出现的次数
3. 分别数一下在翻译参考中出现的次数
4. 最终 modified bigram precision = 4/6

可以将其公式化，这里的 P1 下标 1 表示的是 一元词组，推广到 n 元词组。

如果机器翻译的结果和参考翻译中的某一句完全相同，那么 P1 = P2 = … = Pn = 1
也有可能通过某种组合各个参考翻译得到结果为 1。

最终，我们把以上结合起来，获得最后的 Bleu score
即求所有 P 值的平均，然后取个 e 指数
然后在前面加上一个 BP 参数（brevity penalty 简短惩罚）

• BP 的作用在于，如果输出一个非常短的句子，那很容易得到 Bleu score 的高分，所以我们要防止这个情况的出现
• BP 在机器翻译长度大于人类翻译长度的时候取值为 1，否则产生惩罚

二. 使用场景

在NLP机器翻译任务中，我们如果想对一个语句进行翻译，然后对翻译结果进行评价打分，则需要使用到BLEU score。在使用时需要有候选语句和语句库进行对比，从而根据两者的差异来计算得分。

三. MindSpore代码实现

• BLEU score的MindSpore代码实现

"""BleuScore."""
from collections import Counter
import numpy as np
from mindspore._checkparam import Validator as validator
from .metric import Metric


class BleuScore(Metric):
   
    def __init__(self, n_gram=4, smooth=False):
        super().__init__()
        # validator.check_value_type为参数的校验
        self.n_gram = validator.check_value_type("n_gram", n_gram, [int])
        if self.n_gram > 4 or self.n_gram < 1:
            raise ValueError('The n_gram value ranged from 1 to 4, but got {}'.format(n_gram))

        self.smooth = validator.check_value_type("smooth", smooth, [bool])
        self.clear()

    def clear(self):
        """清除历史数据"""
        self._numerator = np.zeros(self.n_gram)
        self._denominator = np.zeros(self.n_gram)
        self._precision_scores = np.zeros(self.n_gram)
        self._c = 0.0
        self._r = 0.0
        self._trans_len = 0
        self._ref_len = 0
        self._is_update = False
    
    # 用ngram计算每个单词在给定文本中出现的次数。
    def _count_ngram(self, ngram_input_list, n_gram):
        # 先构造一个计数器。
        ngram_counter = Counter()

        for i in range(1, n_gram + 1):
            # 遍历翻译文本或参考文本的列表。
            for j in range(len(ngram_input_list) - i + 1):
                # 构造ngram-key字典
                ngram_key = tuple(ngram_input_list[j:(i + j)])
                ngram_counter[ngram_key] += 1

        return ngram_counter
 
    def update(self, *inputs):
        # 先进行输入个数的判断
        if len(inputs) != 2:
            raise ValueError('The bleu_score need 2 inputs (candidate_corpus, reference_corpus), '
                             'but got {}'.format(len(inputs)))
        # 更新输入，一个为候选句子，一个为参考句子或参考列表
        candidate_corpus = inputs[0]
        reference_corpus = inputs[1]
        # 进行输入的校验
        if len(candidate_corpus) != len(reference_corpus):
            raise ValueError('translate_corpus and reference_corpus should be equal in length, '
                             'but got {} {}'.format(len(candidate_corpus), len(reference_corpus)))
        # 遍历两个输入的每一个单词，使用计数器进行统计
        for (candidate, references) in zip(candidate_corpus, reference_corpus):
            self._c += len(candidate)
            ref_len_list = [len(ref) for ref in references]
            ref_len_diff = [abs(len(candidate) - x) for x in ref_len_list]
            self._r += ref_len_list[ref_len_diff.index(min(ref_len_diff))]
            translation_counter = self._count_ngram(candidate, self.n_gram)
            reference_counter = Counter()

            for ref in references:
                reference_counter |= self._count_ngram(ref, self.n_gram)

            ngram_counter_clip = translation_counter & reference_counter

            for counter_clip in ngram_counter_clip:
                self._numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]

            for counter in translation_counter:
                self._denominator[len(counter) - 1] += translation_counter[counter]

        self._trans_len = np.array(self._c)
        self._ref_len = np.array(self._r)
        self._is_update = True

    def eval(self):
        # 如果_is_update是False，则说明使用方法错误。
        if self._is_update is False:
            raise RuntimeError('Call the update method before calling eval.')

        # 分母不能为0
        if min(self._numerator) == 0.0:
            return np.array(0.0)

        # 计算准确度
        if self.smooth:
            precision_scores = np.add(self._numerator, np.ones(self.n_gram)) / np.add(self._denominator,
                                                                                      np.ones(self.n_gram))
        else:
            precision_scores = self._numerator / self._denominator

        # 使用公式进行计算BLEU
        log_precision_scores = np.array([1.0 / self.n_gram] * self.n_gram) * np.log(precision_scores)
        geometric_mean = np.exp(np.sum(log_precision_scores))
        brevity_penalty = np.array(1.0) if self._c > self._r else np.exp(1 - (self._ref_len / self._trans_len))
        bleu = brevity_penalty * geometric_mean

        return bleu
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

使用方法如下：

import numpy as np
import mindspore.common.dtype as mstype
import mindspore.nn as nn
from mindspore import Tensor

candidate_corpus = [['i', 'have', 'a', 'pen', 'on', 'my', 'desk']]
reference_corpus = [[['i', 'have', 'a', 'pen', 'in', 'my', 'desk'],
                    ['there', 'is', 'a', 'pen', 'on', 'the', 'desk']]]
metric = BleuScore()
metric.clear()
metric.update(candidate_corpus, reference_corpus)
bleu_score = metric.eval()
print(bleu_score)

0.5946035575013605
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 需要说明的问题

BLEU采用的是clipping策略，即：在参考译文中被匹配过的单元（n-gram）应该被剪切掉，不应该再被匹配。BLEU在语料库层级上具有很好的匹配效果，但是随着n的增加，在句子层级上的匹配表现越来越差，因此BLEU在个别语句上可能表现不佳。