隐马尔科夫模型HMM详解(2)——python实现

代码：6.1发布
HMM基本概念、概率计算、预测算法请看上一篇文章，感谢您的阅读！

学习算法

已知观测序列$O=\left(o_1,o_2,\dots ,o_T\right),b_j\left(o_t\right)={\sum }_{m=1}^M{c}_{jm}\mathcal{N}\left(o_t;{\mu }_{jm},{\Sigma }_{jm}\right)$，估计GMM-HMM参数$\lambda$，使$P(O|\lambda )$最大。参数$\lambda$包括：

• 初始状态概率向量$\pi =({\pi }_i)$

• 转移概率矩阵$A=[a_{ij}{]}_{N\times N}$

• 状态$j$的GMM参数$(c_{jm},{\mu }_{jm},{\Sigma }_{jm})$,$j=1,2,...,N;m=1,...,M$表示GMM分量标号。

Viterbi学习算法

如果已知状态-观测对齐序列，每个观测$o_t$对应一个具体的状态，状态-观测对齐序列可通过Viterbi解码算法得到，也可通过人工标注得到。知道每个观测对应的状态，则：

${\pi }_i$可通过最大似然估计得到：

• 令$C(i)$表示初始状态为 $i$ 的次数
• ${\pi }_i=\frac{C(i)}{{\sum }_{k}C(k)}$

$a_{ij}$也可通过最大似然估计得到：

• 令$C(i\to j)$表示从状态$i$到状态$j$的转移次数
• ${\hat{a}}_{ij}=\frac{C(i\to j)}{{\sum }_{k}C(i\to k)}$

可得每个状态$j$对应的观测集合$Z_j=\left(y_1,y_2,\dots ,y_N\right)$，每个状态对应一个GMM，也就得到了每个GMM对应的观测集合$Z_j=\left(y_1,y_2,\dots ,y_N\right)$。

问题：用viterbi算法得到对齐序列需要用到模型参数$\lambda$，最初的$\lambda$怎么得到？

当GMM只有一个分量，$b_j\left(o_t\right)=\mathcal{N}\left(o_t;{\mu }_j,{\Sigma }_j\right)$，$|Z_j|$表示$Z_j$的元素个数，则：

${\hat{\mu }}_j=\frac{{\sum }_{o_t\in Z_j}{o}_t}{|Z_j|}$
${\hat{\Sigma }}_j=\frac{{\sum }_{o_t\in Z_j}\left(o_t-{\hat{\mu }}_j\right){\left(o_t-{\hat{\mu }}_j\right)}^T}{|Z_j|}$

当GMM有多个分量，$b_j\left(o_t\right)={\sum }_{m=1}^M{c}_{jm}\mathcal{N}\left(o_t;{\mu }_{jm},{\Sigma }_{jm}\right)$，可以利用EM算法进行更新（参考上一篇文章）。

Viterbi学习算法

1. 初始化GMM-HMM参数$\lambda =({\pi }_i,a_{ij},GMM参数)$，其中每个状态$j$对应的GMM参数为$(c_{jm},{\mu }_{jm},{\Sigma }_{jm})$
2. 基于GMM-HMM参数$\lambda$和Viterbi算法得到状态-观测对齐，得到每个观测对应的隐藏状态
3. 更新参数$\lambda$
   • ${\hat{\pi }}_i=\frac{C(i)}{{\sum }_{k}C(k)},C(i)$ 表示初始状态为 $i$ 的次数
   • ${\hat{a}}_{ij}=\frac{C(i\to j)}{{\sum }_{k}C(i\to k)},C(i\to j)$ 表示从状态 $i$ 到状态 $j$ 的转移次数
   • 用上一篇文章将的EM算法更新GMM参数
4. 重复2，3步，直到收敛

Baum-Welch学习算法

首先看单分量GMM的情况

