HMM-前向后向算法理解与实现(python)
HMM-前向后向算法理解与实现(python)
HMM-维特比算法理解与实现(python)
基本要素
状态 \(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-前向后向算法理解与实现(python)的更多相关文章
- HMM 前向后向算法(转)
最近研究NLP颇感兴趣,但由于比较懒,所以只好找来网上别人的比较好的博客,备份一下,也方便自己以后方便查找(其实,一般是不会再回过头来看的,嘿嘿 -_-!!) 代码自己重新写了一遍,所以就不把原文代码 ...
- HMM 自学教程(七)前向后向算法
本系列文章摘自 52nlp(我爱自然语言处理: http://www.52nlp.cn/),原文链接在 HMM 学习最佳范例,这是针对 国外网站上一个 HMM 教程 的翻译,作者功底很深,翻译得很精彩 ...
- 隐马尔科夫模型HMM(二)前向后向算法评估观察序列概率
隐马尔科夫模型HMM(一)HMM模型 隐马尔科夫模型HMM(二)前向后向算法评估观察序列概率 隐马尔科夫模型HMM(三)鲍姆-韦尔奇算法求解HMM参数(TODO) 隐马尔科夫模型HMM(四)维特比算法 ...
- 条件随机场CRF(二) 前向后向算法评估标记序列概率
条件随机场CRF(一)从随机场到线性链条件随机场 条件随机场CRF(二) 前向后向算法评估标记序列概率 条件随机场CRF(三) 模型学习与维特比算法解码 在条件随机场CRF(一)中我们总结了CRF的模 ...
- 《统计学习方法》P179页10.22前向后向算法公式推导
- 隐马尔可夫(HMM)、前/后向算法、Viterbi算法
HMM的模型 图1 如上图所示,白色那一行描述由一个隐藏的马尔科夫链生成不可观测的状态随机序列,蓝紫色那一行是各个状态生成可观测的随机序列 话说,上面也是个贝叶斯网络,而贝叶斯网络中有这么一种,如下 ...
- 隐马尔可夫模型HMM与维特比Veterbi算法(一)
隐马尔可夫模型HMM与维特比Veterbi算法(一) 主要内容: 1.一个简单的例子 2.生成模式(Generating Patterns) 3.隐藏模式(Hidden Patterns) 4.隐马尔 ...
- HMM-前向后向算法
基本要素 状态 \(N\)个 状态序列 \(S = s_1,s_2,...\) 观测序列 \(O=O_1,O_2,...\) \(\lambda(A,B,\pi)\) 状态转移概率 \(A = \{a ...
- HMM-前向后向算法(附python实现)
基本要素 状态 \(N\)个 状态序列 \(S = s_1,s_2,...\) 观测序列 \(O=O_1,O_2,...\) \(\lambda(A,B,\pi)\) 状态转移概率 \(A = \{a ...
随机推荐
- G - Messy codeforces1262C
题目大意: 输入n和m,n是n个字符,m是m个前缀.对前缀的规定可以配对的括号.比如(),,((()))等等.在输入n个括号字符,对这个n个字符,通过交换使其满足m个前缀.交换次数不限,规则想当与re ...
- 爬虫与反爬相生相克,道高一丈魔高一尺,如何隐藏ID(附代码)
Python 反爬篇之 ID 混淆 作为爬虫的一方,如果知道了某个站点的数据自增 ID,那么就能轻而易举把整个站点都爬下来. 是不是有点耸人听闻,你去看很多大站例如油管.P 站等,他们都不会轻易把业务 ...
- .NET Core 初识
什么是 ASP.NET Core? ASP.NET Core 是一个新的开源和跨平台的框架,用于构建如 Web 应用.物联网(IoT)应用和移动后端应用等连接到互联网的基于云的现代应用程序.ASP.N ...
- python-Django与Apache整合wsgi模块
1.安装wsgi模块 yum search mod_wsgi yum install -y mod_wsgi 2.会在httpd下有配置文件 cd /etc/httpd/conf.d/wsgi.con ...
- 解决sublime打开文档,出现中文乱码问题
sublime text 软件中出现中文乱码,大多是因为编码格式不支持,需要安装一个插件就可以解决中文乱码问题,推荐安装 ConvertToUtf8 安装步骤: 1.按“shift + ctrl + ...
- pytorch 手写数字识别项目 增量式训练
dataset.py ''' 准备数据集 ''' import torch from torch.utils.data import DataLoader from torchvision.datas ...
- Ubuntu当状态栏网络图标隐藏的解决方法汇总
最有效之一: 直接在终端运行以下命令,以root身份: nm-applet --sm-disable 不建议修改配置文件内容
- 0day笔记(1)PE文件格式与虚拟文件内存的映射
PE文件格式 PE 文件格式把可执行文件分成若干个数据节(section),不同的资源被存放在不同的节中. 一个典型的 PE 文件中包含的节如下: .text 存放着二进制的机器代码 .data 初始 ...
- SQLI-LABS学习笔记(四)
第十六关 和之前的关卡一样,修改闭合,无意义的关卡 ")闭合即可 第十七关 这题从源码上看发现 这里进行了两次查询 先查询了用户名是否存在 再查询密码是否匹配 ...
- RabbitMQ Hello world(二)
简介: Rabbitmq 是消息代理中间件,它接收或者发送消息.你可以把它想想宬一个邮局:当你把邮件放到邮箱时,你可以确定某一位邮递员可以准确的把邮件送到收件人手中,在这个比喻中,rabbitmq是一 ...