Seq2Seq模型中的序列解码策略

导读：在序列生成类任务中，如机器翻译、自动摘要等，Seq2Seq是一种非常强大的模型。作为一种条件语言模型，它直接对P(y|x)进行建模，在生成y的过程中，始终有x作为条件。当训练好了一个这样的模型后，在预测过程中，需要进行解码来找到最有可能的输出序列。这篇文章主要讲解Sequence to Sequence模型在预测阶段中使用的序列解码策略。

一些自然语言处理任务，如脚注生成、机器翻译等，会涉及到生成单词序列，也就是预测结果是单词组成的一个序列。通常情况下，针对这些问题开发的模型会为输出序列中的每个单词生成词汇表中的每个单词上的概率分布，然后用在解码过程中以把这些概率分布转换成最终的单词序列。

解码最有可能的输出序列会涉及到在所有可能的输出序列上基于其概率进行搜索。词汇表的大小通常是由成百上千甚至百万个单词。可以想象，搜索难度在输出序列的长度上是呈指数级增长的，并且穷举所有的可能情况是不切实际的。

因此，在实践中，采用启发式搜索方法来返回一个或更多的近似的或者足够好的被解码好的的输出序列作为最终的预测结果，依据它们的概率值对候选词序列进行评分。

“As the size of the search graph is exponential in the source sentence length, we have to use approximations to find a solution efficiently.” —— Handbook of Natural Language Processing and Machine Translation

很常见的做法就是使用贪心搜索（Greedy Search）或集束搜索（Beam Search）来确定候选文本序列。

“Each individual prediction has an associated score (or probability) and we are interested in output sequence with maximal score (or maximal probability) (…) One popular approximate technique is using greedy prediction, taking the highest scoring item at each stage. While this approach is often effective, it is obviously non-optimal. Indeed, using beam search as an approximate search often works far better than the greedy approach.”——Neural Network Methods in Natural Language Processing

贪心搜索解码器

一种简单直观的方法是使用贪心搜索进行序列解码，在输出序列的每一步中始终选择最有可能（即最大概率）的词。具体来说，就是在生成第一个词 y < 1 > y^{<1>} y<1> 的分布之后，根据条件语言模型挑选出最有可能的第一个词 y < 1 > y^{<1>} y<1>，然后生成第二个词 y < 2 > y^{<2>} y<2> 的概率分布，再挑选出第二个词 y < 2 > y^{<2>} y<2>，以此类推。贪心搜索方法的好处就是它非常快，但是它只能保证每一步都是最优的，无法保证最终的预测序列整体是最优的，特别是如果在 t t t 时刻贪心搜索选择的词不是全局最优，会导致 t t t 时刻往后的所有预测词都是错误的，没有回头路了。如果每个时间步都穷举所有可能的情况的话，时间复杂度 O ( V T ) O(V^T) O(VT) 又太高了。下面我们以机器翻译为例来说明。

法语句子：“Jane visite l’Afrique en septembre.”
翻译 1：Jane is visiting Africa in September.
翻译 2：Jane is going to be visiting Africa in September.

很明显，翻译 1 要比翻译 2 更好，更加简洁明了，相比之下，翻译 2 就显得啰嗦。如果贪心搜索算法挑选’Jane’、‘is’作为输出序列的前两个词，即 y < 1 > , y < 2 > = y^{<1>},y^{<2>}= y<1>,y<2>=(‘Jane’, ‘is’)，那么当挑选第三个词 y < 3 > y^{<3>} y<3> 时，贪心搜索算法会选择’going’而不是’visiting’，因为在英语中’is going’比’is visiting’更加常见，'going’的概率是最大的，即 P ( ′ g o i n g ′ ∣ ′ J a n e ′ , ′ i s ′ ) > P ( ′ v i s i t i n g ′ ∣ ′ J a n e ′ , ′ i s ′ ) P('going' | 'Jane', 'is') > P('visiting' | 'Jane', 'is') P(′going′∣′Jane′,′is′)>P(′visiting′∣′Jane′,′is′)。最终你会得到一个翻译效果并不是最好的句子。

下面我们通过一个简单的例子来演示用贪心搜索方法进行解码的过程。假设我们需要预测一个由 10 个单词组成的序列，所使用的的词汇表由 5 个单词组成。所得到的输出序列中每个单词在整个词汇表中的每个单词上的概率分布如下：

# 定义一个由10个单词组成的序列，单词来自于大小为5的词汇表
data = [[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1],[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1],[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1],[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1],[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1]]
data = array(data)

贪心搜索算法在预测的每一步中选择最有可能的或概率值最大的单词作为输出，我们可以使用 argmax()这个函数来选择序列的每一步中最有可能的词索引值。下面的代码完整地演示了贪心搜索解码策略的过程：

from numpy import array
from numpy import argmax# 贪心搜索解码器
def greedy_decoder(data):# 每行最大概率的索引号return [argmax(s) for s in data]# 定义一个由10个单词组成的序列，单词来自于大小为5的词汇表
data = [[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1],[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1],[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1],[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1],[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1]]
data = array(data)
# 解码输出序列
result = greedy_decoder(data)
print(result)

运行这段样例程序会输出一个整型数字序列，这些数字表示对应单词在字典中的索引号。

[4, 0, 4, 0, 4, 0, 4, 0, 4, 0]

集束搜索解码器

另一种流行的方法是介于贪心搜索和穷举搜索之间的一种折中方案——集束搜索（Beam Search），它能够返回一个最有可能的输出序列的列表。当构造输出序列时它不是贪婪地选择最有可能的下一步，集束搜索扩展所有可能的下一步，仅保留 k 个最有可能的。其中，k 是一个用户指定的参数，控制着整个概率序列的集束（beams）或并行搜索（parallel searches）的数量。

