机器学习之隐马尔科夫模型(HMM)原理及Python实现 (大章节)

HMM

隐马尔可夫模型（hidden Markov model, HMM）是可用于标注问题的统计学模型，是生成模型。

本章节内容参考李航博士的《统计学习方法》
本章节添加了一些结论性结果的推导过程。

1. 从一个自然语言处理的例子开始

例如有三个个句子：
句子一：我/名词 看见/动词 猫/名词
句子二：猫/名词 是/动词 可爱的/形容词
句子三：我/名词 是/动词 可爱的/形容词
一般只能观察到具体的词，所以像"我 看见 猫 …"是观测集合，而词性如"名词 动词 形容词 …"是状态序列

设$Q$是所有可能的状态集合，$V$是所有可能的观测集合：

$$Q=\{q_1,q_2,...,q_N\},V=\{v_1,v_2,...,v_M\}$$

其中， N是可能的状态数，M是可能的观测数。

例如：$Q=\{名词，动词，形容词\}，V=\{我，看见，猫，是，可爱的\}，N=3,M=5$

$I$是长度为$T$的状态序列，$O$是对应的观测序列：

$$I=\{i_1,i_2,...,i_T\},O=\{o_1,o_2,...,o_T\}$$

例如：$I=(名词，动词，名词)，O=(我，看见，猫)$

$A$是状态转移矩阵：

$$A=[a_{ij}{]}_{N\ast N}\text{\hspace{1em}(1)}$$

其中，

$$a_{ij}=p(i_{t+1}=q_j|i_t=q_i),i=1,2,...,N;j=1,2,...,N\text{\hspace{1em}(2)}$$

例如：

转态转移概率	名词	动词	形容词
名词	0	1	0
动词	1/3	0	2/3
形容词	1/3	1/3	1/3

$B$是观测概率矩阵，也就是发射矩阵：

$$B=[b_j(k){]}_{N\ast M}\text{\hspace{1em}(3)}$$

其中，

$$b_j(k)=p(o_t=v_k|i_t=q_j),k=1,2,...,M;j=1,2,...,N\text{\hspace{1em}(4)}$$

例如：

观测矩阵概率	我	看见	猫	是	可爱的
名词	1	0	1	0	0
动词	0	1	0	1	0
形容词	0	0	0	0	1

$\pi$是初始状态概率向量：

$$\pi =({\pi }_i)\text{\hspace{1em}(5)}$$

其中，

$${\pi }_i=p(i_1=q_i),i=1,2,...,N\text{\hspace{1em}(6)}$$

$A,B$和$\pi$是HMM的参数，用$\lambda$表示：

$$\lambda =(A,B,\pi )\text{\hspace{1em}(7)}$$

例如：

名词	动词	形容词
1	0	0

隐马尔可夫的三个基本问题
1.概率计算问题。给定模型$\lambda =(A,B,\pi )$和观测序列$O=(o_1,o_2,...,o_T)$,计算在已知模型参数的情况下，观测序列的概率，即$p(O|\lambda )$。
2.学习问题。已知观测序列$O=(o_1,o_2,...,o_T)$,估计模型参数$\lambda =(A,B,\pi )$，使$p(O|\lambda )$最大。
3.预测问题，也称解码问题。已知模型$\lambda =(A,B,\pi )$和$O=(o_1,o_2,...,o_T)$，求条件概率最大$p(I|O)$最大的状态序列$I=(i_1,i_2,...,i_T)$。

2. 概率预测问题

概率问题预测用直接计算法，计算复杂度高，可以采用动态规划形式的前向和后向算法降低计算复杂度。
为了表示方便，记：

$$(o_{1:t})=(o_1,o_2,...,o_n);(o_{t_{:}T})=(o_t,o_{t+1},...,o_T)$$

2.1 前向算法

接下来就是解前向概率$p(i_t,o_{1:t}|\lambda )$：

$$\begin{array}{rl}p(i_t,o_{1:t}|\lambda )& =\sum _{i_{t-1}}p(i_{t-1},i_t,o_{1:t-1},o_t|\lambda )\\ & =\sum _{i_{t-1}}p(o_t|i_{t-1},i_t,o_{1:t-1},\lambda )p(i_t|i_{t-1},o_{1:t-1},\lambda )p(i_{t-1},o_{1:t-1}|\lambda )\end{array}$$

由隐马尔科夫的条件独立性假设可得：

$$p(o_t|i_{t-1},i_t,o_{1:t-1},\lambda )=p(o_t|i_t,\lambda )$$

$$p(i_t|i_{t-1},o_{1:t-1},\lambda )=p(i_t|i_{t-1},\lambda )$$

故

