用python实现与理解HMM-维特比算法

HaggaiMerle 发布于21天前

HMM-前向后向算法理解与实现(python)

HMM-维特比算法理解与实现(python)

解码问题

  • 给定观测序列 \(O=O_1O_2...O_T\) ,模型 \(\lambda (A,B,\pi)\) ,找到最可能的状态序列 \(I^∗=\{i^∗_1,i^∗_2,...i^∗_T\}\)

近似算法

  • 在每个时刻 \(t\) 选择最可能的状态,得到对应的状态序列

根据HMM-前向后向算法计算时刻 \(t\) 处于状态 \(i^*_t\) 的概率:

\[i^∗_t=argmax[\gamma_t(i)],t=1,2,...T\\ \gamma_t(i) = \frac{\alpha_{i}(t) \beta_{i}(t)}{\sum_{i=1}^{N} \alpha_{i}(t) \beta_{i}(t)} \]

但是无法保证得到的解是全局最优解

维特比算法

维特比算法的基础可以概括为下面三点(来源于吴军:数学之美):

  1. 如果概率最大的路径经过篱笆网络的某点,则从起始点到该点的子路径也一定是从开始到该点路径中概率最大的。

  2. 假定第 t 时刻有 k 个状态,从开始到 t 时刻的 k 个状态有 k 条最短路径,而最终的最短路径必然经过其中的一条。

  3. 根据上述性质,在计算第 t+1 时刻的最短路径时,只需要考虑从开始到当前的 k 个状态值的最短路径和当前状态值到第 t+1 时刻的最短路径即可。如求 t=3 时的最短路径,等于求 t=2 时,从起点到当前时刻的所有状态结点的最短路径加上 t=2 到 t=3 的各节点的最短路径。

HMM-维特比算法理解与实现(python)

通俗理解维特比算法,对上面三点加深理解

假如你从S和E之间找一条最短的路径,最简单的方法就是列出所有可能的路径 ( \(O(T^N)\) ),选出最小的,显然时间复杂度太高。怎么办?(摘自[3])

使用维特比算法

HMM-维特比算法理解与实现(python)

S到A列的路径有三种可能: S-A1,S-A2,S-A3 ,如下图

HMM-维特比算法理解与实现(python)

S-A1,S-A2,S-A3 中必定有一个属于全局最短路径。继续往右,到了B列

对B1:

HMM-维特比算法理解与实现(python)

会产生3条路径:

S-A1-B1,S-A2-B1,S-A3-B1

假设 S-A3-B1 是最短的一条,删掉其他两条。得到

HMM-维特比算法理解与实现(python)

对B2:

HMM-维特比算法理解与实现(python)

会产生3条路径:

S-A1-B2,S-A2-B2,S-A3-B2

假设 S-A1-B2 是最短的一条,删掉其他两条。得到

HMM-维特比算法理解与实现(python)

对B3:

HMM-维特比算法理解与实现(python)

会产生3条路径:

S-A1-B3,S-A2-B3,S-A3-B3

假设 S-A2-B3 是最短的一条,删掉其他两条。得到

HMM-维特比算法理解与实现(python)

现在我们看看对B列的每个节点有哪些,回顾维特比算法第二点

假定第 t 时刻有 k 个状态,从开始到 t 时刻的 k 个状态有 k 条最短路径,而最终的最短路径必然经过其中的一条

B列有三个节点,所以会有三条最短路径,最终的最短路径一定会经过其中一条。如下图

HMM-维特比算法理解与实现(python)

同理,对C列,会得到三条最短路径,如下图

HMM-维特比算法理解与实现(python)

到目前为止,仍然无法确定哪条属于全局最短。最后,我们继续看E节点

HMM-维特比算法理解与实现(python)

最终发现最短路径为 S-A1-B2-C3-E

数学描述

在上述过程中,对每一列(每个时刻)会得到对应状态数的最短路径。在数学上如何表达?记录路径的 最大概率值 $ \delta_t(i)$ 和对应路径 经过的节点 \(\psi_t(i)\) 。

定义在时刻 \(t\) 状态为 \(i\) 的所有单条路径中概率最大值为

\[\delta_{t}(i)=\max _{i_{1}, i_{2}, \ldots, i_{t-1}} P\left(i_{t}=i, i_{t-1}, \ldots, i_{1}, o_{t}, \ldots, o_{1} | \lambda\right), i=1,2, \ldots, N \]

递推公式

