CUQIpy 1.3.0.post0.dev298__py3-none-any.whl → 1.4.0.post0.dev92__py3-none-any.whl

cuqi/__init__.py

@@ -1,6 +1,7 @@
 from . import data
 from . import density
 from . import diagnostics
+from . import algebra
 from . import distribution
 from . import experimental
 from . import geometry
@@ -11,6 +12,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-09-04T09:48:37+0300",
+ "date": "2025-11-24T16:04:21+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "a0d227d0981362a09d24dc976ad65459ba8bf798",
- "version": "1.3.0.post0.dev298"
+ "full-revisionid": "d6622bf24d4986794de75feebd950e695d1da212",
+ "version": "1.4.0.post0.dev92"
 }
 '''  # END VERSION_JSON
 

cuqi/algebra/__init__.py

@@ -0,0 +1,2 @@
+from ._abstract_syntax_tree import VariableNode, Node
+from ._random_variable import RandomVariable

cuqi/{experimental/algebra/_randomvariable.py → algebra/_random_variable.py}

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from typing import List, Any, Union
-from ._ast import VariableNode, Node
-from ._orderedset import _OrderedSet
+from ._abstract_syntax_tree import VariableNode, Node
+from ._ordered_set import _OrderedSet
 import operator
 import cuqi
 from cuqi.distribution import Distribution
@@ -58,7 +58,7 @@ class RandomVariable:
 
         from cuqi.testproblem import Deconvolution1D
         from cuqi.distribution import Gaussian, Gamma, GMRF
-        from cuqi.experimental.algebra import RandomVariable
+        from cuqi.algebra import RandomVariable
         from cuqi.problem import BayesianProblem
 
         import numpy as np
@@ -79,7 +79,7 @@ class RandomVariable:
     .. code-block:: python
 
         from cuqi.distribution import Gaussian, Gamma
-        from cuqi.experimental.algebra import RandomVariable, VariableNode
+        from cuqi.algebra import RandomVariable, VariableNode
 
         # Define the variables
         x = VariableNode('x')

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/_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
@@ -410,5 +419,5 @@ class Distribution(Density, ABC):
     @property
     def rv(self):
         """ Return a random variable object representing the distribution. """
-        from cuqi.experimental.algebra import RandomVariable
-        return RandomVariable(self)
+        from cuqi.algebra import RandomVariable
+        return RandomVariable(self)

cuqi/distribution/_joint_distribution.py

@@ -62,16 +62,16 @@ class JointDistribution:
         posterior = joint(y=y_obs)
         
     """
-    def __init__(self, *densities: [Density, cuqi.experimental.algebra.RandomVariable]):
+    def __init__(self, *densities: [Density, cuqi.algebra.RandomVariable]):
         """ Create a joint distribution from the given densities. """
 
         # Check if all RandomVariables are simple (not-transformed)
         for density in densities:
-            if isinstance(density, cuqi.experimental.algebra.RandomVariable) and density.is_transformed:
+            if isinstance(density, cuqi.algebra.RandomVariable) and density.is_transformed:
                 raise ValueError(f"To be used in {self.__class__.__name__}, all RandomVariables must be untransformed.")
 
         # Convert potential random variables to their underlying distribution
-        densities = [density.distribution if isinstance(density, cuqi.experimental.algebra.RandomVariable) else density for density in densities]
+        densities = [density.distribution if isinstance(density, cuqi.algebra.RandomVariable) else density for density in densities]
 
         # Ensure all densities have unique names
         names = [density.name for density in densities]
@@ -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"
 

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/experimental/__init__.py

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

cuqi/experimental/_recommender.py

@@ -3,7 +3,7 @@ import inspect
 import numpy as np
 
 # This import makes suggest_sampler easier to read
-import cuqi.experimental.mcmc as samplers 
+import cuqi.sampler as samplers 
 
 
 class SamplerRecommender(object):
@@ -15,7 +15,7 @@ class SamplerRecommender(object):
     target: Density or JointDistribution
         Distribution to get sampler recommendations for.
 
-    exceptions: list[cuqi.experimental.mcmc.Sampler], *optional*
+    exceptions: list[cuqi.sampler.Sampler], *optional*
         Samplers not to be recommended.
     
     Example
@@ -104,7 +104,7 @@ class SamplerRecommender(object):
 
         """
 
-        all_samplers = [(name, cls) for name, cls in inspect.getmembers(cuqi.experimental.mcmc, inspect.isclass) if issubclass(cls, cuqi.experimental.mcmc.Sampler)]
+        all_samplers = [(name, cls) for name, cls in inspect.getmembers(cuqi.sampler, inspect.isclass) if issubclass(cls, cuqi.sampler.Sampler)]
         valid_samplers = []
 
         for name, sampler in all_samplers:
@@ -116,7 +116,7 @@ class SamplerRecommender(object):
 
         # Need a separate case for HybridGibbs
         if self.valid_HybridGibbs_sampling_strategy() is not None:
-            valid_samplers += [cuqi.experimental.mcmc.HybridGibbs.__name__ if as_string else cuqi.experimental.mcmc.HybridGibbs]
+            valid_samplers += [cuqi.sampler.HybridGibbs.__name__ if as_string else cuqi.sampler.HybridGibbs]
 
         return valid_samplers
 

cuqi/geometry/__init__.py

@@ -16,6 +16,8 @@ from ._geometry import (
     StepExpansion
 )
 
+from ._product_geometry import _ProductGeometry
+
 
 # TODO: We will remove the use of identity geometries in the future
 _identity_geometries = [_DefaultGeometry1D, _DefaultGeometry2D, Continuous1D, Continuous2D, Discrete, Image2D]

cuqi/{experimental/geometry/_productgeometry.py → geometry/_product_geometry.py}

@@ -17,7 +17,7 @@ class _ProductGeometry(Geometry):
     .. code-block:: python
         import numpy as np
         from cuqi.geometry import Continuous1D, Discrete
-        from cuqi.experimental.geometry import _ProductGeometry
+        from cuqi.geometry import _ProductGeometry
         geometry1 = Continuous1D(np.linspace(0, 1, 100))
         geometry2 = Discrete(["sound_speed"])
         product_geometry = _ProductGeometry(geometry1, geometry2)

cuqi/implicitprior/__init__.py

@@ -1,5 +1,5 @@
 from ._regularizedGaussian import RegularizedGaussian, ConstrainedGaussian, NonnegativeGaussian
 from ._regularizedGMRF import RegularizedGMRF, ConstrainedGMRF, NonnegativeGMRF
 from ._regularizedUnboundedUniform import RegularizedUnboundedUniform
-from ._restorator import RestorationPrior, MoreauYoshidaPrior
+from ._restorator import RestorationPrior, MoreauYoshidaPrior, TweediePrior
 

cuqi/implicitprior/_restorator.py

@@ -232,4 +232,38 @@ class MoreauYoshidaPrior(Distribution):
         """ Returns the conditioning variables of the distribution. """
         # Currently conditioning variables are not supported for user-defined
         # distributions.
-        return []
+        return []
+
+class TweediePrior(MoreauYoshidaPrior):
+    """
+    Alias for MoreauYoshidaPrior following Tweedie's formula framework. TweediePrior 
+    defines priors where gradients are computed based on Tweedie's identity that links 
+    MMSE (Minimum Mean Square Error) denoisers with the underlying smoothed prior, see:
+        - Laumont et al. https://arxiv.org/abs/2103.04715 or https://doi.org/10.1137/21M1406349
+
+    Tweedie's Formula
+    -------------------------
+    In the context of denoising, Tweedie's identity states that for a signal x
+    corrupted by Gaussian noise:
+
+        ∇_x log p_e(x) = (D_e(x) - x) / e
+
+    where D_e(x) is the MMSE denoiser output and e is the noise variance.
+    This enables us to perform gradient-based sampling with algorithms like ULA.
+
+    At implementation level, TweediePrior shares identical functionality with MoreauYoshidaPrior. 
+    Thus, it is implemented as an alias of MoreauYoshidaPrior, meaning all methods, 
+    properties, and behavior are identical. The separate name provides clarity when 
+    working specifically with Tweedie's formula-based approaches.
+
+    Parameters
+    ----------
+    prior : RestorationPrior
+        Prior of the RestorationPrior type containing a denoiser/restorator.
+        
+    smoothing_strength : float, default=0.1
+        Corresponds to the noise variance e in Tweedie's formula context.
+
+    See MoreauYoshidaPrior for the underlying implementation with complete documentation.
+    """
+    pass

cuqi/legacy/__init__.py

@@ -0,0 +1,2 @@
+""" Legacy module for functionalities that are no longer supported or developed. """
+from . import sampler

cuqi/legacy/sampler/__init__.py

@@ -0,0 +1,11 @@
+from ._sampler import Sampler, ProposalBasedSampler
+from ._conjugate import Conjugate
+from ._conjugate_approx import ConjugateApprox
+from ._cwmh import CWMH
+from ._gibbs import Gibbs
+from ._hmc import NUTS
+from ._langevin_algorithm import ULA, MALA
+from ._laplace_approximation import UGLA
+from ._mh import MH
+from ._pcn import pCN
+from ._rto import LinearRTO, RegularizedLinearRTO

cuqi/legacy/sampler/_conjugate.py

@@ -0,0 +1,55 @@
+from cuqi.distribution import Posterior, Gaussian, Gamma, GMRF
+from cuqi.implicitprior import RegularizedGaussian, RegularizedGMRF
+import numpy as np
+
+class Conjugate: # TODO: Subclass from Sampler once updated
+    """ Conjugate sampler
+
+    Sampler for sampling a posterior distribution where the likelihood and prior are conjugate.
+
+    Currently supported conjugate pairs are:
+    - (Gaussian, Gamma)
+    - (GMRF, Gamma)
+    - (RegularizedGaussian, Gamma) with nonnegativity constraints only
+
+    For more information on conjugate pairs, see https://en.wikipedia.org/wiki/Conjugate_prior.
+
+    For implicit regularized Gaussians see:
+    
+    [1] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Bayesian inference with projected densities." SIAM/ASA Journal on Uncertainty Quantification 11.3 (2023): 1025-1043.
+
+    """
+
+    def __init__(self, target: Posterior):
+        if not isinstance(target.likelihood.distribution, (Gaussian, GMRF, RegularizedGaussian, RegularizedGMRF)):
+            raise ValueError("Conjugate sampler only works with a Gaussian-type likelihood function")
+        if not isinstance(target.prior, Gamma):
+            raise ValueError("Conjugate sampler only works with Gamma prior")
+        if not target.prior.dim == 1:
+            raise ValueError("Conjugate sampler only works with univariate Gamma prior")
+            
+        if isinstance(target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)) and (target.likelihood.distribution.preset["constraint"] not in ["nonnegativity"] or target.likelihood.distribution.preset["regularization"] is not None) :
+               raise ValueError("Conjugate sampler only works implicit regularized Gaussian likelihood with nonnegativity constraints")
+        
+        self.target = target
+
+    def step(self, x=None):
+        # Extract variables
+        b = self.target.likelihood.data                                 #mu
+        m = self._calc_m_for_Gaussians(b)                               #n
+        Ax = self.target.likelihood.distribution.mean                   #x_i
+        L = self.target.likelihood.distribution(np.array([1])).sqrtprec #L
+        alpha = self.target.prior.shape                                 #alpha
+        beta = self.target.prior.rate                                   #beta
+
+        # Create Gamma distribution and sample
+        dist = Gamma(shape=m/2+alpha,rate=.5*np.linalg.norm(L@(Ax-b))**2+beta)
+
+        return dist.sample()
+
+    def _calc_m_for_Gaussians(self, b):
+        """ Helper method to calculate m parameter for Gaussian-Gamma conjugate pair. """
+        if isinstance(self.target.likelihood.distribution, (Gaussian, GMRF)):
+            return len(b)
+        elif isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)):
+            return np.count_nonzero(b) # See 

cuqi/legacy/sampler/_conjugate_approx.py

@@ -0,0 +1,52 @@
+from cuqi.distribution import Posterior, LMRF, Gamma
+import numpy as np
+import scipy as sp
+
+class ConjugateApprox: # TODO: Subclass from Sampler once updated
+    """ Approximate Conjugate sampler
+
+    Sampler for sampling a posterior distribution where the likelihood and prior can be approximated
+    by a conjugate pair.
+
+    Currently supported pairs are:
+    - (LMRF, Gamma): Approximated by (Gaussian, Gamma)
+
+    For more information on conjugate pairs, see https://en.wikipedia.org/wiki/Conjugate_prior.
+
+    """
+
+    
+    def __init__(self, target: Posterior):
+        if not isinstance(target.likelihood.distribution, LMRF):
+            raise ValueError("Conjugate sampler only works with Laplace diff likelihood function")
+        if not isinstance(target.prior, Gamma):
+            raise ValueError("Conjugate sampler only works with Gamma prior")
+        self.target = target
+
+    def step(self, x=None):
+        # Extract variables
+        # Here we approximate the Laplace diff with a Gaussian
+
+        # Extract diff_op from target likelihood
+        D = self.target.likelihood.distribution._diff_op
+        n = D.shape[0]
+
+        # Gaussian approximation of LMRF prior as function of x_k
+        # See Uribe et al. (2022) for details
+        # Current has a zero mean assumption on likelihood! TODO
+        beta=1e-5
+        def Lk_fun(x_k):
+            dd =  1/np.sqrt((D @ x_k)**2 + beta*np.ones(n))
+            W = sp.sparse.diags(dd)
+            return W.sqrt() @ D
+
+        x = self.target.likelihood.data                 #x
+        d = len(x)                                      #d
+        Lx = Lk_fun(x)@x                                #Lx
+        alpha = self.target.prior.shape                 #alpha
+        beta = self.target.prior.rate                   #beta
+
+        # Create Gamma distribution and sample
+        dist = Gamma(shape=d+alpha, rate=np.linalg.norm(Lx)**2+beta)
+
+        return dist.sample()