隱馬爾可夫模型（四）——隱馬爾可夫模型的評估問題(后向算法）

對於HMM的評估問題，利用動態規划可以用前向算法，從前到后算出前向變量；也可以采用后向算法，從后到前算出后向變量。

先介紹后向變量β_t(i):給定模型μ=（A,B,π），並且在時間 時刻t 狀態為s_i 的前提下，輸出序列為O_t+1O_t+2...O_T的概率，即

                                    β_t(i)=P(O_t+1O_t+2...O_T|q_t=s_i,μ)

歸納過程

    假設仍然有3個狀態

                 

    當t=T時，按照定義：時間t  狀態q_T 輸出為O_T+1......的概率，從T+1開始的輸出是不存在的（因為T時刻是終止終止狀態），即T之后是空，是個必然事件，因此β_t(i)=1,1≤1≤N

    當t=T-1時，

                          

                 β_T-1(i)=P(O_T|q_T-1=s_i,μ) = a_i1*b₁（O_T)*β_T(1)  +  a_i2*b₂（O_T)*β_T(2)  +  a_i3*b₃（O_T)*β_T(3)

      ......

    當t=1時，

       β₁(1)=P(O₂O_3...O_T|q₂=s₁,μ) = a₁₁*b₁（O₂)*β₂(1) + a₁₂*b₂（O₂)*β₂(2) + a₁₃*b₃（O₂)*β₂(3)

       β₁(2)=P(O₂O_3...O_T|q₂=s₁,μ) = a₂₁*b₁（O₂)*β₂(1) + a₂₂*b₂（O₂)*β₂(2) + a₂₃*b₃（O₂)*β₂(3)

       β₁(3)=P(O₂O_3...O_T|q₂=s₁,μ) = a₃₁*b₁（O₂)*β₂(1) + a₃₂*b₂（O₂)*β₂(2) + a₃₃*b₃（O₂)*β₂(3)

       P(O₁O₂...O_T|μ) =   

                             =  

                             =  

后向算法

    step1 初始化：β_T(i)=1, 1≤1≤N

    step2 歸納計算：

                       1≤t≤T-1, 1≤i≤N

    step3 求終結和：

                   P(O|μ）=  

時間復雜度

    計算某時刻在某個狀態下的后向變量需要看后一時刻的N個狀態，此時時間復雜度為O(N),每個時刻有N個狀態，此時時間復雜度為N*O(N)=O(N²),又有T個時刻，所以時間復雜度為T*O(N²)=O(N²T)。

程序例證

             

后向算法

    計算P(O|M)：

    step1：β₄(1) = 1          β₄(2) = 1          β₄(3) = 1

    step2：β₃(1) = β₄(1)*a₁₁*b₁(white) + β₄(2)*a₁₂*b₂(white) + β₄(3)*a₁₃*b₃(white)

                     ...

    step3:P(O|M) = π₁*β₁(1)*b₁(O₁) + π₂*β₁(2)*b₂(O₁) + π₃*β₁(3)*b₃(O₁)

程序代碼

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
        float a[3][3] = {{0.5,0.2,0.3},{0.3,0.5,0.2},{0.2,0.3,0.5}};
        float b[3][2] = {{0.5,0.5},{0.4,0.6},{0.7,0.3}};
        float result[4][3];
        int list[4] = {0,1,0,1};
        result[3][0] = 1;
        result[3][1] = 1;
        result[3][2] = 1;
        int i,j,k, count = 3;
        for (i=2; i>=0; i--)
        {
            for(j=0; j<=2; j++)
            {
                result[i][j] = 0;
                for(k=0; k<=2; k++)
                {
                   result[i][j] += result[i+1][k] * a[j][k] * b[k][list[count]];
                }
            }
            count -= 1;
        }
       for (i=0; i<=3; i++)
        {
            for(j=0; j<=2; j++)
            {
                printf("b[%d][%d] = %f\n",i+1,j+1,result[i][j]);

            }
        }
        printf("backward:%f\n", result[0][0]*0.2*0.5+result[0][1]*0.4*0.4+result[0][2]*0.4*0.7);
        return 0;
}

運行結果