HMM 评估问题

前向算法

初始概率矩阵π=(1,0,0),即开始处于状态1。
HMM模型如下，试根据前向算法计算产生观察符号序列O={ABAB}的概率。

概率流向：

    /**
     * 前向算法内容 时间复杂度O(T*N^2)
     * 
     * @param hmm
     *            HMM模型
     * @param o
     *            观察序列
     * @return 观察序列概率
     */
    public static double standard(HMM hmm, int[] o) {
        double sum;
        double pprob = 0;
        double[][] alpha = new double[hmm.N][hmm.N];
        // 初始化t=1
        for (int i = 0; i < hmm.N; i++) {
            // 时间0观察状态为o[0]隐状态为i的概率=初始概率*从第i个隐状态到观察状态o[0]（初始值）的概率
            alpha[0][i] = hmm.pi[i] * hmm.B[i][o[0]];
        }
        // 递归
        for (int t = 0; t < o.length - 1; t++) {
            // 上一个的时间递归
            for (int j = 0; j < hmm.N; j++) {
                // 下一个隐状态递归
                sum = 0;
                for (int i = 0; i < hmm.N; i++) {
                    // 上一个隐状态的递归
                    // 概率和=从第i个隐状态到第j的隐状态的概率之和
                    sum += alpha[t][i] * hmm.A[i][j];
                }
                // 下一个时间t隐状态为j的观察状态为o[t+1]的概率
                alpha[t + 1][j] = sum * hmm.B[j][o[t + 1]];

            }
        }
        // 最终时间t所有隐状态下的观察状态为o[o.length-1]的和
        for (int i = 0; i < hmm.N; i++) {
            pprob += alpha[o.length - 1][i];
        }
        return pprob;
    }

后向算法

定义：给定λ，定义到时刻t状态为qi的前提下，从t+1到T的部分观测序列为ot+1,ot+2…oT的概率为后向概率，记做：

可以递推的求得后向概率βt(i)及观测序列概率P(O|λ)
为了计算在时刻t状态为qi条件下时刻t+1之后的观测序列为ot+1,ot+2…oT的后向概率βt(i)，只需要考虑在时刻t+1所有可能的N个状态qj的转移概率(aij项)，以及在此状态下的观测ot+1的观测概率(bjot+1)项，然后考虑状态qj之后的观测序列的后向概率βt+1(j)

    /**
     * 后向算法内容 时间复杂度和前向一样
     * 
     * @param hmm
     *            HMM模型
     * @param o
     *            观察序列
     * @return 这里返回观察序列的概率
     */
    public static double standard(HMM hmm, int[] o) {

        double pprob = 0;
        double sum;
        double[][] beta = new double[o.length][hmm.N];

        // 初始化
        for (int i = 0; i < hmm.N; i++) {
            // 下一个已经确定发生为前提
            // 时间为o.length-1隐状态为i观察状态为o[o.length-1]的概率均为1
            beta[o.length - 1][i] = 1;
        }
        // 迭代计算
        for (int t = o.length - 2; t >= 0; t--) {
            // 上一个时间t
            for (int i = 0; i < hmm.N; i++) {
                // 上一个隐状态i
                sum = 0;
                for (int j = 0; j < hmm.N; j++) {
                    // 下一个隐状态j
                    // a:i->j的转移概率*隐状态j发生观察状态o[t + 1]的概率=当前状态i转移到下一状态j且出现o[t +
                    // 1]的概率
                    // a*之后所发生的概率=完整的概率
                    sum += hmm.A[i][j] * hmm.B[j][o[t + 1]] * beta[t + 1][j];
                }
                beta[t][i] = sum;
            }
        }
        // 整个序列发生的概率
        for (int i = 0; i < hmm.N; i++) {
            // 初始状态i且观察状态o[0]的概率*之后所发生的概率
            pprob += hmm.pi[i] * hmm.B[i][o[0]] * beta[0][i];
        }
        return pprob;
    }

前向算法和后向算法的联系

单个状态的概率

求给定模型λ和观测O，在时刻t处于状态qi的概率。
记：

在每个时刻t选择在该时刻最有可能出现的状态it*，从而得到一个状态序列I*={i1*, i2*… iT*}，将它作为预测的结果。
给定模型和观测序列，时刻t处于状态qi的概率为：

两个状态的联合概率

求给定模型λ和观测O，在时刻t处于状态qi并且时刻t+1处于状态qj的概率。