Viterbi学习算法是一种近似，只考虑了最优对齐路径。而每个时刻$t$每个状态$j$以一定的概率出现，而不是硬对齐（每个时刻只对应一个状态）。

状态占用概率：给定模型$\lambda$和观测$O$，在时刻$t$处于状态$q_i$的概率为${\gamma }_t(i)$:
$${\gamma }_t(i)=P\left(i_t=q_i\mid O,\lambda \right)=\frac{{\alpha }_t(i){\beta }_t(i)}{{\sum }_{i=1}^N{\alpha }_T(i)}$$
可以将这个概率用于EM算法，学习到参数$\lambda$:

• E步：估计状态占用概率
• M步：基于估计的状态占用概率，重新估计参数$\lambda$（最大化）

---

问题：证明${\gamma }_t(i)=P\left(i_t=q_i\mid O,\lambda \right)=\frac{{\alpha }_t(i){\beta }_t(i)}{{\sum }_{i=1}^N{\alpha }_T(i)}$成立。

证：省略$\lambda$，$o_1^t=o_1,o_2,...,o_t$，$O=o_1^T$
$$\begin{array}{rl}P\left(i_t=q_i,O\mid \lambda \right)& =P\left(i_t=q_i,o_1^t,o_{t+1}^T\right)\\ & =P\left(i_t=q_i,o_1^t\right)P\left(o_{t+1}^T\mid i_t=q_i,o_1^t\right)\\ & =P\left(i_t=q_i,o_1^t\right)P\left(o_{t+1}^T\mid i_t=q_i\right)\\ & ={\alpha }_t(i){\beta }_t(i)\\ P(O\mid \lambda )& =\sum _{j=1}^N{\alpha }_T(j)\\ P\left(i_t=q_i\mid O,\lambda \right)& =\frac{P\left(i_t=q_i,O\mid \lambda \right)}{P(O\mid \lambda )}=\frac{{\alpha }_t(i){\beta }_t(i)}{{\sum }_{j=1}^N{\alpha }_T(j)}\end{array}$$

---

对于某个状态，将所有时刻的状态占用概率相加，可认为是一个软次数，使用该软次数重新估计HMM参数：
$$\begin{array}{c}{\hat{\mu }}_j=\frac{{\sum }_{t=1}^T{\gamma }_t(j)o_t}{{\sum }_{t=1}^T{\gamma }_t(j)}\\ {\hat{\Sigma }}_j=\frac{{\sum }_{t=1}^T{\gamma }_t(j)\left(o_t-{\hat{\mu }}_j\right){\left(o_t-{\hat{\mu }}_j\right)}^T}{{\sum }_{t=1}^T{\gamma }_t(i)}\end{array}$$
对比Viterbi算法(硬次数)：
$$\begin{gathered} {\hat{\mu }}_j=\frac{{\sum }_{o_t\in Z_j}{o}_t}{\left|Z_j\right|} \\ {\hat{\Sigma }}_j=\frac{{\sum }_{o_t\in Z_j}\left(o_t-{\hat{\mu }}_j\right){\left(o_t-{\hat{\mu }}_j\right)}^T}{\left|Z_j\right|} \end{gathered}$$
当GMM有多个分量