$$p(i_t,o_{1:t}|\lambda )=\sum _{i_{t-1}}p(o_t|i_t,\lambda )p(i_t|i_{t-1},\lambda )p(i_{t-1},o_{1:t-1}|\lambda )=[\sum _{i_{t-1}}p(i_{t-1},o_{1:t-1}|\lambda )p(i_t|i_{t-1},\lambda )]p(o_t|i_t,\lambda )$$

设：

$${\alpha }_{t+1}(i)=p(o_{1:t+1},i_{t+1}=q_i|\lambda )\text{\hspace{1em}(8)}$$

且：

$$p(i_{t+1}=q_i|i_t=q_j,\lambda )]=a_{ji}$$

$$p(o_{t+1}|i_{t+1},\lambda )=b_i(o_{t+1})$$

则：

$${\alpha }_{t+1}(i)=[\sum _{j=1}^N{\alpha }_t(j)a_{ji}]b_i(o_{t+1})\text{\hspace{1em}(9)}$$

所以前向算法就可迭代进行。

前向算法：
1.初值

$${\alpha }_1(i)={\pi }_i{b}_i(o_1)$$

2.递推 $t=1,2,...,T-1$

$${\alpha }_{t+1}(i)=[\sum _{j=1}^N{\alpha }_t(j)a_{ji}]b_i(o_{t+1})$$

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

2.2 后向算法

后向算法解决后向概率$p(o_{t+1:T}|i_t,\lambda )$:

$$\begin{array}{rl}p(o_{t+1:T}|i_t,\lambda )& =\sum _{i_{t+1}}p(i_{t+1},o_{t+1},o_{t+2:T}|i_t,\lambda )\\ & =\sum _{i_{t+1}}p(o_{t+2:T}|i_{t+1},i_t,o_{t+1},\lambda )p(o_{t+1}|i_{t+1},i_t,\lambda )p(i_{t+1}|i_t,\lambda )\end{array}$$

由隐马尔科夫的条件独立假设得：

$$p(o_{t+2:T}|i_{t+1},i_t,o_{t+1},\lambda )=p(o_{t+2:T}|i_{t+1},\lambda )$$

$$p(o_{t+1}|i_{t+1},i_t,\lambda )=p(o_{t+1}|i_{t+1},\lambda )$$

设：

$${\beta }_t(i)=p(o_{t+1:T}|i_t=q_i,\lambda )\text{\hspace{1em}(10)}$$

又：

$$p(i_{t+1}=q_j|i_t=q_i,\lambda )=a_{ij}$$

$$p(o_{t+1}|i_{t+1}=q_j,\lambda )=b_j(o_{t+1})$$

则：

$${\beta }_t(i)=\sum _{j=1}^N{a}_{ij}{b}_j(o_{t+1}){\beta }_{t+1}(i)\text{\hspace{1em}(11)}$$

后向算法：
(1)

$${\beta }_T(i)=1$$

(2) 对t=T-1,T-2,…,1

$${\beta }_t(i)=\sum _{j=1}^N{a}_{ij}{b}_j(o_{t+1}){\beta }_{t+1}(i)$$

(3)

$$p(O|\lambda )=\sum _{i=1}^N{\pi }_i{b}_i(o_1){\beta }_1(i)$$

2.3 一些概率与期望值

这两个期望值都是后面EM算法用到的中间参量
1.计算$t$时刻处于状态$q_i$的概率。
概率计算问题是计算$p(O|\lambda )$，则有：

$$p(O|\lambda )=\sum _{i_t}p(O,i_t|\lambda )$$

依据隐马尔科夫的独立性假设：

$$p(o_{t+1:T}|i_t,o_{1:t},\lambda )=p(o_{t+1:T}|i_t,\lambda )$$

所以：

$$\begin{array}{rl}p(O|\lambda )& =\sum _{i_t}p(O,i_t|\lambda )\\ & =\sum _{i_t}p(o_{t+1:T}|i_t,o_{1:t},\lambda )p(i_t,o_{1:t}|\lambda )\\ & =\sum _{i_t}p(o_{t+1:T}|i_t,\lambda )p(i_t,o_{1:t}|\lambda )\end{array}$$

又有：

$${\alpha }_t(i)=p(o_{1:t},i_t=q_i|\lambda )\text{\hspace{1em}(12)}$$

$${\beta }_t(i)=p(o_{t+1:T}|i_t=q_i,\lambda )\text{\hspace{1em}(13)}$$

故：

$$p(O,i_t=q_i|\lambda )=p(o_{t+1:T}|i_t=q_i,\lambda )p(i_t=q_i,o_{1:t}|\lambda )={\alpha }_t(i){\beta }_t(i)$$

$$p(O|\lambda )=\sum _{i_t}{\alpha }_t(i){\beta }_t(i)$$

