【NLP | 机器学习】隐马尔科夫模型与代码实现

最新推荐文章于 2024-01-10 18:36:06 发布

silentkunden

最新推荐文章于 2024-01-10 18:36:06 发布

阅读量609

点赞数

分类专栏：机器学习 nlp 文章标签：马尔科夫模型隐马尔可夫模型贝叶斯网络概率模型前向算法

本文链接：https://blog.csdn.net/java_hzp/article/details/117738950

版权

机器学习同时被 2 个专栏收录

9 篇文章 1 订阅

订阅专栏

nlp

5 篇文章 0 订阅

订阅专栏

1.马尔科夫模型、马尔科夫网络、马尔科夫过程、贝叶斯网络的区别

前提条件：将随机变量作为节点，若两个随机变量相关或不独立，则将二者连接一条边；若给定的若干个随机变量，则构成一个有向图

若该网络是有向无环图，则为贝叶斯网络；
若这个图退化成线性链的方式，则得到马尔科夫模型（有向的）；因为每个节点都是随机变量，将其看成各个时刻（或空间）的相关变化，以随机过程的视角，则可以看成是马尔科夫过程。
若2中的网络是无向的（即为无向图模型），可称为马尔科夫随机场或者马尔科夫网络；

2.定义：

隐马尔可夫模型是关于时序的概率模型，由一个隐藏的马尔科夫链随机生成不可观测的状态随机序列，再由各个状态序列生成一个观测从而产生观测随机序列的过程。一个隐马尔科夫模型由初始概率分布 $\pi$ 、状态转移概率分布 $A$ 、观测概率分布 $B$ 所确定。

3.隐马尔可夫模型的前提假设：

假设隐藏的马尔可夫链在任意的 $t$ 时刻的状态只与它前一个时刻有关，与其他时刻的状态及观测无关，也与时刻 $t$ 无关：

$P(i_{t} | i_{t-1},o_{t-1},...,i_{1},o_{1}) = P(i_{t} | i_{t-1}) , t = 1,2,...,T$

假设任意时刻的观测只依赖于该时刻的马尔科夫链的状态，与其它观测及状态无关：

$P(o_{t} | i_{T},o_{T},...,i_{1},o_{1}) = P(o_{t} | i_{t})$

4. 隐马尔可夫模型一般有以下三个基本问题：

5.计算观测序列概率 $P(O | \lambda )$ （上述问题1）：

直接计算法：

思路：通过列举所有可能的长度为 $T$ 的状态序列，求各个状态序列 $I$ 与观测序列的联合概率，然后对所有的状态序列求和，最终得到 $P(O | \lambda )$ 。但计算量很大，时间复杂度达到 $O(TN^{T})$

前向算法

步骤1.计算初值:

$\alpha _{1}(i) = \pi _{i}b_{i}(o_{1}) , i=1,2,...,N$

步骤2.递推计算

$\alpha _{t+1}(i) = \left [ \sum_{j =1}^{N} \alpha _{t}(j)\alpha _{ij} \right ]b_{i}(o_{t+1}), i = 1,2 ,...,N$

$P(O | \lambda ) = \sum_{i =1}^{N} \alpha _{T}(i)$

6.代码实现

class HMM(object):

    def __init__(self, N, M, A=None, B=None, pi=None, O=None):
        '''
        :param N: 状态数量
        :param M:观测数量
        :param A:状态转移矩阵
        :param B:观测概率分布矩阵
        :param Pi:初始概率矩阵
        '''
        self.N = N
        self.M = M
        self.A = A
        self.B = B
        self.pi = Pi
        self.O = O

    def forward_evaluate(self):
        '''
        根据给定的参数计算条件概率
        O: 观测数据
        '''
        X = self.O
        alpha = self.pi * self.B[:,X[0]]
        for x in X[1:]:
            # alpha_next = np.empty(self.N)
            # for j in range(self.N):
            #     alpha_next[j] = np.sum(self.A[:,j] * alpha * self.B[j,x])
            # alpha = alpha_next
            alpha = np.sum(self.A * alpha.reshape(-1,1) * self.B[:,x].reshape(1,-1), axis=0)
        return alpha.sum()