Sequence Modeling With CTC : Labelling Unsegmented Sequence Data with RNN

$$引言$$

最近刚入坑语音识别，看了关于CTC序列对齐的论文。下面是自己对论文的提取和自己的理解，只怪自己太菜，有点力不从心。整片文章用到了离散型的最大似然估计。下面链接是浙大大佬写的一篇，很通俗易懂，希望和大家一起进步学习。
似然与极大似然估计

$$摘要$$

许多真实世界的序列学习任务需要从嘈杂的、未分割的输入数据中预测标签序列。例如，在语音识别中，一个声音信号被转录成单词或子单词单位。递归神经网络(RNNs)是一种功能强大的序列学习者，似乎很适合这类任务。但是，由于它们需要预先分割训练数据，并经过后处理将其输出转化为标签序列，因此目前其适用性有限。Alex Graves等人提出了一种训练神经网络标记未分割序列的新方法CTC (Connectionist Temporal Classification)以标记未分割的序列数据。

$$TemporalClassification$$

设$S$为固定分布$D_{X\times Z}$得到的一组训练示例(training examples)。输入空间$X=({\mathbb{R}}^m{)}^{\ast }$是所有m维实值向量序列的集合。目标空间$Z=L^{\ast }$是最终标签序列集合$L$上的所有（有限）字母序列的集合。通常我们将$L^{\ast }$序列里面的元素或者字母（可以多个）作为标签序列，或者标签。$S$中的每个例子由一对序列$(x,z)$组成。目标序列$z=(z_1,z_2,,,z_U)$最多等于输入序列$x=(x_1,x_2,,,x_T)$，即，$U⩽T$.由于输入序列和目标序列的长度一般不相同，因此没有一种先验的方法来对齐它们

目的是使用$S$来训练一个时间分类器$h:X\to Z$来分类之前不能预见的输入序列，以最小化一些任务特定的误差测量。

$$ErrorRate$$

在本文中，我们感兴趣的是以下误差测量:给定一个从$S$分离出来的测试集$S^{\prime }\subset D_{X\times Z}$，定义个描述 $thelabelerror(LER)$的时间分类器$h$作为其分类与$S^{\prime }$上目标之间的归一化编辑距离,即
$$LER(h,S^{\prime })=\frac{1}{Z}\sum _{(x,z)\in S^{\prime }}ED(h(x))(1)$$
其中$Z$是$S^{\prime }$中目标标签的总数，$ED(p,q)$为$p$与$q$两个序列之间的编辑距离，即p变为q需要插入、替换和删除的最小数目。
这是一种很自然的方法(比如语音或手写识别)，其目的是将转录（transcription）错误的比率降到最低。

$$ConnectionistTemporalClassification$$

本节描述了用于CTC的递归神经网络的输出表示。关键的一步是将网络输出转换为标签序列上的条件概率分布。然后，通过为给定的输入序列选择最可能的标记，该网络可以被用作分类器。

$$FromNetworkOutputstoLabellings$$

一个CTC网络有一个softmax 输出层，该层神经元的个数比$L$标签序列所含的标签数多一。这个额外神经元的激活是为了观察到“空白”或没有标签的概率。比如26个字母，因为还有一个无效字符$ϵ$，所以目标类别一共有27类。这些softmax 输出层的输出一起定义了将所有可能的标签序列与输入序列对齐的所有可能方式的概率。然后，任何一个标签序列的总概率都可以通过对其不同对齐的概率求和来找到。
更正式地说，对于长度为$T$的输入序列$x$，定义一个有$m$个输入，$n$个输出，权值向量为$w$的递归神经网络作为一个连续映射$N_w:({\mathbb{R}}^m{)}^T\mapsto ({\mathbb{R}}^n{)}^T$.
设$y=N_w(x)$为网络输出序列，用$y_t^k$表示输出单元$k$在$t$时刻的激活，则$y_k^t$解释为$t$时刻观察标签$k$的概率，定义了集合$L^{\prime T}$上的分布,$T$为长度, L ′ = L ∪ { b l a n k } : L'=L\cup \{blank\}: L′=L∪{blank}:
我们先搭建这样一个模型：