设：

$${\gamma }_t(i)=p(i_t=q_i|O,\lambda )$$

于是可以得到：

$${\gamma }_t(i)=p(i_t=q_i|O,\lambda )=\frac{p(i_t=q_i,O|\lambda )}{p(O|\lambda )}=\frac{{\alpha }_t(i){\beta }_t(i)}{{\sum }_{j=1}^N{\alpha }_t(j){\beta }_t(j)}\text{\hspace{1em}(14)}$$

2.计算计算$t$时刻处于状态$q_i$且计算$t+1$时刻处于状态$q_j$的概率

$$\begin{array}{rl}p(O|\lambda )& =\sum _{i_t}\sum _{i_{t+1}}p(O,i_t,i_{t+1}|\lambda )\\ & =\sum _{i_t}\sum _{i_{t+1}}p(o_{1:t},o_{t+1},o_{t+2:T},i_t,i_{t+1}|\lambda )\\ & =\sum _{i_t}\sum _{i_{t+1}}p(o_{t+2:T}|o_{1:t},o_{t+1},i_t,i_{t+1},\lambda )p(o_{t+1}|o_{1:t},i_t,i_{t+1},\lambda )p(i_{t+1}|i_t,o_{1:t},\lambda )p(i_t,o_{1:t}|\lambda )\end{array}$$

由隐马尔科夫的独立性假设可得：

$$p(O|\lambda )=\sum _{i_t}\sum _{i_{t+1}}p(o_{t+2:T}|i_{t+1},\lambda )p(o_{t+1}|i_{t+1},\lambda )p(i_{t+1}|i_t,\lambda )p(i_t,o_{1:t}|\lambda )$$

设：

$${\xi }_t(i,j)=p(i_t=q_i,i_{t+1}=q_j|O,\lambda )$$

又有公式(2)(4)(12)(13)

得：

$${\xi }_t(i,j)=\frac{p(i_t=q_i,i_{t+1}=q_j|O,\lambda )}{p(O|\lambda )}=\frac{{\alpha }_t(i)a_{ij}{b}_j(o_{t+1}){\beta }_{t+1}(j)}{{\sum }_{i=1}^N{\sum }_{j=1}^N{\alpha }_t(i)a_{ij}{b}_j(o_{t+1}){\beta }_{t+1}(j)}\text{\hspace{1em}(15)}$$

3. 学习问题

3.1 监督学习

如果有标记好状态序列的样本，那就太好办了，直接将接个矩阵统计的各个维度定义后进行统计就可以了。统计过程中注意概率之和为一的约束。

3.2 无监督学习

如果没有标记状态序列的样本，可以用Baum-Welch算法(EM算法)实现。

已知：包含$S$个长度为$T$的观测序列的观测序列$\{O_1,O_2,...,O_S\}$
目标：学习隐马尔可夫模型的参数$\lambda =(A,B,\pi )$

记观测数据$O$,隐数据$I$，那么隐马尔可夫模型可以表示为：

$$p(O|\lambda )=\sum _{I}p(O|I,\lambda )p(I|\lambda )$$

E步：

因为对$\lambda$而言，$1/p(O|\overline{\lambda })$是常数项，所以

$$\begin{array}{rl}Q(\lambda ,\overline{\lambda })& =E_I[\log p(O,I|\lambda )|O,\overline{\lambda }]\\ & =\sum _I\log p(O,I|\lambda )p(I|O,\overline{\lambda })\\ & =\sum _I\log p(O,I|\lambda )\frac{p(I,O|\overline{\lambda })}{p(O|\overline{\lambda })}\\ & =\sum _I\log p(O,I|\lambda )p(I,O|\overline{\lambda })\end{array}$$

将概率计算问题2.1小姐中前向算法的递归公式展开就可以得到：

$$p(O,I|\lambda )={\pi }_{i_1}{b}_{i_1}(o_1)a_{i_1{i}_2}{b}_{i_2}(o_2)...a_{i_{T-1}{i}_T}{b}_{iT}(o_T)={\pi }_{i_1}[\prod _{t=1}^{T-1}{a}_{i_t{i}_{t+1}}][\prod _{t=1}^T{b}_{it}(o_t)]$$

于是：

$$Q(\lambda ,\overline{\lambda })=\sum _I\log {\pi }_{i_1}p(O,I|\overline{\lambda })+\sum _I(\sum _{t=1}^{T-1}{a}_{i_t{i}_{t+1}})p(O,I|\overline{\lambda })+\sum _I(\sum _{t=1}^T{b}_{it}(o_t))p(O,I|\overline{\lambda })\text{\hspace{1em}(16)}$$

