HMM（隐马尔科夫模型）知识点整理

其他 2020-02-09 15:38:31 阅读次数: 0

目录

HMM（隐马尔科夫模型）知识点整理

  在信息处理过程中，常常会遇到根据已有的序列信息推断源信息的问题，例如在自然语言处理的词性标注问题中，给定一句话，我们希望构建一个模型，能推测出这句话中每个词的词性。这个问题里，我们能够观测到的信息是单词序列，需要被推断的信息是词性序列。我们可以假设两个人在对话，尽管听者直接收到的信息是单词序列，但从说者头脑的思维转变成实际接收到的单词序列，发生了两个重要的过程。过程一，说者从他的语法库中按照一定概率分布生成了第一个词性；过程二，针对该词词性又按照一定概率生成了该词性下的第一个词汇。接下来重复过程一和二，也就变成了听者耳中的一句话。对上述过程建立概率图模型也就是隐马尔科夫模型。

一、一个简单的例子

  上面的例子也许不够直观，这里举一个比较经典的例子（很多讲HMM的书或者博客都有提及）。研究概率问题，总可以想象成有一些人在玩摸球游戏。

例1.1 假设有3袋球，分别编号1，2，3。袋1中有1个红球，2个白球，袋2中有2个红球，1个白球，袋3中有3个白球。有一人甲先随机选择一个袋子，然后再从其中随机摸一个球，另一人乙可以看到甲所摸球的颜色，但无法知道其所选袋子的编号。

  针对上面的例子，我们可以提出以下一些问题，

  1. 乙看到甲的摸球序列为“红，白，红”的概率为多少？
  2. 如果乙看到摸球序列为“红，白，红”，甲所选的编号序列最有可能是什么？
  3. 如果我进行大量的观测，能否探寻到甲选择袋子标号的规律（可能是心理因素，也可能毫无规律）？

  我们不妨暂时先搁置这些问题，先对上面的例子做一些数学上的抽象分析，也就是数学建模。

二、一些概念回顾

2.1 隐变量和概率图

  对于一些在随机过程中无法被直接观测到的变量，例如上面例子中的词性和袋子编号，我们称之为隐变量(hidden variable)。这些变量除非生成者告知我们，否则作为观测者无法得知，观测者唯一能做的就是推断。
  接下来需要简单复习一下概率图模型的基本概念，首先回顾一下概率的链式法则,
p ( x 1 , x 2 , … , x n ) = p ( x 1 ) p ( x 2 ∣ x 1 ) … p ( x n ∣ x 1 , … , x n − 1 ) \begin{aligned} p(x_1,x_2,\dots,x_n)&=p(x_1)p(x_2|x_1)\dots p(x_n|x_1,\dots,x_{n-1}) \end{aligned}
  联合概率分布表达了随机变量之间的全部信息，这些信息包括：

  1. 任意随机变量的自身属性；
  2. 任意两个随机变量之间的独立关系；

  在数学上，图的概念刚好包含了上面两个信息：节点表征了变量自身的属性；边表征了变量与变量之间的关系。因此，很自然地联想到对一组随机变量引入图的概念，从而建立概率图模型。需要说明的是，这里，仅仅考虑有向无环图模型。

2.2 离散Markov模型

  然后需要回顾的一个概念是离散Markov链，离散Markov链是一类简单的随机过程，这里不再给出严格的定义。简单来说，对于一个离散随机变量序列 x 1 , x 2 , … , x n x_1, x_2, \dots, x_n ，如果他们的联合概率分布满足下述条件，则称该随机变量序列为一个离散马尔科夫链：
p ( x 1 , … , x n ) = ∏ i = 1 n p ( x i ∣ x i − 1 ) , p ( x 1 ∣ x 0 ) = p ( x 1 ) p(x_{1},\dots,x_n)=\prod _{i=1}^{n}p(x_{i}|x_{i-1}),p(x_1|x_{0})=p(x_1)
  简单来说，就是第 n n 时刻的随机变量的概率分布仅与 n − 1 n-1 时刻相关。当然，这些随机变量有公共的状态集合 x i ∈ S = { s k } ∣ k = 1 N x_{i}\in S=\{ s_{k} \} |_{k=1}^{N} 。对离散Markov链建立概率图模型如下，
x 1 → x 2 → ⋯ → x n x_1 \rightarrow x_2 \rightarrow \dots \rightarrow x_n
  直观理解就是一个不断延伸下去的线性链（如果不对 n n 做限制）。依附于离散Markov链的第一个重要概念是概率转移矩阵 P P ，该矩阵里的 ( i , j ) (i,j) 处元素为
