精华内容
下载资源
问答
  • HMM

    2020-12-28 19:28:21
    HMM 马尔科夫链即为 状态空间中从一个状态到另一个状态转换的随机过程。 该过程要求具备 “无记忆” 的性质: 下一状态的概率分布只能由当前状态决定,在时间序列中它前面的事件均与之无关 隐马尔可夫模型...

    HMM

    马尔科夫链即为

    • 状态空间中从一个状态到另一个状态转换的随机过程。

    • 该过程要求具备

      “无记忆”

      的性质:

      • 下一状态的概率分布只能由当前状态决定,在时间序列中它前面的事件均与之无关

    隐马尔可夫模型(Hidden Markov Model,HMM)是统计模型,它用来描述一个含有隐含未知参数的马尔可夫过程。

    • 隐马尔可夫模型(Hidden Markov Model,HMM)是统计模型,它用来描述一个含有隐含未知参数的马尔可夫过程。

    • 常见术语

      • 可见状态链
      • 隐含状态链
      • 转换概率
      • 输出概率
    • 什么样的问题可以用HMM模型解决

      • 基于序列的,比如时间序列;
      • 问题中包含两类数据,一类是可以观测到的观测序列;另一类是不能观察到的隐藏状态序列。
    • HMM模型的两个重要假设

      • 其次马尔科夫链假设
      • 观测独立性假设
    • HMM模型的三个基本问题

      • 评估观察序列概率—— 前向后向的概率计算
      • 预测问题,也称为解码问题 ——维特比(Viterbi)算法
      • 模型参数学习问题 —— 鲍姆-韦尔奇(Baum-Welch)算法
    • 前向算法求HMM观测序列

      • 输入:HMM模型 λ=(A,B,Π),观测序列image-20200609235438949
      • 输出:观测序列概率P(O|λ)
          1. 计算时刻1的各个隐藏状态前向概率:image-20191211111014281
          1. 递推时刻2,3,… …T时刻的前向概率:image-20191211111110223
          1. 计算最终结果:image-20191211111203339
    • 后向算法求HMM观测序列

      • 输入:HMM模型 λ=(A,B,Π),观测序列image-20200609235438949
      • 输出:观测序列概率P(O|λ)
        • 初始化时刻T的各个隐藏状态后向概率:image-20191211131712030
        • 递推时刻T−1,T−2,…1时刻的后向概率:image-20191211131727431
        • 计算最终结果:image-20191211131746630

    维特比算法流程总结:

    • 输入:HMM模型 λ=(A,B,Π),观测序列image-20200610115739520
    • 输出:最有可能的隐藏状态序列image-20200610115759219

    流程如下:

    • 1)初始化局部状态:

    image-20191211153308449

      1. 进行动态规划递推时刻 t=2,3,…T 时刻的局部状态:

    image-20191211153349430

      1. 计算时刻T最大的image-20200610115901486,即为最可能隐藏状态序列出现的概率。计算时刻T最大的 image-20200610115925436,即为时刻T最可能的隐藏状态。

    image-20191211153412145

      1. 利用局部状态image-20200610115945012开始回溯。对于 t=T-1,T-2,…,1

    image-20191211153607900

    最终得到最有可能的隐藏状态序列: image-20200610120053531

    MultinomialHMM实例

    下面我们用我们在前面讲的关于球的那个例子使用MultinomialHMM跑一遍。

    import numpy as np
    from hmmlearn import hmm
    
    # 设定隐藏状态的集合
    states = ["box 1", "box 2", "box3"]
    n_states = len(states)
    
    # 设定观察状态的集合
    observations = ["red", "white"]
    n_observations = len(observations)
    
    # 设定初始状态分布
    start_probability = np.array([0.2, 0.4, 0.4])
    
    # 设定状态转移概率分布矩阵
    transition_probability = np.array([
      [0.5, 0.2, 0.3],
      [0.3, 0.5, 0.2],
      [0.2, 0.3, 0.5]
    ])
    
    # 设定观测状态概率矩阵
    emission_probability = np.array([
      [0.5, 0.5],
      [0.4, 0.6],
      [0.7, 0.3]
    ])
    
    # 设定模型参数
    model = hmm.MultinomialHMM(n_components=n_states)
    model.startprob_=start_probability  # 初始状态分布
    model.transmat_=transition_probability  # 状态转移概率分布矩阵
    model.emissionprob_=emission_probability  # 观测状态概率矩阵
    

    现在我们来跑一跑HMM问题三维特比算法的解码过程,使用和之前一样的观测序列来解码,代码如下:

    seen = np.array([[0,1,0]]).T  # 设定观测序列
    box = model.predict(seen)
    
    print("球的观测顺序为:\n", ", ".join(map(lambda x: observations[x], seen.flatten())))
    # 注意:需要使用flatten方法,把seen从二维变成一维
    print("最可能的隐藏状态序列为:\n", ", ".join(map(lambda x: states[x], box)))
    

    我们再来看看求HMM问题一的观测序列的概率的问题,代码如下:

    print(model.score(seen))
    # 输出结果是:-2.03854530992
    

    要注意的是score函数返回的是以自然对数为底的对数概率值,我们在HMM问题一中手动计算的结果是未取对数的原始概率是0.13022。对比一下:

    import math
    
    math.exp(-2.038545309915233)
    # ln0.13022≈−2.0385
    # 输出结果是:0.13021800000000003
    
    展开全文
  • hmm

    2017-04-16 22:43:14
    介绍 代码 ...class Hmm: def __init__(self, description=None): self.description = description @property def hidden_states(self): return self._hidden_states @hidden_states.sett

    介绍



    代码

    #coding:utf-8
    
    class Hmm:
    	def __init__(self, description=None):
    		self.description = description
    
    	@property
    	def hidden_states(self):
    	    return self._hidden_states
    	@hidden_states.setter
    	def hidden_states(self, vals):
    		self._hidden_states = vals
    
    	@property
    	def observed_states(self):
    	    return self._observed_states
    	@observed_states.setter
    	def observed_states(self, vals):
    		self._observed_states = vals
    
    	@property
    	def transition_matrix(self):
    	    return self._transition_matrix
    	@transition_matrix.setter
    	def transition_matrix(self, vals):
    		self._transition_matrix = vals
    
    	@property
    	def emission_matrix(self):
    	    return self._emission_matrix
    	@emission_matrix.setter
    	def emission_matrix(self, vals):
    		self._emission_matrix = vals
    
    	@property
    	def start_prob(self):
    		return self._start_prob
    	@start_prob.setter
    	def start_prob(self, val):
    		self._start_prob = val
    
    	@property
    	def final_prob(self):
    		return self._final_prob
    	@final_prob.setter
    	def final_prob(self, val):
    		self._final_prob = val
    
    	@property
    	def num_states(self):
    	    return self._num_states
    	@num_states.setter
    	def num_states(self, val):
    		self._num_states = val
    
    
    	
    	
    
    
    def hmmfunc_wrapper(func):
    	def inner_wrapper(*args, **kwargs):
    		print '*** before called method=[%s]***' % func.__name__
    		func(args, kwargs)
    		print '*** after called method=[%s]***' % func.__name__
    	return inner_wrapper
    
    import copy
    import numpy as np
    
    class HmmFunc:
    	def __init__(self, description):
    		self.description = description
    
    	def _find_start_state(self,state, src_states):
    		for i , val in enumerate(src_states):
    			if val == state:
    				return i
    		return 0
    
    	def cal_likehood(self, observerd_datas, hmm):
    
    		for j,state in enumerate(observerd_datas):
    			if j == 0:
    				#alpha(t,j) = a0(j) * emission(j,0)
    				start_idx = self._find_start_state(observerd_datas[0], hmm.observed_states)
    				alpha = [1.0 * val * hmm.emission_matrix[i][start_idx] for i , val in enumerate(hmm.start_prob)]
    				continue
    
    			tmp = [0.0] * len(alpha)
    			# Transition : N * N
    			# Emission   : N * Ob
    			# alpha(t,j) = sum_k( alpha(t-1,k)* transition(k,m) )* emission(m,j)
    			idx = self._find_start_state(state,hmm.observed_states)
    			num_states = hmm.num_states
    			for k in range(num_states):
    				sum = 0
    				for m in range(num_states):
    					sum += alpha[m] * hmm.transition_matrix[m][k]
    				#endfor m
    				tmp[k] = sum * hmm.emission_matrix[k][idx]
    			#endfor k
    			alpha = [ v for v in tmp]
    		return np.sum(alpha)
    
    	def cal_most_prob_seq(self, observerd_datas, hmm):
    		#max_probs_end in step j
    		seq_len = len(observerd_datas)
    		num_states = hmm.num_states
    		backwards = [(num_states * [1.0])] * seq_len
    		delta = [(num_states * [1.0])] * seq_len
    		for j , state in enumerate(observerd_datas):
    			if j == 0:
    				start_idx = self._find_start_state(observerd_datas[0], hmm.observed_states)
    				delta[0] = [1.0 * val * hmm.emission_matrix[i][start_idx] for i , val in enumerate(hmm.start_prob)]
    				continue
    			idx = self._find_start_state(state, hmm.observed_states)
    			for k in range(num_states):
    				max_val = -1000
    				maxid = 0
    				for m in range(num_states):
    					 tmp = delta[j-1][m] * hmm.transition_matrix[m][k]
    					 if tmp > max_val:
    					 	max_val = tmp
    					 	maxid = m
    				delta[j][k] = max_val * hmm.emission_matrix[k][idx]
    				backwards[j][k] = maxid
    		#self.backwards = backwards
    		#self.delta = delta
    		idx = self._tranverse(delta, backwards, seq_len, num_states)
    		return self._get_most_prob(idx, hmm.hidden_states)
    
    	def _tranverse(self, delta, backwards, seq_len, num_states):
    		max_val = delta[seq_len-1][0]
    		max_id  = 0
    		for key ,val in enumerate(delta[seq_len -1]):
    			if val > max_val:
    				val = max_val
    				max_id = key - 1
    
    		ret = []
    		ret.append(max_id)
    		for trs in range(seq_len -1 , 0, -1):
    			ret.append(backwards[trs][max_id])
    			max_id = backwards[trs][max_id]
    		return ret
    
    	def _get_most_prob(self, idx, hidden_states):
    		a = [ hidden_states[i] for i in idx]
    		#return a.reverse()
    		a.reverse()
    		return a
    
    	def do_inference(self):
    		pass
    
    
    if __name__ == '__main__':
    	hmm = Hmm()
    	hmm.hidden_states = ['Sunny','Cloudy','Rainy']
    	hmm.observed_states = ['Damp','Soggy','Dry','Dryish']
    	hmm.num_states = 3
    	hmm.start_prob =[0.63,0.17,0.20]
    	hmm.transition_matrix=[[0.5,0.25,0.25], [0.375,0.125,0.375],[0.125,0.675,0.375]]
    	hmm.emission_matrix=[[0.15,0.05,0.6,0.20],[0.25,0.25,0.25,0.25],[0.35,0.5,0.05,0.10]]
    	
          
    	func = HmmFunc('cal')
    	#given transition matrix, emission_matrix, init_prob , observerd_sequences to calculate probility
    	prob = func.cal_likehood(['Damp','Soggy','Dry'], hmm)
    	print prob
    	
    	#given transition matrix, emission_matrix, init_prob, observerd_sequences to calculate most prob hidden states
    	most_prob = func.cal_most_prob_seq(['Damp','Soggy','Dry'], hmm)
    	print most_prob
    	#print func.backwards
    	#print func.delta
    

    标注

    1. 参数估计未作,也即inference

    参考

    http://blog.csdn.net/likelet/article/details/7056068

    http://blog.sina.com.cn/s/blog_953f8a550100zh35.html

    http://www.52nlp.cn/?s=hmm

    <<自然语言处理综述 -第二版>>
    展开全文
  • HMM

    2019-02-18 12:17:22
  • 利用MFCC特征,采用HMM模式,实现中文数据库的情感识别。
  • hmm模型matlab代码vi-HMM 概述 我们的方法是用MATLAB编码的。 这是一种通过隐马尔可夫模型(HMM)查找SNP和Indel的新方法。 该模型将读取的比对(具有Phred + 33编码质量得分的SAM文件)和参考基因组(FASTA文件)...
  • hmm的工具箱和程序隐马尔科夫模型(Hidden Markov Model,以下简称HMM)是比较经典的机器学习模型了,它在语言识别,自然语言处理,模式识别等领域得到广泛的应用。
  • 1.12HMM中的概率问题之后向算法案例代码1.13HMM中的单个状态概率1.14HMM中的单个状态概率案例代码1.15HMM中的两个状态概率1.16HMM中的两个状态概率案例代码1.17HMM中的学习问题之监督学习案例1.18HMM中的学习问题之...
  • hmm模型matlab代码概率堆栈 概率堆叠(Prob_stack.txt):从180个底栖δ18个O记录构造概率栈。 (有关记录的详细信息,请参见[1]的metatdata表。) Prob-LR04-stack(Prob_LR04_stack.txt):从LR04内核构造的概率...
  • hmm模型matlab代码Matlab数据和代码的存储库,可从Moretto等人的论文“通过隐马尔可夫模型揭示正常衰老中的全脑动力学”中得出的数字。 代码: Code/MAIN_code_Moretto_NeuroImage.m main code to run the analyses ...
  • HMM学习PPT

    2018-09-07 08:36:34
    深入了解HMM原理,学习HMM内部结构以及算法推导公式,HMM如何应用于语音识别。
  • HMM以及CRF用于自然语音处理中的命名识别
  • hmm模型matlab代码具有Baum-Welch算法的隐马尔可夫模型 该代码是用Matlab编写的。 输入 数据:N * T矩阵,长度为T的N个数据样本 A_guess:K * K矩阵,其中K是隐藏状态数[对转换矩阵的初始猜测] E_guess:K * E矩阵,...
  • forward and backward algorithm for HMM
  • hmm模型matlab代码HMM学习算法 该存储库包含在Matlab上使用HMM模型实现的歌曲识别器机器学习系统。 训练代码已经在8首歌曲数据集上进行了测试,每首歌曲有15个样本,其中10个样本作为训练数据,5个样本作为测试数据...
  • hmm模型matlab代码PyTorch-Kaldi语音识别工具包 PyTorch-Kaldi是一个开放源代码存储库,用于开发最新的DNN / HMM语音识别系统。 DNN部分由PyTorch管理,而特征提取,标签计算和解码则由Kaldi工具包执行。 该存储库...
  • tensorflow_hmm HMM viterbi和向前/向后算法的Tensorflow和numpy实现。 见对于如何使用Keras HMMLayer一个例子。 有关用法示例,请参见 。 这是hmm.py文档的摘录,仅供参考。 另请参见viterbi_wikipedia_example...
  • PyTorch中的HMM 此存储库包含PyTorch中的隐马尔可夫模型(HMM)的代码,包括正向算法,Viterbi算法和采样。 训练是通过从正向算法反向传播负对数似然来实现的,而不是使用EM算法。 您可以阅读笔记本涵盖HMM模型和...
  • 基于HMM的频率敏感聚类方法PIFS-HMM.pdf

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,709
精华内容 11,483
关键字:

HMM