特此说明隐变量
隐马尔可夫模型的隐变量就是观测序列对应的状态序列，所以隐变量可以用（14）式的变量表示
后面在M步中更新模型参数的时候也用到了（15）式，是不是就说明隐变量是两个，其实不是的，这儿只是为了表示的方便和算法的方便。
也就是在E步中，用$\gamma$和$\xi$表示隐变量，只是为了编程和表示的便利，这两个变量在E步中信息是重复的。

M步：

1.求解${\pi }_i$
由(15)式可得：

$$L({\pi }_{i_1})=\sum _I\log {\pi }_{i_1}p(O,I|\overline{\lambda })=\sum _i^N\log {\pi }_{i_1}p(O,i_1=i|\overline{\lambda })$$

又因为${\pi }_i$满足约束条件${\sum }_{i=1}^N{\pi }_{i_1}=1$，利用拉格朗日乘子法，写出拉格朗日函数：

$$\sum _{i=1}^N\log {\pi }_{i}p(O,i_1=i|\overline{\lambda })+\gamma (\sum _{i=1}^N{\pi }_i-1)$$

对其求偏导并且令其结果为0得：

$$\frac{\partial }{\partial {\pi }_i}[\sum _{i=1}^N\log {\pi }_{i}p(O,i=i|\overline{\lambda })+\gamma (\sum _{i_1=1}^N{\pi }_i-1)]=0\text{\hspace{1em}(17)}$$

得：

$$p(O,i_1=i|\overline{\lambda })+\gamma {\pi }_i=0$$

得到：

$${\pi }_i=\frac{p(O,i_1=i|\overline{\lambda })}{-\lambda }$$

带入${\sum }_{i=1}^N{\pi }_{i_1}=1$的：

$$-\lambda =\sum _{i=1}^{N}p(O,i_1=i|\overline{\lambda })=p(o|\overline{\lambda })$$

求得并有公式(14)：

$${\pi }_i=\frac{p(O,i_1=i|\overline{\lambda })}{p(o|\overline{\lambda })}={\gamma }_1(i)\text{\hspace{1em}(18)}$$

2.求解$a_{ij}$:

$$\begin{gathered} L(a_{ij})=\sum _I(\sum _{t=1}^{T-1}{a}_{i_t{i}_{t+1}})p(O,I|\overline{\lambda })=\sum _{i=1}^N(\sum _{t=1}^{T-1}{a}_{i_t{i}_{t+1}})(\sum _{j=1}^{N}p(O,i_t=i,i_{t+1}=j|\overline{\lambda })) \\ =\sum _{i=1}^N\sum _{j=1}^N\sum _{t=1}^{T-1}{a}_{ij}p(O,i_t=i,i_{t+1}=j|\overline{\lambda }) \end{gathered}$$

应用约束条件${\sum }_{j=1}^N{a}_{ij}=1$,用拉格朗日乘子法可以求出：

$$\sum _{i=1}^N\sum _{j=1}^N\sum _{t=1}^{T-1}{a}_{ij}p(O,i_t=i,i_{t+1}=j|\overline{\lambda })+\lambda (\sum _{j=1}^N{a}_{ij}-1)$$

对上式求骗到并等于0得到：

$$\frac{\partial }{\partial a_{ij}}[\sum _{i=1}^N\sum _{j=1}^N\sum _{t=1}^{T-1}{a}_{ij}p(O,i_t=i,i_{t+1}=j|\overline{\lambda })+\lambda (\sum _{j=1}^N{a}_{ij}-1)]=0$$

得到：

$$\sum _{t=1}^{T-1}p(O,i_t=i,i_{t+1}=j|\overline{\lambda })+\lambda a_{ij}=0$$

所以：

$$a_{ij}=\frac{{\sum }_{t=1}^{T-1}p(O,i_t=i,i_{t+1}=j|\overline{\lambda })}{-\lambda }$$

将上式带入${\sum }_{j=1}^N{a}_{ij}=1$：

$$-\lambda =\sum _{j=1}^N\sum _{t=1}^{T-1}p(O,i_t=i,i_{t+1}=j|\overline{\lambda })=\sum _{t=1}^{T-1}p(O,i_t=i|\overline{\lambda })$$

故得：

$$a_{ij}=\frac{{\sum }_{t=1}^{T-1}p(O,i_t=i,i_{t+1}=j|\overline{\lambda })}{{\sum }_{t=1}^{T-1}p(O,i_t=i|\overline{\lambda })}=\frac{{\sum }_{t=1}^{T-1}p(O,i_t=i,i_{t+1}=j|\overline{\lambda })/p(o|\overline{\lambda })}{{\sum }_{t=1}^{T-1}p(O,i_t=i|\overline{\lambda })/p(o|\overline{\lambda })}$$

