第十六章 隐马尔科夫模型

文章目录

    • 简介
    • 概念
      • 随机变量与随机过程
      • 马尔可夫链
      • 隐含马尔可夫模型
      • 两个基本假设
      • 三个基本问题
    • 算法
      • 观测序列生成算法
      • 概率计算算法
        • 前向概率与后向概率
          • 前向算法
          • 后向算法
          • 小结
        • 概率与期望
      • 学习问题
        • 监督学习方法
        • Baum-Welch算法
      • 预测算法
        • 近似算法(MAP)
        • 维特比算法(Viterbi)

简介


  • 动态贝叶斯网络的最简单实现隐马尔可夫模型。HMM可以看成是一种推广的混合模型。

  • 序列化建模,打破了数据独立同分布的假设。

  • 有些关系需要理清

    第十六章 隐马尔科夫模型_第1张图片
  • 另外一个图

马尔可夫网络
贝叶斯网络
B
A
C
D
B
A
C
D

另外,注意一点,在李老师这本书上介绍的HMM,涉及到举例子的,给的都是观测概率矩阵是离散的情况,对应了Multinominal HMM。但这个观测概率矩阵是可以为连续的分布的,比如高斯模型,对应了Gaussian HMM,高斯无处不在。具体可以参考hmmlearn库[^2]

  • HMM有两个基本假设和三个基本问题, 两个基本假设。 I I I是隐变量。

概念


随机变量与随机过程


19世纪, 概率论的发展从对(相对静态的)随机变量的研究发展到对随机变量的时间序列 s 1 , s 2 , s 3 , … , s t , … s_1,s_2, s_3, \dots,s_t,\dots s1,s2,s3,,st,,即随机过程(动态的)的研究

马尔可夫链


随机过程有两个维度的不确定性。马尔可夫为了简化问题,提出了一种简化的假设,即随机过程中各个状态 s t s_t st的概率分布,只与它的前一个状态 s t − 1 s_{t-1} st1有关, 即 P ( s t ∣ s 1 , s 2 , s 3 , … , s t − 1 ) = P ( s t ∣ s t − 1 ) P(s_t|s_1, s_2, s_3, \dots,s_{t-1})=P(s_t|s_{t-1}) P(sts1,s2,s3,,st1)=P(stst1)

这个假设后来被称为马尔可夫假设,而符合这个假设的随机过程则称为马尔可夫过程,也称为马尔可夫链

P ( s t ∣ s 1 , s 2 , s 3 , … , s t − 1 ) = P ( s t ∣ s t − 1 ) P(s_t|s_1, s_2, s_3, \dots,s_{t-1})=P(s_t|s_{t-1}) P(sts1,s2,s3,,st1)=P(stst1)

时间和状态取值都是离散的马尔可夫过程也称为马尔可夫链

隐含马尔可夫模型


P ( s 1 , s 2 , s 3 , … , o 1 , o 2 , o 3 , …   ) = ∏ t P ( s t ∣ s t − 1 ) ⋅ P ( o t ∣ s t ) P(s_1,s_2,s_3,\dots,o_1,o_2,o_3,\dots)=\prod_tP(s_t|s_{t-1})\cdot P(o_t|s_t) P(s1,s2,s3,,o1,o2,o3,)=tP(stst1)P(otst)

隐含的是状态 s s s

隐含马尔可夫模型由初始概率分布(向量 π \pi π), 状态转移概率分布(矩阵 A A A)以及观测概率分布(矩阵 B B B)确定.

隐马尔可夫模型 λ \lambda λ 可以用三元符号表示, 即
λ = ( A , B , π ) \lambda = (A, B, \pi) λ=(A,B,π)

其中 A , B , π A,B,\pi A,B,π称为模型三要素。

具体实现的过程中,如果观测的概率分布是定的,那么 B B B就是确定的。在hhmlearn中,实现了三种概率分布的HMM模型:MultinominalHMM,GaussianHMM,GMMHMM。还可以定义不同的emission probabilities[^3],生成不同的HMM模型。

