机器学习---HMM前向、后向和维特比算法的计算

news2025/1/17 2:59:55

1. HMM

import numpy as np


# In[15]:


class HiddenMarkov:
    def forward(self, Q, V, A, B, O, PI):  # 使用前向算法
        N = len(Q)  # 状态序列的大小
        M = len(O)  # 观测序列的大小
        alphas = np.zeros((N, M))  # alpha值
        T = M  # 有几个时刻，有几个观测序列，就有几个时刻
        for t in range(T):  # 遍历每一时刻，算出alpha值
            indexOfO = V.index(O[t])  # 找出序列对应的索引
            for i in range(N):
                if t == 0:  # 计算初值
                    alphas[i][t] = PI[t][i] * B[i][indexOfO]
                    print('alpha1(%d)=p%db%db(o1)=%f' % (i, i, i, alphas[i][t]))
                else:
                    alphas[i][t] = np.dot([alpha[t - 1] for alpha in alphas], [a[i] for a in A]) * B[i][
                        indexOfO]  # 递推（）
                    print('alpha%d(%d)=[sigma alpha%d(i)ai%d]b%d(o%d)=%f' % (t, i, t - 1, i, i, t, alphas[i][t]))
                    # print(alphas)
        P = np.sum([alpha[M - 1] for alpha in alphas])  # 求和终止
        # alpha11 = pi[0][0] * B[0][0]    #代表a1(1)
        # alpha12 = pi[0][1] * B[1][0]    #代表a1(2)
        # alpha13 = pi[0][2] * B[2][0]   #代表a1(3)
        print(P)
    def backward(self, Q, V, A, B, O, PI):  # 后向算法
        N = len(Q)  # 状态序列的大小
        M = len(O)  # 观测序列的大小
        betas = np.ones((N, M))  # beta
        for i in range(N):
            print('beta%d(%d)=1' % (M, i))
        for t in range(M - 2, -1, -1):
            indexOfO = V.index(O[t + 1])  # 找出序列对应的索引
            for i in range(N):
                betas[i][t] = np.dot(np.multiply(A[i], [b[indexOfO] for b in B]), [beta[t + 1] for beta in betas])
                realT = t + 1
                realI = i + 1
                print('beta%d(%d)=[sigma a%djbj(o%d)]beta%d(j)=(' % (realT, realI, realI, realT + 1, realT + 1),
                      end='')
                for j in range(N):
                    print("%.2f*%.2f*%.2f+" % (A[i][j], B[j][indexOfO], betas[j][t + 1]), end='')
                print("0)=%.3f" % betas[i][t])
        # print(betas)
        indexOfO = V.index(O[0])
        P = np.dot(np.multiply(PI, [b[indexOfO] for b in B]), [beta[0] for beta in betas])
        print("P(O|lambda)=", end="")
        for i in range(N):
            print("%.1f*%.1f*%.5f+" % (PI[0][i], B[i][indexOfO], betas[i][0]), end="")
        print("0=%f" % P)

    def viterbi(self, Q, V, A, B, O, PI):
        N = len(Q)  # 状态序列的大小
        M = len(O)  # 观测序列的大小
        deltas = np.zeros((N, M))
        psis = np.zeros((N, M))
        I = np.zeros((1, M))
        for t in range(M):
            realT = t+1
            indexOfO = V.index(O[t])  # 找出序列对应的索引
            for i in range(N):
                realI = i+1
                if t == 0:
                    deltas[i][t] = PI[0][i] * B[i][indexOfO]
                    psis[i][t] = 0
                    print('delta1(%d)=pi%d * b%d(o1)=%.2f * %.2f=%.2f'%(realI, realI, realI, PI[0][i], B[i][indexOfO], deltas[i][t]))
                    print('psis1(%d)=0' % (realI))
                else:
                    deltas[i][t] = np.max(np.multiply([delta[t-1] for delta in deltas], [a[i] for a in A])) * B[i][indexOfO]
                    print('delta%d(%d)=max[delta%d(j)aj%d]b%d(o%d)=%.2f*%.2f=%.5f'%(realT, realI, realT-1, realI, realI, realT, np.max(np.multiply([delta[t-1] for delta in deltas], [a[i] for a in A])), B[i][indexOfO], deltas[i][t]))
                    psis[i][t] = np.argmax(np.multiply([delta[t-1] for delta in deltas], [a[i] for a in A]))
                    print('psis%d(%d)=argmax[delta%d(j)aj%d]=%d' % (realT, realI, realT-1, realI, psis[i][t]))
        print(deltas)
        print(psis)
        I[0][M-1] = np.argmax([delta[M-1] for delta in deltas])
        print('i%d=argmax[deltaT(i)]=%d' % (M, I[0][M-1]+1))
        for t in range(M-2, -1, -1):
            I[0][t] = psis[int(I[0][t+1])][t+1]
            print('i%d=psis%d(i%d)=%d' % (t+1, t+2, t+2, I[0][t]+1))
        print(I)