a i j = p ( x n = s j ∣ x n − 1 = s i ) a_{ij}=p(x_n=s_j|x_{n-1}=s_i)

  故 P ∈ R N × N P \in \mathbb{R}^{N \times N} 。这里的转移概率忽略了时间的影响，事实上存在一类时移Markov链，其概率转移矩阵是时间的函数。
  接下来，自然要问，Markov链是怎样开始的呢？因而，我们需要定义Markov的初始分布 p ( x 1 ) p(x_1) ， π = ( π 1 , … , π n ) \pi=(\pi_1,\dots,\pi_n) 。

三、HMM基本概念

3.1 概率图结构

  有了上面的一些概念准备，我们就可以着手建立隐马尔科夫模型，我们可以假设例子中的过程一（其中的变量无法被观测，因而是隐变量）为一个离散Markov链，记作第 t t 时刻的隐变量为 q t q_t ，第 i i 时刻观测到的变量记作 o t o_t ，并且 o t o_t 仅与 q t q_t 存在条件相关性。于是可以得到下面的概率图
在这里插入图片描述

  用黑色表示隐节点，空白节点表示可以被观测的节点。有了上面的概率图，模型的结构也就清晰起来。

3.2 模型参数

  接下来的任务就是对概率图中的边引入参数。我们仍然需要引入一些符号，对于状态节点 q t q_t ，其状态空间为 S = { s k } ∣ k = 1 N S=\{ s_{k} \} |_{k=1}^{N} ，对于观测节点，其状态空间为 V = { v k } ∣ k = 1 M V=\{ v_{k} \} |_{k=1}^{M} 。
  根据假设，隐节点序列是一个离散Markov链，于是我们对其引入转移矩阵 A = ( a i j ) N × N A=(a_{ij})_{N\times N} 和初始分布 π \pi 。接下来我们需要引入另外一个矩阵来表征概率 p ( o t ∣ q t ) p(o_t|q_t) ，即 B = ( b i j ) N × M B=(b_{ij})_{N\times M} ，称之为发射矩阵，其中的元素可以简单记作 b j ( o t ) b_{j}(o_t) ，表示概率 p ( o t ∣ q t = s j ) p(o_t|q_t=s_j) 。
  总结一下，一个HMM模型记作 μ = ( A , B , π ) \mu=(A,B,\pi) ，其中，

  1. A = ( a i j ) N × N A=(a_{ij})_{N\times N} 称为转移矩阵；
  2. b j ( o t ) , j = 1 , 2 , … , N b_{j}(o_t),j=1,2,\dots,N 称为发射概率；
  3. π = ( π 1 , … , π N ) \pi=(\pi_1, \dots, \pi_N) 为初始分布；

  通过引入概率图模型，我们就成功地将例1.1抽象化了。接下来，还有一步重要的工作是将例1.1中的问题用数学语言表达，也就是HMM模型中的三个基本问题，

  1. 给定模型 μ = ( A , B , π ) \mu=(A,B,\pi) 和观测序列 O = o 1 o 2 … o T O=o_1o_2\dots o_T ， p ( O ) p(O) 为何值？
  2. 给定模型 μ = ( A , B , π ) \mu=(A,B,\pi) 和观测序列 O = o 1 o 2 … o T O=o_1o_2\dots o_T ，最有可能的序列 Q = q 1 q 2 … q T Q=q_1q_2\dots q_T 是什么？
  3. 给定已知的序列 O = o 1 o 2 … o T O=o_1o_2\dots o_T 和 Q = q 1 q 2 … q T Q=q_1q_2\dots q_T ，最有可能的模型 μ = ( A , B , π ) \mu=(A,B,\pi) 是什么？

  接下来的三个算法分别解决了上述三个问题。

四、前向后向算法

4.1 野蛮推导

  事实上，HMM的概率图模型表达的是联合概率 p ( o 1 o 2 … o T , q 1 q 2 … q T ) p(o_1o_2\dots o_T, q_1q_2\dots q_T)
问题1所要求的概率是 p ( O ∣ μ ) p(O|\mu) ，我们自然可以使用全概率公式和条件概率公式进行一系列的推导，最终得到如下的表达式：
p ( O ∣ μ ) = ∑ Q ∈ S T ∏ t = 1 T b q t ( o t ) p ( q t ∣ q t − 1 ) = ∑ Q ∈ S T π q 1 b q 1 ( o 1 ) ∏ t = 2 T a q t − 1 q t b q t ( o t ) p(O|\mu)=\sum_{Q\in S^T} \prod_{t=1}^Tb_{q_t}(o_t)p(q_t|q_{t-1})=\sum_{Q\in S^T}\pi_{q_1}b_{q_1}(o_1)\prod_{t=2}^{T}a_{q_{t-1}q_t}b_{q_t}(o_t)

