定义
一个隐马尔科夫模型由2个随机过程 { x k , y k } \{x_k, y_k\} {xk,yk} 组成
- x k x_k xk 是不可观测到的有限状态 S = { S 1 , S 2 , . . . , S k } S = \{S_1, S_2, ..., S_k\} S={S1,S2,...,Sk} 集合(马式链)
- y k y_k yk 是可观测到的有限状态的集合(观测链)
组成
一个隐马尔科夫模型可以表现为下图:
由上图可知,一个隐马尔科夫模型由5个部分组成:
- 隐状态空间
S
S
S(状态空间)
S = { s 1 , s 2 , . . . , s n } S = \{s_1, s_2, ..., s_n\} S={s1,s2,...,sn},即所有隐藏状态的集合 - 观测空间
O
O
O
O = { o 1 , o 2 , . . . , o m } O = \{o_1, o_2, ..., o_m\} O={o1,o2,...,om},即所有观测状态的集合 - 初始状态概率空间
Π
\Pi
Π
Π = { π 1 , π 2 , . . . , π n } \Pi=\{\pi_1, \pi_2, ..., \pi_n\} Π={π1,π2,...,πn},个数和状态集合个数相同,代表了各个状态能在 t = 1 t = 1 t=1时刻出现的概率 - 隐状态转移概率矩阵
A
A
A
A = { a i , j ∣ 状 态 i 转 移 到 状 态 j 的 概 率 } A = \{a_{i, j}| 状态i转移到状态j的概率\} A={ai,j∣状态i转移到状态j的概率} - 观测值生成概率矩阵
B
B
B
B = { b i , j ∣ 状 态 i 生 成 观 测 j 的 概 率 } B = \{b_{i, j}|状态i生成观测j的概率\} B={bi,j∣状态i生成观测j的概率}
所以记一个HMM的参数
λ
\lambda
λ 为一个五元组
λ
=
{
S
,
O
,
Π
,
A
,
B
}
\lambda = \{S, O, \Pi, A, B\}
λ={S,O,Π,A,B}
通常记为
λ
=
{
Π
,
A
,
B
}
\lambda = \{\Pi, A, B\}
λ={Π,A,B}
本篇中,记
- N N N为状态集合元素个数
- M M M为观测集合元素个数
- T T T为序列中元素个数
- Q = { q 1 , q 2 , . . . , q N } Q = \{q_1, q_2, ..., q_N\} Q={q1,q2,...,qN} 为隐藏状态集合
- V = { v 1 , v 2 , . . . , v N } V = \{v_1, v_2, ..., v_N\} V={v1,v2,...,vN} 为显性观测集合
- I = { i 1 , i 2 , . . . , i T } I = \{i_1, i_2, ..., i_T\} I={i1,i2,...,iT} 为状态序列
- O = { o 1 , o 2 , . . . , o T } O = \{o_1, o_2, ..., o_T\} O={o1,o2,...,oT} 为观测序列
- Π = { π 1 , π 2 , . . . , π n } \Pi=\{\pi_1, \pi_2, ..., \pi_n\} Π={π1,π2,...,πn} 为初始状态概率
- A = { a i , j ∣ 状 态 i 转 移 到 状 态 j 的 概 率 } A = \{a_{i, j}| 状态i转移到状态j的概率\} A={ai,j∣状态i转移到状态j的概率} 为状态转移矩阵
- B = { b i , j ∣ 状 态 i 生 成 观 测 j 的 概 率 } B = \{b_{i, j}|状态i生成观测j的概率\} B={bi,j∣状态i生成观测j的概率} 为生成矩阵
面临的问题
对于隐马尔科夫模型来说,他有三类问题
- 评估问题 evaluation
给定模型参数 λ \lambda λ和观测序列 O O O,求解在该模型下,给定的观测序列出现的概率 P ( O ∣ λ ) P(O|\lambda) P(O∣λ)
使用前向算法/后向算法 - 解码问题 decoding
给定模型参数 λ \lambda λ和观测序列 O O O,求解在该模型下,可以生成该观测序列概率最大的隐藏状态序列 I I I
使用维特比算法 - 学习问题 learning
给定一串观测序列 O O O,求解能生成这个观测序列的模型参数 λ \lambda λ(参数训练)
使用Baum-Welch算法
评估问题
对于某一个观测值,都有 N N N种状态可以生成它,所以对于一串观测值 O = { o 1 , o 2 , . . . , o T } O=\{o_1, o_2, ..., o_T\} O={o1,o2,...,oT},产生的隐藏状态序列 I = { i 1 , i 2 , . . . , i T } I=\{i_1, i_2, ..., i_T\} I={i1,i2,...,iT}共有 N T N^T NT种可能性,所以枚举的话时间复杂度会过高
所以采用前向/后向算法降低计算量
前向算法
前向变量: α t ( i ) = P ( o 1 , o 2 , . . . , o t , i t = q i ∣ λ ) \alpha_t(i) = P(o_1, o_2, ..., o_t, i_t = q_i|\lambda) αt(i)=P(o1,o2,...,ot,it=qi∣λ),表示了到 t t t时刻为止,生成了部分给定的观测序列 { o 1 , o 2 , . . . , o t } \{o_1, o_2, ..., o_t\} {o1,o2,...,ot},且 t t t时刻处于状态 Q i Q_i Qi的概率
前向计算步骤:
- 初始化
α
1
(
i
)
,
i
∈
[
1
,
N
]
\alpha_1(i), i∈[1, N]
α1(i),i∈[1,N]
即 t = 1 t = 1 t=1时刻,生成了一个隐藏状态 q i q_i qi,且生成了观测点 o 1 o_1 o1的概率
α 1 ( i ) = π q i b q i o 1 \alpha_1(i) = \pi_{q_i}b_{qi o_1} α1(i)=πqibqio1 - 递推
α
t
(
i
)
,
t
∈
[
2
,
T
]
,
i
∈
[
1
,
N
]
\alpha_t(i), t∈[2, T], i∈[1, N]
αt(i),t∈[2,T],i∈[1,N]
对 t ∈ [ 2 , T ] t∈[2, T] t∈[2,T], i ∈ [ 1 , N ] i∈[1, N] i∈[1,N], α t ( i ) \alpha_t(i) αt(i) 表示到 t t t 时刻为止,生成了部分给定的观测序列 { o 1 , o 2 , . . . , o t } \{o_1, o_2, ..., o_t\} {o1,o2,...,ot},且 t t t 时刻处于 q i q_i qi 状态的概率
根据全概率公式,易知, α t ( i ) \alpha_t(i) αt(i) 可以通过所有的 α t − 1 ( i ) , i ∈ [ 1 , N ] \alpha_{t-1}(i), i∈[1, N] αt−1(i),i∈[1,N] 进行计算
α t ( i ) = ∑ j = 1 N α t − 1 ( j ) a Q j Q i b Q i o t \alpha_t(i) = \sum_{j=1}^{N}{\alpha_{t-1}(j)a_{Q_j Q_i}b_{Q_i o_t}} αt(i)=j=1∑Nαt−1(j)aQjQibQiot - 结束
对 t = T t = T t=T 时刻的所有状态 α T ( i ) , i ∈ [ 1 , N ] \alpha_T(i), i∈[1, N] αT(i),i∈[1,N] 进行求和操作,得到最后的概率
举例:
后向算法
后向变量: β 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}, ..., o_T| i_t = q_i, \lambda) βt(i)=P(ot+1,ot+2,...,oT∣it=qi,λ),表示了在 t t t时刻处于状态 q i q_i qi的情况下,生成了部分给定的观测序列 { o t + 1 , o t + 2 , . . . , o T } \{o_{t+1}, o_{t+2}, ..., o_T\} {ot+1,ot+2,...,oT}的概率
后向计算步骤:
- 初始化
β
T
(
i
)
,
i
∈
[
1
,
N
]
\beta_T(i), i∈[1, N]
βT(i),i∈[1,N]
当 t = T t = T t=T的时候,由于到此为止所有的观测序列已经生成,无论处于何种状态下一个时刻都结束了,所以
β T ( i ) = 1 , i ∈ [ 1 , N ] \beta_T(i) = 1, i∈[1, N] βT(i)=1,i∈[1,N] - 递推
β
t
(
i
)
,
t
∈
[
2
,
T
]
,
i
∈
[
1
,
N
]
\beta_t(i), t∈[2, T], i∈[1, N]
βt(i),t∈[2,T],i∈[1,N]
同样根据全概率公式, β t ( i ) = \beta_t(i) = βt(i)= t t t时刻所处的状态 q i q_i qi转换到 t + 1 t+1 t+1时刻 q j q_j qj的概率 × × × 改状态生成状态 o t + 1 o_{t+1} ot+1 的概率
β t ( i ) = ∑ j = 1 N a q i q j b q j o t + 1 β t + 1 ( j ) \beta_t(i) = \sum_{j = 1}^{N}{a_{q_i q_j}b_{q_j o_{t+1}}\beta_{t+1}(j)} βt(i)=j=1∑Naqiqjbqjot+1βt+1(j) - 结束
所有生成初始状态的可能性 × × ×初始状态生成 o 1 o_1 o1的可能性 × β 1 ( i ) ×\beta_1(i) ×β1(i)
∵ β 1 ( i ) \beta_1(i) β1(i) 是已知生成序列 { o 2 , o 3 , . . . , o T } \{o_2, o_3, ..., o_T\} {o2,o3,...,oT}
举例:
后向不太好理解,所以假设有两个骰子,一个是4面骰,一个是6面骰,骰子都是等重的,两者之间的转换为
设观测序列为
1
6
2
3
1 \ 6 \ 2 \ 3
1 6 2 3 则有
解码问题
有基础概念:如果概率最大的路径 P P P 经过某个点,那么这条路径上从起点到该点的路径一定是最短路径,否则,用更短的路径代替这条,总路径也会变短
总体思想和前向算法一样,只是把求和换成求 m a x max max,所以举一个例子即可
假设有
- 3个盒子(box1, box2, box3)【3个状态】
- 2个球(red、white)【2种观测值】
- 依次拿出3个球,表现为 O ( r e d , w h i t e , r e d ) O(red, white, red) O(red,white,red) 【观测序列】
求解最有可能的盒子拿取顺序
- 初始化
δ 0 ( 1 ) = π 1 × P ( r e d ∣ b o x 1 ) δ 0 ( 2 ) = π 2 × P ( r e d ∣ b o x 2 ) δ 0 ( 3 ) = π 3 × P ( r e d ∣ b o x 3 ) \delta_0(1) = \pi_1 \times P(red|box1) \\ \delta_0(2) =\pi_2 \times P(red|box2) \\ \delta_0(3) =\pi_3 \times P(red|box3) δ0(1)=π1×P(red∣box1)δ0(2)=π2×P(red∣box2)δ0(3)=π3×P(red∣box3) - 递推
δ 1 ( 1 ) = m a x { δ 0 ( 1 ) × P ( b o x 1 → b o x 1 ) , δ 0 ( 2 ) × P ( b o x 2 → b o x 1 ) , δ 0 ( 3 ) × P ( b o x 3 → b o x 1 ) } × P ( w h i t e ∣ b o x 1 ) δ 1 ( 2 ) = m a x { δ 0 ( 1 ) × P ( b o x 1 → b o x 2 ) , δ 0 ( 2 ) × P ( b o x 2 → b o x 2 ) , δ 0 ( 3 ) × P ( b o x 3 → b o x 2 ) } × P ( w h i t e ∣ b o x 1 ) δ 1 ( 3 ) = m a x { δ 0 ( 1 ) × P ( b o x 1 → b o x 3 ) , δ 0 ( 2 ) × P ( b o x 2 → b o x 3 ) , δ 0 ( 3 ) × P ( b o x 3 → b o x 3 ) } × P ( w h i t e ∣ b o x 1 ) \delta_1(1) =max\{\delta_0(1) \times P(box1 → box1), \delta_0(2) \times P(box2 → box1), \delta_0(3) \times P(box3 → box1)\} \times P(white|box1) \\ \delta_1(2) =max\{\delta_0(1) \times P(box1 → box2), \delta_0(2) \times P(box2 → box2), \delta_0(3) \times P(box3 → box2)\} \times P(white|box1) \\ \delta_1(3) =max\{\delta_0(1) \times P(box1 → box3), \delta_0(2) \times P(box2 → box3), \delta_0(3) \times P(box3 → box3)\} \times P(white|box1) \\ δ1(1)=max{δ0(1)×P(box1→box1),δ0(2)×P(box2→box1),δ0(3)×P(box3→box1)}×P(white∣box1)δ1(2)=max{δ0(1)×P(box1→box2),δ0(2)×P(box2→box2),δ0(3)×P(box3→box2)}×P(white∣box1)δ1(3)=max{δ0(1)×P(box1→box3),δ0(2)×P(box2→box3),δ0(3)×P(box3→box3)}×P(white∣box1)
…
依次递推即可
学习问题
已知观测序列
O
(
o
1
,
o
2
,
.
.
.
,
o
T
)
O(o_1, o_2, ..., o_T)
O(o1,o2,...,oT),估计模型参数
λ
=
(
A
,
B
,
Π
)
\lambda=(A, B, \Pi)
λ=(A,B,Π),使该模型下观测序列
P
(
O
∣
λ
)
P(O|\lambda)
P(O∣λ) 最大
首先明确几个有用的概率公式:
- 在
t
t
t 时刻为状态
q
i
q_i
qi 的概率
γ t ( i ) = α t ( i ) β t ( i ) ∑ i = 1 N α t ( i ) β t ( i ) \gamma_t(i) = \frac{\alpha_t(i)\beta_t(i)}{\sum_{i=1}^{N}{\alpha_t(i)\beta_t(i)}} γt(i)=∑i=1Nαt(i)βt(i)αt(i)βt(i)
分子是 t t t 时刻为状态 q i q_i qi, 分母是 t t t 时刻为所有状态 - 在
t
t
t 时刻为状态
q
i
q_i
qi,且
t
+
1
t +1
t+1 时刻为状态
q
j
q_j
qj 的概率
ξ t ( i , j ) = α t ( i ) a i , j b i , o t + 1 β t + 1 ( i ) ∑ i = 1 N ∑ j = 1 N α t ( i ) a i , j b j , o t + 1 β t + 1 ( i ) \xi_t(i, j) = \frac{\alpha_t(i)a_{i, j}b_{i, o_{t + 1}}\beta_{t+1}(i)}{\sum_{i=1}^{N}\sum_{j=1}^{N}{\alpha_t(i)a_{i, j}b_{j, o_{t+1}}\beta_{t+1}(i)}} ξt(i,j)=∑i=1N∑j=1Nαt(i)ai,jbj,ot+1βt+1(i)αt(i)ai,jbi,ot+1βt+1(i)
分子是 t t t 时刻为状态 q i q_i qi且 t + 1 t +1 t+1 时刻为状态 q j q_j qj , 分母是 t t t 时刻为所有状态且 t + 1 t +1 t+1 时刻为任意状态
那么转移概率矩阵A的递推公式通过常态来表述,就是
a
i
,
j
=
整
条
序
列
状
态
i
转
换
到
状
态
j
的
次
数
整
条
序
列
出
现
状
态
i
的
次
数
a_{i, j} = \frac{整条序列状态i转换到状态j的次数}{整条序列出现状态i的次数}
ai,j=整条序列出现状态i的次数整条序列状态i转换到状态j的次数
用期望/概率来代替次数,有
a
i
,
j
=
∑
t
=
1
T
−
1
ξ
t
(
i
,
j
)
∑
t
=
1
T
−
1
γ
t
(
i
)
a_{i, j} = \frac{\sum_{t=1}^{T-1}\xi_t(i, j)}{\sum_{t=1}^{T-1}\gamma_t(i)}
ai,j=∑t=1T−1γt(i)∑t=1T−1ξt(i,j)
生成矩阵B
b
i
,
j
=
整
条
序
列
出
现
状
态
i
且
生
成
的
观
测
值
为
j
的
次
数
整
条
序
列
出
现
状
态
i
的
次
数
b_{i, j} = \frac{整条序列出现状态i且生成的观测值为j的次数}{整条序列出现状态i的次数}
bi,j=整条序列出现状态i的次数整条序列出现状态i且生成的观测值为j的次数
用期望/概率来代替次数,有
b
i
(
k
)
=
∑
t
=
0
,
O
t
=
v
k
T
γ
t
(
i
)
∑
t
=
1
T
γ
t
(
i
)
b_i(k) = \frac{\sum_{t=0, O_t=v_k}^{T}{\gamma_t(i)}}{\sum_{t=1}^{T}{\gamma_t(i)}}
bi(k)=∑t=1Tγt(i)∑t=0,Ot=vkTγt(i)
初始概率矩阵
Π
\Pi
Π
Π
=
状
态
i
出
现
在
t
=
1
时
刻
的
概
率
\Pi = 状态i出现在t = 1时刻的概率
Π=状态i出现在t=1时刻的概率
Π
i
=
γ
1
(
i
)
\Pi_i = \gamma_1(i)
Πi=γ1(i)