Reformat docs

Author: colin

pymc3/step_methods/hmc/base_hmc.py

@@ -12,24 +12,25 @@ class BaseHMC(ArrayStepShared):
 
     def __init__(self, vars=None, scaling=None, step_scale=0.25, is_cov=False,
                  model=None, blocked=True, use_single_leapfrog=False, **theano_kwargs):
-        """
+        """Superclass to implement Hamiltonian/hybrid monte carlo
+
         Parameters
         ----------
-            vars : list of theano variables
-            scaling : array_like, ndim = {1,2}
-                Scaling for momentum distribution. 1d arrays interpreted matrix diagonal.
-            step_scale : float, default=0.25
-                Size of steps to take, automatically scaled down by 1/n**(1/4)
-            is_cov : bool, default=False
-                Treat scaling as a covariance matrix/vector if True, else treat it as a
-                precision matrix/vector
-            state
-                State object
-            model : pymc3 Model instance.  default=Context model
-            blocked: Boolean, default True
-            use_single_leapfrog: Boolean, will leapfrog steps take a single step at a time.
-                default False.
-            **theano_kwargs: passed to theano functions
+        vars : list of theano variables
+        scaling : array_like, ndim = {1,2}
+            Scaling for momentum distribution. 1d arrays interpreted matrix diagonal.
+        step_scale : float, default=0.25
+            Size of steps to take, automatically scaled down by 1/n**(1/4)
+        is_cov : bool, default=False
+            Treat scaling as a covariance matrix/vector if True, else treat it as a
+            precision matrix/vector
+        state
+            State object
+        model : pymc3 Model instance.  default=Context model
+        blocked: Boolean, default True
+        use_single_leapfrog: Boolean, will leapfrog steps take a single step at a time.
+            default False.
+        **theano_kwargs: passed to theano functions
         """
         model = modelcontext(model)
 

pymc3/step_methods/hmc/hmc.py

@@ -27,13 +27,13 @@ def __init__(self, vars=None, path_length=2., step_rand=unif, **kwargs):
         """
         Parameters
         ----------
-            vars : list of theano variables
-            path_length : float, default=2
-                total length to travel
-            step_rand : function float -> float, default=unif
-                A function which takes the step size and returns an new one used to
-                randomize the step size at each iteration.
-            **kwargs : passed to BaseHMC
+        vars : list of theano variables
+        path_length : float, default=2
+            total length to travel
+        step_rand : function float -> float, default=unif
+            A function which takes the step size and returns an new one used to
+            randomize the step size at each iteration.
+        **kwargs : passed to BaseHMC
         """
         super(HamiltonianMC, self).__init__(vars, **kwargs)
         self.path_length = path_length

pymc3/step_methods/hmc/nuts.py

@@ -28,17 +28,17 @@ def __init__(self, vars=None, Emax=1000, target_accept=0.8,
         """
         Parameters
         ----------
-            vars : list of Theano variables, default continuous vars
-            Emax : float, default 1000
-                maximum energy
-            target_accept : float (0,1) default .8
-                target for avg accept probability between final branch and initial position
-            gamma : float, default .05
-            k : float (.5,1) default .75
-                scaling of speed of adaptation
-            t0 : int, default 10
-                slows inital adapatation
-            kwargs: passed to BaseHMC
+        vars : list of Theano variables, default continuous vars
+        Emax : float, default 1000
+            maximum energy
+        target_accept : float (0,1) default .8
+            target for avg accept probability between final branch and initial position
+        gamma : float, default .05
+        k : float (.5,1) default .75
+            scaling of speed of adaptation
+        t0 : int, default 10
+            slows inital adapatation
+        kwargs: passed to BaseHMC
         """
         super(NUTS, self).__init__(vars, use_single_leapfrog=True, **kwargs)
 

pymc3/step_methods/hmc/quadpotential.py

@@ -14,18 +14,18 @@ def quad_potential(C, is_cov, as_cov):
     """
     Parameters
     ----------
-        C : arraylike, 0 <= ndim <= 2
-            scaling matrix for the potential
-            vector treated as diagonal matrix
-        is_cov : Boolean
-            whether C is provided as a covariance matrix or hessian
-        as_cov : Boolean
-            whether the random draws should come from the normal dist
-            using the covariance matrix above or the inverse
+    C : arraylike, 0 <= ndim <= 2
+        scaling matrix for the potential
+        vector treated as diagonal matrix
+    is_cov : Boolean
+        whether C is provided as a covariance matrix or hessian
+    as_cov : Boolean
+        whether the random draws should come from the normal dist
+        using the covariance matrix above or the inverse
 
     Returns
     -------