4.2 前向算法

  求解上式面临的最大问题是计算复杂度，需要进行约 O ( T N T ) O(TN^T) 次乘法和加法运算。这个计算量是巨大的，事实上，如果在序列里存在一定的递推关系，就可以可容易地降低计算复杂度。的确存在这样的递推关系，这也是前向后向算法（forward-backward algorithm）的基本思路。
  假设某一个HMM发展到 t − 1 t-1 时刻，也就是说我们已经观测到了 o 1 , … , o t − 1 o_1,\dots,o_{t-1} ，那么，接下来会发生这样两个过程，

  1. 由 q t − 1 q_{t-1} （尽管我们并不知道它是什么）转移到 q t q_t ；
  2. 由 q t q_t 发射出 o t o_t ；

  也就是说，我们关心的是概率
p ( o 1 o 2 … o t , q t = s i ∣ μ ) , i = 1 , … , N p(o_1o_2\dots o_t, q_t=s_i|\mu),i=1,\dots,N
把上面的概率记作 α t ( i ) \alpha_t(i) ，称为前向变量，根据上面的两个过程，递推关系也就十分明显了，
α t + 1 ( j ) = ∑ i = 1 N α t ( i ) a i j b j ( o t + 1 ) , j = 1 , … , N \alpha_{t+1}(j)=\sum_{i=1}^N\alpha_t(i)a_{ij}b_j(o_{t+1}),j=1,\dots,N
  很显然，当HMM终止在 T T 时刻时，我们有
α T ( i ) = p ( o 1 … o T , q T = s i ) \alpha_T(i)=p(o_1\dots o_T,q_T=s_i)
则，
p ( O ∣ μ ) = ∑ i = 1 N α T ( i ) p(O|\mu)=\sum_{i=1}^N\alpha_T(i)
  在完整给出算法以前，我们先将算法的变量用向量形式表达，定义向量
α ( t ) = ( α t ( 1 ) , … , α t ( N ) ) T \alpha(t)=(\alpha_t(1),\dots,\alpha_t(N))^T
转移概率矩阵为 P = ( a i j ) N × N \bold{P}=(a_{ij})_{N\times N} ，定义矩阵
C ( o t ) = d i a g ( b 1 ( o t ) , … , b N ( o t ) ) \bold{C}(o_t)=\bold{diag}(b_1(o_t),\dots,b_N(o_t))
下面给出矩阵形式的算法，
算法4.1(前向算法)

  1. 初始化
    α ( 1 ) = C ( o 1 ) π ; \alpha(1)=\bold{C}(o_1)\pi;
  2. F o r t = 2 , … , T d o \bold{For}\quad t=2,\dots,T \quad \bold{do}
    α ( t ) = C ( o t ) P T α ( t − 1 ) ; \alpha(t)=\bold{C}(o_t)\bold{P}^T\alpha(t-1);
  3. 算法终止
    P ( O ∣ μ ) = ∑ i = 1 N α T ( i ) ; P(O|\mu)=\sum_{i=1}^N\alpha_T(i);

  上面的算法基于的是动态规划的思想，很容易计算，其算法的时间复杂度为 O ( T N 2 ) O(TN^2) ，空间复杂度为 O ( N 2 ) O(N^2) 。

4.3 后向算法

  前向算法从序列的初始位置开始推理到终止状态 T T ，既然整个观测序列都已经知道了，那是不是可以由终止状态往前推呢？在动态规划的思想里，这两种递推结果一般是一致的。而得到后向算法的关键仍然在于定义一个存在合理递推关系的后向变量。
  同样可以类似定义前向变量时的分析，假设我们从HMM序列的终止状态回溯至时刻 t t （发射 o t o_t 以后，转移至 q t + 1 q_{t+1} 以前），我们已知的信息是观测序列 o t + 1 , … , o T o_{t+1},\dots,o_T ，考虑从 t t 时刻往前回溯两步的过程，

  1. q t q_t 以概率 b q t ( o t ) b_{q_t}(o_t) 发射 o t o_t ；
  2. q t − 1 q_{t-1} 转移至 q t q_t ；