两个基本假设


  1. 齐次马尔科夫假设(状态)
    P ( i t ∣ i t − 1 , o t − 1 , … , i 1 , o 1 ) = P ( i t ∣ i t − 1 ) , t = 1 , 2 , … , T P(i_t|i_{t-1},o_{t-1},\dots,i_1,o_1) = P(i_t|i_{t-1}), t=1,2,\dots,T P(itit1,ot1,,i1,o1)=P(itit1),t=1,2,,T
    注意书里这部分的描述

    假设隐藏的马尔可夫链在任意时刻 t t t的状态 → i t \rightarrow i_t it

    只依赖于其前一时刻的状态 → i t − 1 \rightarrow i_{t-1} it1

    与其他时刻的状态 → i t − 1 , … , i 1 \rightarrow i_{t-1, \dots, i_1} it1,,i1

    及观测无关 → o t − 1 , … , o 1 \rightarrow o_{t-1},\dots,o_1 ot1,,o1

    也与时刻 t t t无关 → t = 1 , 2 , … , T \rightarrow t=1,2,\dots,T t=1,2,,T

    如此烦绕的一句话, 用一个公式就表示了, 数学是如此美妙.

  2. 观测独立性假设(观测)
    P ( o t ∣ i T , o T , i T − 1 , o T − 1 , … , i t + 1 , o t + 1 , i t , i t − 1 , o t − 1 , … , i 1 , o 1 ) = P ( o t ∣ i t ) P(o_t|i_T,o_T,i_{T-1},o_{T-1},\dots,i_{t+1},o_{t+1},i_t,i_{t-1},o_{t-1},\dots,i_1,o_1)=P(o_t|i_t) P(otiT,oT,iT1,oT1,,it+1,ot+1,it,it1,ot1,,i1,o1)=P(otit)
    书里这部分描述如下

    假设任意时刻 t t t的观测 → o t \rightarrow o_t ot

    只依赖于该时刻的马尔可夫链的状态 → i t \rightarrow i_t it

    与其他观测 → o T , o T − 1 , … , o t + 1 , o t − 1 , … , o 1 \rightarrow o_T,o_{T-1},\dots,o_{t+1},o_{t-1},\dots,o_1 oT,oT1,,ot+1,ot1,,o1

    及状态无关 → i T , i T − 1 , … , i t + 1 , i t − 1 , … , i 1 \rightarrow i_T,i_{T-1},\dots,i_{t+1},i_{t-1},\dots,i_1 iT,iT1,,it+1,it1,,i1

三个基本问题


  1. 概率计算问题
    输入: 模型 λ = ( A , B , π ) \lambda=(A,B,\pi) λ=(A,B,π), 观测序列 O = ( o 1 , o 2 , … , o T ) O=(o_1,o_2,\dots,o_T) O=(o1,o2,,oT)
    输出: P ( O ∣ λ ) P(O|\lambda) P(Oλ)

  2. 学习问题
    输入: 观测序列 O = ( o 1 , o 2 , … , o T ) O=(o_1,o_2,\dots,o_T) O=(o1,o2,,oT)
    输出: 输出 λ = ( A , B , π ) \lambda=(A,B,\pi) λ=(A,B,π)

  3. 预测问题, 也称为解码问题(Decoding)
    输入: 模型 λ = ( A , B , π ) \lambda=(A,B,\pi) λ=(A,B,π), 观测序列 O = ( o 1 , o 2 , … , o T ) O=(o_1,o_2,\dots,o_T) O=(o1,o2,,oT)
    输出: 状态序列 I = ( i 1 , i 2 , … , i T ) I=(i_1,i_2,\dots,i_T) I=(i1,i2,,iT)

    因为状态序列是隐藏的,不可观测的,所以叫解码

HMM存在三个基本问题:
-给定模型参数和观测数据,估计隐藏状态的最优序列
-给定模型参数和观测数据,计算数据的可能性
-仅在给定观测数据的情况下,估计模型参数
第一个和第二个问题可以分别通过称为维特比算法和前向-后向算法的动态编程算法来解决。最后一个问题可以通过迭代期望最大化(EM)算法来解决,该算法被称为Baum-Welch算法

算法


观测序列生成算法


输入: λ = ( A , B , π ) \lambda=(A,B,\pi) λ=(A,B,π) ,观测序列长度 T T T

输出:观测序列 O = ( o 1 , o 2 , … , o T ) O=(o_1,o_2,\dots,o_T) O=(o1,o2,,oT)

  1. 按照初始状态分布 π \pi π产生 i 1 i_1 i1
  2. t = 1 t=1 t=1
  3. 按照状态 i t i_t it的观测概率分布 b i t ( k ) b_{i_t}(k) bit(k)生成 o t o_t ot
  4. 按照状态 i t i_t it的状态转移概率分布 { a i t , i t + 1 } \{a_{i_t, {i_{t+1}}}\} {ait,it+1}产生状态 i t + 1 i_{t+1} it+1, i t + 1 = 1 , 2 , … , N \color{red}i_{t+1}=1,2,\dots,N it+1=1,2,,N
  5. t = t + 1 t=t+1 t=t+1 如果 t < T tt<T转到3,否则,终止