将（14）和（15）带入的：

$$a_{ij}=\frac{{\sum }_{t=1}^{T-1}{\xi }_t(i,j)}{{\sum }_{t=1}^{T-1}{\gamma }_t(i)}\text{\hspace{1em}(19)}$$

3.求解$b_{j}k$:

$$L(b_{j}k)=\sum _I(\sum _{t=1}^T{b}_{it}(o_t))p(O,I|\overline{\lambda })=\sum _{j=1}^N\sum _{t=1}^T{b}_j(o_t)p(O,i_t=j|\overline{\lambda })$$

在约束条件${\sum }_{k=1}^M{b}_j(k)=1$的拉格朗日乘子法：

$$\sum _{j=1}^N\sum _{t=1}^T{b}_j(o_t)p(O,i_t=j|\overline{\lambda })+\lambda (\sum _{k=1}^M{b}_j(k)-1)$$

对其求偏导得：

$$\frac{\partial }{\partial b_j(k)}[\sum _{j=1}^N\sum _{t=1}^T{b}_j(o_t)p(O,i_t=j|\overline{\lambda })+\lambda (\sum _{k=1}^M{b}_j(k)-1)]=0$$

因为只有在$o_t=v_k$时偏导才不会等于0，以$I(o_t=v_k)$表示，则：

$$\sum _{t=1}^{T}p(O,i_t=j|\overline{\lambda })I(o_t=v_k)+\lambda b_j(o_t)I(o_t=v_k)=0$$

$b_j(o_t)I(o_t=v_k)$可以写作$b_j(k)$，故：

$$b_j(k)=\frac{{\sum }_{t=1}^{T}p(O,i_t=j|\overline{\lambda })I(o_t=v_k)}{-\lambda }$$

将上式带入${\sum }_{k=1}^M{b}_j(k)=1$得：

$$-\lambda =\sum _{k=1}^M\sum _{t=1}^{T}p(O,i_t=j|\overline{\lambda })I(o_t=v_k)=\sum _{t=1}^{T}p(O,i_t=j|\overline{\lambda })$$

得到：

$$b_j(k)=\frac{{\sum }_{t=1}^{T}p(O,i_t=j|\overline{\lambda })I(o_t=v_k)}{{\sum }_{t=1}^{T}p(O,i_t=j|\overline{\lambda })}$$

又有（14）式可得：

$$b_j(k)=\frac{{\sum }_{t=1,o_t=v_k}^T{\gamma }_t(j)}{{\sum }_{t=1}^T{\gamma }_t(j)}\text{\hspace{1em}(20)}$$

EM算法总结：
E步：

$${\gamma }_t(i)=p(i_t=q_i|O,\lambda )=\frac{p(i_t=q_i,O|\lambda )}{p(O|\lambda )}=\frac{{\alpha }_t(i){\beta }_t(i)}{{\sum }_{j=1}^N{\alpha }_t(j){\beta }_t(j)}$$

$${\xi }_t(i,j)=\frac{p(i_t=q_i,i_{t+1}=q_j|O,\lambda )}{p(O|\lambda )}=\frac{{\alpha }_t(i)a_{ij}{b}_j(o_{t+1}){\beta }_{t+1}(j)}{{\sum }_{i=1}^N{\sum }_{j=1}^N{\alpha }_t(i)a_{ij}{b}_j(o_{t+1}){\beta }_{t+1}(j)}$$

M步：
$${\pi }_i=\frac{p(O,i_1=i|\overline{\lambda })}{p(o|\overline{\lambda })}={\gamma }_1(i)$$

$$a_{ij}=\frac{{\sum }_{t=1}^{T-1}{\xi }_t(i,j)}{{\sum }_{t=1}^{T-1}{\gamma }_t(i)}$$

$$b_j(k)=\frac{{\sum }_{t=1,o_t=v_k}^T{\gamma }_t(j)}{{\sum }_{t=1}^T{\gamma }_t(j)}$$

4. 预测问题（解码问题）

用维特比算法进行求解：
已知：模型$\lambda =(A,B,\pi )$和$O=(o_1,o_2,...,o_T)$
求：条件概率最大$p(I|O,\lambda )$最大的状态序列$I=(i_1,i_2,...,i_T)$
因为$p(O)$是一个定值，所以：

$$\underset{I}{\max }p(I|O,\lambda )=\underset{I}{\max }p(I,O|\lambda )/p(O|\lambda )=\underset{I}{\max }p(I,O|\lambda )$$

定义在时刻$t$状态为$i$的所有单个路径$(i_1,i_2,...,i_t)$中概率最大值为：

$${\delta }_t(i)=\underset{i_1,i_2,...,i_{t-1}}{\max }p(i_t=i,i_{t-1:i_1},o_{t:1}|\lambda )$$