当 $b_j\left(o_t\right)={\sum }_{m=1}^M{c}_{jm}\mathcal{N}\left(o_t;{\mu }_{jm},{\Sigma }_{jm}\right)$ 时，与前面类似，定义给定模型 $\lambda$ 和观测 $O$ ，在时刻 $t$ 处于状态 $q_j$ 且为GMM第 $k$ 个分量的概率为 ${\zeta }_t(j,k)$
$$\begin{array}{rl}{\zeta }_t(j,k)& =P\left(i_t=q_j,m_t=k\mid 0,\lambda \right)\\ & =\frac{P\left(i_t=q_j,m_t=k,0\mid \lambda \right)}{P(O\mid \lambda )}\\ & =\frac{{\sum }_i{\alpha }_{t-1}(i)a_{ij}{c}_{jk}{b}_{jk}\left(o_t\right){\beta }_t(j)}{{\sum }_{i=1}^N{\alpha }_T(i)}\end{array}$$
则有
$$\begin{array}{l}{\hat{\mu }}_{jk}=\frac{{\sum }_{t=1}^T{\zeta }_t(j,k)o_t}{{\sum }_{t=1}^T{\zeta }_t(j,k)}\\ {\hat{\Sigma }}_{jk}=\frac{{\sum }_{t=1}^T{\zeta }_t(j,k)\left(o_t-{\hat{\mu }}_{jk}\right){\left(o_t-{\hat{\mu }}_{jk}\right)}^T}{{\sum }_{t=1}^T{\zeta }_t(j,k)}\\ {\hat{c}}_{jk}=\frac{{\sum }_{t=1}^T{\zeta }_t(j,k)}{{\sum }_{t=1}^T{\sum }_k{\zeta }_t(j,k)}\end{array}$$
与状态占用概率类似，定义给定模型 $\lambda$ 和观测 $O$ ，在时刻 $t$ 处于状态 $q_i$ 且在时刻 $t+1$ 处于 状态 $q_j$ 的概率为 ${\xi }_t(\mathbf{i},\mathbf{j})$ :
$$\begin{array}{rl}{\xi }_t(i,j)& =P\left(i_t=q_i,i_{t+1}=q_j\mid 0,\lambda \right)\\ & =\frac{P\left(i_t=q_i,i_{t+1}=q_j,O\mid \lambda \right)}{P(O\mid \lambda )}\\ & =\frac{{\alpha }_t(i)a_{ij}{b}_j\left(o_{t+1}\right){\beta }_{t+1}(j)}{{\sum }_{i=1}^N{\alpha }_T(i)}\end{array}$$
且有 ${\gamma }_t(i)={\sum }_{k=1}^N{\xi }_t(i,k)$
由该概率可得转移概率和初始概率：
$$\begin{array}{rl}{\hat{a}}_{ij}& =\frac{{\sum }_{t=1}^{T-1}{\xi }_t(i,j)}{{\sum }_{t=1}^{T-1}{\sum }_{k=1}^N{\xi }_t(i,k)}=\frac{{\sum }_{t=1}^{T-1}{\xi }_t(i,j)}{{\sum }_{t=1}^{T-1}{\gamma }_t(i)}\\ {\hat{\pi }}_i& ={\gamma }_1(i)\end{array}$$
问题：证明${\xi }_t(i,j)=\frac{{\alpha }_t(i)a_{ij}{b}_j\left(o_{t+1}\right){\beta }_{t+1}(j)}{{\sum }_{i=1}^N{\alpha }_T(i)}$

---

证：由前向公式的递推证明可知 ${\alpha }_t(i)a_{ij}{b}_j\left(o_{t+1}\right)=P\left(i_t=q_i,i_{t+1}=q_j,o_1^{t+1}\mid \lambda \right)$
后向公式定义可知 ${\beta }_{t+1}(j)=P\left(o_{t+2}^T\mid i_{t+1}=q_j,\lambda \right)$
$\begin{array}{rl}P\left(i_t=q_i,i_{t+1}=q_j,0\mid \lambda \right)& =P\left(i_t=q_i,i_{t+1}=q_j,o_1^{t+1},o_{t+2}^T\mid \lambda \right)\\ & =P\left(i_t=q_i,i_{t+1}=q_j,o_1^{t+1}\mid o_{t+2}^T,\lambda \right)P\left(o_{t+2}^T\mid \lambda \right)\\ & =P\left(i_t=q_i,i_{t+1}=q_j,o_1^{t+1}\mid \lambda \right)P\left(o_{t+2}^T\mid i_{t+1}=q_j,\lambda \right)\\ & ={\alpha }_t(i)a_{ij}{b}_j\left(o_{t+1}\right){\beta }_{t+1}(j)\end{array}$

