HMM 前向后向算法（转）

最近研究NLP颇感兴趣，但由于比较懒，所以只好找来网上别人的比较好的博客，备份一下，也方便自己以后方便查找（其实，一般是不会再回过头来看的，嘿嘿 -_-!!)

代码自己重新写了一遍，所以就不把原文代码贴过来了。

1. 前向算法（摘自http://www.cnblogs.com/kaituorensheng/archive/2012/12/01/2797230.html）

隐马模型的评估问题即，在已知一个观察序列O=O₁O₂...O_T，和模型μ=（A,B,π}的条件下，观察序列O的概率，即P(O|μ}

如果穷尽所有的状态组合，即S₁S₁...S₁, S₁S₁...S₂, S₁S₁...S₃, ..., S₃S₃...S₃。这样的话t₁时刻有N个状态，t₂时刻有N个状态...t_T时刻有N个状态，这样的话一共有N*N*...*N= N^T种组合，时间复杂度为O(N^T),计算时，就会出现“指数爆炸”，当T很大时，简直无法计算这个值。为解决这一问题，Baum提出了前向算法。

归纳过程

首先引入前向变量α_t(i):在时间t时刻，HMM输出序列为O₁O₂...O_T,在第t时刻位于状态s_i的概率。

当T=1时，输出序列为O₁,此时计算概率为P(O₁|μ）：假设有三个状态（如下图）1、2、3，输出序列为O₁，有三种可能一是状态1发出，二是从状态2发出，三是从状态3发出。另外从状态1发出观察值O₁得概率为b₁(O₁),从状态2发出观察值O₁得概率为b₂(O₁),从状态3发出观察值O₁得概率为b₃(O₁)。因此可以算出

P(O₁|μ）= π₁*b₁(O₁)+π₂*b₂(O₁) + π₃*b₃(O₁)= α₁(1) + α₁(2) + α₁(3)

当T=2时，输出序列为O₁O₂,此时计算概率为P(O₁O₂|μ）：假设有三个状态（如下图）1、2、3，输出序列为O₁，有三种可能一是状态1发出，二是从状态2发出，三是从状态3发出。另外从状态1发出观察值O₂得概率为b₁(O₂),从状态2发出观察值O₂得概率为b₂(O₂),从状态3发出观察值O₂得概率为b₃(O₂)。

要是从状态1发出观察值O₂，可能从第一时刻的1、2或3状态装换过来，要是从状态1转换过来，概率为α₁(1)*a₁₁*b₁(O₂),要是从状态2转换过来，概率为α₁(2)*a₂₁*b₁(O₂),要是从状态3转换过来，概率为α₁(3)*a₃₁*b₁(O₂),因此

P(O₁O_₂,q₂₌s₁|μ）= α₁(1)*a₁₁*b₁(O₂) + α₁(2)*a₂₁*b₁(O₂) + α₁(3)*a₃₁*b₁(O₂)=α₂(1)

同理：P(O₁O_₂_,q₂₌s₁|μ）= α₁(1)*a₁₂*b₂(O₂) + α₁(2)*a₂₂*b₂(O₂) + α₁(3)*a₃₂*b₂(O₂)=α₂(2)

P(O₁O_₂_,q₂₌s₁|μ）= α₁(1)*a₁₃*b₁(O₂) + α₁(2)*a₂₃*b₃(O₂) + α₁(3)*a₃₃*b₃(O₂)=α₂(3)

所以：P(O₁O_₂|μ）=P(O₁O_₂,q₂₌s₁|μ）+ P(O₁O_₂_,q₂₌s₁|μ）+ P(O₁O_₂_,q₂₌s₁|μ）

=α₂(1) + α₂(2) + α₂(3)

以此类推。。。

前向算法

step1 初始化：α₁(i) = π_i*b_i(O₁), 1≤i≤N

step2 归纳计算:

step3 终结：

P(O|μ）=

时间复杂度

计算某时刻的某个状态的前向变量需要看前一时刻的N个状态，此时时间复杂度为O(N),每个时刻有N个状态，此时时间复杂度为N*O(N)=O(N²),又有T个时刻，所以时间复杂度为T*O(N²)=O(N²T)。

程序例证

前向算法计算P(O|M)：

step1：α₁(1) =π₁*b₁(red)=0.2*0.5=0.1 α₁(2)=π₂*b₂(red)==0.4*0.4= 0.16 α₁(3)=π₃*b₃(red)==0.4*0.7=0.21

step2：α₂(1)=α₁(1)*a₁₁*b₁(white) + α₁(2)*a₂₁*b₁(white) + α₁(3)*a₃₁*b₁(white)

...

step3:P(O|M) = α₃(1)+α₃(2)+α₃(3)

2. 后向算法(摘自http://www.cnblogs.com/kaituorensheng/archive/2012/12/03/2800489.html)

对于HMM的评估问题，利用动态规划可以用前向算法，从前到后算出前向变量；也可以采用后向算法，从后到前算出后向变量。

先介绍后向变量β_t(i):给定模型μ=（A,B,π），并且在时间 时刻t 状态为s_i的前提下，输出序列为O_t+1O_t+2...O_T的概率，即

β_t(i)=P(O_t+1O_t+2...O_T|q_t=s_i,μ)

归纳过程

假设仍然有3个状态

当t=T时，按照定义：时间t 状态q_T输出为O_T+1......的概率，从T+1开始的输出是不存在的（因为T时刻是终止终止状态），即T之后是空，是个必然事件，因此β_t(i)=1,1≤1≤N

当t=T-1时，

β_T-1(i)=P(O_T|q_T-1=s_i,μ) = a_i1*b₁（O_T)*β_T(1) + a_i2*b₂（O_T)*β_T(2) + a_i3*b₃（O_T)*β_T(3)

......

当t=1时，

β₁(1)=P(O₂O_3...O_T|q₂=s₁,μ) = a₁₁*b₁（O₂)*β₂(1) + a₁₂*b₂（O₂)*β₂(2) + a₁₃*b₃（O₂)*β₂(3)

β₁(2)=P(O₂O_3...O_T|q₂=s₁,μ) = a₂₁*b₁（O₂)*β₂(1) + a₂₂*b₂（O₂)*β₂(2) + a₂₃*b₃（O₂)*β₂(3)

β₁(3)=P(O₂O_3...O_T|q₂=s₁,μ) = a₃₁*b₁（O₂)*β₂(1) + a₃₂*b₂（O₂)*β₂(2) + a₃₃*b₃（O₂)*β₂(3)

