changed names of gradient member functions

Author: jsalvatier

pymc/Node.py

@@ -28,15 +28,13 @@ def logp_of_set(s):
     else:
         raise exc[0], exc[1], exc[2]
 
-def grad_logp_of_set(variable_set, calculation_set = None):
+def logp_gradient_of_set(variable_set, calculation_set = None):
 
-    grad_logp = {}
+    logp_gradient = {}
     for var in variable_set:   
-        gradient = var.gradient(calculation_set)
-        
-        grad_logp[var] = gradient
+        logp_gradient[var] = var.logp_gradient_contribution(calculation_set)
 
-    return grad_logp
+    return logp_gradient
 
 
 

pymc/PyMCObjects.py

@@ -235,13 +235,13 @@ def A(x = B, y = C):
 
     :SeeAlso: Stochastic, Node, LazyFunction, stoch, dtrm, data, Model, Container
     """
-    def __init__(self, logp,  doc, name, parents, cache_depth=2, plot=None, verbose=None, grad_logps = {}):
+    def __init__(self, logp,  doc, name, parents, cache_depth=2, plot=None, verbose=None, logp_partial_gradients = {}):
 
         self.ParentDict = ParentDict
 
         # This function gets used to evaluate self's value.
         self._logp_fun = logp
-        self._grad_logp_functions = grad_logps
+        self._logp_partial_gradients_functions = logp_partial_gradients
 
 
         self.errmsg = "Potential %s forbids its parents' current values"%name
@@ -271,14 +271,14 @@ def gen_lazy_function(self):
                                     cache_depth = self._cache_depth)
         self._logp.force_compute()
 
-        self._grad_logps = {}
-        for parameter, function in self._grad_logp_functions.iteritems():
-            lazy_grad_logp = LazyFunction(fun = function,
+        self._logp_partial_gradients= {}
+        for parameter, function in self._logp_partial_gradients_functions.iteritems():
+            lazy_logp_partial_gradients = LazyFunction(fun = function,
                                             arguments = self.parents,
                                             ultimate_args = self.extended_parents,
                                             cache_depth = self._cache_depth)
-            lazy_grad_logp.force_compute()
-            self._grad_logps[parameter] = lazy_grad_logp
+            lazy_logp_partial_gradients.force_compute()
+            self._logp_partial_gradients[parameter] = lazy_logp_partial_gradients
 
     def get_logp(self):
         if self.verbose > 1:
@@ -309,7 +309,7 @@ def set_logp(self,value):
 
     logp = property(fget = get_logp, fset=set_logp, doc="Self's log-probability value conditional on parents.")
 
-    def grad_logp(self, calculation_set = None):
+    def logp_partial_gradient(self, calculation_set = None):
         gradient = 0
         if self in calculation_set:
 
@@ -320,37 +320,14 @@ def grad_logp(self, calculation_set = None):
 
                 if value is variable:
                     try :
-                        grad_func = self._grad_logps[parameter]
+                        grad_func = self._logp_partial_gradients[parameter]
                     except KeyError:
                         raise NotImplementedError(repr(self) + " has no gradient function for parameter " + parameter)
 
                     gradient = gradient + grad_func.get()
 
-        #_grad_logp can return either raveled or non-raveled values, but they should be consistent
         return np.reshape(gradient, np.shape(variable.value)) #np.reshape(gradient, np.shape(variable.value))
 
-
-
-def parameter_value_dict(p, parameters):
-    for parameter, value in parameters.iteritems():
-        if isinstance(value, Variable):
-            p[parameter] = value.value 
-        else: 
-            p[parameter] = value
-    return p
-# should be able to be replaced in python 3.0 by 
-#def params(parameters):
-#    return dict( parameter : get_val(value) for parameter, value in parameters.iteritems())
-
-#def get_val(value):
-#    if isinstance(value, Variable):
-#        return value.value 
-#    else: 
-#        return value
-
-
-
-
 class Deterministic(DeterministicBase):
     """
     A variable whose value is determined by the values of its parents.