-        q : Quadpotential
+    q : Quadpotential
     """
 
     if issparse(C) and is_cov != as_cov:

pymc3/step_methods/hmc/trajectory.py

@@ -14,15 +14,15 @@ def _theano_hamiltonian(model_vars, shared, logpt, potential):
 
     Parameters
     ----------
-    model_vars: array of variables to be sampled
-    shared theano tensors that are already shared
-    logpt: model log probability
-    potential: hamiltonian potential
+    model_vars : array of variables to be sampled
+    shared : theano tensors that are already shared
+    logpt : model log probability
+    potential : hamiltonian potential
 
     Returns
     -------
-    Hamiltonian: namedtuple with log pdf, gradient of log pdf, and potential functions
-    q: Starting position variable.
+    Hamiltonian : namedtuple with log pdf, gradient of log pdf, and potential functions
+    q : Starting position variable.
     """
     dlogp = gradient(logpt, model_vars)
     (logp, dlogp), q = join_nonshared_inputs([logpt, dlogp], model_vars, shared)
@@ -36,14 +36,14 @@ def _theano_energy_function(H, q, **theano_kwargs):
 
     Parameters
     ----------
-    H: Hamiltonian namedtuple
-    q: theano variable, starting position
-    theano_kwargs: passed to theano.function
+    H : Hamiltonian namedtuple
+    q : theano variable, starting position
+    theano_kwargs : passed to theano.function
 
     Returns
     -------
-    energy_function: theano function that computes the energy at a point (p, q) in phase space
-    p: Starting momentum variable.
+    energy_function : theano function that computes the energy at a point (p, q) in phase space
+    p : Starting momentum variable.
     """
     p = tt.dvector('p')
     p.tag.test_value = q.tag.test_value
@@ -91,19 +91,19 @@ def get_theano_hamiltonian_functions(model_vars, shared, logpt, potential,
     Parameters
     ----------
     model_vars : array of variables to be sampled
-    shared theano tensors that are already shared
-    logpt: model log probability
-    potential: hamiltonian potential
+    shared : theano tensors that are already shared
+    logpt : model log probability
+    potential : Hamiltonian potential
     theano_kwargs : dictionary of keyword arguments to pass to theano functions
-    use_single_leapfrog: Boolean, if only 1 integration step is done at a time (as in NUTS),
-                         this provides a ~2x speedup
+    use_single_leapfrog : Boolean, if only 1 integration step is done at a time (as in NUTS),
+                          this provides a ~2x speedup
 
     Returns
     -------
-    H: Hamiltonian namedtuple
-    energy_function: theano function computing energy at a point in phase space
-    leapfrog_integrator: theano function integrating the Hamiltonian from a point in phase space
-    theano_variables: dictionary of variables used in the computation graph which may be useful
+    H : Hamiltonian namedtuple
+    energy_function : theano function computing energy at a point in phase space
+    leapfrog_integrator : theano function integrating the Hamiltonian from a point in phase space
+    theano_variables : dictionary of variables used in the computation graph which may be useful
     """
     H, q = _theano_hamiltonian(model_vars, shared, logpt, potential)
     energy_function, p = _theano_energy_function(H, q, **theano_kwargs)
@@ -137,18 +137,18 @@ def leapfrog(H, q, p, epsilon, n_steps):
     ----------
     H : Hamiltonian instance.
         Tuple of `logp, dlogp, potential`.
-    q: Theano.tensor
+    q : Theano.tensor
         initial position vector
-    p: Theano.tensor
+    p : Theano.tensor
         initial momentum vector
-    epsilon: float, step size
-    n_steps: int, number of iterations
+    epsilon : float, step size
+    n_steps : int, number of iterations
 
     Returns
     -------
-    position: Theano.tensor
+    position : Theano.tensor
         position estimate at time :math:`n \cdot e`.
-    momentum: Theano.tensor
+    momentum : Theano.tensor
         momentum estimate at time :math:`n \cdot e`.
     """
     def full_update(p, q):