白板推导系列Pytorch-隐马尔可夫模型-概率计算问题

HMM 博客汇总

• 问题三合一（为了防止部分读者厌烦，故而单独发了三个问题的博客）
• 概率计算问题
• 学习问题
• 解码问题
• 词性标注

概率计算问题（Evaluation）

给定模型 $\lambda =(A,B,\pi )$ 和观测序列 $O=\left(o_1,o_2,\cdots ,o_T\right)$ , 计算在模型 $\lambda$ 下观测序列 $O$ 出现的概率 $P(O\mid \lambda )$.

直接计算法

$$P(O|\lambda )=\sum _{I}P(O,I|\lambda )=\sum _{I}P(O|I,\lambda )\cdot P(I|\lambda )$$

前向算法

定义前向概率为
$${\alpha }_t(i)=P(o_1,o_2,...,o_t,i_t=q_i|\lambda )$$
那么我们要求的
$$P(O|\lambda )=P(o_1,o_2,...,o_T|\lambda )=\sum _i^{N}P(o_1,o_2,...,o_T,i_T=q_i|\lambda )=\sum _i{\alpha }_T(i)$$

算法过程：

（1）初值
$${\alpha }_1(i)=P(o_1,i_1=q_i|\lambda )=P(i_1|\lambda )\cdot P(o_1|i_1=qi,\lambda )={\pi }_i{b}_i(o_1)$$
（2）递推
$$\begin{array}{rl}{\alpha }_{t+1}(i)& =P(o_1,o_2,...,o_t,o_{t+1},i_{t+1}=q_i|\lambda )\\ & =P(o_1,o_2,...,o_t,i_{t+1}=q_i|\lambda )\cdot P(o_{t+1}|o_1,o_2,...,o_t,i_{t+1}=q_i|\lambda )\\ & =[\sum _{j=1}P(o_1,o_2,...,o_t,i_t=q_j,i_{t+1}=q_i|\lambda )]\cdot P(o_{t+1}|i_{t+1}=q_i)\\ & =[\sum _{j=1}P(o_1,o_2,...,o_t,i_t=q_j|\lambda )\cdot P(i_{t+1}=q_i|o_1,o_2,...,o_t,i_t=q_j,\lambda )]\cdot b_i(o_{t+1})\\ & =[\sum _{j=1}{\alpha }_t(j)\cdot P(i_{t+1}=q_i|i_t=q_j,\lambda )]\cdot b_i(o_{t+1})\\ & =[\sum _{j=1}{\alpha }_t(j)\cdot a_{ji}]\cdot b_i(o_{t+1})\end{array}$$
（3）终止
$$P(O|\lambda )=\sum _i{\alpha }_T(i)$$

算法实现

定义观测数据和$\lambda$参数（$\pi ,A,B$）

import numpy as np

O = [1,1,0,0,1]
Pi= [0.25,0.25,0.25,0.25]
A = [
    [0, 1, 0, 0 ],
    [0.4,0,0.6,0],
    [0,0.4,0,0.6],
    [0,0,0.5,0.5]
]
B = [
    [0.5,0.5],
    [0.3,0.7],
    [0.6,0.4],
    [0.8,0.2]
]

定义模型

class ForwardModel:
    def __init__(self,Pi,A,B) -> None:
        self.Pi = Pi
        self.A = A
        self.B = B
        self.T = len(A)
    def predict(self,O):
        alpha = np.zeros(shape=(self.T,),dtype=float)
        # 初值
        for i in range(self.T):
            alpha[i] = self.Pi[i]*self.B[i][O[0]]
        # 递推
        for observation in O:
            temp = np.zeros_like(alpha)
            for i in range(self.T):
                for j in range(self.T):
                    temp[i] += alpha[j]*self.A[j][i]
                temp[i] = temp[i]*self.B[i][observation]
            alpha = temp
        # 终止
        return np.sum(alpha)

预测

model = ForwardModel(Pi,A,B)
model.predict(O)

0.01164323808

读者可自行验证是否正确

后向算法

定义后向概率为
$${\beta }_t(i)=P\left(o_{t+1},o_{t+2},\cdots ,o_T\mid i_t=q_i,\lambda \right)$$
那么
$$\begin{array}{rl}P(O|\lambda )& =P(o_1,o_2,...,o_T|\lambda )\\ & =\sum _{i=1}^{N}P(o_1,o_2,...,o_T,i_1=q_i|\lambda )\\ & =\sum _{i=1}^{N}P(o_1|o_2,...,o_T,i_1=q_i,\lambda )\cdot P(o_2,...,o_T,i_1=q_i|\lambda )\\ & =\sum _{i=1}^{N}P(o_1|i_1=q_i,\lambda )\cdot P(o_2,...,o_T|i_1=q_i,\lambda )\cdot P(i_1=q_i|\lambda )\\ & =\sum _{i=1}^N{b}_i(o_1)\cdot {\beta }_1(i)\cdot {\pi }_i\end{array}$$

算法过程

（1）初值
$${\beta }_T(i)=1$$

（2）递推
$$\begin{array}{rl}{\beta }_t(i)& =P\left(o_{t+1},o_{t+2},\cdots ,o_T\mid i_t=q_i,\lambda \right)\\ & =\sum _{j=1}^{N}P\left(o_{t+1},o_{t+2},\cdots ,o_T,i_{t+1}=q_j\mid i_t=q_i,\lambda \right)\\ & =\sum _{j=1}^{N}P\left(o_{t+1},o_{t+2},\cdots ,o_T\mid i_{t+1}=q_j,i_t=q_i,\lambda \right)\cdot P(i_{t+1}=q_j|i_t=q_i,\lambda )\\ & =\sum _{j=1}^{N}P\left(o_{t+1},o_{t+2},\cdots ,o_T\mid i_{t+1}=q_j,i_t=q_i,\lambda \right)\cdot {\alpha }_{ij}\end{array}$$
接下来这个步骤很关键，根据概率图模型。。。（挖个坑，这儿差个证明）
$$\begin{array}{rl}{\beta }_t(i)& =\sum _{j=1}^{N}P(o_{t+1},...o_T|i_{t+1}=q_j,\lambda )\cdot {\alpha }_{ij}\\ & =\sum _{j=1}^{N}P(o_{t+2},...o_T|i_{t+1}=q_j,\lambda )\cdot P(o_{t+1}|o_{t+2},...o_T,i_{t+1}=q_j,\lambda )\cdot {\alpha }_{ij}\\ & =\sum _{j=1}^N{\beta }_{t+1}(j)\cdot b_j(o_{t+1})\cdot {\alpha }_{ij}\end{array}$$
（3）终止
$$\begin{array}{r}P(O|\lambda )=\sum _{i=1}^N{b}_i(o_1)\cdot {\beta }_1(i)\cdot {\pi }_i\end{array}$$

算法实现

数据和参数定义部分与上面一致，略

定义模型

class BackwardModel:
    def __init__(self,Pi,A,B) -> None:
        self.Pi = Pi
        self.A = A
        self.B = B
        self.T = len(A)

    def predict(self,O):
        # 初值
        beta = np.ones(shape=(self.T,))
        # 递推
        for o in reversed(O):
            temp = np.zeros_like(beta)
            for i in range(self.T):
                for j in range(self.T):
                    temp[i] += beta[j]*B[j][o]*A[i][j]
            beta = temp
        # 终止
        res = 0
        for i in range(self.T):
            res += B[i][O[0]]*beta[i]*Pi[i]
        return res

预测

model = BackwardModel(Pi,A,B)
model.predict(O)

0.01164323808

我们看到这跟前面使用前向算法得出的预测值是相同的