sample.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import pymc4 as pm\n",
    "import arviz as az\n",
    "\n",
    "import tensorflow_probability as tfp\n",
    "\n",
    "use_tf_eager = True "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use try/except so we can easily re-execute the whole notebook.\n",
    "if use_tf_eager:\n",
    "    try:\n",
    "        tf.enable_eager_execution()\n",
    "    except:\n",
    "        pass\n",
    "\n",
    "def evaluate(tensors):\n",
    "    \"\"\"Evaluates Tensor or EagerTensor to Numpy `ndarray`s.\n",
    "    Args:\n",
    "    tensors: Object of `Tensor` or EagerTensor`s; can be `list`, `tuple`,\n",
    "        `namedtuple` or combinations thereof.\n",
    "\n",
    "    Returns:\n",
    "        ndarrays: Object with same structure as `tensors` except with `Tensor` or\n",
    "          `EagerTensor`s replaced by Numpy `ndarray`s.\n",
    "    \"\"\"\n",
    "    if tf.executing_eagerly():\n",
    "        return tf.contrib.framework.nest.pack_sequence_as(\n",
    "            tensors,\n",
    "            [t.numpy() if tf.contrib.framework.is_tensor(t) else t\n",
    "             for t in tf.contrib.framework.nest.flatten(tensors)])\n",
    "    return sess.run(tensors)\n",
    "\n",
    "def session_options(enable_gpu_ram_resizing=True, enable_xla=True):\n",
    "    \"\"\"\n",
    "    Allowing the notebook to make use of GPUs if they're available.\n",
    "    \n",
    "    XLA (Accelerated Linear Algebra) is a domain-specific compiler for linear \n",
    "    algebra that optimizes TensorFlow computations.\n",
    "    \"\"\"\n",
    "    config = tf.ConfigProto()\n",
    "    config.log_device_placement = True\n",
    "    if enable_gpu_ram_resizing:\n",
    "        # `allow_growth=True` makes it possible to connect multiple colabs to your\n",
    "        # GPU. Otherwise the colab malloc's all GPU ram.\n",
    "        config.gpu_options.allow_growth = True\n",
    "    if enable_xla:\n",
    "        # Enable on XLA. https://www.tensorflow.org/performance/xla/.\n",
    "        config.graph_options.optimizer_options.global_jit_level = (\n",
    "            tf.OptimizerOptions.ON_1)\n",
    "    return config\n",
    "\n",
    "\n",
    "def reset_sess(config=None):\n",
    "    \"\"\"\n",
    "    Convenience function to create the TF graph & session or reset them.\n",
    "    \"\"\"\n",
    "    if config is None:\n",
    "        config = session_options()\n",
    "    global sess\n",
    "    tf.reset_default_graph()\n",
    "    try:\n",
    "        sess.close()\n",
    "    except:\n",
    "        pass\n",
    "    sess = tf.InteractiveSession(config=config)\n",
    "\n",
    "reset_sess()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<pymc4._random_variables.Normal at 0x1c2eb992b0>,\n",
       " <pymc4._random_variables.HalfNormal at 0x1c2eb993c8>,\n",
       " <pymc4._random_variables.Normal at 0x1c2ea75dd8>,\n",
       " <pymc4._random_variables.Normal at 0x1c2eb994e0>]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@pm.model\n",
    "def t_test(sd_prior='half_normal'):\n",
    "    mu = pm.Normal('mu', 0, 1)\n",
    "    sd = pm.HalfNormal('sd', 1)\n",
    "    pm.Normal('y_0', 0, 2 * sd)\n",
    "    pm.Normal('y_1', mu, 2 * sd)\n",
    "\n",
    "model = t_test.configure()\n",
    "\n",
    "model._forward_context.vars"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HMC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample(model, nsteps=200, burnin=100, leapfrog_steps=10, defun=True):\n",
    "    # Since HMC operates over unconstrained space, we need to transform the\n",
    "    # samples so they live in real-space.\n",
    "    random_variables = model._forward_context.vars\n",
    "    unconstraining_bijectors = []\n",
    "    inits = []\n",
    "    for rv in random_variables:\n",
    "        inits.append(tf.ones(rv.sample().shape))\n",
    "        if isinstance(rv, pm.Normal):\n",
    "            unconstraining_bijectors.append(tfp.bijectors.Identity())\n",
    "        elif isinstance(rv, pm.HalfNormal):\n",
    "            unconstraining_bijectors.append(tfp.bijectors.Exp())\n",
    "        else:\n",
    "            print('rv not identifiable')\n",
    "\n",
    "    unnormalized_posterior_log_prob = model.make_logp_function()\n",
    "    \n",
    "    if tf.executing_eagerly() and defun:\n",
    "        # compile logp to speed things up\n",
    "        unnormalized_posterior_log_prob = tf.contrib.eager.defun(\n",
    "            unnormalized_posterior_log_prob)\n",
    "\n",
    "    # Initialize the step_size. (It will be automatically adapted.)\n",
    "    with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\n",
    "        step_size = tf.get_variable(\n",
    "            name='step_size',\n",
    "            initializer=tf.constant(0.5, dtype=tf.float32),\n",
    "            trainable=False,\n",
    "            use_resource=True\n",
    "        )\n",
    "\n",
    "    if tf.executing_eagerly() and defun:\n",
    "        sample_chain = tf.contrib.eager.defun(tfp.mcmc.sample_chain)\n",
    "    else:\n",
    "        sample_chain = tfp.mcmc.sample_chain\n",
    "    \n",
    "    # Defining the HMC\n",
    "    hmc = tfp.mcmc.TransformedTransitionKernel(\n",
    "        inner_kernel=tfp.mcmc.HamiltonianMonteCarlo(\n",
    "            target_log_prob_fn=unnormalized_posterior_log_prob,\n",
    "            num_leapfrog_steps=leapfrog_steps,\n",
    "            step_size=step_size,\n",
    "            step_size_update_fn=tfp.mcmc.make_simple_step_size_update_policy(100),\n",
    "            state_gradients_are_stopped=False),\n",
    "        bijector=unconstraining_bijectors)\n",
    "\n",
    "    # Sampling from the chain.\n",
    "    posterior_samples_tensor, kernel_results = sample_chain(\n",
    "        num_results=nsteps,\n",
    "        num_burnin_steps=burnin,\n",
    "        current_state=inits,\n",
    "        kernel=hmc)\n",
    "\n",
    "    # Initialize any created variables.\n",
    "    init_g = tf.global_variables_initializer()\n",
    "    init_l = tf.local_variables_initializer()\n",
    "    \n",
    "    evaluate(init_g)\n",
    "    evaluate(init_l)\n",
    "    \n",
    "    *posterior_samples, kernel_results_ = evaluate([\n",
    "        *posterior_samples_tensor,\n",
    "        kernel_results,\n",
    "    ])\n",
    "    \n",
    "    trace = {rv.name: arr for rv, arr in zip(random_variables, posterior_samples)}\n",
    "    \n",
    "    return az.dict_to_dataset(trace), kernel_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/twiecki/anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/math_grad.py:80: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From /Users/twiecki/anaconda3/lib/python3.6/site-packages/tensorflow/python/ops/math_ops.py:3067: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "CPU times: user 4.12 s, sys: 270 ms, total: 4.39 s\n",
      "Wall time: 4.02 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "trace, sampler_stats = sample(model, defun=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 39.4 s, sys: 280 ms, total: 39.7 s\n",
      "Wall time: 41 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "trace, sampler_stats = sample(model, defun=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "az.plot_trace(trace);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NUTS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "import cProfile\n",
    "import time\n",
    "import pstats\n",
    "\n",
    "tfe = tf.contrib.eager\n",
    "tfd = tfp.distributions\n",
    "# Copyright 2018 The TensorFlow Probability Authors.\n",
    "#\n",
    "# Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "# you may not use this file except in compliance with the License.\n",
    "# You may obtain a copy of the License at\n",
    "#\n",
    "#     http://www.apache.org/licenses/LICENSE-2.0\n",
    "#\n",
    "# Unless required by applicable law or agreed to in writing, software\n",
    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "# See the License for the specific language governing permissions and\n",
    "# limitations under the License.\n",
    "# ============================================================================\n",
    "\"\"\"No U-Turn Sampler via an Eager-only single-chain implementation.\n",
    "The implementation uses minimal abstractions and data structures: it applies\n",
    "Python callables, lists, and Tensors. It closely follows [1; Algorithm 3] in\n",
    "that there exists a \"build tree\" function that recursively builds the No-U-Turn\n",
    "Sampler trajectory. The path length is set adaptively; the step size is fixed.\n",
    "Future work may abstract this code as part of a Markov chain Monte Carlo\n",
    "library.\n",
    "#### References\n",
    "[1]: Matthew D. Hoffman, Andrew Gelman. The No-U-Turn Sampler: Adaptively\n",
    "     Setting Path Lengths in Hamiltonian Monte Carlo.\n",
    "     In _Journal of Machine Learning Research_, 15(1):1593-1623, 2014.\n",
    "     http://jmlr.org/papers/volume15/hoffman14a/hoffman14a.pdf\n",
    "\"\"\"\n",
    "\n",
    "def nuts(target_log_prob_fn,\n",
    "           current_state,\n",
    "           step_size,\n",
    "           seed=None,\n",
    "           current_target_log_prob=None,\n",
    "           current_grads_target_log_prob=None,\n",
    "           name=None):\n",
    "  \"\"\"Simulates a No-U-Turn Sampler (NUTS) trajectory.\n",
    "  Args:\n",
    "    target_log_prob_fn: Python callable which takes an argument like\n",
    "      `*current_state` and returns its (possibly unnormalized) log-density under\n",
    "      the target distribution.\n",
    "    current_state: List of `Tensor`s representing the states to simulate from.\n",
    "    step_size: List of `Tensor`s representing the step sizes for the leapfrog\n",
    "      integrator. Must have same shape as `current_state`.\n",
    "    seed: Integer to seed the random number generator.\n",
    "    current_target_log_prob: Scalar `Tensor` representing the value of\n",
    "      `target_log_prob_fn` at the `current_state`.\n",
    "    current_grads_target_log_prob: List of `Tensor`s representing gradient of\n",
    "      `current_target_log_prob` with respect to `current_state`. Must have same\n",
    "      shape as `current_state`.\n",
    "    name: A name for the operation.\n",
    "  Returns:\n",
    "    next_state: List of `Tensor`s representing the next states of the NUTS\n",
    "      trajectory. Has same shape as `current_state`.\n",
    "    next_target_log_prob: Scalar `Tensor` representing the value of\n",
    "      `target_log_prob_fn` at `next_state`.\n",
    "    next_grads_target_log_prob: List of `Tensor`s representing the gradient of\n",
    "      `next_target_log_prob` with respect to `next_state`.\n",
    "  Raises:\n",
    "    NotImplementedError: If the execution mode is not eager.\n",
    "  \"\"\"\n",
    "  if not tf.executing_eagerly():\n",
    "    raise NotImplementedError(\"`kernel` is only available in Eager mode.\")\n",
    "\n",
    "  with tf.name_scope(name,\n",
    "                     default_name=\"nuts_kernel\",\n",
    "                     values=[current_state, step_size, seed,\n",
    "                             current_target_log_prob,\n",
    "                             current_grads_target_log_prob]):\n",
    "    with tf.name_scope(\"initialize\"):\n",
    "      current_state = [tf.convert_to_tensor(s) for s in current_state]\n",
    "      step_size = [tf.convert_to_tensor(s) for s in step_size]\n",
    "      value_and_gradients_fn = tfe.value_and_gradients_function(\n",
    "          target_log_prob_fn)\n",
    "      #value_and_gradients_fn = _embed_no_none_gradient_check(\n",
    "      #    value_and_gradients_fn)\n",
    "      if (current_target_log_prob is None or\n",
    "          current_grads_target_log_prob is None):\n",
    "        (current_target_log_prob,\n",
    "         current_grads_target_log_prob) = value_and_gradients_fn(*current_state)\n",
    "\n",
    "      seed_stream = tfd.SeedStream(seed, \"nuts_kernel\")\n",
    "      current_momentum = []\n",
    "      for state_tensor in current_state:\n",
    "        momentum_tensor = tf.random_normal(shape=tf.shape(state_tensor),\n",
    "                                           dtype=state_tensor.dtype,\n",
    "                                           seed=seed_stream())\n",
    "        current_momentum.append(momentum_tensor)\n",
    "\n",
    "      # Draw a slice variable u ~ Uniform(0, p(initial state, initial\n",
    "      # momentum)) and compute log u. For numerical stability, we perform this\n",
    "      # in log space where log u = log (u' * p(...)) = log u' + log\n",
    "      # p(...) and u' ~ Uniform(0, 1).\n",
    "      log_slice_sample = tf.log(tf.random_uniform([], seed=seed_stream()))\n",
    "      log_slice_sample += _log_joint(current_target_log_prob,\n",
    "                                     current_momentum)\n",
    "\n",
    "      # Initialize loop variables. It comprises a collection of information\n",
    "      # about a \"reverse\" state, a collection of information about a \"forward\"\n",
    "      # state, a collection of information about the next state,\n",
    "      # the trajectory's tree depth, the number of candidate states, and\n",
    "      # whether to continue the trajectory.\n",
    "      reverse_state = current_state\n",
    "      reverse_target_log_prob = current_target_log_prob\n",
    "      reverse_grads_target_log_prob = current_grads_target_log_prob\n",
    "      reverse_momentum = current_momentum\n",
    "      forward_state = current_state\n",
    "      forward_target_log_prob = current_target_log_prob\n",
    "      forward_grads_target_log_prob = current_grads_target_log_prob\n",
    "      forward_momentum = current_momentum\n",
    "      next_state = current_state\n",
    "      next_target_log_prob = current_target_log_prob\n",
    "      next_grads_target_log_prob = current_grads_target_log_prob\n",
    "      depth = 0\n",
    "      num_states = 1\n",
    "      continue_trajectory = True\n",
    "\n",
    "    while continue_trajectory:\n",
    "      # Grow the No-U-Turn Sampler trajectory by choosing a random direction and\n",
    "      # simulating Hamiltonian dynamics in that direction. This extends either\n",
    "      # the forward or reverse state.\n",
    "      direction = tfp.math.random_rademacher([], seed=seed_stream())\n",
    "      if direction < 0:\n",
    "        [\n",
    "            reverse_state,\n",
    "            reverse_target_log_prob,\n",
    "            reverse_grads_target_log_prob,\n",
    "            reverse_momentum,\n",
    "            _,\n",
    "            _,\n",
    "            _,\n",
    "            _,\n",
    "            next_state_in_subtree,\n",
    "            next_target_log_prob_in_subtree,\n",
    "            next_grads_target_log_prob_in_subtree,\n",
    "            num_states_in_subtree,\n",
    "            continue_trajectory,\n",
    "        ] = _build_tree(\n",
    "            value_and_gradients_fn=value_and_gradients_fn,\n",
    "            current_state=reverse_state,\n",
    "            current_target_log_prob=reverse_target_log_prob,\n",
    "            current_grads_target_log_prob=reverse_grads_target_log_prob,\n",
    "            current_momentum=reverse_momentum,\n",
    "            direction=direction,\n",
    "            depth=depth,\n",
    "            step_size=step_size,\n",
    "            log_slice_sample=log_slice_sample,\n",
    "            seed=seed_stream())\n",
    "      else:\n",
    "        [\n",
    "            _,\n",
    "            _,\n",
    "            _,\n",
    "            _,\n",
    "            forward_state,\n",
    "            forward_target_log_prob,\n",
    "            forward_grads_target_log_prob,\n",
    "            forward_momentum,\n",
    "            next_state_in_subtree,\n",
    "            next_target_log_prob_in_subtree,\n",
    "            next_grads_target_log_prob_in_subtree,\n",
    "            num_states_in_subtree,\n",
    "            continue_trajectory,\n",
    "        ] = _build_tree(\n",
    "            value_and_gradients_fn=value_and_gradients_fn,\n",
    "            current_state=forward_state,\n",
    "            current_target_log_prob=forward_target_log_prob,\n",
    "            current_grads_target_log_prob=forward_grads_target_log_prob,\n",
    "            current_momentum=forward_momentum,\n",
    "            direction=direction,\n",
    "            depth=depth,\n",
    "            step_size=step_size,\n",
    "            log_slice_sample=log_slice_sample,\n",
    "            seed=seed_stream())\n",
    "\n",
    "      if continue_trajectory:\n",
    "        # If the built tree did not terminate, accept the tree's next state\n",
    "        # with a certain probability.\n",
    "        accept_state_in_subtree = _random_bernoulli(\n",
    "            [],\n",
    "            probs=tf.minimum(1., num_states_in_subtree / num_states),\n",
    "            dtype=tf.bool,\n",
    "            seed=seed_stream())\n",
    "        if accept_state_in_subtree:\n",
    "          next_state = next_state_in_subtree\n",
    "          next_target_log_prob = next_target_log_prob_in_subtree\n",
    "          next_grads_target_log_prob = next_grads_target_log_prob_in_subtree\n",
    "\n",
    "      # Continue the NUTS trajectory if the tree-building did not terminate, and\n",
    "      # if the reverse-most and forward-most states do not exhibit a U-turn.\n",
    "      has_no_u_turn = tf.logical_and(\n",
    "          _has_no_u_turn(forward_state, reverse_state, forward_momentum),\n",
    "          _has_no_u_turn(forward_state, reverse_state, reverse_momentum))\n",
    "      continue_trajectory = continue_trajectory and has_no_u_turn\n",
    "      num_states += num_states_in_subtree\n",
    "      depth += 1\n",
    "\n",
    "    return next_state, next_target_log_prob, next_grads_target_log_prob\n",
    "\n",
    "\n",
    "def _build_tree(value_and_gradients_fn,\n",
    "                current_state,\n",
    "                current_target_log_prob,\n",
    "                current_grads_target_log_prob,\n",
    "                current_momentum,\n",
    "                direction,\n",
    "                depth,\n",
    "                step_size,\n",
    "                log_slice_sample,\n",
    "                max_simulation_error=1000.,\n",
    "                seed=None):\n",
    "  \"\"\"Builds a tree at a given tree depth and at a given state.\n",
    "  The `current` state is immediately adjacent to, but outside of,\n",
    "  the subtrajectory spanned by the returned `forward` and `reverse` states.\n",
    "  Args:\n",
    "    value_and_gradients_fn: Python callable which takes an argument like\n",
    "      `*current_state` and returns a tuple of its (possibly unnormalized)\n",
    "      log-density under the target distribution and its gradient with respect to\n",
    "      each state.\n",
    "    current_state: List of `Tensor`s representing the current states of the\n",
    "      NUTS trajectory.\n",
    "    current_target_log_prob: Scalar `Tensor` representing the value of\n",
    "      `target_log_prob_fn` at the `current_state`.\n",
    "    current_grads_target_log_prob: List of `Tensor`s representing gradient of\n",
    "      `current_target_log_prob` with respect to `current_state`. Must have same\n",
    "      shape as `current_state`.\n",
    "    current_momentum: List of `Tensor`s representing the momentums of\n",
    "      `current_state`. Must have same shape as `current_state`.\n",
    "    direction: int that is either -1 or 1. It determines whether to perform\n",
    "      leapfrog integration backwards (reverse) or forward in time respectively.\n",
    "    depth: non-negative int that indicates how deep of a tree to build.\n",
    "      Each call to `_build_tree` takes `2**depth` leapfrog steps.\n",
    "    step_size: List of `Tensor`s representing the step sizes for the leapfrog\n",
    "      integrator. Must have same shape as `current_state`.\n",
    "    log_slice_sample: The log of an auxiliary slice variable. It is used\n",
    "      together with `max_simulation_error` to avoid simulating trajectories with\n",
    "      too much numerical error.\n",
    "    max_simulation_error: Maximum simulation error to tolerate before\n",
    "      terminating the trajectory. Simulation error is the\n",
    "      `log_slice_sample` minus the log-joint probability at the simulated state.\n",
    "    seed: Integer to seed the random number generator.\n",
    "  Returns:\n",
    "    reverse_state: List of `Tensor`s representing the \"reverse\" states of the\n",
    "      NUTS trajectory. Has same shape as `current_state`.\n",
    "    reverse_target_log_prob: Scalar `Tensor` representing the value of\n",
    "      `target_log_prob_fn` at the `reverse_state`.\n",
    "    reverse_grads_target_log_prob: List of `Tensor`s representing gradient of\n",
    "      `reverse_target_log_prob` with respect to `reverse_state`. Has same shape\n",
    "      as `reverse_state`.\n",
    "    reverse_momentum: List of `Tensor`s representing the momentums of\n",
    "      `reverse_state`. Has same shape as `reverse_state`.\n",
    "    forward_state: List of `Tensor`s representing the \"forward\" states of the\n",
    "      NUTS trajectory. Has same shape as `current_state`.\n",
    "    forward_target_log_prob: Scalar `Tensor` representing the value of\n",
    "      `target_log_prob_fn` at the `forward_state`.\n",
    "    forward_grads_target_log_prob: List of `Tensor`s representing gradient of\n",
    "      `forward_target_log_prob` with respect to `forward_state`. Has same shape\n",
    "      as `forward_state`.\n",
    "    forward_momentum: List of `Tensor`s representing the momentums of\n",
    "      `forward_state`. Has same shape as `forward_state`.\n",
    "    next_state: List of `Tensor`s representing the next states of the NUTS\n",
    "      trajectory. Has same shape as `current_state`.\n",
    "    next_target_log_prob: Scalar `Tensor` representing the value of\n",
    "      `target_log_prob_fn` at `next_state`.\n",
    "    next_grads_target_log_prob: List of `Tensor`s representing the gradient of\n",
    "      `next_target_log_prob` with respect to `next_state`.\n",
    "    num_states: Number of acceptable candidate states in the subtree. A state is\n",
    "      acceptable if it is \"in the slice\", that is, if its log-joint probability\n",
    "      with its momentum is greater than `log_slice_sample`.\n",
    "    continue_trajectory: bool determining whether to continue the simulation\n",
    "      trajectory. The trajectory is continued if no U-turns are encountered\n",
    "      within the built subtree, and if the log-probability accumulation due to\n",
    "      integration error does not exceed `max_simulation_error`.\n",
    "  \"\"\"\n",
    "  if depth == 0:  # base case\n",
    "    # Take a leapfrog step. Terminate the tree-building if the simulation\n",
    "    # error from the leapfrog integrator is too large. States discovered by\n",
    "    # continuing the simulation are likely to have very low probability.\n",
    "    [\n",
    "        next_state,\n",
    "        next_target_log_prob,\n",
    "        next_grads_target_log_prob,\n",
    "        next_momentum,\n",
    "    ] = _leapfrog(\n",
    "        value_and_gradients_fn=value_and_gradients_fn,\n",
    "        current_state=current_state,\n",
    "        current_grads_target_log_prob=current_grads_target_log_prob,\n",
    "        current_momentum=current_momentum,\n",
    "        step_size=direction * step_size)\n",
    "    next_log_joint = _log_joint(next_target_log_prob, next_momentum)\n",
    "    num_states = tf.cast(next_log_joint > log_slice_sample, dtype=tf.int32)\n",
    "    continue_trajectory = (next_log_joint >\n",
    "                           log_slice_sample - max_simulation_error)\n",
    "    return [\n",
    "        next_state,\n",
    "        next_target_log_prob,\n",
    "        next_grads_target_log_prob,\n",
    "        next_momentum,\n",
    "        next_state,\n",
    "        next_target_log_prob,\n",
    "        next_grads_target_log_prob,\n",
    "        next_momentum,\n",
    "        next_state,\n",
    "        next_target_log_prob,\n",
    "        next_grads_target_log_prob,\n",
    "        num_states,\n",
    "        continue_trajectory,\n",
    "    ]\n",
    "\n",
    "  # Build a tree at the current state.\n",
    "  seed_stream = tfd.SeedStream(seed, \"build_tree\")\n",
    "  [\n",
    "      reverse_state,\n",
    "      reverse_target_log_prob,\n",
    "      reverse_grads_target_log_prob,\n",
    "      reverse_momentum,\n",
    "      forward_state,\n",
    "      forward_target_log_prob,\n",
    "      forward_grads_target_log_prob,\n",
    "      forward_momentum,\n",
    "      next_state,\n",
    "      next_target_log_prob,\n",
    "      next_grads_target_log_prob,\n",
    "      num_states,\n",
    "      continue_trajectory,\n",
    "  ] = _build_tree(value_and_gradients_fn=value_and_gradients_fn,\n",
    "                  current_state=current_state,\n",
    "                  current_target_log_prob=current_target_log_prob,\n",
    "                  current_grads_target_log_prob=current_grads_target_log_prob,\n",
    "                  current_momentum=current_momentum,\n",
    "                  direction=direction,\n",
    "                  depth=depth - 1,\n",
    "                  step_size=step_size,\n",
    "                  log_slice_sample=log_slice_sample,\n",
    "                  seed=seed_stream())\n",
    "  if continue_trajectory:\n",
    "    # If the just-built subtree did not terminate, build a second subtree at\n",
    "    # the forward or reverse state, as appropriate.\n",
    "    if direction < 0:\n",
    "      [\n",
    "          reverse_state,\n",
    "          reverse_target_log_prob,\n",
    "          reverse_grads_target_log_prob,\n",
    "          reverse_momentum,\n",
    "          _,\n",
    "          _,\n",
    "          _,\n",
    "          _,\n",
    "          far_state,\n",
    "          far_target_log_prob,\n",
    "          far_grads_target_log_prob,\n",
    "          far_num_states,\n",
    "          far_continue_trajectory,\n",
    "      ] = _build_tree(\n",
    "          value_and_gradients_fn=value_and_gradients_fn,\n",
    "          current_state=reverse_state,\n",
    "          current_target_log_prob=reverse_target_log_prob,\n",
    "          current_grads_target_log_prob=reverse_grads_target_log_prob,\n",
    "          current_momentum=reverse_momentum,\n",
    "          direction=direction,\n",
    "          depth=depth - 1,\n",
    "          step_size=step_size,\n",
    "          log_slice_sample=log_slice_sample,\n",
    "          seed=seed_stream())\n",
    "    else:\n",
    "      [\n",
    "          _,\n",
    "          _,\n",
    "          _,\n",
    "          _,\n",
    "          forward_state,\n",
    "          forward_target_log_prob,\n",
    "          forward_grads_target_log_prob,\n",
    "          forward_momentum,\n",
    "          far_state,\n",
    "          far_target_log_prob,\n",
    "          far_grads_target_log_prob,\n",
    "          far_num_states,\n",
    "          far_continue_trajectory,\n",
    "      ] = _build_tree(\n",
    "          value_and_gradients_fn=value_and_gradients_fn,\n",
    "          current_state=forward_state,\n",
    "          current_target_log_prob=forward_target_log_prob,\n",
    "          current_grads_target_log_prob=forward_grads_target_log_prob,\n",
    "          current_momentum=forward_momentum,\n",
    "          direction=direction,\n",
    "          depth=depth - 1,\n",
    "          step_size=step_size,\n",
    "          log_slice_sample=log_slice_sample,\n",
    "          seed=seed_stream())\n",
    "\n",
    "    # Propose either `next_state` (which came from the first subtree and so is\n",
    "    # nearby) or the new forward/reverse state (which came from the second\n",
    "    # subtree and so is far away).\n",
    "    num_states += far_num_states\n",
    "    accept_far_state = _random_bernoulli(\n",
    "        [],\n",
    "        probs=far_num_states / num_states,\n",
    "        dtype=tf.bool,\n",
    "        seed=seed_stream())\n",
    "    if accept_far_state:\n",
    "      next_state = far_state\n",
    "      next_target_log_prob = far_target_log_prob\n",
    "      next_grads_target_log_prob = far_grads_target_log_prob\n",
    "\n",
    "    # Continue the NUTS trajectory if the far subtree did not terminate either,\n",
    "    # and if the reverse-most and forward-most states do not exhibit a U-turn.\n",
    "    has_no_u_turn = tf.logical_and(\n",
    "        _has_no_u_turn(forward_state, reverse_state, forward_momentum),\n",
    "        _has_no_u_turn(forward_state, reverse_state, reverse_momentum))\n",
    "    continue_trajectory = far_continue_trajectory and has_no_u_turn\n",
    "\n",
    "  return [\n",
    "      reverse_state,\n",
    "      reverse_target_log_prob,\n",
    "      reverse_grads_target_log_prob,\n",
    "      reverse_momentum,\n",
    "      forward_state,\n",
    "      forward_target_log_prob,\n",
    "      forward_grads_target_log_prob,\n",
    "      forward_momentum,\n",
    "      next_state,\n",
    "      next_target_log_prob,\n",
    "      next_grads_target_log_prob,\n",
    "      num_states,\n",
    "      continue_trajectory,\n",
    "  ]\n",
    "\n",
    "\n",
    "def _embed_no_none_gradient_check(value_and_gradients_fn):\n",
    "  \"\"\"Wraps value and gradients function to assist with None gradients.\"\"\"\n",
    "  @functools.wraps(value_and_gradients_fn)\n",
    "  def func_wrapped(*args, **kwargs):\n",
    "    \"\"\"Wrapped function which checks for None gradients.\"\"\"\n",
    "    value, grads = value_and_gradients_fn(*args, **kwargs)\n",
    "    if any(grad is None for grad in grads):\n",
    "      raise ValueError(\"Gradient is None for a state.\")\n",
    "    return value, grads\n",
    "  return func_wrapped\n",
    "\n",
    "#@tfe.defun\n",
    "def _has_no_u_turn(state_one, state_two, momentum):\n",
    "  \"\"\"If two given states and momentum do not exhibit a U-turn pattern.\"\"\"\n",
    "  state_one = tf.stack(state_one)\n",
    "  state_two = tf.stack(state_two)\n",
    "  momentum = tf.stack(momentum)\n",
    "  dot_product = tf.reduce_sum(tf.map_fn(lambda x: tf.reduce_sum((x[0] - x[1]) * x[2]),\n",
    "    [state_one, state_two, momentum],\n",
    "    dtype=tf.float32))\n",
    "  #dot_product = sum([tf.reduce_sum((s1 - s2) * m)\n",
    "  #                   for s1, s2, m in zip(state_one, state_two, momentum)])\n",
    "  return dot_product > 0\n",
    "\n",
    "#@tfe.defun\n",
    "def _leapfrog(value_and_gradients_fn,\n",
    "              current_state,\n",
    "              current_grads_target_log_prob,\n",
    "              current_momentum,\n",
    "              step_size):\n",
    "  \"\"\"Runs one step of leapfrog integration.\"\"\"\n",
    "  def momentum_update(x):\n",
    "    m, step, g = x\n",
    "    return m + 0.5 * step * g\n",
    "  current_momentum = tf.stack(current_momentum)\n",
    "  current_grads_target_log_prob = tf.stack(current_grads_target_log_prob)\n",
    "  step_size = tf.stack(step_size)\n",
    "  mid_momentum = tf.map_fn(\n",
    "      momentum_update, \n",
    "      [current_momentum, step_size, current_grads_target_log_prob],\n",
    "      dtype=tf.float32,\n",
    "  )\n",
    "  #mid_momentum2 = [\n",
    "  #    m + 0.5 * step * g for m, step, g in\n",
    "  #    zip(current_momentum, step_size, current_grads_target_log_prob)]\n",
    "  def state_update(x):\n",
    "    s, step, m = x\n",
    "    return s + step * m\n",
    "  current_state = tf.stack(current_state)\n",
    "  next_state = tf.map_fn(\n",
    "      state_update,\n",
    "      [current_state, step_size, mid_momentum],\n",
    "      dtype=tf.float32,\n",
    "  )\n",
    "  #next_state = [\n",
    "  #    s + step * m for s, step, m in\n",
    "  #    zip(current_state, step_size, mid_momentum)]\n",
    "\n",
    "  next_target_log_prob, next_grads_target_log_prob = value_and_gradients_fn(\n",
    "      *tf.unstack(next_state))\n",
    "  next_grads_target_log_prob = tf.stack(next_grads_target_log_prob)\n",
    "  next_momentum = tf.map_fn(\n",
    "      momentum_update,\n",
    "      [mid_momentum, step_size, next_grads_target_log_prob],\n",
    "      dtype=tf.float32,\n",
    "  )\n",
    "  #next_momentum = [\n",
    "  #    m + 0.5 * step * g for m, step, g in\n",
    "  #    zip(mid_momentum, step_size, next_grads_target_log_prob)]\n",
    "  return [\n",
    "      next_state,\n",
    "      next_target_log_prob,\n",
    "      next_grads_target_log_prob,\n",
    "      next_momentum,\n",
    "  ]\n",
    "\n",
    "\n",
    "#@tfe.defun\n",
    "def _log_joint(current_target_log_prob, current_momentum):\n",
    "  \"\"\"Log-joint probability given a state's log-probability and momentum.\"\"\"\n",
    "  #momentum_log_prob = -sum([tf.reduce_sum(0.5 * (m ** 2.))\n",
    "  #                          for m in current_momentum])\n",
    "  current_momentum = tf.stack(current_momentum)\n",
    "  momentum_log_prob = -tf.reduce_sum(tf.map_fn(\n",
    "      lambda m: tf.reduce_sum(0.5 * (m ** 2.)),\n",
    "      current_momentum,\n",
    "      dtype=tf.float32,       \n",
    "  ))\n",
    "  return current_target_log_prob + momentum_log_prob\n",
    "\n",
    "#@tfe.defun\n",
    "def _random_bernoulli(shape, probs, dtype=tf.int32, seed=None, name=None):\n",
    "  \"\"\"Returns samples from a Bernoulli distribution.\"\"\"\n",
    "  with tf.name_scope(name, \"random_bernoulli\", [shape, probs]):\n",
    "    probs = tf.convert_to_tensor(probs)\n",
    "    random_uniform = tf.random_uniform(shape, dtype=probs.dtype, seed=seed)\n",
    "    return tf.cast(tf.less(random_uniform, probs), dtype)\n",
    "\n",
    "def profiler(func):\n",
    "  \"\"\"Decorator for profiling the execution of a function.\"\"\"\n",
    "  @functools.wraps(func)\n",
    "  def func_wrapped(*args, **kwargs):\n",
    "    \"\"\"Function which wraps original function with start/stop profiling.\"\"\"\n",
    "    pr = cProfile.Profile()\n",
    "    pr.enable()\n",
    "    start = time.time()\n",
    "    output = func(*args, **kwargs)\n",
    "    print(\"Elapsed\", time.time() - start)\n",
    "    pr.disable()\n",
    "    ps = pstats.Stats(pr).sort_stats(\"cumulative\")\n",
    "    ps.print_stats()\n",
    "    return output\n",
    "  return func_wrapped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sample_nuts(model, nsteps=1000, burnin=500, step_size=.05, profile=False):\n",
    "    # Since HMC operates over unconstrained space, we need to transform the\n",
    "    # samples so they live in real-space.\n",
    "    random_variables = model._forward_context.vars\n",
    "    unconstraining_bijectors = []\n",
    "    inits = []\n",
    "    for rv in random_variables:\n",
    "        inits.append(tf.ones(rv.sample().shape, name=rv.name))\n",
    "        if isinstance(rv, pm.Normal):\n",
    "            unconstraining_bijectors.append(tfp.bijectors.Identity())\n",
    "        elif isinstance(rv, pm.HalfNormal):\n",
    "            unconstraining_bijectors.append(tfp.bijectors.Exp())\n",
    "        else:\n",
    "            print('rv not identifiable')\n",
    "\n",
    "    unnormalized_posterior_log_prob = model.make_logp_function()\n",
    "    \n",
    "    if tf.executing_eagerly():\n",
    "        # compile logp to speed things up\n",
    "        unnormalized_posterior_log_prob = tf.contrib.eager.defun(\n",
    "            unnormalized_posterior_log_prob)\n",
    "\n",
    "    posterior_samples = []\n",
    "    target_log_prob = None\n",
    "    grads_target_log_prob = None\n",
    "    \n",
    "    if profile:\n",
    "        sampler = profiler(nuts)\n",
    "    else:\n",
    "        sampler = nuts\n",
    "    step_size = tf.stack([step_size] * len(inits))\n",
    "    \n",
    "    for step in range(nsteps):\n",
    "        print(\"Step\", step)\n",
    "        [\n",
    "            inits,\n",
    "            target_log_prob,\n",
    "            grads_target_log_prob,\n",
    "        ] = sampler(target_log_prob_fn=unnormalized_posterior_log_prob,\n",
    "                   current_state=inits,\n",
    "                   step_size=step_size,\n",
    "                   seed=step,\n",
    "                   current_target_log_prob=target_log_prob,\n",
    "                   current_grads_target_log_prob=grads_target_log_prob)\n",
    "        posterior_samples.append(inits)\n",
    "   \n",
    "    trace = {rv.name: arr for rv, arr in zip(random_variables, posterior_samples)}\n",
    "    \n",
    "    return az.dict_to_dataset(trace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0\n",
      "Step 1\n",
      "Step 2\n",
      "Step 3\n",
      "Step 4\n",
      "Step 5\n",
      "Step 6\n",
      "Step 7\n",
      "Step 8\n",
      "Step 9\n",
      "CPU times: user 10.1 s, sys: 193 ms, total: 10.3 s\n",
      "Wall time: 10.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "trace = sample_nuts(model, 10, profile=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with defun"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Step 0\n",
      "Step 1\n",
      "Step 2\n",
      "Step 3\n",
      "Step 4\n",
      "Step 5\n",
      "Step 6\n",
      "Step 7\n",
      "Step 8\n",
      "Step 9\n",
      "CPU times: user 19.3 s, sys: 1.48 s, total: 20.7 s\n",
      "Wall time: 19.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "trace = sample_nuts(model, 10, profile=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "az.plot_trace(trace);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Auto-assigning NUTS sampler...\n",
      "Initializing NUTS using jitter+adapt_diag...\n",
      "Multiprocess sampling (2 chains in 2 jobs)\n",
      "NUTS: [y_1, y_0, sd, mu]\n",
      "Sampling 2 chains: 100%|██████████| 2000/2000 [00:01<00:00, 1016.09draws/s]\n",
      "/Users/twiecki/anaconda3/lib/python3.6/site-packages/mkl_fft/_numpy_fft.py:1044: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  output = mkl_fft.rfftn_numpy(a, s, axes)\n",
      "There were 32 divergences after tuning. Increase `target_accept` or reparameterize.\n",
      "There were 132 divergences after tuning. Increase `target_accept` or reparameterize.\n",
      "The acceptance probability does not match the target. It is 0.34980487569178514, but should be close to 0.8. Try to increase the number of tuning steps.\n",
      "The gelman-rubin statistic is larger than 1.05 for some parameters. This indicates slight problems during sampling.\n",
      "The estimated number of effective samples is smaller than 200 for some parameters.\n"
     ]
    }
   ],
   "source": [
    "import pymc3 as pm3\n",
    "\n",
    "with pm3.Model():\n",
    "    mu = pm3.Normal('mu', 0, 1)\n",
    "    sd = pm3.HalfNormal('sd', 1)\n",
    "    pm3.Normal('y_0', 0, 2 * sd)\n",
    "    pm3.Normal('y_1', mu, 2 * sd)\n",
    "    pm3.sample()"
   ]
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}