书中定义了 I = ( i 1 , i 2 , … , i T ) , Q = { q 1 , q 2 , … , q T } I=(i_1,i_2,\dots,i_T), Q=\{q_1,q_2,\dots,q_T\} I=(i1,i2,,iT),Q={q1,q2,,qT}根据定义, i t i_t it的取值集合应该是 Q Q Q,而上面算法描述中说明了 i t + 1 = 1 , 2 , … , N \color{red}i_{t+1}=1,2,\dots,N it+1=1,2,,N
注意这里面的 i t i_t it实际上不是状态, 而是对应了前面的 i , j i,j i,j的含义,实际的状态应该是 q i t q_{i_t} qit这个算法中的 a i t i t + 1 = P ( i t + 1 = q i t + 1 ∣ i t = q i t ) a_{i_ti_{t+1}}=P(i_{t+1}=q_{i_{t+1}}|i_t=q_{i_t}) aitit+1=P(it+1=qit+1it=qit) 这里同样的符号,表示了两个不同的含义

概率计算算法


前向概率与后向概率

给定马尔可夫模型 λ \lambda λ, 定义到时刻 t t t部分观测序列为 o 1 , o 2 , … , o t o_1, o_2, \dots ,o_t o1,o2,,ot, 且状态 q i q_i qi的概率为前向概率, 记作
α t ( i ) = P ( o 1 , o 2 , … , o t , i t = q i ∣ λ ) \alpha_t(i)=P(o_1,o_2,\dots,o_t,i_t=q_i|\lambda) αt(i)=P(o1,o2,,ot,it=qiλ)
给定马尔可夫模型 λ \lambda λ, 定义到时刻 t t t状态为 q i q_i qi的条件下, 从 t + 1 t+1 t+1 T T T的部分观测序列为 o t + 1 , o t + 2 , … , o T o_{t+1}, o_{t+2}, \dots ,o_T ot+1,ot+2,,oT的概率为后向概率, 记作
β t ( i ) = P ( o t + 1 , o t + 2 , … , o T ∣ i t = q i , λ ) \beta_t(i)=P(o_{t+1},o_{t+2},\dots,o_T|i_t=q_i, \lambda) βt(i)=P(ot+1,ot+2,,oTit=qi,λ)
关于 α 和 β 这两个公式 , 仔细看下 , 细心理解 . \color{red} 关于\alpha 和\beta 这两个公式, 仔细看下, 细心理解. 关于αβ这两个公式,仔细看下,细心理解. 前向概率从前往后递推, 后向概率从后向前递推。

前向算法

输入: λ , O \lambda , O λ,O

输出: P ( O ∣ λ ) P(O|\lambda) P(Oλ)

  1. 初值
    α 1 ( i ) = π i b i ( o 1 ) , i = 1 , 2 , … , N \alpha_1(i)=\pi_ib_i(o_1), i=1,2,\dots,N α1(i)=πibi(o1),i=1,2,,N
    观测值 o 1 o_1 o1, i i i的含义是对应状态 q i q_i qi

    这里 α \alpha α N N N维向量, 和状态集合 Q Q Q的大小 N N N有关系. α \alpha α是个联合概率.

  2. 递推
    α t + 1 ( i ) = [ ∑ j = 1 N α t ( j ) a j i ] b i ( o t + 1 ) ,   i = 1 , 2 , … , N ,   t = 1 , 2 , … , T − 1 \color{red}\alpha_{t+1}(i) = \left[\sum\limits_{j=1}^N\alpha_t(j)a_{ji}\right]b_i(o_{t+1})\color{black}, \ i=1,2,\dots,N, \ t = 1,2,\dots,T-1 αt+1(i)=[j=1Nαt(j)aji]bi(ot+1), i=1,2,,N, t=1,2,,T1
    转移矩阵 A A A维度 N × N N\times N N×N, 观测矩阵 B B B维度 N × M N\times M N×M, 具体的观测值 o o o可以表示成one-hot形式, 维度 M × 1 M\times1 M×1, 所以 α \alpha α的维度是 α = α A B o = 1 × N × N × N × N × M × M × N = 1 × N \alpha = \alpha ABo=1\times N\times N\times N \times N\times M \times M\times N=1\times N α=αABo=1×N×N×N×N×M×M×N=1×N

  3. 终止
    P ( O ∣ λ ) = ∑ i = 1 N α T ( i ) = ∑ i = 1 N α T ( i ) β T ( i ) P(O|\lambda)=\sum\limits_{i=1}^N\alpha_T(i)=\color{red}\sum\limits_{i=1}^N\alpha_T(i)\beta_T(i) P(Oλ)=i=1NαT(i)=i=1NαT(i)βT(i)
    注意, 这里 O → ( o 1 , o 2 , o 3 , … , o t ) O\rightarrow (o_1, o_2, o_3,\dots, o_t) O(o1,o2,o3,,ot), α i \alpha_i αi见前面前向概率的定义 P ( o 1 , o 2 , … , o t , i t = q i ∣ λ ) P(o_1,o_2,\dots,o_t,i_t=q_i|\lambda) P(o1,o2,,ot,it=qiλ), 所以, 对 i i i求和能把联合概率中的 I I I消掉.

    这个书里面解释的部分有说.