P(O₁O₂...O_T|μ) =

后向算法

step1 初始化：β_T(i)=1, 1≤1≤N

step2 归纳计算：

1≤t≤T-1, 1≤i≤N

step3 求终结和：

P(O|μ）=

时间复杂度

计算某时刻在某个状态下的后向变量需要看后一时刻的N个状态，此时时间复杂度为O(N),每个时刻有N个状态，此时时间复杂度为N*O(N)=O(N²),又有T个时刻，所以时间复杂度为T*O(N²)=O(N²T)。

程序例证

后向算法

计算P(O|M)：

step1：β₄(1) = 1 β₄(2) = 1 β₄(3) = 1

step2：β₃(1) = β₄(1)*a₁₁*b₁(white) + β₄(2)*a₁₂*b₂(white) + β₄(3)*a₁₃*b₃(white)

...

step3:P(O|M) = π₁*β₁(1)*b₁(O₁) + π₂*β₁(2)*b₂(O₁) + π₃*β₁(3)*b₃(O₁)

3.前向-后向算法(摘自http://www.cnblogs.com/kaituorensheng/archive/2012/12/05/2803182.html)

重新回顾：

前向变量α_t(i):在时刻t,在已知模型μ=（A,B,π）的条件下，状态处于s_i,输出序列为O₁0₂...O_t,前向变量为α_t(i)

后向变量β_t(i):在时刻t,在已知模型μ=（A,B,π）和状态处于s_i的条件下，输出序列为O_t+1O_t+2...O_T,后向变量为β_t(i)

公式推导：

P(O,q_t=s_i|μ） = P(O₁O₂...O_T, q_t=s_i|μ）

=P(O₁O₂...O_t,q_t=si,O_t+1O_t+2...O_T|μ)

=P(O₁O₂...O_t,q_t=si|μ) * P(O_t+1O_t+2...O_T|O₁O₂...O_t,q_t=si,μ)

=P(O₁O₂...O_t,q_t=si|μ) * P(O_t+1O_t+2...O_T|q_t=si,μ)

=α_t(i) * β_t(i)

P(O|μ）=

案例分析：

分析：

P(q₄=s₃|O,M) = P(q₄=s₃, O|M)/P(O|M)

= P(O,q₄=s₃|M)/P(O|M)

= α₄(3) * β₄(3)/