[学习笔记] [机器学习] 12. [下] HMM 隐马尔可夫算法（马尔科夫链、HMM 三类问题、前后后向算法、维特比算法、鲍姆-韦尔奇算法、API 及实例）

5. 维特比算法解码隐藏状态序列 $Q$

学习目标：

• 知道维特比算法解码隐藏状态序列 $Q$

---

在本篇我们会讨论维特比算法解码隐藏状态序列 $Q$，即给定模型 $\lambda$ 和观测序列 $O$，求给定观测序列 $O$ 条件下，最可能出现的对应的隐藏状态序列 $Q^{\ast }$。

HMM 模型的解码问题最常用的算法是维特比算法，当然也有其他的算法可以求解这个问题。同时维特比算法是一个通用的求序列最短路径的动态规划算法，也可以用于很多其他问题。

5.1 HMM 最可能隐藏状态序列求解概述

HMM 模型的解码问题即：

给定模型 $\lambda =(A,B,\Pi )$ 和 观测序列 $O=o_1,o_2,...,o_T$，求给定观测序列 $O$ 条件下，最可能出现的对应的隐藏状态序列 $Q^{\ast }=q_1^{\ast },q_2^{\ast },...，q_T^{\ast }$，即 $P(Q^{\ast }|O)$ 的最大化。

一个可能的近似解法是求出观测序列 $O$ 在每个时刻 $t$ 最可能的隐藏状态 $q_t^{\ast }$，然后得到一个近似的隐藏状态序列 $Q^{\ast }=q_1^{\ast },q_2^{\ast },...，q_T^{\ast }$。要这样近似求解不难，利用前向后向算法评估观察序列概率的定义：

• 在给定模型 $\lambda$ 和观测序列 $O$ , at time$t$ is in state$q_i$The probability of is
  $c_t\left(i\right)$ , this probability can be calculated by the forward algorithm and backward algorithm of HMM. This way we have:

$$Q_t^{\ast }=\underset{i\le i\le N}{\mathrm{argmax}}\mathring{(}i)t=1,2,...,T$$

in:

• $A$ : State transition matrix, where$a_{ij}$means from the hidden state $i$ transfers to the hidden state$j$ 的概率。
• $B$：观测概率矩阵，其中 $b_j(k)$ 表示在隐藏状态 $j$ 下观测到符号 $k$ 的概率。
• $\Pi$：初始状态概率向量，其中 ${\pi }_i$ 表示初始时刻隐藏状态为 $i$ 的概率。
• $O$：观测序列，其中 $o_t$ 表示时刻 $t$ 的观测值。
• $\lambda$：HMM 模型参数，包括状态转移矩阵 $A$、观测概率矩阵 $B$ 和初始状态概率向量 $\Pi$。
• $Q^{\ast }$：最可能的隐藏状态序列（即预测的隐藏状态序列），其中 $q_t^{\ast }$ 表示时刻 $t$ 最可能的隐藏状态。
• ${\gamma }_t(i)$：在给定模型 $\lambda$ 和观测序列 $O$ 时，在时刻 $t$ 处于状态 $q_i$ 的概率。

---

近似算法很简单，但是却不能保证预测的状态序列 $Q^{\ast }$ 整体是最可能的状态序列 $Q_{\text{best}}$，因为预测的状态序列 $Q^{\ast }$ 中某些相邻的隐藏状态 $q$ 可能存在转移概率 $a_{ij}$ 为 0 的情况。

而维特比算法可以将 HMM 的状态序列作为一个整体来考虑，避免近似算法的问题，下面我们来看看维特比算法进行 HMM 解码的方法。

5.2 维特比算法概述

The Viterbi algorithm is a general decoding algorithm, which is a method for finding the shortest path of a sequence based on dynamic programming. Since it is a dynamic programming algorithm, it is necessary to find a suitable local state and a recursive formula for the local state.

In HMM, the Viterbi algorithm defines two local states for recursion:

[ The first local state $d_t\left(q\right)$ ]The first local state is at time$t$ hidden state is$q$ all possible state transition paths$q_1,q_2,...,q_t$The probability maximum value in , denoted as $d_t(q)$：

$${\delta }_t(q)=\underset{q_1,q_2,...,q_{t-1}}{\max }P(q_t=q,q_1,q_2,...,q_{t-1},o_t,o_{t-1},...,o_1|\lambda )i=1,2,...,N$$

由 ${\delta }_t(q)$ 的定义可以得到 $The\; recursive\; expression\; of\; \delta$ :

$$\begin{array}{rl}{d}_{t+1}(q)& =\underset{q_1,q_2,...,q_t}{\max }P(q_{t+1}=q,q_1,q_2,...,q_t,o_{t+1},o_t,...,o_1|\lambda )\\ & =\underset{1\le j\le N}{\max }\left[d_t\right(j){has}_{ji}]b_i(o_{t+1})\end{array}$$

[ The second local state $p_t\left(q\right)$ ]The second local state is recursively obtained from the first local state.

We define at time $t$ hidden state isqqAll single state transition paths of$q$$(q_1,q_2,...,q_{t-1})$ in the transition path with the highest probability$t-The\; hidden\; state\; of\; 1$ node is$p_t\left(q\right)$ . Its recursive expression can be expressed as:

$$p_t(q)=\underset{1\le j\le N}{\mathrm{argmax}}\left[d_{t-1}\right(j){has}_{ji}]$$

With these two partial states, we can recurse from time 0 to time $T$ , then use$p_t\left(i\right)$ The recorded previous most likely state nodes backtrack until an optimal sequence of hidden states is found.

in:

• $A$：状态转移矩阵，其中 $a_{ij}$ 表示从隐藏状态 $i$ 转移到隐藏状态 $j$ 的概率。
• $B$：观测概率矩阵，其中 $b_j(k)$ 表示在隐藏状态 $j$ 下观测到符号 $k$ 的概率。
• $\Pi$：初始状态概率向量，其中 ${\pi }_i$ 表示初始时刻隐藏状态为 $i$ 的概率。
• $O$：观测序列，其中 $o_t$ 表示时刻 $t$ 的观测值。
• $\lambda$：HMM 模型参数，包括状态转移矩阵 $A$、观测概率矩阵 $B$ and initial state probability vector$P.$ _
• $d_t\left(q\right)$ : at time$t$ hidden state isqqThe probability maximum among all possible state transition paths of$q\; .$
• $p_t\left(q\right)$ : at time$t$ hidden state is$Among\; all\; single\; state\; transition\; paths\; of\; q$ , the t − 1 t-1transition path with the highest probability$t-Hidden\; state\; of\; 1$ node.

The Viterbi algorithm solves the optimal state sequence through dynamic programming, which has high efficiency and accuracy.

5.3 Summary of Viterbi Algorithm Process

• Form :HMM $l=(A,B,\prod )$ , viewing order$O=(o_1,o_2,...,o_T)$
• Output : Most likely sequence of hidden states $Q^{\ast }=q_1^{\ast },q_1^{\ast },...,q_T^{\ast }$

The process is as follows :

Step 1 : Initialize local state

$$\begin{array}{rl}& d_1(q)={Pi}_i{b}_i(o_1)i=1,2,...,N\\ & p_1\left(q\right)=0i=1,2,...,N\end{array}$$

Step 2 : Carry out dynamic programming recursion time $t=2,3,...,$The local state of$T$

$$\begin{array}{rlr}& d_t(q)=\underset{1\le j\le N}{\max }\left[d_{t-1}\right(j){has}_{ji}]b_i(o_t)& i=1,2,...,N\\ & p_t(i)=\underset{1\le j\le N}{\mathrm{argmax}}\left[d_{t-1}\right(j){has}_{ji}]& i=1,2,...,N\end{array}$$