if __name__ == '__main__':
    Q = [1, 2, 3]
    V = ['红', '白']
    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]]
    # O = ['红', '白', '红', '红', '白', '红', '白', '白']
    O = ['红', '白', '红', '白']    #例子
    PI = [[0.2, 0.4, 0.4]]
    HMM = HiddenMarkov()
#    HMM.forward(Q, V, A, B, O, PI)
    HMM.backward(Q, V, A, B, O, PI)
#     HMM.viterbi(Q, V, A, B, O, PI)

隐马尔可夫模型是一个统计模型，用于描述由隐藏的状态序列和对应的观测序列组成的系统。在这

个模型中，隐藏的状态是无法直接观测到的，而只能通过观测序列来进行推断。

前向算法（Forward Algorithm）:前向算法用于计算在给定观测序列下每个时间步长处于特定状态

的概率。前向算法利用动态规划的思想，通过递推计算每个时间步的前向概率。前向概率

（alpha）的计算公式为：alpha[t][j] = sum(alpha[t-1][i] * A[i][j] * B[j][O[t]]) for i in range(N)

其中，alpha[t][j]表示在时间步t处于状态j的概率，A[i][j]表示从状态i转移到状态j的概率，B[j]

[O[t]]表示在状态j下观测到序列中的第t个观测的概率。

后向算法（Backward Algorithm）:后向算法用于计算在给定观测序列下每个时间步从特定状态开始

的概率。后向算法同样利用动态规划的思想，通过递推计算每个时间步的后向概率。后向概率

（beta）的计算公式为： beta[t][i] = sum(A[i][j] * B[j][O[t+1]] * beta[t+1][j]) for j in range(N)，其

中，beta[t][i]表示在时间步t从状态i开始的概率，A[i][j]表示从状态i转移到状态j的概率，B[j][O[t+1]]

表示在状态j下观测到序列中的第t+1个观测的概率，beta[t+1][j]表示在时间步t+1处于状态j的概率。

维特比算法（Viterbi Algorithm）:维特比算法用于找到在给定观测序列下最可能的隐藏状态序列。

维特比算法利用动态规划的思想，通过递推计算每个时间步的最大概率和对应的状态。维特比算法

中使用的两个变量是delta和psi，分别表示到达某个状态的最大概率和之前的最优状态。 delta[t][j]

= max(delta[t-1][i] * A[i][j] * B[j][O[t]]) for i in range(N)

psi[t][j] = argmax(delta[t-1][i] * A[i][j]) for i in range(N)

其中，delta[t][j]表示在时间步t到达状态j的最大概率，psi[t][j]表示在时间步t到达状态j时的最优前一

个状态，argmax表示取最大值的索引。

import numpy as np


# In[15]:


class HiddenMarkov:
    def forward(self, Q, V, A, B, O, PI):  # 使用前向算法
        N = len(Q)  # 状态序列的大小
        M = len(O)  # 观测序列的大小
        alphas = np.zeros((N, M))  # alpha值
        T = M  # 有几个时刻，有几个观测序列，就有几个时刻
        for t in range(T):  # 遍历每一时刻，算出alpha值
            indexOfO = V.index(O[t])  # 找出序列对应的索引
            for i in range(N):
                if t == 0:  # 计算初值
                    alphas[i][t] = PI[t][i] * B[i][indexOfO]
                    print('alpha1(%d)=p%db%db(o1)=%f' % (i, i, i, alphas[i][t]))
                else:
                    alphas[i][t] = np.dot([alpha[t - 1] for alpha in alphas], [a[i] for a in A]) * B[i][
                        indexOfO]  # 递推（）
                    print('alpha%d(%d)=[sigma alpha%d(i)ai%d]b%d(o%d)=%f' % (t, i, t - 1, i, i, t, alphas[i][t]))
                    # print(alphas)
        P = np.sum([alpha[M - 1] for alpha in alphas])  # 求和终止
        # alpha11 = pi[0][0] * B[0][0]    #代表a1(1)
        # alpha12 = pi[0][1] * B[1][0]    #代表a1(2)
        # alpha13 = pi[0][2] * B[2][0]   #代表a1(3)
        print(P)
    def backward(self, Q, V, A, B, O, PI):  # 后向算法
        N = len(Q)  # 状态序列的大小
        M = len(O)  # 观测序列的大小
        betas = np.ones((N, M))  # beta
        for i in range(N):
            print('beta%d(%d)=1' % (M, i))
        for t in range(M - 2, -1, -1):
            indexOfO = V.index(O[t + 1])  # 找出序列对应的索引
            for i in range(N):
                betas[i][t] = np.dot(np.multiply(A[i], [b[indexOfO] for b in B]), [beta[t + 1] for beta in betas])
                realT = t + 1
                realI = i + 1
                print('beta%d(%d)=[sigma a%djbj(o%d)]beta%d(j)=(' % (realT, realI, realI, realT + 1, realT + 1),
                      end='')
                for j in range(N):
                    print("%.2f*%.2f*%.2f+" % (A[i][j], B[j][indexOfO], betas[j][t + 1]), end='')
                print("0)=%.3f" % betas[i][t])
        # print(betas)
        indexOfO = V.index(O[0])
        P = np.dot(np.multiply(PI, [b[indexOfO] for b in B]), [beta[0] for beta in betas])
        print("P(O|lambda)=", end="")
        for i in range(N):
            print("%.1f*%.1f*%.5f+" % (PI[0][i], B[i][indexOfO], betas[i][0]), end="")
        print("0=%f" % P)

    def viterbi(self, Q, V, A, B, O, PI):
        N = len(Q)  # 状态序列的大小
        M = len(O)  # 观测序列的大小
        deltas = np.zeros((N, M))
        psis = np.zeros((N, M))
        I = np.zeros((1, M))
        for t in range(M):
            realT = t+1
            indexOfO = V.index(O[t])  # 找出序列对应的索引
            for i in range(N):
                realI = i+1
                if t == 0:
                    deltas[i][t] = PI[0][i] * B[i][indexOfO]
                    psis[i][t] = 0
                    print('delta1(%d)=pi%d * b%d(o1)=%.2f * %.2f=%.2f'%(realI, realI, realI, PI[0][i], B[i][indexOfO], deltas[i][t]))
                    print('psis1(%d)=0' % (realI))
                else:
                    deltas[i][t] = np.max(np.multiply([delta[t-1] for delta in deltas], [a[i] for a in A])) * B[i][indexOfO]
                    print('delta%d(%d)=max[delta%d(j)aj%d]b%d(o%d)=%.2f*%.2f=%.5f'%(realT, realI, realT-1, realI, realI, realT, np.max(np.multiply([delta[t-1] for delta in deltas], [a[i] for a in A])), B[i][indexOfO], deltas[i][t]))
                    psis[i][t] = np.argmax(np.multiply([delta[t-1] for delta in deltas], [a[i] for a in A]))
                    print('psis%d(%d)=argmax[delta%d(j)aj%d]=%d' % (realT, realI, realT-1, realI, psis[i][t]))
        print(deltas)
        print(psis)
        I[0][M-1] = np.argmax([delta[M-1] for delta in deltas])
        print('i%d=argmax[deltaT(i)]=%d' % (M, I[0][M-1]+1))
        for t in range(M-2, -1, -1):
            I[0][t] = psis[int(I[0][t+1])][t+1]
            print('i%d=psis%d(i%d)=%d' % (t+1, t+2, t+2, I[0][t]+1))
        print(I)

