机器学习之隐马尔科夫（HMM）模型

机器学习之隐马尔科夫模型（HMM）

• 1、隐马尔科夫模型介绍
• 2、隐马尔科夫数学原理
• 3、Python代码实现隐马尔科夫模型
• 4、总结

隐马尔可夫模型介绍

马尔科夫模型（hidden Markov model，HMM）是关于时序的概率模型，描述由一个隐藏的马尔科夫随机生成不可观测的状态随机序列，再由各个状态生成一个观测从而产生观测随机序列的过程，属于一个生成模型。

下面我们来从概率学角度定义马尔科夫模型，从一个典型例子开始：

假设有4个盒子，每个盒子里面有不同数量的红、白两种颜色的球，具体如下表：

盒子编号	1	2	3	4
红球数	5	3	6	8
白球数	5	7	4	2

现在从这些盒子中取出T个球，取样规则为每次选择一个盒子取出一个球，记录其颜色，放回。在这个过程中，我们只能观测到球的颜色的序列，观测不到球是从哪个盒子中取出来的，即观测不到盒子的序列，这里有两个随机序列，一个是盒子的序列（状态序列），一个是球的颜色的观测序列（观测序列），前者是隐藏的，只有后者是可观测的。这里就构成了一个马尔科夫的例子。

定义$\mathbf{Q}$是所有的可能的状态集合，V是所有的可能的观测的集合：
Q = { q 1 , q 2 , ⋯   , q N } , 　 　 　 　 　 V = { v 1 , v 2 , ⋯   , v M } Q = \{q_1,q_2,\cdots,q_N\},　　　　　V = \{v_1,v_2,\cdots,v_M\} Q={ q1​,q2​,⋯,qN​},　　　　　V={ v1​,v2​,⋯,vM​}
其中，Ｎ是可能的状态数，Ｍ是可能的观测数，例如上例中Ｎ＝４，Ｍ＝２。

$\mathbf{I}$是长度为T的状态序列，$\mathbf{O}$是对应的观测序列：
$$I=(i_1,i_2,\cdots ,i_T),O=(o_1,o_2,\cdots ,o_T)$$
A是状态转移概率矩阵：
$$A=[a_{i,j}{]}_{N\times N}$$
其中，$a_{i,j}=P(i_{t+1}=q_j|i_t=q_i),i=1,2,\cdots ,N;j=1,2,\cdots ,N$ 是指在时刻$t$处于状态$q_i$的条件下在时刻$t+1$转移到状态$q_j$的概率。

B是观测概率矩阵：
$$B=[b_j(k){]}_{N\times M}$$
其中，$b_j(k)=P(o_t=v_k|i_t=q_j),k=1,2,\cdots ,M;j=1,2,\cdots ,N$ 是指在时刻$t$处于状态$q_j$的条件下生成观测$v_k$的概率。

$\pi$是初始状态概率向量：
$$\pi =({\pi }_i)$$
其中，${\pi }_i=P(i_1=q_i),i=1,2,\cdots ,N$ 是指在时刻$t$=1处于状态$q_i$的概率。

由此可得到，隐马尔可夫模型$\lambda$的三元符号表示，即
$$\lambda =(A,B,\pi )$$
$A,B,\pi$称为隐马尔可夫模型的三要素。

由定义可知隐马尔可夫模型做了两个基本假设：

(1)齐次马尔科夫性假设，即假设隐藏的马尔科夫链在任意时刻$t$的状态只和$t$-1状态有关；
$$P(i_t|i_{t-1},o_{t-1},\cdots ,i_1,o_1)=P(i_t|i_{t-1}),t=1,2,\cdots ,T$$
(2)观测独立性假设，观测只和当前时刻状态有关；
$$P(o_t|i_T,i_{T-1},o_{T-1},\cdots ,i_{t+1},o_{t+1},i_t,i_{t-1},o_{t-1},\cdots ,i_1,o_1)=P(O_t|i_t)$$
仍以上面的盒子取球为例，假设我们定义盒子和球模型：

• 状态集合：$Q$ = {盒子1，盒子2，盒子3，盒子4}， N=4

• 观测集合：$V$ = {红球，白球} M=2

• 初始化概率分布：
  $$\pi =(0.25,0.25,0.25,0.25{)}^T$$

• 状态转移矩阵：
  $$A=\left[\begin{array}{cccc}0& 1& 0& 0\\ 0.4& 0& 0.6& 0\\ 0& 0.4& 0& 0.6\\ 0& 0& 0.5& 0.5\end{array}\right]$$

