开发工具：

Visual Studio v2010

.NET Framework 4 Client Profile

版本历史：

V1.1 2011年06月09日

• 修正UMDHMM在Baum-Welch算法中存在的模型参数调整错误。

 

V1.0 2011年06月08日

• 将C语言实现的隐马尔科夫模型算法（UMDHMM）改为C#语言实现。

功能描述：

• 前向算法（forward algorithm）：给定HMM求一个观察序列的概率（评估）
• 后向算法（backward algorithm）：给定HMM求一个观察序列的概率（评估）
• 前向-后向算法（forward-backward algorithm）：根据观察序列生成隐马尔科夫模型（学习）
• 维特比算法（Viterbi algorithm）：搜索最有可能生成一个观察序列的隐藏状态序列（解码）

下载地址：

隐马尔科夫模型.zip

源代码：

HMM.cs（类构造函数）

/* ---------------------------------------------------------- 文件名称：HMM.cs作者：秦建辉MSN：splashcn@msn.com QQ：36748897版本历史：V1.1 2011年06月09日修正UMDHMM在Baum-Welch算法中存在的模型参数调整错误。V1.0 2011年06月08日将C语言实现的隐马尔科夫模型算法（UMDHMM）改为C#语言实现。功能描述：1.前向算法（forward algorithm）：给定HMM求一个观察序列的概率（评估）2.后向算法（backward algorithm）：给定HMM求一个观察序列的概率（评估）3.前向-后向算法（forward-backward algorithm）：根据观察序列生成隐马尔科夫模型（学习）4.维特比算法（Viterbi algorithm）：搜索最有可能生成一个观察序列的隐藏状态序列（解码）参考资料：C代码：http://www.kanungo.com/software/umdhmm-v1.02.zip学习资料：http://www.52nlp.cn/category/hidden-markov-model------------------------------------------------------------ */ using System;namespace Splash {public partial class HMM{/// <summary>/// 隐藏状态数目 N/// </summary>public readonly Int32 N;/// <summary>/// 观察符号数目 M/// </summary>public readonly Int32 M; /// <summary>/// 状态转移矩阵 A/// </summary>public Double[,] A;/// <summary>/// 混淆矩阵（confusion matrix）B/// </summary>public Double[,] B;/// <summary>/// 初始概率向量 PI/// </summary>public Double[] PI;/// <summary>/// 构造函数/// </summary>/// <param name="StatesNum">隐藏状态数目</param>/// <param name="ObservationSymbolsNum">观察符号数目</param>public HMM(Int32 StatesNum, Int32 ObservationSymbolsNum){N = StatesNum; // 隐藏状态数目M = ObservationSymbolsNum; // 观察符号数目A = new Double[N, N]; // 状态转移矩阵B = new Double[N, M]; // 混淆矩阵 PI = new Double[N]; // 初始概率向量} } }

Viterbi.cs（维特比算法）

using System;namespace Splash {partial class HMM{/// <summary>/// 维特比算法：通过给定的观察序列，推算出可能性最大的隐藏状态序列/// Viterbi Algorithm: Finding most probable sequence of hidden states/// </summary>/// <param name="OB">已知的观察序列</param>/// <param name="Probability">可能性最大的隐藏状态序列的概率</param>/// <returns>可能性最大的隐藏状态序列</returns>/// <remarks>使用双精度运算，不输出中间结果</remarks>public Int32[] Viterbi(Int32[] OB, out Double Probability){Double[,] DELTA;Int32[,] PSI;return Viterbi(OB, out DELTA, out PSI, out Probability);}/// <summary>/// 维特比算法：通过给定的观察序列，推算出可能性最大的隐藏状态序列/// </summary>/// <param name="OB">已知的观察序列</param>/// <param name="DELTA">输出中间结果：局部最大概率</param>/// <param name="PSI">输出中间结果：反向指针指示最可能路径</param>/// <param name="Probability">可能性最大的隐藏状态序列的概率</param>/// <returns>可能性最大的隐藏状态序列</returns> /// <remarks>使用双精度运算，且输出中间结果</remarks>public Int32[] Viterbi(Int32[] OB, out Double[,] DELTA, out Int32[,] PSI, out Double Probability){ DELTA = new Double[OB.Length, N]; // 局部概率PSI = new Int32[OB.Length, N]; // 反向指针// 1. 初始化for (Int32 j = 0; j < N; j++){DELTA[0, j] = PI[j] * B[j, OB[0]];}// 2. 递归for (Int32 t = 1; t < OB.Length; t++){for (Int32 j = 0; j < N; j++){Double MaxValue = DELTA[t - 1, 0] * A[0, j];Int32 MaxValueIndex = 0;for (Int32 i = 1; i < N; i++){Double Value = DELTA[t - 1, i] * A[i, j];if (Value > MaxValue){MaxValue = Value;MaxValueIndex = i;}}DELTA[t, j] = MaxValue * B[j, OB[t]];PSI[t, j] = MaxValueIndex; // 记录下最有可能到达此状态的上一个状态}}// 3. 终止Int32[] Q = new Int32[OB.Length]; // 定义最佳路径Probability = DELTA[OB.Length - 1, 0];Q[OB.Length - 1] = 0;for (Int32 i = 1; i < N; i++){if (DELTA[OB.Length - 1, i] > Probability){Probability = DELTA[OB.Length - 1, i];Q[OB.Length - 1] = i;}}// 4. 路径回溯for (Int32 t = OB.Length - 2; t >= 0; t--){Q[t] = PSI[t + 1, Q[t + 1]];}return Q;}/// <summary>/// 维特比算法：通过给定的观察序列，推算出可能性最大的隐藏状态序列/// </summary>/// <param name="OB">已知的观察序列</param>/// <param name="Probability">可能性最大的隐藏状态序列的概率</param>/// <returns>可能性最大的隐藏状态序列</returns>/// <remarks>使用对数运算，不输出中间结果</remarks>public Int32[] ViterbiLog(Int32[] OB, out Double Probability){Double[,] DELTA;Int32[,] PSI; return ViterbiLog(OB, out DELTA, out PSI, out Probability);}/// <summary>/// 维特比算法：通过给定的观察序列，推算出可能性最大的隐藏状态序列/// </summary>/// <param name="OB">已知的观察序列</param>/// <param name="DELTA">输出中间结果：局部最大概率。结果为自然对数值</param>/// <param name="PSI">输出中间结果：反向指针指示最可能路径</param>/// <param name="Probability">可能性最大的隐藏状态序列的概率</param>/// <returns>可能性最大的隐藏状态序列</returns> /// <remarks>使用对数运算，且输出中间结果</remarks>public Int32[] ViterbiLog(Int32[] OB, out Double[,] DELTA, out Int32[,] PSI, out Double Probability){ DELTA = new Double[OB.Length, N]; // 局部概率PSI = new Int32[OB.Length, N]; // 反向指针// 0. 预处理Double[,] LogA = new Double[N, N];for (Int32 i = 0; i < N; i++){for (Int32 j = 0; j < N; j++){LogA[i, j] = Math.Log(A[i, j]);}}Double[,] LogBIOT = new Double[N, OB.Length];for (Int32 i = 0; i < N; i++){for (Int32 t = 0; t < OB.Length; t++){LogBIOT[i, t] = Math.Log(B[i, OB[t]]);}}Double[] LogPI = new Double[N];for (Int32 i = 0; i < N; i++){LogPI[i] = Math.Log(PI[i]);}// 1. 初始化for (Int32 j = 0; j < N; j++){DELTA[0, j] = LogPI[j] + LogBIOT[j, 0];}// 2. 递归for (Int32 t = 1; t < OB.Length; t++){for (Int32 j = 0; j < N; j++){Double MaxValue = DELTA[t - 1, 0] + LogA[0, j];Int32 MaxValueIndex = 0;for (Int32 i = 1; i < N; i++){Double Value = DELTA[t - 1, i] + LogA[i, j];if (Value > MaxValue){MaxValue = Value;MaxValueIndex = i;}}DELTA[t, j] = MaxValue + LogBIOT[j, t];PSI[t, j] = MaxValueIndex; // 记录下最有可能到达此状态的上一个状态}}// 3. 终止Int32[] Q = new Int32[OB.Length]; // 定义最佳路径Probability = DELTA[OB.Length - 1, 0];Q[OB.Length - 1] = 0;for (Int32 i = 1; i < N; i++){if (DELTA[OB.Length - 1, i] > Probability){Probability = DELTA[OB.Length - 1, i];Q[OB.Length - 1] = i;}}// 4. 路径回溯Probability = Math.Exp(Probability);for (Int32 t = OB.Length - 2; t >= 0; t--){Q[t] = PSI[t + 1, Q[t + 1]];}return Q;}} }

Forward.cs（前向算法）

using System;namespace Splash {partial class HMM{/// <summary>/// 前向算法：计算观察序列的概率/// Forward Algorithm: Finding the probability of an observed sequence/// </summary>/// <param name="OB">已知的观察序列</param>/// <returns>观察序列的概率</returns>/// <remarks>使用双精度运算，不输出中间结果</remarks>public Double Forward(Int32[] OB){Double[,] ALPHA; // 只声明，不定义return Forward(OB, out ALPHA);}/// <summary>/// 前向算法：计算观察序列的概率/// </summary>/// <param name="OB">已知的观察序列</param>/// <param name="ALPHA">输出中间结果：局部概率</param>/// <returns>观察序列的概率</returns>/// <remarks>使用双精度运算，输出中间结果</remarks>public Double Forward(Int32[] OB, out Double[,] ALPHA){ ALPHA = new Double[OB.Length, N]; // 局部概率// 1. 初始化：计算初始时刻所有状态的局部概率for (Int32 j = 0; j < N; j++){ALPHA[0, j] = PI[j] * B[j, OB[0]];}// 2. 归纳：递归计算每个时间点的局部概率for (Int32 t = 1; t < OB.Length; t++){for (Int32 j = 0; j < N; j++){Double Sum = 0;for (Int32 i = 0; i < N; i++){Sum += ALPHA[t - 1, i] * A[i, j];}ALPHA[t, j] = Sum * B[j, OB[t]];}}// 3. 终止：观察序列的概率等于最终时刻所有局部概率之和Double Probability = 0;for (Int32 i = 0; i < N; i++){Probability += ALPHA[OB.Length - 1, i];}return Probability;}/// <summary>/// 带比例因子修正的前向算法：计算观察序列的概率/// </summary>/// <param name="OB">已知的观察序列</param>/// <param name="ALPHA">中间结果：局部概率</param>/// <param name="SCALE">中间结果：比例因子</param>/// <returns>观察序列的概率（自然对数值）</returns>private Double ForwardWithScale(Int32[] OB, ref Double[,] ALPHA, ref Double[] SCALE){if(ALPHA == null) ALPHA = new Double[OB.Length, N];if(SCALE == null) SCALE = new Double[OB.Length];// 1. 初始化SCALE[0] = 0;for (Int32 j = 0; j < N; j++){ALPHA[0, j] = PI[j] * B[j, OB[0]];SCALE[0] += ALPHA[0, j];}for (Int32 j = 0; j < N; j++){ALPHA[0, j] /= SCALE[0];}// 2. 归纳for (Int32 t = 1; t < OB.Length; t++){SCALE[t] = 0;for (Int32 j = 0; j < N; j++){Double Sum = 0;for (Int32 i = 0; i < N; i++){Sum += ALPHA[t - 1, i] * A[i, j];}ALPHA[t, j] = Sum * B[j, OB[t]];SCALE[t] += ALPHA[t, j];}for (Int32 j = 0; j < N; j++){ALPHA[t, j] /= SCALE[t];}} // 3. 终止Double Probability = 0;for (Int32 t = 0; t < OB.Length; t++){Probability += Math.Log(SCALE[t]);}return Probability; // 自然对数值}} }

Backward.cs（后向算法）

using System;namespace Splash {partial class HMM{/// <summary>/// 后向算法：计算观察序列的概率/// </summary>/// <param name="OB">已知的观察序列</param>/// <returns>观察序列的概率</returns>public Double Backward(Int32[] OB){Double[,] BETA; // 只声明，不定义return Backward(OB, out BETA);}/// <summary>/// 后向算法：计算观察序列的概率/// </summary>/// <param name="OB">已知的观察序列</param>/// <param name="BETA">中间结果</param>/// <returns>观察序列的概率</returns>public Double Backward(Int32[] OB, out Double[,] BETA){ BETA = new Double[OB.Length, N];// 初始化for (Int32 j = 0; j < N; j++){BETA[OB.Length - 1, j] = 1.0;}// 归纳for (Int32 t = OB.Length - 2; t >= 0; t--){for (Int32 j = 0; j < N; j++){Double Sum = 0;for (Int32 i = 0; i < N; i++){Sum += A[j, i] * B[i, OB[t + 1]] * BETA[t + 1, i];}BETA[t, j] = Sum;}}// 终止Double Probability = 0;for (Int32 i = 0; i < N; i++){Probability += BETA[0, i];}return Probability;}/// <summary>/// 带比例因子修正的后向算法/// </summary>/// <param name="OB">已知的观察序列</param>/// <param name="SCALE">用于修正的比例因子</param>/// <param name="BETA">中间结果：局部概率</param>private void BackwardWithScale(Int32[] OB, Double[] SCALE, ref Double[,] BETA){if(BETA == null) BETA = new Double[OB.Length, N];// 初始化for (Int32 j = 0; j < N; j++){BETA[OB.Length - 1, j] = 1.0 / SCALE[OB.Length - 1];}// 归纳for (Int32 t = OB.Length - 2; t >= 0; t--){for (Int32 j = 0; j < N; j++){Double Sum = 0;for (Int32 i = 0; i < N; i++){Sum += A[j, i] * B[i, OB[t + 1]] * BETA[t + 1, i];}BETA[t, j] = Sum / SCALE[t];}}}} }

BaumWelch.cs（前向-后向算法）