步骤三：计算时刻 $T$ 最大的 ${\delta }_T(i)$，即为最可能隐藏状态序列出现的概率。计算时刻 $T$ 最大的 ${\psi }_t(q)$，即为时刻 $T$ 最可能的隐藏状态。

$$\begin{array}{rl}& P^{\ast }=\underset{1\le j\le N}{\max }{\delta }_T(i)\\ & q_T^{\ast }=\underset{1\le j\le N}{\mathrm{argmax}}[{\delta }_T(q)]\end{array}$$

步骤四：利用局部状态 ${\psi }_t(i)$ 开始回溯。对于 $t=T-1,T-2,...,1$：

$$q_t^{\ast }={\psi }_{t+1}(q_{t+1}^{\ast })$$

最终得到最有可能的隐藏状态序列 $Q^{\ast }=q_1^{\ast },q_2^{\ast },...,q_T^{\ast }$。

其中：

• $A$ : State transition matrix, where$a_{ij}$means from the hidden state $i$ transfers to the hidden state$The\; probability\; of\; j$ .
• $B$ : Observation probability matrix, where$b_j\left(k\right)$ means that in the hidden statejjThe symbol kkis observed under$j$$probability\; of\; k$ .
• $\Pi$ : initial state probability vector, where${Pi}_i$Indicates that the hidden state at the initial moment is $probability\; of\; i$ .
• $O$ : sequence of observations, where$o_t$represents time $The\; observed\; value\; of\; t$ .
• $\lambda$ : HMM model parameters, including the state transition matrix$A.$ Observation probability matrix$B$ and initial state probability vector$P.$ _
• $d_t\left(q\right)$ : at time$t$ hidden state isqqThe probability maximum among all possible state transition paths of$q\; .$
• $p_t\left(q\right)$ : at time$t$ hidden state is$Among\; all\; single\; state\; transition\; paths\; of\; q$ , the t − 1 t-1transition path with the highest probability$t-Hidden\; state\; of\; 1$ node.

5.4 Solution example of HMM Viterbi algorithm

Below we still use the example of boxes and balls to look at the solution of the HMM Viterbi algorithm. Our observation set is:

$$\begin{array}{rl}& V=\{red,White\}\\ & M=2\end{array}$$

Our state collection is:

$$\begin{array}{rl}& Q=\{box1,\_盒子2,盒子3\}\\ & N=3\end{array}$$

而观察序列 $O$ 和状态序列 $i$ 的长度为都为 3。

初始状态分布为：

$$\Pi =(0.2,0.4,0.4{)}^T$$

状态转移概率分布矩阵 $A$（不可见的，隐含的）为：

$$A={\left[\begin{array}{ccc}0.5& 0.2& 0.3\\ 0.3& 0.5& 0.2\\ 0.2& 0.3& 0.5\end{array}\right]}_{N\times N=3\times 3}$$

行表示第几次抽球（从2开始）；列表示使用第几个盒子的概率

观测状态概率矩阵 $B$（可见的）为：

$$B={\left[\begin{array}{cc}0.5& 0.5\\ 0.4& 0.6\\ 0.7& 0.3\end{array}\right]}_{N\times M=3\times 2}$$

行代表第几个盒子；列1代表红球的概率，列2代表白球的概率

球的颜色的观测序列：

O = { 红 , 白 , 红 } O = \{红, 白, 红\} O={ 红,白,红}

---

按照我们前面的维特比算法，首先需要得到三个隐藏状态在 时刻1 时对应的各自两个局部状态，此时观测状态为 1：

$$\begin{array}{rl}& d_1(1)={Pi}_1{b}_1(o_1)=\underset{first\; box}{0.2}\times \underset{red\; ball}{0.5}=0.1\\ & d_1(2)={Pi}_2{b}_2\left(o_1\right)=\underset{second\; box}{0.4}\times \underset{red\; ball}{0.4}=0.16\\ & d_1(3)={Pi}_3{b}_3(o_1)=\underset{第三个盒子}{0.4}\times \underset{红球}{0.7}=0.16\\ & {\psi }_1(1)={\psi }_1(2)={\psi }_1(3)=0\end{array}$$