• 观测矩阵:
  $$B=\left[\begin{array}{cc}0.5& 0.5\\ 0.3& 0.7\\ 0.6& 0.4\\ 0.8& 0.2\end{array}\right]$$

隐马尔可夫模型的三个基本问题

• 1、概率计算问题

  给定：$\lambda =(A,B,\pi )O=(o_1,o_2,\cdots ,o_T)$

  计算：$P(O|\lambda )$

• 2、学习问题

  已知：$O=(o_1,o_2,\cdots ,o_T)$

  估计：$\lambda =(A,B,\pi )$,使$P(O|\lambda )$最大

• 3、预测问题（解码）

  已知：$\lambda =(A,B,\pi )O=(o_1,o_2,\cdots ,o_T)$

  求：使$P(I|O)$最大的状态序列$I=(i_1,i_2,\cdots ,i_T)$

下面我们使用python代码写一个HMM模型生成序列$O$的示例代码

import numpy as np

class HMM(object):
    def __init__(self, N, M, pi=None, A=None, B=None):
        self.N = N
        self.M = M
        self.pi = pi
        self.A = A
        self.B = B

    def get_data_with_distribute(self, dist): # 根据给定的概率分布随机返回数据（索引）
        r = np.random.rand()
        for i, p in enumerate(dist):
            if r < p: return i
            r -= p

    def generate(self, T: int):
        '''
        根据给定的参数生成观测序列
        T: 指定要生成观测序列的长度
        '''
        result = []
        for ind in range(T):        # 依次生成状态和观测数据
            if ind==0:
                i = self.get_data_with_distribute(self.pi)
            else:
            	i = self.get_data_with_distribute(self.A[i])
            o = self.get_data_with_distribute(self.B[i])
            result.append(o)
        return result

if __name__ == "__main__":
    pi = np.array([0.25, 0.25, 0.25, 0.25])
    A = np.array([
        [0,  1,  0, 0],
        [0.4, 0, 0.6, 0],
        [0, 0.4, 0, 0.6],
        [0, 0, 0.5, 0.5]])
    B = np.array([
        [0.5, 0.5],
        [0.3, 0.7],
        [0.6, 0.4],
        [0.8, 0.2]])
    hmm = HMM(4, 2, pi, A, B)
    print(hmm.generate(10))  # 生成10个数据
 
# 生成结果如下
[0, 0, 0, 0, 1, 1, 1, 1, 0, 0]   # 0代表红球，1代表白球

隐马尔可夫模型数学原理

下面我们从隐马尔可夫模型的三个基本问题出发，逐个解释问题解法：

• 1、概率计算问题

  • 直接计算法
  • 前向算法
  • 后向算法

  直接计算法：

  • 状态序列$I=(i_1,i_2,\cdots ,i_T)$概率：$P(I|\lambda )={\pi }_{i_1}{a}_{i_1{i}_2}{a}_{i_2{i}_3}\cdots a_{i_{T-1}{i}_T}$

  • 对固定的状态序列$I$，观测序列$O$的概率：$P(O|I,\lambda )$
    $$P(O|I,\lambda )=b_{i_1}(o_1)b_{i_2}(o_2)\cdots b_{i_T}(o_T)$$

  • $O$和$I$同时出现的联合概率为：
    $$P(O,I|\lambda )=P(O|I,\lambda )P(I|\lambda )={\pi }_{i_1}{b}_{i_1}(o_1)a_{i_1{i}_2}{b}_{i_2}(o_2)\cdots a_{i_{T-1}{i}_T}{b}_{i_T}(o_T)$$

  • 对所有的可能的状态序列$I$求和，得到观测序列$O$的概率：
    $$P(O|\pi )=\sum _{I}P(O|i,\lambda )P(I|\lambda )=\sum _{i_1,i_2,\cdots ,i_T}{\pi }_{i_1}{b}_{i_1}(o_1)a_{i_1{i}_2}{b}_{i_2}(o_2)\cdots a_{i_{T-1}{i}_T}{b}_{i_T}(o_T)$$

    此算法的复杂度为$O(T{N}^T)$，计算量太大，不可行。

  前向算法：

  • 前向概率定义：给定隐马尔科夫模型$\lambda$，定义到时刻t部分观测序列为：$o_1,o_2,\cdots ,o_t$，且状态为$q_i$的概率为前向概率，记作：
    $${\alpha }_t(i)=P(o_1,o_2,\cdots ,o_t,i_t=q_t|\lambda )$$
    输入：隐马尔可夫模型$\lambda$，观测序列$O$；

    输出：观测序列概率$P(O|\lambda )$

    初值： α 1 ( i ) =