CUQIpy 1.0.0.post0.dev384__tar.gz → 1.0.0.post0.dev420__tar.gz

{cuqipy-1.0.0.post0.dev384 → cuqipy-1.0.0.post0.dev420}/CUQIpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.0.0.post0.dev384
+Version: 1.0.0.post0.dev420
 Summary: Computational Uncertainty Quantification for Inverse problems in Python
 Maintainer-email: "Nicolai A. B. Riis" <nabr@dtu.dk>, "Jakob S. Jørgensen" <jakj@dtu.dk>, "Amal M. Alghamdi" <amaal@dtu.dk>, Chao Zhang <chaz@dtu.dk>
 License:                                  Apache License

{cuqipy-1.0.0.post0.dev384 → cuqipy-1.0.0.post0.dev420}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.0.0.post0.dev384
+Version: 1.0.0.post0.dev420
 Summary: Computational Uncertainty Quantification for Inverse problems in Python
 Maintainer-email: "Nicolai A. B. Riis" <nabr@dtu.dk>, "Jakob S. Jørgensen" <jakj@dtu.dk>, "Amal M. Alghamdi" <amaal@dtu.dk>, Chao Zhang <chaz@dtu.dk>
 License:                                  Apache License

{cuqipy-1.0.0.post0.dev384 → cuqipy-1.0.0.post0.dev420}/cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-07-05T09:29:07+0200",
+ "date": "2024-07-05T09:58:51+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "3e3d762fab019f39257708bb9cdf5abc3681f196",
- "version": "1.0.0.post0.dev384"
+ "full-revisionid": "c77d3deee70affd3a987b7a639bd576c4fe3896a",
+ "version": "1.0.0.post0.dev420"
 }
 '''  # END VERSION_JSON
 

{cuqipy-1.0.0.post0.dev384 → cuqipy-1.0.0.post0.dev420}/cuqi/distribution/_custom.py

@@ -50,13 +50,13 @@ class UserDefinedDistribution(Distribution):
         if self.logpdf_func is not None:
             return self.logpdf_func(x)
         else:
-            raise Exception("logpdf_func is not defined.")
+            raise NotImplementedError("logpdf_func is not defined.")
     
     def _gradient(self, x):
         if self.gradient_func is not None:
             return self.gradient_func(x)
         else:
-            raise Exception("gradient_func is not defined.")
+            raise NotImplementedError("gradient_func is not defined.")
 
     def _sample(self, N=1, rng=None):
         #TODO(nabr) allow sampling more than 1 sample and potentially rng?

cuqipy-1.0.0.post0.dev420/cuqi/experimental/mcmc/_conjugate.py

@@ -0,0 +1,197 @@
+import numpy as np
+from abc import ABC, abstractmethod
+import math
+from cuqi.experimental.mcmc import SamplerNew
+from cuqi.distribution import Posterior, Gaussian, Gamma, GMRF
+from cuqi.implicitprior import RegularizedGaussian, RegularizedGMRF
+from cuqi.utilities import get_non_default_args
+
+class ConjugateNew(SamplerNew):
+    """ Conjugate sampler
+
+    Sampler for sampling a posterior distribution which is a so-called "conjugate" distribution, i.e., where the likelihood and prior are conjugate to each other - denoted as a conjugate pair.   
+
+    Currently supported conjugate pairs are:
+    - (Gaussian, Gamma) where Gamma is defined on the precision parameter of the Gaussian
+    - (GMRF, Gamma) where Gamma is defined on the precision parameter of the GMRF
+    - (RegularizedGaussian, Gamma) with nonnegativity constraints only and Gamma is defined on the precision parameter of the RegularizedGaussian
+    - (RegularizedGMRF, Gamma) with nonnegativity constraints only and Gamma is defined on the precision parameter of the RegularizedGMRF
+
+    Currently the Gamma distribution must be univariate.
+
+    A conjugate pair defines implicitly a so-called conjugate distribution which can be sampled from directly.
+
+    The conjugate parameter is the parameter that both the likelihood and prior PDF depend on.
+
+    For more information on conjugacy and conjugate distributions 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 _initialize(self):
+        pass
+
+    @SamplerNew.target.setter # Overwrite the target setter to set the conjugate pair
+    def target(self, value):
+        """ Set the target density. Runs validation of the target. """
+        self._target = value
+        if self._target is not None:
+            self._set_conjugatepair()
+            self.validate_target()
+
+    def validate_target(self):
+        self._ensure_target_is_posterior()
+        self._conjugatepair.validate_target()
+        
+    def step(self):
+        self.current_point = self._conjugatepair.sample()
+        return 1 # Returns acceptance rate of 1
+
+    def tune(self, skip_len, update_count):
+        pass # No tuning required for conjugate sampler
+
+    def _ensure_target_is_posterior(self):
+        """ Ensure that the target is a Posterior distribution. """
+        if not isinstance(self.target, Posterior):
+            raise TypeError("Conjugate sampler requires a target of type Posterior")
+
+    def _set_conjugatepair(self):
+        """ Set the conjugate pair based on the likelihood and prior. This requires target to be set. """
+        self._ensure_target_is_posterior()
+        if isinstance(self.target.likelihood.distribution, (Gaussian, GMRF)) and isinstance(self.target.prior, Gamma):
+            self._conjugatepair = _GaussianGammaPair(self.target)
+        elif isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)) and isinstance(self.target.prior, Gamma):
+            self._conjugatepair = _RegularizedGaussianGammaPair(self.target)
+        else:
+            raise ValueError(f"Conjugacy is not defined for likelihood {type(self.target.likelihood.distribution)} and prior {type(self.target.prior)}, in CUQIpy")
+
+    def __repr__(self):
+        msg = super().__repr__()
+        if hasattr(self, "_conjugatepair"):
+            msg += f"\n Conjugate pair:\n\t {type(self._conjugatepair).__name__.removeprefix('_')}"
+        return msg
+        
+class _ConjugatePair(ABC):
+    """ Abstract base class for conjugate pairs (likelihood, prior) used in the Conjugate sampler. """
+
+    def __init__(self, target):
+        self.target = target
+
+    @abstractmethod
+    def validate_target(self):
+        """ Validate the target distribution for the conjugate pair. """
+        pass
+
+    @abstractmethod
+    def sample(self):
+        """ Sample from the conjugate distribution. """
+        pass
+
+
+class _GaussianGammaPair(_ConjugatePair):
+    """ Implementation for the Gaussian-Gamma conjugate pair."""
+
+    def validate_target(self):
+        if not isinstance(self.target.likelihood.distribution, (Gaussian, GMRF)):
+            raise ValueError("Conjugate sampler only works with a Gaussian likelihood function")
+
+        if not isinstance(self.target.prior, Gamma):
+            raise ValueError("Conjugate sampler only works with Gamma prior")
+
+        if self.target.prior.dim != 1:
+            raise ValueError("Conjugate sampler only works with univariate Gamma prior")
+
+        key, value = _get_conjugate_parameter(self.target)
+        if key == "cov":
+            if not _check_conjugate_parameter_is_scalar_reciprocal(value):
+                raise ValueError("Gaussian-Gamma conjugate pair defined via covariance requires `cov` for the `Gaussian` to be: lambda x : 1.0/x for the conjugate parameter")
+        elif key == "prec":
+            if not _check_conjugate_parameter_is_scalar_identity(value):
+                raise ValueError("Gaussian-Gamma conjugate pair defined via precision requires `prec` for the `Gaussian` to be: lambda x : x for the conjugate parameter")
+        else:
+            raise ValueError("Conjugate sampler for Gaussian likelihood functions only works when conjugate parameter is defined via covariance or precision")
+
+    def sample(self):
+        # Extract variables
+        b = self.target.likelihood.data                                 # mu
+        m = len(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()
+
+
+class _RegularizedGaussianGammaPair(_ConjugatePair):
+    """Implementation for the Regularized Gaussian-Gamma conjugate pair."""
+
+    def validate_target(self):
+        if not isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)):
+            raise ValueError("Conjugate sampler only works with a Regularized Gaussian likelihood function")
+
+        if not isinstance(self.target.prior, Gamma):
+            raise ValueError("Conjugate sampler only works with Gamma prior")
+
+        if self.target.prior.dim != 1:
+            raise ValueError("Conjugate sampler only works with univariate Gamma prior")
+
+        if self.target.likelihood.distribution.preset not in ["nonnegativity"]:
+            raise ValueError("Conjugate sampler only works with implicit regularized Gaussian likelihood with nonnegativity constraints")
+
+        key, value = _get_conjugate_parameter(self.target)
+        if key == "cov":
+            if not _check_conjugate_parameter_is_scalar_reciprocal(value):
+                raise ValueError("Regularized Gaussian-Gamma conjugate pair defined via covariance requires cov: lambda x : 1.0/x for the conjugate parameter")
+        elif key == "prec":
+            if not _check_conjugate_parameter_is_scalar_identity(value):
+                raise ValueError("Regularized Gaussian-Gamma conjugate pair defined via precision requires prec: lambda x : x for the conjugate parameter")
+        else:
+            raise ValueError("Conjugate sampler for a Regularized Gaussian likelihood functions only works when conjugate parameter is defined via covariance or precision")
+
+    def sample(self):
+        # Extract variables
+        b = self.target.likelihood.data                                 # mu
+        m = np.count_nonzero(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 _get_conjugate_parameter(target):
+    """Extract the conjugate parameter name (e.g. d), and returns the mutable variable that is defined by the conjugate parameter, e.g. cov and its value e.g. lambda d:1/d"""
+    par_name = target.prior.name
+    mutable_likelihood_vars  = target.likelihood.distribution.get_mutable_variables()
+
+    found_parameter_pairs = []
+
+    for var_key in mutable_likelihood_vars:
+        attr = getattr(target.likelihood.distribution, var_key)
+        if callable(attr) and par_name in get_non_default_args(attr):
+            found_parameter_pairs.append((var_key, attr))
+    if len(found_parameter_pairs) == 1:
+        return found_parameter_pairs[0]
+    elif len(found_parameter_pairs) > 1:
+        raise ValueError(f"Multiple references of parameter {par_name} found in likelihood function for conjugate sampler with target {target}. This is not supported.")
+    else:
+        raise ValueError(f"Unable to find conjugate parameter {par_name} in likelihood function for conjugate sampler with target {target}")
+
+def _check_conjugate_parameter_is_scalar_identity(f):
+    """Tests whether a function (scalar to scalar) is the identity (lambda x: x)."""
+    test_values = [1.0, 10.0, 100.0]
+    return all(np.allclose(f(x), x) for x in test_values)
+
+def _check_conjugate_parameter_is_scalar_reciprocal(f):
+    """Tests whether a function (scalar to scalar) is the reciprocal (lambda x : 1.0/x)."""
+    return all(math.isclose(f(x), 1.0 / x) for x in [1.0, 10.0, 100.0])

{cuqipy-1.0.0.post0.dev384 → cuqipy-1.0.0.post0.dev420}/cuqi/experimental/mcmc/_conjugate_approx.py

@@ -1,9 +1,10 @@
 import numpy as np
-from cuqi.experimental.mcmc import SamplerNew
-from cuqi.distribution import Posterior, LMRF, Gamma
+from cuqi.experimental.mcmc import ConjugateNew
+from cuqi.experimental.mcmc._conjugate import _ConjugatePair, _get_conjugate_parameter, _check_conjugate_parameter_is_scalar_reciprocal
+from cuqi.distribution import LMRF, Gamma
 import scipy as sp
 
-class ConjugateApproxNew(SamplerNew):
+class ConjugateApproxNew(ConjugateNew):
     """ Approximate Conjugate sampler
 
     Sampler for sampling a posterior distribution where the likelihood and prior can be approximated
@@ -16,26 +17,27 @@ class ConjugateApproxNew(SamplerNew):
 
     LMRF likelihood must have zero mean.
 
-    Currently, the sampler does NOT automatically check that the conjugate distributions are defined on the correct parameters.
-
-
-    For more information on conjugate pairs, see https://en.wikipedia.org/wiki/Conjugate_prior.
+    For more details on conjugacy see :class:`ConjugateNew`.
 
     """
 
-    def _initialize(self):
-        pass
+    def _set_conjugatepair(self):
+        """ Set the conjugate pair based on the likelihood and prior. This requires target to be set. """
+        if isinstance(self.target.likelihood.distribution, LMRF) and isinstance(self.target.prior, Gamma):
+            self._conjugatepair = _LMRFGammaPair(self.target)
+        else:
+            raise ValueError(f"Conjugacy is not defined for likelihood {type(self.target.likelihood.distribution)} and prior {type(self.target.prior)}, in CUQIpy")
 
-    def validate_target(self):
 
-        if not isinstance(self.target, Posterior):
-            raise TypeError("Approximate conjugate sampler requires a target of type Posterior")
+class _LMRFGammaPair(_ConjugatePair):
+    """ Implementation of the conjugate pair (LMRF, Gamma) """
 
+    def validate_target(self):
         if not isinstance(self.target.likelihood.distribution, LMRF):
             raise ValueError("Approximate conjugate sampler only works with LMRF likelihood function")
         
         if not isinstance(self.target.prior, Gamma):
-            raise ValueError("Approximate conjugate sampler only works with Gamma prior")
+            raise ValueError("Approximate conjugate sampler with LMRF likelihood only works with Gamma prior")
         
         if not self.target.prior.dim == 1:
             raise ValueError("Approximate conjugate sampler only works with univariate Gamma prior")
@@ -43,7 +45,14 @@ class ConjugateApproxNew(SamplerNew):
         if np.sum(self.target.likelihood.distribution.location) != 0:
             raise ValueError("Approximate conjugate sampler only works with zero mean LMRF likelihood")
         
-    def step(self):
+        key, value = _get_conjugate_parameter(self.target)
+        if key == "scale":
+            if not _check_conjugate_parameter_is_scalar_reciprocal(value):
+                raise ValueError("Approximate conjugate sampler only works with Gamma prior on the inverse of the scale parameter of the LMRF likelihood")
+        else:
+            raise ValueError(f"No approximate conjugacy defined for likelihood {type(self.target.likelihood.distribution)} and prior {type(self.target.prior)}, in CUQIpy")
+        
+    def sample(self):
         # Extract variables
         # Here we approximate the LMRF with a Gaussian
 
@@ -69,7 +78,4 @@ class ConjugateApproxNew(SamplerNew):
         # Create Gamma distribution and sample
         dist = Gamma(shape=d+alpha, rate=np.linalg.norm(Lx)**2+beta)
 
-        self.current_point = dist.sample()
-
-    def tune(self, skip_len, update_count):
-        pass
+        return dist.sample()

{cuqipy-1.0.0.post0.dev384 → cuqipy-1.0.0.post0.dev420}/cuqi/experimental/mcmc/_direct.py

@@ -23,6 +23,7 @@ class DirectNew(SamplerNew):
         
     def step(self):
         self.current_point = self.target.sample()
+        return 1 # Returns acceptance rate of 1
 
     def tune(self, skip_len, update_count):
         pass     

{cuqipy-1.0.0.post0.dev384 → cuqipy-1.0.0.post0.dev420}/cuqi/problem/_problem.py

@@ -710,8 +710,7 @@ class BayesianProblem(object):
         # Require gradient?
         if must_have_gradient:
             try: 
-                posterior.prior.gradient(np.zeros(posterior.prior.dim))
-                posterior.likelihood.gradient(np.zeros(posterior.likelihood.dim))
+                posterior.posterior.gradient(np.zeros(posterior.posterior.dim))
                 G = True
             except (NotImplementedError, AttributeError):
                 G = False

cuqipy-1.0.0.post0.dev384/cuqi/experimental/mcmc/_conjugate.py

@@ -1,77 +0,0 @@
-import numpy as np
-from cuqi.experimental.mcmc import SamplerNew
-from cuqi.distribution import Posterior, Gaussian, Gamma, GMRF
-from cuqi.implicitprior import RegularizedGaussian, RegularizedGMRF
-
-class ConjugateNew(SamplerNew):
-    """ Conjugate sampler
-
-    Sampler for sampling a posterior distribution where the likelihood and prior are conjugate.
-
-    Currently supported conjugate pairs are:
-    - (Gaussian, Gamma) where Gamma is defined on the precision parameter of the Gaussian
-    - (GMRF, Gamma) where Gamma is defined on the precision parameter of the GMRF
-    - (RegularizedGaussian, Gamma) with nonnegativity constraints only and Gamma is defined on the precision parameter of the RegularizedGaussian
-    - (RegularizedGMRF, Gamma) with nonnegativity constraints only and Gamma is defined on the precision parameter of the RegularizedGMRF
-
-    Gamma distribution must be univariate.
-
-    Currently, the sampler does NOT automatically check that the conjugate distributions are defined on the correct parameters.
-
-    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 _initialize(self):
-        pass
-
-    def validate_target(self):
-
-        if not isinstance(self.target, Posterior):
-            raise TypeError("Conjugate sampler requires a target of type Posterior")
-
-        if not isinstance(self.target.likelihood.distribution, (Gaussian, GMRF, RegularizedGaussian, RegularizedGMRF)):
-            raise ValueError("Conjugate sampler only works with a Gaussian-type likelihood function")
-        
-        if not isinstance(self.target.prior, Gamma):
-            raise ValueError("Conjugate sampler only works with Gamma prior")
-        
-        if not self.target.prior.dim == 1:
-            raise ValueError("Conjugate sampler only works with univariate Gamma prior")
-        
-        if isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)) and self.target.likelihood.distribution.preset not in ["nonnegativity"]:
-            raise ValueError("Conjugate sampler only works with implicit regularized Gaussian likelihood with nonnegativity constraints")
-
-    def step(self):
-        # 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)
-
-        self.current_point = dist.sample()
-
-    def tune(self, skip_len, update_count):
-        pass
-
-    def _calc_m_for_Gaussians(self, b):
-        """ Helper method to calculate m parameter for Gaussian-Gamma conjugate pair.
-         
-        Classically m defines the number of observations in the Gaussian likelihood function.
-
-        However, for implicit regularized Gaussians, m is the number of non-zero elements in the data vector b see [1].
-           
-        """
-
-        if isinstance(self.target.likelihood.distribution, (Gaussian, GMRF)):
-            return len(b)
-        elif isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)):
-            return np.count_nonzero(b)