if __name__ == '__main__':
    Q = [1, 2, 3]
    V = ['红', '白']
    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]]
    # O = ['红', '白', '红', '红', '白', '红', '白', '白']
    O = ['红', '白', '红', '白']    #例子
    PI = [[0.2, 0.4, 0.4]]
    HMM = HiddenMarkov()
#    HMM.forward(Q, V, A, B, O, PI)
#    HMM.backward(Q, V, A, B, O, PI)
    HMM.viterbi(Q, V, A, B, O, PI)

前向算法（Forward Algorithm）：前向算法用于计算给定观测序列下每个时刻的前向概率

（alpha），表示在当前时刻观测到特定状态的概率。通过递推计算，利用前一时刻的前向概率和

状态转移概率、发射概率来计算当前时刻的前向概率。数学公式：alpha[i][t] = PI[t][i] * B[i]

[indexOfO]，其中alpha[i][t]表示在时刻t处于状态i的前向概率，PI[t][i]表示初始状态概率，B[i]

[indexOfO]表示在状态i观测到观测序列的概率。

后向算法（Backward Algorithm）：后向算法用于计算给定观测序列下每个时刻的后向概率

（beta），表示从当前时刻开始，在未来时刻观测到特定状态的概率。通过递推计算，利用后一时

刻的后向概率和状态转移概率、发射概率来计算当前时刻的后向概率。数学公式：beta[i][t] = Σ(A[i]

[j] * B[j][indexOfO] * beta[j][t+1])，其中beta[i][t]表示在时刻t处于状态i的后向概率，A[i][j]表示状态i

转移到状态j的概率，B[j][indexOfO]表示在状态j观测到观测序列的概率。

维特比算法（Viterbi Algorithm）：维特比算法用于找到给定观测序列下最可能的隐藏状态序列，

即根据观测序列推断出最可能的隐藏状态路径。通过动态规划的方式，利用状态转移概率、发射概

率和初始状态概率，计算每个时刻每个状态的最大概率值和对应的前一个状态。数学公式：delta[i]

[t] = max(delta[t-1][j] * A[j][i]) * B[i][indexOfO]，其中delta[i][t]表示在时刻t处于状态i的最大概率值，

A[j][i]表示状态j转移到状态i的概率，B[i][indexOfO]表示在状态i观测到观测序列的概率。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1450219.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

大学建筑专业的搜题软件？大学搜题工具中的高级搜索功能有哪些？ #学习方法#微信#经验分享

大学建筑专业的搜题软件？大学搜题工具中的高级搜索功能有哪些？ #学习方法#微信#经验分享

学习和考试是大学生生活中不可避免的一部分，而在这个信息爆炸的时代，如何快速有效地获取学习资源和解答问题成为了大学生们共同面临的难题。为了解决这个问题，搜题和学习软件应运而生。今天，我将为大家介绍几款备受大学生青睐的搜…
阅读更多...
[Vue warn]: Duplicate keys detected: ‘1‘. This may cause an update error.

[Vue warn]: Duplicate keys detected: ‘1‘. This may cause an update error.

[Vue warn]: Duplicate keys detected: ‘1‘. This may cause an update error.——> Vue报错，key关键字不唯一： 解决办法：修改一下重复的id值！！！
阅读更多...
安卓自定义画板