递推推导：

$$\begin{array}{rl}& p(i_{t+1}=i,i_{t:1},o_{t+1:1}|\lambda )\\ & =p(i_{t+1}=i,i_t,i_{t-1:1},o_{t+1},o_{t:1}|\lambda )\\ & =p(o_{t+1}|i_{t+1}=i,i_t,o_{t:1},\lambda )p(i_{t+1}=i|i_t,i_{t-1:1},o_{t:1},\lambda )p(i_t,i_{t-1:1},o_{t:1}|\lambda )\\ & =p(o_{t+1}|i_{t+1}=i,\lambda )p(i_{t+1}=i|i_t,\lambda )p(i_t,i_{t-1:1},o_{t:1}|\lambda )\end{array}$$

故：

$${\delta }_{t+1}(i)=\underset{i_1,i_2,...,i_{t-1}}{\max }p(i_{t+1}=i,i_{t:1},o_{t+1:1}|\lambda )=\underset{1\le j\le N}{\max }[{\delta }_t(j)a_{ji}]b_i(o_{t+1})\text{\hspace{1em}(21)}$$

定义在时刻$t$状态为$i$的所有单个路径$(i_1,i_2,...,i_{t-1})$中概率最大的第$t-1$个节点为：

$${\psi }_t(i)=\arg \underset{1\le j\le N}{\max }[{\delta }_{t-1}(j)a_{ji}]\text{\hspace{1em}(22)}$$

5. python实现模型

5.1 参数对应关系

下面说一下上面公式中出现的参数和下面模型之中的名称的对应关系(公式中的符号将会和代码一致):

:param N: $N$ 表示状态数
:param M: $M$ 表示观测数
:param V: $V$ 表示观测集合，维度$(M,)$
:param A: $A$ 对应于状态转移矩阵，维度$(N,N)$
:param B: $B$对应于观测概率矩阵（发射矩阵)，维度$(N,M)$
:param pi: $\pi$ 对应于初始状态向量，维度$(N,)$
:param S: $S$ 表示输入句子数量
:param T: $T$ 表示每个句子的个数
:param gamma: $\gamma$ 隐变量，表示状态的概率矩阵，维度$(S,N,T)$
:param xi: $\xi$ 隐变量，表示状态的概率矩阵，维度$(S,N,N,T)$
:param alpha: $\alpha$ 前向算法结果，维度$(N,T)$
:param beta: $\beta$ 后向算法结果,维度$(N,T)$
:param delta: $\delta$ 维特比算法中存储概率最大值，维度$(N,T)$
:param psi: $\psi$ 维特比算法中存储概率最大值索引，维度$(N,T)$
:param I: $I$ 输出的状态向量，维度$(T,)$

小技巧：为了避免连续乘积带来内存溢出，一般先用对数进行计算，最后再用指数运算还原。
logsumexp() # http://bayesjumping.net/log-sum-exp-trick/
$$\log \sum _i\exp (x_i)=b+\log \sum _i\exp (x_i-b)$$

def logSumExp(ns):
    max = np.max(ns)
    ds = ns - max
    sumOfExp = np.exp(ds).sum()
    return max + np.log(sumOfExp)

5.2 python实现HMM

import numpy as np


