stochastic_volatility_mcmc.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stochastic volatility: Bayesian inference\n",
    "\n",
    "This notebook describes estimating the basic univariate stochastic volatility model with Bayesian methods via Markov chain monte carlo (MCMC) methods, as in Kim et al. (1998).\n",
    "\n",
    "The code defining the models and the functions for taking draws from the conditional posteriors is also available in a Python script [`sv.py`](https://github.com/ChadFulton/tsa-notebooks/blob/master/src/sv.py)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from __future__ import division\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import statsmodels.api as sm\n",
    "import matplotlib.pyplot as plt\n",
    "np.set_printoptions(suppress=True, precision=5)\n",
    "\n",
    "from scipy.stats import norm, invgamma\n",
    "from scipy.special import logsumexp\n",
    "\n",
    "from src import sv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A canonical univariate stochastic volatility model from Kim et al. (1998), hereafter KSC, is:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "y_t & = \\beta \n",
    "e^{h_t / 2} \\varepsilon_t & \\varepsilon_t \\sim N(0, 1)\\\\\n",
    "h_{t+1} & = \\mu + \\phi(h_t - \\mu) + \\sigma_\\eta \\eta_t \\qquad & \\eta_t \\sim N(0, 1) \\\\\n",
    "h_1 & \\sim N(\\mu, \\sigma_\\eta^2 / (1 - \\phi^2))\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "Here, $y_t$ usually represents the mean-corrected return of some asset and $h_t$ is log-volatility. Note that $\\beta$ and $\\mu$ are not separately identified, so KSC normalize $\\beta = 1$. However, since $\\beta$ is easier to interpret, they give results in terms of $\\beta = \\exp(\\mu / 2)$. The parameter vector is usually written as $\\theta = (\\phi, \\sigma_\\eta^2, \\mu)$.\n",
    "\n",
    "By taking squares and logs of each side of the first equation, above, we get the following observation equation (here we have set $\\beta = 1$):\n",
    "\n",
    "$$y_t^* = h_t + z_t$$\n",
    "\n",
    "where $y_t^* = \\log (y_t^2 + c)$, $z_t = \\log \\varepsilon_t^2$, and so $E[z_t] = 1.27036$ and $\\text{Var}(z_t) = 4.93$ and $c$ is an offset to prevent numerical issues when $y_t$ is close to zero, set by KSC to $0.001$. Along with the transition equation for $h_t$, above, this forms a non-Gaussian state space model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Illustration\n",
    "\n",
    "For the empirical illustration in this notebook, we will follow KSC in modeling the U.K. Sterling / U.S. Dollar exchange rate between October 1, 1981 and June 28, 1985. This is the same dataset as was used in Harvey et al. (1994), although KSC multiply the mean-corrected returns by 100 (so the results will be a little different than in the notebook replicating Harvey et al. (1994)).\n",
    "\n",
    "Tom Doan of the RATS econometrics software package has made available the replication data at https://estima.com/forum/viewtopic.php?f=8&t=1595."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*** No CODEPAGE record, no encoding_override: will use 'ascii'\n"
     ]
    }
   ],
   "source": [
    "ex = pd.read_excel('data/xrates.xls')\n",
    "dta = np.log(ex).diff().iloc[1:]\n",
    "\n",
    "endog = (dta['USXUK'] - dta['USXUK'].mean()) * 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quasi-likelihood estimation\n",
    "\n",
    "One option for estimating the parameters of this model is the \"quasi-likelihood method\" of Harvey et al. (1994), in which the model is approximated by replacing $\\log \\varepsilon_t^2$ with a Gaussian random variable of the same mean and variance. This approach will only be valid asymptotically, although Ruiz (1994) suggests that it may perform well nonetheless.\n",
    "\n",
    "Since this model was described fully in another notebook, we do not present it again here, but use the state space model described there and stored in [`sv.py`](../files/sv.py)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "mod_QLSV = sv.QLSV(endog)\n",
    "res_QLSV = mod_QLSV.fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                           Statespace Model Results                           \n",
      "==============================================================================\n",
      "Dep. Variable:                  USXUK   No. Observations:                  945\n",
      "Model:                           QLSV   Log Likelihood               -1973.517\n",
      "Date:                Sat, 14 Apr 2018   AIC                           3953.034\n",
      "Time:                        21:52:08   BIC                           3967.588\n",
      "Sample:                             0   HQIC                          3958.581\n",
      "                                - 945                                         \n",
      "Covariance Type:                  opg                                         \n",
      "==============================================================================\n",
      "                 coef    std err          z      P>|z|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "phi            0.9909      0.010     96.107      0.000       0.971       1.011\n",
      "sigma2_eta     0.0059      0.006      0.981      0.327      -0.006       0.018\n",
      "mu            -0.7082      0.331     -2.143      0.032      -1.356      -0.060\n",
      "===================================================================================\n",
      "Ljung-Box (Q):                       26.31   Jarque-Bera (JB):                44.60\n",
      "Prob(Q):                              0.95   Prob(JB):                         0.00\n",
      "Heteroskedasticity (H):               1.14   Skew:                            -0.51\n",
      "Prob(H) (two-sided):                  0.26   Kurtosis:                         2.71\n",
      "===================================================================================\n",
      "\n",
      "Warnings:\n",
      "[1] Covariance matrix calculated using the outer product of gradients (complex-step).\n"
     ]
    }
   ],
   "source": [
    "print(res_QLSV.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bayesian estimation\n",
    "\n",
    "KSC provide an alternative method for estimating this model using Bayesian techniques; instead of approximating $\\log \\varepsilon_t^2$ by a single Gaussian distribution, they approximate it with a mixture of Gaussians, so that:\n",
    "\n",
    "$$z_t | s_t = i \\sim N(m_i - 1.27036, v_i^2)$$\n",
    "\n",
    "where $s_t$ is an indicator random variable defined so that $P(s_t = i) = q_i, i = 1, \\dots, K$ where $K$ is the number of mixture components. The values of $(q_i, m_i, v_i^2)$ that define the component Gaussians are given below (see KSC Table 4, p. 371).\n",
    "\n",
    "**Note**: we provide all Python implementations of the estimation procedure in this notebook, but the functions are also collected in the associated [`sv.py`](../files/sv.py) file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# q_i, m_i, v_i^2\n",
    "ksc_params = np.array([[0.04395, 2.77786,   0.16735],\n",
    "                       [0.24566, 1.79518,   0.34023],\n",
    "                       [0.34001, 0.61942,  0.64009],\n",
    "                       [0.25750, -1.08819,  1.26261],\n",
    "                       [0.10556, -3.97281,  2.61369],\n",
    "                       [0.00002, -8.56686,  5.17950],\n",
    "                       [0.00730, -10.12999, 5.79596]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditional on $\\{ s_t \\}_{t=1}^T$, the observation equation at each time period is well-defined with a Gaussian noise term. Thus conditional on the parameters and the mixing indicators, the stochastic volatility problem can be cast in the form of a time-varying state space model and the Kalman filter and smoother can be used to compute posterior distributions.\n",
    "\n",
    "KSC found that a good approximation of $\\log \\varepsilon_t^2$ could be achieved by setting $K=7$. Omori et al. (2007) extend this to $K=10$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TVLLDT(sm.tsa.statespace.MLEModel):\n",
    "    \"\"\"\n",
    "    Time-varying local linear deterministic trend\n",
    "    \"\"\"\n",
    "    def __init__(self, endog, offset=0.001):\n",
    "        # Convert to log squares, with offset\n",
    "        endog = np.log(endog**2 + offset)\n",
    "\n",
    "        # Initialize base model\n",
    "        super(TVLLDT, self).__init__(endog, k_states=1, k_posdef=1,\n",
    "                                     initialization='stationary')\n",
    "\n",
    "        # Setup time-varying arrays for observation equation\n",
    "        self['obs_intercept'] = np.zeros((1, self.nobs))\n",
    "        self['obs_cov'] = np.zeros((1, 1, self.nobs))\n",
    "\n",
    "        # Setup fixed components of state space matrices\n",
    "        self['design', 0, 0] = 1\n",
    "        self['selection', 0, 0] = 1\n",
    "\n",
    "    def update_mixing(self, indicators):\n",
    "        # z_t | s_t ~ N(m_i - 1.27036, v_i^2)\n",
    "        # See equation (10), p. 371\n",
    "        self['obs_intercept', 0] = ksc_params[indicators, 1] - 1.27036\n",
    "        self['obs_cov', 0, 0] = ksc_params[indicators, 2]\n",
    "\n",
    "    def update(self, params, **kwargs):\n",
    "        params = super(TVLLDT, self).update(params, **kwargs)\n",
    "\n",
    "        self['state_intercept', 0, 0] = params[0] * (1 - params[1])\n",
    "        self['transition', 0, 0] = params[1]\n",
    "        self['state_cov', 0, 0] = params[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Priors\n",
    "\n",
    "To compute the model, we need to specify a prior distribution for the parameters in $\\theta$. The prior specifications below are taken from KSC.\n",
    "\n",
    "#### Prior for $\\sigma_\\eta^2$\n",
    "\n",
    "We consider the conjugate prior:\n",
    "\n",
    "$$\\sigma_\\eta^2 | \\phi, \\mu \\sim IG(\\sigma_r / s, S_\\sigma / 2)$$\n",
    "\n",
    "where we follow them setting $\\sigma_r = 5$ and $S_\\sigma = 0.01 \\times \\sigma_r = 0.05$.\n",
    "\n",
    "#### Prior for $\\phi$\n",
    "\n",
    "Defining $\\phi^* = (\\phi + 1) / 2$, we specify a prior on $\\phi^*$:\n",
    "\n",
    "$$\\phi^* \\sim Beta(\\phi^{(1)}, \\phi^{(2)})$$\n",
    "\n",
    "As discussed in KSC, this prior has support over $(-1, 1)$, enforcing stationarity of the stochastic volatility process.\n",
    "\n",
    "Setting $\\phi^{(1)} = 20$ and $\\phi^{(2)} = 1.5$ implies that $E[\\phi] = 0.86$.\n",
    "\n",
    "Finally:\n",
    "\n",
    "$$\\pi(\\phi) \\propto \\left [ \\frac{(1 + \\phi)}{2} \\right ]^{\\phi^{(1)} - 1} \\left [ \\frac{(1 - \\phi)}{2} \\right ]^{\\phi^{(2)} - 1} $$\n",
    "\n",
    "#### Prior for $\\mu$\n",
    "\n",
    "KSC suggest a diffuse prior on $\\mu$ (or alternatively a slightly informative prior like $\\mu \\sim N(0, 10)$)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sampling from the conditional posteriors\n",
    "\n",
    "KSC show that with the priors specified above, we can sample from the conditional posteriors as follows:\n",
    "\n",
    "#### Sampling $\\sigma_\\eta^2$\n",
    "\n",
    "The conditional posterior distribution is:\n",
    "\n",
    "$$\\sigma_\\eta^2 | y, h, \\phi, \\mu \\sim IG \\left ( \\frac{n + \\sigma_r}{2},\n",
    "\\frac{S_\\sigma + (h_1 - \\mu)^2(1 - \\phi^2) + \\sum_{i=1}^{n-1} [(h_{t+1} - \\mu) - \\phi(h_t-\\mu)]^2}{2} \\right )$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_posterior_sigma2(model, states, phi, mu, prior_params=(5, 0.05)):\n",
    "    sigma_r, S_sigma = prior_params\n",
    "\n",
    "    v1 = sigma_r + model.nobs\n",
    "    tmp1 = (states[0, 0] - mu)**2 * (1 - phi**2)\n",
    "    tmp = np.sum(((states[0, 1:] - mu) - phi * (states[0, :-1] - mu))**2)\n",
    "    delta1 = S_sigma + tmp1 + tmp\n",
    "\n",
    "    return invgamma.rvs(v1, scale=delta1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sampling $\\phi$\n",
    "\n",
    "We can apply a Metropolis step: generating a proposal value $\\phi^*$ from $N(\\hat \\phi, V_\\theta)$ and accepting the proposal with probability\n",
    "\n",
    "$$\\exp(g(\\phi^*) - g(\\phi^{(i-1)}))$$\n",
    "\n",
    "where:\n",
    "\n",
    "$$g(\\phi) = \\log \\pi(\\phi) - \\frac{(h_1 - \\mu)^2 (1 - \\phi^2)}{2 \\sigma_\\eta^2} + \\frac{1}{2} \\log (1 - \\phi^2)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g(phi, states, mu, sigma2, prior_params=(20, 1.5)):\n",
    "    phi_1, phi_2 = prior_params\n",
    "\n",
    "    # Prior distribution gives zero weight to non-stationary processes\n",
    "    if np.abs(phi) >= 1:\n",
    "        return -np.inf\n",
    "\n",
    "    prior = ((1 + phi) / 2)**(phi_1 - 1) * ((1 - phi) / 2)**(phi_2 - 1)\n",
    "\n",
    "    tmp1 = (states[0, 0] - mu)**2 * (1 - phi**2) / 2 * sigma2\n",
    "    tmp2 = 0.5 * np.log(1 - phi**2)\n",
    "\n",
    "    return np.log(prior) - tmp1 + tmp2\n",
    "\n",
    "def draw_posterior_phi(model, states, phi, mu, sigma2, prior_params=(20, 1.5)):\n",
    "    tmp1 = np.sum((states[0, 1:] - mu) * (states[0, :-1] - mu))\n",
    "    tmp2 = np.sum((states[0, :-1] - mu)**2)\n",
    "    phi_hat = tmp1 / tmp2\n",
    "    V_phi = sigma2 / tmp2\n",
    "\n",
    "    proposal = norm.rvs(phi_hat, scale=V_phi**0.5)\n",
    "    g_proposal = g(proposal, states, mu, sigma2, prior_params)\n",
    "    g_previous = g(phi, states, mu, sigma2, prior_params)\n",
    "    acceptance_probability = np.exp(g_proposal - g_previous)\n",
    "\n",
    "    return proposal if acceptance_probability > np.random.uniform() else phi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sampling $\\mu$\n",
    "\n",
    "The conditional posterior distribution is:\n",
    "\n",
    "$$\\mu | y, h, \\phi, \\sigma_\\eta^2 \\sim N (\\hat \\mu, \\sigma_\\mu^2)$$\n",
    "\n",
    "where:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\hat \\mu & = \\sigma_\\mu^2 \\left [ \\frac{(1 - \\phi^2)}{\\sigma_\\eta^2} h_1 + \\frac{(1 - \\phi)}{\\sigma_\\eta^2} \\sum_{t=1}^{n-1} (h_{t+1} - \\phi h_t) \\right ] \\\\\n",
    "\\sigma_\\mu^2 & = \\sigma_\\eta^2 \\left [ (n - 1)(1 - \\phi)^2 + (1 - \\phi^2) \\right ]^{-1}\n",
    "\\end{aligned}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_posterior_mu(model, states, phi, sigma2):\n",
    "    sigma2_mu = sigma2 / ((model.nobs - 1) * (1 - phi)**2 + (1 - phi**2))\n",
    "\n",
    "    tmp1 = ((1 - phi**2) / sigma2) * states[0, 0]\n",
    "    tmp = ((1 - phi) / sigma2) * np.sum(states[0, 1:] - phi * states[0, :-1])\n",
    "    mu_hat = sigma2_mu * (tmp1 + tmp)\n",
    "\n",
    "    return norm.rvs(loc=mu_hat, scale=sigma2_mu**0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sampling $\\{h_t\\}_{t=1}^T$\n",
    "\n",
    "Conditional on the mixing indicators (which yield the time-varying observation equation matrices) and the parameters, the states can be sampled via the usual simulation smoother.\n",
    "\n",
    "#### Sampling $\\{s_t\\}_{t=1}^T$\n",
    "\n",
    "Each indicator $s_t$ can only take a discrete number of values (since it is an indicator variable denoting which of the mixing distributions is active at time $t$). KSC show that the mixing indicators can be independently sampled from the following probability mass function:\n",
    "\n",
    "$$\n",
    "P[s_t = i | \\cdot] \\propto q_i f_N( y_t^* | h_t + m_i - 1.2704, v_i^2)\n",
    "$$\n",
    "\n",
    "where $f_N( y_t^* \\mid a, b)$ denotes the probability density at $y_t^*$ of a Gaussian random variable with mean $a$ and variance $b$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mixing_posterior(mod, states):\n",
    "    resid = mod.endog[:, 0] - states[0]\n",
    "\n",
    "    # Construct the means (nobs x 7), variances (7,), prior probabilities (7,)\n",
    "    means = ksc_params[None, :, 1] - 1.27036\n",
    "    variances = ksc_params[:, 2]\n",
    "    prior_probabilities = ksc_params[:, 0]\n",
    "\n",
    "    # Make dimensions compatible for broadcasting\n",
    "    resid = np.repeat(resid[:, None], len(variances), axis=-1)\n",
    "    variances = np.repeat(variances[None, :], mod.nobs, axis=0)\n",
    "    prior_probabilities = np.repeat(prior_probabilities[None, :], mod.nobs,\n",
    "                                    axis=0)\n",
    "\n",
    "    # Compute loglikelihood (nobs x 7)\n",
    "    loglikelihoods = -0.5 * ((resid - means)**2 / variances +\n",
    "                             np.log(2 * np.pi * variances))\n",
    "\n",
    "    # Get (values proportional to) the (log of the) posterior (nobs x 7)\n",
    "    posterior_kernel = loglikelihoods + np.log(prior_probabilities)\n",
    "\n",
    "    # Normalize to get the actual posterior probabilities\n",
    "    tmp = logsumexp(posterior_kernel, axis=1)\n",
    "    posterior_probabilities = np.exp(posterior_kernel - tmp[:, None])\n",
    "\n",
    "    return posterior_probabilities\n",
    "\n",
    "def draw_mixing(mod, states):\n",
    "    posterior_probabilities = mixing_posterior(mod, states)\n",
    "\n",
    "    # Draw from the posterior\n",
    "    variates = np.random.uniform(size=mod.nobs)\n",
    "    tmp = np.cumsum(posterior_probabilities, axis=1) > variates[:, None]\n",
    "    sample = np.argmax(tmp, axis=1)\n",
    "\n",
    "    return sample"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MCMC\n",
    "\n",
    "Below we perform 10,000 iterations to sample from the posterior. When presenting results, below, we will drop the first 5,000 iterations as the burn-in period, and of the remaining 5,000 iterations we will save only every tenth iteration. Results will then be computed from the remaining 500 iterations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(1234)\n",
    "\n",
    "# Setup the model and simulation smoother\n",
    "mod = TVLLDT(endog)\n",
    "mod.set_smoother_output(0, smoother_state=True)\n",
    "sim = mod.simulation_smoother()\n",
    "\n",
    "# Simulation parameters\n",
    "n_iterations = 10000\n",
    "burn = 5000\n",
    "thin = 10\n",
    "\n",
    "# Storage for traces\n",
    "trace_smoothed = np.zeros((n_iterations + 1, mod.nobs))\n",
    "trace_states = np.zeros((n_iterations + 1, mod.nobs))\n",
    "trace_mixing = np.zeros((n_iterations + 1, mod.nobs), int)\n",
    "trace_mu = np.zeros((n_iterations + 1, 1))\n",
    "trace_phi = np.zeros((n_iterations + 1, 1))\n",
    "trace_sigma2 = np.zeros((n_iterations + 1, 1))\n",
    "\n",
    "# Initial values (p. 367)\n",
    "trace_mixing[0] = 0\n",
    "trace_mu[0] = 0\n",
    "trace_phi[0] = 0.95\n",
    "trace_sigma2[0] = 0.5\n",
    "\n",
    "# Iterations\n",
    "for s in range(1, n_iterations + 1):\n",
    "    # Update the parameters of the model\n",
    "    mod.update_mixing(trace_mixing[s-1])\n",
    "    params = np.r_[trace_mu[s-1], trace_phi[s-1], trace_sigma2[s-1]]\n",
    "    mod.update(params, transformed=True)\n",
    "    \n",
    "    # Simulation smoothing\n",
    "    sim.simulate()\n",
    "    states = sim.simulated_state\n",
    "    trace_states[s] = states[0]\n",
    "\n",
    "    # Draw mixing indicators\n",
    "    trace_mixing[s] = draw_mixing(mod, states)\n",
    "    \n",
    "    # Draw parameters\n",
    "    trace_phi[s] = draw_posterior_phi(mod, states, trace_phi[s-1], trace_mu[s-1], trace_sigma2[s-1])\n",
    "    trace_sigma2[s] = draw_posterior_sigma2(mod, states, trace_phi[s-1], trace_mu[s-1])\n",
    "    trace_mu[s] = draw_posterior_mu(mod, states, trace_phi[s-1], trace_sigma2[s-1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results\n",
    "\n",
    "Below we present the posterior means for the parameters. This replicates Table 5 from KSC. We also show the corresponding QMLE estimates. These latter are similar to the posterior means for $\\phi$ and $\\beta$ but the QMLE estimate of $\\sigma_\\eta$ is about half that from the Bayesian approach, potentially demonstrating a downside of the quasi-likelihood approach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Replication of Table 5 from KSC: means of posterior draws from MCMC (value from KSC in parentheses)\n",
      "  phi | y        = 0.97600 (0.97779)\n",
      "  sigma | y      = 0.15947 (0.15850)\n",
      "  beta | y       = 0.65292 (0.64733)\n",
      "\n",
      "QMLE estimates\n",
      "  phi            = 0.99091\n",
      "  sigma          = 0.07663\n",
      "  beta           = 0.70181\n"
     ]
    }
   ],
   "source": [
    "# Means of parameters\n",
    "mean_phi = np.mean(trace_phi[burn::thin])\n",
    "mean_sigma = np.mean(trace_sigma2[burn::thin]**0.5)\n",
    "mean_beta = np.mean(np.exp(trace_mu[burn::thin] / 2))\n",
    "\n",
    "print('Replication of Table 5 from KSC: means of posterior draws from MCMC (value from KSC in parentheses)')\n",
    "print('  phi | y        = %.5f (0.97779)' % mean_phi)\n",
    "print('  sigma | y      = %.5f (0.15850)' % mean_sigma)\n",
    "print('  beta | y       = %.5f (0.64733)' % mean_beta)\n",
    "print('')\n",
    "print('QMLE estimates')\n",
    "print('  phi            = %.5f' % res_QLSV.params[0])\n",
    "print('  sigma          = %.5f' % res_QLSV.params[1]**0.5)\n",
    "print('  beta           = %.5f' % np.exp(res_QLSV.params[2] / 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the parameter $\\sigma_\\eta$ controls the variance of the underlying stochastic volatility process, underestimation will dampen changes in the volatility process over the sample. This is shown in the graph, below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(15, 4))\n",
    "\n",
    "posterior_states = np.percentile(trace_states[burn::thin], (15, 50, 85), axis=0)\n",
    "\n",
    "ax.plot(posterior_states[1], label='Posterior median')\n",
    "ax.fill_between(np.arange(mod.nobs), posterior_states[0], posterior_states[2], alpha=0.2)\n",
    "ax.plot(res_QLSV.smoothed_state[0], label='QMLE')\n",
    "ax.set(title='Estimated stochastic volatility: posterior median and 15%/85% credible set',\n",
    "       xlabel=r'$t$', xlim=(0, len(endog)))\n",
    "ax.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we may be interested in the full conditional posterior distributions of the parameters. These are shown below, along with the posterior means and the QMLE estimates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x288 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n",
    "\n",
    "axes[0].hist(trace_phi[burn::thin])\n",
    "ylim = (0, 140)\n",
    "axes[0].vlines(mean_phi, ylim[0], ylim[1], label='Posterior mean')\n",
    "axes[0].vlines(res_QLSV.params[0], ylim[0], ylim[1], color='r', label='QMLE')\n",
    "axes[0].set(title=r'$\\phi$', ylim=ylim)\n",
    "axes[0].legend(loc='upper left')\n",
    "\n",
    "axes[1].hist(trace_sigma2[burn::thin]**0.5)\n",
    "ylim = (0, 110)\n",
    "axes[1].vlines(mean_sigma, ylim[0], ylim[1], label='Posterior mean')\n",
    "axes[1].vlines(res_QLSV.params[1]**0.5, ylim[0], ylim[1], color='r', label='QMLE')\n",
    "axes[1].set(title=r'$\\sigma_\\eta$', ylim=ylim)\n",
    "\n",
    "axes[2].hist(np.exp(trace_mu[burn::thin] / 2))\n",
    "ylim = (0, 340)\n",
    "axes[2].vlines(mean_beta, ylim[0], ylim[1], label='Posterior mean')\n",
    "axes[2].vlines(np.exp(res_QLSV.params[2] / 2), ylim[0], ylim[1], color='r', label='QMLE')\n",
    "axes[2].set(title=r'$\\beta$', ylim=ylim);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}