安卓自定义画板

包含功能： 包含 获取当前画板的截图、设置画笔样式、获取画笔样式、设置画笔宽度、获取画笔宽度、设置画笔颜色、获取画笔颜色、加载图片、获取图片位图对象、设置图片位图对象，并在画布上绘制图片、撤销上一步操作、重做上一步撤销的操作、清空所有绘图…
阅读更多...
.net和jar包windows服务部署

.net和jar包windows服务部署

一.NetCore 1.创建启动脚本run_instal.bat,例如程序文件为ApiDoc.exe set serviceName"Apidoc Web 01" set serviceFilePath%~dp0ApiDoc.exe set serviceDescription"ApiDoc 动态接口服务 web 01"sc create %serviceName% BinPath%serviceFilePath% sc c…
阅读更多...
TiDB 在医疗保障信息平台的应用实践

TiDB 在医疗保障信息平台的应用实践

文章介绍了 TiDB 在医疗保障信息平台中的应用。东软医保云应用管理平台通过与 TiDB 联合，成功满足了医疗保障业务中高并发、实时性和复杂查询的要求。在某地市医疗保障信息平台的实践中，TiDB 分布式数据库有效实现了在线交易和实时分析服务，日…
阅读更多...
5种风格非常经典的免费wordpress主题

5种风格非常经典的免费wordpress主题

免费wordpress主题下载 高端大气上档次的wordpress主题，也可以是免费的，可以在线免费下载。 https://www.wpniu.com/themes/288.html wordpress免费主题 高端大气的wordpress免费主题，LOGO在顶部左侧，导航菜单在顶部右侧。 ht…
阅读更多...
2007-2021年上市公司内控信息披露指数/上市公司内部控制信息披露指数数据

2007-2021年上市公司内控信息披露指数/上市公司内部控制信息披露指数数据

2007-2021年上市公司内控信息披露指数/上市公司内部控制信息披露指数数据 1、时间：2007-2021年 2、范围：上市公司 3、指标：证券代码、证券简称、辖区、证监会行业、申万行业、内部环境、风险评估、控制活动、信息与沟通、内部监督、内部控…
阅读更多...
使用人工智能增强人类能力的开源框架

使用人工智能增强人类能力的开源框架

主要特征 创建它是为了让人类能够轻松地通过人工智能增强自己。我认为目前人们使用人工智能太困难了。我认为工具太多，网站太多，而将问题与解决方案结合起来的实际用例太少。Fabric 是解决这些问题的一种方法。 它的最佳功能是它的模式，即使…
阅读更多...
【MySQL/Redis】如何实现缓存一致

【MySQL/Redis】如何实现缓存一致

目录 不实用的方案 1. 先写 MySQL , 再写 Redis 2. 先写 Redis ， 再写MySQL 3. 先删 Redis，再写 MySQL 实用的方案 1. 先删 Redis，再写 MySQL, 再删 Redis 2. 先写 MySQL , 再删 Redis 3. 先写MySQL，通过BinLog&#xff0…
阅读更多...
Redis面试题整理（持续更新）

Redis面试题整理（持续更新）

1. 缓存穿透？ 缓存穿透是指查询一个一定不存在的数据，如果从存储层查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到 DB 去查询，可能导致DB挂掉，这种情况大概率是遭到了攻击。 解决方案： …
阅读更多...
MySQL 基础知识（三）之数据库操作

MySQL 基础知识（三）之数据库操作

目录 1 显示当前时间、用户名、数据库版本 2 查看已有数据库 3 创建数据库 4 使用数据库 5 查看当前使用的数据库 6 查看当前数据库信息 7 查看数据库编码 8 修改数据库信息 9 删除数据库 10 查看最大连接数 11 查看数据库当前连接数，并发数 12 查看数据…
阅读更多...
ch5-homework-基于LMDeploy的大模型量化部署实践