${\psi }_1(1)={\psi }_1(2)={\psi }_1(3)=0$ 是因为初始化设定它们为 0

现在开始递推三个隐藏状态在 时刻2 时对应的各自两个局部状态，此时观测状态为 2：

$$\begin{array}{rl}& d_2(1)=\underset{1\le j\le 3}{\max }\left[d_1\right(j){has}_j]b_1(o_2)=\underset{1\le j\le 3}{\max }[\underset{the\; first\; case}{\underline{\underset{last\; time\; box1}{0.1}\times \underset{Box1\to Box1}{0.15}}},\underset{the\; second\; case}{\underline{\underset{last\; time\; box2}{0.16}\times \underset{Box2\to Box1}{0.3}}},\underset{third\; case}{\underline{\underset{last\; time\; box3}{0.28}\times \underset{Box3\to Box1}{0.2}}}]\times \underset{White\; ball}{0.5}=0.028\\ & p_2\left(1\right)=\underset{The\; index\; corresponding\; to\; the\; maximum\; value\left(startingfrom1\right)}{3}\\ & d_2(2)=\underset{1\le j\le 3}{\max }\left[d_1\right(j){has}_j]b_2(o_2)=\underset{1\le j\le 3}{\max }[\underset{the\; first\; case}{\underline{\underset{last\; time\; box1}{0.1}\times \underset{Box1\to Box2}{0.2}}},\underset{the\; second\; case}{\underline{\underset{last\; time\; box2}{0.16}\times \underset{Box2\to Box2}{0.5}}},\underset{third\; case}{\underline{\underset{last\; time\; box3}{0.28}\times \underset{Box3\to Box2}{0.3}}}]\times \underset{White\; ball}{0.6}=0.0504\\ & p_2(2)=\underset{The\; index\; corresponding\; to\; the\; maximum\; value\left(startingfrom1\right)}{3}\\ & d_2(3)=\underset{1\le j\le 3}{\max }\left[d_1\right(j){has}_{j3}]b_3(o_2)=\underset{1\le j\le 3}{\max }[\underset{the\; first\; case}{\underline{\underset{last\; time\; box1}{0.1}\times \underset{Box1\to Box3}{0.3}}},\underset{the\; second\; case}{\underline{\underset{last\; time\; box2}{0.16}\times \underset{Box2\to Box3}{0.2}}},\underset{third\; case}{\underline{\underset{last\; time\; box3}{0.28}\times \underset{盒子3\to 盒子3}{0.5}}}]\times \underset{白球}{0.3}=0.042\\ & {\psi }_2(3)=\underset{最大值对应的索引(从1开始)}{3}\end{array}$$

继续递推三个隐藏状态在 时刻3 时对应的各自两个局部状态，此时观测状态为 1：