”The local beam search algorithm keeps track of k states rather than just one. It begins with k randomly generated states. At each step, all the successors of all k states are generated. If any one is a goal, the algorithm halts. Otherwise, it selects the k best successors from the complete list and repeats.“——Artificial Intelligence: A Modern Approach

请注意，k 个最高概率不仅仅是指当前时刻 y ^ t \hat{y}_t y^t 的最高概率，而且是截止目前这条路径上的累计概率之和，序列得分计算公式如下：

score ( y 1 , … , y t ) = log ⁡ P L M ( y 1 , … , y t ∣ x ) = ∑ i = 1 t log ⁡ P L M ( y i ∣ y 1 , … , y i − 1 , x ) \begin{array}{ll} \text{score}(y_1,\dots,y_t) &=\log P_{LM}(y_1,\dots,y_t|x) \\ &= \sum_{i=1}^t \log P_{LM}(y_i | y_1, \dots, y_{i-1}, x) \end{array} score(y1,…,yt)=logPLM(y1,…,yt∣x)=∑i=1tlogPLM(yi∣y1,…,yi−1,x)

概率是小数，将小数相乘会产生非常小的数。为避免浮点数下溢，将概率的自然对数相乘在一起以使数字更大且易于管理。所有的分数取其负数，分数越高越好。最后，我们可以按照得分的升序排列所有候选序列，并选择前 k 个作为最可能的候选序列。

贪心搜索常用的集束宽（beam widths）是 1，在机器翻译的一些基准问题中常用的集束宽是 5 到 10 之间。更大的集束宽会让模型的表现变得更好，因为多个候选序列增加了更好地匹配到目标序列的可能性。但是，表现变好的同时消耗的资源越多，解码速度也会下降。

”The local beam search algorithm keeps track of k states rather than just one. It begins with k randomly generated states. At each step, all the successors of all k states are generated. If any one is a goal, the algorithm halts. Otherwise, it selects the k best successors from the complete list and repeats.“——Beam Search Strategies for Neural Machine Translation

对于每个候选序列来说，要么达到最大序列长度，要么遇到序列终止符号，亦或者达到某个概率阈值，集束搜索过程就会终止。

接下来，我们举例说明集束搜索解码序列的详细过程。假设 k=2，第一个时间步保留 2 个最高概率的词为"he"和"I"，它们分别作为下一个时间步的输入。“he"输入预测输出的前 2 名是"hit"和"struck”，则"hit"这条路的累加概率是"he"的概率加上"hit"的概率等于-1.7。同样地，可以计算出其他几个词对应路径的概率得分。最后，在这 4 条路径上保留 k=2 条路径，所以"hit"和"was"对应的路径被保留，作为下一个时间步的输入，"struck"和"got"对应的路径被剪枝。

最终的搜索树如下图所示，可以看到在每个时间步都只保留了 k=2 个节点往下继续搜索。最后"pie"对应的路径得分最高，通过回溯法得到概率最高的翻译句子。

请注意，集束搜索作为一种剪枝策略，并不能保证得到全局最优解，但它能以较大的概率得到全局最优解，同时相比穷举搜索，它极大地提高了搜索效率。

下面我们也通过一个简单的例子来演示对给定的概率序列和参数 k 用集束搜索方法进行解码的过程。所得到的概率分布与贪心搜索方法一致，完整的样例代码如下：

from math import log
from numpy import array
from numpy import argmax# 集束搜索
def beam_search_decoder(data, k):sequences = [[list(), 1.0]]# 遍历序列中的每一步for row in data:all_candidates = list()# 扩展每个候选项for i in range(len(sequences)):seq, score = sequences[i]for j in range(len(row)):candidate = [seq + [j], score * -log(row[j])]all_candidates.append(candidate)# 根据分数排列所有候选项ordered = sorted(all_candidates, key=lambda tup:tup[1])# 选择k个最有可能的sequences = ordered[:k]return sequences# 定义一个由10个单词组成的序列，单词来自于大小为5的词汇表
data = [[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1],[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1],[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1],[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1],[0.1, 0.2, 0.3, 0.4, 0.5],[0.5, 0.4, 0.3, 0.2, 0.1]]
data = array(data)
# 解码输出序列
result = beam_search_decoder(data, 3)
# 打印结果
for seq in result:print(seq)

运行这段样例程序会输出 k 个整型数字（数字代码单词在字典中的索引值）序列以及对应的 log 概率值。

[[4, 0, 4, 0, 4, 0, 4, 0, 4, 0], 0.025600863289563108]
[[4, 0, 4, 0, 4, 0, 4, 0, 4, 1], 0.03384250043584397]
[[4, 0, 4, 0, 4, 0, 4, 0, 3, 0], 0.03384250043584397]

最后，需要注意的是当集束搜索过程结束时，需要从 n 条候选路径中选一个得分最高的路径作为最终结果。由于不同路径的长度不一样，累加越多得分越低，所以需要用长度对得分进行归一化。归一化公式如下：

1 t ∑ i = 1 t log ⁡ P L M ( y i ∣ y 1 , … , y i − 1 , x ) \frac{1}{t} \sum_{i=1}^t \log P_{LM}(y_i | y_1, \dots, y_{i-1}, x) t1i=1∑tlogPLM(yi∣y1,…,yi−1,x)

想要了解更多的自然语言处理最新进展、技术干货及学习教程，欢迎关注微信公众号“语言智能技术笔记簿”或扫描二维码添加关注。