书中有说前向算法的关键是其局部计算前向概率, 然后利用路径结构将前向概率"递推"到全局.

减少计算量的原因在于每一次计算直接引用前一时刻的计算结果, 避免重复计算.

前向算法计算 P ( O ∣ λ ) P(O|\lambda) P(Oλ)的复杂度是 O ( N 2 T ) O(N^2T) O(N2T)阶的,直接计算的复杂度是 O ( T N T ) O(TN^T) O(TNT)阶,所以 T = 2 T=2 T=2时候并没什么改善。

红色部分为后补充了 β T ( i ) \beta_T(i) βT(i)项,这项为1,此处注意和后面的后向概率对比。

后向算法

输入: λ , O \lambda , O λ,O
输出: P ( O ∣ λ ) P(O|\lambda) P(Oλ)

  1. 终值
    β T ( i ) = 1 , i = 1 , 2 , … , N \beta_T(i)=1, i=1,2,\dots,N βT(i)=1,i=1,2,,N
    t = T t=T t=T时刻, 观测序列已经确定.

  2. 递推
    β t ( i ) = ∑ j = 1 N a i j b j ( o t + 1 ) β t + 1 ( j ) , i = 1 , 2 , … , N , t = T − 1 , T − 2 , … , 1 \color{red}\beta_t(i)=\sum\limits_{j=1}^Na_{ij}b_j(o_{t+1})\beta_{t+1}(j)\color{black}, i=1,2,\dots,N, t=T-1, T-2,\dots,1 βt(i)=j=1Naijbj(ot+1)βt+1(j),i=1,2,,N,t=T1,T2,,1
    从后往前推
    β = A B o β = N × N × N × M × M × N × N × 1 = N × 1 \beta = ABo\beta = N \times N \times N \times M \times M \times N \times N \times 1 = N \times 1 β=ABoβ=N×N×N×M×M×N×N×1=N×1

P ( O ∣ λ ) = ∑ i = 1 N π i b i ( o 1 ) β 1 ( i ) = ∑ i = 1 α 1 ( i ) β 1 ( i ) P(O|\lambda)=\sum\limits_{i=1}^N\pi_ib_i(o_1)\beta_1(i)=\color{red}\sum\limits_{i=1}\alpha_1(i)\beta_1(i) P(Oλ)=i=1Nπibi(o1)β1(i)=i=1α1(i)β1(i)

  • 这里需要注意下,按照后向算法, β \beta β在递推过程中会越来越小,如果层数较多,怕是 P ( O ∣ λ ) P(O|\lambda) P(Oλ)会消失
  • 另外一个要注意的点 o t + 1 β t + 1 \color{red}o_{t+1}\beta_{t+1} ot+1βt+1
  • 注意,红色部分为后补充,结合前面的前向概率最后的红色部分一起理解
小结

求解的都是观测序列概率
观测序列概率 P ( O ∣ λ ) P(O|\lambda) P(Oλ)统一写成
P ( O ∣ λ ) = ∑ i = 1 N ∑ j = 1 N α t ( i ) a i j b j ( o t + 1 β t + 1 ( j ) ) ,   t = 1 , 2 , … , T − 1 P(O|\lambda)=\sum_{i=1}^N\sum_{j=1}^N\alpha_t(i)a_{ij}b_j(o_{t+1}\beta_{t+1}(j)),\ t=1,2,\dots,T-1 P(Oλ)=i=1Nj=1Nαt(i)aijbj(ot+1βt+1(j)), t=1,2,,T1