@@ -460,23 +437,21 @@ def set_value(self,value):
 
     value = property(fget = get_value, fset=set_value, doc="Self's value computed from current values of parents.")
 
-    def grad_logp(self, variable, calculation_set = None):
+    def logp_partial_gradient(self, variable, calculation_set = None):
         """
         gets the logp gradient of this deterministic with respect to variable
         """
         if self.verbose > 0:
-            print '\t' + self.__name__ + ': grad_logp accessed.'
+            print '\t' + self.__name__ + ': logp_partial_gradient accessed.'
 
         if not (variable.dtype in float_dtypes and self.dtype in float_dtypes):
                 return zeros(shape(variable.value))
 
         #gradient = 0
 
         # loop through all the parameters and add up all the gradients of log p with respect to the approrpiate variable
-        gradient = __builtin__.sum([child.grad_logp(self, calculation_set) for child in self.children ])
-        #for child in self.children:
-        #    gradient = gradient + child.grad_logp(self, calculation_set)
-            
+        gradient = __builtin__.sum([child.logp_partial_gradient(self, calculation_set) for child in self.children ])
+
         totalGradient = 0
         for parameter, value in self.parents.iteritems():
             if value is variable:
@@ -654,7 +629,7 @@ def __init__(   self,
                     verbose = None,
                     isdata=None,
                     check_logp=True,
-                    grad_logps = {}):
+                    logp_partial_gradients = {}):
 
         self.counter = Counter()
         self.ParentDict = ParentDict