---

Baum-Welch学习算法总结

1. 初始化GMM-HMM参数 $\lambda =\left({\pi }_i,a_{ij},\left(c_{jm},{\mu }_{jm},{\Sigma }_{jm}\right)\right)$
2. E步：对所有时间 $t$ 、状态 $i$
   • 递推计算前向概率 ${\alpha }_t(i)$ 和后向概率 ${\beta }_t(i)$
   • 计算 ${\zeta }_t(j,k)=\frac{{\sum }_i{\alpha }_{t-1}(i)a_{ij}{c}_{jk}{b}_{jk}\left(o_t\right){\beta }_t(j)}{{\sum }_{i=1}^N{\alpha }_T(i)},{\xi }_t(i,j)=\frac{{\alpha }_t(i)a_{ij}{b}_j\left(o_{t+1}\right){\beta }_{t+1}(j)}{{\sum }_{i=1}^N{\alpha }_T(i)},{\gamma }_t(i)={\sum }_{k=1}^N{\xi }_t(i,k)$
3. M步： 更新参数

$$\begin{array}{rl}{\hat{\mu }}_{jk}& =\frac{{\sum }_{t=1}^T{\zeta }_t(j,k)o_t}{{\sum }_{t=1}^T{\zeta }_t(j,k)}\\ {\hat{\Sigma }}_{jk}& =\frac{{\sum }_{t=1}^T{\zeta }_t(j,k)\left(o_t-{\hat{\mu }}_{jk}\right){\left(o_t-{\hat{\mu }}_{jk}\right)}^T}{{\sum }_{t=1}^T{\zeta }_t(j,k)}\\ {\hat{c}}_{jk}& =\frac{{\sum }_{t=1}^T{\zeta }_t(j,k)}{{\sum }_{t=1}^T{\sum }_k{\zeta }_t(j,k)}\\ {\hat{a}}_{ij}& =\frac{{\sum }_{t=1}^{T-1}{\xi }_t(i,j)}{{\sum }_{t=1}^{T-1}{\sum }_{k=1}^N{\xi }_t(i,k)}=\frac{{\sum }_{t=1}^{T-1}{\xi }_t(i,j)}{{\sum }_{t=1}^{T-1}{\gamma }_t(i)}\\ {\hat{\pi }}_i& ={\gamma }_1(i)\end{array}$$
4. 重复2，3步，直到收敛

python实现

考虑盒子和球模型 $\lambda =(A,B,\pi )$, 状态集合 $Q=\{1,2,3\}$, 观测集合 $V=\{$ 红, 白 $\}$：
$A=\left[\begin{array}{lll}0.5& 0.2& 0.3\\ 0.3& 0.5& 0.2\\ 0.2& 0.3& 0.5\end{array}\right],\mathrm{B}=\left[\begin{array}{cc}0.5& 0.5\\ 0.4& 0.6\\ 0.7& 0.3\end{array}\right],\pi =(0.2,0.4,0.4{)}^T$
设 $T=3,O=($ 红，白, 红)

• 实现前向算法和后向算法，分别计算$P(O|\lambda )$
• 实现Viterbi算法，求最优状态序列(最优路径)

前向算法：

公式：
初值：

1. $\alpha_1(i) = \pi_ib_i(o_1)，i=1,2,…,N $

2. 递推：对$t=1,2,...,T-1$
   $${\alpha }_{t+1}(i)=\left[\sum _{j=1}^N{\alpha }_t(j)a_{ji}\right]b_i\left(o_{t+1}\right)$$

3. 终止：$P(O\mid \lambda )={\sum }_{i=1}^N{\alpha }_T(i)$