\[\begin{aligned} \delta_{t+1}(i) &=\max _{i_{1}, i_{2}, \ldots, i_{t}} P\left(i_{t+1}=i, i_{t}, \ldots, i_{1}, o_{t+1}, \ldots, o_{1} | \lambda\right) \\ &=\max _{1 \leq j \leq N}\left[\delta_{t}(j) a_{j i}\right] b_{i}\left(o_{t+1}\right), i=1,2, \ldots, N ; t=1,2, \ldots, T-1 \end{aligned} \]

定义在时刻 \(t\) 状态为 \(i\) 的所有单条路径中,概率最大路径的第 \(t - 1\) 个节点为

\[\psi_{t}(i)=\arg \max _{1 \leq j \leq N}\left[\delta_{t-1}(j) a_{j i}\right], i=1,2, \ldots, N \]

维特比算法步骤:

​ step1:初始化

\[\begin{aligned}&\delta_{1}(i)=\pi_{i} b_{i}\left(o_{1}\right), i=1,2, \ldots, N\\&\psi_{1}(i)=0, i=1,2, \ldots, N\\\end{aligned} \]

​ step2:递推,对 \(t=2,3,...,T\)

\[\delta_{t}(i)=\max _{1 \leq j \leq N}\left[\delta_{t-1}(j) a_{j i}\right] b_{i}\left(o_{t}\right), i=1,2, \ldots, N \\\psi_{t}(i)=\arg \max _{1 \leq j \leq N}\left[\delta_{t-1}(j) a_{j i}\right], i=1,2, \ldots, N \\ \]

​ step3:计算时刻 \(T\) 最大的 $ \delta _T(i) \(,即为最可能隐藏状态序列出现的概率。计算时刻\) T \(最大的\) \psi_T(i) \(,即为时刻\) T$最可能的隐藏状态。

\[P^{*}=\max _{1 \leq i \leq N} \delta_{T}(i) \quad i_{T}^{*}=\arg \max _{1 \leq i \leq N} \delta_{T}(i) \]

​ step4:最优路径回溯,对 \(t=T-1,...,1\)

\[i_{t}^{*}=\psi_{t+1}\left(i_{t+1}^{*}\right)\\I^*=(i_{1}^{*},i_{2}^{*},...,i_{T}^{*}) \]

代码实现

假设从三个 袋子 {1,2,3} 中 取出 4 个球 O={red,white,red,white} ,模型参数 \(\lambda = (A,B,\pi)\) 如下,计算状态序列,即取出的球来自哪个袋子

#状态 1 2 3
A = [[0.5,0.2,0.3],
	 [0.3,0.5,0.2],
	 [0.2,0.3,0.5]]

pi = [0.2,0.4,0.4]

# red white
B = [[0.5,0.5],
	 [0.4,0.6],
	 [0.7,0.3]]
def hmm_viterbi(A,B,pi,O):
    T = len(O)
    N = len(A[0])
    
    delta = [[0]*N for _ in range(T)]
    psi = [[0]*N for _ in range(T)]
    
    #step1: init
    for i in range(N):
        delta[0][i] = pi[i]*B[i][O[0]]
        psi[0][i] = 0
        
    #step2: iter
    for t in range(1,T):
        for i in range(N):
            temp,maxindex = 0,0
            for j in range(N):
                res = delta[t-1][j]*A[j][i]
                if res>temp:
                    temp = res
                    maxindex = j

            delta[t][i] = temp*B[i][O[t]]#delta
            psi[t][i] = maxindex

    #step3: end
    p = max(delta[-1])
    for i in range(N):
        if delta[-1][i] == p:
            i_T = i

    #step4:backtrack
    path = [0]*T
    i_t = i_T
    for t in reversed(range(T-1)):
        i_t = psi[t+1][i_t]
        path[t] = i_t
    path[-1] = i_T
    
    return delta,psi,path

A = [[0.5,0.2,0.3],[0.3,0.5,0.2],[0.2,0.3,0.5]]
B = [[0.5,0.5],[0.4,0.6],[0.7,0.3]]
pi = [0.2,0.4,0.4]
O = [0,1,0,1]
hmm_viterbi(A,B,pi,O)

结果

HMM-维特比算法理解与实现(python)

references:

[1] https://www.cnblogs.com/kaituorensheng/archive/2012/12/04/2802140.html

[2] https://blog.csdn.net/hudashi/java/article/details/87875259

[3] https://www.zhihu.com/question/20136144

查看原文: HMM-维特比算法理解与实现(python)

  • blueostrich
  • goldenduck
  • tinyelephant
  • blackladybug
  • lazysnake