class MyHMM(object):
    def __init__(self, N=None, A=None, B=None, pi=None):
        """
        HMM模型：
        >隐马尔可夫的三个基本问题
        >1.概率计算问题。给定模型$\lambda=(A,B,\pi)$和观测序列$O=(o_1,o_2,...,o_T)$,计算在已知模型参数的情况下，观测序列的概率，
            即$p(O|\lambda)$。用前向算法或后向算法。
        >2.学习问题。已知观测序列$O=(o_1,o_2,...,o_T)$,估计模型参数$\lambda=(A,B,\pi)$，使$p(O|\lambda)$最大。用BW算法。
        >3.预测问题，也称解码问题。已知模型$\lambda=(A,B,\pi)$和$O=(o_1,o_2,...,o_T)$，求条件概率最大$p(I|O)$最大的状态序列
            $I=(i_1,i_2,...,i_T)$。用维特比算法解码。

        :param N: $N$ 表示状态数
        :param M: $M$ 表示观测数
        :param V: $V$ 表示观测集合，维度$(M,)$
        :param A: $A$ 对应于状态转移矩阵，维度$(N, N)$
        :param B: $B$对应于观测概率矩阵（发射矩阵)，维度$(N, M)$
        :param pi: $pi$ 对应于初始状态向量，维度$(N,)$
        :param S: $S$ 表示输入句子数量
        :param T: $T$ 表示每个句子的个数
        :param gamma: $gamma$ 隐变量，表示状态的概率矩阵，维度$(S,N,T)$
        :param xi: $xi$ 隐变量，表示状态的概率矩阵，维度$(S,N,N,T)$
        :param alpha: $alpha$ 前向算法结果，维度$(N,T)$
        :param beta: $beta$ 后向算法结果,维度$(N,T)$
        :param delta: $delta$ 维特比算法中存储概率最大值，维度$(N,T)$
        :param psi: $psi$ 维特比算法中存储概率最大值索引，维度$(N,T)$
        :param I: $I$ 输出的状态向量，维度$(T,)$
        """
        self.N = N  # 状态数
        self.params = {
            'A': A,
            'B': B,
            'pi': pi,
            'gamma': None,
            'xi': None
        }

        self.M = None  # 观测数

        self.S = None  # 句子个数
        self.T = None  # 每个句子的长度

        self.V = None  # 观测集合

        self.eps = np.finfo(float).eps

        np.random.seed(2)

    def _init_params(self):
        """
        初始化模型参数
        :return:
        """
        def generate_random_n_data(N):
            ret = np.random.rand(N)
            return ret / np.sum(ret)

        pi = generate_random_n_data(self.N)
        A = np.array([generate_random_n_data(self.N) for _ in range(self.N)])
        B = np.array([generate_random_n_data(self.M) for _ in range(self.N)])

        gamma = np.zeros((self.S, self.N, self.T))
        xi = np.zeros((self.S, self.N, self.N, self.T))

        self.params = {
            'A': A,
            'B': B,
            'pi': pi,
            'gamma': gamma,
            'xi': xi
        }

    def logSumExp(self, ns, axis=None):
        max = np.max(ns)
        ds = ns - max
        sumOfExp = np.exp(ds).sum(axis=axis)
        return max + np.log(sumOfExp)

    def _forward(self, O_s):
        """
        前向算法，公式参考博客公式(9)
        :param O_s: 单个序列，维度(N,)
        :return:
        """
        A = self.params['A']
        B = self.params['B']
        pi = self.params['pi']
        T = len(O_s)

        log_alpha = np.zeros((self.N, T))

        for i in range(self.N):
            log_alpha[i, 0] = np.log(pi[i] + self.eps) + np.log(B[i, O_s[0]])

        for t in range(1, T):
            for i in range(self.N):
                log_alpha[i, t] = self.logSumExp(np.array([log_alpha[_i, t-1] +
                                                           np.log(A[_i, i] + self.eps) +
                                                           np.log(B[i, O_s[t]])
                                                           for _i in range(self.N)]))
        return log_alpha

    def _backward(self, O_s):
        """
        后向算法，参考博客公式(11)
        :param O_s: 单个序列，维度(N,)
        :return:
        """
        A = self.params['A']
        B = self.params['B']
        pi = self.params['pi']
        T = len(O_s)

        log_beta = np.zeros((self.N, T))

        for i in range(self.N):
            log_beta[i, T-1] = 0

        for t in range(T-2, -1, -1):
            for i in range(self.N):
                log_beta[i, t] = self.logSumExp(np.array([
                    log_beta[_i, t+1] + np.log(A[i, _i] + self.eps) + np.log(B[_i, O_s[t+1]] + self.eps)
                for _i in range(self.N)]))
        return log_beta

    def _E_step(self, O):
        """
        BW算法的E_step
        计算隐变量，参考博客公式(9)(11)
        :param O:
        :return:
        """
        A = self.params['A']
        B = self.params['B']
        pi = self.params['pi']
        # 对S个句子依次执行
        for s in range(self.S):
            O_s = O[s]
            log_alpha = self._forward(O_s)
            log_beta = self._backward(O_s)

            # 前向算法得到的最大似然
            log_likelihood = self.logSumExp(log_alpha[:, self.T -1])  # log p(O|lambda)
            # # 后向算法得到的最大似然 （两个结果应该是相等的）
            # log_likelihood = self.logSumExp(np.array([np.log(pi[_i] + self.eps) + np.log(B[_i, 0] + self.eps) + log_beta[_i, 0] for _i in range(self.N)]))

            for i in range(self.N):
                self.params['gamma'][s, i, self.T-1] = log_alpha[i, self.T-1] + log_beta[i, self.T-1] - log_likelihood

            for t in range(self.T - 1):
                for i in range(self.N):
                    self.params['gamma'][s, i, t] = log_alpha[i, t] + log_beta[i, t] - log_likelihood
                    for j in range(self.N):
                        self.params['xi'][s, i, j, t] = log_alpha[i, t] + np.log(A[i, j] + self.eps) + np.log(B[j, O_s[t + 1]] + self.eps) + log_beta[j, t+1] - log_likelihood

    def _M_step(self, O):
        """
        BW算法的M_step。参考博客公式(18)(19)(20)
        :param O:
        :return:
        """
        gamma = self.params['gamma']
        xi = self.params['xi']

        count_gamma = np.zeros((self.S, self.N, self.M))
        count_xi = np.zeros((self.S, self.N, self.N))

        for s in range(self.S):
            O_s = O[s, :]
            for i in range(self.N):
                for k in range(self.M):
                    if not (O_s == k).any():

                        count_gamma[s, i, k] = np.log(self.eps)
                    else:
                        count_gamma[s, i, k] = self.logSumExp(gamma[s, i, O_s == k])

                for j in range(self.N):
                    count_xi[s, i, j] = self.logSumExp(xi[s, i, j, :])

        self.params['pi'] = np.exp(self.logSumExp(gamma[:, :, 0], axis=0) - np.log(self.S + self.eps))
        np.testing.assert_almost_equal(self.params['pi'].sum(), 1)

        for i in range(self.N):
            for k in range(self.M):
                self.params['B'][i, k] = np.exp(self.logSumExp(count_gamma[:, i, k]) - self.logSumExp(
                    count_gamma[:, i, :]
                ))

            for j in range(self.N):
                self.params['A'][i, j] = np.exp(self.logSumExp(count_xi[:, i, j]) - self.logSumExp(
                    count_xi[:, i, :]
                ))

            np.testing.assert_almost_equal(self.params['A'][i, :].sum(), 1)
            np.testing.assert_almost_equal(self.params['B'][i, :].sum(), 1)

    def fit(self, O, V=(0,1,2,3,4), max_iter=20):
        O = np.array(O)
        self.S, self.T = O.shape
        self.M = len(V)
        self.V = V
        print(self.S, self.T)

        self._init_params()

        for i in range(max_iter):
            self._E_step(O)
            self._M_step(O)

    def decode(self, O_s):
        """
        用维特比算法解码。参考公式(21)(22)
        :param O_s:
        :return:
        """
        O_s = np.array(O_s)
        if len(O_s.shape) != 1:
            raise ('只容许一个序列进行解码.')

        T = len(O_s)

        delta = np.zeros((self.N, self.T))
        psi = np.zeros((self.N, self.T))

        for i in range(self.N):
            psi[i, 0] = 0
            delta[i, 0] = np.log(self.params['pi'][i] + self.eps) + np.log(self.params['B'][i, O_s[0]])

        for t in range(1, T):
            for i in range(self.N):
                seq_prob = [delta[j, t-1] + np.log(self.params['A'][j, i] + self.eps) + np.log(self.params['B'][i, O_s[t]]) for j in range(self.N)]
                delta[i, t] = np.max(seq_prob)
                psi[i, t] = np.argmax(seq_prob)

        pointer = np.argmax(delta[:, -1])
        I = [pointer]
        for t in reversed(range(1, T)):
            pointer = int(psi[int(pointer), t])
            I.append(pointer)

        I.reverse()
        return I

