diff --git a/docs/source/conf.py b/docs/source/conf.py index 9eb9f3e51a..e3f1fec77a 100755 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -147,7 +147,6 @@ ("Examples", "nb_examples/index"), ("Books + Videos", "learn"), ("API", "api"), - ("Developer Guide", "developer_guide"), ("About PyMC3", "history") ], # "fixed_sidebar": "false", diff --git a/docs/source/developer_guide.rst b/docs/source/developer_guide.rst deleted file mode 100644 index 74d63805e8..0000000000 --- a/docs/source/developer_guide.rst +++ /dev/null @@ -1,1107 +0,0 @@ -===================== -PyMC3 Developer Guide -===================== - -`PyMC3 `__ is a Python package for Bayesian -statistical modeling built on top of -`Theano `__. This -document aims to explain the design and implementation of probabilistic -programming in PyMC3, with comparisons to other PPL like TensorFlow Probability (TFP) -and Pyro in mind. A user-facing API -introduction can be found in the `API -quickstart `__. A more accessible, user facing deep introduction can be found in -`Peadar Coyle's probabilistic programming primer `__ - -Distribution ------------- - -A high-level introduction of ``Distribution`` in PyMC3 can be found in -the `documentation `__. The source -code of the probability distributions is nested under -`pymc3/distributions `__, -with the ``Distribution`` class defined in `distribution.py -`__. -A few important points to highlight in the Distribution Class: - -.. code:: python - - class Distribution(object): - """Statistical distribution""" - def __new__(cls, name, *args, **kwargs): - ... - try: - model = Model.get_context() - except TypeError: - raise TypeError(... - - if isinstance(name, string_types): - ... - dist = cls.dist(*args, **kwargs) - return model.Var(name, dist, ...) - ... - -In a way, the snippet above represents the unique features of pymc3's -``Distribution`` class: - -- Distribution objects are only usable inside of a ``Model`` context. If they are created outside of the model context manager, it raises an error. - -- A ``Distribution`` requires at least a name argument, and other parameters that defines the Distribution. - -- When a ``Distribution`` is initialized inside of a Model context, two things happen: - - 1. a stateless distribution is initialized ``dist = {DISTRIBUTION_cls}.dist(*args, **kwargs)``; - 2. a random variable following the said distribution is added to the model ``model.Var(name, dist, ...)`` - -Thus, users who are building models using ``with pm.Model() ...`` should -be aware that they are never directly exposed to static and stateless -distributions, but rather random variables that follow some density -functions. Instead, to access a stateless distribution, you need to call -``pm.SomeDistribution.dist(...)`` or ``RV.dist`` *after* you initialized -``RV`` in a model context (see -https://docs.pymc.io/prob\_dists.html#using-pymc-distributions-without-a-model). - -With this distinction in mind, we can take a closer look at the -stateless distribution part of pymc3 (see distriution api in `doc -`__), which divided into: - -- Continuous - -- Discrete - -- Multivariate - -- Mixture - -- Timeseries - -Quote from the doc: - - All distributions in ``pm.distributions`` will have two important - methods: ``random()`` and ``logp()`` with the following signatures: - -.. code:: python - - class SomeDistribution(Continuous): - def __init__(...): - ... - - def random(self, point=None, size=None): - ... - return random_samples - - def logp(self, value): - ... - return total_log_prob - -PyMC3 expects the ``logp()`` method to return a log-probability -evaluated at the passed value argument. This method is used internally -by all of the inference methods to calculate the model log-probability, -which is then used for fitting models. The ``random()`` method is -used to simulate values from the variable, and is used internally for -posterior predictive checks. - -In the PyMC3 ``Distribution`` class, the ``logp()`` method is the most -elementary. As long as you have a well-behaved density function, we can -use it in the model to build the model log-likelihood function. Random -number generation is great to have, but sometimes there might not be -efficient random number generator for some densities. Since a function -is all you need, you can wrap almost any thenao function into a -distribution using ``pm.DensityDist`` -https://docs.pymc.io/prob\_dists.html#custom-distributions - -Thus, distributions that are defined in the ``distributions`` submodule -(e.g. look at ``pm.Normal`` in ``pymc3.distributions.continuous``), each -describes a *family* of probabilistic distribution (no different from -distribution in other PPL library). Once it is initialised within a -model context, it contains properties that are related to the random -variable (*e.g.* mean/expectation). Note that if the parameters are -constants, these properties could be the same as the distribution -properties. - -Reflection -~~~~~~~~~~ - -How tensor/value semantics for probability distributions is enabled in pymc3: - -In PyMC3, we treat ``x = Normal('x', 0, 1)`` as defining a random -variable (intercepted and collected under a model context, more on that -below), and x.dist() as the associated density/mass function -(distribution in the mathematical sense). It is not perfect, and now -after a few years learning Bayesian statistics I also realized these -subtleties (i.e., the distinction between *random variable* and -*distribution*). But when I was learning probabilistic modelling as a -beginner, I did find this approach to be the easiest and most -straightforward. In a perfect world, we should have -:math:`x \sim \text{Normal}(0, 1)` which defines a random variable that -follows a Gaussian distribution, and -:math:`\chi = \text{Normal}(0, 1), x \sim \chi` which define a scalar -density function that takes input :math:`x` - (``X:=f(x) = 1/sqrt(2*pi) * exp(-.5*x**2)``) - -Within a model context, RVs are essentially Theano tensors (more on that -below). This is different than TFP and pyro, where you need to be more -explicit about the conversion. For example: - -**PyMC3** - -.. code:: python - - with pm.Model() as model: - z = pm.Normal('z', mu=0., sd=5.) # ==> pymc3.model.FreeRV, or theano.tensor with logp - x = pm.Normal('x', mu=z, sd=1., observed=5.) # ==> pymc3.model.ObservedRV, also has logp properties - x.logp({'z': 2.5}) # ==> -4.0439386 - model.logp({'z': 2.5}) # ==> -6.6973152 - -**TFP** - -.. code:: python - - z_dist = tfd.Normal(loc=0., scale=5.) # ==> - z = z_dist.sample() # ==> - x = tfd.Normal(loc=z, scale=1.).log_prob(5.) # ==> - model_logp = z_dist.log_prob(z) + x - sess = tf.Session() - sess.run(x, feed_dict={z: 2.5}) # ==> -4.0439386 - sess.run(model_logp, feed_dict={z: 2.5}) # ==> -6.6973152 - -**pyro** - -.. code:: python - - z_dist = dist.Normal(loc=0., scale=5.) # ==> - z = pyro.sample("z", z_dist) # ==> - # reset/specify value of z - z.data = torch.tensor(2.5) - x = dist.Normal(loc=z, scale=1.).log_prob(5.) # ==> - model_logp = z_dist.log_prob(z) + x - x # ==> -4.0439386 - model_logp # ==> -6.6973152 - - -Random method and logp method, very different behind the curtain -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -In short, the random method is scipy/numpy-based, and the logp method is -Theano-based. The ``logp`` method is straightforward - it is a Theano -function within each distribution. It has the following signature: - -.. code:: python - - def logp(self, value): - # GET PARAMETERS - param1, param2, ... = self.params1, self.params2, ... - # EVALUATE LOG-LIKELIHOOD FUNCTION, all inputs are (or array that could be convert to) theano tensor - total_log_prob = f(param1, param2, ..., value) - return total_log_prob - -In the ``logp`` method, parameters and values are either Theano tensors, -or could be converted to tensors. It is rather convenient as the -evaluation of logp is represented as a tensor (``RV.logpt``), and when -we linked different ``logp`` together (e.g., summing all ``RVs.logpt`` -to get the model totall logp) the dependence is taken care of by Theano -when the graph is built and compiled. Again, since the compiled function -depends on the nodes that already in the graph, whenever you want to generate -a new function that takes new input tensors you either need to regenerate the graph -with the appropriate dependencies, or replace the node by editing the existing graph. -In PyMC3 we use the second approach by using ``theano.clone()`` when it is needed. - -As explained above, distribution in a ``pm.Model()`` context -automatically turn into a tensor with distribution property (pymc3 -random variable). To get the logp of a free\_RV is just evaluating the -``logp()`` `on -itself `__: - -.. code:: python - - # self is a theano.tensor with a distribution attached - self.logp_sum_unscaledt = distribution.logp_sum(self) - self.logp_nojac_unscaledt = distribution.logp_nojac(self) - -Or for a ObservedRV. it evaluate the logp on the data: - -.. code:: python - - self.logp_sum_unscaledt = distribution.logp_sum(data) - self.logp_nojac_unscaledt = distribution.logp_nojac(data) - -However, for the random method things are a bit less graceful. As the -random generator is limited in Theano, all random generation is done in -scipy/numpy land. In the random method, we have: - -.. code:: python - - def random(self, point=None, size=None): - # GET PARAMETERS - param1, param2, ... = draw_values([self.param1, self.param2, ...], - point=point, - size=size) - # GENERATE SAMPLE - samples = generate_samples(SCIPY_OR_NUMPY_RANDOM_FUNCTION, - param1, param2, ... # ==> parameters, type is numpy arrays - dist_shape=self.shape, - size=size) - return samples - -Here, ``point`` is a dictionary that contains dependence of -``param1, param2, ...``, and ``draw_values`` generates a (random) -``(size, ) + param.shape`` arrays *conditioned* on the information from -``point``. This is the backbone for forwarding random simulation. The -``draw_values`` function is a recursive algorithm to try to resolve all -the dependence outside of Theano, by walking the Theano computational -graph, it is complicated and a constant pain point for bug fixing: -https://github.com/pymc-devs/pymc3/blob/master/pymc3/distributions/distribution.py#L217-L529 -(But also see a `recent -PR `__ that use -interception and context manager to resolve the dependence issue) - -Model context and Random Variable ---------------------------------- - -I like to think that the ``with pm.Model() ...`` is a key syntax feature -and *the* signature of PyMC3 model language, and in general a great -out-of-the-box thinking/usage of the context manager in Python (with -`some -critics `__, of -course). - -Essentially `what a context manager -does `__ is: - -.. code:: python - - with EXPR as VAR: - USERCODE - -which roughly translates into this: - -.. code:: python - - VAR = EXPR - VAR.__enter__() - try: - USERCODE - finally: - VAR.__exit__() - -or conceptually: - -.. code:: python - - with EXPR as VAR: - # DO SOMETHING - USERCODE - # DO SOME ADDITIONAL THINGS - -So what happened within the ``with pm.Model() as model: ...`` block, -besides the initial set up ``model = pm.Model()``? Starting from the -most elementary: - -Random Variable -~~~~~~~~~~~~~~~ - -From the above session, we know that when we call eg -``pm.Normal('x', ...)`` within a Model context, it returns a random -variable. Thus, we have two equivalent ways of adding random variable to -a model: - - -.. code:: python - - with pm.Model() as m: - x = pm.Normal('x', mu=0., sd=1.) - - -Which is the same as doing: - - -.. code:: python - - m = pm.Model() - x = m.Var('x', pm.Normal.dist(mu=0., sd=1.)) - - -Both with the same output: - - -.. parsed-literal:: - - print(type(x)) # ==> - print(m.free_RVs) # ==> [x] - print(x.distribution.logp(5.)) # ==> Elemwise{switch,no_inplace}.0 - print(x.distribution.logp(5.).eval({})) # ==> -13.418938533204672 - print(m.logp({'x': 5.})) # ==> -13.418938533204672 - - - -Looking closer to the classmethod ``model.Var``, it is clear that what -PyMC3 does is an **interception** of the Random Variable, depending on -the ``*args``: -https://github.com/pymc-devs/pymc3/blob/6d07591962a6c135640a3c31903eba66b34e71d8/pymc3/model.py#L786-L847 - -.. code:: python - - def Var(self, name, dist, data=None, total_size=None): - """ - ... - """ - ... - if data is None: - if getattr(dist, "transform", None) is None: - with self: - var = FreeRV(...) # ==> FreeRV - self.free_RVs.append(var) - else: - with self: - var = TransformedRV(...) # ==> TransformedRV - ... - self.deterministics.append(var) - self.add_random_variable(var) - return var - elif isinstance(data, dict): - with self: - var = MultiObservedRV(...) # ==> MultiObservedRV - self.observed_RVs.append(var) - if var.missing_values: - ... # ==> Additional FreeRV if there is missing values - else: - with self: - var = ObservedRV(...) # ==> ObservedRV - self.observed_RVs.append(var) - if var.missing_values: - ... # ==> Additional FreeRV if there is missing values - - self.add_random_variable(var) - return var - -In general, if there is observed, the RV is defined as a ``ObservedRV``, -otherwise if it has a transformed method, it is a ``TransformedRV``, otherwise, it returns the -most elementary form: a ``FreeRV``. - -Below, I will take a deeper look into ``TransformedRV``, a normal user -might not necessary come in contact with the concept, as -``TransformedRV`` and ``TransformedDistribution`` are intentionally not -user facing. - -Because in PyMC3 there is no bijector class like in TFP or pyro, we only -have a partial implementation called ``Transform``, which implements -Jacobian correction for forward mapping only (there is no Jacobian -correction for inverse mapping). The use case we considered are limited -to the set of distributions that are bounded, and the transformation -maps the bounded set to the real line - see -`doc `__. -In general, PyMC3 does not provide explicit functionality to transform -one distribution to another. Instead, a dedicated distribution is -usually created in consideration of optimising performance. But getting a -``TransformedDistribution`` is also possible (see also in -`doc `__): - -.. code:: python - - tr = pm.distributions.transforms - class Exp(tr.ElemwiseTransform): - name = "exp" - def backward(self, x): - return tt.log(x) - def forward(self, x): - return tt.exp(x) - def jacobian_det(self, x): - return -tt.log(x) - - lognorm = Exp().apply(pm.Normal.dist(0., 1.)) - lognorm - - -.. parsed-literal:: - - - - - -Now, back to ``model.RV(...)`` - things return from ``model.RV(...)`` -are Theano tensor variables, and it is clear from looking at -``TransformedRV``: - -.. code:: python - - class TransformedRV(TensorVariable): - ... - -as for ``FreeRV`` and ``ObservedRV``, they are TensorVariable with -Factor: - -.. code:: python - - class FreeRV(Factor, TensorVariable): - ... - -and ``Factor`` basically `enable and assign the -logp `__ -(representated as a tensor also) property to a Theano tensor (thus -making it a random variable). For a ``TransformedRV``, it transform the -distribution into a ``TransformedDistribution``, and then model.Var is -called again to added the RV associated with the -``TransformedDistribution`` as a ``FreeRV``: - -.. code:: python - - ... - self.transformed = model.Var( - transformed_name, transform.apply(distribution), total_size=total_size) - -note: after ``transform.apply(distribution)`` its ``.transform`` -porperty is set to ``None``, thus making sure that the above call will -only add one ``FreeRV``. In another word, you *cannot* do chain -transformation by nested applying multiple transforms to a Distribution -(however, you can use `Chain -transformation `__). - -.. code:: python - - z = pm.Lognormal.dist(mu=0., sd=1., transform=tr.Log) - z.transform # ==> pymc3.distributions.transforms.Log - - -.. code:: python - - z2 = Exp().apply(z) - z2.transform is None # ==> True - - - -Additional things that ``pm.Model`` does -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -In a way, ``pm.Model`` is a tape machine that records what is being -added to the model, it keeps track the random variables (observed or -unobserved) and potential term (additional tensor that to be added to -the model logp), and also deterministic transformation (as bookkeeping): -named\_vars, free\_RVs, observed\_RVs, deterministics, potentials, -missing\_values. The model context then computes some simple model -properties, builds a bijection mapping that transforms between -dictionary and numpy/Theano ndarray, thus allowing logp/dlogp function -to have two equivalent version: one take a dict as input and the other -take a ndarray as input. More importantly, a pm.Model() contains methods -to compile Theano function that takes Random Variables (that are also -initialised within the same model) as input. - -.. code:: python - - with pm.Model() as m: - z = pm.Normal('z', 0., 10., shape=10) - x = pm.Normal('x', z, 1., shape=10) - - print(m.test_point) - print(m.dict_to_array(m.test_point)) # ==> m.bijection.map(m.test_point) - print(m.bijection.rmap(np.arange(20))) - - -.. parsed-literal:: - - {'z': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]), 'x': array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])} - [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.] - {'z': array([10., 11., 12., 13., 14., 15., 16., 17., 18., 19.]), 'x': array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])} - - -.. code:: python - - list(filter(lambda x: "logp" in x, dir(pm.Model))) - - -.. parsed-literal:: - - ['d2logp', - 'd2logp_nojac', - 'datalogpt', - 'dlogp', - 'dlogp_array', - 'dlogp_nojac', - 'fastd2logp', - 'fastd2logp_nojac', - 'fastdlogp', - 'fastdlogp_nojac', - 'fastlogp', - 'fastlogp_nojac', - 'logp', - 'logp_array', - 'logp_dlogp_function', - 'logp_elemwise', - 'logp_nojac', - 'logp_nojact', - 'logpt', - 'varlogpt'] - - - -Logp and dlogp --------------- - -The model collects all the random variables (everything in -``model.free_RVs`` and ``model.observed_RVs``) and potential term, and -sum them together to get the model logp: - -.. code:: python - - @property - def logpt(self): - """Theano scalar of log-probability of the model""" - with self: - factors = [var.logpt for var in self.basic_RVs] + self.potentials - logp = tt.sum([tt.sum(factor) for factor in factors]) - ... - return logp - -which returns a Theano tensor that its value depends on the free -parameters in the model (i.e., its parent nodes from the Theano -graph).You can evaluate or compile into a python callable (that you can -pass numpy as input args). Note that the logp tensor depends on its -input in the Theano graph, thus you cannot pass new tensor to generate a -logp function. For similar reason, in PyMC3 we do graph copying a lot -using theano.clone to replace the inputs to a tensor. - -.. code:: python - - with pm.Model() as m: - z = pm.Normal('z', 0., 10., shape=10) - x = pm.Normal('x', z, 1., shape=10) - y = pm.Normal('y', x.sum(), 1., observed=2.5) - - print(m.basic_RVs) # ==> [z, x, y] - print(m.free_RVs) # ==> [z, x] - - -.. code:: python - - type(m.logpt) # ==> theano.tensor.var.TensorVariable - - -.. code:: python - - m.logpt.eval({x: np.random.randn(*x.tag.test_value.shape) for x in m.free_RVs}) - -output: - -.. parsed-literal:: - - array(-51.25369126) - - - -PyMC3 then compiles a logp function with gradient that takes -``model.free_RVs`` as input and ``model.logpt`` as output. It could be a -subset of tensors in ``model.free_RVs`` if we want a conditional -logp/dlogp function: - -.. code:: python - - def logp_dlogp_function(self, grad_vars=None, **kwargs): - if grad_vars is None: - grad_vars = list(typefilter(self.free_RVs, continuous_types)) - else: - ... - varnames = [var.name for var in grad_vars] # In a simple case with only continous RVs, - # this is all the free_RVs - extra_vars = [var for var in self.free_RVs if var.name not in varnames] - return ValueGradFunction(self.logpt, grad_vars, extra_vars, **kwargs) - -``ValueGradFunction`` is a callable class which isolates part of the -Theano graph to compile additional Theano functions. PyMC3 relies on -``theano.clone`` to copy the ``model.logpt`` and replace its input. It -does not edit or rewrite the graph directly. - -.. code:: python - - class ValueGradFunction(object): - """Create a theano function that computes a value and its gradient. - ... - """ - def __init__(self, logpt, grad_vars, extra_vars=[], dtype=None, - casting='no', **kwargs): - ... - - self._grad_vars = grad_vars - self._extra_vars = extra_vars - self._extra_var_names = set(var.name for var in extra_vars) - self._logpt = logpt - self._ordering = ArrayOrdering(grad_vars) - self.size = self._ordering.size - self._extra_are_set = False - - ... - - # Extra vars are a subset of free_RVs that are not input to the compiled function. - # But nonetheless logpt depends on these RVs. - # This is set up as a dict of theano.shared tensors, but givens (a list of - # tuple(free_RVs, theano.shared)) is the actual list that goes into the theano function - givens = [] - self._extra_vars_shared = {} - for var in extra_vars: - shared = theano.shared(var.tag.test_value, var.name + '_shared__') - self._extra_vars_shared[var.name] = shared - givens.append((var, shared)) - - # See the implementation below. Basically, it clones the logpt and replaces its - # input with a *single* 1d theano tensor - self._vars_joined, self._logpt_joined = self._build_joined( - self._logpt, grad_vars, self._ordering.vmap) - - grad = tt.grad(self._logpt_joined, self._vars_joined) - grad.name = '__grad' - - inputs = [self._vars_joined] - - self._theano_function = theano.function( - inputs, [self._logpt_joined, grad], givens=givens, **kwargs) - - - def _build_joined(self, logpt, args, vmap): - args_joined = tt.vector('__args_joined') - args_joined.tag.test_value = np.zeros(self.size, dtype=self.dtype) - - joined_slices = {} - for vmap in vmap: - sliced = args_joined[vmap.slc].reshape(vmap.shp) - sliced.name = vmap.var - joined_slices[vmap.var] = sliced - - replace = {var: joined_slices[var.name] for var in args} - return args_joined, theano.clone(logpt, replace=replace) - - - def __call__(self, array, grad_out=None, extra_vars=None): - ... - logp, dlogp = self._theano_function(array) - return - - - def set_extra_values(self, extra_vars): - ... - - def get_extra_values(self): - ... - - @property - def profile(self): - ... - - def dict_to_array(self, point): - ... - - def array_to_dict(self, array): - ... - - def array_to_full_dict(self, array): - """Convert an array to a dictionary with grad_vars and extra_vars.""" - ... - - ... - -The important parts of the above function is highlighted and commented. -On a high level, it allows us to build conditional logp function and its -gradient easily. Here is a taste of how it works in action: - -.. code:: python - - inputlist = [np.random.randn(*x.tag.test_value.shape) for x in m.free_RVs] - - func = m.logp_dlogp_function() - func.set_extra_values({}) - input_dict = {x.name: y for x, y in zip(m.free_RVs, inputlist)} - print(input_dict) - input_array = func.dict_to_array(input_dict) - print(input_array) - print(" ===== ") - func(input_array) - - -.. parsed-literal:: - - {'z': array([-0.7202002 , 0.58712205, -1.44120196, -0.53153001, -0.36028732, - -1.49098414, -0.80046792, -0.26351819, 1.91841949, 1.60004128]), 'x': array([ 0.01490006, 0.60958275, -0.06955203, -0.42430833, -1.43392303, - 1.13713493, 0.31650495, -0.62582879, 0.75642811, 0.50114527])} - [-0.7202002 0.58712205 -1.44120196 -0.53153001 -0.36028732 -1.49098414 - -0.80046792 -0.26351819 1.91841949 1.60004128 0.01490006 0.60958275 - -0.06955203 -0.42430833 -1.43392303 1.13713493 0.31650495 -0.62582879 - 0.75642811 0.50114527] - ===== - (array(-51.0769075), - array([ 0.74230226, 0.01658948, 1.38606194, 0.11253699, -1.07003284, - 2.64302891, 1.12497754, -0.35967542, -1.18117557, -1.11489642, - 0.98281586, 1.69545542, 0.34626619, 1.61069443, 2.79155183, - -0.91020295, 0.60094326, 2.08022672, 2.8799075 , 2.81681213])) - - - -.. code:: python - - irv = 1 - print("Condition Logp: take %s as input and conditioned on the rest."%(m.free_RVs[irv].name)) - func_conditional = m.logp_dlogp_function(grad_vars=[m.free_RVs[irv]]) - func_conditional.set_extra_values(input_dict) - input_array2 = func_conditional.dict_to_array(input_dict) - print(input_array2) - print(" ===== ") - func_conditional(input_array2) - - -.. parsed-literal:: - - Condition Logp: take x as input and conditioned on the rest. - [ 0.01490006 0.60958275 -0.06955203 -0.42430833 -1.43392303 1.13713493 - 0.31650495 -0.62582879 0.75642811 0.50114527] - ===== - (array(-51.0769075), - array([ 0.98281586, 1.69545542, 0.34626619, 1.61069443, 2.79155183, - -0.91020295, 0.60094326, 2.08022672, 2.8799075 , 2.81681213])) - - - -So why is this necessary? One can imagine that we just compile one logp -function, and do bookkeeping ourselves. For example, we can build the -logp function in Theano directly: - -.. code:: python - - import theano - func = theano.function(m.free_RVs, m.logpt) - func(*inputlist) - - -.. parsed-literal:: - - array(-51.0769075) - - - -.. code:: python - - logpt_grad = theano.grad(m.logpt, m.free_RVs) - func_d = theano.function(m.free_RVs, logpt_grad) - func_d(*inputlist) - - -.. parsed-literal:: - - [array([ 0.74230226, 0.01658948, 1.38606194, 0.11253699, -1.07003284, - 2.64302891, 1.12497754, -0.35967542, -1.18117557, -1.11489642]), - array([ 0.98281586, 1.69545542, 0.34626619, 1.61069443, 2.79155183, - -0.91020295, 0.60094326, 2.08022672, 2.8799075 , 2.81681213])] - - - -Similarly, build a conditional logp: - -.. code:: python - - shared = theano.shared(inputlist[1]) - func2 = theano.function([m.free_RVs[0]], m.logpt, givens=[(m.free_RVs[1], shared)]) - print(func2(inputlist[0])) - - logpt_grad2 = theano.grad(m.logpt, m.free_RVs[0]) - func_d2 = theano.function([m.free_RVs[0]], logpt_grad2, givens=[(m.free_RVs[1], shared)]) - print(func_d2(inputlist[0])) - - -.. parsed-literal:: - - -51.07690750130328 - [ 0.74230226 0.01658948 1.38606194 0.11253699 -1.07003284 2.64302891 - 1.12497754 -0.35967542 -1.18117557 -1.11489642] - - -The above also gives the same logp and gradient as the output from -``model.logp_dlogp_function``. But the difficulty is to compile -everything into a single function: - -.. code:: python - - func_logp_and_grad = theano.function(m.free_RVs, [m.logpt, logpt_grad]) # ==> ERROR - - -We want to have a function that return the evaluation and its gradient -re each input: ``value, grad = f(x)``, but the naive implementation does -not work. We can of course wrap 2 functions - one for logp one for dlogp -- and output a list. But that would mean we need to call 2 functions. In -addition, when we write code using python logic to do bookkeeping when -we build our conditional logp. Using ``theano.clone``, we always have -the input to the Theano function being a 1d vector (instead of a list of -RV that each can have very different shape), thus it is very easy to do -matrix operation like rotation etc. - -Reflection -~~~~~~~~~~ - -| The current setup is quite powerful, as the Theano compiled function - is fairly fast to compile and to call. Also, when we are repeatedly - calling a conditional logp function, external RV only need to reset - once. However, there are still significant overheads when we are - passing values between Theano graph and numpy. That is the reason we - often see no advantage in using GPU, because the data is copying - between GPU and CPU at each function call - and for a small model, the - result is a slower inference under GPU than CPU. -| Also, ``theano.clone`` is too convenient (pymc internal joke is that - it is like a drug - very addictive). If all the operation happens in - the graph (including the conditioning and setting value), I see no - need to isolate part of the graph (via graph copying or graph - rewriting) for building model and running inference. -| Moreover, if we are limiting to the problem that we can solved most - confidently - model with all continous unknown parameters that could - be sampled with dynamic HMC, there is even less need to think about - graph cloning/rewriting. - -Inference ---------- - -MCMC -~~~~ - -The ability for model instance to generate conditional logp and dlogp -function enable one of the unique feature of PyMC3 - `CompoundStep -method `__. -It is conceptual level it is a Metropolis-within-Gibbs sampler. User can -`specify different sampler of different -RVs `__. -Alternatively, it is implemented as yet another interceptor: the -``pm.sample(...)`` call will try to `assign the best step methods to -different -free\_RVs `__ -(e.g., NUTS if all free\_RVs are continous). Then, (conditional) logp -function(s) are compiled, and the sampler called each sampler within the -list of CompoundStep in a for-loop for one sample circle. - -For each sampler, it implements a ``step.step`` method to perform MH -updates. Each time a dictionary (``point`` in ``PyMC3`` land, same -structure as ``model.test_point``) is passed as input and output a new -dictionary with the free\_RVs being sampled now has a new value (if -accepted, see -`here `__ -and -`here `__). -There are some example in the `CompoundStep -doc `__. - -Transition kernel -^^^^^^^^^^^^^^^^^ - -The base class for most MCMC sampler (except SMC) is in -`ArrayStep `__. -You can see that the ``step.step()`` is mapping the ``point`` into an -array, and call ``self.astep()``, which is an array in, array out -function. A pymc3 model compile a conditional logp/dlogp function that -replace the input RVs with a shared 1D tensor (flatten and stack view of -the original RVs). And the transition kernel (i.e., ``.astep()``) takes -array as input and output an array. See for example in the `MH -sampler `__. - -This is of course very different compare to the transition kernel in eg -TFP, which is a tenor in tensor out function. Moreover, transition -kernels in TFP do not flatten the tensors, see eg docstring of -`tensorflow\_probability/python/mcmc/random\_walk\_metropolis.py `__: - -.. code:: python - - new_state_fn: Python callable which takes a list of state parts and a - seed; returns a same-type `list` of `Tensor`s, each being a perturbation - of the input state parts. The perturbation distribution is assumed to be - a symmetric distribution centered at the input state part. - Default value: `None` which is mapped to - `tfp.mcmc.random_walk_normal_fn()`. - - -Dynamic HMC -^^^^^^^^^^^ - -We love NUTS, or to be more precise Dynamic HMC with complex stoping -rules. This part is actually all done outside of Theano, for NUTS, it -includes: the leapfrog, dual averaging, tunning of mass matrix and step -size, the tree building, sampler related statistics like divergence and -energy checking. We actually have a Theano version of HMC: -https://github.com/pymc-devs/pymc3/blob/master/pymc3/step\_methods/hmc/trajectory.py -but it is never been used. - -Variational Inference (VI) -~~~~~~~~~~~~~~~~~~~~~~~~~~ - -The design of the VI module takes a different approach than -MCMC - it has a functional design, and everything is done within Theano -(i.e., Optimization and building the variational objective). The base -class of variational inference is -`pymc3.variational.Inference `__, -where it builds the objective function by calling: - -.. code:: python - - ... - self.objective = op(approx, **kwargs)(tf) - ... - -Where: - -.. code:: python - - op : Operator class - approx : Approximation class or instance - tf : TestFunction instance - kwargs : kwargs passed to :class:`Operator` - -The design is inspired by the great work `Operator Variational -Inference `__. ``Inference`` object is -a very high level of VI implementation. It uses primitives: Operator, -Approximation, and Test functions to combine them into single objective -function. Currently we do not care too much about the test function, it -is usually not required (and not implemented). The other primitives are -defined as base classes in `this -file `__. -We use inheritance to easily implement a broad class of VI methods -leaving a lot of flexibility for further extensions. - -For example, consider ADVI. We know that in the high-level, we are -approximating the posterior in the latent space with a diagonal -Multivariate Gaussian. In another word, we are approximating each elements in -``model.free_RVs`` with a Gaussian. Below is what happen in the set up: - -.. code:: python - - def __init__(self, *args, **kwargs): - super(ADVI, self).__init__(MeanField(*args, **kwargs)) - # ==> In the super class KLqp - super(KLqp, self).__init__(KL, MeanField(*args, **kwargs), None, beta=beta) - # ==> In the super class Inferece - ... - self.objective = KL(MeanField(*args, **kwargs))(None) - ... - -where ``KL`` is Operator based on Kullback Leibler Divergence (it does -not need any test function). - -.. code:: python - - ... - def apply(self, f): - return -self.datalogp_norm + self.beta * (self.logq_norm - self.varlogp_norm) - -Since the logp and logq are from the approximation, let's dive in -further on it (there is another abstraction here - ``Group`` - that -allows you to combine approximation into new approximation, but we will -skip this for now and only consider ``SingleGroupApproximation`` like -``MeanField``): The definition of ``datalogp_norm``, ``logq_norm``, -``varlogp_norm`` are in -`variational/opvi `__, -strip away the normalizing term, ``datalogp`` and ``varlogp`` are -expectation of the variational free\_RVs and data logp - we clone the -datalogp and varlogp from the model, replace its input with Theano -tensor that `samples from the variational -posterior `__. -For ADVI, these samples are from `a -Gaussian `__. -Note that the samples from the posterior approximations are usually 1 -dimension more, so that we can compute the expectation and get the -gradient of the expectation (by computing the `expectation of the -gradient! `__). -As for the ``logq`` since it is a Gaussian `it is pretty -straightforward to evaluate `__. - -Some challenges and insights from implementing VI. -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -- Graph based approach was helpful, but Theano had no direct access to - previously created nodes in the computational graph. you can find a - lot of ``@node_property`` usages in implementation. This is done to - cache nodes. TensorFlow has graph utils for that that could - potentially help in doing this. On the other hand graph management in - Tensorflow seemed to more tricky than expected. The high level reason - is that graph is an add only container - -- There were few fixed bugs not obvoius in the first place. Theano has - a tool to manipulate the graph (``theano.clone``) and this tool - requires extremely careful treatment when doing a lot of graph - replacements at different level. - -- We coined a term ``theano.clone`` curse. We got extremely dependent - on this feature. Internal usages are uncountable: - - - we use this to `vectorize the - model `__ - for both MCMC and VI to speed up computations - - we use this to `create sampling - graph `__ - for VI. This is the case you want posterior predictive as a part - of computational graph. - -As this is the core of the VI process, we were trying to replicate this pattern -in TF. However, when ``theano.clone`` is called, Theano creates a new part of the graph that can -be collected by garbage collector, but TF's graph is add only. So we -should solve the problem of replacing input in a different way. - -Forward sampling ----------------- - -As explained above, in distribution we have method to walk the model -dependence graph and generate forward random sample in scipy/numpy. This -allows us to do prior predictive samples using -``pymc3.sampling.sample_prior_predictive`` see `code `__. -It is a fairly fast batch operation, but we have quite a lot of bugs and -edge case especially in high dimensions. The biggest pain point is the -automatic broadcasting. As in the batch random generation, we want to -generate (n\_sample, ) + RV.shape random samples. In some cases, where -we broadcast RV1 and RV2 to create a RV3 that has one more batch shape, -we get error (even worse, wrong answer with silent error): - -.. code:: python - - with pm.Model() as m: - mu = pm.Normal('mu', 0., 1., shape=(5, 1)) - sd = pm.HalfNormal('sd', 5., shape=(1, 10)) - pm.Normal('x', mu=mu, sd=sd, observed=np.random.randn(2, 5, 10)) - trace = pm.sample_prior_predictive(100) - - trace['x'].shape # ==> should be (100, 2, 5, 10), but get (100, 5, 10) - -.. code:: python - - pm.Normal.dist(mu=np.zeros(2), sd=1).random(size=(10, 4)) # ==> ERROR - -There are also other error related random sample generation (e.g., -`Mixture is currently -broken `__). - -Extending PyMC3 ---------------- - -- Custom Inference method - - `Inferencing Linear Mixed Model with EM.ipynb `__ - - `Laplace approximation in pymc3.ipynb `__ -- Connecting it to other library within a model - - `Using “black box” likelihood function by creating a custom Theano Op `__ - - Using emcee -- Using other library for inference - - Connecting to Julia for solving ODE (with gradient for solution that can be used in NUTS) - -What we got wrong ------------------ - -Shape -~~~~~ - -One of the pain point we often face is the issue of shape. The approach -in TFP and pyro is currently much more rigorous. Adrian’s PR -(https://github.com/pymc-devs/pymc3/pull/2833) might fix this problem, -but likely it is a huge effort of refactoring. I implemented quite a lot -of patches for mixture distribution, but still they are not done very -naturally. - -Random methods in numpy -~~~~~~~~~~~~~~~~~~~~~~~ - -There is a lot of complex logic for sampling from random variables, and -because it is all in Python, we can't transform a sampling graph -further. Unfortunately, Theano does not have code to sample from various -distributions and we didn't want to write that our own. - -Samplers are in Python -~~~~~~~~~~~~~~~~~~~~~~ - -While having the samplers be written in Python allows for a lot of -flexibility and intuitive for experiment (writing e.g. NUTS in Theano is -also very difficult), it comes at a performance penalty and makes -sampling on the GPU very inefficient because memory needs to be copied -for every logp evaluation. \ No newline at end of file diff --git a/docs/source/index.rst b/docs/source/index.rst index 2a3bb50e0d..2fd4a9177a 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -10,10 +10,10 @@

