CUQIpy 1.3.0__py3-none-any.whl → 1.4.0.post0.dev61__py3-none-any.whl

cuqi/__init__.py

@@ -11,6 +11,7 @@ from . import operator
 from . import pde
 from . import problem
 from . import sampler
+from . import legacy
 from . import array
 from . import samples
 from . import solver

cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-01-31T15:19:46+0100",
+ "date": "2025-11-06T09:26:50+0300",
  "dirty": false,
  "error": null,
- "full-revisionid": "ef3d19707582cdca0d5ae948c99047b04daab707",
- "version": "1.3.0"
+ "full-revisionid": "e8fd90f6c716b96b04543b4fe62dd637033ccd32",
+ "version": "1.4.0.post0.dev61"
 }
 '''  # END VERSION_JSON
 

cuqi/density/_density.py

@@ -143,7 +143,15 @@ class Density(ABC):
     def enable_FD(self, epsilon=1e-8):
         """ Enable finite difference approximation for logd gradient. Note
         that if enabled, the FD approximation will be used even if the 
-        _gradient method is implemented. """
+        _gradient method is implemented. 
+        
+        Parameters
+        ----------
+        epsilon : float
+
+        Spacing (step size) to use for finite difference approximation for logd
+        gradient for each variable. Default is 1e-8.
+        """
         self._FD_enabled = True
         self._FD_epsilon = epsilon
 

cuqi/distribution/__init__.py

@@ -14,6 +14,6 @@ from ._lognormal import Lognormal
 from ._normal import Normal
 from ._truncated_normal import TruncatedNormal
 from ._posterior import Posterior
-from ._uniform import Uniform
+from ._uniform import Uniform, UnboundedUniform
 from ._custom import UserDefinedDistribution, DistributionGallery
 from ._joint_distribution import JointDistribution, _StackedJointDistribution, MultipleLikelihoodPosterior

cuqi/distribution/_beta.py

@@ -48,7 +48,7 @@ class Beta(Distribution):
 
         # Check bounds
         if np.any(x<=0) or np.any(x>=1) or np.any(self.alpha<=0) or np.any(self.beta<=0):
-            return -np.Inf
+            return -np.inf
 
         # Compute logpdf
         return np.sum(sps.beta.logpdf(x, a=self.alpha, b=self.beta))

cuqi/distribution/_cauchy.py

@@ -75,14 +75,14 @@ class Cauchy(Distribution):
     def logpdf(self, x):
 
         if self._is_out_of_bounds(x):
-            return -np.Inf
+            return -np.inf
         
         return np.sum(-np.log(np.pi*self.scale*(1+((x-self.location)/self.scale)**2)))
     
     def cdf(self, x):
 
         if self._is_out_of_bounds(x):
-            return -np.Inf
+            return -np.inf
         
         return np.sum(sps.cauchy.cdf(x, loc=self.location, scale=self.scale))
     

cuqi/distribution/_distribution.py

@@ -105,7 +105,7 @@ class Distribution(Density, ABC):
                 f"Inconsistent distribution geometry attribute {self._geometry} and inferred "
                 f"dimension from distribution variables {inferred_dim}."
             )
-        
+
         # If Geometry dimension is None, update it with the inferred dimension
         if inferred_dim and self._geometry.par_dim is None: 
             self.geometry = inferred_dim
@@ -117,7 +117,7 @@ class Distribution(Density, ABC):
         # We do not use self.name to potentially infer it from python stack.
         if self._name: 
             self._geometry._variable_name = self._name
-            
+
         return self._geometry
 
     @geometry.setter
@@ -160,7 +160,7 @@ class Distribution(Density, ABC):
                     f"{self.logd.__qualname__}: To evaluate the log density all conditioning variables and main"
                     f" parameter must be specified. Conditioning variables are: {cond_vars}"
                 )
-            
+
             # Check if all conditioning variables are specified
             all_cond_vars_specified = all([key in kwargs for key in cond_vars])
             if not all_cond_vars_specified:
@@ -168,7 +168,7 @@ class Distribution(Density, ABC):
                     f"{self.logd.__qualname__}: To evaluate the log density all conditioning variables must be"
                     f" specified. Conditioning variables are: {cond_vars}"
                 )
-            
+
             # Extract exactly the conditioning variables from kwargs
             cond_kwargs = {key: kwargs[key] for key in cond_vars}
 
@@ -186,7 +186,7 @@ class Distribution(Density, ABC):
         # Not conditional distribution, simply evaluate log density directly
         else:
             return super().logd(*args, **kwargs)
-        
+
     def _logd(self, *args):
         return self.logpdf(*args) # Currently all distributions implement logpdf so we simply call this method.
 
@@ -216,7 +216,7 @@ class Distribution(Density, ABC):
         # Get samples from the distribution sample method
         s = self._sample(N,*args,**kwargs)
 
-        #Store samples in cuqi samples object if more than 1 sample
+        # Store samples in cuqi samples object if more than 1 sample
         if N==1:
             if len(s) == 1 and isinstance(s,np.ndarray): #Extract single value from numpy array
                 s = s.ravel()[0]
@@ -264,7 +264,7 @@ class Distribution(Density, ABC):
         # Go through every mutable variable and assign value from kwargs if present
         for var_key in mutable_vars:
 
-            #If keyword directly specifies new value of variable we simply reassign
+            # If keyword directly specifies new value of variable we simply reassign
             if var_key in kwargs:
                 setattr(new_dist, var_key, kwargs.get(var_key))
                 processed_kwargs.add(var_key)
@@ -291,9 +291,18 @@ class Distribution(Density, ABC):
 
                 elif len(var_args)>0:                      #Some keywords found
                     # Define new partial function with partially defined args
-                    func = partial(var_val, **var_args)
+                    if (
+                        hasattr(var_val, "_supports_partial_eval")
+                        and var_val._supports_partial_eval
+                    ):
+                        func = var_val(**var_args)
+                    else:
+                        # If the callable does not support partial evaluation,
+                        # we use the partial function to set the variable
+                        func = partial(var_val, **var_args)
+
                     setattr(new_dist, var_key, func)
-                
+
                 # Store processed keywords
                 processed_kwargs.update(var_args.keys())
 
@@ -329,7 +338,7 @@ class Distribution(Density, ABC):
 
     def get_conditioning_variables(self):
         """Return the conditioning variables of this distribution (if any)."""
-        
+
         # Get all mutable variables
         mutable_vars = self.get_mutable_variables()
 
@@ -338,7 +347,7 @@ class Distribution(Density, ABC):
 
         # Add any variables defined through callable functions
         cond_vars += get_indirect_variables(self)
-        
+
         return cond_vars
 
     def get_mutable_variables(self):
@@ -347,10 +356,10 @@ class Distribution(Density, ABC):
         # If mutable variables are already cached, return them
         if hasattr(self, '_mutable_vars'):
             return self._mutable_vars
-        
+
         # Define list of ignored attributes and properties
         ignore_vars = ['name', 'is_symmetric', 'geometry', 'dim']
-        
+
         # Get public attributes
         attributes = get_writeable_attributes(self)
 
@@ -396,7 +405,7 @@ class Distribution(Density, ABC):
                         raise ValueError(f"{self._condition.__qualname__}: {ordered_keys[index]} passed as both argument and keyword argument.\nArguments follow the listed conditioning variable order: {self.get_conditioning_variables()}")
                     kwargs[ordered_keys[index]] = arg
         return kwargs
-    
+
     def _check_geometry_consistency(self):
         """ Checks that the geometry of the distribution is consistent by calling the geometry property. Should be called at the end of __init__ of subclasses. """
         self.geometry
@@ -411,4 +420,4 @@ class Distribution(Density, ABC):
     def rv(self):
         """ Return a random variable object representing the distribution. """
         from cuqi.experimental.algebra import RandomVariable
-        return RandomVariable(self)
+        return RandomVariable(self)

cuqi/distribution/_joint_distribution.py

@@ -84,6 +84,8 @@ class JointDistribution:
         cond_vars = self._get_conditioning_variables()
         if len(cond_vars) > 0:
             raise ValueError(f"Every density parameter must have a distribution (prior). Missing prior for {cond_vars}.")
+        # Initialize finite difference gradient approximation settings
+        self.disable_FD()
 
     # --------- Public properties ---------
     @property
@@ -96,6 +98,38 @@ class JointDistribution:
         """ Returns the geometries of the joint distribution. """
         return [dist.geometry for dist in self._distributions]
 
+    @property
+    def FD_enabled(self):
+        """ Returns a dictionary of keys and booleans indicating for each
+        parameter name (key) if finite difference approximation of the logd
+        gradient is enabled. """
+        par_names = self.get_parameter_names()
+        FD_enabled = {
+            par_name: self.FD_epsilon[par_name] is not None for par_name in par_names
+        }
+        return FD_enabled
+
+    @property
+    def FD_epsilon(self):
+        """ Returns a dictionary indicating for each parameter name the
+        spacing for the finite difference approximation of the logd gradient."""
+        return self._FD_epsilon
+
+    @FD_epsilon.setter
+    def FD_epsilon(self, value):
+        """ Set the spacing for the finite difference approximation of the
+        logd gradient as a dictionary. The keys are the parameter names.
+        The value for each key is either None (no FD approximation) or a float
+        representing the FD step size.
+        """
+        par_names = self.get_parameter_names()
+        if value is None:
+            self._FD_epsilon = {par_name: None for par_name in par_names}
+        else:
+            if set(value.keys()) != set(par_names):
+                raise ValueError("Keys of FD_epsilon must match the parameter names of the distribution "+f" {par_names}")
+            self._FD_epsilon = value
+
     # --------- Public methods ---------
     def logd(self, *args, **kwargs):
         """ Evaluate the un-normalized log density function. """
@@ -136,6 +170,33 @@ class JointDistribution:
         # Can reduce to Posterior, Likelihood or Distribution.
         return new_joint._reduce_to_single_density()
 
+    def enable_FD(self, epsilon=None):
+        """ Enable finite difference approximation for logd gradient. Note
+        that if enabled, the FD approximation will be used even if the 
+        _gradient method is implemented. By default, all parameters
+        will have FD enabled with a step size of 1e-8.
+        
+        Parameters
+        ----------
+        epsilon : dict, *optional*
+
+        Dictionary indicating the spacing (step size) to use for finite
+        difference approximation for logd gradient for each variable.
+
+        Keys are variable names.
+        Values are either a float to enable FD with the given value as the FD
+        step size, or None to disable FD for that variable. Default is 1e-8 for
+        all variables.
+        """
+        if epsilon is None:
+            epsilon = {par_name: 1e-8 for par_name in self.get_parameter_names()}
+        self.FD_epsilon = epsilon
+
+    def disable_FD(self):
+        """ Disable finite difference approximation for logd gradient. """
+        par_names = self.get_parameter_names()
+        self.FD_epsilon = {par_name: None for par_name in par_names}
+
     def get_parameter_names(self) -> List[str]:
         """ Returns the parameter names of the joint distribution. """
         return [dist.name for dist in self._distributions]
@@ -202,34 +263,58 @@ class JointDistribution:
         # Count number of distributions and likelihoods
         n_dist = len(self._distributions)
         n_likelihood = len(self._likelihoods)
+        reduced_FD_epsilon = {par_name:self.FD_epsilon[par_name] for par_name in self.get_parameter_names()}
+        self.enable_FD(epsilon=reduced_FD_epsilon)
 
         # Cant reduce if there are multiple distributions or likelihoods
         if n_dist > 1:
             return self
 
+        # If only evaluated densities left return joint to ensure logd method is available
+        if n_dist == 0 and n_likelihood == 0:
+            return self
+
+        # Extract the parameter name of the distribution
+        if n_dist == 1:
+            par_name = self._distributions[0].name
+        elif n_likelihood == 1:
+            par_name = self._likelihoods[0].name
+        else:
+            par_name = None
+
         # If exactly one distribution and multiple likelihoods reduce
         if n_dist == 1 and n_likelihood > 1:
-            return MultipleLikelihoodPosterior(*self._densities)
-        
+            reduced_distribution = MultipleLikelihoodPosterior(*self._densities)
+            reduced_FD_epsilon = {par_name:self.FD_epsilon[par_name]}
+
         # If exactly one distribution and one likelihood its a Posterior
         if n_dist == 1 and n_likelihood == 1:
             # Ensure parameter names match, otherwise return the joint distribution
             if set(self._likelihoods[0].get_parameter_names()) != set(self._distributions[0].get_parameter_names()):
                 return self
-            return self._add_constants_to_density(Posterior(self._likelihoods[0], self._distributions[0]))
+            reduced_distribution = Posterior(self._likelihoods[0], self._distributions[0])
+            reduced_distribution = self._add_constants_to_density(reduced_distribution)
+            reduced_FD_epsilon = self.FD_epsilon[par_name]
 
         # If exactly one distribution and no likelihoods its a Distribution
         if n_dist == 1 and n_likelihood == 0:
-            return self._add_constants_to_density(self._distributions[0])        
-        
+            # Intentionally skip enabling FD here. If the user wants FD, they
+            # can enable it for this particular distribution before forming
+            # the joint distribution.
+            return self._add_constants_to_density(self._distributions[0])
+
         # If no distributions and exactly one likelihood its a Likelihood
         if n_likelihood == 1 and n_dist == 0:
-            return self._likelihoods[0]
+            # This case seems to not happen in practice, but we include it for
+            # completeness.
+            reduced_distribution = self._likelihoods[0]
+            reduced_FD_epsilon = self.FD_epsilon[par_name] 
+
+        if self.FD_enabled[par_name]:
+            reduced_distribution.enable_FD(epsilon=reduced_FD_epsilon)
+
+        return reduced_distribution
 
-        # If only evaluated densities left return joint to ensure logd method is available
-        if n_dist == 0 and n_likelihood == 0:
-            return self
-        
     def _add_constants_to_density(self, density: Density):
         """ Add the constants (evaluated densities) to a single density. Used when reducing to single density. """
 
@@ -274,7 +359,7 @@ class JointDistribution:
                     if len(cond_vars) > 0:
                         msg += f"|{cond_vars}"
                     msg += ")"
-        
+
         msg += "\n"
         msg += "    Densities: \n"
 
@@ -283,7 +368,7 @@ class JointDistribution:
             msg += f"\t{density.name} ~ {density}\n"
 
         # Wrap up
-        msg += ")"
+        msg += " )"
 
         return msg
 

cuqi/distribution/_posterior.py

@@ -1,5 +1,6 @@
 from cuqi.geometry import _DefaultGeometry, _get_identity_geometries
 from cuqi.distribution import Distribution
+from cuqi.density import Density
 
 # ========================================================================
 class Posterior(Distribution):
@@ -25,6 +26,14 @@ class Posterior(Distribution):
         self.prior = prior 
         super().__init__(**kwargs)
 
+    def get_density(self, name) -> Density:
+        """ Return a density with the given name. """
+        if name == self.likelihood.name:
+            return self.likelihood
+        if name == self.prior.name:
+            return self.prior
+        raise ValueError(f"No density with name {name}.")
+
     @property
     def data(self):
         return self.likelihood.data

cuqi/distribution/_truncated_normal.py

@@ -37,7 +37,7 @@ class TruncatedNormal(Distribution):
         p = cuqi.distribution.TruncatedNormal(mean=0, std=1, low=-2, high=2)
         samples = p.sample(5000)
     """
-    def __init__(self, mean=None, std=None, low=-np.Inf, high=np.Inf, is_symmetric=False, **kwargs):
+    def __init__(self, mean=None, std=None, low=-np.inf, high=np.inf, is_symmetric=False, **kwargs):
         # Init from abstract distribution class
         super().__init__(is_symmetric=is_symmetric, **kwargs)  
 
@@ -97,7 +97,7 @@ class TruncatedNormal(Distribution):
         # the unnormalized logpdf
         # check if x falls in the range between np.array a and b
         if np.any(x < self.low) or np.any(x > self.high):
-            return -np.Inf
+            return -np.inf
         else:
              return self._normal.logpdf(x)
 
@@ -107,7 +107,7 @@ class TruncatedNormal(Distribution):
         """
         # check if x falls in the range between np.array a and b
         if np.any(x < self.low) or np.any(x > self.high):
-            return np.NaN*np.ones_like(x)
+            return np.nan*np.ones_like(x)
         else:
             return self._normal.gradient(x, *args, **kwargs)
 

cuqi/distribution/_uniform.py

@@ -1,5 +1,6 @@
 import numpy as np
 from cuqi.distribution import Distribution
+from cuqi.geometry import Geometry
 
 class Uniform(Distribution):
 
@@ -46,7 +47,7 @@ class Uniform(Distribution):
         Computes the gradient of logpdf at the given values of x.
         """
         if np.any(x < self.low) or np.any(x > self.high):
-            return np.NaN*np.ones_like(x)
+            return np.nan*np.ones_like(x)
         else:
             return np.zeros_like(x)
 
@@ -57,4 +58,37 @@ class Uniform(Distribution):
         else:
             s = np.random.uniform(self.low, self.high, (N,self.dim)).T
 
-        return s
+        return s
+
+class UnboundedUniform(Distribution):
+    """
+    Unbounded uniform distribution. This is a special case of the
+    Uniform distribution, where the lower and upper bounds are set to
+    -inf and inf, respectively. This distribution is not normalizable,
+    and therefore cannot be sampled from. It is mainly used for
+    initializing non-informative priors.
+    Parameters
+    ----------
+    geometry : int or Geometry
+        The geometry of the distribution. If an integer is given, it is
+        interpreted as the dimension of the distribution. If a
+        Geometry object is given, its par_dim attribute is used.
+    """
+    def __init__(self, geometry, is_symmetric=True, **kwargs):
+        super().__init__(geometry=geometry, is_symmetric=is_symmetric, **kwargs) 
+
+    def logpdf(self, x):
+        """
+        Evaluate the logarithm of the unnormalized PDF at the given values of x.
+        """
+        # Always return 1.0 (the unnormalized log PDF)
+        return 1.0
+
+    def gradient(self, x):
+        """
+        Computes the gradient of logpdf at the given values of x.
+        """
+        return np.zeros_like(x)
+
+    def _sample(self, N=1, rng=None):
+        raise NotImplementedError("Cannot sample from UnboundedUniform distribution")

cuqi/experimental/__init__.py

@@ -1,4 +1,4 @@
 """ Experimental module for testing new features and ideas.  """
-from . import mcmc
 from . import algebra
 from . import geometry
+from ._recommender import SamplerRecommender