$$p(\pi |x)=\prod _{t=1}^T{y}_{{\pi }_t}^t,\forall \pi \in L^{\prime T}.(2)$$
$\bullet$ $t\in (1,T)$，$T$为输入序列$x$的长度。
$\bullet$ 从上文$L^{\prime T}$的定义可知，$\pi$是一个$L^{\prime }$序列，比如hee$ϵ$l$ϵ$llo
$\bullet$ ${\pi }_t:x$输入序列的第$t$个位置(帧)所在$\pi$序列映射的元素(这里有个比对关系$x\mapsto L^{\prime }$)
$\bullet$ 如上文$y_k^t$的解释。$y_{{\pi }_t}^t:x$输入序列的第$t$个位置（帧）所在$\pi$序列映射的元素的概率分布
$\bullet$ 音频通过分帧进行特征提取，将得到的音谱图送入网络中训练，按照CTC的时序，一个帧对应一个输入位置、时间。即时间$T$和$x$序列的长度$T$是一样的。

将通过操作$B$可以编码为标签路径$l$的所有路径的概率累加，我们最大化这个概率就能训练好模型，这里每条路径中的元素假设是独立的，所以通过累乘来得到。但随着帧长的加大，如果对所有的路径进行穷举，是一个NPC问题，这里通过前后向算法来计算(后面会具体提到)。

$$p(l,x)=\sum _{\pi \in B^{-1}(l)}p(\pi |x)(1)$$
$\bullet$ $l:$ hello
$\bullet$ $B:L^{\ast T}\mapsto L^{\le T}$

$$ConstructingtheClassifier$$

根据上述公式，分类器的输出应该是输入序列最可能的标签:

$$h(x)=\underset{l\in L^{\le T}}{\mathrm{argmax}}p(l|x)$$
如下图，就是找到其中概率最大的一条path:

这里使用的是前缀搜索算法，但这里的算法有个问题，（下文使用了beam search进行改进）。
图片与算法描述：
每个节点要么以(’ e ')结束，要么扩展父节点的前缀。扩展节点上面的数字是所有以该前缀开头的标签的总概率。一个结束节点上面的数字是单个标记在其父节点结束的概率。在每次迭代中，探索最有可能的剩余前缀的扩展。搜索结束时，一个单一的标签(这里是“XY”)比任何剩余的前缀更可能。

$$CTC工作过程$$

下图是CTC工作过程的直观感受图（对齐与折叠）：

过程分析：

$\prod$是累乘（最大似然估计）

$$p(Y|X)=\sum _{A\in A_X{,}_Y}\prod _{t=1}^T{p}_t(a_t|X)$$
The CTC conditional probability  marginalizes over the set of valid alignments   computing the probability for a single alignment step-by-step.

首先是一张分好帧的声谱图，将每一帧的特征送入（fed into）RNN中训练。随后，每一帧的特征随着时间step by step进行识别，获得映射（比对）到{h,e,l,o,$ϵ$}的概率分布。如上图所示，阴影部分越重代表映射（比对）到该alphabet 的概率越大。然后，随着时间，从前往后通过比对形成3个概率不同的序列L’，整合后形成最终的L。到这里，通过直观感受，这段音频说的就是hello。

经过CTC训练的模型通常使用递归神经网络（RNN）估算每个时间步的概率，$$p_t(a_t|X)$$RNN通常会很好地工作，因为它考虑了输入中的上下文

但，我们又想，那如果我们一下送入不止一小段音频。可能最后的L’集合包括
hello
h$ϵ$ello
hello$ϵ$
he$ϵ$ll$ϵ$llo
…
可以看出这些都会被整合成hello.假设能够整合成hello序列的所有序列的个数为N.
而，这L的形成过程就是N个path,这N个path所代表的的概率相加就组成了最终的标签L。
注意：L’.length()>=L.length();

$$LossFunction$$

如果我们不小心，CTC损失的计算成本可能非常高。因为采用直接的方法会有大量的比对。

幸运的是，这个问题可以用动态规划算法来解决，类似于HMMs的向前向后算法(Rabiner, 1989)。关键
思想是，对应于标签的路径的总和可以分解为对应于标签前缀的路径的迭代总和。然后，可以通过向前和向后递归变量有效地计算迭代。

Summing over all alignments can be very expensive.  Dynamic programming merges alignments, so it’s much faster.
动态规划算法与递归算法相似，都是将大问题分解为小问题，然后逐步求解。规划算法是将大问题分解为独立的小问题，然后合并；而动态规划是从后往前推，逐步剥削。从上图可以看到，当前节点的值只与上一个时刻有关系。所以就可以用动态规划算法。

为了使描述算法会更容易，我们使用下面的序列

we can have an $ϵ$ before or after any token in $Y$
$$Z=[ϵ,y_1,ϵ,y_2,...,ϵ,y_U,ϵ]★$$
which is $Y$with an $ϵ$ at the beginning, end, and between every character.

我们设$\alpha$是所给节点合并路径后的值（score）。(注意为了将两篇论文的内容联系起来，这里的数学符号：${\alpha }_{s,t}=={\alpha }_t(s)$) \quad 更确切地说，${\alpha }_{s,t}$是$Z_{1:s}$序列在经过$t$个输入步骤（step）后的最终值（score）。

所以，现在，对于某个长度为$r$的序列$q$，用 $q_{1:p}$ 和 $q_{r-p:r}$ 分别表示其第一个和最后一个p符号。然后，对于标记 $\mathrm{I}$，定义前向变量 ${\alpha }_t(s)$ 为 $t$ 时刻 $1:s$的总概率，即：
$$\begin{gathered} {\alpha }_t(s)\stackrel{def}{=}\sum _{\pi \in N^T; \\ B({\pi }_{1:t})={\mathrm{I}}_{1:s}}\prod _{t^{\prime }=1}^t{y}_{{\pi }_{t^{\prime }}}^{t^{\prime }}(5) \end{gathered}$$

AS we’ll see,我们可以计算最终的CTC score,$P(Y|X)$,从${\alpha }_s$在the last time-step得到。
只有我们知道the previous time-step 我们就可以计算出最终的${\alpha }_{s,t}$。也就是说，${\alpha }_t(s)$可以从${\alpha }_{t-1}(s)$ 和${\alpha }_{t-1}(s-1)$递归地计算
由$ϵ$的位置，$Z$序列所导致的$\alpha$的score可由两种case,如下：
Case 1:

在这种情况下，我们不能跳过$Z_{s-1}$.
The first reason is that:
对于$\subset 1\supset$序列$Z$,$Z_{s-1}$可能是 Y = { y 1 , y 2 , . . . } Y=\{y_{1},y_{2},... \} Y={y1​,y2​,...}中的一个元素，它不是$ϵ$.对于训练来说，这是有用的信息，不能忽略。而且，前面我们已经定义，每个在$Z$序列的$Y$中的元素都会被$ϵ$followed.我们可以通过$Z_s=ϵ$判断它.
The second reason is that:
对于$\subset 2\supset$序列$Z,$如果我们想识别相同的字符，就必须在它俩中间有$ϵ$.比如：我们要识别hello,必须是hel$ϵ$lo之类的，否则会被CTC整合成helo。我们就可以判断这种特殊情况同，当$Z_s=Z_{s-2}.$
我们可以得到下面公式：
$${\alpha }_{s,t}=({\alpha }_{s-1,t-1}+{\alpha }_{s,t-1}).pt(z_s|X)$$

The CTC probability of the two valid subsequences after $t-1$ input steps. The probability of the current character at input step $t$.

Case 2:

如果$z_{s-1}$是$ϵ$,并且它两边的$z_s$,$z_{s-2}$是不同的字符。将允许我们跳过前面的token in $Z$,即，$z_{s-1}$连接$z_{s-2}$.
在这种情况下，我们可以得到下面公式：
$${\alpha }_{s,t}=({\alpha }_{s-2,t-1}+{\alpha }_{s-1,t-1}+{\alpha }_{s,t-1}).pt(z_s|X)$$
The CTC probability of the two valid subsequences after $t-1$ input steps. The probability of the current character at input step $t$.

结合Case 1,Case 2的讨论情况，呈现下图动态编程算法执行的计算示例。每个有效的路线在此图中都有一个路径。

由于当前节点的score的值只依赖于上一时刻的输入$X$，图片上右上角（正向传播）、左下角（反向传播）的节点是invailed（下文将给出严格的公式定义）

从上图可以看出，红色箭头标注的路径概率最高,$P(Y|X)$，输入的L’序列为： { ϵ , a , ϵ , ϵ , b , ϵ } \{\epsilon,a,\epsilon,\epsilon,b,\epsilon\} {ϵ,a,ϵ,ϵ,b,ϵ},经过整合后的最终标签是 Y = { a , b } Y=\{a,b\} Y={a,b}
而，完全概率是两个最终节点所代表的的路径之和（下文将给出严格的公式定义）。

现在我们可以有效地计算损失函数，下一步是计算梯度并训练模型。CTC损失函数在每个时间步输出概率上是可区分的，因为它只是它们的和还有乘积。鉴于此，我们可以相对于（未归一化的）输出概率分析计算损失函数的梯度，然后像往常一样进行反向传播。

训练模型后，我们想用它找到给定输入的可能输出。更准确地说，我们需要解决：
$$Y^{\ast }=\underset{Y}{\mathrm{argmax}}p(Y|X)$$
一种启发式方法是在每个时间步长获取最可能的输出。这使我们具有最高概率的对齐方式：
$$A^{\ast }=\underset{A}{\mathrm{argmax}}\prod _{t=1}^T{p}_t(a_t|X)$$
然后，我们可以折叠重复并删除$ϵ$ token得到$Y$.

对于许多应用程序，此启发式方法效果很好，尤其是当大多数概率质量分配给单个对齐方式时。但是，这种方法有时会错过容易找到的可能性更高的输出。问题是，它没有考虑到单个输出可以有很多对齐的事实。

这是一个例子。假设对齐方式[a，a，$ϵ$]和[a，a，a]的概率分别低于[b，b，b]。但是它们的概率之和实际上大于[b，b，b]的概率之和。天真的启发式会错误地提出Y =Y =[b]作为最可能的假设。它应该选择$Y=Y=[a]$。为了解决这个问题，算法需要考虑以下事实：[a，a，a]和[a，a，$ϵ$]折叠到相同的输出

$$beamsearch$$

我们可以使用修改后的modified beam search来解决上述问题。
先来说一下Beam search算法，该算法有个参数叫做宽度，假设宽度设为3，在RNN的输出中，该算法每个时间t输出时，不同于贪婪算法只找最高的，而是找最高的三个概率作为下一次的输入，依次迭代，如下图所示，每次t时间都是基于t-1输出的最高三个查找当前概率最高的三个。(这里也可以看出，当宽度设置为1时就是贪婪算法)
Beam Search（集束搜索/束搜索）
Seq2Seq中的beam search算法

给定有限的计算量，修改后的modified beam search不一定会找到最可能的是的$Y$。 至少，它确实具有很好的属性，我们可以在更多的计算（a larger beam-size）之间进行权衡，以获得渐近更好的解决方案。

常规modified beam search在每个输入步骤都会计算一组新的假设。通过使用所有可能的输出字符扩展每个假设并仅保留最前面的候选，从而从上一组生成新的假设.



上图是 l = { a } l=\{a\} l={a}和 l = { a , a } l=\{a,a\} l={a,a}的两个示例。（$L$是最终进过CTC整合的标签序列$l$的集合）
因为$a$的生成路劲较多，我下面仅仅以 L = { a , a } L=\{a,a\} L={a,a}做下分析：
T=1时刻，$\lambda$（为空）经过扩展生成了最有可能的3个扩展值（$ϵ$，a，b）。如果为a,那么T=1时刻生成了 l ′ = { a } l'=\{a\} l′={a}的序列,经过整合生成了 l = { a } l=\{a\} l={a}的标签序列。
T=2时刻，T=1生成的标签序列 l = { a } l=\{a\} l={a}经过扩展生成了最有可能的3个扩展值（$ϵ$，a，b）。如果为$ϵ$,那么T=2时刻生成了 L ′ = { a ， ϵ } L'=\{a，\epsilon\} L′={a，ϵ}的序列，最后经过整合生成了L={a}的标签序列。
T=3时刻，T=2生成的标签序列 l = { a } l=\{a\} l={a}经过扩展生成了最有可能的3个扩展值（$ϵ$，a，b）。如果为a,那么T=3时刻生成了 l ′ = { a ， l'=\{a， l′={a，\epsilon$，a\}$的序列，经过整合生成了 l = { a ， a } l=\{a，a\} l={a，a}的标签序列。
T=4时刻，没有扩展，最终标签序列为上一个时刻T=3时生成的标签序列 l = { a ， a } l=\{a，a\} l={a，a}。

$$TheCTCForward-BackwardAlgorithm$$

根据上面$★$公式的定义，这里令 ${\mathrm{I}}^{\prime }等于Z$的具体的实例，使 ${\mathrm{I}}^{\prime }$具备上面的定义。
结合上文分析的两种Case，我们允许所有前缀以空白 $(b)$ 或$\mathrm{I}({\mathrm{I}}_1)$中的第一个符号开始。
这给了我们下面的初始化规则:
$${\alpha }_1(1)=y_b^1$$
$${\alpha }_1(2)=y_{{\mathrm{I}}_1}^1$$
$${\alpha }_1(s)=0,\forall s>2$$
下面我们给出${\alpha }_t(s)$更准确地$ForwardAlgorithm$:
$${\alpha }_t(s)=\{\begin{array}{ll}{\stackrel{-}{\alpha }}_t(s)y_{{\mathrm{I}}_s^{\prime }}^t& \text{if }{\mathrm{I}}_s^{\prime }=bor{\mathrm{I}}_{s-2}^{\prime }={\mathrm{I}}_s^{\prime }\\ ({\stackrel{-}{\alpha }}_t(s)+{\alpha }_{t-1}(s-2))y_{{\mathrm{I}}_s^{\prime }}^t& \text{otherwise }\end{array}(6)$$
where
$${\mathrm{I}}_s^{\prime }中的s代表下标，表示{\mathrm{I}}^{\prime }序列的第s个字母$$
$${\stackrel{-}{\alpha }}_t(s)\stackrel{def}{=}{\alpha }_{t-1}(s)+{\alpha }_{t-1}(s-1)(7)$$

图片描述：
该图说明用于标记“CAT”的前向后向算法。黑色圆圈代表标签，白色圆圈代表空白。箭头表示允许转换。前向变量按箭头的方向更新，后向变量按箭头的反方向更新。
请注意,${\alpha }_t(s)=0\forall s<|{\mathrm{I}}^{\prime }|-2(T-t)-1，$因为这些变量对应的状态没有足够的时间步长来完成序列，(上图右上角的未连接的圆圈)。
Also ${\alpha }_t(s)=0\forall s<1$.

$\mathrm{I}$ 的概率等于${\mathrm{I}}^{\prime }$（在时间上$T$有和没有最后的空白的·）的所有概率之和。

$$p(\mathrm{I}|x)={\alpha }_T(|{\mathrm{I}}^{\prime }|)+{\alpha }_T(|{\mathrm{I}}^{\prime }|-1)(8)$$
同理，反向变量 ${\beta }_t(s)$，定义为在 $t$ 时刻 ${\mathrm{I}}_{s:|\mathrm{I}|}$ 的总概率。
$$\begin{gathered} {\beta }_t(s)\stackrel{def}{=}\sum _{\pi \in N^T; \\ B(\pi :T)={\mathrm{I}}_{s:|\mathrm{I}|}}\prod _{t^{\prime }=t}^T{y}_{{\pi }_{t^{\prime }}}^{t^{\prime }}(9) \end{gathered}$$
$${\beta }_T(|{\mathrm{I}}^{\prime }|)=y_b^T$$
$${\beta }_T(|{\mathrm{I}}^{\prime }-1|)=y_{{\mathrm{I}}_{|\mathrm{I}|}}^T$$
$${\beta }_T(s)=0,\forall s<|{\mathrm{I}}^{\prime }|-1$$
下面我们给出${\alpha }_t(s)$更准确地$ForwardAlgorithm$:
$${\beta }_t(s)=\{\begin{array}{ll}{\stackrel{-}{\beta }}_t(s)y_{{\mathrm{I}}_s^{\prime }}^t& \text{if }{\mathrm{I}}_s^{\prime }=bor{\mathrm{I}}_{s+2}^{\prime }={\mathrm{I}}_s^{\prime }\\ ({\stackrel{-}{\beta }}_t(s)+{\beta }_{t+1}(s+2))y_{{\mathrm{I}}_s^{\prime }}^t& \text{otherwise }\end{array}(6)$$
where
$${\mathrm{I}}_s^{\prime }中的s代表下标，表示{\mathrm{I}}^{\prime }序列的第s个字母$$
$${\stackrel{-}{\beta }}_t(s)\stackrel{def}{=}{\beta }_{t+1}(s)+{\beta }_{t+1}(s+1)(7)$$

注意：${\beta }_t(s)=0\forall s>2t$ (上图中，左下角未连接的部分) 和$\forall s>|{\mathrm{I}}^{\prime }|$

在实践中，上述递归将很快导致任何数字计算机上的低流.
避免这种情况的一种方法是重新调整前后变量。如果我们定义：
$$C_t\stackrel{def}{=}\sum _s{\alpha }_t(s),{\hat{\alpha }}_t(s)\stackrel{def}{=}\frac{{\alpha }_t(s)}{C_t}♠$$
$$D_t\stackrel{def}{=}\sum _s{\beta }_t(s),{\hat{\beta }}_t(s)\stackrel{def}{=}\frac{{\beta }_t(s)}{D_t}♠$$

为了评估最大似然误差，我们需要目标标记概率的自然对数。
有了重新标定的变量，它们的形式就特别简单了.
$$ln(p(\mathrm{I}|x))\stackrel{def}{=}\sum _{t=1}^{T}ln(C_t)$$

$$MaximumLikelihoodTraining$$

最大似然训练的目的是同时最大化训练集中所有正确分类的对数概率。在我们的例子中，这意味着最小化以下目标函数.

通过极大似然估计，可以直观的理解，$S$ 是我们观测到的值，找到$N_w$这个最优的网络参数，使我们的目标函数最小化。
为了用梯度下降训练网络，我们需要对（12）网络输出进行微分。由于训练例子是独立的，我们可以认为它们是独立的。

我们现在展示如何使用前面的前先后向算法来计算 (13)。
关键的一点是，对于标记 $\mathrm{I}$，在给定的 $s$ 和 $t$ 上的前向变量和后向变量的乘积就是 $\mathrm{I}$对应的所有路径在t时刻通过符号s的概率。更精确地说，从(5)和(9)我们有：

从(2)所给的，从中重新排列和代入：

从(3)我们可以看出这只是$p(\mathrm{I}|x)$总概率的一部分，由于这些路径经过${\mathrm{I}}_s^{\prime }$
对于任意的 $t$，我们可以对所有 $s$ 求和得到:

对 $y_t^k$ 求导, 我们只需要考虑那些在 $t$ 时刻经过标记 $k$ 的路径即可。注意到同一个标签(或空白)可能会重复多次，我们将标签 $k$ 出现的位置集中定义为 l a b ( I , k ) = { s : I s ′ = k } lab(\Iota, k) = \{s: \Iota_s' = k\} lab(I,k)={s:Is′​=k}，可为空。从（14）求导得到：

观察到：

设$\mathrm{I}=z$，将(8)和(15)代入(13)，对目标函数求导
最后，为了通过softmax层反向传播梯度，我们需要目标函数对非标准化输出$u_k^t$的导数
如果使用$♠$的重新缩放，我们有:

反应式(16)是网络在训练过程中接收到的‘错误信号’(下图)。

图片描述：
训练期间CTC误差信号的演变。左列显示了同一序列在不同训练阶段的输出激活(虚线为“空白”单元);右边的列显示了相应的错误信号。

参考于：

• Connectionist Temporal Classification: Labelling Unsegmented
  Sequence Data with Recurrent Neural Networks （Alex Graves提出的CTC经典论文）
  下载地址：链接：https://pan.baidu.com/s/1K3-BFZZ33eJXBa9qcOZqRQ
  提取码：j9gn

• Sequence Modeling With CTC

• 序列模型之CTC算法