$$\begin{array}{rl}& d_3(1)=\underset{1\le j\le 3}{\max }\left[d_1\right(j){has}_j]b_1(o_3)=\underset{1\le j\le 3}{\max }[\underset{the\; first\; case}{\underline{\underset{last\; time\; box1}{0.028}\times \underset{Box1\to Box1}{0.5}}},\underset{the\; second\; case}{\underline{\underset{last\; time\; box2}{0.0504}\times \underset{Box2\to Box1}{0.3}}},\underset{third\; case}{\underline{\underset{last\; time\; box3}{0.042}\times \underset{Box3\to Box1}{0.2}}}]\times \underset{red\; ball}{0.5}=0.00756\\ & p_3\left(1\right)=\underset{The\; index\; corresponding\; to\; the\; maximum\; value\left(startingfrom1\right)}{2}\\ & d_3(2)=\underset{1\le j\le 3}{\max }\left[d_1\right(j){has}_j]b_2(o_3)=\underset{1\le j\le 3}{\max }[\underset{the\; first\; case}{\underline{\underset{last\; time\; box1}{0.028}\times \underset{Box1\to Box2}{0.2}}},\underset{the\; second\; case}{\underline{\underset{last\; time\; box2}{0.0504}\times \underset{Box2\to Box2}{0.5}}},\underset{third\; case}{\underline{\underset{last\; time\; box3}{0.042}\times \underset{盒子3\to 盒子2}{0.3}}}]\times \underset{红球}{0.4}=0.0504\\ & {\psi }_3(2)=\underset{最大值对应的索引(从1开始)}{2}\\ & {\delta }_3(3)=\underset{1\le j\le 3}{\max }[{\delta }_1(j)a_{j3}]b_3(o_3)=\underset{1\le j\le 3}{\max }[\underset{第一种情况}{\underline{\underset{上一次是盒子1}{0.028}\times \underset{盒子1\to 盒子3}{0.3}}},\underset{第二种情况}{\underline{\underset{上一次是盒子2}{0.0504}\times \underset{盒子2\to 盒子3}{0.2}}},\underset{第三种情况}{\underline{\underset{上一次是盒子3}{0.042}\times \underset{盒子3\to 盒子3}{0.5}}}]\times \underset{红球}{0.7}=0.042\\ & {\psi }_3(3)=\underset{最大值对应的索引(从1开始)}{3}\end{array}$$

维特比算法是一种常用的 HMM 解码算法，它基于动态规划来求解最优状态序列。维特比算法定义了两个局部状态 ${\delta }_t(q)$ 和 ${\psi }_t(q)$ 来进行递推。其中，${\delta }_t(q)$ 表示在时刻 $t$ 隐藏状态为 $q$ 的所有可能的状态转移路径中的概率最大值；${\psi }_t(q)$ 表示在时刻 $t$ 隐藏状态为 $Among\; all\; single\; state\; transition\; paths\; of\; q$ , the t − 1 t-1transition path with the highest probability$t-Hidden\; state\; of\; 1$ node.

In the above example, the maximum probability at the last moment is $d_3\left(3\right)$ , which means that at time 3, the hidden state has the highest probability of being 3. Therefore, we can get$q_3^{\ast }=3$ , that is, the most likely hidden state at time 3 is 3.

Next, we can use the local state $p_t\left(i\right)$ to backtrack to obtain the optimal state sequence. Since$p_3(3)=3$ , so$q_2^{\ast }=3$ ; Since$p_2\left(3\right)=3$ , so$q_1^{\ast }=3$ . Therefore, we get the final optimal state sequence as{ 3 , 3 , 3 } \{3, 3, 3\}{ 3,3,3}。

The Viterbi algorithm still draws on the idea of ​​​​dynamic programming

---

Summary :

• Form :HMM $l=(A,B,\prod )$ , viewing order$O=(o_1,o_2,...,o_T)$
• Output : Most likely sequence of hidden states $Q^{\ast }=q_1^{\ast },q_1^{\ast },...,q_T^{\ast }$

The process is as follows :

Step 1 : Initialize local state

$$\begin{array}{rl}& {\delta }_1(q)={\Pi }_i{b}_i(o_1)i=1,2,...,N\\ & {\psi }_1(q)=0i=1,2,...,N\end{array}$$

步骤二：进行动态规划递推时刻 $t=2,3,...,T$ 的局部状态

$$\begin{array}{rlr}& d_t(q)=\underset{1\le j\le N}{\max }\left[d_{t-1}\right(j){has}_{ji}]b_i(o_t)& i=1,2,...,N\\ & p_t(i)=\underset{1\le j\le N}{\mathrm{argmax}}\left[d_{t-1}\right(j){has}_{ji}]& i=1,2,...,N\end{array}$$

步骤三：计算时刻 $T$ 最大的 ${\delta }_T(i)$，即为最可能隐藏状态序列出现的概率。计算时刻 $T$ 最大的 ${\psi }_t(q)$，即为时刻 $T$ 最可能的隐藏状态。