@@ -673,7 +648,7 @@ def __init__(   self,
         self._logp_fun = logp
 
         #This function will be used to evaluate self's gradient of log probability.
-        self._grad_logp_functions = grad_logps
+        self._logp_partial_gradient_functions = logp_partial_gradients
 
         # This function will be used to draw values for self conditional on self's parents.
         self._random = random
@@ -753,14 +728,14 @@ def gen_lazy_function(self):
         self._logp.force_compute()
 
 
-        self._grad_logps = {}
-        for parameter, function in self._grad_logp_functions.iteritems():
-            lazy_grad_logp = LazyFunction(fun = function,
+        self._logp_partial_gradients = {}
+        for parameter, function in self._logp_partial_gradient_functions.iteritems():
+            lazy_logp_partial_gradient = LazyFunction(fun = function,
                                             arguments = arguments,
                                             ultimate_args = self.extended_parents | set([self]),
                                             cache_depth = self._cache_depth)
-            lazy_grad_logp.force_compute()
-            self._grad_logps[parameter] = lazy_grad_logp
+            lazy_logp_partial_gradient.force_compute()
+            self._logp_partial_gradients[parameter] = lazy_logp_partial_gradient
 
     def get_value(self):
         # Define value attribute
@@ -844,19 +819,17 @@ def set_logp(self, new_logp):
 
 
 
-    def gradient(self, calculation_set = None):
+    def logp_gradient_contribution(self, calculation_set = None):
         """
         Calculates the gradient of the joint log posterior with respect to self. 
         Calculation of the log posterior is restricted to the variables in calculation_set. 
         """
         #NEED some sort of check to see if the log p calculation has recently failed, in which case not to continue
 
-        gradient = self.grad_logp(self, calculation_set) + __builtin__.sum([child.grad_logp(self, calculation_set) for child in self.children] )
+        return self.logp_partial_gradient(self, calculation_set) + __builtin__.sum([child.logp_partial_gradient(self, calculation_set) for child in self.children] )
 
-            
-        return gradient
 
-    def grad_logp(self, variable, calculation_set = None):
+    def logp_partial_gradient(self, variable, calculation_set = None):
         """
         Calculates the partial gradient of the posterior of self with respect to variable.
         Returns zero if self is not in calculation_set.
@@ -869,7 +842,7 @@ def grad_logp(self, variable, calculation_set = None):
 
             if variable is self:
                 try :
-                    gradient_func = self._grad_logps['value']
+                    gradient_func = self._logp_partial_gradients['value']
 
                 except KeyError:
                     raise NotImplementedError(repr(self) + " has no gradient function for 'value'")
@@ -885,7 +858,7 @@ def grad_logp(self, variable, calculation_set = None):
     def _pgradient(self, variable, parameter, value):
         if value is variable:
             try :
-                return np.reshape(self._grad_logps[parameter].get(), np.shape(variable.value))
+                return np.reshape(self._logp_partial_gradients[parameter].get(), np.shape(variable.value))
             except KeyError:
                 raise NotImplementedError(repr(self) + " has no gradient function for parameter " + parameter)
         else:

pymc/StepMethods.py

@@ -1,7 +1,7 @@
 from __future__ import division
 
 import numpy as np
-from utils import msqrt, check_type, round_array, float_dtypes, integer_dtypes, bool_dtypes, safe_len, find_generations, logp_of_set, symmetrize, grad_logp_of_set
+from utils import msqrt, check_type, round_array, float_dtypes, integer_dtypes, bool_dtypes, safe_len, find_generations, logp_of_set, symmetrize, logp_gradient_of_set
 from numpy import ones, zeros, log, shape, cov, ndarray, inner, reshape, sqrt, any, array, all, abs, exp, where, isscalar, iterable, multiply, transpose, tri
 from numpy.linalg.linalg import LinAlgError
 from numpy.linalg import pinv, cholesky
@@ -280,10 +280,10 @@ def _get_logp_plus_loglike(self):
     # Make get property for retrieving log-probability
     logp_plus_loglike = property(fget = _get_logp_plus_loglike, doc="The summed log-probability of all stochastic variables that depend on \n self.stochastics, and self.stochastics.")
 
-    def _get_grad_logp(self):
-        return grad_logp_of_set(self.stochastics, self.markov_blanket)
+    def _get_logp_gradient(self):
+        return logp_gradient_of_set(self.stochastics, self.markov_blanket)
 
-    grad_logp = property(fget = _get_grad_logp)
+    logp_gradient = property(fget = _get_logp_gradient)
 
     def current_state(self):
         """Return a dictionary with the current value of the variables defining

pymc/distributions.py

@@ -117,11 +117,11 @@ def new_dist_class(*new_class_args):
         stochastic_from_dist
     """
 
-    (dtype, name, parent_names, parents_default, docstr, logp, random, mv, grad_logps) = new_class_args
+    (dtype, name, parent_names, parents_default, docstr, logp, random, mv, logp_partial_gradients) = new_class_args
     class new_class(Stochastic):
         __doc__ = docstr
         def __init__(self, *args, **kwds):
-            (dtype, name, parent_names, parents_default, docstr, logp, random, mv, grad_logps) = new_class_args
+            (dtype, name, parent_names, parents_default, docstr, logp, random, mv, logp_partial_gradients) = new_class_args
             parents=parents_default
 
             # Figure out what argument names are needed.
@@ -241,15 +241,15 @@ def shape_error():
                 logp = debug_wrapper(logp)
                 random = debug_wrapper(random)
             else:
-                Stochastic.__init__(self, logp=logp, random=random, grad_logps = grad_logps, dtype=dtype, **arg_dict_out)
+                Stochastic.__init__(self, logp=logp, random=random, logp_partial_gradients = logp_partial_gradients, dtype=dtype, **arg_dict_out)
 
     new_class.__name__ = name
     new_class.parent_names = parent_names
 
     return new_class
 
 
-def stochastic_from_dist(name, logp, random=None, grad_logp={}, dtype=np.float, mv=False):
+def stochastic_from_dist(name, logp, random=None, logp_partial_gradients={}, dtype=np.float, mv=False):
     """
     Return a Stochastic subclass made from a particular distribution.
 
@@ -303,12 +303,13 @@ def stochastic_from_dist(name, logp, random=None, grad_logp={}, dtype=np.float,
     logp=valuewrapper(logp)
     distribution_arguments = logp.__dict__
 
-    wrapped_grad_logps = {}
+    wrapped_logp_partial_gradients = {}
 
-    for parameter, func in grad_logp.iteritems():
-        wrapped_grad_logps[parameter] = valuewrapper(grad_logp[parameter], arguments = distribution_arguments)
+    print logp_partial_gradients
+    for parameter, func in logp_partial_gradients.iteritems():
+        wrapped_logp_partial_gradients[parameter] = valuewrapper(logp_partial_gradients[parameter], arguments = distribution_arguments)
 
-    return new_dist_class(dtype, name, parent_names, parents_default, docstr, logp, random, mv, wrapped_grad_logps)
+    return new_dist_class(dtype, name, parent_names, parents_default, docstr, logp, random, mv, wrapped_logp_partial_gradients)
 
 
 #-------------------------------------------------------------
@@ -2695,23 +2696,23 @@ def local_decorated_likelihoods(obj):
 
 for dist in sc_continuous_distributions:
     dist_logp, dist_random, grad_logp = name_to_funcs(dist, locals())
-    locals()[capitalize(dist)]= stochastic_from_dist(dist, dist_logp, dist_random, grad_logp)
+    locals()[capitalize(dist)]= stochastic_from_dist(dist, dist_logp, dist_random, logp_partial_gradients = grad_logp)
 
 for dist in mv_continuous_distributions:
     dist_logp, dist_random, grad_logp = name_to_funcs(dist, locals())
-    locals()[capitalize(dist)]= stochastic_from_dist(dist, dist_logp, dist_random, grad_logp = grad_logp, mv=True)
+    locals()[capitalize(dist)]= stochastic_from_dist(dist, dist_logp, dist_random, logp_partial_gradients = grad_logp, mv=True)
 
 for dist in sc_discrete_distributions:
     dist_logp, dist_random, grad_logp = name_to_funcs(dist, locals())
-    locals()[capitalize(dist)]= stochastic_from_dist(dist, dist_logp, dist_random, grad_logp = grad_logp, dtype=np.int)
+    locals()[capitalize(dist)]= stochastic_from_dist(dist, dist_logp, dist_random, logp_partial_gradients = grad_logp, dtype=np.int)
 
 for dist in mv_discrete_distributions:
     dist_logp, dist_random, grad_logp = name_to_funcs(dist, locals())
-    locals()[capitalize(dist)]= stochastic_from_dist(dist, dist_logp, dist_random, grad_logp = grad_logp, dtype=np.int, mv=True)
+    locals()[capitalize(dist)]= stochastic_from_dist(dist, dist_logp, dist_random, logp_partial_gradients = grad_logp, dtype=np.int, mv=True)
 
 
 dist_logp, dist_random, grad_logp = name_to_funcs('bernoulli', locals())
-Bernoulli = stochastic_from_dist('bernoulli', dist_logp, dist_random,grad_logp, dtype=np.bool)
+Bernoulli = stochastic_from_dist('bernoulli', dist_logp, dist_random,logp_partial_gradients = grad_logp, dtype=np.bool)
 
 
 def uninformative_like(x):

pymc/tests/test_gradients.py

@@ -192,7 +192,7 @@ def test_numpy_deterministics_jacobians(self):
     def check_gradients(self, stochastic):
 
         stochastics = find_variable_set(stochastic)
-        gradients = utils.grad_logp_of_set(stochastics, stochastics)
+        gradients = utils.logp_gradient_of_set(stochastics, stochastics)
 
         for s, analytic_gradient in gradients.iteritems():
 
@@ -324,7 +324,7 @@ def check_model_gradients(self, model):
         markov_blanket = list(model)+list(children)
 
 
-        gradients = utils.grad_logp_of_set(model)
+        gradients = utils.logp_gradient_of_set(model)
         for variable in model:
 
             analytic_gradient = gradients[variable]

pymc/utils.py

@@ -12,7 +12,7 @@
 import pdb
 from numpy.linalg.linalg import LinAlgError
 from numpy.linalg import cholesky, eigh, det, inv
-from Node import logp_of_set, grad_logp_of_set
+from Node import logp_of_set, logp_gradient_of_set
 import types
 
 from numpy import sqrt, obj2sctype, ndarray, asmatrix, array, pi, prod, exp,\