P ( O ∣ λ ) = α A B o β P(O|\lambda) = \alpha ABo\beta P(Oλ)=αABoβ

其实前向和后向不是为了求整个序列 O O O的概率,是为了求中间的某个点 t t t,前向后向主要是有这个关系:
α t ( i ) β t ( i ) = P ( i t = q i , O ∣ λ ) \alpha_t(i)\beta_t(i)=P(i_t=q_i,O|\lambda) αt(i)βt(i)=P(it=qi,Oλ)
t = 1 t=1 t=1或者 t = T − 1 t=T-1 t=T1的时候,单独用后向和前向就可以求得 P ( O ∣ λ ) P(O|\lambda) P(Oλ),分别利用前向和后向算法均可以求解 P ( O ∣ λ ) P(O|\lambda) P(Oλ),结果一致。

利用上述关系可以得到下面一些概率和期望,这些概率和期望的表达式在后面估计模型参数的时候有应用。

概率与期望

  1. 输入模型 λ \lambda λ与观测 O O O,输出在时刻 t t t处于状态 q i q_i qi的概率 γ t ( i ) \gamma_t(i) γt(i)
  2. 输入模型 λ \lambda λ与观测 O O O,输出在时刻 t t t处于状态 q i q_i qi且在时刻 t + 1 t+1 t+1处于状态 q j q_j qj的概率 ξ t ( i , j ) \xi_t(i,j) ξt(i,j)
  3. 在观测 O O O下状态 i i i出现的期望值
  4. 在观测 O O O下状态 i i i转移的期望值
  5. 在观测 O O O下状态 i i i转移到状态 j j j的期望值

学习问题


监督学习方法

效果好,费钱,如果有钱能拿到标注数据,不用犹豫,去干吧。

Baum-Welch算法

马尔可夫模型实际上是一个含有隐变量的概率模型
P ( O ∣ λ ) = ∑ I P ( O ∣ I , λ ) P ( I ∣ λ ) P(O|\lambda)=\sum\limits_IP(O|I,\lambda)P(I|\lambda) P(Oλ)=IP(OI,λ)P(Iλ)
关于EM算法可以参考第九章, 对隐变量求期望, Q Q Q函数极大化

输入: 观测数据 O = ( o 1 , o 2 , … , o T ) O=(o_1, o_2, \dots, o_T) O=(o1,o2,,oT)

输出: 隐马尔可夫模型参数

  1. 初始化
    n = 0 n=0 n=0,选取 a i j ( 0 ) , b j ( k ) ( 0 ) , π i ( 0 ) a_{ij}^{(0)}, b_j(k)^{(0)}, \pi_i^{(0)} aij(0),bj(k)(0),πi(0),得到模型参数 λ ( 0 ) = ( A ( 0 ) , B ( 0 ) , π ( 0 ) ) \lambda^{(0)}=(A^{(0)}, B^{(0)},\pi^{(0)}) λ(0)=(A(0),B(0),π(0))

  2. 递推
    n = 1 , 2 , … , n=1,2,\dots, n=1,2,,
    a i j ( n + 1 ) = ∑ t = 1 T − 1 ξ t ( i , j ) ∑ t = 1 T − 1 γ t ( i ) a_{ij}^{(n+1)}=\frac{\sum\limits_{t=1}^{T-1}\xi_t(i,j)}{\sum\limits_{t=1}^{T-1}\gamma_t(i)} aij(n+1)=t=1T1γt(i)t=1T1ξt(i,j)

b j ( k ) ( n + 1 ) = ∑ t = 1 , o t = v k T γ t ( j ) ∑ t = 1 T γ t ( j ) b_j(k)^{(n+1)}=\frac{\sum\limits_{t=1,o_t=v_k}^{T}\gamma_t(j)}{\sum\limits_{t=1}^T\gamma_t(j)} bj(k)(n+1)=t=1Tγt(j)t=1,ot=vkTγt(j)