ch5-homework-基于LMDeploy的大模型量化部署实践

ch5-homework-基于LMDeploy的大模型量化部署实践 主要内容教程复现环境配置服务部署模型转换在线转换离线转换 TurboMind 推理命令行本地对话TurboMind推理API服务网页 Demo 演示TurboMind 服务作为后端TurboMind 推理作为后端 TurboMind 推理 Python 代码集成最佳实践方案实践…
阅读更多...
第三十回 张都监血溅鸳鸯楼 武行者夜走蜈蚣岭-python可接受任意数量参数的函数

第三十回 张都监血溅鸳鸯楼 武行者夜走蜈蚣岭-python可接受任意数量参数的函数

武松回到孟州城，来到张都监后花园墙外，这是一个马院，问清楚后槽张团练他们三人还在鸳鸯楼吃酒，直接一刀杀了。武松从后门这里爬过墙，来到了厨房，将两个还在服侍的丫环杀了。 武松认得路，蹑手蹑…
阅读更多...
网络爬虫实战 | 上传以及下载处理后的文件

网络爬虫实战 | 上传以及下载处理后的文件

以实现爬虫一个简单的（SimFIR (doctrp.top)）网址为例，需要遵循几个步骤： 1. 分析网页结构 首先，需要分析该网页的结构，了解图片是如何存储和组织的。这通常涉及查看网页的HTML源代码，可能还包…
阅读更多...
【剪辑必备】今天我教你如何手动去下载苹果官网4K预告片 完全免费

【剪辑必备】今天我教你如何手动去下载苹果官网4K预告片 完全免费

🚀 个人主页 极客小俊 ✍🏻 作者简介：web开发者、设计师、技术分享博主 🐋 希望大家多多支持一下, 我们一起学习和进步！😄 🏅 如果文章对你有帮助的话，欢迎评论 💬点赞&a…
阅读更多...
问题：用来表示证券收益的波动性，值越大说明()。 #媒体#经验分享

问题：用来表示证券收益的波动性，值越大说明()。 #媒体#经验分享

问题：用来表示证券收益的波动性，值越大说明()。 A.风险大 B.风险小 C.不确定 D.风险固定 参考答案如图所示
阅读更多...
MySQL5.7升级到MySQL8.0的最佳实践分享

MySQL5.7升级到MySQL8.0的最佳实践分享

一、前言 事出必有因，在这个月的某个项目中，我们面临了一项重要任务，即每年一次的等保测评整改。这次测评的重点是Mysql的一些高危漏洞，客户要求我们无论如何必须解决这些漏洞。尽管我们感到无奈，但为了满足客户的要求…
阅读更多...
命令行参数和环境变量

命令行参数和环境变量

命令行参数 命令行参数是在用户在命令行中输入命令时，跟随命令一起输入的一些附加信息。这些参数可以用来配置命令的行为或传递一些数据给命令。 让同样的程序在不同的命令行参数下运行出不同的结果！ 将这些命令和参数可以传给 main 函数生&#xff0…
阅读更多...
(15)Hive调优——数据倾斜的解决指南

(15)Hive调优——数据倾斜的解决指南

目录 前言 一、什么是数据倾斜 二、发生数据倾斜的表现 2.1 MapReduce任务 2.2 Spark任务 三、如何定位发生数据倾斜的代码 四、发生数据倾斜的原因 3.1 key分布不均匀 3.1.1 某些key存在大量相同值 3.1.2 存在大量异常值或空值 3.2 业务数据本身的特性 3.3 SQL语句…
阅读更多...
【更新】企业数字化转型-年度报告175个词频、文本统计

【更新】企业数字化转型-年度报告175个词频、文本统计

数据说明： 这份数据含数字化转型175个词频、各维度水平，保留2000-2021年数据。参考吴非、赵宸宇两位老师做法，根据上市公司年报文本，整理数字化转型175个词频数据，希望对大家有所帮助。 参考管理世界中吴非&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023