HMM2概率计算问题_机器学习

最新推荐文章于 2021-11-30 19:54:35 发布

明朝百晓生

最新推荐文章于 2021-11-30 19:54:35 发布

阅读量362

点赞数

分类专栏：人工智能

4AM_明朝百晓生

本文链接：https://blog.csdn.net/chengxf2/article/details/103988258

版权

人工智能专栏收录该内容

102 篇文章 3 订阅

订阅专栏

前言：

这里主要介绍观察序列 $P(O|\lambda)$ 的前向与后向算法

直接计算法
前向算法
后向算法
概率与期望值计算

一直接计算

已知条件：

模型 $\lambda = (A,B,\pi)$ ,

O=(o_1,o_2,....,o_T)

观测序列出现的概率：

$P(O|\lambda)$

状态序列 I=(i_1,i_2,...i_T) 的概率

$P(I |\lambda)=\pi_{i_1}a_{i_1i_2}a_{i_2i_3}.....a_{i_{T-1}i_T}$

对于固定的状态序列 I=(i_1,i_2,...i_T) ，观测序列 O=(o_1,o_2,....,o_T)

$P(O|I,\lambda)=b_{i_1}(o_1)b_{i_2}(o_2)...b_{i_T}(o_T)$

O 和 I 同时出现的联合概率为： 这个实际应用中也经常会用到

$P(O, I|\lambda)= P(O|I,\lambda)P(I|\lambda)$ （通过贝叶斯公式可以推导）

$=\sum_{i_1,i_2,...i_T}\pi_{i_1}b_{i_1}(o_1)a_{i_1i_2}b_{i_2}(o_2)...a_{i_{T-1}i_T}b_{i_T}(o_T)$

上面计算量太大了，可以通过前向和后向算法简化

二前向算法

算法流程：

输入：隐马尔可夫模型 $\lambda$ ,观测序列O

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

初始值：

$\alpha_1(i)=\pi_{i}b_i(o_1),i=1,2,...N$

递推值：

$\alpha_{t+1}(i)=[\sum_{j=1}^{N}\alpha_t(j)a_{ji}]b_i(o_{t+1}),i=1,2,...N$

终止值：

$P(O|\lambda)=\sum_{t=1}^{N}\alpha_T(i)$

例子：

# -*- coding: utf-8 -*-
"""
Created on Wed Jan 15 15:45:08 2020

@author: chengxf2
"""

import numpy as np


def Forward():
    
    ##状态转移矩阵
    arrA = np.array([[0.5,0.2,0.3],
         [0.3,0.5,0.2],
         [0.2,0.3,0.5]])
    

   
    ##观测概率矩阵
    arrB= np.array([[0.5,0.5],
                    [0.4, 0.6],
                    [0.7,0.3]])
    m,n = np.shape(arrA)
    
    PI= np.array([0.2,0.4,0.4]) ##初始状态概率
    
    T =3
    V =[0,1,0] ##观测集合
    dictV ={0:"红",1:"白"}
    arrAlpha = np.zeros((T,n)) ##array
    
    print("\n 观测序序列: ")
    for t in range(T):
        obj= V[t]
        print("\t ",dictV[obj])
    
    print("\n *****************计算初始值********************")
    
    ##step1 处置计算
    
    obj =V[0]
    b1 = arrB[:,obj]
    arrAlpha[0,]=np.multiply(PI,b1)

    print("\n  arrAlpha ",arrAlpha[0,])
    
    print("\n *****************递推********************")
    
    for t in range(T-1):
        
        alpha_t = arrAlpha[t,]  ## 前向概率
        obj_t1 = V[t+1] ##t+1时刻的观测值
        objB = arrB[:,obj_t1]
        arrAlpha[t+1,]=np.multiply(np.dot(alpha_t,arrA),objB)
        

    print("\n arrAlpha", arrAlpha)
    
    ##观测序列的概率
    print("\n *****************观测序列的概率********************")
    P = sum(arrAlpha[T-1,])
    print("\n arrAlpha: ", P)
    
    
     
  
    

        
       
        

Forward()

二后向算法

定义给定隐马尔可夫模型 $\lambda$ ,定义t时刻状态 q_i, ,从t+1到T的部分观测序列为 $o_{t+1},o_{t+2},....o_T$ 的概率为后向概率

记住：

$\beta_t(i)=P(o_{t+1},o_{t+2},....,o_T|i_t=q_i.\lambda)$

算法流程：

输入：观测序列O, 以及模型 $\lambda$

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

2.1

$\beta_T(i)=1,i =1,2,...,N$

2.2 对t = T-1,T-2,....,1

$\beta_t(i)=\sum_{j=1}^{N}a_{ij}b_j(o_{t+1})\beta_{t+1}(j),i=1,2,...,N$

2.3

$p(O|\lambda)=\sum_{i=1}^{N}\pi_ib_i(o_1)\beta_1(i)$


import numpy as np
"""

Q:  状态序列
V： 观测集合
A:  转移概率矩阵
B:  生成概率矩阵
O:  观测序列
PI: 概率向量

"""

def BackWard():
    
    Q =[1,2,3]
    V =['红','白']
    A = np.array([[0.5,0.2,0.3],
         [0.3,0.5,0.2],
         [0.2,0.3,0.5]])
    
    B = np.array([[0.5,0.5],
                    [0.4, 0.6],
                    [0.7,0.3]])
    
    O = ['红','白','红']
    PI = [0.2, 0.4, 0.4]
    
    T = len(O)
    N = len(Q)
    
    beta = np.zeros((T,N))
    
    print("\n ***********step1 初始化概率***********")
    beta[T-1,]=1.0
    print("\n beta ",beta)
    
    print("\n ***********step2 后向计算法***********")
    for t in range(T-2,-1,-1):
        index = V.index(O[t+1])
        
        for i  in range(N):
            a = np.dot(np.multiply(A[i,],B[:,index]),beta[t+1,].T)
            #print("\n a: ",a,"\t i: ",i)
            beta[t,i]= a
    print("\n beta ",beta)
    
  
    print("\n ===计算P(O|lambda) ===: ")
    index0 = V.index(O[0])
    P = np.dot(np.multiply(PI,B[:,index0]),beta[0])
    print("\n P: ",P)