examples/walkthroughs/pylfppl_walkthrough_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PyLFPPL: Introduction\n",
    "\n",
    "Python LFPPL is a probabilistic programming language that is built for enabling one to perform inference in probabilistic programs that require gradient based inference algorithms. As `if-else` statements within probabilistic programs that use gradient based inference, take on two different forms. On one hand hand `if-else` have the usual programmer interpretation, but on the other, when random variables are placed inside of the predicate, or the body of an `if-else` expression, then we must treat those variables with care as discontinuities arise at point of indecision. We must ensure that at this indecision boundary the discontinuity, with respect to space it is in and the measure imposed on it, has a measure of zero. \n",
    "\n",
    "Our framework was built to ensure that certain criteria in the compiled output of a directed acyclic graphical model are met. The language is extensible enough for one to add their own custom built potentials; which could be either log joint densities or loss functions, within the framework. There is a higher layer inference framework that takes advantage of PyLFPPL called [pyfo](https://github.com/bradleygramhansen/pyfo), we are actively developing this. The corresponding paper is called [A Low-level Probabilistic Programming Language for Non-Differentiable Models](toadd). \n",
    "\n",
    "In this walk-through we shall go through the basics of how to write a model and how to compile the model. In the following walk-through we shall show how to use custom density functions, how add other distributions within the framework and how to take advantage of the translation rules that are embedded within the language. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyLFPPL imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from pyppl import compile_model \n",
    "from pyppl.utils.core import create_network_graph, display_graph\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A statistical model with basic control-flow\n",
    "\n",
    "For fun, let us add some contextual data: Whether or not Alice decides to go to space is highly dependent upon the number of points Alice collects, which is dependent upon a draw from a centered normal distribution, $x_1$. If she draws a number greater than 0, then we observe that Alice gets 1.5 points and the likelihood she goes to space, given the 1.5 points, is distributed by $\\mathcal{N}(1.5~|~x_1,1)$. However, if she draws a number less than or equal to 0, then her likelihood is quite different. She gains 1 point, but the likelihood that the distribution is centered around 1, is dependent upon a random draw from a categorical distribution that returns a 0 with probability 0.1, 1 with probability 0.2, and 2 with probability 0.7. If we find that the value of the $x_1$ after the inference is greater than zero, then Alice goes to space, else she stays on Earth :-(\n",
    "\n",
    "\n",
    "$$ x_1 \\sim \\mathcal{N}(0,1) $$\n",
    "$$ x_2 \\sim \\mathcal{Cat}(0.1, 0.2, 0.7) $$\n",
    "we observe our data (\"points\")\n",
    "$$y_1 = 1.5 $$\n",
    "$$y_2 = 1 $$\n",
    "\n",
    "likelihood terms\n",
    "$$ y_1 = 1.5~|~x_1 = \\mathcal{N}(y_1~|~x_1,~1) $$\n",
    "$$ y_2 = 1~|~x_2 = \\mathcal{N}(y_2~|~x_2,~1) $$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_if_clojure=\"\"\"\n",
    "(let [x1 (sample (normal [0 0 0] [1 1 1]))\n",
    "      x2 (sample (categorical [0.1 0.2 0.7]))\n",
    "      y1 [1.5 1.5 1.5]\n",
    "      y2 [1 1 1] ]\n",
    "  (if (> x1 0)\n",
    "    (observe (normal x1 [1 1 1]) y1)\n",
    "    (observe (normal x2 [1 1 1]) y2))\n",
    "  [x1 x2])\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "compiled_clojure = compile_model(model_if_clojure, language='clojure')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The compiler takes the above code and transforms it into a model class, from which the user can manipulate the program and interface with an inference engine. \n",
    "\n",
    "As can be seen above, the language consists of some special syntax, one being \n",
    "<font color='red'>sample</font>`(<distribution_name>(param1, param2m, ...))`\n",
    "\n",
    "which generates the `priors` for the variables of interest, and the second being \n",
    "<font color='blue'>observe</font>`(<distribution name>(param1, param2, ...), <observation/data>)` \n",
    "\n",
    "which generates the likelihood given the observed data. The definitions given here are for when writing models in `python`, but examples of what the statements look like in `clojure` is given in the example above. \n",
    "\n",
    "Finally, `if`-expressions, whilst on the surface look like usual `if`-statements, are interpreted in a special way in `PyLFPPL`. If the predicate, in the example above this is `(> x1 0)`, contains any <font color='red'>sampled</font> variables, then within `PyLFPPL` a specific key-value pair is generated for that `if`-statement, so that those variables can be controlled in a special way. \n",
    "\n",
    "This is especially important when using gradient based inference algorithms, as the conditions within the predicates can create **measure zero** discontinuities. When using algorithms such as Hamiltonian Monte Carlo (HMC) for performing inference in models that are of a low dimensionality with a suitably low number of discontinuities, one may not notice a difference in the outcome of the inference result. If they have the ground truth available. However, using HMC on such models is completely and utterly statistically wrong. But the HMC algorithm for such a model would run without hindrance. \n",
    "\n",
    "This is dangerous for two reasons. One, If probabilistic programming languages and systems are supposed to deal with these subtleties whilst letting the modeller focus on modelling, then we are letting down a large group of the target users, who may not truly understand these subtleties. Two, the use of gradient based inference with control flow is poorly understood. Whilst point two, is re-iterating point one to some extent, it is important to understand, that a lack of understanding about a particular inference technique is detrimental to the setup of the probabilistic programming language and system. This is one of the reasons behind `PyLFPPL`, a simple language with inbuilt constraints to avoid these issue, yet is flexible enough to be integrated into other probabilistic programming systems.  \n",
    "\n",
    "\n",
    "Here is a print out of the model class for the above model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# 2019-03-16 18:15:44.590612\n",
      "import torch.distributions as dist\n",
      "\n",
      "\n",
      "class Model():\n",
      "\n",
      "\tdef __init__(self, vertices: set, arcs: set, data: set, conditionals: set):\n",
      "\t\tsuper().__init__()\n",
      "\t\tself.vertices = vertices\n",
      "\t\tself.arcs = arcs\n",
      "\t\tself.data = data\n",
      "\t\tself.conditionals = conditionals\n",
      "\t\n",
      "\tdef __repr__(self):\n",
      "\t\tV = '\\n'.join(sorted([repr(v) for v in self.vertices]))\n",
      "\t\tA = ', '.join(['({}, {})'.format(u.name, v.name) for (u, v) in self.arcs]) if len(self.arcs) > 0 else '  -'\n",
      "\t\tC = '\\n'.join(sorted([repr(v) for v in self.conditionals])) if len(self.conditionals) > 0 else '  -'\n",
      "\t\tD = '\\n'.join([repr(u) for u in self.data]) if len(self.data) > 0 else '  -'\n",
      "\t\tgraph = 'Vertices V:\\n{V}\\nArcs A:\\n  {A}\\n\\nConditions C:\\n{C}\\n\\nData D:\\n{D}\\n'.format(V=V, A=A, C=C, D=D)\n",
      "\t\tgraph = '#Vertices: {}, #Arcs: {}\\n'.format(len(self.vertices), len(self.arcs)) + graph\n",
      "\t\treturn graph\n",
      "\t\n",
      "\tdef gen_cond_bit_vector(self, state):\n",
      "\t\tresult = 0\n",
      "\t\tfor cond in self.conditionals:\n",
      "\t\t\tresult = cond.update_bit_vector(state, result)\n",
      "\t\treturn result\n",
      "\n",
      "\tdef gen_cond_vars(self):\n",
      "\t\treturn [c.name for c in self.conditionals]\n",
      "\n",
      "\tdef gen_cont_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_continuous and not v.is_conditional and v.is_sampled]\n",
      "\n",
      "\tdef gen_disc_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_discrete and v.is_sampled]\n",
      "\n",
      "\tdef gen_if_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_conditional and v.is_sampled and v.is_continuous]\n",
      "\n",
      "\tdef gen_log_prob(self, state):\n",
      "\t\ttry:\n",
      "\t\t\tlog_prob = 0\n",
      "\t\t\tdst_ = dist.Normal(loc=[0, 0, 0], scale=[1, 1, 1])\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30001'])\n",
      "\t\t\tdst_ = dist.Categorical(probs=[0.1, 0.2, 0.7])\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30002'])\n",
      "\t\t\tstate['cond_30003'] = (state['x30001'] > 0)\n",
      "\t\t\tdst_ = dist.Normal(loc=state['x30001'], scale=[1, 1, 1])\n",
      "\t\t\tif state['cond_30003']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30004'])\n",
      "\t\t\tdst_ = dist.Normal(loc=state['x30002'], scale=[1, 1, 1])\n",
      "\t\t\tif not state['cond_30003']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30005'])\n",
      "\t\t\treturn log_prob\n",
      "\t\texcept(ValueError, RuntimeError) as e:\n",
      "\t\t\tprint('****Warning: Target density is ill-defined****')\n",
      "\n",
      "\tdef gen_prior_samples(self):\n",
      "\t\tstate = {}\n",
      "\t\tdst_ = dist.Normal(loc=[0, 0, 0], scale=[1, 1, 1])\n",
      "\t\tstate['x30001'] = dst_.sample()\n",
      "\t\tdst_ = dist.Categorical(probs=[0.1, 0.2, 0.7])\n",
      "\t\tstate['x30002'] = dst_.sample()\n",
      "\t\tstate['cond_30003'] = (state['x30001'] > 0)\n",
      "\t\tdst_ = dist.Normal(loc=state['x30001'], scale=[1, 1, 1])\n",
      "\t\tstate['y30004'] = [1.5, 1.5, 1.5]\n",
      "\t\tdst_ = dist.Normal(loc=state['x30002'], scale=[1, 1, 1])\n",
      "\t\tstate['y30005'] = [1, 1, 1]\n",
      "\t\treturn state\n",
      "\n",
      "\tdef get_arcs(self):\n",
      "\t\treturn self.arcs\n",
      "\n",
      "\tdef get_arcs_names(self):\n",
      "\t\treturn [(u.name, v.name) for (u, v) in self.arcs]\n",
      "\n",
      "\tdef get_conditions(self):\n",
      "\t\treturn self.conditionals\n",
      "\n",
      "\tdef get_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_sampled]\n",
      "\n",
      "\tdef get_vertices(self):\n",
      "\t\treturn self.vertices\n",
      "\n",
      "\tdef get_vertices_names(self):\n",
      "\t\treturn [v.name for v in self.vertices]\n",
      "\n",
      "\tdef is_torch_imported(self):\n",
      "\t\timport sys \n",
      "\t\tprint('torch' in sys.modules) \n",
      "\t\tprint(torch.__version__) \n",
      "\t\tprint(type(torch.tensor)) \n",
      "\t\timport inspect \n",
      "\t\tprint(inspect.getfile(torch))\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(compiled_clojure.code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the models imported by changing the arguments in the `compile_model` function. By specification to our current application the compiler automatically imports `pytorch`. This can be easily removed by going into `ppl_graph_codegen.py` file and then removing the `if not has_dist` block. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# 2019-03-16 18:15:44.649859\n",
      "import torch.distributions as dist\n",
      "import matplotlib as mpl \n",
      "import numpy as np \n",
      "\n",
      "class Model():\n",
      "\n",
      "\tdef __init__(self, vertices: set, arcs: set, data: set, conditionals: set):\n",
      "\t\tsuper().__init__()\n",
      "\t\tself.vertices = vertices\n",
      "\t\tself.arcs = arcs\n",
      "\t\tself.data = data\n",
      "\t\tself.conditionals = conditionals\n",
      "\t\n",
      "\tdef __repr__(self):\n",
      "\t\tV = '\\n'.join(sorted([repr(v) for v in self.vertices]))\n",
      "\t\tA = ', '.join(['({}, {})'.format(u.name, v.name) for (u, v) in self.arcs]) if len(self.arcs) > 0 else '  -'\n",
      "\t\tC = '\\n'.join(sorted([repr(v) for v in self.conditionals])) if len(self.conditionals) > 0 else '  -'\n",
      "\t\tD = '\\n'.join([repr(u) for u in self.data]) if len(self.data) > 0 else '  -'\n",
      "\t\tgraph = 'Vertices V:\\n{V}\\nArcs A:\\n  {A}\\n\\nConditions C:\\n{C}\\n\\nData D:\\n{D}\\n'.format(V=V, A=A, C=C, D=D)\n",
      "\t\tgraph = '#Vertices: {}, #Arcs: {}\\n'.format(len(self.vertices), len(self.arcs)) + graph\n",
      "\t\treturn graph\n",
      "\t\n",
      "\tdef gen_cond_bit_vector(self, state):\n",
      "\t\tresult = 0\n",
      "\t\tfor cond in self.conditionals:\n",
      "\t\t\tresult = cond.update_bit_vector(state, result)\n",
      "\t\treturn result\n",
      "\n",
      "\tdef gen_cond_vars(self):\n",
      "\t\treturn [c.name for c in self.conditionals]\n",
      "\n",
      "\tdef gen_cont_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_continuous and not v.is_conditional and v.is_sampled]\n",
      "\n",
      "\tdef gen_disc_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_discrete and v.is_sampled]\n",
      "\n",
      "\tdef gen_if_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_conditional and v.is_sampled and v.is_continuous]\n",
      "\n",
      "\tdef gen_log_prob(self, state):\n",
      "\t\ttry:\n",
      "\t\t\tlog_prob = 0\n",
      "\t\t\tdst_ = dist.Normal(loc=[0, 0, 0], scale=[1, 1, 1])\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30001'])\n",
      "\t\t\tdst_ = dist.Categorical(probs=[0.1, 0.2, 0.7])\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30002'])\n",
      "\t\t\tstate['cond_30003'] = (state['x30001'] > 0)\n",
      "\t\t\tdst_ = dist.Normal(loc=state['x30001'], scale=[1, 1, 1])\n",
      "\t\t\tif state['cond_30003']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30004'])\n",
      "\t\t\tdst_ = dist.Normal(loc=state['x30002'], scale=[1, 1, 1])\n",
      "\t\t\tif not state['cond_30003']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30005'])\n",
      "\t\t\treturn log_prob\n",
      "\t\texcept(ValueError, RuntimeError) as e:\n",
      "\t\t\tprint('****Warning: Target density is ill-defined****')\n",
      "\n",
      "\tdef gen_prior_samples(self):\n",
      "\t\tstate = {}\n",
      "\t\tdst_ = dist.Normal(loc=[0, 0, 0], scale=[1, 1, 1])\n",
      "\t\tstate['x30001'] = dst_.sample()\n",
      "\t\tdst_ = dist.Categorical(probs=[0.1, 0.2, 0.7])\n",
      "\t\tstate['x30002'] = dst_.sample()\n",
      "\t\tstate['cond_30003'] = (state['x30001'] > 0)\n",
      "\t\tdst_ = dist.Normal(loc=state['x30001'], scale=[1, 1, 1])\n",
      "\t\tstate['y30004'] = [1.5, 1.5, 1.5]\n",
      "\t\tdst_ = dist.Normal(loc=state['x30002'], scale=[1, 1, 1])\n",
      "\t\tstate['y30005'] = [1, 1, 1]\n",
      "\t\treturn state\n",
      "\n",
      "\tdef get_arcs(self):\n",
      "\t\treturn self.arcs\n",
      "\n",
      "\tdef get_arcs_names(self):\n",
      "\t\treturn [(u.name, v.name) for (u, v) in self.arcs]\n",
      "\n",
      "\tdef get_conditions(self):\n",
      "\t\treturn self.conditionals\n",
      "\n",
      "\tdef get_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_sampled]\n",
      "\n",
      "\tdef get_vertices(self):\n",
      "\t\treturn self.vertices\n",
      "\n",
      "\tdef get_vertices_names(self):\n",
      "\t\treturn [v.name for v in self.vertices]\n",
      "\n",
      "\tdef is_torch_imported(self):\n",
      "\t\timport sys \n",
      "\t\tprint('torch' in sys.modules) \n",
      "\t\tprint(torch.__version__) \n",
      "\t\tprint(type(torch.tensor)) \n",
      "\t\timport inspect \n",
      "\t\tprint(inspect.getfile(torch))\n",
      "\n"
     ]
    }
   ],
   "source": [
    "compile_clojure = compile_model(model_if_clojure, language='clojure',imports='import matplotlib as mpl \\nimport numpy as np ')\n",
    "print(compile_clojure.code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing the Graph G(V,E) of the statistical model. \n",
    "\n",
    "Each vertex of the graph is an object, with a set of attributes. These attributes describe the relationships between the vertex and other vertices. In addition to this, the attributes contain information about the observables and latent variables at each vertex.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#Vertices: 4, #Arcs: 2\n",
      "Vertices V:\n",
      "Vertex x30001 [Sample]\n",
      "  Name:           x30001\n",
      "  Ancestors:      \n",
      "  Cond-Ancs.:     \n",
      "  Dist-Args:      {'loc': '[0, 0, 0]', 'scale': '[1, 1, 1]'}\n",
      "  Dist-Code:      dist.Normal([0, 0, 0], [1, 1, 1])\n",
      "  Dist-Name:      Normal\n",
      "  Dist-Type:      DistributionType.CONTINUOUS\n",
      "  Sample-Size:    1\n",
      "Vertex x30002 [Sample]\n",
      "  Name:           x30002\n",
      "  Ancestors:      \n",
      "  Cond-Ancs.:     \n",
      "  Dist-Args:      {'probs': '[0.1, 0.2, 0.7]'}\n",
      "  Dist-Code:      dist.Categorical([0.1, 0.2, 0.7])\n",
      "  Dist-Name:      Categorical\n",
      "  Dist-Type:      DistributionType.DISCRETE\n",
      "  Sample-Size:    1\n",
      "Vertex y30004 [Observe]\n",
      "  Name:           y30004\n",
      "  Ancestors:      x30001\n",
      "  Conditions:     cond_30003=True\n",
      "  Cond-Ancs.:     x30001\n",
      "  Cond-Nodes:     cond_30003\n",
      "  Dist-Args:      {'loc': \"state['x30001']\", 'scale': '[1, 1, 1]'}\n",
      "  Dist-Code:      dist.Normal(state['x30001'], [1, 1, 1])\n",
      "  Dist-Name:      Normal\n",
      "  Dist-Type:      DistributionType.CONTINUOUS\n",
      "  Sample-Size:    1\n",
      "  Observation:    [1.5, 1.5, 1.5]\n",
      "Vertex y30005 [Observe]\n",
      "  Name:           y30005\n",
      "  Ancestors:      x30002\n",
      "  Conditions:     cond_30003=False\n",
      "  Cond-Ancs.:     x30001\n",
      "  Cond-Nodes:     cond_30003\n",
      "  Dist-Args:      {'loc': \"state['x30002']\", 'scale': '[1, 1, 1]'}\n",
      "  Dist-Code:      dist.Normal(state['x30002'], [1, 1, 1])\n",
      "  Dist-Name:      Normal\n",
      "  Dist-Type:      DistributionType.CONTINUOUS\n",
      "  Sample-Size:    1\n",
      "  Observation:    [1, 1, 1]\n",
      "Arcs A:\n",
      "  (x30001, y30004), (x30002, y30005)\n",
      "\n",
      "Conditions C:\n",
      "Condition\n",
      "  Name:         cond_30003\n",
      "  Ancestors:    x30001\n",
      "  Condition:    (state['x30001'] > 0)\n",
      "  Function:     state['x30001']\n",
      "  Op:           >\n",
      "\n",
      "Data D:\n",
      "  -\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(compile_clojure)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see from the graph that $x_2$ is only dependent on the observation $y_2$, whereas $x_1$ can be affected by both observations. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  An example of an independent Categorical model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_categorical = \"\"\"\n",
    "(let[z (sample (categorical [0.7 0.15 0.15]))\n",
    "    z1 (sample (categorical [0.1 0.5 0.4]))\n",
    "    z2 (sample (categorical [0.2 0.2 0.6]))]\n",
    "    z z1 z2)\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "compiled_clojure = compile_model(model_categorical, language='clojure')\n",
    "# print(compiled_clojure.code)\n",
    "vertices = compiled_clojure.vertices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting the depndence graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "create_network_graph(vertices=vertices)\n",
    "display_graph(vertices=vertices);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, in this model there are no dependencies between the different latent variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A Hidden Markov Model\n",
    "\n",
    "In a HMM the goal is to infer the hidden states. In doing so we aim to explain how our observations are produced, as the underlying assumption is that the hidden state directly affects the observation produced. This is a very short description, of a very powerful tool. See [here](http://mlg.eng.cam.ac.uk/zoubin/papers/ijprai.pdf) for more details on HMMs. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_hmm_clojure=\"\"\"\n",
    "(defn data [n]\n",
    "  (let [points (vector 0.9 0.8 0.7 0.0 -0.025\n",
    "                       5.0 2.0 0.1 0.0 0.13\n",
    "                       0.45 6.0 0.2 0.3 -1.0 -1.0)]\n",
    "    (get points n)))\n",
    "\n",
    ";; Define the init, transition, and observation distributions\n",
    "(defn get-init-params []\n",
    "  (vector (/ 1. 3.) (/ 1. 3.) (/ 1. 3.)))\n",
    "\n",
    "(defn get-trans-params [k]\n",
    "  (nth (vector (vector 0.1  0.5  0.4 )\n",
    "               (vector 0.2  0.2  0.6 )\n",
    "               (vector 0.7 0.15 0.15 )) k))\n",
    "\n",
    "(defn get-obs-dist [k]\n",
    "  (nth (vector (normal -1. 1.)\n",
    "               (normal  1. 1.)\n",
    "               (normal  0. 1.)) k))\n",
    "\n",
    ";; Function to step through HMM and sample latent state\n",
    "(defn hmm-step [n states]\n",
    "  (let [next-state (sample (categorical (get-trans-params (last states))))]\n",
    "    (observe (get-obs-dist next-state) (data n))\n",
    "    (conj states next-state)))\n",
    "\n",
    ";; Loop through the data\n",
    "(let [init-state (sample (categorical (get-init-params)))]\n",
    "  (loop 16 (vector init-state) hmm-step))\n",
    "\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting the graphical model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "compiled_clojure = compile_model(model_hmm_clojure, language='clojure')\n",
    "vertices = compiled_clojure.vertices\n",
    "create_network_graph(vertices=vertices)\n",
    "display_graph(vertices=vertices);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PyLFPPL for python based models\n",
    "\n",
    "PyLFPPLs design allows one to use it with many different languages, we so far have built an interface for both `python` and `clojure` code. \n",
    "It is also important to note that the number of distributions one can add to `PyLFPPL` is boundless, as we will show in future walk-throughs. \n",
    "\n",
    "## Bayesian linear regression model\n",
    "\n",
    "The aim of inference in this model is to infer the equation of the line $ x = y*s + b$ (this is written to match the notation below. In general one would see his written as $y = mx +c$).\n",
    "\n",
    "$$slope \\sim \\mathcal{N}(0, 10) $$\n",
    "$$bias \\sim \\mathcal{N}(0, 10) $$\n",
    "\n",
    "Observations\n",
    "$$y = [(1.,2.), (2.1,3.9), (3.,5.3)] $$\n",
    "Constructing the equation of the predicted curve\n",
    "$$x_n = slope \\times y[1,n] + bias$$\n",
    "The likelihood\n",
    "$$y = y[2,n]~|~x_n = \\mathcal{N}(y[2,n]~|~x_n,~\\mathbf{I}) $$   \n",
    "\n",
    "## The Python LFPPL code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "model_lr_python = \"\"\"\n",
    "import torch\n",
    "slope= sample(normal(torch.zeros(1), torch.ones(10.0)))\n",
    "bias= sample(normal(torch.zeros(1), torch.tensor(10.0)))\n",
    "y= torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])\n",
    "def f(data,slope,bias,i):\n",
    "    return slope*data[0,i] + bias\n",
    "for i in range(3):\n",
    "    observe(normal(slope*y[0,i] + bias , torch.ones(len(f(y[0,i],slope,bias,i)))),y[1,i])\n",
    "\n",
    "[slope, bias]\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "compiled_python = compile_model(model_lr_python, language='python')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Graph\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#Vertices: 5, #Arcs: 6\n",
      "Vertices V:\n",
      "Vertex x30001 [Sample]\n",
      "  Name:           x30001\n",
      "  Ancestors:      \n",
      "  Cond-Ancs.:     \n",
      "  Dist-Args:      {'loc': 'torch.zeros(1)', 'scale': 'torch.ones(10.0)'}\n",
      "  Dist-Code:      dist.Normal(torch.zeros(1), torch.ones(10.0))\n",
      "  Dist-Name:      Normal\n",
      "  Dist-Type:      DistributionType.CONTINUOUS\n",
      "  Sample-Size:    1\n",
      "  Orig. Name:     slope\n",
      "Vertex x30002 [Sample]\n",
      "  Name:           x30002\n",
      "  Ancestors:      \n",
      "  Cond-Ancs.:     \n",
      "  Dist-Args:      {'loc': 'torch.zeros(1)', 'scale': 'torch.tensor(10.0)'}\n",
      "  Dist-Code:      dist.Normal(torch.zeros(1), torch.tensor(10.0))\n",
      "  Dist-Name:      Normal\n",
      "  Dist-Type:      DistributionType.CONTINUOUS\n",
      "  Sample-Size:    1\n",
      "  Orig. Name:     bias\n",
      "Vertex y30003 [Observe]\n",
      "  Name:           y30003\n",
      "  Ancestors:      x30001, x30002\n",
      "  Conditions:     \n",
      "  Cond-Ancs.:     \n",
      "  Cond-Nodes:     \n",
      "  Dist-Args:      {'loc': \"((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 0]]) + state['x30002'])\", 'scale': \"torch.ones(len(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 0]][[0, 0]]) + state['x30002'])))\"}\n",
      "  Dist-Code:      dist.Normal(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 0]]) + state['x30002']), torch.ones(len(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 0]][[0, 0]]) + state['x30002']))))\n",
      "  Dist-Name:      Normal\n",
      "  Dist-Type:      DistributionType.CONTINUOUS\n",
      "  Sample-Size:    1\n",
      "  Observation:    torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[1, 0]]\n",
      "Vertex y30004 [Observe]\n",
      "  Name:           y30004\n",
      "  Ancestors:      x30001, x30002\n",
      "  Conditions:     \n",
      "  Cond-Ancs.:     \n",
      "  Cond-Nodes:     \n",
      "  Dist-Args:      {'loc': \"((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 1]]) + state['x30002'])\", 'scale': \"torch.ones(len(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 1]][[0, 1]]) + state['x30002'])))\"}\n",
      "  Dist-Code:      dist.Normal(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 1]]) + state['x30002']), torch.ones(len(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 1]][[0, 1]]) + state['x30002']))))\n",
      "  Dist-Name:      Normal\n",
      "  Dist-Type:      DistributionType.CONTINUOUS\n",
      "  Sample-Size:    1\n",
      "  Observation:    torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[1, 1]]\n",
      "Vertex y30005 [Observe]\n",
      "  Name:           y30005\n",
      "  Ancestors:      x30001, x30002\n",
      "  Conditions:     \n",
      "  Cond-Ancs.:     \n",
      "  Cond-Nodes:     \n",
      "  Dist-Args:      {'loc': \"((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 2]]) + state['x30002'])\", 'scale': \"torch.ones(len(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 2]][[0, 2]]) + state['x30002'])))\"}\n",
      "  Dist-Code:      dist.Normal(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 2]]) + state['x30002']), torch.ones(len(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 2]][[0, 2]]) + state['x30002']))))\n",
      "  Dist-Name:      Normal\n",
      "  Dist-Type:      DistributionType.CONTINUOUS\n",
      "  Sample-Size:    1\n",
      "  Observation:    torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[1, 2]]\n",
      "Arcs A:\n",
      "  (x30001, y30003), (x30002, y30003), (x30001, y30004), (x30001, y30005), (x30002, y30004), (x30002, y30005)\n",
      "\n",
      "Conditions C:\n",
      "  -\n",
      "\n",
      "Data D:\n",
      "  -\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(compiled_python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# 2019-03-16 18:15:47.804193\n",
      "import torch.distributions as dist\n",
      "import torch\n",
      "\n",
      "class Model():\n",
      "\n",
      "\tdef __init__(self, vertices: set, arcs: set, data: set, conditionals: set):\n",
      "\t\tsuper().__init__()\n",
      "\t\tself.vertices = vertices\n",
      "\t\tself.arcs = arcs\n",
      "\t\tself.data = data\n",
      "\t\tself.conditionals = conditionals\n",
      "\t\n",
      "\tdef __repr__(self):\n",
      "\t\tV = '\\n'.join(sorted([repr(v) for v in self.vertices]))\n",
      "\t\tA = ', '.join(['({}, {})'.format(u.name, v.name) for (u, v) in self.arcs]) if len(self.arcs) > 0 else '  -'\n",
      "\t\tC = '\\n'.join(sorted([repr(v) for v in self.conditionals])) if len(self.conditionals) > 0 else '  -'\n",
      "\t\tD = '\\n'.join([repr(u) for u in self.data]) if len(self.data) > 0 else '  -'\n",
      "\t\tgraph = 'Vertices V:\\n{V}\\nArcs A:\\n  {A}\\n\\nConditions C:\\n{C}\\n\\nData D:\\n{D}\\n'.format(V=V, A=A, C=C, D=D)\n",
      "\t\tgraph = '#Vertices: {}, #Arcs: {}\\n'.format(len(self.vertices), len(self.arcs)) + graph\n",
      "\t\treturn graph\n",
      "\t\n",
      "\tdef gen_cond_bit_vector(self, state):\n",
      "\t\tresult = 0\n",
      "\t\tfor cond in self.conditionals:\n",
      "\t\t\tresult = cond.update_bit_vector(state, result)\n",
      "\t\treturn result\n",
      "\n",
      "\tdef gen_cond_vars(self):\n",
      "\t\treturn [c.name for c in self.conditionals]\n",
      "\n",
      "\tdef gen_cont_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_continuous and not v.is_conditional and v.is_sampled]\n",
      "\n",
      "\tdef gen_disc_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_discrete and v.is_sampled]\n",
      "\n",
      "\tdef gen_if_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_conditional and v.is_sampled and v.is_continuous]\n",
      "\n",
      "\tdef gen_log_prob(self, state):\n",
      "\t\ttry:\n",
      "\t\t\tlog_prob = 0\n",
      "\t\t\tdst_ = dist.Normal(loc=torch.zeros(1), scale=torch.ones(10.0))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30001'])\n",
      "\t\t\tdst_ = dist.Normal(loc=torch.zeros(1), scale=torch.tensor(10.0))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30002'])\n",
      "\t\t\tdst_ = dist.Normal(loc=((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 0]]) + state['x30002']), scale=torch.ones(len(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 0]][[0, 0]]) + state['x30002']))))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30003'])\n",
      "\t\t\tdst_ = dist.Normal(loc=((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 1]]) + state['x30002']), scale=torch.ones(len(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 1]][[0, 1]]) + state['x30002']))))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30004'])\n",
      "\t\t\tdst_ = dist.Normal(loc=((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 2]]) + state['x30002']), scale=torch.ones(len(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 2]][[0, 2]]) + state['x30002']))))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30005'])\n",
      "\t\t\treturn log_prob\n",
      "\t\texcept(ValueError, RuntimeError) as e:\n",
      "\t\t\tprint('****Warning: Target density is ill-defined****')\n",
      "\n",
      "\tdef gen_prior_samples(self):\n",
      "\t\tstate = {}\n",
      "\t\tdst_ = dist.Normal(loc=torch.zeros(1), scale=torch.ones(10.0))\n",
      "\t\tstate['x30001'] = dst_.sample()\n",
      "\t\tdst_ = dist.Normal(loc=torch.zeros(1), scale=torch.tensor(10.0))\n",
      "\t\tstate['x30002'] = dst_.sample()\n",
      "\t\tdst_ = dist.Normal(loc=((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 0]]) + state['x30002']), scale=torch.ones(len(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 0]][[0, 0]]) + state['x30002']))))\n",
      "\t\tstate['y30003'] = torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[1, 0]]\n",
      "\t\tdst_ = dist.Normal(loc=((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 1]]) + state['x30002']), scale=torch.ones(len(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 1]][[0, 1]]) + state['x30002']))))\n",
      "\t\tstate['y30004'] = torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[1, 1]]\n",
      "\t\tdst_ = dist.Normal(loc=((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 2]]) + state['x30002']), scale=torch.ones(len(((state['x30001'] * torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[0, 2]][[0, 2]]) + state['x30002']))))\n",
      "\t\tstate['y30005'] = torch.tensor([[1.0, 2.1], [2.0, 3.9], [3.0, 5.3]])[[1, 2]]\n",
      "\t\treturn state\n",
      "\n",
      "\tdef get_arcs(self):\n",
      "\t\treturn self.arcs\n",
      "\n",
      "\tdef get_arcs_names(self):\n",
      "\t\treturn [(u.name, v.name) for (u, v) in self.arcs]\n",
      "\n",
      "\tdef get_conditions(self):\n",
      "\t\treturn self.conditionals\n",
      "\n",
      "\tdef get_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_sampled]\n",
      "\n",
      "\tdef get_vertices(self):\n",
      "\t\treturn self.vertices\n",
      "\n",
      "\tdef get_vertices_names(self):\n",
      "\t\treturn [v.name for v in self.vertices]\n",
      "\n",
      "\tdef is_torch_imported(self):\n",
      "\t\timport sys \n",
      "\t\tprint('torch' in sys.modules) \n",
      "\t\tprint(torch.__version__) \n",
      "\t\tprint(type(torch.tensor)) \n",
      "\t\timport inspect \n",
      "\t\tprint(inspect.getfile(torch))\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(compiled_python.code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The dependency graph\n",
    "\n",
    "With `python` models we can plot the user defined label names. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "vertices = compiled_python.vertices\n",
    "create_network_graph(vertices=vertices)\n",
    "display_graph(vertices=vertices);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Models in pure python\n",
    "We don't need to import `torch`, we can actually write models in pure python, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_purepython=\"\"\"\n",
    "mean= sample(poisson(3))\n",
    "x= sample(gamma(mean,1))\n",
    "y= 10\n",
    "observe(normal(x,5), y)\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "compiled_python = compile_model(model_purepython, language='python')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An Example of the Graph G(V,E)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#Vertices: 3, #Arcs: 2\n",
      "Vertices V:\n",
      "Vertex x30001 [Sample]\n",
      "  Name:           x30001\n",
      "  Ancestors:      \n",
      "  Cond-Ancs.:     \n",
      "  Dist-Args:      {'rate': '3'}\n",
      "  Dist-Code:      dist.Poisson(3)\n",
      "  Dist-Name:      Poisson\n",
      "  Dist-Type:      DistributionType.DISCRETE\n",
      "  Sample-Size:    1\n",
      "  Orig. Name:     mean\n",
      "Vertex x30002 [Sample]\n",
      "  Name:           x30002\n",
      "  Ancestors:      x30001\n",
      "  Cond-Ancs.:     \n",
      "  Dist-Args:      {'alpha': \"state['x30001']\", 'beta': '1'}\n",
      "  Dist-Code:      dist.Gamma(state['x30001'], 1)\n",
      "  Dist-Name:      Gamma\n",
      "  Dist-Type:      DistributionType.CONTINUOUS\n",
      "  Sample-Size:    1\n",
      "  Orig. Name:     x\n",
      "Vertex y30003 [Observe]\n",
      "  Name:           y30003\n",
      "  Ancestors:      x30002\n",
      "  Conditions:     \n",
      "  Cond-Ancs.:     \n",
      "  Cond-Nodes:     \n",
      "  Dist-Args:      {'loc': \"state['x30002']\", 'scale': '5'}\n",
      "  Dist-Code:      dist.Normal(state['x30002'], 5)\n",
      "  Dist-Name:      Normal\n",
      "  Dist-Type:      DistributionType.CONTINUOUS\n",
      "  Sample-Size:    1\n",
      "  Observation:    10\n",
      "Arcs A:\n",
      "  (x30001, x30002), (x30002, y30003)\n",
      "\n",
      "Conditions C:\n",
      "  -\n",
      "\n",
      "Data D:\n",
      "  -\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(compiled_python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl4VdX59vHvE0JCgmEMyDwTIAmDYqlaKAgOqEAVCq0oWJXWSq3zQOfWsVY7/FBRi5U6VZBBccQ6MfiiVRSQJIQZQQiCBBJmSPK8f+wTCBggQsJJ2PfnurgIJ2evs3KAfZ+1117PMndHRETCKybaHRARkehSEIiIhJyCQEQk5BQEIiIhpyAQEQk5BYGISMgpCEREQk5BICIScgoCEZGQUxCIiIScgkBEJOQUBCIiIRcb7Q5UemYxQB2C96oA2Ip7UXQ7JSJSfhQEpTFLBE4DegGtCd4nBwwoxGwlMAf4DPddUeuniEg5MJWhLsGsGtAHGArEAduAfKCwxLOqAbWAJGAvMBmYiXshIiJVkIKgmFltYDTQEVgP7CnDUfFAEyAbGId7XsV1UESkYigIoDgExgD1CULg22oCbAb+rDAQkapGdw0Fl4NGc+whQOS4+sDoSHsiIlWGgiCYEyi+HHQ81kfa6XOc7YiInFDhDoLg7qChHH8IFFsPDMUsoZzaExGpcOEOguAW0TjKNjFcFnsIJpBPK6f2REQqXNiDoBfBLaLlKT/SrohIlRDeIAhWDLcmOHGXp3ygTaR9EZFKL8wnq+KyEYddCHYF9KwJt38MDZrBdWfC4DK0Wxhpt0459VNEpEKFOQiKy0Yc1pMwtw7kXwRXboGGF0P9l+GstWU7yat8h4hUCWEOggKC2kGHVQOKfgQfb4aaveGj8+D9LZD8LPz0b/CzadBzVbB+4HDti4hUeuFdWRxcw38M2MhhLg99DdU7wHU1YddXkDwLxp0JeQUQswBaZEHqOuhUHXa2hMVdICsFNhs0BK5TlVIRqQrCGwQAZmOAxsCW0r59EZz/EaRmw6M9YXgsFGbBcyWfUwT2OTTLhNS10KkeeBzMvwpuBz7zUL/BIlIVhD0IvgdcA6wpj+Yc+BJO/xVseR7OAqoD04CpwEeuEYKIVEJhD4IE4O8EI4LyWFQWD9QFbjbYDaQDPwSGRB5/iSAU5ri75hBEpFIIdxAAmPUDRgKryqG11sAzuL/7zZexDgSBMARoDrxMEArvufu+cnhtEZFjoiAIqoXeQXASP56aQ00IwuQvR9ukxsxaE6xJ+CGQArxGEAr/dffdx9EHEZFvTUEAUd2PwMyaAZcSjBS6ATOAKcCb7r7jGPoiIvKtKAiKHWGHshlwWlPY2BnWHXJUue5QZmYNgUsIQuFM4F2CkcJrrg1vRKSCKAhKOnjP4nggfxfsfBBuT4Tc22AcB/YsrkUQFhWyZ7GZ1QMGEYRCb2AOQShMd/fN5flaIhJuCoLSBHcTnQb0mguDsuEsAz8fXmkaLEBbSXBino/7rorvjtUCLiYIhfOAjwlC4WV331DRry8iJzcFwRGYWUIMrK8NdaqDx8D7OXBeNFcMW7CZTn+CieYLgUUEoTDN3ddGq18iUnUpCI7AzG4C7gFqRh7aBZzt7gui16sDzKwGcC7BSGEQsJwgFKa6+4po9k1Eqg4FwWFYcHloPQdXGi0C3nH3C6LTq8Mzs+oE8xtDCO5CWs+BUFgcxa6JSCWnIDiMUkYDxSrVqKA0Fkx69yQIhcEEm+VMjfxaqPpHIlKSgqAUhxkNFKu0o4LSWFBltQcHVjUXcSAUPlEoiIiCoBRHGA0Uq/SjgtKYmREsWhtCMNmcyIGieHO9nG+BFZGqQUFQCjP7CkgC9kYeSiTYaKb4zwkE9/MPi0L3ykUkFFI5MFJoyIH6RzNVFE8kPBQEpTCz3hx8WeiXQBbBSt9iy90984R2rAKZWXuC+YQhBHWXXiEIhXfdvTwqs4pIJaUgKAMzmwDMdvcJ0e7LiWBmLTkQCmnA6wShMMNPwAI6ETmxwrxnsRyGu3/h7n93954El4/mAtcDG8zsRTP7kZklRbeXIlJeFARyRO6e4+7j3L0f0A74L/ATYJ2ZTTezkWZWN6qdFJHjoiCQMnP3Te7+pLtfCLQgKJc9GPjCzGaY2U/NrEF0eyki35aCQI6Ju29192fd/RKCUtxPERTEW25m75nZL8ysSXR7KSJloSCQ4+bu2939xcjttI2AsQT7KWSY2f8zs1siE9AiUgkpCKRcufsud3/Z3UcQhMI9BBPO88xsnpmNidyqKiKVhIJAKoy773X3N919FNAYuJNgbmG2mX1uZn8ws/TI4jYRiRIFgZwQ7l7g7u+6+2igGcG2oHWAN4BsM7vPzLorFEROPAWBnHDuXujuH7j7zUBLYATBFqCTgJVm9pCZnRUpmCciFUz/0SSqPPCxu98JtAcuAXYCTwJrzOxhM+sTKa0tIhVAQSCVRiQUFrr77909jWD3tQ3A34H1ZvZPMzs/sgmPiJQTBYFUWu6e7e73uvtpwFnAMuAuglIX/zazgZHtOkXkOCgIpEpw95Xu/qC7n0mwp8JnwG0EofCCmf3QzA63f4SIHIGCQKocd1/r7mPdvTfQEZgFXAvkmNlUMxtuZrWi20uRqkNBIFWau29w98fd/TyCfRReA4YDX5rZa2Z2lZnVj24vRSo3BYGcNNx9s7tPcPcBQHPgP8AAYJWZvW1mPzezU6PbS5HKR0EgJyV3z3P3/7j7EIJVzU8AvYElZjbLzG4ws2bR7aVI5aAgkJOeu+9w9ynufhlB/aOHgNOBhWb2kZndbmZtottLkeiJjXYHRE4kd98NvAq8GlmPcA7wQ+AjM1tHsMfCVHfPjmI3RU4ojQgktNx9n7v/191/RnD56GaCEcO7ZpZpZneZWVfVP5KTnYJAhP31j2a6+y8JJppHAYnAdGCZmT1gZj0UCnIyUhCIHMLdi9z9Q3e/jeCW1B8BhcCzwGoz+7uZ9VRRPDlZ6B+yyBFE6h996u6/Jli8djGwFRgHrDOzcWbWz8w03yZVloJApIwioZDh7n9y9y4Et6OuAR4gWNX8LzO70MziottTkW9HQSByjNx9qbv/2d3PAL4DZAK/Jah/9KyZXWJmCdHtpcjRKQhEyoG7r3b3v7n794B04CPgRoJQeNHMhpnZKdHtpUjpFAQi5czd17v7o+5+DsFmO28DVxPsqfCymY0wszrR7aXIAQoCkQrk7hvdfby79yfYlnMawQK2NWb2ppmNMrPk6PZSwk5BIHKCuPsWd3/G3X8ANAWeBi4AVpjZu2Y22swaR7eXEkYKApEocPdt7j7R3YcSrGp+BDgbyDKzD8zsZjNrGd1eSlgoCESizN13uvtL7n4FQYmL+wgmnD81s0/M7E4zaxfdXsrJTEEgUom4+x53f8PdryEYKfwKaAV8YGYLzez3ZpamUhdSnhQEIpVUpCjeO+5+HcGcwvVAPWAGsNjM7jGz0xQKcrwUBCJVQKQo3hx3vwloAYwE4gjKZq8wswfN7EzVP5JjoX80IlVMpNTFx+5+B9AOGAzsBp4iuC11rJn1NrNqUe2oVBkKApEqLBIKC9z9d+6eCpwHbAT+j6Ao3uNmdl5kEx6RUikIRE4i7r7Y3e9x927A94CVwD0ERfEmmNkAM4uPbi+lslEQiJyk3H2Fu//F3b8LnAYsAO4gqH/0HzMbbGaJ0e2lVAYKApEQcPe17v5/7v59oBMwBxhNMFKYYmaXmVmt6PZSokVBIBIy7r7B3R9z93OBtsAbwBXAl2b2qpldaWZ1o9tLOZEUBCIh5u5fu/tT7n4xwV7NE4FLCLbkfMvMfmZmDaPbS6loCgIRAcDd89z9eXe/lGAB25NAX2Cpmc00s1+aWdPo9lIqgoJARL7B3be7+2R3/zFB/aO/AWcAi8xsrpndamatotlHKT/acFtEjsjddwOvAK9E9mPuCwwBPjaztcBUYKq7L4liN+U4aEQgImXm7nvdfYa7/xRoAtwW+f19M8swsz+ZWWfVP6paFAQickzcvcDd33f364FmwM+AJOA1YImZ3W9mZygUKj8FgYgcN3cvcve57n4LQdns4ZFv/QdYZWZ/M7OzVRSvctJfioiUq0j9o3nu/iugAzAQyAeeANaa2SNmdo6ZaY6yklAQiEiFiYTCInf/o7t3JphoXg88BKw3s/Fm1j8yCS1RoiAQkRPG3Ze4+33u3h34LpAN/J6g/tHTZjbIzGpEt5fhoyAQkahw91Xu/ld3PxvoDHwC3EIQChPNbKiZnRLdXoaDgkBEos7d17n7I+7eB0gB3gNGEeyp8JKZXWFmtaPayZOYgkBEKhV33+ju/3T3C4DWwMvAMIKJ5tfN7Gozqx/dXp5cFAQiUmm5e667P+3ugwjWKjwHXASsNLN3zOw6M2sU3V5WfQoCEakS3D3f3V9w9x8CjYFxQE9gsZnNNrMbzax5dHtZNSkIRKTKcfed7j7N3S8nKIr3ANAVmG9m/zOzO8ysbXR7WXVoQYeIVGnuvgd4HXjdzKoDfQiK4s01sxxgCkFRvMXR62XlphGBiJw03H2fu7/t7j8nKIZ3A9AA+K+ZZZnZ3WbWLZr1j8yIMaOeGQ0jv0f9PKwRgYiclNy9EJgNzDazm4HvAD8EpgFuZlMJSmh/7O5e1nYjq6A7ufvCsh9DInAa0IvgTqhYwAEDCs1YSbCP9Gfu7Cpru+XFvsXPH1pmNgGY7e4Tot0XETk+kdFAN4LLR0OAmgThMBWYGwmQIx1/FcHubZe7+8QjP5dqBJeqhgJxwDaCukslX6MaUIugcuteYDIw050j9qM8KQjKQEEgcvIys1SCkcIQoCHBuoWpwEx3Lyjl+bOA7wO7gJ+6+/Olt0ttYDTQkaC+0p4ydCee4JJWNjDOnbxv/QMdg6hfmxIRiSZ3z3L3u9y9K8Glm9XAfUCOmf3LzC4ys3iAyOrmMyOHJgDjzezKQ9uMhMAYgstAqyhbCBB53qrIcWMi7VQ4BYGISIS7L3f3B9y9B9AdWAT8iiAUngP+SHD5plgC8JiZXVP8QORy0GigPsFI4Fisjxw/OtJehVIQiIiUwt3XuPs/3L0XkAbMBUYChxbCSwAeNrOfR/7chwOXg47H+kg7fY6znaNSEIiIHIW75wBPE0wslyYB+JvZqTcSTAwfbwgUWw8MNSOhnNorlYJARKRsLuTgy0KHSoB2/4D3erF/TuCSfpB4BzS7Ft5OhreSoem1wWOX9g2e81IjqHMzxP4WGo2GSU1KtLmHYAL5tIr4gYopCEREymYkwS2exfYAecAOoABYBxdugO37gm8/1hpe6QkPTYb6efCLi+EXA6HhVnhgCrzcC55sCY13wV9egmnjYWcC/P3MQ143n2ASu8JoQZmISNl0BrYAKwgmkRcCS4ElwBfgDjwGbAye/t/WUDsPRq+CZXXg/wYFj988HX65En6XD2+0hVHvwZl58HV1qL4PWm4+5HXzgTZmxLhTVBE/mIJARKRs2hxpBbIZ9QjOqZGFYFsTIS4yOkjaGywkBjgl8lj8XtiSGHx9eS+YeA5U3wv9Vx3SdGGk3TpAbrn8JIfQpSERkTIoQxmK4rIREXV2wp644Ov8+KCaBMC2yGO746HuzuDru+fBpPHQIBf+eMER2q8QGhGIiJSPAg6c7YHzVsH0XvBIG3ivA7T9Aoos+HpsPuQnQf+VMKEF1CiE5D0QUwSxhyst8Y1VzuVFQSAiUj62EpysqwGFwdzAjP8HdwyFulvhqalQaPDTITDmhzDoA/jZaritGzx2HuyNgyYb4c8zDmm3WqTdrRXVcdUaKgPVGhKRsjBjDMHuaVvKsdm6wHp3HijHNg+iOQIRkfIzh4NvMS0PtSLtVhgFgYhI+fmMYNFZfDm1F0+wXmF+ObVXKgWBiEg5iWwqM5mglHR5aAJMrujNahQEIiLlaybBfgLHGwbF+xLMPM52jkpBICJSjiI7i40DNnPsYdAkcvy4E7FTmYJARKScRXYW+zMHNpkp65xBPAc2s/nzidqhTOsIREQqgDt5ZvyFA3sWxxPUDTrcnsW1CCaGn+EE71msIBARqSCRk/m7ZswlKCXdC2jDwefeAmAlMAmYX9ETw6VREIiIVLDIyX0uMNeMGIICcrFEVgxXVFXRslIQiIicQJGTfoVUET1WmiwWEQk5BYGISMgpCEREQk5BICIScgoCEZGQUxCIiIScgkBEJOQUBCIiIacgEBEJOQWBiEjIKQhEREJOQSAiEnIKAhGRkFMQiIiEnIJARCTkFAQiIiGnIBARCTkFgYhIyCkIRERCTkEgIhJyCgIRkZBTEIiIhJyCQEQk5BQEIiIhpyAQEQk5BYGISMgpCEREQk5BICIScgoCEZGQUxCIiIScgkBEJOQUBCIiIacgEBEJOQWBiEjIKQhEREJOQSAiEnIKAhGRkFMQiIiEnIJARCTkFAQiIiGnIBARCTkFgYhIyCkIRERCTkEgIhJyCgIRkZBTEIiIhJyCQEQk5BQEIiIhpyAQEQk5BYGISMgpCEREQk5BICIScgoCEZGQUxCIiIScgkBEJOQUBCIiIacgEBEJudhod0BEjs+nn37aMDY29kkgHX24EygCMgoKCkZ17959Y1kOUBCIVHGxsbFPNmrUqFODBg22xMTEeLT7I9FVVFRkmzZtSt2wYcOTwKCyHKNPDyJVX3qDBg3yFQICEBMT4w0aNMgjGCGW7ZgK7I+InBgxCgEpKfLvoczndwWBiEjIKQhETjbJyV0x615uv5KTux7tJe+8885G7dq1S0tJSUnt2LFj6nvvvVezIn/EHj16dJg9e3ZiWZ//2muvJZ1zzjntSj62bdu2mDp16nTLzc096Dx47rnnth0/fnzdsra9evXq6v3792/zbV+/WNOmTTvn5OREdb5Wk8UiJ5vNm8v3//VR2nvnnXdqvvXWW3UWLVqUlZCQ4Dk5ObF79uyxcu1DBUhKSirq1atX3vPPP1/3l7/85WaAzZs3V/v0009Peemll1aVpY19+/bRqlWrfTNmzFhZsb2tWBoRHI1ZTFOIOx2SMKuHmd4zkRLWrVtXvV69egUJCQkO0Lhx44JWrVrtA7jtttsap6end2rfvn3aZZdd1rKoqAgIPtFfc801zdPT0zu1adMmbdasWYnnn39+25YtW6bfcMMNTQCWLFkS17p167RBgwa1btOmTVr//v3bbNu27Rv//6ZNm1arW7duHVNTUztdeOGFbfLy8mIApkyZUqt169ZpqampnaZMmVKntL5fdtlluZMnT65X/Ofnn3++Tq9evfKTkpKK3n///cRu3bp17NSpU+ppp53WceHChfEAY8eOrd+3b992Z555ZsrZZ5/dYcmSJXHt27dPK+5z9+7dO6SmpnZKTU3t9Pbbb+8fGW3btq1anz592rVq1Sp9+PDhLQoLC7/Rn3HjxtXr3Llzp44dO6YOHz68ZUFBAQUFBQwZMqRV+/bt01JSUlL/9Kc/NTzWv6vD0UmtNGaJmH0PszHAY0/Cd8bDEOBB4HHMxkS+nxDlnopE3SWXXJK/fv36uFatWqVfccUVLV5//fVTir93++23b8zIyFi8bNmyzF27dsVMnDixdvH34uLiijIyMhZfddVVm4YOHdpu/Pjxa7KzszMnTZqUvGHDhmoAq1evrnH99ddvXLlyZWZSUlLRgw8+2KDka+fk5MTed999jWfPnr00Kytr8emnn77z7rvvPnXnzp12/fXXt3rllVeWZ2RkLN64cWP10vo+ePDg/MzMzMTi15s8eXK9yy67LBega9euuz/55JPsxYsXZ/3hD39Yd8cddzQrPi4zMzNx+vTpKz755JMlJdtr0qRJwZw5c5ZmZWUtnjRp0sqbb765RfH3Fi1aVHPcuHFrli9fnrF69er4Z5555qDLT5999lmNKVOm1Js3b152dnZ2VkxMjD/++OP1P/zww8ScnJzqy5Yty1y6dGnWL37xi83H8vd0JAqCksyqYdYP+BtwDdAY2LgedmyCLcBa4KvI49cAf8esH2bVotZnkSirXbt2UUZGRtYjjzzyRYMGDQquvPLKtmPHjq0P8OabbyZ16dKlY0pKSurcuXOTMjIy9n94uvTSS7cCdO3adVe7du12tWzZcl9CQoI3b958z8qVK+MAGjVqtPf888/fATBixIjNc+fOPaXka8+cObPmihUravTo0aNjx44dUydOnFh/zZo1cQsWLKjRrFmzPZ07d94TExPD5ZdfXurJs0aNGn7eeedtffbZZ+vm5OTEZmVlJQ4ePDgfIDc3t9pFF13Utn379ml33HFH86VLl9YoPq5Xr175p5566jc+0u/du9eGDx/eKiUlJXXo0KFtV6xYsf+Yzp0770hNTd0bGxvLsGHDcufMmXPQzzJjxoykjIyMxK5du3bq2LFj6gcffFBr5cqV8R07dtyzdu3a+CuvvLL5lClTatWtW/ebQ4njpDmCYma1gdFAR2A9sOcwzywkCIUtQDwwEuiB2Tjc805EV0Uqm9jYWAYMGLBtwIAB27p06bLr2WefrT9q1KjcW2+9teX//ve/rHbt2u275ZZbmuzevXv/h88aNWo4QExMDPHx8ftvf42JiaGgoMAAzA6eajj0z+5Oz54981999dWDrunPnTu3zKP14cOH5957772N3d3OP//8rcV9ufPOO5v27t1729tvv71iyZIlcX379u1QfExiYmJRaW3de++9pzZs2HDf1KlTVxUVFZGQkND9cH0v5WexoUOHbn700UfXHdpuRkZG1ksvvVTr8ccfbzBp0qR6kydPXl3Wn68sNCKA4hAYA7QGVnH4EDjUnsjzWwNjIu2IhMrChQvjFy1aFF/85/nz5yc0a9Zs786dO2MAGjVqVJCXlxfz6quvlvlOnGI5OTlx77zzTk2A559/vt7ZZ5+9veT3+/Tps2PevHmnZGRkxAPk5+fHfP755/HdunXbvW7durjMzMx4gIkTJ9b7ZuuBiy++eNvq1atrPPnkkw2GDx+eW/x4fn5+tWbNmu0FeOKJJ5LL0t+8vLxqjRs33letWjXGjRtXv+Q8wKJFi2pmZ2fHFRYWMmXKlHq9evXaVvLY/v3757/22mt1161bFwvw1VdfVVu6dGlcTk5ObGFhIT/5yU+23n///esWLVpU5rulykpBEFzWGQ3UJxgJHIv1keNH6zKRRF39+gUnsr38/PxqI0eObN22bdu0lJSU1Ozs7IQHHnhgfXJycuHll1++qVOnTmnnnHNOSteuXXd825du1arV7ocffrhhmzZt0rZu3Rp72223bSr5/SZNmhQ88cQTq3/84x+3SUlJST3jjDM6Llq0qEZiYqI//PDDXwwYMKBdampqp+Tk5MP+DNWqVePiiy/esnXr1tiLLrpo/8n5zjvv3PDHP/6xWadOnVILCsr2lt50000bX3jhhfodOnRIzc7OrpGQkLB/5JCenr7j5z//eYu2bdumt2jRYs+IESO2ljy2e/fuu3/729+u69evX0pKSkpq3759U9auXVt99erV1Xv27NmhY8eOqSNGjGhz1113fVnmN7CMzD3kCxKDOYGRBJ/sS/UU/KApfHEBLDhKa62BZ3B/tzy7KHIkCxcuXN21a9evo92P8rZkyZK4AQMGtF+2bFlmtPtSFS1cuDC5a9eurcry3HCPCMwSgaEc+0jgUOuBobqbSESqknAHAZwGxFH2OYGj2UMwgXxaObUnElodOnTYq9HAiRH2IOgFbDvqs76d/Ei7IiJVQmhvH401u6oQ7u8BmQuh3ZXw3lvQ+WuoOx5eeBtaTIbvAQyAzT+BL26Fbo/B+fugemv48nWY/DXEnQ03doXsZdCiMWz+HN5KNIvBvdRbzEREKpPQjghOhUSAM2FlK1j/JPT/NbwbC4V/gHMnwPk/gg+ugvcnQ/MciD8dNj0Hz0yCf62FRvdCt+L2asC+m+HNFdB8CjQFSl3SLiJS2YR2RFA9EoI/gyWZ0GgD1P8ZrL4Pti2DVgDPQF+AQrCNsH0TJE+A3tuh5l6I+wqSits7H5ZcAOvuBXKDeYLQvrciUrWEdkSwL9jXkzhwA2Jg/320p8FigB/A3L/Ai1fC2+fBmufg7Jqw82Z4vTrsddi/NDAWvPjNjFwPKt97uUXKKDmZrmZ0L69fyckctQz1ihUrqvfr169ty5Yt05s3b55+1VVXNd+9e7dBUKRt5MiRLY7WxomWmJj4jZs6vvvd76ZMnTq1VsnH7rrrroaXX375t+p/796923399ddHXFNU2usDDBkypNWECRO+9eK74xHaIPgKdka+/MZ7YMDV8NZb0P0OGPYBdKgNBf1hwQZo8Bqk14Rdh2vbgzIUWw/3fZGKtHlz+Y5Gj9ZeUVERl1xySbtBgwZt/eKLLzJWrVqVsWPHjpgbb7yxaXn2o6R9+/ZVSLtDhw7NfeGFFw5ahTx16tR6V1xxRe7hjimpqKiIwsJCZs2atTw5ObncawJVlNAGQYH7BIdftYfqb8MbufAPgNXw5Kfw4r/go3z46164bzlMaAO7JsCHe+D+RfCfXPjHDJhxFmx1+NPvISvy9dhb4V1NFEtYvPrqq0nx8fFFN95442YI6g49/vjjaydNmpRcXDZ63bp11Xv06NGhZcuW6bfeemtjCMpB9OnTp12HDh1S27dvn1a8GcycOXMSv/Od73RIS0vr1LNnz/ZffPFFdQhKV1999dXN09PTO40ZM6ZxkyZNOheXcMjPz49p1KhRlz179lhmZmZ8r1692qelpXXq3r17h/nz59cAyM7OjuvWrVvHlJSU1OJS14caMWLElvfee6928WhmyZIlcRs3bqx+wQUXbM/Ly4s566yzUlJTUzulpKSkPvfcc3WKn9OqVav0Sy+9tFVKSkraihUr4kpuNnPuuee2TUtL69SuXbu0hx566KBSFddcc03zdu3apZ111lkp69ev/0bgHu69uOeeexoWr+QeMGDAETfFKYvQBkHEHEpc5y8ntSLtioTCokWLErp27bqz5GP16tUraty48d6srKx4gM8//7zmK6+8sjwzMzPzlVdeqTd79uzEadOm1WrUqNG+JUuWZC1btixz8ODB+Xv27LEbbrihxfTp01dkZmYuvvLKK7++7baeegKkAAAG20lEQVTb9o8s9u7daxkZGYv/+te/5nTq1GnnG2+8kQQwadKk2r17986Lj4/3UaNGtRw3btyazMzMxQ8++OCX1113XQuA0aNHtxg1atSmpUuXZjVu3LjUIcWpp55a2LVr1x1TpkypDfD000/XGzhw4JaYmBgSExOLXn/99eVZWVmLZ82atfTXv/51s+L9FdasWRN//fXXb1q+fHlmSkrK3pJtPv/886szMzMXL1iwIOuJJ544tbjk9a5du2LOOOOMHcuXL8/83ve+t23MmDEHhdOR3ouxY8c2ysjIyFq6dGnWv//97y+O6y8QTWh+BowgmNwtj0Vlxe3ML4e2RE4aPXv2zG/UqFEhwMUXX7xl5syZp1xyySV5v/nNb5pfd911TX/wgx/k9e/ff/snn3xSY9myZQl9+/ZNgeBSS4MGDfaftIv3CgAYOnTolhdeeKHuwIEDt7344ov1Ro8evSkvLy9m/vz5pwwdOrRt8fP27t1rAJ999tkpb7755gqAa6+9dvPdd9+9f3+BkoYNG5Y7adKkuldcccXWadOm1Rs/fvzqSF/spptuavbRRx+dEhMTw8aNG+O+/PLLWIDGjRvv7devX6m1lB544IFTX3/99ToAGzZsqJ6ZmVmjUaNGO2JiYhg1alQuwNVXX7158ODBB21l+fnnn8cf7r3o0KHDrksvvbT1oEGDtl5++eXHfRk63EHgvguzyRyl1tC30ISg1tBh5w9ETjbp6em7Xn755YMmN3Nzc2NycnLiUlNT9/zvf/9LLK0Ec5cuXfZ89tlnWVOnTq39u9/9ruk777yTP2zYsK3t2rXbtWDBguzSXispKWn/JdfLLrts69133930q6++qpaRkZE4cODA/Pz8/JikpKSC7OzsrNKOj4mJOWpxteHDh2/9zW9+0/yDDz5I3L17d0yvXr12AjzxxBP1Nm/eHLto0aLF8fHx3rRp0867du2KgcOXpX7ttdeSZs2alTRv3rzspKSkoh49enQoPuZQpZWlPtx78f777y978803k6ZPn177oYcearxkyZLM6tVL3XunTMJ+aQhgJpBNcBI/Hk0i7cw8znZEqpRBgwZt2717d8wjjzxSH6CgoIDRo0c3Hzp06NfFJ+4PPvig1ldffVVt+/bt9sYbb9Tp3bv39tWrV1dPSkoqGj16dO4tt9yyYcGCBYldunTZnZubG1tcenrPnj02b968GqW9bu3atYu6dOmy49prr23Rr1+/vNjYWOrVq1fUrFmzvU899VRdCD5Ff/jhhwkAp59++vbx48fXAxg/fnz9w/08tWvXLjrrrLO2jRo1qtWll166fwSSl5dXLTk5eV98fLy/+uqrSevXr4872nuzdevWarVr1y5MSkoqmj9/fo2FCxfu37qyqKiI4ruD/v3vf9fv0aPHQVUODvdeFBYWsmLFiriBAwdue/TRR9dt3769Wl5e3nFVPVYQuBcC44DNHHsYNIkcPy7SnkjU1K9fvrcuH629mJgYXn755eXTpk2r27Jly/TWrVunx8fHF40dO3b/BitdunTZMWjQoLZpaWlpAwcO3PL9739/56effprQrVu3Th07dky99957m/z+97/PqVGjhk+cOHHFmDFjmnXo0CE1LS0tddasWacc7rWHDRu2Zfr06fVKXjJ64YUXVk6YMCG5eBJ66tSpdQDGjRu35p///GfDlJSU1HXr1h3x4/OPf/zj3CVLliSMHDlyf7ujRo3KXbhwYc2UlJTUp59+un7r1q13H+29GzJkSF5BQYG1adMm7fbbb29ashR3QkJC0ccff1yzffv2abNnz066//77c0oee7j3oqCgwIYPH946JSUlNT09PXXUqFEbj/cOJZWhLlb2HcpKiufASEA7lElUnKxlqOX4fJsy1OGeIyjJPQ+zvwB9CEpTxxMUkMsnWBdQrBrBnUG1CMLiGWCmRgIiUlUpCEoKTubvYjaXoJR0L6ANB79PBcBKYBIwXxPDIlLVKQhKE5zc5wJzMYshKCAXSxACW7VYTCqZoqKiIivLHTESDkVFRcb+ajdHp8nio3Evwj0X942R3xUCUtlkbNq0qXbkP7+EXFFRkW3atKk2kFHWYzQiEKniCgoKRm3YsOHJDRs2pKMPdxKMBDIKCgpGlfUA3TUkIhJy+vQgIhJyCgIRkZBTEIiIhJyCQEQk5BQEIiIhpyAQEQk5BYGISMgpCEREQk5BICIScgoCEZGQUxCIiIScgkBEJOQUBCIiIacgEBEJOQWBiEjIKQhEREJOQSAiEnIKAhGRkFMQiIiEnIJARCTkFAQiIiGnIBARCTkFgYhIyCkIRERCTkEgIhJyCgIRkZBTEIiIhNz/B5axy4Hr6BacAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "vertices = compiled_python.vertices\n",
    "create_network_graph(vertices=vertices)\n",
    "display_graph(vertices=vertices);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gaussian Mixture model\n",
    "\n",
    "In this model the goal of the inference procedure is to infer the unknown means that describe the observations. Gaussian mixtures assume that the data can be modelled by a collection of Gaussian distributions (of course this is by no means always true). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_gmm2 = \"\"\"\n",
    "import torch\n",
    "\n",
    "means= 2\n",
    "samples= 10\n",
    "y= [-2.0, -2.5, -1.7, -1.9, -2.2, 1.5, 2.2, 3.0, 1.2, 2.8,-1.7, -1.3,  3.2,  0.8, -0.9, 0.3, 1.4, 2.1, 0.8, 1.9] \n",
    "ys= torch.tensor([y])\n",
    "pi= torch.tensor(0.5*torch.ones(samples,means))\n",
    "mus= sample(normal(torch.zeros(means,1), 2*torch.ones(means,1)))\n",
    "\n",
    "zn= sample(categorical(pi), sample_size=2)\n",
    "\n",
    "for i in range(samples):\n",
    "    index = (zn == i).nonzero()\n",
    "    observe(normal(mus[i]*torch.ones(len(index),1), 2*torch.ones(len(index),1)), ys[index])\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "compiled_python = compile_model(model_gmm2, language='python')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The code output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# 2019-03-16 18:15:48.779345\n",
      "import torch.distributions as dist\n",
      "import torch\n",
      "\n",
      "class Model():\n",
      "\n",
      "\tdef __init__(self, vertices: set, arcs: set, data: set, conditionals: set):\n",
      "\t\tsuper().__init__()\n",
      "\t\tself.vertices = vertices\n",
      "\t\tself.arcs = arcs\n",
      "\t\tself.data = data\n",
      "\t\tself.conditionals = conditionals\n",
      "\t\n",
      "\tdef __repr__(self):\n",
      "\t\tV = '\\n'.join(sorted([repr(v) for v in self.vertices]))\n",
      "\t\tA = ', '.join(['({}, {})'.format(u.name, v.name) for (u, v) in self.arcs]) if len(self.arcs) > 0 else '  -'\n",
      "\t\tC = '\\n'.join(sorted([repr(v) for v in self.conditionals])) if len(self.conditionals) > 0 else '  -'\n",
      "\t\tD = '\\n'.join([repr(u) for u in self.data]) if len(self.data) > 0 else '  -'\n",
      "\t\tgraph = 'Vertices V:\\n{V}\\nArcs A:\\n  {A}\\n\\nConditions C:\\n{C}\\n\\nData D:\\n{D}\\n'.format(V=V, A=A, C=C, D=D)\n",
      "\t\tgraph = '#Vertices: {}, #Arcs: {}\\n'.format(len(self.vertices), len(self.arcs)) + graph\n",
      "\t\treturn graph\n",
      "\t\n",
      "\tdef gen_cond_bit_vector(self, state):\n",
      "\t\tresult = 0\n",
      "\t\tfor cond in self.conditionals:\n",
      "\t\t\tresult = cond.update_bit_vector(state, result)\n",
      "\t\treturn result\n",
      "\n",
      "\tdef gen_cond_vars(self):\n",
      "\t\treturn [c.name for c in self.conditionals]\n",
      "\n",
      "\tdef gen_cont_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_continuous and not v.is_conditional and v.is_sampled]\n",
      "\n",
      "\tdef gen_disc_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_discrete and v.is_sampled]\n",
      "\n",
      "\tdef gen_if_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_conditional and v.is_sampled and v.is_continuous]\n",
      "\n",
      "\tdef gen_log_prob(self, state):\n",
      "\t\ttry:\n",
      "\t\t\tlog_prob = 0\n",
      "\t\t\tdst_ = dist.Normal(loc=torch.zeros(2, 1), scale=(2 * torch.ones(2, 1)))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30001'])\n",
      "\t\t\tdst_ = dist.Categorical(probs=torch.tensor((0.5 * torch.ones(10, 2))))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30002'])\n",
      "\t\t\tdst_ = dist.Normal(loc=(state['x30001'][0] * torch.ones(len((state['x30002'] == 0).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 0).nonzero()), 1)))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30004'])\n",
      "\t\t\tdst_ = dist.Normal(loc=(state['x30001'][1] * torch.ones(len((state['x30002'] == 1).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 1).nonzero()), 1)))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30005'])\n",
      "\t\t\tdst_ = dist.Normal(loc=(state['x30001'][2] * torch.ones(len((state['x30002'] == 2).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 2).nonzero()), 1)))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30006'])\n",
      "\t\t\tdst_ = dist.Normal(loc=(state['x30001'][3] * torch.ones(len((state['x30002'] == 3).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 3).nonzero()), 1)))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30007'])\n",
      "\t\t\tdst_ = dist.Normal(loc=(state['x30001'][4] * torch.ones(len((state['x30002'] == 4).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 4).nonzero()), 1)))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30008'])\n",
      "\t\t\tdst_ = dist.Normal(loc=(state['x30001'][5] * torch.ones(len((state['x30002'] == 5).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 5).nonzero()), 1)))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30009'])\n",
      "\t\t\tdst_ = dist.Normal(loc=(state['x30001'][6] * torch.ones(len((state['x30002'] == 6).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 6).nonzero()), 1)))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30010'])\n",
      "\t\t\tdst_ = dist.Normal(loc=(state['x30001'][7] * torch.ones(len((state['x30002'] == 7).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 7).nonzero()), 1)))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30011'])\n",
      "\t\t\tdst_ = dist.Normal(loc=(state['x30001'][8] * torch.ones(len((state['x30002'] == 8).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 8).nonzero()), 1)))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30012'])\n",
      "\t\t\tdst_ = dist.Normal(loc=(state['x30001'][9] * torch.ones(len((state['x30002'] == 9).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 9).nonzero()), 1)))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30013'])\n",
      "\t\t\treturn log_prob\n",
      "\t\texcept(ValueError, RuntimeError) as e:\n",
      "\t\t\tprint('****Warning: Target density is ill-defined****')\n",
      "\n",
      "\tdef gen_prior_samples(self):\n",
      "\t\tstate = {}\n",
      "\t\tdst_ = dist.Normal(loc=torch.zeros(2, 1), scale=(2 * torch.ones(2, 1)))\n",
      "\t\tstate['x30001'] = dst_.sample()\n",
      "\t\tdst_ = dist.Categorical(probs=torch.tensor((0.5 * torch.ones(10, 2))))\n",
      "\t\tstate['x30002'] = dst_.sample(sample_size=2)\n",
      "\t\tstate['data_30003'] = [-2.0, -2.5, -1.7, -1.9, -2.2, 1.5, 2.2, 3.0, 1.2, 2.8, -1.7, -1.3, 3.2, 0.8, -0.9, 0.3, 1.4, 2.1, 0.8, 1.9]\n",
      "\t\tdst_ = dist.Normal(loc=(state['x30001'][0] * torch.ones(len((state['x30002'] == 0).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 0).nonzero()), 1)))\n",
      "\t\tstate['y30004'] = torch.tensor([state['data_30003']])[(state['x30002'] == 0).nonzero()]\n",
      "\t\tdst_ = dist.Normal(loc=(state['x30001'][1] * torch.ones(len((state['x30002'] == 1).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 1).nonzero()), 1)))\n",
      "\t\tstate['y30005'] = torch.tensor([state['data_30003']])[(state['x30002'] == 1).nonzero()]\n",
      "\t\tdst_ = dist.Normal(loc=(state['x30001'][2] * torch.ones(len((state['x30002'] == 2).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 2).nonzero()), 1)))\n",
      "\t\tstate['y30006'] = torch.tensor([state['data_30003']])[(state['x30002'] == 2).nonzero()]\n",
      "\t\tdst_ = dist.Normal(loc=(state['x30001'][3] * torch.ones(len((state['x30002'] == 3).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 3).nonzero()), 1)))\n",
      "\t\tstate['y30007'] = torch.tensor([state['data_30003']])[(state['x30002'] == 3).nonzero()]\n",
      "\t\tdst_ = dist.Normal(loc=(state['x30001'][4] * torch.ones(len((state['x30002'] == 4).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 4).nonzero()), 1)))\n",
      "\t\tstate['y30008'] = torch.tensor([state['data_30003']])[(state['x30002'] == 4).nonzero()]\n",
      "\t\tdst_ = dist.Normal(loc=(state['x30001'][5] * torch.ones(len((state['x30002'] == 5).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 5).nonzero()), 1)))\n",
      "\t\tstate['y30009'] = torch.tensor([state['data_30003']])[(state['x30002'] == 5).nonzero()]\n",
      "\t\tdst_ = dist.Normal(loc=(state['x30001'][6] * torch.ones(len((state['x30002'] == 6).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 6).nonzero()), 1)))\n",
      "\t\tstate['y30010'] = torch.tensor([state['data_30003']])[(state['x30002'] == 6).nonzero()]\n",
      "\t\tdst_ = dist.Normal(loc=(state['x30001'][7] * torch.ones(len((state['x30002'] == 7).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 7).nonzero()), 1)))\n",
      "\t\tstate['y30011'] = torch.tensor([state['data_30003']])[(state['x30002'] == 7).nonzero()]\n",
      "\t\tdst_ = dist.Normal(loc=(state['x30001'][8] * torch.ones(len((state['x30002'] == 8).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 8).nonzero()), 1)))\n",
      "\t\tstate['y30012'] = torch.tensor([state['data_30003']])[(state['x30002'] == 8).nonzero()]\n",
      "\t\tdst_ = dist.Normal(loc=(state['x30001'][9] * torch.ones(len((state['x30002'] == 9).nonzero()), 1)), scale=(2 * torch.ones(len((state['x30002'] == 9).nonzero()), 1)))\n",
      "\t\tstate['y30013'] = torch.tensor([state['data_30003']])[(state['x30002'] == 9).nonzero()]\n",
      "\t\treturn state\n",
      "\n",
      "\tdef get_arcs(self):\n",
      "\t\treturn self.arcs\n",
      "\n",
      "\tdef get_arcs_names(self):\n",
      "\t\treturn [(u.name, v.name) for (u, v) in self.arcs]\n",
      "\n",
      "\tdef get_conditions(self):\n",
      "\t\treturn self.conditionals\n",
      "\n",
      "\tdef get_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_sampled]\n",
      "\n",
      "\tdef get_vertices(self):\n",
      "\t\treturn self.vertices\n",
      "\n",
      "\tdef get_vertices_names(self):\n",
      "\t\treturn [v.name for v in self.vertices]\n",
      "\n",
      "\tdef is_torch_imported(self):\n",
      "\t\timport sys \n",
      "\t\tprint('torch' in sys.modules) \n",
      "\t\tprint(torch.__version__) \n",
      "\t\tprint(type(torch.tensor)) \n",
      "\t\timport inspect \n",
      "\t\tprint(inspect.getfile(torch))\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(compiled_python.code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The dependency graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "vertices = compiled_python.vertices\n",
    "create_network_graph(vertices=vertices)\n",
    "display_graph(vertices=vertices);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Coal Mining model\n",
    "\n",
    "This model is popular change point detection model in the statistics community. The goal of the model is to infer, whether or not improvements in technology and safety had an impact on reducing the number of coal mining related deaths. See [here](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=7&ved=0ahUKEwibzpmXxeTbAhVIPhQKHRxGCVEQFghFMAY&url=https%3A%2F%2Fwiki.helsinki.fi%2Fdownload%2Fattachments%2F48865343%2FWB.pdf&usg=AOvVaw0Vx-U9LuQU4j9W-dnLpZgr) for more details.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_coal_mining=\"\"\"\n",
    "e= sample(exponential(1))\n",
    "l= sample(exponential(1))\n",
    "T= 10\n",
    "s= sample(uniform(0,10))\n",
    "y= [4,5,4,1,0,4,3,4,0,6,3,3,4,0,2,6,3,3,5,4,5,3,1,4,4,1,5,5,\n",
    "      3,4,2,5,2,2,3,4,2,1,3,2,1,1,1,1,1,3,0,0,1,0,1,1,0,0,3,1,\n",
    "      0,3,2,2,0,1,1,1,0,1,0,1,0,0,0,2,1,0,0,0,1,1,0,2,2,3,1,1,\n",
    "      2,1,1,1,1,2,4,2,0,0,0,1,4,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0]\n",
    "for i in range(T-1):\n",
    "    if i+1 < s:\n",
    "        observe(exponential(e), y[i])\n",
    "    elif i == s:\n",
    "        observe(exponential(1), y[i])\n",
    "    else:\n",
    "        observe(exponential(2), y[i])\n",
    "[e,l,s]\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "compiled_python = compile_model(model_coal_mining, language='python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# 2019-03-16 18:15:49.287581\n",
      "import torch.distributions as dist\n",
      "\n",
      "\n",
      "class Model():\n",
      "\n",
      "\tdef __init__(self, vertices: set, arcs: set, data: set, conditionals: set):\n",
      "\t\tsuper().__init__()\n",
      "\t\tself.vertices = vertices\n",
      "\t\tself.arcs = arcs\n",
      "\t\tself.data = data\n",
      "\t\tself.conditionals = conditionals\n",
      "\t\n",
      "\tdef __repr__(self):\n",
      "\t\tV = '\\n'.join(sorted([repr(v) for v in self.vertices]))\n",
      "\t\tA = ', '.join(['({}, {})'.format(u.name, v.name) for (u, v) in self.arcs]) if len(self.arcs) > 0 else '  -'\n",
      "\t\tC = '\\n'.join(sorted([repr(v) for v in self.conditionals])) if len(self.conditionals) > 0 else '  -'\n",
      "\t\tD = '\\n'.join([repr(u) for u in self.data]) if len(self.data) > 0 else '  -'\n",
      "\t\tgraph = 'Vertices V:\\n{V}\\nArcs A:\\n  {A}\\n\\nConditions C:\\n{C}\\n\\nData D:\\n{D}\\n'.format(V=V, A=A, C=C, D=D)\n",
      "\t\tgraph = '#Vertices: {}, #Arcs: {}\\n'.format(len(self.vertices), len(self.arcs)) + graph\n",
      "\t\treturn graph\n",
      "\t\n",
      "\tdef gen_cond_bit_vector(self, state):\n",
      "\t\tresult = 0\n",
      "\t\tfor cond in self.conditionals:\n",
      "\t\t\tresult = cond.update_bit_vector(state, result)\n",
      "\t\treturn result\n",
      "\n",
      "\tdef gen_cond_vars(self):\n",
      "\t\treturn [c.name for c in self.conditionals]\n",
      "\n",
      "\tdef gen_cont_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_continuous and not v.is_conditional and v.is_sampled]\n",
      "\n",
      "\tdef gen_disc_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_discrete and v.is_sampled]\n",
      "\n",
      "\tdef gen_if_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_conditional and v.is_sampled and v.is_continuous]\n",
      "\n",
      "\tdef gen_log_prob(self, state):\n",
      "\t\ttry:\n",
      "\t\t\tlog_prob = 0\n",
      "\t\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30001'])\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30002'])\n",
      "\t\t\tdst_ = dist.Uniform(low=0, high=10)\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30003'])\n",
      "\t\t\tstate['cond_30004'] = (1 < state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\t\tif state['cond_30004']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30005'])\n",
      "\t\t\tstate['cond_30006'] = (0 == state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\t\tif state['cond_30006'] and not state['cond_30004']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30007'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\t\tif not state['cond_30004'] and not state['cond_30006']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30008'])\n",
      "\t\t\tstate['cond_30009'] = (2 < state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\t\tif state['cond_30009']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30010'])\n",
      "\t\t\tstate['cond_30011'] = (1 == state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\t\tif state['cond_30011'] and not state['cond_30009']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30012'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\t\tif not state['cond_30009'] and not state['cond_30011']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30013'])\n",
      "\t\t\tstate['cond_30014'] = (3 < state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\t\tif state['cond_30014']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30015'])\n",
      "\t\t\tstate['cond_30016'] = (2 == state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\t\tif not state['cond_30014'] and state['cond_30016']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30017'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\t\tif not state['cond_30014'] and not state['cond_30016']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30018'])\n",
      "\t\t\tstate['cond_30019'] = (4 < state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\t\tif state['cond_30019']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30020'])\n",
      "\t\t\tstate['cond_30021'] = (3 == state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\t\tif state['cond_30021'] and not state['cond_30019']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30022'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\t\tif not state['cond_30019'] and not state['cond_30021']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30023'])\n",
      "\t\t\tstate['cond_30024'] = (5 < state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\t\tif state['cond_30024']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30025'])\n",
      "\t\t\tstate['cond_30026'] = (4 == state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\t\tif state['cond_30026'] and not state['cond_30024']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30027'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\t\tif not state['cond_30026'] and not state['cond_30024']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30028'])\n",
      "\t\t\tstate['cond_30029'] = (6 < state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\t\tif state['cond_30029']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30030'])\n",
      "\t\t\tstate['cond_30031'] = (5 == state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\t\tif not state['cond_30029'] and state['cond_30031']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30032'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\t\tif not state['cond_30029'] and not state['cond_30031']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30033'])\n",
      "\t\t\tstate['cond_30034'] = (7 < state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\t\tif state['cond_30034']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30035'])\n",
      "\t\t\tstate['cond_30036'] = (6 == state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\t\tif state['cond_30036'] and not state['cond_30034']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30037'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\t\tif not state['cond_30034'] and not state['cond_30036']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30038'])\n",
      "\t\t\tstate['cond_30039'] = (8 < state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\t\tif state['cond_30039']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30040'])\n",
      "\t\t\tstate['cond_30041'] = (7 == state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\t\tif not state['cond_30039'] and state['cond_30041']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30042'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\t\tif not state['cond_30039'] and not state['cond_30041']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30043'])\n",
      "\t\t\tstate['cond_30044'] = (9 < state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\t\tif state['cond_30044']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30045'])\n",
      "\t\t\tstate['cond_30046'] = (8 == state['x30003'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\t\tif state['cond_30046'] and not state['cond_30044']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30047'])\n",
      "\t\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\t\tif not state['cond_30046'] and not state['cond_30044']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30048'])\n",
      "\t\t\treturn log_prob\n",
      "\t\texcept(ValueError, RuntimeError) as e:\n",
      "\t\t\tprint('****Warning: Target density is ill-defined****')\n",
      "\n",
      "\tdef gen_prior_samples(self):\n",
      "\t\tstate = {}\n",
      "\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\tstate['x30001'] = dst_.sample()\n",
      "\t\tstate['x30002'] = dst_.sample()\n",
      "\t\tdst_ = dist.Uniform(low=0, high=10)\n",
      "\t\tstate['x30003'] = dst_.sample()\n",
      "\t\tstate['cond_30004'] = (1 < state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\tstate['y30005'] = 4\n",
      "\t\tstate['cond_30006'] = (0 == state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\tstate['y30007'] = 4\n",
      "\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\tstate['y30008'] = 4\n",
      "\t\tstate['cond_30009'] = (2 < state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\tstate['y30010'] = 5\n",
      "\t\tstate['cond_30011'] = (1 == state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\tstate['y30012'] = 5\n",
      "\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\tstate['y30013'] = 5\n",
      "\t\tstate['cond_30014'] = (3 < state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\tstate['y30015'] = 4\n",
      "\t\tstate['cond_30016'] = (2 == state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\tstate['y30017'] = 4\n",
      "\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\tstate['y30018'] = 4\n",
      "\t\tstate['cond_30019'] = (4 < state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\tstate['y30020'] = 1\n",
      "\t\tstate['cond_30021'] = (3 == state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\tstate['y30022'] = 1\n",
      "\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\tstate['y30023'] = 1\n",
      "\t\tstate['cond_30024'] = (5 < state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\tstate['y30025'] = 0\n",
      "\t\tstate['cond_30026'] = (4 == state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\tstate['y30027'] = 0\n",
      "\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\tstate['y30028'] = 0\n",
      "\t\tstate['cond_30029'] = (6 < state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\tstate['y30030'] = 4\n",
      "\t\tstate['cond_30031'] = (5 == state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\tstate['y30032'] = 4\n",
      "\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\tstate['y30033'] = 4\n",
      "\t\tstate['cond_30034'] = (7 < state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\tstate['y30035'] = 3\n",
      "\t\tstate['cond_30036'] = (6 == state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\tstate['y30037'] = 3\n",
      "\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\tstate['y30038'] = 3\n",
      "\t\tstate['cond_30039'] = (8 < state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\tstate['y30040'] = 4\n",
      "\t\tstate['cond_30041'] = (7 == state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\tstate['y30042'] = 4\n",
      "\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\tstate['y30043'] = 4\n",
      "\t\tstate['cond_30044'] = (9 < state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=state['x30001'])\n",
      "\t\tstate['y30045'] = 0\n",
      "\t\tstate['cond_30046'] = (8 == state['x30003'])\n",
      "\t\tdst_ = dist.Exponential(rate=1)\n",
      "\t\tstate['y30047'] = 0\n",
      "\t\tdst_ = dist.Exponential(rate=2)\n",
      "\t\tstate['y30048'] = 0\n",
      "\t\treturn state\n",
      "\n",
      "\tdef get_arcs(self):\n",
      "\t\treturn self.arcs\n",
      "\n",
      "\tdef get_arcs_names(self):\n",
      "\t\treturn [(u.name, v.name) for (u, v) in self.arcs]\n",
      "\n",
      "\tdef get_conditions(self):\n",
      "\t\treturn self.conditionals\n",
      "\n",
      "\tdef get_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_sampled]\n",
      "\n",
      "\tdef get_vertices(self):\n",
      "\t\treturn self.vertices\n",
      "\n",
      "\tdef get_vertices_names(self):\n",
      "\t\treturn [v.name for v in self.vertices]\n",
      "\n",
      "\tdef is_torch_imported(self):\n",
      "\t\timport sys \n",
      "\t\tprint('torch' in sys.modules) \n",
      "\t\tprint(torch.__version__) \n",
      "\t\tprint(type(torch.tensor)) \n",
      "\t\timport inspect \n",
      "\t\tprint(inspect.getfile(torch))\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(compiled_python.code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The dependency graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "vertices = compiled_python.vertices\n",
    "create_network_graph(vertices=vertices)\n",
    "display_graph(vertices=vertices);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other types of analytic functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# 2019-03-16 18:15:50.125226\n",
      "import torch.distributions as dist\n",
      "\n",
      "\n",
      "class Model():\n",
      "\n",
      "\tdef __init__(self, vertices: set, arcs: set, data: set, conditionals: set):\n",
      "\t\tsuper().__init__()\n",
      "\t\tself.vertices = vertices\n",
      "\t\tself.arcs = arcs\n",
      "\t\tself.data = data\n",
      "\t\tself.conditionals = conditionals\n",
      "\t\n",
      "\tdef __repr__(self):\n",
      "\t\tV = '\\n'.join(sorted([repr(v) for v in self.vertices]))\n",
      "\t\tA = ', '.join(['({}, {})'.format(u.name, v.name) for (u, v) in self.arcs]) if len(self.arcs) > 0 else '  -'\n",
      "\t\tC = '\\n'.join(sorted([repr(v) for v in self.conditionals])) if len(self.conditionals) > 0 else '  -'\n",
      "\t\tD = '\\n'.join([repr(u) for u in self.data]) if len(self.data) > 0 else '  -'\n",
      "\t\tgraph = 'Vertices V:\\n{V}\\nArcs A:\\n  {A}\\n\\nConditions C:\\n{C}\\n\\nData D:\\n{D}\\n'.format(V=V, A=A, C=C, D=D)\n",
      "\t\tgraph = '#Vertices: {}, #Arcs: {}\\n'.format(len(self.vertices), len(self.arcs)) + graph\n",
      "\t\treturn graph\n",
      "\t\n",
      "\tdef gen_cond_bit_vector(self, state):\n",
      "\t\tresult = 0\n",
      "\t\tfor cond in self.conditionals:\n",
      "\t\t\tresult = cond.update_bit_vector(state, result)\n",
      "\t\treturn result\n",
      "\n",
      "\tdef gen_cond_vars(self):\n",
      "\t\treturn [c.name for c in self.conditionals]\n",
      "\n",
      "\tdef gen_cont_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_continuous and not v.is_conditional and v.is_sampled]\n",
      "\n",
      "\tdef gen_disc_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_discrete and v.is_sampled]\n",
      "\n",
      "\tdef gen_if_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_conditional and v.is_sampled and v.is_continuous]\n",
      "\n",
      "\tdef gen_log_prob(self, state):\n",
      "\t\ttry:\n",
      "\t\t\tlog_prob = 0\n",
      "\t\t\tdst_ = dist.Exp(values=3)\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30001'])\n",
      "\t\t\tdst_ = dist.Gamma(alpha=state['x30001'], beta=1)\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30002'])\n",
      "\t\t\tdst_ = dist.Log(values=((state['x30002'] * state['x30002']) + 1))\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30003'])\n",
      "\t\t\treturn log_prob\n",
      "\t\texcept(ValueError, RuntimeError) as e:\n",
      "\t\t\tprint('****Warning: Target density is ill-defined****')\n",
      "\n",
      "\tdef gen_prior_samples(self):\n",
      "\t\tstate = {}\n",
      "\t\tdst_ = dist.Exp(values=3)\n",
      "\t\tstate['x30001'] = dst_.sample()\n",
      "\t\tdst_ = dist.Gamma(alpha=state['x30001'], beta=1)\n",
      "\t\tstate['x30002'] = dst_.sample()\n",
      "\t\tdst_ = dist.Log(values=((state['x30002'] * state['x30002']) + 1))\n",
      "\t\tstate['y30003'] = 10\n",
      "\t\treturn state\n",
      "\n",
      "\tdef get_arcs(self):\n",
      "\t\treturn self.arcs\n",
      "\n",
      "\tdef get_arcs_names(self):\n",
      "\t\treturn [(u.name, v.name) for (u, v) in self.arcs]\n",
      "\n",
      "\tdef get_conditions(self):\n",
      "\t\treturn self.conditionals\n",
      "\n",
      "\tdef get_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_sampled]\n",
      "\n",
      "\tdef get_vertices(self):\n",
      "\t\treturn self.vertices\n",
      "\n",
      "\tdef get_vertices_names(self):\n",
      "\t\treturn [v.name for v in self.vertices]\n",
      "\n",
      "\tdef is_torch_imported(self):\n",
      "\t\timport sys \n",
      "\t\tprint('torch' in sys.modules) \n",
      "\t\tprint(torch.__version__) \n",
      "\t\tprint(type(torch.tensor)) \n",
      "\t\timport inspect \n",
      "\t\tprint(inspect.getfile(torch))\n",
      "\n"
     ]
    }
   ],
   "source": [
    "model_purepython=\"\"\"\n",
    "mean= sample(Exp(3))\n",
    "x= sample(gamma(mean,1))\n",
    "y= 10\n",
    "observe(Log(x*x+1), y)\n",
    "\"\"\"\n",
    "compiled_python = compile_model(model_purepython, language='python')\n",
    "\n",
    "print(compiled_python.code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I would like to thank [Andrea Patanè](http://www.cs.ox.ac.uk/people/andrea.patane/), [Sasha Salter](http://ori.ox.ac.uk/mrg_people/sasha-salter/) and Saeid Naderiparizi for proof reading the post.\n",
    "\n",
    "## Using factor\n",
    "\n",
    "In the following examples we demonstrate how to use ```factor``` and what happens when dealing with models that contain zero-density. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_rrhmc_clojure=\"\"\"\n",
    "(let [x (sample (uniform -6 6))\n",
    "       absx (max x (- x))\n",
    "       A 0.1\n",
    "       y 0\n",
    "       z (- (sqrt (* x (* A x))))]\n",
    " (if (< (- absx 3) 0)\n",
    "     (observe (factor z) y)\n",
    "     (observe (factor(- z 1)) y))\n",
    " x)\n",
    "\"\"\"\n",
    "\n",
    "model_rrhmc_python= \"\"\"\n",
    "import torch\n",
    "x = sample(uniform(-6,6))\n",
    "absx = max(x, -x)\n",
    "A = 0.1\n",
    "z = -torch.sqrt(x*A*x)\n",
    "if absx-3 < 0:\n",
    "    observe(factor(z),None)\n",
    "    observe(factor(z-1),None)\n",
    "\"\"\"\n",
    "compiled_clojure = compile_model(model_rrhmc_clojure, language='clojure')\n",
    "compiled_python = compile_model(model_rrhmc_python, language='python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#Vertices: 3, #Arcs: 2\n",
      "Vertices V:\n",
      "Vertex x30001 [Sample]\n",
      "  Name:           x30001\n",
      "  Ancestors:      \n",
      "  Cond-Ancs.:     \n",
      "  Dist-Args:      {'low': '-6', 'high': '6'}\n",
      "  Dist-Code:      dist.Uniform(-6, 6)\n",
      "  Dist-Name:      Uniform\n",
      "  Dist-Type:      DistributionType.CONTINUOUS\n",
      "  Sample-Size:    1\n",
      "  Orig. Name:     x\n",
      "Vertex y30003 [Observe]\n",
      "  Name:           y30003\n",
      "  Ancestors:      x30001\n",
      "  Conditions:     cond_30002=True\n",
      "  Cond-Ancs.:     x30001\n",
      "  Cond-Nodes:     cond_30002\n",
      "  Dist-Args:      {'log_p': \"-torch.sqrt(((state['x30001'] * 0.1) * state['x30001']))\"}\n",
      "  Dist-Code:      dist.factor(-torch.sqrt(((state['x30001'] * 0.1) * state['x30001'])))\n",
      "  Dist-Name:      factor\n",
      "  Dist-Type:      DistributionType.UNDEFINED\n",
      "  Sample-Size:    1\n",
      "  Observation:    None\n",
      "Vertex y30004 [Observe]\n",
      "  Name:           y30004\n",
      "  Ancestors:      x30001\n",
      "  Conditions:     cond_30002=True\n",
      "  Cond-Ancs.:     x30001\n",
      "  Cond-Nodes:     cond_30002\n",
      "  Dist-Args:      {'log_p': \"(-torch.sqrt(((state['x30001'] * 0.1) * state['x30001'])) + -1)\"}\n",
      "  Dist-Code:      dist.factor((-torch.sqrt(((state['x30001'] * 0.1) * state['x30001'])) + -1))\n",
      "  Dist-Name:      factor\n",
      "  Dist-Type:      DistributionType.UNDEFINED\n",
      "  Sample-Size:    1\n",
      "  Observation:    None\n",
      "Arcs A:\n",
      "  (x30001, y30003), (x30001, y30004)\n",
      "\n",
      "Conditions C:\n",
      "Condition\n",
      "  Name:         cond_30002\n",
      "  Ancestors:    x30001\n",
      "  Condition:    ((max(state['x30001'], -state['x30001']) + -3) < 0)\n",
      "  Function:     (max(state['x30001'], -state['x30001']) + -3)\n",
      "  Op:           <\n",
      "\n",
      "Data D:\n",
      "  -\n",
      "\n",
      "# 2019-03-16 18:15:51.130612\n",
      "import torch.distributions as dist\n",
      "import torch\n",
      "\n",
      "class Model():\n",
      "\n",
      "\tdef __init__(self, vertices: set, arcs: set, data: set, conditionals: set):\n",
      "\t\tsuper().__init__()\n",
      "\t\tself.vertices = vertices\n",
      "\t\tself.arcs = arcs\n",
      "\t\tself.data = data\n",
      "\t\tself.conditionals = conditionals\n",
      "\t\n",
      "\tdef __repr__(self):\n",
      "\t\tV = '\\n'.join(sorted([repr(v) for v in self.vertices]))\n",
      "\t\tA = ', '.join(['({}, {})'.format(u.name, v.name) for (u, v) in self.arcs]) if len(self.arcs) > 0 else '  -'\n",
      "\t\tC = '\\n'.join(sorted([repr(v) for v in self.conditionals])) if len(self.conditionals) > 0 else '  -'\n",
      "\t\tD = '\\n'.join([repr(u) for u in self.data]) if len(self.data) > 0 else '  -'\n",
      "\t\tgraph = 'Vertices V:\\n{V}\\nArcs A:\\n  {A}\\n\\nConditions C:\\n{C}\\n\\nData D:\\n{D}\\n'.format(V=V, A=A, C=C, D=D)\n",
      "\t\tgraph = '#Vertices: {}, #Arcs: {}\\n'.format(len(self.vertices), len(self.arcs)) + graph\n",
      "\t\treturn graph\n",
      "\t\n",
      "\tdef gen_cond_bit_vector(self, state):\n",
      "\t\tresult = 0\n",
      "\t\tfor cond in self.conditionals:\n",
      "\t\t\tresult = cond.update_bit_vector(state, result)\n",
      "\t\treturn result\n",
      "\n",
      "\tdef gen_cond_vars(self):\n",
      "\t\treturn [c.name for c in self.conditionals]\n",
      "\n",
      "\tdef gen_cont_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_continuous and not v.is_conditional and v.is_sampled]\n",
      "\n",
      "\tdef gen_disc_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_discrete and v.is_sampled]\n",
      "\n",
      "\tdef gen_if_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_conditional and v.is_sampled and v.is_continuous]\n",
      "\n",
      "\tdef gen_log_prob(self, state):\n",
      "\t\ttry:\n",
      "\t\t\tlog_prob = 0\n",
      "\t\t\tdst_ = dist.Uniform(low=-6, high=6)\n",
      "\t\t\tlog_prob = log_prob + dst_.log_prob(state['x30001'])\n",
      "\t\t\tstate['cond_30002'] = ((max(state['x30001'], -state['x30001']) + -3) < 0)\n",
      "\t\t\tdst_ = dist.factor(log_p=-torch.sqrt(((state['x30001'] * 0.1) * state['x30001'])))\n",
      "\t\t\tif state['cond_30002']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30003'])\n",
      "\t\t\tdst_ = dist.factor(log_p=(-torch.sqrt(((state['x30001'] * 0.1) * state['x30001'])) + -1))\n",
      "\t\t\tif state['cond_30002']:\n",
      "\t\t\t\tlog_prob = log_prob + dst_.log_prob(state['y30004'])\n",
      "\t\t\treturn log_prob\n",
      "\t\texcept(ValueError, RuntimeError) as e:\n",
      "\t\t\tprint('****Warning: Target density is ill-defined****')\n",
      "\n",
      "\tdef gen_prior_samples(self):\n",
      "\t\tstate = {}\n",
      "\t\tdst_ = dist.Uniform(low=-6, high=6)\n",
      "\t\tstate['x30001'] = dst_.sample()\n",
      "\t\tstate['cond_30002'] = ((max(state['x30001'], -state['x30001']) + -3) < 0)\n",
      "\t\tdst_ = dist.factor(log_p=-torch.sqrt(((state['x30001'] * 0.1) * state['x30001'])))\n",
      "\t\tstate['y30003'] = None\n",
      "\t\tdst_ = dist.factor(log_p=(-torch.sqrt(((state['x30001'] * 0.1) * state['x30001'])) + -1))\n",
      "\t\tstate['y30004'] = None\n",
      "\t\treturn state\n",
      "\n",
      "\tdef get_arcs(self):\n",
      "\t\treturn self.arcs\n",
      "\n",
      "\tdef get_arcs_names(self):\n",
      "\t\treturn [(u.name, v.name) for (u, v) in self.arcs]\n",
      "\n",
      "\tdef get_conditions(self):\n",
      "\t\treturn self.conditionals\n",
      "\n",
      "\tdef get_vars(self):\n",
      "\t\treturn [v.name for v in self.vertices if v.is_sampled]\n",
      "\n",
      "\tdef get_vertices(self):\n",
      "\t\treturn self.vertices\n",
      "\n",
      "\tdef get_vertices_names(self):\n",
      "\t\treturn [v.name for v in self.vertices]\n",
      "\n",
      "\tdef is_torch_imported(self):\n",
      "\t\timport sys \n",
      "\t\tprint('torch' in sys.modules) \n",
      "\t\tprint(torch.__version__) \n",
      "\t\tprint(type(torch.tensor)) \n",
      "\t\timport inspect \n",
      "\t\tprint(inspect.getfile(torch))\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(compiled_python)\n",
    "print(compiled_python.code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'x30001': tensor(-5.3484), 'cond_30002': tensor(0, dtype=torch.uint8), 'y30003': None, 'y30004': None}\n",
      "tensor(-2.4849)\n"
     ]
    }
   ],
   "source": [
    "import torch.distributions as dist\n",
    "import torch\n",
    "\n",
    "# In practice the factor statement will be a class, pre-defined\n",
    "# within your choosen distribution library. This may require you \n",
    "# to add a simple class like the one provided below.\n",
    "class factor:\n",
    "    def __init__(self,log_p):\n",
    "        self.log_p = log_p\n",
    "    \n",
    "    def log_prob(self,value):\n",
    "    # all entries to the factor statement are just values\n",
    "    # as the factor statement itself is not a function and thus does not evaluate. \n",
    "    # It can only return the following. Value here is discarded as factor does not\n",
    "    # process values.\n",
    "        return torch.exp(self.log_p)\n",
    "\n",
    "# The following functions are contained within the model class output. \n",
    "# We could have easily written something like the following, if factor exists inside of\n",
    "# your distibution classes:\n",
    "\n",
    "# model = compile_python\n",
    "# print(model.gen_prior_samples())\n",
    "def gen_log_prob(state):\n",
    "    try:\n",
    "        log_prob = 0\n",
    "        dst_ = dist.Uniform(low=-6, high=6)\n",
    "        log_prob = log_prob + dst_.log_prob(state['x30001'])\n",
    "        state['cond_30002'] = ((max(state['x30001'], -state['x30001']) + -3) < 0)\n",
    "        dst_ = factor(log_p=-torch.sqrt(((state['x30001'] * 0.1) * state['x30001'])))\n",
    "        if state['cond_30002']:\n",
    "            log_prob = log_prob + dst_.log_prob(state['y30003'])\n",
    "        dst_ = factor(log_p=(-torch.sqrt(((state['x30001'] * 0.1) * state['x30001'])) + -1))\n",
    "        if state['cond_30002']:\n",
    "            log_prob = log_prob + dst_.log_prob(state['y30004'])\n",
    "        return log_prob\n",
    "    except(RuntimeError,ValueError) as e:\n",
    "        print('****Warning: Target density is ill-defined****')\n",
    "def gen_prior_samples():\n",
    "\t\tstate = {}\n",
    "\t\tdst_ = dist.Uniform(low=-6, high=6)\n",
    "\t\tstate['x30001'] = dst_.sample()\n",
    "\t\tstate['cond_30002'] = ((max(state['x30001'], -state['x30001']) + -3) < 0)\n",
    "\t\tdst_ = factor(log_p=-torch.sqrt(((state['x30001'] * 0.1) * state['x30001'])))\n",
    "\t\tstate['y30003'] = None\n",
    "\t\tdst_ = factor(log_p=(-torch.sqrt(((state['x30001'] * 0.1) * state['x30001'])) + -1))\n",
    "\t\tstate['y30004'] = None\n",
    "\t\treturn state\n",
    "\n",
    "# Generating the state from the compilation target. \n",
    "state  = gen_prior_samples()\n",
    "print(state)\n",
    "print(gen_log_prob(state))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is **important** to note that `factor` statements cannot be placed inside of `sample` statements. For example, consider the following model from above, slightly adapted:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/test/Projects/PyLFPPL/pyppl/backend/ppl_graph_generator.py:153: UserWarning: ********** Model is not valid **********\n",
      "  self.define(node.name, self.visit(node.value))\n",
      "/Users/test/Projects/PyLFPPL/pyppl/backend/ppl_graph_generator.py:153: UserWarning: ********** factor statements cannot be placed within sample statements  **********\n",
      "  self.define(node.name, self.visit(node.value))\n"
     ]
    },
    {
     "ename": "SystemExit",
     "evalue": "1",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\u001b[0;31m:\u001b[0m 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/test/miniconda3/envs/pylfppl/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3299: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "model_rrhmc_python= \"\"\"\n",
    "import torch\n",
    "x = sample(uniform(-6,6))\n",
    "x_not_allowed = sample(factor(6))\n",
    "absx = max(x, -x)\n",
    "A = 0.1\n",
    "z = -torch.sqrt(x*A*x)\n",
    "if absx-3 < 0:\n",
    "    observe(factor(z),None)\n",
    "    observe(factor(z-1),None)\n",
    "\"\"\"\n",
    "compiled_python = compile_model(model_rrhmc_python, language='python')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To understand why this is so, see Chapter 4 of Tom Rainforth's thesis: [here](https://www.researchgate.net/profile/Tom_Rainforth/publication/324923515_Automating_Inference_Learning_and_Design_using_Probabilistic_Programming/links/5aeb84ce0f7e9b01d3e05b8d/Automating-Inference-Learning-and-Design-using-Probabilistic-Programming.pdf)  or the following paper by Sam Stanton, Hongseok Yang et al. for even greater technical details: [here](https://arxiv.org/pdf/1601.04943.pdf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vertices = compiled_python.vertices\n",
    "create_network_graph(vertices=vertices)\n",
    "display_graph(vertices=vertices);\n",
    "\n",
    "# a list of all latent vars\n",
    "all_sampled_vars = compiled_python.get_vars()\n",
    "\n",
    "_number_of_latents = len(all_sampled_vars)\n",
    "print('There are {} latent variables'.format(_number_of_latents))\n",
    "\n",
    "print(all_sampled_vars)\n",
    "_names = dict(\n",
    "    [(vertex.name, vertex.original_name) for vertex in vertices if vertex.name in all_sampled_vars])# distribution arguments and names\n",
    "\n",
    "\n",
    "for key in _names:\n",
    "    print('Unique name in compiler: {0} User defined name:  {1}'.format(key, _names[key]))\n",
    "    \n",
    "    \n",
    "observables = dict([(vertex.name, vertex.observation) for vertex in vertices if vertex.is_observed])\n",
    "for key in observables:\n",
    "    print('Printing the observable name: {0} and value: {1}'.format(key, observables[key]))\n",
    "\n",
    "_cond_bools = None if len(compiled_python.gen_if_vars()) == 0 else compiled_python.gen_cond_vars()\n",
    "print(compiled_python.get_conditions())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A very simple example of how factor could be written in your probabilistic programming system is provided below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factor(log_p=None):\n",
    "    import math\n",
    "    return math.exp(log_p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Density 0 Model\n",
    "\n",
    "In this model the ```Model.gen_logprob()``` will have to evaluate `log(0) =` $\\infty$, which implies the `log_prob = ` $\\infty$. \n",
    "This would enable the user to discard, or record, if necessary, such samples.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_densityzero_python= \"\"\"\n",
    "import torch\n",
    "x = sample(normal(2,0))\n",
    "y = 1\n",
    "if x < -0.5:\n",
    "    observe(normal(-2,1),y)\n",
    "elif x < 0.5:\n",
    "    observe(factor(0),y)\n",
    "else:\n",
    "    observe(normal(2,1),y)\n",
    "\"\"\"\n",
    "compile_python = compile_model(model_densityzero_python, language=\"python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(compile_python.code)\n",
    "vertices = compile_python.vertices\n",
    "create_network_graph(vertices=vertices)\n",
    "display_graph(vertices=vertices);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}