5.3 模型测试

def generate_data():
    O = [['我', '看见', '猫'],
         ['猫', '是', '可爱的'],
         ['我', '是', '可爱的']]
    word2index = {}
    index2word = {}
    for sentence in O:
        for word in sentence:
            if word not in word2index.keys():
                word2index[word] = len(word2index)
                index2word[len(index2word)] = word
    print(word2index)
    print(index2word)
    O_input = []
    for sentence in O:
        O_input.append([word2index[word] for word in sentence])
    print(O_input)
    return O_input


def run_my_model():
    O_input = generate_data()
    N = 3  # 隐变量的维度设为3，表示有3种词性
    my = MyHMM(N=N)
    my.fit(O_input)

    print('A:')
    print(my.params['A'])
    print('B:')
    print(my.params['B'])
    print('pi:')
    print(my.params['pi'])

    I = my.decode(O_s=(2, 1, 0))
    print("I:")
    print(I)

打印的结果为：
A:
[[0.33333528 0.33332093 0.33334378]
[0.43652988 0.25000742 0.3134627 ]
[0.2500279 0.4999721 0.25 ]]
B:
[[9.91856630e-17 1.12533719e-04 1.06467892e-01 3.70235380e-05 8.93382551e-01]
[7.40229993e-17 3.33285967e-01 1.91726675e-07 6.66712274e-01 1.56719927e-06]
[5.31681136e-01 1.48466699e-11 4.68318638e-01 1.95615241e-11 2.25912305e-07]]
pi:
[1.16786216e-17 3.50652002e-23 1.00000000e+00]
I:
[2, 1, 2]

参考资料：
《统计学习方法》李航著