一般使用前向算法解决评估问题。所谓评估问题就是，已知一个HMM，还有一个观察序列，求在这个HMM下这个观察序列的概率。
我们还是举那个天气海藻的例子。假定初始概率PI，转移矩阵A，观察矩阵B都已知了，我们现在有一个观察序列：dry，damp，soggy，求p（dry, damp, soggy | HMM）的概率。
我们先列出已知的参数：
有三个隐藏状态：sunny，cloudy，rainy
状态转移矩阵：
yesterday | |||||
| Sunny | Cloudy | Rainy | |||
|---|---|---|---|---|---|
| Sunny | 0.500 | 0.375 | 0.125 | ||
| Cloudy | 0.250 | 0.125 | 0.625 | ||
| Rainy | 0.250 | 0.375 | 0.375 | ||
有四个观察状态：dry，dryish，damp，soggy
观察矩阵：
states | ||||||
| Dry | Dryish | Damp | Soggy | |||
|---|---|---|---|---|---|---|
| Sunny | 0.60 | 0.20 | 0.15 | 0.05 | ||
| Cloudy | 0.25 | 0.25 | 0.25 | 0.25 | ||
| Rainy | 0.05 | 0.10 | 0.35 | 0.50 | ||
初始概率PI：
| Sunny | 0.63 |
|---|---|
| Cloudy | 0.17 |
| Rainy | 0.20 |
已知的观察序列：dry，damp，soggy
显然有3个观察时刻，假定t=0观察到 dry, t=1 观察到damp, t=2 观察到 soggy
前向算法步骤：
一、 根据初始概率PI，观察矩阵，计算t=0时刻，p( dry(t=0) | (sunny, cloudy, rainy))的值，同时把计算出来的值保存到alpha这个二维数组中。
// t=0 dry | sunny
alpha[0][0] = PI[0] * p(dry | sunny) = 0.63 * 0.60 = 0.378
// t=0 dry | cloudy
alpha[1][0] = PI[1] * p(dry | cloudy) = 0.17 * 0.25 = 0.0425
// t=0 dry | rainy
alpha[2][0] = PI[2] * p(dry | rainy) = 0.20 * 0.05 = 0.01
二、计算t=（i < T）的概率，保存到alpha数组
可以用下面的公式来概括
其中，a表示转移矩阵，b表示观察矩阵，t表示当前观察序列的时刻，n表示的是有多少个隐藏状态。
三、当计算到最后一个时刻时，将最后这个时刻下三个状态的概率相加。
前向算法java代码如下：
package cn.yunzhisheng.hmm;
publicclass HMM {
publicint M = 3;
// 转移矩阵
publicdouble[][] transferMatix = {
{0.500, 0.375, 0.125},
{0.250, 0.125, 0.625},
{0.250, 0.375, 0.375}
};
// 观察矩阵
publicdouble[][] observationMatix = {
{0.60, 0.20, 0.15, 0.05},
{0.25, 0.25, 0.25, 0.25},
{0.05, 0.10, 0.35, 0.50}
};
// 初始概率
publicdouble[] pi = {0.63, 0.17, 0.20};
// 前向算法
publicdouble forward(int[] seq){
// 保存中间计算结果的alpha矩阵
int T = seq.length;
double [][] alpha = newdouble[M][T];
double sum = 0.0;
double prob = 0.0;
// t = 0 用初始概率乘以相应观察矩阵的概率，保存到alpha的第一列中
for(int j = 0; j < M; j++){
alpha[j][0] = pi[j] * observationMatix[j][seq[0]];
}
// 从t=1循环计算带T-1
for(int t = 1; t < T; t++){
// t时刻 M个隐藏状态
for(int j = 0; j < M; j++){
sum = 0.0;
for(int i = 0; i < M; i++){
// 根据t-1时刻的值 乘以转移矩阵的概率 得到t时刻的概率，然后将所有隐藏状态的概率相加
sum += alpha[i][t-1] * transferMatix[i][j];
}
// sum 乘以 观察矩阵的概率 保存到alpha[j][t] 数组中
alpha[j][t] = sum * observationMatix[j][seq[t]];
}
}
// t = T-1 已经是最后一个时刻，将3个状态的概率相加
for(int j = 0; j < M; j++){
prob += alpha[j][T-1];
}
return prob;
}
publicstaticvoid main(String[] args) {
HMM hmm = new HMM();
// 观察序列
int [] seq = {0, 2, 3};
// 前向算法
double p = hmm.forward(seq);
System.out.println(p);
}
}
计算出来的结果是：
0.026901406250000003