def forward_algorithm(O, HMM_model):
    """HMM Forward Algorithm.
    Args:
        O: (o1, o2, ..., oT), observations
        HMM_model: (pi, A, B), (init state prob, transition prob, emitting prob)
    Return:
        prob: the probability of HMM_model generating O.
    """
    pi, A, B = HMM_model
    T = len(O)
    N = len(pi)
    prob = 0.0
    
    alphas = np.zeros((N, T))
    for t in range(T):
        for i in range(N):
            if t == 0:
                alphas[i][t] = pi[i] * B[i][O[t]]
            else:
                alphas[i][t] = np.dot([alpha[t-1] for alpha in alphas], [a[i] for a in A]) * B[i][O[t]]
    prob = np.sum([alpha[T-1] for alpha in alphas])
    
    return prob

后向算法：

初值：${\beta }_T(i)=1,i=1,2,...,N$

2. 递推：对$t=T-1,T-2,...,1$
   $${\beta }_t(i)=\sum _{j=1}^N{a}_{ij}{b}_j\left(o_{t+1}\right){\beta }_{t+1}(j),i=1,2,\cdots ,N$$

3. 终止：$P(O\mid \lambda )={\sum }_{i=1}^N{\pi }_i{b}_i\left(o_1\right){\beta }_1(i)$

def backward_algorithm(O, HMM_model):
    """HMM Backward Algorithm.
    Args:
        O: (o1, o2, ..., oT), observations
        HMM_model: (pi, A, B), (init state prob, transition prob, emitting prob)
    Return:
        prob: the probability of HMM_model generating O.
    """
    pi, A, B = HMM_model
    T = len(O)
    N = len(pi)
    prob = 0.0
    betas = np.zeros((N, T))
    for i in range(N):
        betas[i][0] = 1
    for t in range(1, T):
        for i in range(N):
            for j in range(N):
                betas[i][t] += A[i][j]*B[j][O[T-t]]*betas[j][t-1]
    
    for i in range(N):
        prob += pi[i]*B[i][O[0]]*betas[i][-1]
    
    return prob

Viterbi算法：

公式：

$$\begin{array}{rl}{\delta }_{t+1}(i)& =\underset{i_1,i_2,\cdots ,i_t}{\max }P\left(i_{t+1}=i,i_t,\cdots ,i_1,o_{t+1},\cdots ,o_1\mid \lambda \right)\\ & =\underset{1⩽j⩽N}{\max }\left[{\delta }_t(j)a_{ji}\right]b_i\left(o_{t+1}\right),i=1,2,\cdots ,N;t=1,2,\cdots ,T-1\end{array}$$

$${\psi }_t(i)=\arg \underset{1⩽j⩽N}{\max }\left[{\delta }_{t-1}(j)a_{ji}\right],i=1,2,\cdots ,N$$

def Viterbi_algorithm(O, HMM_model):
    """Viterbi decoding.
    Args:
        O: (o1, o2, ..., oT), observations
        HMM_model: (pi, A, B), (init state prob, transition prob, emitting prob)
    Returns:
        best_prob: the probability of the best state sequence
        best_path: the best state sequence
    """
    pi, A, B = HMM_model
    T = len(O)
    N = len(pi)
    best_prob, best_path = 0.0, []
    # Begin Assignment
    deltas = np.zeros((N,T), dtype=np.float64)
    nodes = np.zeros((N,T), dtype=np.int)
    for i in range(N):
        deltas[0][i] = pi[i]*B[i][0]
    for t in range(1, T):
        tmp = [deltas[t-1][j] * A[j][i] for j in range(N)]
        nodes[t][i] = int(np.argmax(tmp))
        deltas[t][i] = tmp[nodes[t][i]] * B[i][O[t]]
    best_path = np.zeros((T), dtype=np.int)
    best_path[T-1] = np.argmax(deltas[T-1])
    for t in range(T-2, -1, -1):
        best_path[t] = nodes[t+1][best_path[t+1]]
    # 
    best_prob = deltas[best_path[1]][best_path[-1]]
    # transform the state as index in python start from '0'
    best_path = [(val+1) for val in best_path]
   
    return best_prob, best_path