$$\begin{array}{rl}& P^{\ast }=\underset{1\le j\le N}{\max }{\delta }_T(i)\\ & q_T^{\ast }=\underset{1\le j\le N}{\mathrm{argmax}}[d_T(q)]\end{array}$$

Step 4 : Use the local state $p_t\left(i\right)$ Start backtracking. For$t=T-1,T-2,...,1$：

$$q_t^{\ast }=p_{t+1}(q_{t+1}^{\ast })$$

Finally, the most likely hidden state sequence $Q^{\ast }=q_1^{\ast },q_2^{\ast },...,q_T^{\ast }$。

in:

• $A$：状态转移矩阵，其中 $a_{ij}$ 表示从隐藏状态 $i$ 转移到隐藏状态 $j$ 的概率。
• $B$：观测概率矩阵，其中 $b_j(k)$ 表示在隐藏状态 $j$ 下观测到符号 $k$ 的概率。
• $\Pi$：初始状态概率向量，其中 ${\pi }_i$ 表示初始时刻隐藏状态为 $i$ 的概率。
• $O$：观测序列，其中 $o_t$ 表示时刻 $t$ 的观测值。
• $\lambda$：HMM 模型参数，包括状态转移矩阵 $A$、观测概率矩阵 $B$ and initial state probability vector$P.$ _
• $d_t\left(q\right)$ : at time$t$ hidden state isqqThe probability maximum among all possible state transition paths of$q\; .$
• $p_t\left(q\right)$ : at time$t$ hidden state is$Among\; all\; single\; state\; transition\; paths\; of\; q$ , the t − 1 t-1transition path with the highest probability$t-Hidden\; state\; of\; 1$ node.

6. Introduction to Baum-Welch Algorithm

learning target:

• Understanding the Baum-Welch Algorithm

6.1 Question introduction

Model parameter learning problem - Baum-Welch (Baum-Welch) algorithm (unknown state), that is, a given observation sequence O = { o 1 , o 2 , . . . , o T } O = \{o_1, o_2,..., o_T\}O={ o1​,o2​,...,oT​} ,unlock$l=(A,B,\Pi )$ , so that the conditional probability of the observation sequence under the model$P(O|A)$ max.

The most commonly used solution is the Baum-Welch algorithm, which is actually based on the EM algorithm, but in the era when the Baum-Welch algorithm appeared, the EM algorithm has not been abstracted, so it is called Baum - Welch algorithm.

6.2 Principle of Baum-Welch Algorithm

Since the principle of the Baum-Welch algorithm is the principle of the EM algorithm, then we need to find the joint distribution $P(O,I|\lambda )$ based on the conditional probability$P(I|O,\overline{l})$ , where$\overline{l}$is the current model parameter; then maximize this expectation in the M step to get the updated model parameter $l$ .

---

Let’s take a look at step E first, the current model parameter is $\overline{l}$, joint distribution $P(O,I|\lambda )$ based on the conditional probability P$(I|O,\overline{l})$ expected expression is:

$$L(\lambda ,\overline{l})=\sum _{I}P(I|O,\overline{l}\left)\log P\right(O,I|\lambda )$$

In step M, we maximize the above formula, and then get the updated model parameters as follows:

$$\overline{l}=\underset{l}{\mathrm{argmax}}\sum _{I}P(I|O,\overline{l})\log P(O,I|\lambda )$$

Iterate through steps E and M until $\overline{l}$convergence.

7. HMM model API introduction

learning target:

• Guide the usage of HMM model API

7.1 Installation of API

Official website link: https://hmmlearn.readthedocs.io/en/latest/

pip install hmmlearn==0.2.5

7.2 Introduction to hmmlearn

hmmlearn implements three HMM model classes, which can be divided into two types according to whether the observation state is a continuous state or a discrete state.

• GaussianHMM and GMMHMM are HMM models for continuous observation states
• MultinomialHMM is a model of discrete observation states, and it is also the model we use in the HMM principle series

