{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(sec:hmm-intro)=\n",
    "# Hidden Markov Models\n",
    "\n",
    "In this section, we discuss the\n",
    "hidden Markov model or HMM,\n",
    "which is a state space model in which the hidden states\n",
    "are discrete, so $\\hidden_t \\in \\{1,\\ldots, \\nstates\\}$.\n",
    "The observations may be discrete,\n",
    "$\\obs_t \\in \\{1,\\ldots, \\nsymbols\\}$,\n",
    "or continuous,\n",
    "$\\obs_t \\in \\real^\\nstates$,\n",
    "or some combination,\n",
    "as we illustrate below.\n",
    "More details can be found in e.g., \n",
    "{cite}`Rabiner89,Fraser08,Cappe05`.\n",
    "For an interactive introduction,\n",
    "see https://nipunbatra.github.io/hmm/."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "{\n",
    "    \"tags\": [\n",
    "        \"hide-cell\"\n",
    "    ]\n",
    "}\n",
    "\n",
    "\n",
    "### Import standard libraries\n",
    "\n",
    "import abc\n",
    "from dataclasses import dataclass\n",
    "import functools\n",
    "from functools import partial\n",
    "import itertools\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from typing import Any, Callable, NamedTuple, Optional, Union, Tuple\n",
    "\n",
    "import jax\n",
    "import jax.numpy as jnp\n",
    "from jax import lax, vmap, jit, grad\n",
    "#from jax.scipy.special import logit\n",
    "#from jax.nn import softmax\n",
    "import jax.random as jr\n",
    "\n",
    "\n",
    "\n",
    "import distrax\n",
    "import optax\n",
    "\n",
    "import jsl\n",
    "import ssm_jax\n",
    "\n",
    "import inspect\n",
    "import inspect as py_inspect\n",
    "import rich\n",
    "from rich import inspect as r_inspect\n",
    "from rich import print as r_print\n",
    "\n",
    "def print_source(fname):\n",
    "    r_print(py_inspect.getsource(fname))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(sec:casino)=\n",
    "### Example: Casino HMM\n",
    "\n",
    "To illustrate HMMs with categorical observation model,\n",
    "we consider the \"Ocassionally dishonest casino\" model from {cite}`Durbin98`.\n",
    "There are 2 hidden states, representing whether the dice being used in the casino is fair or loaded.\n",
    "Each state defines a distribution over the 6 possible observations.\n",
    "\n",
    "The transition model is denoted by\n",
    "```{math}\n",
    "p(\\hidden_t=j|\\hidden_{t-1}=i) = \\hmmTransScalar_{ij}\n",
    "```\n",
    "Here the $i$'th row of $\\hmmTrans$ corresponds to the outgoing distribution from state $i$.\n",
    "This is  a row stochastic matrix,\n",
    "meaning each row sums to one.\n",
    "We can visualize\n",
    "the non-zero entries in the transition matrix by creating a state transition diagram,\n",
    "as shown in \n",
    "{numref}`fig:casino`.\n",
    "\n",
    "```{figure} /figures/casino.png\n",
    ":scale: 50%\n",
    ":name: fig:casino\n",
    "\n",
    "Illustration of the casino HMM.\n",
    "```\n",
    "\n",
    "The  observation model\n",
    "$p(\\obs_t|\\hidden_t=j)$ has the form\n",
    "```{math}\n",
    "p(\\obs_t=k|\\hidden_t=j) = \\hmmObsScalar_{jk} \n",
    "```\n",
    "This is represented by the histograms associated with each\n",
    "state in  {numref}`fig:casino`.\n",
    "\n",
    "Finally,\n",
    "the initial state distribution is denoted by\n",
    "```{math}\n",
    "p(\\hidden_1=j) = \\hmmInitScalar_j\n",
    "```\n",
    "\n",
    "Collectively we denote all the parameters by $\\params=(\\hmmTrans, \\hmmObs, \\hmmInit)$.\n",
    "\n",
    "Now let us implement this model in code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# state transition matrix\n",
    "A = np.array([\n",
    "    [0.95, 0.05],\n",
    "    [0.10, 0.90]\n",
    "])\n",
    "\n",
    "# observation matrix\n",
    "B = np.array([\n",
    "    [1/6, 1/6, 1/6, 1/6, 1/6, 1/6], # fair die\n",
    "    [1/10, 1/10, 1/10, 1/10, 1/10, 5/10] # loaded die\n",
    "])\n",
    "\n",
    "pi = np.array([0.5, 0.5])\n",
    "\n",
    "(nstates, nobs) = np.shape(B)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<distrax._src.utils.hmm.HMM object at 0x7ff18017a7f0>\n"
     ]
    }
   ],
   "source": [
    "import distrax\n",
    "from distrax import HMM\n",
    "\n",
    "\n",
    "hmm = HMM(trans_dist=distrax.Categorical(probs=A),\n",
    "            init_dist=distrax.Categorical(probs=pi),\n",
    "            obs_dist=distrax.Categorical(probs=B))\n",
    "\n",
    "print(hmm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Let's sample from the model. We will generate a sequence of latent states, $\\hidden_{1:T}$,\n",
    "which we then convert to a sequence of observations, $\\obs_{1:T}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing sample observed/latent...\n",
      "x: 633665342652353616444236412331351246651613325161656366246242\n",
      "z: 222222211111111111111111111111111111111222111111112222211111\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "seed = 314\n",
    "n_samples = 300\n",
    "z_hist, x_hist = hmm.sample(seed=jr.PRNGKey(seed), seq_len=n_samples)\n",
    "\n",
    "z_hist_str = \"\".join((np.array(z_hist) + 1).astype(str))[:60]\n",
    "x_hist_str = \"\".join((np.array(x_hist) + 1).astype(str))[:60]\n",
    "\n",
    "print(\"Printing sample observed/latent...\")\n",
    "print(f\"x: {x_hist_str}\")\n",
    "print(f\"z: {z_hist_str}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is the source code for the sampling algorithm.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_source(hmm.sample)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us check correctness by computing empirical pairwise statistics\n",
    "\n",
    "We will compute the number of i->j latent state transitions, and check that it is close to the true \n",
    "A[i,j] transition probabilites."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[225.  92.]\n",
      " [ 92.  90.]]\n",
      "[[0.7097792  0.29022083]\n",
      " [0.50549453 0.4945055 ]]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "import collections\n",
    "def compute_counts(state_seq, nstates):\n",
    "    wseq = np.array(state_seq)\n",
    "    word_pairs = [pair for pair in zip(wseq[:-1], wseq[1:])]\n",
    "    counter_pairs = collections.Counter(word_pairs)\n",
    "    counts = np.zeros((nstates, nstates))\n",
    "    for (k,v) in counter_pairs.items():\n",
    "        counts[k[0], k[1]] = v\n",
    "    return counts\n",
    "\n",
    "\n",
    "def normalize(u, axis=0, eps=1e-15):\n",
    "    u = jnp.where(u == 0, 0, jnp.where(u < eps, eps, u))\n",
    "    c = u.sum(axis=axis)\n",
    "    c = jnp.where(c == 0, 1, c)\n",
    "    return u / c, c\n",
    "\n",
    "def normalize_counts(counts):\n",
    "    ncounts = vmap(lambda v: normalize(v)[0], in_axes=0)(counts)\n",
    "    return ncounts\n",
    "\n",
    "init_dist = jnp.array([1.0, 0.0])\n",
    "trans_mat = jnp.array([[0.7, 0.3], [0.5, 0.5]])\n",
    "obs_mat = jnp.eye(2)\n",
    "\n",
    "hmm = HMM(trans_dist=distrax.Categorical(probs=trans_mat),\n",
    "            init_dist=distrax.Categorical(probs=init_dist),\n",
    "            obs_dist=distrax.Categorical(probs=obs_mat))\n",
    "\n",
    "rng_key = jax.random.PRNGKey(0)\n",
    "seq_len = 500\n",
    "state_seq, _ = hmm.sample(seed=PRNGKey(seed), seq_len=seq_len)\n",
    "\n",
    "counts = compute_counts(state_seq, nstates=2)\n",
    "print(counts)\n",
    "\n",
    "trans_mat_empirical = normalize_counts(counts)\n",
    "print(trans_mat_empirical)\n",
    "\n",
    "assert jnp.allclose(trans_mat, trans_mat_empirical, atol=1e-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our primary goal will be to infer the latent state from the observations,\n",
    "so we can detect if the casino is being dishonest or not. This will\n",
    "affect how we choose to gamble our money.\n",
    "We discuss various ways to perform this inference below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(sec:lillypad)=\n",
    "## Example: Lillypad HMM\n",
    "\n",
    "\n",
    "If $\\obs_t$ is continuous, it is common to use a Gaussian\n",
    "observation model:\n",
    "```{math}\n",
    "p(\\obs_t|\\hidden_t=j) = \\gauss(\\obs_t|\\vmu_j,\\vSigma_j)\n",
    "```\n",
    "This is sometimes called a Gaussian HMM.\n",
    "\n",
    "As a simple example, suppose we have an HMM with 3 hidden states,\n",
    "each of which generates a 2d Gaussian.\n",
    "We can represent these Gaussian distributions are 2d ellipses,\n",
    "as we show below.\n",
    "We call these ``lilly pads'', because of their shape.\n",
    "We can imagine a frog hopping from one lilly pad to another.\n",
    "(This analogy is due to the late Sam Roweis.)\n",
    "The frog will stay on a pad for a while (corresponding to remaining in the same\n",
    "discrete state $\\hidden_t$), and then jump to a new pad\n",
    "(corresponding to a transition to a new state).\n",
    "The data we see are just the 2d points (e.g., water droplets)\n",
    "coming from near the pad that the frog is currently on.\n",
    "Thus this model is like a Gaussian mixture model,\n",
    "in that it generates clusters of observations,\n",
    "except now there is temporal correlation between the data points.\n",
    "\n",
    "Let us now illustrate this model in code.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<distrax._src.utils.hmm.HMM object at 0x7fd658f7b7f0>\n"
     ]
    }
   ],
   "source": [
    "# Let us create the model\n",
    "\n",
    "initial_probs = jnp.array([0.3, 0.2, 0.5])\n",
    "\n",
    "# transition matrix\n",
    "A = jnp.array([\n",
    "[0.3, 0.4, 0.3],\n",
    "[0.1, 0.6, 0.3],\n",
    "[0.2, 0.3, 0.5]\n",
    "])\n",
    "\n",
    "# Observation model\n",
    "mu_collection = jnp.array([\n",
    "[0.3, 0.3],\n",
    "[0.8, 0.5],\n",
    "[0.3, 0.8]\n",
    "])\n",
    "\n",
    "S1 = jnp.array([[1.1, 0], [0, 0.3]])\n",
    "S2 = jnp.array([[0.3, -0.5], [-0.5, 1.3]])\n",
    "S3 = jnp.array([[0.8, 0.4], [0.4, 0.5]])\n",
    "cov_collection = jnp.array([S1, S2, S3]) / 60\n",
    "\n",
    "\n",
    "import tensorflow_probability as tfp\n",
    "\n",
    "if False:\n",
    "    hmm = HMM(trans_dist=distrax.Categorical(probs=A),\n",
    "            init_dist=distrax.Categorical(probs=initial_probs),\n",
    "            obs_dist=distrax.MultivariateNormalFullCovariance(\n",
    "                loc=mu_collection, covariance_matrix=cov_collection))\n",
    "else:\n",
    "    hmm = HMM(trans_dist=distrax.Categorical(probs=A),\n",
    "              init_dist=distrax.Categorical(probs=initial_probs),\n",
    "              obs_dist=distrax.as_distribution(\n",
    "                  tfp.substrates.jax.distributions.MultivariateNormalFullCovariance(loc=mu_collection,\n",
    "                                                                                    covariance_matrix=cov_collection)))\n",
    "\n",
    "print(hmm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50,)\n",
      "(50, 2)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "n_samples, seed = 50, 10\n",
    "samples_state, samples_obs = hmm.sample(seed=PRNGKey(seed), seq_len=n_samples)\n",
    "\n",
    "print(samples_state.shape)\n",
    "print(samples_obs.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "# Let's plot the observed data in 2d\n",
    "xmin, xmax = 0, 1\n",
    "ymin, ymax = 0, 1.2\n",
    "colors = [\"tab:green\", \"tab:blue\", \"tab:red\"]\n",
    "\n",
    "def plot_2dhmm(hmm, samples_obs, samples_state, colors, ax, xmin, xmax, ymin, ymax, step=1e-2):\n",
    "    obs_dist = hmm.obs_dist\n",
    "    color_sample = [colors[i] for i in samples_state]\n",
    "\n",
    "    xs = jnp.arange(xmin, xmax, step)\n",
    "    ys = jnp.arange(ymin, ymax, step)\n",
    "\n",
    "    v_prob = vmap(lambda x, y: obs_dist.prob(jnp.array([x, y])), in_axes=(None, 0))\n",
    "    z = vmap(v_prob, in_axes=(0, None))(xs, ys)\n",
    "\n",
    "    grid = np.mgrid[xmin:xmax:step, ymin:ymax:step]\n",
    "\n",
    "    for k, color in enumerate(colors):\n",
    "        ax.contour(*grid, z[:, :, k], levels=[1], colors=color, linewidths=3)\n",
    "        ax.text(*(obs_dist.mean()[k] + 0.13), f\"$k$={k + 1}\", fontsize=13, horizontalalignment=\"right\")\n",
    "\n",
    "    ax.plot(*samples_obs.T, c=\"black\", alpha=0.3, zorder=1)\n",
    "    ax.scatter(*samples_obs.T, c=color_sample, s=30, zorder=2, alpha=0.8)\n",
    "\n",
    "    return ax, color_sample\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "_, color_sample = plot_2dhmm(hmm, samples_obs, samples_state, colors, ax, xmin, xmax, ymin, ymax)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7fd5e174b460>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's plot the hidden state sequence\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.step(range(n_samples), samples_state, where=\"post\", c=\"black\", linewidth=1, alpha=0.3)\n",
    "ax.scatter(range(n_samples), samples_state, c=color_sample, zorder=3)\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "6407c60499271029b671b4ff687c4ed4626355c45fd34c44476827f4be42c4d7"
  },
  "kernelspec": {
   "display_name": "Python 3.9.2 ('spyder-dev')",
   "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}