6. Hidden Markov Models.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "from typing import Collection, Dict, List, Optional, Tuple\n",
    "\n",
    "from IPython.display import display, Markdown\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm.auto import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HMM:\n",
    "    def __init__(\n",
    "        self, \n",
    "        Z: Collection[str], \n",
    "        X: Collection[str], \n",
    "        init_dist: Optional[Dict[str, float]] = None, \n",
    "        transition_probs: Optional[Dict[Tuple[str, str], float]] = None, \n",
    "        emission_probs: Optional[Dict[Tuple[str, str], float]] = None,\n",
    "    ):\n",
    "        self.Z = Z  # Hidden states space\n",
    "        self.X = X  # Observations space\n",
    "\n",
    "        self.pi = init_dist  # P(z_0); z_0 -> p\n",
    "        self.tr = transition_probs  # P(z_t | z_{t-1}); (z_t_1, z_t) -> p\n",
    "        self.em = emission_probs  # P (x_t | z_t); (x_t, z_t) -> p\n",
    "        \n",
    "    @property\n",
    "    def theta(self):\n",
    "        return self.pi, self.tr, self.em\n",
    "    \n",
    "    @theta.setter\n",
    "    def theta(self, values: tuple):\n",
    "        self.pi, self.tr, self.em = values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "1dbf22f40a22c3e6713af662c3ede576",
     "grade": false,
     "grade_id": "default-hmms",
     "locked": true,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def get_gene_hmm():\n",
    "    _hmm = HMM(\n",
    "        Z=('H', 'L'),\n",
    "        X=('A', 'C', 'G', 'T'),\n",
    "        init_dist={'H': 0.5, 'L': 0.5},\n",
    "        transition_probs={\n",
    "            ('H', 'H'): 0.5, ('H', 'L'): 0.5,\n",
    "            ('L', 'L'): 0.6, ('L', 'H'): 0.4, \n",
    "        },\n",
    "        emission_probs={\n",
    "            ('A', 'H'): 0.2, ('C', 'H'): 0.3, ('G', 'H'): 0.3, ('T', 'H'): 0.2,\n",
    "            ('A', 'L'): 0.3, ('C', 'L'): 0.2, ('G', 'L'): 0.2, ('T', 'L'): 0.3,\n",
    "        }\n",
    "    )\n",
    "\n",
    "    return _hmm\n",
    "\n",
    "def get_weather_hmm():\n",
    "    _hmm = HMM(\n",
    "        Z=('Rainy', 'Sunny'),\n",
    "        X=('Walk', 'Shop', 'Clean'),\n",
    "        init_dist={'Rainy': 0.6, 'Sunny': 0.4},\n",
    "        transition_probs={\n",
    "            ('Rainy', 'Rainy'): 0.7, ('Rainy', 'Sunny'): 0.3,\n",
    "            ('Sunny', 'Rainy'): 0.4, ('Sunny', 'Sunny'): 0.6,\n",
    "        },\n",
    "        emission_probs={\n",
    "            ('Walk', 'Rainy'): 0.1, ('Shop', 'Rainy'): 0.4, ('Clean', 'Rainy'): 0.5,\n",
    "            ('Walk', 'Sunny'): 0.6, ('Shop', 'Sunny'): 0.3, ('Clean', 'Sunny'): 0.1,\n",
    "        }\n",
    "    )\n",
    "\n",
    "    return _hmm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hmm_basic_info(hmm):\n",
    "    \"\"\"Displays parameters of given HMM.\"\"\"\n",
    "    # Initial distribution `pi`\n",
    "    pi_df = pd.DataFrame(\n",
    "        columns=[f'$$z^{{(0)}} = {z_0}$$' for z_0 in hmm.pi.keys()],\n",
    "        index=[\"$$P(z^{{(0)}})$$\"],\n",
    "    )\n",
    "\n",
    "    for z_0, p_z_0 in hmm.pi.items():\n",
    "        pi_df[f'$$z^{{(0)}} = {z_0}$$']['$$P(z^{{(0)}})$$'] = p_z_0\n",
    "        \n",
    "    display(pi_df)\n",
    "    \n",
    "    # Transition matrix `a`\n",
    "    a_df = pd.DataFrame(\n",
    "        columns=[f'$$z^{{(t)}} = {dst}$$' for dst in hmm.Z],\n",
    "        index=[f'$$z^{{(t-1)}} = {src}$$' for src in hmm.Z],\n",
    "    )\n",
    "\n",
    "    for (src, dst), val in hmm.tr.items():\n",
    "        a_df[f'$$z^{{(t)}} = {dst}$$'][f'$$z^{{(t-1)}} = {src}$$'] = val\n",
    "        \n",
    "    display(a_df)\n",
    "    \n",
    "    # Emission matrix `b`\n",
    "    b_df = pd.DataFrame(\n",
    "        columns=[f'$$z^{{(t)}} = {z}$$' for z in hmm.Z],\n",
    "        index=[f'$$x^{{(t)}} = {x}$$' for x in hmm.X],\n",
    "    )\n",
    "\n",
    "    for (x, z), val in hmm.em.items():\n",
    "        b_df[f'$$z^{{(t)}} = {z}$$'][f'$$x^{{(t)}} = {x}$$'] = val\n",
    "    \n",
    "    display(b_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>$$z^{(0)} = Rainy$$</th>\n",
       "      <th>$$z^{(0)} = Sunny$$</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>$$P(z^{{(0)}})$$</th>\n",
       "      <td>0.6</td>\n",
       "      <td>0.4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 $$z^{(0)} = Rainy$$ $$z^{(0)} = Sunny$$\n",
       "$$P(z^{{(0)}})$$                 0.6                 0.4"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>$$z^{(t)} = Rainy$$</th>\n",
       "      <th>$$z^{(t)} = Sunny$$</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>$$z^{(t-1)} = Rainy$$</th>\n",
       "      <td>0.7</td>\n",
       "      <td>0.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$$z^{(t-1)} = Sunny$$</th>\n",
       "      <td>0.4</td>\n",
       "      <td>0.6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      $$z^{(t)} = Rainy$$ $$z^{(t)} = Sunny$$\n",
       "$$z^{(t-1)} = Rainy$$                 0.7                 0.3\n",
       "$$z^{(t-1)} = Sunny$$                 0.4                 0.6"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>$$z^{(t)} = Rainy$$</th>\n",
       "      <th>$$z^{(t)} = Sunny$$</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>$$x^{(t)} = Walk$$</th>\n",
       "      <td>0.1</td>\n",
       "      <td>0.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$$x^{(t)} = Shop$$</th>\n",
       "      <td>0.4</td>\n",
       "      <td>0.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$$x^{(t)} = Clean$$</th>\n",
       "      <td>0.5</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    $$z^{(t)} = Rainy$$ $$z^{(t)} = Sunny$$\n",
       "$$x^{(t)} = Walk$$                  0.1                 0.6\n",
       "$$x^{(t)} = Shop$$                  0.4                 0.3\n",
       "$$x^{(t)} = Clean$$                 0.5                 0.1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# hmm = get_gene_hmm()\n",
    "hmm = get_weather_hmm()\n",
    "\n",
    "hmm_basic_info(hmm=hmm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "def logsumexp(x):\n",
    "    \"\"\"Compute sum of log-probs using log-sum-exp trick.\"\"\"\n",
    "    x = np.array(x)\n",
    "    x_max = max(x)\n",
    "    return np.log(np.sum(np.exp(x - x_max))) + x_max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "efa4a5ae689776d16dfc432091c3f63f",
     "grade": false,
     "grade_id": "forward",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def forward(hmm: HMM, X: List[str]):\n",
    "    \"\"\"Implement the forward algorithm.\n",
    "\n",
    "    :param hmm: Hidden Markov Model object.\n",
    "    :param X: Sequence of elements of length T.\n",
    "    :return: alpha. Dict of log-probabilities, where each key (t, z) denotes\n",
    "        that any particular state z is chosen at the step t.\n",
    "    \"\"\"\n",
    "    alpha = {}  # (t, z_j) -> log_p\n",
    "    \n",
    "\n",
    "    for t in range(len(X)):\n",
    "         for j in range(len(hmm.Z)):\n",
    "            if t==0:\n",
    "                alpha[(t, hmm.Z[j])]=hmm.pi[hmm.Z[j]]*hmm.em[(X[t],hmm.Z[j])]\n",
    "            elif t>0:\n",
    "                suma=0\n",
    "                for i in range(len(hmm.Z)):\n",
    "                    suma+=alpha[(t-1, hmm.Z[i])]*hmm.tr[(hmm.Z[i],hmm.Z[j])]\n",
    "                alpha[(t, hmm.Z[j])]=hmm.em[(X[t],hmm.Z[j])]*suma\n",
    "\n",
    "    return alpha\n",
    "\n",
    "#  logarytmy prawdopodobieństw\n",
    "\n",
    "def forward(hmm: HMM, X: List[str]):\n",
    "    \"\"\"Implement the forward algorithm.\n",
    "\n",
    "    :param hmm: Hidden Markov Model object.\n",
    "    :param X: Sequence of elements of length T.\n",
    "    :return: alpha. Dict of log-probabilities, where each key (t, z) denotes\n",
    "        that any particular state z is chosen at the step t.\n",
    "    \"\"\"\n",
    "    alpha = {}  # (t, z_j) -> log_p\n",
    "    \n",
    "\n",
    "    for t in range(len(X)):\n",
    "        for j in range(len(hmm.Z)):\n",
    "            if t==0:\n",
    "                alpha[(t, hmm.Z[j])] = np.log(hmm.pi[hmm.Z[j]]) + np.log(hmm.em[(X[t],hmm.Z[j])])\n",
    "            elif t>0:\n",
    "                log_sum = []\n",
    "                for i in range(len(hmm.Z)):\n",
    "                    log_sum.append(alpha[(t-1, hmm.Z[i])] + np.log(hmm.tr[(hmm.Z[i],hmm.Z[j])]))\n",
    "                alpha[(t, hmm.Z[j])] = np.log(hmm.em[(X[t],hmm.Z[j])]) + logsumexp(log_sum)\n",
    "\n",
    "    return alpha\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b08b00b53b97d1f3d05a57b2f30717b2",
     "grade": false,
     "grade_id": "score-observation-sequence",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def score_observation_sequence(hmm: HMM, X: List[str]):\n",
    "    \"\"\"Computes the probability of observing a given sequence.\n",
    "\n",
    "    :param hmm: Hidden Markov Model object.\n",
    "    :param X: Sequence of elements of length T.\n",
    "    :return: Tuple of log probability and alpha matrix calculated using\n",
    "        `forward` step. Log probabilities are estimated as a sum of log\n",
    "        probs over each possible state in the last step of alpha. Note, that\n",
    "        these probabilities does not have to sum to one, since they\n",
    "        describe probability of all paths leading to a particular state.\n",
    "    \"\"\"\n",
    "    if any(param is None for param in hmm.theta):\n",
    "        raise RuntimeError('Model must be trained first!')\n",
    "    \n",
    "    alpha = forward(hmm=hmm, X=X)\n",
    "    log_p = None\n",
    "        \n",
    "    last_step_probs = [alpha[(len(X)-1, z)] for z in hmm.Z]\n",
    "    log_p = logsumexp(last_step_probs)\n",
    "    return log_p, alpha\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_table(scores, T, Z, name):\n",
    "    df = pd.DataFrame(\n",
    "        columns=[f'$$t = {t}$$' for t in range(T)],\n",
    "        index=[f'$$z = {z}$$' for z in Z],\n",
    "    )\n",
    "\n",
    "    for (t, z), v in scores.items():\n",
    "        df[f'$$t = {t}$$'][f'$$z = {z}$$'] = np.round(v, 4)\n",
    "\n",
    "    display(Markdown(f'### {name} table'))\n",
    "    display(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log-Probability of observing X: -5.4934694111481 (actual probability: 0.004113547799999996)\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Forward table"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>$$t = 0$$</th>\n",
       "      <th>$$t = 1$$</th>\n",
       "      <th>$$t = 2$$</th>\n",
       "      <th>$$t = 3$$</th>\n",
       "      <th>$$t = 4$$</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>$$z = Rainy$$</th>\n",
       "      <td>-2.8134</td>\n",
       "      <td>-2.6736</td>\n",
       "      <td>-3.5976</td>\n",
       "      <td>-4.5859</td>\n",
       "      <td>-5.8041</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$$z = Sunny$$</th>\n",
       "      <td>-1.4271</td>\n",
       "      <td>-4.1227</td>\n",
       "      <td>-5.7952</td>\n",
       "      <td>-6.9035</td>\n",
       "      <td>-6.814</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              $$t = 0$$ $$t = 1$$ $$t = 2$$ $$t = 3$$ $$t = 4$$\n",
       "$$z = Rainy$$   -2.8134   -2.6736   -3.5976   -4.5859   -5.8041\n",
       "$$z = Sunny$$   -1.4271   -4.1227   -5.7952   -6.9035    -6.814"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# sample_X = ['G', 'G', 'C', 'A']\n",
    "sample_X = ['Walk', 'Clean', 'Clean', 'Clean', 'Shop']\n",
    "\n",
    "log_p, alpha = score_observation_sequence(hmm=hmm, X=sample_X)\n",
    "print(f'Log-Probability of observing X: {log_p} (actual probability: {np.exp(log_p)})')\n",
    "\n",
    "print_table(scores=alpha, T=len(sample_X), Z=hmm.Z, name='Forward')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def viterbi_decode(hmm: HMM, X: List[str]):\n",
    "    \"\"\"Implement the Viterbi decoding algorithm.\n",
    "\n",
    "    :param hmm: Hidden Markov Model object.\n",
    "    :param X: Sequence of elements of length T.\n",
    "    :return: Tuple of: the most probable path of hidden states and the\n",
    "        omega matrix. The most probability is chosen in a greedy fashion\n",
    "        by takin the most probable hidden state in each step. Omega describes\n",
    "        hidden states probabilities at each `t` step.\n",
    "    \"\"\"\n",
    "    if any(param is None for param in hmm.theta):\n",
    "        raise RuntimeError('Model must be trained first!')\n",
    "    \n",
    "    omega = {}  # (t, z_t) -> max (log_p, z_{t-1})\n",
    "    max_Z = ''\n",
    "    \n",
    "    for t in range(len(X)):\n",
    "        max_t_prob = float('-inf')\n",
    "        max_t_z = None\n",
    "        for j in range(len(hmm.Z)):\n",
    "            if t == 0:\n",
    "                prob = np.log(hmm.pi[hmm.Z[j]]) + np.log(hmm.em[(X[t],hmm.Z[j])])\n",
    "                omega[(t, hmm.Z[j])] = (prob, None)\n",
    "                if prob > max_t_prob:\n",
    "                    max_t_prob = prob\n",
    "                    max_t_z = hmm.Z[j]\n",
    "            elif t > 0:\n",
    "                max_zi = float('-inf')\n",
    "                for i in range(len(hmm.Z)):\n",
    "                    max_i = omega[(t-1, hmm.Z[i])][0] + np.log(hmm.tr[(hmm.Z[i],hmm.Z[j])])\n",
    "                    if max_i > max_zi:\n",
    "                        max_zi = max_i\n",
    "                        max_t_z = hmm.Z[i]\n",
    "\n",
    "                omega[(t, hmm.Z[j])] = (np.log(hmm.em[(X[t],hmm.Z[j])]) + max_zi, max_t_z)\n",
    "\n",
    "    max_Z = []\n",
    "    t = len(X) - 1\n",
    "\n",
    "    while t >= 0:\n",
    "        max_z = max((omega[(t, z)][0], z) for z in hmm.Z)[1]\n",
    "        max_Z = [max_z] + max_Z\n",
    "        t -= 1\n",
    "\n",
    "    return max_Z, omega"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_viterbi_table(scores, T, Z):\n",
    "    def highlight_max(s):\n",
    "        is_max = s == s.max()\n",
    "        return ['background-color: yellow' if v else '' for v in is_max]\n",
    "\n",
    "    df = pd.DataFrame(\n",
    "        columns=[f'$$t = {t}$$' for t in range(T)],\n",
    "        index=[f'$$z = {z}$$' for z in Z],\n",
    "    )\n",
    "\n",
    "    for (t, z), v in scores.items():\n",
    "        df[f'$$t = {t}$$'][f'$$z = {z}$$'] = (np.round(v[0], 4), v[1])\n",
    "\n",
    "\n",
    "    df = df.style.apply(highlight_max)\n",
    "\n",
    "    display(Markdown('### Viterbi table'))\n",
    "    display(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Most probable sequence of hidden states: ['Sunny', 'Rainy', 'Rainy', 'Rainy', 'Rainy']\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Viterbi table"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<style  type=\"text/css\" >\n",
       "#T_c56bb_row0_col1,#T_c56bb_row0_col2,#T_c56bb_row0_col3,#T_c56bb_row0_col4,#T_c56bb_row1_col0{\n",
       "            background-color:  yellow;\n",
       "        }</style><table id=\"T_c56bb_\" ><thead>    <tr>        <th class=\"blank level0\" ></th>        <th class=\"col_heading level0 col0\" >$$t = 0$$</th>        <th class=\"col_heading level0 col1\" >$$t = 1$$</th>        <th class=\"col_heading level0 col2\" >$$t = 2$$</th>        <th class=\"col_heading level0 col3\" >$$t = 3$$</th>        <th class=\"col_heading level0 col4\" >$$t = 4$$</th>    </tr></thead><tbody>\n",
       "                <tr>\n",
       "                        <th id=\"T_c56bb_level0_row0\" class=\"row_heading level0 row0\" >$$z = Rainy$$</th>\n",
       "                        <td id=\"T_c56bb_row0_col0\" class=\"data row0 col0\" >(-2.8134, None)</td>\n",
       "                        <td id=\"T_c56bb_row0_col1\" class=\"data row0 col1\" >(-3.0366, 'Sunny')</td>\n",
       "                        <td id=\"T_c56bb_row0_col2\" class=\"data row0 col2\" >(-4.0864, 'Rainy')</td>\n",
       "                        <td id=\"T_c56bb_row0_col3\" class=\"data row0 col3\" >(-5.1362, 'Rainy')</td>\n",
       "                        <td id=\"T_c56bb_row0_col4\" class=\"data row0 col4\" >(-6.4092, 'Rainy')</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_c56bb_level0_row1\" class=\"row_heading level0 row1\" >$$z = Sunny$$</th>\n",
       "                        <td id=\"T_c56bb_row1_col0\" class=\"data row1 col0\" >(-1.4271, None)</td>\n",
       "                        <td id=\"T_c56bb_row1_col1\" class=\"data row1 col1\" >(-4.2405, 'Sunny')</td>\n",
       "                        <td id=\"T_c56bb_row1_col2\" class=\"data row1 col2\" >(-6.5431, 'Rainy')</td>\n",
       "                        <td id=\"T_c56bb_row1_col3\" class=\"data row1 col3\" >(-7.5929, 'Rainy')</td>\n",
       "                        <td id=\"T_c56bb_row1_col4\" class=\"data row1 col4\" >(-7.5441, 'Rainy')</td>\n",
       "            </tr>\n",
       "    </tbody></table>"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x1b8de93c5e0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "max_Z, scores = viterbi_decode(hmm=hmm, X=sample_X)\n",
    "\n",
    "print('Most probable sequence of hidden states:', max_Z)\n",
    "\n",
    "print_viterbi_table(scores=scores, T=len(sample_X), Z=hmm.Z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate(hmm: HMM, N: int):\n",
    "    \"\"\"Generates `N` observations and returns both X and Z.\"\"\"\n",
    "    X, Z = [], []\n",
    "\n",
    "    # Draw initial state\n",
    "    z_0 = np.random.choice(\n",
    "        a=hmm.Z,\n",
    "        p=[hmm.pi[z] for z in hmm.Z],\n",
    "    )\n",
    "    Z.append(z_0)\n",
    "\n",
    "    # Draw next states based on transition matrix\n",
    "    z_t_1 = z_0\n",
    "    for _ in range(N - 1):\n",
    "        z_t = np.random.choice(\n",
    "            a=hmm.Z,\n",
    "            p=[hmm.tr[(z_t_1, z)] for z in hmm.Z],\n",
    "        )\n",
    "\n",
    "        Z.append(z_t)\n",
    "        z_t_1 = z_t\n",
    "\n",
    "    # Draw observations\n",
    "    for z_t in Z:\n",
    "        x_t = np.random.choice(\n",
    "            a=hmm.X,\n",
    "            p=[hmm.em[(x, z_t)] for x in hmm.X],\n",
    "        )\n",
    "        X.append(x_t)\n",
    "\n",
    "    return X, Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z (hidden states): ['Sunny', 'Rainy', 'Sunny', 'Sunny', 'Rainy', 'Rainy', 'Rainy', 'Rainy', 'Rainy', 'Sunny']\n",
      "X (observations): ['Walk', 'Clean', 'Shop', 'Walk', 'Shop', 'Clean', 'Walk', 'Shop', 'Clean', 'Walk']\n"
     ]
    }
   ],
   "source": [
    "num_observations = 10\n",
    "X_generated, Z_generated = generate(hmm=hmm, N=num_observations)\n",
    "\n",
    "print('Z (hidden states):', Z_generated)\n",
    "print('X (observations):', X_generated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_dataset(model, num_seq, seq_length, train_size):\n",
    "    tr_size = int(train_size * num_seq)\n",
    "    te_size = num_seq - tr_size\n",
    "\n",
    "    ds = {\n",
    "        'train': np.array([generate(hmm=model, N=seq_length)[0] for _ in range(tr_size)]),\n",
    "        'test': np.array([generate(hmm=model, N=seq_length)[0] for _ in range(te_size)]),\n",
    "    }\n",
    "    \n",
    "    return ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pdist(n, rng=None):\n",
    "    p = np.random.uniform(size=n)\n",
    "    p /= sum(p)\n",
    "    return p\n",
    "\n",
    "\n",
    "def get_uninitialized_hmm(Z, X):\n",
    "    # Initial distribution    \n",
    "    pi = {z: v for z, v in zip(Z, pdist(len(Z)))}\n",
    "    \n",
    "    # Transition probs\n",
    "    tr = {\n",
    "        (z_t_1, z_t): p\n",
    "        for z_t_1 in Z\n",
    "        for z_t, p in zip(Z, pdist(len(Z)))\n",
    "    }\n",
    "    \n",
    "    # Emission probs\n",
    "    em = {\n",
    "        (x, z_k): p\n",
    "        for z_k in Z\n",
    "        for x, p in zip(X, pdist(len(X)))\n",
    "    }\n",
    "    \n",
    "    _hmm = HMM(\n",
    "        Z=Z, \n",
    "        X=X, \n",
    "        init_dist=pi, \n",
    "        transition_probs=tr, \n",
    "        emission_probs=em,\n",
    "    )\n",
    "    return _hmm\n",
    "\n",
    "\n",
    "def get_uninitialized_gene_hmm():\n",
    "    return get_uninitialized_hmm(\n",
    "        Z=('H', 'L'),\n",
    "        X=('A', 'C', 'G', 'T'),\n",
    "    )\n",
    "\n",
    "\n",
    "def get_uninitialized_weather_hmm():\n",
    "    return get_uninitialized_hmm(\n",
    "        Z=('Rainy', 'Sunny'),\n",
    "        X=('Walk', 'Shop', 'Clean'),\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train => (800, 10)\n",
      "Test => (200, 10)\n"
     ]
    }
   ],
   "source": [
    "dataset = make_dataset(model=hmm, num_seq=1_000, seq_length=10, train_size=0.8)\n",
    "\n",
    "print('Train =>', dataset['train'].shape)\n",
    "print('Test =>', dataset['test'].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parameter_loss(prev_theta, theta):\n",
    "    if prev_theta == (None, None, None):\n",
    "        return 1\n",
    "\n",
    "    prev_pi, prev_tr, prev_em = prev_theta\n",
    "    pi, tr, em = theta\n",
    "\n",
    "    loss = 0\n",
    "\n",
    "    # Initial dist loss\n",
    "    for k in prev_pi.keys():\n",
    "        loss += (prev_pi[k] - pi[k]) ** 2\n",
    "\n",
    "    # Transition prob. loss\n",
    "    for k in prev_tr.keys():\n",
    "        loss += (prev_tr[k] - tr[k]) ** 2\n",
    "\n",
    "    # Emission prob. loss\n",
    "    for k in prev_em.keys():\n",
    "        loss += (prev_em[k] - em[k]) ** 2\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_hmm(hmm, X):\n",
    "    return logsumexp([\n",
    "        score_observation_sequence(hmm=hmm, X=x)[0]\n",
    "        for x in X\n",
    "    ]) - np.log(len(X))\n",
    "\n",
    "\n",
    "def training_plots(hmm, losses, probas, X_test):\n",
    "    fig, ax = plt.subplots(ncols=2, figsize=(15, 4))\n",
    "    ax[0].plot(range(len(losses)), losses, marker='x', linestyle='--')\n",
    "    ax[0].set_xlabel('Epoch')\n",
    "    ax[0].set_ylabel('Loss')\n",
    "\n",
    "    ax[1].plot(range(len(probas)), probas, marker='x', linestyle='--', label='Train')\n",
    "    ax[1].set_xlabel('Epoch')\n",
    "    ax[1].set_ylabel('Train log-prob')\n",
    "\n",
    "    logp = test_hmm(hmm=hmm, X=X_test)\n",
    "    print(f'Test log-p: {logp}')\n",
    "    ax[1].axhline(logp, linestyle='--', color='r', label='Test')\n",
    "    ax[1].legend()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "d0f7eeffd7beee976855fe01c0663bee",
     "grade": false,
     "grade_id": "viterbi-learning",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "def fit_viterbi(\n",
    "    hmm: HMM, \n",
    "    X_train: List[List[str]], \n",
    "    smoothing: int = 1,\n",
    "    eps: float = 1e-4, \n",
    "    max_epochs: int = 30, \n",
    "    verbose: bool = True,\n",
    ") -> Dict[str, List[float]]:\n",
    "    \"\"\"Estimates the model's parameters using Viterbi learning algorithm.\"\"\"\n",
    "    prev_theta = (None, None, None)\n",
    "\n",
    "    logs = {\n",
    "        'losses': [],\n",
    "        'probas': [],\n",
    "    }\n",
    "\n",
    "    for epoch in tqdm(\n",
    "        iterable=range(max_epochs), \n",
    "        desc='Epochs',\n",
    "        disable=not verbose,\n",
    "    ):\n",
    "        # Update params\n",
    "        prev_theta = hmm.theta\n",
    "        hmm.theta = estimate_parameters(hmm, X_train, smoothing=smoothing)\n",
    "\n",
    "        # Compute loss\n",
    "        loss = parameter_loss(prev_theta, hmm.theta)\n",
    "        probas = logsumexp([\n",
    "            score_observation_sequence(hmm=hmm, X=x)[0]\n",
    "            for x in X_train\n",
    "        ]) - np.log(len(X_train))\n",
    "\n",
    "        logs['losses'].append(loss)\n",
    "        logs['probas'].append(probas)\n",
    "\n",
    "        # Logging\n",
    "        if verbose:\n",
    "            print(f'Epoch: {epoch} => '\n",
    "                  f'Loss: {np.round(loss, 5)}, '\n",
    "                  f'Log-prob: {probas}')\n",
    "\n",
    "        # Stopping condition\n",
    "        if loss < eps:\n",
    "            break\n",
    "    \n",
    "    return logs\n",
    "\n",
    "\n",
    "\n",
    "def estimate_parameters(hmm: HMM, X_train: List[List[str]], smoothing: int):\n",
    "    \"\"\"Estimate parameters of the HMM usng Viterbi algorithm.\n",
    "\n",
    "    :param hmm: Hidden Markov Model object.\n",
    "    :param X: Sequence of elements of length T.\n",
    "    :return: Tuple of parameters of the HMM: initial state probability pi,\n",
    "        transition probability matrix a, and emission probabiliy matrix b.\n",
    "    \"\"\"\n",
    "\n",
    "    n_pi = {z: 0 for z in hmm.Z}\n",
    "    n_a = {(z_1, z_2): 0 for z_1 in hmm.Z for z_2 in hmm.Z}\n",
    "    n_b = {(x, z):0 for x in hmm.X for z in hmm.Z }\n",
    "\n",
    "\n",
    "    for x in X_train:\n",
    "        max_Z, _ = viterbi_decode(hmm=hmm, X=list(x))\n",
    "        n_pi[max_Z[0]] += 1\n",
    "        \n",
    "        for i in range(len(max_Z)-1):\n",
    "            n_a[(max_Z[i], max_Z[i+1])] += 1\n",
    "        \n",
    "        for i in range(len(max_Z)):\n",
    "            n_b[(x[i], max_Z[i])] += 1\n",
    "\n",
    "\n",
    "    pi = {k: v / sum(n_pi.values()) for k, v in n_pi.items()}\n",
    "    tr_ = {k: sum([n_a[k_1] for k_1 in n_a.keys() if k_1[0] == k[0]]) for k in n_a.keys()}\n",
    "    tr = {k: (v + smoothing) / (tr_[k] + smoothing) for k, v in n_a.items()}\n",
    "    en_ = {k: sum([n_b[k_1] for k_1 in n_b.keys() if k_1[1] == k[1]]) for k in n_b.keys()}\n",
    "    em = {k: (v + smoothing) / (en_[k] + smoothing) for k, v in n_b.items()}\n",
    "\n",
    "    return pi, tr, em"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>$$z^{(0)} = Rainy$$</th>\n",
       "      <th>$$z^{(0)} = Sunny$$</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>$$P(z^{{(0)}})$$</th>\n",
       "      <td>0.530342</td>\n",
       "      <td>0.469658</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 $$z^{(0)} = Rainy$$ $$z^{(0)} = Sunny$$\n",
       "$$P(z^{{(0)}})$$            0.530342            0.469658"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>$$z^{(t)} = Rainy$$</th>\n",
       "      <th>$$z^{(t)} = Sunny$$</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>$$z^{(t-1)} = Rainy$$</th>\n",
       "      <td>0.38398</td>\n",
       "      <td>0.61602</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$$z^{(t-1)} = Sunny$$</th>\n",
       "      <td>0.36439</td>\n",
       "      <td>0.63561</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      $$z^{(t)} = Rainy$$ $$z^{(t)} = Sunny$$\n",
       "$$z^{(t-1)} = Rainy$$             0.38398             0.61602\n",
       "$$z^{(t-1)} = Sunny$$             0.36439             0.63561"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>$$z^{(t)} = Rainy$$</th>\n",
       "      <th>$$z^{(t)} = Sunny$$</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>$$x^{(t)} = Walk$$</th>\n",
       "      <td>0.362804</td>\n",
       "      <td>0.387457</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$$x^{(t)} = Shop$$</th>\n",
       "      <td>0.276046</td>\n",
       "      <td>0.432585</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$$x^{(t)} = Clean$$</th>\n",
       "      <td>0.361149</td>\n",
       "      <td>0.179957</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    $$z^{(t)} = Rainy$$ $$z^{(t)} = Sunny$$\n",
       "$$x^{(t)} = Walk$$             0.362804            0.387457\n",
       "$$x^{(t)} = Shop$$             0.276046            0.432585\n",
       "$$x^{(t)} = Clean$$            0.361149            0.179957"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# hmm_viterbi = get_uninitialized_gene_hmm()\n",
    "hmm_viterbi = get_uninitialized_weather_hmm()\n",
    "\n",
    "hmm_basic_info(hmm_viterbi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs:   3%|▎         | 1/30 [00:00<00:13,  2.16it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 => Loss: 0.53758, Log-prob: -10.947657478255422\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs:   7%|▋         | 2/30 [00:00<00:12,  2.22it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1 => Loss: 0.20667, Log-prob: -10.94017428160987\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epochs:   7%|▋         | 2/30 [00:01<00:18,  1.49it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 2 => Loss: 0.0, Log-prob: -10.94017428160987\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>$$z^{(0)} = Rainy$$</th>\n",
       "      <th>$$z^{(0)} = Sunny$$</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>$$P(z^{{(0)}})$$</th>\n",
       "      <td>0.325</td>\n",
       "      <td>0.675</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                 $$z^{(0)} = Rainy$$ $$z^{(0)} = Sunny$$\n",
       "$$P(z^{{(0)}})$$               0.325               0.675"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>$$z^{(t)} = Rainy$$</th>\n",
       "      <th>$$z^{(t)} = Sunny$$</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>$$z^{(t-1)} = Rainy$$</th>\n",
       "      <td>0.35309</td>\n",
       "      <td>0.647331</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$$z^{(t-1)} = Sunny$$</th>\n",
       "      <td>0.318474</td>\n",
       "      <td>0.681733</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      $$z^{(t)} = Rainy$$ $$z^{(t)} = Sunny$$\n",
       "$$z^{(t-1)} = Rainy$$             0.35309            0.647331\n",
       "$$z^{(t-1)} = Sunny$$            0.318474            0.681733"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>$$z^{(t)} = Rainy$$</th>\n",
       "      <th>$$z^{(t)} = Sunny$$</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>$$x^{(t)} = Walk$$</th>\n",
       "      <td>0.00038</td>\n",
       "      <td>0.467859</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$$x^{(t)} = Shop$$</th>\n",
       "      <td>0.00038</td>\n",
       "      <td>0.532327</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>$$x^{(t)} = Clean$$</th>\n",
       "      <td>1.0</td>\n",
       "      <td>0.000186</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    $$z^{(t)} = Rainy$$ $$z^{(t)} = Sunny$$\n",
       "$$x^{(t)} = Walk$$              0.00038            0.467859\n",
       "$$x^{(t)} = Shop$$              0.00038            0.532327\n",
       "$$x^{(t)} = Clean$$                 1.0            0.000186"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test log-p: -10.92974259115623\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "logs = fit_viterbi(hmm=hmm_viterbi, X_train=dataset['train'])\n",
    "hmm_basic_info(hmm_viterbi)\n",
    "training_plots(hmm_viterbi, logs['losses'], logs['probas'], dataset['test'])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}