HMM-前向后向算法(附代码)
基本要素
状态 \(N\)个
状态序列 \(S = s_1,s_2,...\)
观测序列 \(O=O_1,O_2,...\)
\(\lambda(A,B,\pi)\)
- 状态转移概率 \(A = \{a_{ij}\}\)
- 发射概率 \(B = \{b_{ik}\}\)
- 初始概率分布 \(\pi = \{\pi_i\}\)
观测序列生成过程
- 初始状态
- 选择观测
- 状态转移
- 返回step2
HMM三大问题
- 概率计算问题(评估问题)
给定观测序列 \(O=O_1O_2...O_T\),模型 \(\lambda (A,B,\pi)\),计算 \(P(O|\lambda)\),即计算观测序列的概率
- 解码问题
给定观测序列 \(O=O_1O_2...O_T\),模型 \(\lambda (A,B,\pi)\),找到对应的状态序列 \(S\)
- 学习问题
给定观测序列 \(O=O_1O_2...O_T\),找到模型参数 \(\lambda (A,B,\pi)\),以最大化 \(P(O|\lambda)\),
概率计算问题
给定模型 \(\lambda\) 和观测序列 \(O\),如何计算\(P(O| \lambda)\)?
暴力枚举每一个可能的状态序列 \(S\)
对每一个给定的状态序列
\[P(O|S,\lambda) = \prod^T_{t=1} P(O_t|s_t,\lambda) =\prod^T_{t=1} b_{s_tO_t}
\]一个状态序列的产生概率
\[P(S|\lambda) = P(s_1)\prod^T_{t=2}P(s_t|s_{t-1})=\pi_1\prod^T_{t=2}a_{s_{t-1}s_t}
\]联合概率
\[P(O,S|\lambda) = P(S|\lambda)P(O|S,\lambda) =\pi_1\prod^T_{t=2}a_{s_{t-1}s_t}\prod^T_{t=1} b_{s_tO_t}
\]考虑所有的状态序列
\[P(O|\lambda)=\sum_S\pi_1b_{s_1O_1}\prod^T_{t=2}a_{s_{t-1}s_t}b_{s_tO_t}
\]
\(O\) 可能由任意一个状态得到,所以需要将每个状态的可能性相加。
这样做什么问题?时间复杂度高达 \(O(2TN^T)\)。每个序列需要计算 \(2T\) 次,一共 \(N^T\) 个序列。
前向算法
在时刻 \(t\),状态为 \(i\) 时,前面的时刻观测到 \(O_1,O_2, ..., O_t\) 的概率,记为 \(\alpha _i(t)\) :
\]
当 \(t=1\) 时,输出为 \(O_1\),假设有三个状态,\(O_1\) 可能是任意一个状态发出,即
\]
当 \(t=2\) 时,输出为 \(O_1O_2\) ,\(O_2\) 可能由任一个状态发出,同时产生 \(O_2\) 对应的状态可以由 \(t=1\) 时刻任意一个状态转移得到。假设 \(O_2\) 由状态 1
发出,如下图
=\bold{\alpha_1(1)}a_{11}b_1(O_2)+\bold{\alpha_2(1)}a_{21}b_1(O_2)+\bold{\alpha_3(1)}a_{31}b_1(O_2) = \bold{\alpha_1(2)}
\]
同理可得 \(\alpha_2(2),\alpha_3(2)\)
=\bold{\alpha_1(1)}a_{12}b_2(O_2)+\bold{\alpha_2(1)}a_{22}b_2(O_2)+\bold{\alpha_3(1)}a_{32}b_2(O_2)
\\
\bold{\alpha_3(2)} = P(O_1O_2,s_2=q_3|\lambda)
=\bold{\alpha_1(1)}a_{13}b_3(O_2)+\bold{\alpha_2(1)}a_{23}b_3(O_2)+\bold{\alpha_3(1)}a_{33}b_3(O_2)
\]
所以
= \alpha_1(2)+\alpha_2(2)+\alpha_3(2)
\]
所以前向算法过程如下:
step1:初始化 \(\alpha_i(1)= \pi_i*b_i(O_1)\)
step2:计算 \(\alpha_i(t) = (\sum^{N}_{j=1} \alpha_j(t-1)a_{ji})b_i(O_{t})\)
step3:\(P(O|\lambda) = \sum^N_{i=1}\alpha_i(T)\)
相比暴力法,时间复杂度降低了吗?
当前时刻有 \(N\) 个状态,每个状态可能由前一时刻 \(N\) 个状态中的任意一个转移得到,所以单个时刻的时间复杂度为 \(O(N^2)\),总时间复杂度为 \(O(TN^2)\)
代码实现
例子:
假设从三个 袋子 {1,2,3}
中 取出 4 个球 O={red,white,red,white}
,模型参数\(\lambda = (A,B,\pi)\) 如下,计算序列O
出现的概率
#状态 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]]
step1:初始化 \(\alpha_i(1)= \pi_i*b_i(O_1)\)
step2:计算 \(\alpha_i(t) = (\sum^{N}_{j=1} \alpha_j(t-1)a_{ji})b_i(O_{t})\)
step3:\(P(O|\lambda) = \sum^N_{i=1}\alpha_i( T)\)
#前向算法
def hmm_forward(A,B,pi,O):
T = len(O)
N = len(A[0])
#step1 初始化
alpha = [[0]*T for _ in range(N)]
for i in range(N):
alpha[i][0] = pi[i]*B[i][O[0]]
#step2 计算alpha(t)
for t in range(1,T):
for i in range(N):
temp = 0
for j in range(N):
temp += alpha[j][t-1]*A[j][i]
alpha[i][t] = temp*B[i][O[t]]
#step3
proba = 0
for i in range(N):
proba += alpha[i][-1]
return proba,alpha
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_forward(A,B,pi,O) #结果为 0.06009
结果
后向算法
在时刻 \(t\),状态为 \(i\) 时,观测到 \(O_{t+1},O_{t+2}, ..., O_T\) 的概率,记为 \(\beta _i(t)\) :
\]
当 \(t=T\) 时,由于 \(T\) 时刻之后为空,没有观测,所以 \(\beta_i(t)=1\)
当 \(t = T-1\) 时,观测 \(O_T\) ,\(O_T\) 可能由任意一个状态产生
\]
当 \(t=1\) 时,观测为 \(O_{2},O_{3}, ..., O_T\)
\beta_1(1)
&= P(O_{2},O_{3}, ..., O_T|s_1=1,\lambda)\\
&=a_{11}b_1(O_2)\beta_1(2)+a_{12}b_2(O_2)\beta_2(2)+a_{13}b_3(O_2)\beta_3(2)
\\
\quad
\\
\beta_2(1)
&= P(O_{2},O_{3}, ..., O_T|s_1=2,\lambda)\\
&=a_{21}b_1(O_2)\beta_1(2)+a_{22}b_2(O_2)\beta_2(2)+a_{23}b_3(O_2)\beta_3(2)
\\
\quad
\\
\beta_3(1)
&=P(O_{2},O_{3}, ..., O_T|s_1=3,\lambda)\\
&=a_{31}b_1(O_2)\beta_1(2)+a_{32}b_2(O_2)\beta_2(2)+a_{33}b_3(O_2)\beta_3(2)
\end{aligned}
\]
所以
\]
后向算法过程如下:
step1:初始化 \(\beta_i(T)=1\)
step2:计算 \(\beta_i(t) = \sum^N_{j=1}a_{ij}b_j(O_{t+1})\beta_j(t+1)\)
step3:\(P(O|\lambda) = \sum^N_{i=1}\pi_ib_i(O_1)\beta_i(1)\)
- 时间复杂度 \(O(N^2T)\)
代码实现
还是上面的例子
#后向算法
def hmm_backward(A,B,pi,O):
T = len(O)
N = len(A[0])
#step1 初始化
beta = [[0]*T for _ in range(N)]
for i in range(N):
beta[i][-1] = 1
#step2 计算beta(t)
for t in reversed(range(T-1)):
for i in range(N):
for j in range(N):
beta[i][t] += A[i][j]*B[j][O[t+1]]*beta[j][t+1]
#step3
proba = 0
for i in range(N):
proba += pi[i]*B[i][O[0]]*beta[i][0]
return proba,beta
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_backward(A,B,pi,O) #结果为 0.06009
结果
前向-后向算法
回顾前向、后向变量:
- \(a_i(t)\) 时刻 \(t\),状态为 \(i\) ,观测序列为 \(O_1,O_2, ..., O_t\) 的概率
- \(\beta_i(t)\) 时刻 \(t\),状态为 \(i\) ,观测序列为 \(O_{t+1},O_{t+2}, ..., O_T\) 的概率
P(O,s_t=i|\lambda)
&= P(O_1,O_2, ..., O_T,s_t=i|\lambda)\\
&= P(O_1,O_2, ..., O_t,s_t=i,O_{t+1},O_{t+2}, ..., O_T|\lambda)\\
&= P(O_1,O_2, ..., O_t,s_t=i|\lambda)*P(O_{t+1},O_{t+2}, ..., O_T|O_1,O_2, ..., O_t,s_t=i,\lambda) \\
&= P(O_1,O_2, ..., O_t,s_t=i|\lambda)*P(O_{t+1},O_{t+2}, ..., O_T,s_t=i|\lambda)\\
&= a_i(t)*\beta_i(t)
\end{aligned}
\]
即在给定的状态序列中,\(t\) 时刻状态为 \(i\) 的概率。
使用前后向算法可以计算隐状态,记 \(\gamma_i(t) = P(s_t=i|O,\lambda)\) 表示时刻 \(t\) 位于隐状态 \(i\) 的概率
\]
\gamma_{i}(t)
&=P\left(s_{t}={i} | O, \lambda\right)=\frac{P\left(s_{t}={i}, O | \lambda\right)}{P(O | \lambda)} \\
&=\frac{\alpha_{i}(t) \beta_{i}(t)}{P(O | \lambda)}=\frac{\alpha_{i}(t) \beta_{i}(t)}{\sum_{i=1}^{N} \alpha_{i}(t) \beta_{i}(t)}
\end{aligned}
\]
references:
[1] https://www.cs.sjsu.edu/~stamp/RUA/HMM.pdf
[2]https://www.cnblogs.com/fulcra/p/11065474.html
[3] https://www.cnblogs.com/sjjsxl/p/6285629.html
[4] https://blog.csdn.net/xueyingxue001/article/details/52396494
HMM-前向后向算法(附代码)的更多相关文章
- HMM 前向后向算法(转)
最近研究NLP颇感兴趣,但由于比较懒,所以只好找来网上别人的比较好的博客,备份一下,也方便自己以后方便查找(其实,一般是不会再回过头来看的,嘿嘿 -_-!!) 代码自己重新写了一遍,所以就不把原文代码 ...
- HMM 自学教程(七)前向后向算法
本系列文章摘自 52nlp(我爱自然语言处理: http://www.52nlp.cn/),原文链接在 HMM 学习最佳范例,这是针对 国外网站上一个 HMM 教程 的翻译,作者功底很深,翻译得很精彩 ...
- 隐马尔科夫模型HMM(二)前向后向算法评估观察序列概率
隐马尔科夫模型HMM(一)HMM模型 隐马尔科夫模型HMM(二)前向后向算法评估观察序列概率 隐马尔科夫模型HMM(三)鲍姆-韦尔奇算法求解HMM参数(TODO) 隐马尔科夫模型HMM(四)维特比算法 ...
- 条件随机场CRF(二) 前向后向算法评估标记序列概率
条件随机场CRF(一)从随机场到线性链条件随机场 条件随机场CRF(二) 前向后向算法评估标记序列概率 条件随机场CRF(三) 模型学习与维特比算法解码 在条件随机场CRF(一)中我们总结了CRF的模 ...
- 从似然函数到EM算法(附代码实现)
1. 什么是EM算法 最大期望算法(Expectation-maximization algorithm,又译为期望最大化算法),是在概率模型中寻找参数最大似然估计或者最大后验估计的算法,其中概率模型 ...
- main函数执行前、后再执行的代码
一.main结束 不代表整个进程结束 (1)全局对象的构造函数会在main 函数之前执行, 全局对象的析构函数会在main函数之后执行: 用atexit注册的函数 ...
- SpringBoot+MyBatisPlus+ElementUI一步一步搭建前后端分离的项目(附代码下载)
场景 一步一步教你在IEDA中快速搭建SpringBoot项目: https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/87688277 ...
- 《统计学习方法》P179页10.22前向后向算法公式推导
- 隐马尔可夫(HMM)、前/后向算法、Viterbi算法
HMM的模型 图1 如上图所示,白色那一行描述由一个隐藏的马尔科夫链生成不可观测的状态随机序列,蓝紫色那一行是各个状态生成可观测的随机序列 话说,上面也是个贝叶斯网络,而贝叶斯网络中有这么一种,如下 ...
随机推荐
- L8梯度消失、梯度爆炸
houseprices数据下载: 链接:https://pan.baidu.com/s/1-szkkAALzzJJmCLlJ1aXGQ 提取码:9n9k 梯度消失.梯度爆炸以及Kaggle房价预测 代 ...
- First Training
B B - Local Extrema CodeForces - 888A You are given an array a. Some element of this array ai is a l ...
- idea ------- 源码调试运行
1.创建一个 想学 的 ,使用单步调试进行一步步学习 调整系统资源 单步调试 (F7) ,进入不了源码,调整idea 让我们可以进入底层学习 想要在源码里面添加注释,要将引用的源文件指向,我们刚才复制 ...
- Ubuntu上mysql, 通过python连接报错Can't connect to MySQL server on xxx (10061)
通过sqlyog连接ubuntu上的mysql报错 试了试python直接连接也报同样的错 那应该就是ubuntu上mysql服务自己的问题了 查看mysql 版本 mysql -V root@clo ...
- self不明白什么意思,我来帮助你了解self的含义
先看下面这段代码 # 用函数模仿类def dog(name, gender): def jiao(dog1): print('%s汪汪叫' % dog1["name"]) def ...
- Redis的三大问题
一般我们对缓存读操作的时候有这么一个固定的套路: 如果我们的数据在缓存里边有,那么就直接取缓存的. 如果缓存里没有我们想要的数据,我们会先去查询数据库,然后将数据库查出来的数据写到缓存中. 最后将数据 ...
- Flutter 步骤进度组件
老孟导读:最近文章更新拖后腿了,一直忙着网站改版的事情,今天总算落地了,全新的Flutter网站即将上线,敬请期待.网站目前收集197个组件的详细用法,还有150多个组件待整理. Stepper S ...
- python机器学习的常用算法
Python机器学习 学习意味着通过学习或经验获得知识或技能.基于此,我们可以定义机器学习(ML)如下 - 它可以被定义为计算机科学领域,更具体地说是人工智能的应用,其为计算机系统提供了学习数据和从经 ...
- php phpStudy session存放位置
如果你仅仅是想知道session保存的文件在哪里,你可以在你的PHP文件当中运行函数:session_save_path之后查看运行结果即可知道session文件的存放目录. 或者: 在php-ini ...
- 闲聊http1.1的6个方法
GET :获取资源GET 方法用来请求访问已被 URI 识别的资源.指定的资源经服务器端解析后返回响应内容. POST :传输实体主体POST 方法用来传输实体的主体.虽然用 GET 方法也可以传输实 ...