机器学习时间序列模型：隐马尔可夫模型HMM（2）

1、HMM概率的直接计算方法

输入：

模型 M = ( π, A , B  )

观测序列 O = ( o 1 , o 2 , . . . , oT )

输出：

计算在模型M下观测序列O出现的概率P(O|M)，计算方法如下所示。

利用直接算法的计算量很大，其时间复杂度为O(TN^T)，故该算法可行性很差。紧接着我们介绍前向算法和后向算法。

2、HMM概率的前向算法

【1】前向算法的推导过程

首先定义前向概率。给定HMM模型M，时刻t的观测序列O={o1,o2,…ot}，将状态为qi的概率定义为前向概率，记作：

下面通过递推法求得前向概率和观测序列的概率。

输入：HMM模型M；观测序列O

输出：观测序列的概率P(O|M)

步骤1：

初始化前向概率：计算初始时刻状态i1=qi和观测o1的联合概率。

步骤2：

该步骤是前向概率的推导公式，计算t+1时刻部分的观察测序列{O1,O2…Ot,Ot+1}且在t+1时刻处于状态qi的前向概率。

对于t=1, 2, … T-1，有：

【3】结果

利用前向算法的时间复杂度为O(N^2T)，而直接计算是O(TN^T)。

【2】以天气预测案例来演示推导过程

示例：

考虑天气预报模型 λ=(π,A,B)，状态集合Q = {1,2,3}，观测集合V ={晴天，雨天}，

初始状态矩阵 π = {0.5,0.3,0.2},

状态转移矩阵 A = [[0.2,0.3,0.5] ,

[0.3,0.5,0.2] ,

[0.1,0.3,0.6] ]

观测矩阵B = [ [0.3,0.7],

[0.2,0.8] ,

[0.5,0.5]]

设T=2，O =(晴天,晴天)，试用隐马尔可夫模型的前向算法计算P(O|λ)，并使用python编程序实现。

根据题目给出的HMM模型λ=(A,B,π)和观测序列O=(晴天,晴天)，我们需要使用前向算法计算P(O|λ)。

首先，我们可以计算时刻t=1时，观测为晴天的概率：

α(1,1) = π(1) * B(1,1) = 0.5 * 0.3 = 0.15

α(1,2) = π(2) * B(2,1) = 0.3 * 0.2 = 0.06

α(1,3) = π(3) * B(3,1) = 0.2 * 0.5 = 0.1

然后，我们可以计算时刻t=2时，观测为晴天的概率：

α(2,1) = [α(1,1) * A(1,1) + α(1,2) * A(2,1) + α(1,3) * A(3,1)] * B(1,1)

         = [0.15 * 0.2 + 0.06 * 0.3 + 0.1 * 0.1] * 0.3

         = 0.0174

α(2,2) = [α(1,1) * A(1,2) + α(1,2) * A(2,2) + α(1,3) * A(3,2)] * B(2,1)

         = [0.15 * 0.3 + 0.06 * 0.5 + 0.1 * 0.3] * 0.2

         = 0.021

α(2,3) = [α(1,1) * A(1,3) + α(1,2) * A(2,3) + α(1,3) * A(3,3)] * B(3,1)

         = [0.15 * 0.5 + 0.06 * 0.2 + 0.1 * 0.6] * 0.5

         = 0.0735

最后，我们可以计算P(O|λ)：

P(O|λ) = α(2,1) + α(2,2) + α(2,3) = 0.0174 + 0.021 + 0.0735 = 0.112

所以，根据前向算法计算，P(O|λ) = 0.112，和我们用以前直接算法得出结果相同。

【3】python实现前向算法

Python实现如下所示：

import numpy as np

# 定义模型参数

Q = [1, 2, 3]

V = ['晴天', '雨天']

π = np.array([0.5, 0.3, 0.2])

T = 2

O = ['晴天', '晴天']

A = np.array([[0.2, 0.3, 0.5], [0.3, 0.5, 0.2], [0.1, 0.3, 0.6]])

B = np.array([[0.3, 0.7], [0.2, 0.8], [0.5, 0.5]])

# 初始化前向概率矩阵

N = len(Q)

α = np.zeros((N, T))

# 初始化第一列

for i in range(N):

    α[i][0] = π[i] * B[i][V.index(O[0])]

# 递推计算前向概率

for t in range(T - 1):

    for j in range(N):

        α[j][t + 1] = np.sum(A[i][j] * α[i][t] * B[j][V.index(O[t + 1])] for i in range(N))

# 计算观测序列概率

p_O_given_λ = np.sum(α[:, T - 1])

print("P(O| λ) = ", p_O_given_λ)

结果：P(O| λ) =  0.1119

该天气预测程序的python代码解读如下所示。