Friendly modelling API

PyMC3 allows you to write down models using an intuitive syntax to describe a data generating process.

-

Cutting edge algorithms and model building blocks

+

Cutting edge algorithms

Fit your model using gradient-based MCMC algorithms like NUTS, using ADVI for fast approximate inference — including minibatch-ADVI for scaling to large datasets — or using - Gaussian processes to build Bayesian nonparametric models.

+ Gaussian processes to fit a regression model.

diff --git a/docs/source/notebooks/GLM.ipynb b/docs/source/notebooks/GLM.ipynb index 57fd2a38e0..f42311c62c 100644 --- a/docs/source/notebooks/GLM.ipynb +++ b/docs/source/notebooks/GLM.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# (Generalized) Linear and Hierarchical Linear Models in PyMC3" + "# GLM: Linear Regression" ] }, { @@ -28,7 +28,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Linear Regression\n", + "Simple example\n", + "==============\n", "\n", "Lets generate some data with known slope and intercept and fit a simple linear GLM." ] @@ -145,7 +146,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Robust GLM\n", + "Robust GLM\n", + "==========\n", "\n", "Lets try the same model but with a few outliers in the data." ] @@ -253,7 +255,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Hierarchical GLM" + "# Hierarchical GLM" ] }, { @@ -450,7 +452,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Logistic Regression" + "# Logistic Regression" ] }, { diff --git a/docs/source/notebooks/MvGaussianRandomWalk_demo.ipynb b/docs/source/notebooks/MvGaussianRandomWalk_demo.ipynb index 87f3ae7ed2..e7072fb000 100644 --- a/docs/source/notebooks/MvGaussianRandomWalk_demo.ipynb +++ b/docs/source/notebooks/MvGaussianRandomWalk_demo.ipynb @@ -1,12 +1,5 @@ { "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Multivariate Gaussian Random Walk" - ] - }, { "cell_type": "code", "execution_count": 1, @@ -68,9 +61,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsUAAAE/CAYAAACuKr76AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nwu5JUCyEEEIIIeze/wf9HnXl+rzPcAAAAABJRU5ErkJggg==\n", "text/plain": [ - "
" + "" ] }, "metadata": {}, @@ -160,12 +153,39 @@ "name": "stderr", "output_type": "stream", "text": [ - "Only 100 samples in chain.\n", "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", - "Multiprocess sampling (4 chains in 4 jobs)\n", - "NUTS: [sd, beta, alpha, packed_L_β, packed_L_α]\n", - "Sampling 4 chains: 100%|██████████| 2400/2400 [01:08<00:00, 35.03draws/s]\n" + " 99%|█████████▉| 594/600 [08:32<00:05, 1.16it/s]/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:429: UserWarning: Chain 1 contains only 100 samples.\n", + " % (self._chain_id, n))\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:459: UserWarning: Chain 1 reached the maximum tree depth. Increase max_treedepth, increase target_accept or reparameterize.\n", + " 'reparameterize.' % self._chain_id)\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:451: UserWarning: The acceptance probability in chain 1 does not match the target. It is 0.536618056712, but should be close to 0.8. Try to increase the number of tuning steps.\n", + " % (self._chain_id, mean_accept, target_accept))\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:467: UserWarning: Chain 1 contains 19 diverging samples after tuning. If increasing `target_accept` does not help try to reparameterize.\n", + " % (self._chain_id, n_diverging))\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:429: UserWarning: Chain 2 contains only 100 samples.\n", + " % (self._chain_id, n))\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:459: UserWarning: Chain 2 reached the maximum tree depth. Increase max_treedepth, increase target_accept or reparameterize.\n", + " 'reparameterize.' % self._chain_id)\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:451: UserWarning: The acceptance probability in chain 2 does not match the target. It is 0.691331874096, but should be close to 0.8. Try to increase the number of tuning steps.\n", + " % (self._chain_id, mean_accept, target_accept))\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:467: UserWarning: Chain 2 contains 8 diverging samples after tuning. If increasing `target_accept` does not help try to reparameterize.\n", + " % (self._chain_id, n_diverging))\n", + "100%|██████████| 600/600 [08:38<00:00, 1.16it/s]/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:429: UserWarning: Chain 0 contains only 100 samples.\n", + " % (self._chain_id, n))\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:459: UserWarning: Chain 0 reached the maximum tree depth. Increase max_treedepth, increase target_accept or reparameterize.\n", + " 'reparameterize.' % self._chain_id)\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:467: UserWarning: Chain 0 contains 5 diverging samples after tuning. If increasing `target_accept` does not help try to reparameterize.\n", + " % (self._chain_id, n_diverging))\n", + "\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:429: UserWarning: Chain 3 contains only 100 samples.\n", + " % (self._chain_id, n))\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:459: UserWarning: Chain 3 reached the maximum tree depth. Increase max_treedepth, increase target_accept or reparameterize.\n", + " 'reparameterize.' % self._chain_id)\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:451: UserWarning: The acceptance probability in chain 3 does not match the target. It is 0.550616532328, but should be close to 0.8. Try to increase the number of tuning steps.\n", + " % (self._chain_id, mean_accept, target_accept))\n", + "/home/jovyan/pymc3/pymc3/step_methods/hmc/nuts.py:467: UserWarning: Chain 3 contains 18 diverging samples after tuning. If increasing `target_accept` does not help try to reparameterize.\n", + " % (self._chain_id, n_diverging))\n" ] } ], @@ -199,9 +219,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsUAAAE/CAYAAACuKr76AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCCGEkJzn/wOkY7BvrfVhaAAAAABJRU5ErkJggg==\n", "text/plain": [ - "
" + "" ] }, "metadata": {}, @@ -241,7 +261,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.5" + "version": "3.6.2" } }, "nbformat": 4, diff --git a/docs/source/notebooks/api_quickstart.ipynb b/docs/source/notebooks/api_quickstart.ipynb index 5a0333ec89..55a5bbc82d 100644 --- a/docs/source/notebooks/api_quickstart.ipynb +++ b/docs/source/notebooks/api_quickstart.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# General API quickstart" + "# API quickstart" ] }, { diff --git a/docs/source/notebooks/cox_model.ipynb b/docs/source/notebooks/cox_model.ipynb index f088d50b7b..8c217ef8fb 100644 --- a/docs/source/notebooks/cox_model.ipynb +++ b/docs/source/notebooks/cox_model.ipynb @@ -1,12 +1,5 @@ { "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Cox model" - ] - }, { "cell_type": "code", "execution_count": 1, @@ -291,7 +284,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.5" + "version": "3.6.1" }, "latex_envs": { "bibliofile": "biblio.bib", diff --git a/docs/source/notebooks/gaussian_process.ipynb b/docs/source/notebooks/gaussian_process.ipynb index 69eb3f5e0f..61c6caf8c1 100644 --- a/docs/source/notebooks/gaussian_process.ipynb +++ b/docs/source/notebooks/gaussian_process.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Gaussian Processes using numpy kernel\n", + "# Gaussian Processes\n", "\n", "(c) 2016 by Chris Fonnesbeck" ] diff --git a/docs/source/notebooks/table_of_contents_examples.js b/docs/source/notebooks/table_of_contents_examples.js index 385eafb845..b358ed313b 100644 --- a/docs/source/notebooks/table_of_contents_examples.js +++ b/docs/source/notebooks/table_of_contents_examples.js @@ -1,27 +1,21 @@ Gallery.contents = { - "BEST": "Case Studies", - "LKJ": "Case Studies", - "dawid-skene": "Case Studies", - "stochastic_volatility": "Case Studies", - "rugby_analytics": "Case Studies", - "multilevel_modeling": "Case Studies", - "Diagnosing_biased_Inference_with_Divergences": "Diagnostics and Model Criticism", - "model_comparison": "Diagnostics and Model Criticism", - "posterior_predictive": "Diagnostics and Model Criticism", - "Bayes_factor": "Diagnostics and Model Criticism", - "GLM": "(Generalized) Linear and Hierarchical Linear Models", - "GLM-linear": "(Generalized) Linear and Hierarchical Linear Models", - "GLM-logistic": "(Generalized) Linear and Hierarchical Linear Models", - "GLM-hierarchical-binominal-model": "(Generalized) Linear and Hierarchical Linear Models", - "GLM-hierarchical": "(Generalized) Linear and Hierarchical Linear Models", - "hierarchical_partial_pooling": "(Generalized) Linear and Hierarchical Linear Models", - "GLM-model-selection": "(Generalized) Linear and Hierarchical Linear Models", - "GLM-negative-binomial-regression": "(Generalized) Linear and Hierarchical Linear Models", - "GLM-poisson-regression": "(Generalized) Linear and Hierarchical Linear Models", - "GLM-robust-with-outlier-detection": "(Generalized) Linear and Hierarchical Linear Models", - "GLM-robust": "(Generalized) Linear and Hierarchical Linear Models", - "GLM-rolling-regression": "(Generalized) Linear and Hierarchical Linear Models", - "GLM-hierarchical-advi-minibatch": "(Generalized) Linear and Hierarchical Linear Models", + "AR": "Time Series", + "BEST": "Applied", + "Bayes_factor": "Other", + "Diagnosing_biased_Inference_with_Divergences": "Diagnostics", + "Euler-Maruyama_and_SDEs": "Time Series", + "GLM-hierarchical-advi-minibatch": "Variational Inference", + "GLM-hierarchical-binominal-model": "GLMs", + "GLM-hierarchical": "GLMs", + "GLM-linear": "GLMs", + "GLM-logistic": "GLMs", + "GLM-model-selection": "GLMs", + "GLM-negative-binomial-regression": "GLMs", + "GLM-poisson-regression": "GLMs", + "GLM-robust-with-outlier-detection": "GLMs", + "GLM-robust": "GLMs", + "GLM-rolling-regression": "GLMs", + "GLM": "GLMs", "GP-Kron": "Gaussian Processes", "GP-Latent": "Gaussian Processes", "GP-Marginal": "Gaussian Processes", @@ -32,29 +26,32 @@ Gallery.contents = { "GP-TProcess": "Gaussian Processes", "GP-slice-sampling": "Gaussian Processes", "GP-smoothing": "Gaussian Processes", - "gaussian_process": "Gaussian Processes", + "MvGaussianRandomWalk_demo": "Time Series", + "SMC2_gaussians": "Other", + "bayes_param_survival_pymc3": "Survival Analysis", + "bayesian_neural_network_advi": "Variational Inference", + "bayesian_neural_network_with_sgfs": "Stochastic Gradients", + "censored_data": "Survival Analysis", + "constant_stochastic_gradient": "Stochastic Gradients", + "convolutional_vae_keras_advi": "Variational Inference", + "cox_model": "Other", + "dawid-skene": "Applied", "dependent_density_regression": "Mixture Models", "dp_mix": "Mixture Models", + "empirical-approx-overview": "Variational Inference", "gaussian-mixture-model-advi": "Mixture Models", "gaussian_mixture_model": "Mixture Models", + "gaussian_process": "Gaussian Processes", + "hierarchical_partial_pooling": "GLMs", + "lda-advi-aevb": "Variational Inference", "marginalized_gaussian_mixture_model": "Mixture Models", - "SMC2_gaussians": "Simulation-based Inference", - "bayesian_neural_network_with_sgfs": "Stochastic Gradients", - "constant_stochastic_gradient": "Stochastic Gradients", + "model_comparison": "Diagnostics", + "multilevel_modeling": "Applied", + "normalizing_flows_overview": "Variational Inference", + "posterior_predictive": "Diagnostics", + "rugby_analytics": "Applied", "sgfs_simple_optimization": "Stochastic Gradients", - "bayes_param_survival_pymc3": "Survival Analysis", - "censored_data": "Survival Analysis", + "stochastic_volatility": "Applied", "survival_analysis": "Survival Analysis", - "weibull_aft": "Survival Analysis", - "cox_model": "Survival Analysis", - "MvGaussianRandomWalk_demo": "Time Series", - "AR": "Time Series", - "Euler-Maruyama_and_SDEs": "Time Series", - "bayesian_neural_network_advi": "Variational Inference", - "convolutional_vae_keras_advi": "Variational Inference", - "empirical-approx-overview": "Variational Inference", - "lda-advi-aevb": "Variational Inference", - "normalizing_flows_overview": "Variational Inference", - "gaussian-mixture-model-advi": "Variational Inference", - "GLM-hierarchical-advi-minibatch": "Variational Inference" + "weibull_aft": "Survival Analysis" } diff --git a/docs/source/notebooks/table_of_contents_tutorials.js b/docs/source/notebooks/table_of_contents_tutorials.js index 5e1cdbe421..bf607ac5ea 100644 --- a/docs/source/notebooks/table_of_contents_tutorials.js +++ b/docs/source/notebooks/table_of_contents_tutorials.js @@ -1,20 +1,16 @@ Gallery.contents = { "api_quickstart": "Basics", - "variational_api_quickstart": "Basics", - "theano": "Basics", - "prob_dists": "Basics", - "gp": "Basics", - "sampling_compound_step": "Deep dives", - "sampler-stats": "Deep dives", - "Diagnosing_biased_Inference_with_Divergences": "Deep dives", - "advanced_theano": "Deep dives", - "getting_started": "Deep dives", - "PyMC3_tips_and_heuristic": "How-To", - "blackbox_external_likelihood": "How-To", + "getting_started": "Basics", + "sampler-stats": "Basics", + "sampling_compound_step": "Basics", + "howto_debugging": "Basics", + "live_sample_plots": "How-To", "profiling": "How-To", - "howto_debugging": "How-To", - "model_averaging": "How-To", "updating_priors": "How-To", - "live_sample_plots": "How-To", - "lasso_block_update": "How-To" + "lasso_block_update": "How-To", + "model_averaging": "How-To", + "blackbox_external_likelihood": "How-To", + "LKJ": "How-To", + "variational_api_quickstart": "How-To", + "PyMC3_tips_and_heuristic": "How-To" } diff --git a/docs/source/prob_dists.rst b/docs/source/prob_dists.rst index bee53da8b5..69ad7d8508 100644 --- a/docs/source/prob_dists.rst +++ b/docs/source/prob_dists.rst @@ -1,8 +1,8 @@ .. _prob_dists: -********************************** -Probability Distributions in PyMC3 -********************************** +************************* +Probability Distributions +************************* The most fundamental step in building Bayesian models is the specification of a full probability model for the problem at hand. This primarily involves assigning parametric statistical distributions to unknown quantities in the model, in addition to appropriate functional forms for likelihoods to represent the information from the data. To this end, PyMC3 includes a comprehensive set of pre-defined statistical distributions that can be used as model building blocks.