π i ( n + 1 ) = γ 1 ( i ) \pi_i^{(n+1)}=\gamma_1(i) πi(n+1)=γ1(i)

  1. 终止
    得到模型参数 λ ( n + 1 ) = ( A ( n + 1 ) , B ( n + 1 ) , π ( n + 1 ) ) \lambda^{(n+1)}=(A^{(n+1)}, B^{(n+1)},\pi^{(n+1)}) λ(n+1)=(A(n+1),B(n+1),π(n+1))

理解:


单独说一下这个问题,公式里面求和有个 o t = v k o_t=v_k ot=vk, 什么意思?

γ \gamma γ的维度应该是 N × T N\times T N×T,通过 ∑ t = 1 T \sum\limits_{t=1}^T t=1T可以降维到 N N N,但是实际上 B B B的维度是 N × M N\times M N×M,所以有了这个表达,书中对应部分的表达在 P 172 的 10.3 P_{172}的10.3 P17210.3,也说明了 b j ( k ) b_j(k) bj(k)的具体定义。

注意这里 b j ( k ) b_j(k) bj(k)并不要求是离散的,可以定义为一个连续的函数, 所以书中这样的表达更通用一些,关于这点在本章大参考文献[^5]中有部分内容讨论,见Special cases of the B parameters

这里涉及到实际实现的时候,可以考虑把观测序列 O O O转换成one-hot的形式, O o n e _ h o t O_{one\_hot} Oone_hot维度为 M × T M\times T M×T B B B的维度 N × M N\times M N×M B ⋅ O B\cdot O BO之后,转换成观测序列对应的发射概率矩阵,维度为 N × T N\times T N×T

补充一下, o t = v k o_t=v_k ot=vk有另外一种表达是$ \sigma_{o_t,v_k}$, 克罗内克函数。

克罗内克函数是一个二元函数, 自变量一般是两个整数, 如果两者相等, 输出是1, 否则为0.