• GaussianHMM: Gaussian Hidden Markov Model
• GMMHMM: Gaussian Mixture Hidden Markov Model
• MultinomialHMM: Multinomial Hidden Markov Model

Here we mainly introduce the MultinomialHMM model about the discrete state that we have been talking about before. For the model of MultinomialHMM, it is relatively simple to use.

from hmmlearn import hmm


model = hmm.MultinomialHMM (n_components=1, startprob_prior=1.0,
                            algorithm='viterbi', random_state=None,
                            n_iter=10, tol=0.01, verbose=False,
                            params='ste', init_params='ste')

• Role : hmm.MultinomialHMM()It is a class in hmmlearnthe library , which is used to create a hidden Markov model with polynomial (discrete) emission.
• Parameters :
  • n_components: (int) number of hidden states
  • n_iter: (int, optional) the maximum number of loops (iterations) during training
  • tol: (float, optional) Convergence threshold. If the gain of the log-likelihood falls below this value, EM will stop.
  • verbose: (bool, optional) When assigned to True, the probability (score) of each iteration and the probability of this iteration will be output to the standard output
  • init_params: (string, optional) Determines which parameters will be initialized during training.
    • 's' means startprob: the parameter corresponds to our hidden state initial distribution $Pi$
    • 't' means transmat: corresponding to our state transition matrix $A$
    • 'e' means emissionprob: corresponding to our observation state probability matrix $B$
    • An empty string "" represents all training with user-supplied parameters
• method :
  • fit()
  • decode()
  • score()
  • wait

7.3 Multinomial HMM example

Let's run through the MultinomialHMM with the example we talked about earlier about the ball.

import numpy as np
from hmmlearn import hmm

# 设定隐藏状态的集合 
states = ["box 1", "box 2", "box 3"]
n_states = len(states)

# 设定观察状态的集合
observations = ["red", "white"]
n_observations = len(observations)

# 设定初始状态分布
start_probability = np.array([0.2, 0.4, 0.4])

# 设定状态转移概率分布矩阵
transition_probability = np.array([[0.5, 0.2, 0.3],
                                   [0.3, 0.5, 0.2],
                                   [0.2, 0.3, 0.5]])

# 设定观测状态概率矩阵
emission_probability = np.array([[0.5, 0.5],
                                 [0.4, 0.6],
                                 [0.7, 0.3]])

# 定义模型
model = hmm.MultinomialHMM(n_components=n_states)

# 设定模型参数
model.startprob_ = start_probability  # 初始化状态分布
model.transmat_ = transition_probability  # 初始化状态转移概率分布矩阵
model.emissionprob_ = emission_probability  # 初始化观测状态概率矩阵

Now let's run HMM question 3: the decoding process of the Viterbi algorithm, using the same observation sequence as before to decode, the code is as follows:

seen = np.array([[0, 1, 0]]).T  # 设定观测序列（红白红）

# 维特比模型训练
box = model.predict(seen)

print("球的观测顺序为：", ' → '.join(map(lambda x: observations[x], seen.flatten())))
# 注意：需要使用flatten方法，把seen从二维变成一维
print("最可能的隐藏状态序列为：", ' → '.join(map(lambda x: states[x], box)))

Use mapthe function to seenmap the elements of the array observationsto the elements in
Use mapthe function to boxmap the elements of the array to the elements statesin

球的观测顺序为： red → white → red
最可能的隐藏状态序列为： box 3 → box 2 → box 2

---

Let's take a look at the problem of finding the probability of the observation sequence of HMM problem 1. The code is as follows:

prob = model.score(seen)

print(f"观测序列出现的概率为：{
      
      prob}")

观测序列出现的概率为：-2.038545309915233

It should be noted that scorethe function returns the logarithmic probability value based on the natural logarithm. The result of our manual calculation in HMM problem 1 is that the original probability without taking the logarithm is 0.13022. Compare:

import math

prob_true = math.exp(prob)
print(f"观测序列出现的概率为：{
      
      prob_true * 100:.3f}%")

观测序列出现的概率为：13.022%