也就是说，我们关心的是概率
p ( o t … o T ∣ q t − 1 = s i , μ ) p(o_t\dots o_{T}|q_{t-1}=s_i,\mu)
记上面的概率为 β t − 1 ( i ) \beta_{t-1}(i) ，由上面的过程，可以很自然得到以下递推关系，
β t − 1 ( i ) = ∑ j = 1 N β t ( j ) b j ( o t ) a i j \beta_{t-1}(i)=\sum_{j=1}^N\beta_t(j)b_j(o_t)a_{ij}
则，
p ( O ∣ μ ) = ∑ j = 1 N β 1 ( j ) b j ( o 1 ) π j p(O|\mu)=\sum_{j=1}^N\beta_1(j)b_j(o_1)\pi_j
  同样，用矩阵表示，定义，
β ( t ) = ( β t ( 1 ) , … , β t ( N ) ) T \beta(t)=(\beta_t(1),\dots,\beta_t(N))^T
后向算法陈述如下
算法4.2（后向算法）

  1. 初始化
    β ( T ) = ( 1 , … , 1 ) T ; \beta(T)=(1,\dots,1)^T;
  2. F o r t = T − 1 , … , 1 d o \bold{For}\quad t=T-1,\dots,1 \quad \bold{do}
    β ( t − 1 ) = P C ( o t ) β ( t ) ; \beta(t-1)=\bold{P}\bold{C}(o_t)\beta(t);
  3. 算法终止
    p ( O ∣ μ ) = π T C ( o 1 ) β ( 1 ) ; p(O|\mu)=\pi^T\bold{C}(o_1)\beta(1);

后向算法的时间复杂度和空间复杂度同样分别为 O ( T N 2 ) O(TN^2) 和 O ( N 2 ) O(N^2) 。

4.4 联系

  如果仔细观察，可以发现前向变量与后向变量之间事实上构成一种互补性，为了验证这一想法，我们做以下推导，
p ( O ∣ μ ) = ∑ i = 1 N p ( o 1 … o T , q t = s i ∣ μ ) = ∑ i = 1 N p ( o t + 1 … o T ∣ q t = s i , o 1 … , o t , μ ) p ( o 1 , … , o t , q t ∣ μ ) = ∑ i = 1 N p ( o t … o T ∣ q t − 1 = s i , μ ) p ( o 1 , … , o t , q t ∣ μ ) = ∑ i = 1 N α t ( i ) × β t ( i ) = α ( t ) T β ( t ) \begin{aligned} p(O|\mu)&=\sum_{i=1}^N p(o_1\dots o_T,q_t=s_i|\mu) \\ &= \sum_{i=1}^N p(o_{t+1} \dots o_T|q_t=s_i,o_1\dots,o_t,\mu)p(o_1,\dots,o_t,q_t|\mu) \\ &=\sum_{i=1}^Np(o_t\dots o_{T}|q_{t-1}=s_i,\mu)p(o_1,\dots,o_t,q_t|\mu) \\ &=\sum_{i=1}^N\alpha_t(i)\times \beta_t(i) \\ &=\alpha(t)^T\beta(t) \end{aligned}
  通过引入动态规划算法，基本问题一可以被相对较高效地解决了。

五、维特比算法

  接下来考虑基本问题二，即给定观测序列 o 1 … o T o_1\dots o_T 和模型 μ = ( A , B , π ) \mu=(A,B,\pi) ，求最优的状态序列 q 1 q 2 … q T q_1q_2\dots q_T 。首先我们需要定义“最优”，比较合理的想法是
Q ∗ = arg max ⁡ q 1 … q T p ( Q ∣ O , μ ) Q^*=\argmax_{q_1\dots q_T}p(Q|O,\mu)
  直接对式 p ( Q ∣ O , μ ) p(Q|O,\mu) 进行时间上的递推是有些困难的，但是根据贝叶斯公式，有
p ( Q ∣ O , μ ) ∝ p ( O , Q ∣ μ ) p(Q|O,\mu) \propto p(O,Q|\mu)
因而我们可以考虑对 p ( O , Q ∣ μ ) p(O,Q|\mu) 使用动态规划的算法，对问题进行分解，若对序列长度为 T T 时成立，则对子过程长度 t t 也应当满足 p ( q 1 … q t , o 1 … o t ∣ μ ) p(q_1\dots q_t, o_1\dots o_t|\mu) 最大。基于上面的思路，定义如下的一个变量
δ t ( i ) = max ⁡ q 1 … q t − 1 p ( q 1 … q t − 1 , q t = s i , o 1 … o t ∣ μ ) \delta_t(i)=\max_{q_1\dots q_{t-1}}p(q_1\dots q_{t-1},q_t=s_i,o_1\dots o_t|\mu)
  上述变量称为维特比(Viterbi)变量，类似前向算法和后向算法的分析，得到如下的递推关系（不加证明），