其实和指示函数差不多, 只不过条件只限制在了相等。
σ i j = { 1 ( i = j ) 0 ( i ≠ j ) b j ( k ) = ∑ t = 1 , o t = v k T γ t ( j ) ∑ t = 1 T γ t ( j ) = ∑ t = 1 T σ o t , v k γ t ( j ) ∑ t = 1 T γ t ( j ) \sigma_{ij}= \begin{cases} 1 (i = j)\\ 0 (i\ne j) \end{cases} \\ b_j(k)=\frac{\sum\limits_{t=1,o_t=v_k}^{T}\gamma_t(j)}{\sum\limits_{t=1}^T\gamma_t(j)}=\frac{\sum\limits_{t=1}^{T}\sigma_{o_t,v_k}\gamma_t(j)}{\sum\limits_{t=1}^T\gamma_t(j)} σij={1(i=j)0(i=j)bj(k)=t=1Tγt(j)t=1,ot=vkTγt(j)=t=1Tγt(j)t=1Tσot,vkγt(j)

E E E步与 M M M步的理解


Baum-Welch算法是EM算法在隐马尔可夫模型学习中的具体实现, 由Baum和Welch提出.

看到书上这里都知道是EM算法, 具体实现 哪里是 E , 哪里是 M ? \color{red}哪里是E,哪里是M? 哪里是E,哪里是M?

书中在前向后向算法介绍之后, 单独有一个小节介绍了"一些概率与期望值的计算", 这部分内容在后面的Baum

-Welch算法中会用到, 代码实现的时候才理解, 这小节对应的是E步概率和期望, 后面算法里面的是M步的内容, 说明如何用这些概率和期望去更新HMM模型的参数.

重新梳理一下整个10.2节的内容,这部分内容描述**概率计算方法 **, 实际上在E步操作的时候都要用到,需要用到前向后向算法根据模型参数 A , B , π A,B,\pi A,B,π来更新 α \alpha α β \beta β,然后利用这两个值来更新一些概率和期望,再通过模型参数的递推公式来更新模型参数。

这里可能还有点疑问,EM算法的描述里面,E步计算的是Q函数,但是前面的描述似乎并没有显示Q函数和这些工作之间的关系。另外,M步具体操作是参数更新的递推公式,怎么就是最大化了呢? 书中 P 182 P_{182} P182的推导也许能解释这个问题。

看到这里, 感觉书上真的是一句废话都没有…

这部分的理解,要再结合第九章的内容反复一下,应该会有新的体会。

注意E步计算Q函数
Q ( λ , λ ˉ ) = ∑ I log ⁡ P ( O , I ∣ λ ) P ( O , I ∣ λ ˉ ) Q(\lambda,\bar{\lambda})=\sum_I\log P(O,I|\lambda)P(O,I|\bar\lambda) Q(λ,λˉ)=IlogP(O,Iλ)P(O,Iλˉ)
对比一下算法9.1, P ( O , I ∣ λ ˉ ) = P ( I ∣ O , λ ˉ ) P ( O ∣ λ ˉ ) P(O,I|\bar\lambda)=P(I|O,\bar\lambda)P(O|\bar\lambda) P(O,Iλˉ)=P(IO,λˉ)P(Oλˉ),所以书中在这个地方有个注释,略去了对于 λ \lambda λ而言的常数因子 1 / P ( O ∣ λ ˉ ) 1/P(O|\bar\lambda) 1/P(Oλˉ)

预测算法


近似算法(MAP)

每个时刻最有可能的状态 i t ∗ i_t^* it
i t ∗ = arg ⁡ max ⁡ 1 ⩽ i ⩽ N [ γ t ( i ) ] , t = 1 , 2 , … , T i_t^*=\arg \max\limits_{1\leqslant i\leqslant N}\left[\gamma_t(i)\right], t=1,2,\dots,T it=arg1iNmax[γt(i)],t=1,2,,T
得到序列 I ∗ = ( i 1 ∗ , i 2 ∗ , … , i T ∗ ) I^*=(i_1^*,i_2^*,\dots,i_T^*) I=(i1,i2,,iT)

这个算法, 在输出每个状态的时候, 只考虑了当前的状态.

维特比算法(Viterbi)

输入: 模型 λ = ( A , B , π ) \lambda=(A, B, \pi) λ=(A,B,π)和观测 O = ( o 1 , o 2 , … , o T ) O=(o_1, o_2,\dots,o_T) O=(o1,o2,,oT)

输出: 最优路径 I ∗ = ( i 1 ∗ , i 2 ∗ , … , i T ∗ ) I^*=(i_1^*, i_2^*,\dots,i_T^*) I=(i1,i2,,iT)

  1. 初始化
    δ 1 ( i ) = π i b i ( o 1 ) , i = 1 , 2 , … , N \delta_1(i)=\pi_ib_i(o_1), i=1,2,\dots,N δ1(i)=πibi(o1),i=1,2,,N
    ψ 1 ( i ) = 0 , i = 1 , 2 , … , N \psi_1(i)=0, i=1,2,\dots,N ψ1(i)=0,i=1,2,,N
  2. 递推
    t = 2 , 3 , … , T t=2,3,\dots,T t=2,3,,T
    δ t ( i ) = max ⁡ 1 ⩽ j ⩽ N [ δ t − 1 ( j ) a j i ] b i ( o t ) , i = 1 , 2 , … , N \delta_t(i)=\max\limits_{1\leqslant j \leqslant N}\left[\delta_{t-1}(j)a_{ji}\right]b_i(o_t), i=1,2,\dots,N δt(i)=1jNmax[δt1(j)aji]bi(ot),i=1,2,,N
    ψ t ( j ) = arg ⁡ max ⁡ 1 ⩽ j ⩽ N [ δ t − 1 ( j ) a j i ] , i = 1 , 2 , … , N \psi_t(j)=\arg\max\limits_{1\leqslant j \leqslant N}\left[\delta_{t-1}(j)a_{ji}\right], i=1,2,\dots,N ψt(j)=arg1jNmax[δt1(j)aji],i=1,2,,N
  3. 终止
    P ∗ = max ⁡ 1 ⩽ i ⩽ N δ T ( i ) P^*=\max\limits_{1\leqslant i\leqslant N}\delta_T(i) P=1iNmaxδT(i)
    i T ∗ = arg ⁡ max ⁡ 1 ⩽ i ⩽ N [ δ T ( i ) ] i_T^*=\arg\max\limits_{1\leqslant i \leqslant N}\left[ \delta_T(i)\right] iT=arg1iNmax[δT(i)]
  4. 最优路径回溯
    t = T − 1 , T − 2 , … , 1 t=T-1, T-2, \dots,1 t=T1,T2,,1
    i t ∗ = ψ t + 1 ( i i + 1 ∗ ) i_t^*=\psi_{t+1}(i_{i+1}^*) it=ψt+1(ii+1)

书上配了个图,这个图可视化了 δ \delta δ

你可能感兴趣的:(机器学习,手写AI,深度学习,机器学习)