δ t + 1 ( j ) = max ⁡ i [ δ t ( i ) a i j ] b t + 1 ( o t + 1 ) \delta_{t+1}(j)=\max_{i} \left[ \delta_t(i)a_{ij} \right]b_{t+1}(o_{t+1})
这里需要注意一个问题，由于存在转移概率，所以决定 t t 时刻的最优状态 q t q_t 的关键因素是 q t + 1 q_{t+1} ，因而，为了确定整个最优状态序列 q 1 … q T q_1\dots q_T ，需要从 q T q_T 开始回溯至 q 1 q_1 ，因而算法需要记录下这些回溯路径，用符号 l ( q t ∗ = s i ) l(q_t^*=s_i) 表示，它定义为 q t ∗ = s i q_t^*=s_i 时， q t − 1 ∗ q_{t-1}^* 的状态。
  这样，就能够对算法进行前向递推，再进行反向回溯，从而求解出最佳状态序列 q 1 … q T q_1 \dots q_T 。把Viterbi算法总结如下，
算法5.1 Viterbi算法

  1. 初始化
    δ 1 ( i ) = π i , i = 1 , … , N ; \delta_1(i)=\pi_i,i=1,\dots,N;
  2. F o r t = 2 , … , T d o \bold{For} \quad t=2,\dots,T\quad \bold{do}
    F o r j = 1 , … , N d o \quad \bold{For} \quad j=1,\dots,N \quad \bold{do}
    δ t ( j ) = max ⁡ i [ δ t − 1 ( i ) a i j ] b j ( o t ) ; r e c o r d l ( q t ∗ = s j ) = arg max ⁡ i [ [ δ t − 1 ( i ) a i j ] ; \delta_t(j)=\max_{i}[\delta_{t-1}(i)a_{ij}]b_j(o_t);\\ \bold{record}\quad l(q_t^*=s_j)=\argmax_i[[\delta_{t-1}(i)a_{ij}];
  3. 递推终止
    q T ∗ = arg max ⁡ j δ T ( j ) ; q_T^*=\argmax_{j}\delta_T(j);
  4. 回溯
    F o r t = T − 1 , … , 1 d o \bold{For}\quad t=T-1,\dots,1 \quad \bold{do}
    q t ∗ = l ( q t + 1 ∗ ) ; q_t^*=l(q_{t+1}^*);
  5. 输出 q 1 ∗ … q T ∗ q_1^*\dots q_T^* ；

  简单分析可知，Viterbi算法的时间复杂度和空间复杂度分别为 O ( T N 2 ) O(TN^2) 和 O ( N 2 ) O(N^2) 。这样，基本问题二也被有效解决了。

六、Baum-Welch算法

6.1 先验or后验

  上述两个算法都是基于的模型参数 μ = ( A , B , π ) \mu=(A,B,\pi) 已知，而事实上，实际问题中更多的情形是给定一些训练集，然后通过算法从中估计出合适的模型参数，也就是HMM的基本问题三，其数学形式为
μ ∗ = arg max ⁡ μ p ( μ ∣ Q , O ) \mu^*=\argmax_{\mu}p(\mu|Q,O)
这里的估计方式称为后验估计(posterior estimation)，根据贝叶斯公式，有如下关系成立，
p ( μ ∣ Q , O ) ∝ p ( Q , O ∣ μ ) p ( μ ) p(\mu|Q,O) \propto p(Q,O|\mu)p(\mu)
p ( Q , O ∣ μ ) p(Q,O|\mu) 称为似然函数， p ( μ ) p(\mu) 为参数的先验分布(prior distribution)，这部分我们考虑极大似然估计的方法，即
μ ∗ = arg max ⁡ μ log ⁡ p ( Q , O ∣ μ ) \mu^*=\argmax_{\mu}\log p(Q,O|\mu)

6.2 监督学习

  倘若足够幸运，我们搜集到了大量的序列对 ( Q , O ) (Q, O) ，那么，就可以构建监督学习的模型，也就是说，我们可以直接处理
对数似然函数
l ( μ ) = log ⁡ p ( Q , O ∣ μ ) l(\mu)=\log p(Q,O|\mu)
带入参数，利用Lagrange乘子法求极值。通常情况下，序列 Q Q （例如词性序列）难以获得，或者获取成本极大，于是我们需要考虑无监督学习模型。

6.3 EM算法

  我们依然引入监督学习中的似然函数，即
l ( μ ) = log ⁡ p ( Q , O ∣ μ ) l(\mu)=\log p(Q,O|\mu)
这里的 Q Q 为隐变量，无法获知，因而我们无法写出上式的具体形式。我们无法得知似然函数的具体取值（事实上它是 Q Q 的随机变量函数），就很难通过解析或者迭代的方法一步一步地使它最大化，那么，退一步讲，如果 l ( μ ) l(\mu) 的期望值一步一步最大化，是不是也就一定程度上意味着它本身也是在趋向最大呢？
  上面的想法就是EM(Expectation Maximum)算法的基本思路，也就是对似然函数的期望求最大。在求期望的时候又会遇到一个新的问题， Q Q 的分布是依赖于参数 μ \mu 的，为了使得算法能够运行下去，我们将这里的参数设置为迭代前一时刻的参数（已知条件，通过初始化得来），而将当下的参数设为需要优化的变量，于是定义了 L L 函数（通常的文献里记作Q函数，这里为了区分序列Q），其表达式为
L ( μ ( k ) , μ ( k − 1 ) ) = ∑ Q ∈ S T p ( Q , O ∣ μ ( k − 1 ) ) log ⁡ p ( Q , O ∣ μ ( k ) ) L(\mu^{(k)},\mu^{(k-1)} )=\sum_{Q\in S^T} p(Q,O|\mu^{(k-1)})\log p(Q,O|\mu^{(k)})
  上式完成了E阶段，即求期望阶段，接下来我们要做的就是找到上式的极大值，即M阶段。
μ ( k ) ∗ = arg max ⁡ μ L ( μ ( k ) , μ ( k − 1 ) ) \mu^{(k)*} = \argmax_{\mu}L(\mu^{(k)},\mu^{(k-1)} )
  接下来，推导上述表达式的具体形式，也就是Baum-Welch算法。

6.4 Baum-Welch算法

  我们之前推导过 p ( Q , O ∣ μ ) p(Q,O|\mu) 的具体形式如下，
p ( Q , O ∣ μ ) = ∑ Q ∈ S T π q 1 b q 1 ( o 1 ) ∏ t = 2 T a q t − 1 q t b q t ( o t ) p(Q,O|\mu)=\sum_{Q\in S^T}\pi_{q_1}b_{q_1}(o_1)\prod_{t=2}^{T}a_{q_{t-1}q_t}b_{q_t}(o_t)
由于 μ ( k − 1 ) \mu^{(k-1)} 已知，所以 p ( Q , O ∣ μ ( k − 1 ) ) p(Q,O|\mu^{(k-1)}) 为一常数。于是，简要化简可得对数似然函数如下，
L ( μ ( k ) , μ ( k − 1 ) ) = ∑ Q ∈ S T p ( Q , O ∣ μ ( k − 1 ) ) log ⁡ π q 1 + ∑ Q ∈ S T ∑ t = 1 T p ( Q , O ∣ μ ( k − 1 ) ) log ⁡ b q t ( o t ) + ∑ Q ∈ S T ∑ t = 2 T p ( Q , O ∣ μ ( k − 1 ) ) log ⁡ a q t − 1 q t \begin{aligned} L(\mu^{(k)},\mu^{(k-1)} )&=\sum_{Q\in S^T}p(Q,O|\mu^{(k-1)})\log \pi_{q_1} \\ &\quad +\sum_{Q\in S^T}\sum_{t=1}^T p(Q,O|\mu^{(k-1)})\log b_{q_t}(o_t) \\ &\quad + \sum_{Q\in S^T}\sum_{t=2}^T p(Q,O|\mu^{(k-1)})\log a_{q_{t-1}q_t} \end{aligned}
  接下来，首先考虑求参数 π i \pi_i 的极值点， π i \pi_i 存在以下约束条件，
∑ i = 1 N π i = 1 \sum_{i=1}^N \pi_i = 1
引入Lagrange乘子 λ \lambda ，求导后可得，
∂ L ∂ π i = p ( q 1 = s i , O ∣ μ ( t − 1 ) ) ⋅ 1 π i + λ = 0 i = 1 , 2 , … , N \frac{\partial L}{\partial \pi_i} = p(q_1=s_i,O|\mu^{(t-1)})\cdot \frac{1}{\pi_i}+\lambda=0 \\ i=1,2,\dots,N
解得，
π i ( k ) = p ( q 1 = s i , O ∣ μ ( t − 1 ) ) ∑ i = 1 N p ( q 1 = s i , O ∣ μ ( t − 1 ) ) \pi_i^{(k)} = \frac{p(q_1=s_i,O|\mu^{(t-1)})}{\sum_{i=1}^N p(q_1=s_i,O|\mu^{(t-1)})}
  值得注意的是，在4.4部分，我们探讨了前向变量和后向变量的关系，于是，上式又可表示为
π i ( k ) = π i ( k − 1 ) β 1 ( i ) ∑ i = 1 N π i ( k − 1 ) β 1 ( i ) \pi_i^{(k)}=\frac{\pi_i^{(k-1)}\beta_1(i)}{\sum_{i=1}^N \pi_i^{(k-1)}\beta_1(i)}
  然后讨论参数 a i j a_{ij} ，它的约束条件为
∑ j = 1 N a i j = 1 i = 1 , … , N \sum_{j=1}^Na_{ij}=1\quad i=1,\dots,N
同样，引入Lagrange乘子 λ i \lambda_i ，求导后可得
∂ L ∂ a i j = ∑ t = 2 T p ( q t − 1 = s i , q t = s j , O ∣ μ ( k − 1 ) ) + λ i a i j = 0 \frac{\partial L}{\partial a_{ij}}=\sum_{t=2}^Tp(q_{t-1}=s_i,q_t=s_j,O|\mu^{(k-1)})+\lambda_i a_{ij}=0
解得，
a i j ( k ) = ∑ t = 2 T p ( q t − 1 = s i , q t = s j , O ∣ μ ( k − 1 ) ) ∑ i = 1 N ∑ t = 2 T p ( q t − 1 = s i , q t = s j , O ∣ μ ( k − 1 ) ) a_{ij}^{(k)}=\frac{\sum_{t=2}^Tp(q_{t-1}=s_i,q_t=s_j,O|\mu^{(k-1)})}{\sum_{i=1}^N \sum_{t=2}^Tp(q_{t-1}=s_i,q_t=s_j,O|\mu^{(k-1)})}
利用前向变量和后向变量，我们可以推导以下关系，
p ( q t − 1 = s i , q t = s j ∣ O , μ ) = p ( q t − 1 = s i , q t = s j , O ∣ μ ) p ( O ∣ μ ) = p ( o t + 1 … o T ∣ , q t = s j , o 1 … o t , q t − 1 = s i ) × p ( o t , q t = s j ∣ q t − 1 = s i ) × p ( o 1 … o t − 1 , q t − 1 = s i ) / p ( O ∣ μ ) = α t − 1 ( i ) a i j b t ( o t ) β t ( j ) ∑ i = 1 N ∑ j = 1 N α t − 1 ( i ) a i j b t ( o t ) β t ( j ) \begin{aligned} p(q_{t-1}=s_i,q_t =s_j|O,\mu)&=\frac{p(q_{t-1}=s_i,q_t =s_j,O|\mu)}{p(O|\mu)} \\ &=p(o_{t+1}\dots o_{T}|,q_t=s_j,o_1 \dots o_t,q_{t-1}=s_i) \\ &\quad \times p(o_t,q_t=s_j|q_{t-1}=s_i) \times p(o_1\dots o_{t-1},q_{t-1}=s_i) / p(O|\mu)\\ &=\frac{\alpha_{t-1}(i)a_{ij}b_t(o_t)\beta_t(j)}{\sum_{i=1}^N\sum_{j=1}^N \alpha_{t-1}(i)a_{ij}b_t(o_t)\beta_t(j)} \end{aligned}
  为了书写简便，我们引入两个新的符号，记
ξ t ( i , j ) = p ( q t = s i , q t + 1 = s j ∣ O , μ ) \xi_t(i,j)=p(q_t=s_i, q_{t+1}=s_j|O,\mu)
γ t ( i ) = p ( q t = s i ∣ O , μ ) = ∑ j = 1 N ξ t ( i , j ) \gamma_t(i)=p(q_t=s_i|O,\mu)=\sum_{j=1}^N \xi_t(i,j)
因此， a i j a_{ij} 的新的参数更新式如下，
a i j ( k ) = ∑ t = 1 T − 1 ξ t ( i , j ) ∑ t = 1 T − 1 γ t ( j ) a_{ij}^{(k)}=\frac{\sum_{t=1}^{T-1} \xi_t(i,j)}{\sum_{t=1}^{T-1}\gamma_t(j)}
  最后，我们考虑参数 b j ( n ) b_j(n) ，它表示概率 p ( o t = v n ∣ q t = s j ) p(o_t=v_n|q_t=s_j) 。它满足的约束条件为
∑ n = 1 M b j ( n ) = 1 , j = 1 , … , N \sum_{n=1}^M b_j(n)=1,j=1,\dots,N
利用Lagrange乘子法，得到如下方程，
∂ L ∂ b j ( n ) = ∑ t = 1 T p ( q t = s j , O ∣ μ ( k − 1 ) ) 1 ( o t = v n ) + λ j b j ( n ) = 0 \frac{\partial L}{\partial b_j(n)} = \sum_{t=1}^Tp(q_t=s_j,O|\mu^{(k-1)})\bold{1}(o_t=v_n)+\lambda_j b_j(n)=0
解得，
b j ( n ) = ∑ t = 1 T p ( q t = s j , O ∣ μ ( k − 1 ) ) 1 ( o t = v n ) ∑ t = 1 T p ( q t = s j , O ∣ μ ( k − 1 ) ) b_j(n)=\frac{\sum_{t=1}^Tp(q_t=s_j,O|\mu^{(k-1)})\bold{1}(o_t=v_n) }{\sum_{t=1}^Tp(q_t=s_j,O|\mu^{(k-1)}) }
带入符号，得
b j ( n ) = ∑ t = 1 T γ t ( j ) 1 ( o t = v n ) ∑ t = 1 T γ t ( j ) b_j(n)=\frac{\sum_{t=1}^T \gamma_t(j) \bold{1}(o_t=v_n)}{\sum_{t=1}^T \gamma_t(j)}
至此，所有的参数更新式都已推导出来，下面将算法总结如下，

算法6.1

  1. 初始化 μ 0 = ( A 0 , B 0 , π 0 ) \mu_0=(A_0,B_0,\pi_0) ；
  2. F o r k = 1 , … , m a x i t e r a t e d o \bold{For}\quad k=1,\dots,maxiterate \quad \bold{do}
    F o r w a r d a l g o r i t h m → α ( k ) ; B a c k w a r d a l g o r i t h m → β ( k ) ; ξ t ( i , j ) ← α t − 1 ( i ) a i j b t ( o t ) β t ( j ) ∑ i = 1 N ∑ j = 1 N α t − 1 ( i ) a i j b t ( o t ) β t ( j ) ; γ t ( i ) ← ∑ j = 1 N ξ t ( i , j ) ; a i j ( k + 1 ) = ∑ t = 1 T − 1 ξ t ( i , j ) ∑ t = 1 T − 1 γ t ( j ) ; b j ( k + 1 ) ( n ) = ∑ t = 1 T γ t ( j ) 1 ( o t = v n ) ∑ t = 1 T γ t ( j ) ; π i ( k + 1 ) = γ 1 ( i ) ; \begin{aligned} & \bold{Forward\quad algorithm} \rightarrow \alpha^{(k)}; \\ &\bold{Backward \quad algorithm} \rightarrow \beta^{(k)}; \\ &\xi_t(i,j) \leftarrow \frac{\alpha_{t-1}(i)a_{ij}b_t(o_t)\beta_t(j)}{\sum_{i=1}^N\sum_{j=1}^N \alpha_{t-1}(i)a_{ij}b_t(o_t)\beta_t(j)}; \\ &\gamma_t(i) \leftarrow \sum_{j=1}^N \xi_t(i,j); \\ &a_{ij}^{(k+1)}=\frac{\sum_{t=1}^{T-1} \xi_t(i,j)}{\sum_{t=1}^{T-1}\gamma_t(j)}; \\ & \\ &b_j^{(k+1)}(n)=\frac{\sum_{t=1}^T \gamma_t(j) \bold{1}(o_t=v_n)}{\sum_{t=1}^T \gamma_t(j)};\\ &\pi_i^{(k+1)}=\gamma_1(i); \end{aligned}
  3. 算法终止，输出 μ = ( A , B , π ) \mu=(A,B,\pi) ;

七、一些可用的工具

  hmmlearn和seqlearn是比较好用的用于序列学习的工具包，提供了python接口，链接如下
https://pypi.org/project/hmmlearn/
https://pypi.org/project/seqlearn/

[参考资料]
[1]: 宗成庆.《统计自然语言处理》

Siomkos
发布了6 篇原创文章 · 获赞 3 · 访问量 180
私信 关注

猜你喜欢

转载自blog.csdn.net/qq_35733289/article/details/104195426
今日推荐
周排行
成为C++高手之宏与枚举
在CAD二次开发中使用进度条
Js插件ECharts，HighCharts学习网址整理
Celery提交任务出错(on windows.)
cephfs内核客户端性能追踪
thinkphp中PHPExcel用法
EntityFramework动态组合多排序字段
汇编语言（八）实验9 根据材料编程
安装ubuntu后必须做的事情（对我而言）
JS函数式编程
每日归档
更多
2024-10-22(0)
2024-10-21(0)
2024-10-20(0)
2024-10-19(0)
2024-10-18(0)
2024-10-17(0)
2024-10-16(0)
2024-10-15(0)
2024-10-14(0)
2024-10-13(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022