CUQIpy 1.2.0.post0.dev446__tar.gz → 1.2.0.post0.dev501__tar.gz

{cuqipy-1.2.0.post0.dev446 → cuqipy-1.2.0.post0.dev501}/CUQIpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: CUQIpy
-Version: 1.2.0.post0.dev446
+Version: 1.2.0.post0.dev501
 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.2.0.post0.dev446 → cuqipy-1.2.0.post0.dev501}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: CUQIpy
-Version: 1.2.0.post0.dev446
+Version: 1.2.0.post0.dev501
 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.2.0.post0.dev446 → cuqipy-1.2.0.post0.dev501}/cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-01-20T14:37:50+0100",
+ "date": "2025-01-30T19:07:50+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "04ade2ac5f81fefc462cb802ec723be5f10e0f0a",
- "version": "1.2.0.post0.dev446"
+ "full-revisionid": "ead079a625cad175f6a0159d46c90d7cdf80bc0f",
+ "version": "1.2.0.post0.dev501"
 }
 '''  # END VERSION_JSON
 

{cuqipy-1.2.0.post0.dev446 → cuqipy-1.2.0.post0.dev501}/cuqi/distribution/_modifiedhalfnormal.py

@@ -24,13 +24,13 @@ class ModifiedHalfNormal(Distribution):
     
     Parameters
     ----------
-    alpha : float
+    alpha : float or array_like
         The polynomial exponent parameter :math:`\\alpha` of the MHN distribution. Must be positive.
 
-    beta : float
+    beta : float or array_like
         The quadratic exponential parameter :math:`\\beta` of the MHN distribution. Must be positive.
 
-    gamma : float
+    gamma : float or array_like
         The linear exponential parameter :math:`\\gamma` of the MHN distribution.
 
     """
@@ -38,9 +38,9 @@ class ModifiedHalfNormal(Distribution):
         # Init from abstract distribution class
         super().__init__(is_symmetric=is_symmetric, **kwargs) 
 
-        self._alpha = alpha
-        self._beta = beta
-        self._gamma = gamma
+        self.alpha = alpha
+        self.beta = beta
+        self.gamma = gamma
 
     @property
     def alpha(self):
@@ -48,13 +48,13 @@ class ModifiedHalfNormal(Distribution):
         return self._alpha
     
     @alpha.setter
-    def shape(self, value):
-        self._shape = force_ndarray(value, flatten=True)
+    def alpha(self, value):
+        self._alpha = force_ndarray(value, flatten=True)
 
     @property
     def beta(self):
         """ The quadratic exponential parameter of the MHN distribution. Must be positive. """
-        return self._alpha
+        return self._beta
     
     @beta.setter
     def beta(self, value):
@@ -63,7 +63,7 @@ class ModifiedHalfNormal(Distribution):
     @property
     def gamma(self):
         """ The linear exponential parameter of the MHN distribution. """
-        return self._alpha
+        return self._gamma
     
     @gamma.setter
     def gamma(self, value):
@@ -78,11 +78,8 @@ class ModifiedHalfNormal(Distribution):
         return (self.alpha - 1)/val - 2*self.beta*val + self.gamma
 
     def _gradient(self, val, *args, **kwargs):
-        if hasattr(self.alpha, '__iter__'):
-            return np.array([self._gradient_scalar(v) for v in val])
-        else:
-            return np.array([self.dim*[self._gradient_scalar(v)] for v in val])
-    
+        return np.array([self._gradient_scalar(v) for v in val])
+
     def _MHN_sample_gamma_proposal(self, alpha, beta, gamma, rng, delta=None):
         """
             Sample from a modified half-normal distribution using a Gamma distribution proposal.
@@ -180,7 +177,7 @@ class ModifiedHalfNormal(Distribution):
 
     def _sample(self, N, rng=None):
         if hasattr(self.alpha, '__getitem__'):
-            return np.array([self._MHN_sample(self.alpha[i], self.beta[i], self.gamma[i], rng=rng) for i in range(N)])
+            return np.array([[self._MHN_sample(self.alpha[i], self.beta[i], self.gamma[i], rng=rng) for i in range(len(self.alpha))] for _ in range(N)])
         else:
             return np.array([self._MHN_sample(self.alpha, self.beta, self.gamma, rng=rng) for i in range(N)])
 

cuqipy-1.2.0.post0.dev501/cuqi/experimental/__init__.py

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

{cuqipy-1.2.0.post0.dev446 → cuqipy-1.2.0.post0.dev501}/cuqi/experimental/algebra/_randomvariable.py

@@ -6,6 +6,8 @@ import operator
 import cuqi
 from cuqi.distribution import Distribution
 from copy import copy, deepcopy
+import numpy as np
+
 
 class RandomVariable:
     """ Random variable defined by a distribution with the option to apply algebraic operations on it.
@@ -165,6 +167,30 @@ class RandomVariable:
             raise ValueError(f"Expected arguments {self.parameter_names}, got arguments {kwargs}")
 
         return self.tree(**kwargs)
+
+    def sample(self, N=1):
+        """ Sample from the random variable. 
+
+        Parameters
+        ----------
+        N : int, optional
+            Number of samples to draw. Default is 1.
+        """
+
+        if self.is_cond:
+            raise NotImplementedError(
+                "Unable to directly sample from a random variable that has distributions with "
+                "conditioning variables. This is not implemented."
+            )
+
+        if N == 1: return self(**{dist.name: dist.sample() for dist in self.distributions})
+            
+        samples = np.array([
+            self(**{dist.name: dist.sample() for dist in self.distributions})
+            for _ in range(N)
+        ]).reshape(-1, N)  # Ensure correct shape (dim, N)
+
+        return cuqi.samples.Samples(samples)
     
     @property
     def tree(self):

cuqipy-1.2.0.post0.dev501/cuqi/experimental/mcmc/_conjugate.py

@@ -0,0 +1,335 @@
+import numpy as np
+from abc import ABC, abstractmethod
+import math
+from cuqi.experimental.mcmc import Sampler
+from cuqi.distribution import Posterior, Gaussian, Gamma, GMRF, ModifiedHalfNormal
+from cuqi.implicitprior import RegularizedGaussian, RegularizedGMRF, RegularizedUnboundedUniform
+from cuqi.utilities import get_non_default_args, count_nonzero, count_constant_components_1D, count_constant_components_2D
+from cuqi.geometry import Continuous1D, Continuous2D, Image2D
+
+class Conjugate(Sampler):
+    """ 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 preset constraints only and Gamma is defined on the precision parameter of the RegularizedGaussian
+    - (RegularizedGMRF, Gamma) with preset constraints only and Gamma is defined on the precision parameter of the RegularizedGMRF
+    - (RegularizedGaussian, ModifiedHalfNormal) with preset constraints and regularization only
+    - (RegularizedGMRF, ModifiedHalfNormal) with preset constraints and regularization only
+
+    Currently the Gamma and ModifiedHalfNormal 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 and the corresponding conjugacy relations, see:
+    
+    Section 3.3 from [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.
+    Section 4 from [2] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Sparse Bayesian inference with regularized Gaussian distributions." Inverse Problems 39.11 (2023): 115004.
+
+    """
+
+    def _initialize(self):
+        pass
+
+    @Sampler.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, RegularizedUnboundedUniform) and isinstance(self.target.prior, Gamma):
+            # Check RegularizedUnboundedUniform before RegularizedGaussian and RegularizedGMRF due to the first inheriting from the second.
+            self._conjugatepair = _RegularizedUnboundedUniformGammaPair(self.target)
+        elif isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)) and isinstance(self.target.prior, Gamma):
+            self._conjugatepair = _RegularizedGaussianGammaPair(self.target)
+        elif isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)) and isinstance(self.target.prior, ModifiedHalfNormal):
+            self._conjugatepair = _RegularizedGaussianModifiedHalfNormalPair(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 conjugate_distribution(self):
+        return self._conjugatepair.conjugate_distribution()
+
+    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 conjugate_distribution(self):
+        """ Returns the posterior distribution in the form of a CUQIpy distribution """
+        pass
+
+    def sample(self):
+        """ Sample from the conjugate distribution. """
+        return self.conjugate_distribution().sample()
+
+
+class _GaussianGammaPair(_ConjugatePair):
+    """ Implementation for the Gaussian-Gamma conjugate pair."""
+
+    def validate_target(self):
+        if self.target.prior.dim != 1:
+            raise ValueError("Gaussian-Gamma conjugacy only works with univariate Gamma prior")
+
+        key_value_pairs = _get_conjugate_parameter(self.target)
+        if len(key_value_pairs) != 1:
+            raise ValueError(f"Multiple references to conjugate parameter {self.target.prior.name} found in likelihood. Only one occurance is supported.")
+        for key, value in key_value_pairs:
+            if key == "cov":
+                if not _check_conjugate_parameter_is_scalar_linear_reciprocal(value):
+                    raise ValueError("Gaussian-Gamma conjugate pair defined via covariance requires cov: lambda x : s/x for the conjugate parameter")
+            elif key == "prec":
+                if not _check_conjugate_parameter_is_scalar_linear(value):
+                    raise ValueError("Gaussian-Gamma conjugate pair defined via precision requires prec: lambda x : s*x for the conjugate parameter")
+            else:
+                raise ValueError(f"RegularizedGaussian-ModifiedHalfNormal conjugacy does not support the conjugate parameter {self.target.prior.name} in the {key} attribute. Only cov and prec")
+
+    def conjugate_distribution(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
+        return Gamma(shape=m/2 + alpha, rate=.5 * np.linalg.norm(L @ (Ax - b))**2 + beta)
+
+
+class _RegularizedGaussianGammaPair(_ConjugatePair):
+    """Implementation for the Regularized Gaussian-Gamma conjugate pair using the conjugacy rules from [1], Section 3.3."""
+
+    def validate_target(self):
+        if self.target.prior.dim != 1:
+            raise ValueError("RegularizedGaussian-Gamma conjugacy only works with univariate ModifiedHalfNormal prior")
+
+        if self.target.likelihood.distribution.preset not in ["nonnegativity"]:
+            raise ValueError("RegularizedGaussian-Gamma conjugacy only works with implicit regularized Gaussian likelihood with nonnegativity constraints")
+
+        key_value_pairs = _get_conjugate_parameter(self.target)
+        if len(key_value_pairs) != 1:
+            raise ValueError(f"Multiple references to conjugate parameter {self.target.prior.name} found in likelihood. Only one occurance is supported.")
+        for key, value in key_value_pairs:
+            if key == "cov":
+                if not _check_conjugate_parameter_is_scalar_linear_reciprocal(value):
+                    raise ValueError("Regularized Gaussian-Gamma conjugacy defined via covariance requires cov: lambda x : s/x for the conjugate parameter")
+            elif key == "prec":
+                if not _check_conjugate_parameter_is_scalar_linear(value):
+                    raise ValueError("Regularized Gaussian-Gamma conjugacy defined via precision requires prec: lambda x : s*x for the conjugate parameter")
+            else:
+                raise ValueError(f"RegularizedGaussian-ModifiedHalfNormal conjugacy does not support the conjugate parameter {self.target.prior.name} in the {key} attribute. Only cov and prec")
+
+    def conjugate_distribution(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
+        return Gamma(shape=m/2 + alpha, rate=.5 * np.linalg.norm(L @ (Ax - b))**2 + beta)
+    
+    
+class _RegularizedUnboundedUniformGammaPair(_ConjugatePair):
+    """Implementation for the RegularizedUnboundedUniform-ModifiedHalfNormal conjugate pair using the conjugacy rules from [2], Section 4."""
+
+    def validate_target(self):
+        if self.target.prior.dim != 1:
+            raise ValueError("RegularizedUnboundedUniform-Gamma conjugacy only works with univariate Gamma prior")
+        
+        if self.target.likelihood.distribution.preset not in ["l1", "tv"]:
+            raise ValueError("RegularizedUnboundedUniform-Gamma conjugacy only works with implicit regularized Gaussian likelihood with l1 or tv regularization")
+        
+        key_value_pairs = _get_conjugate_parameter(self.target)
+        if len(key_value_pairs) != 1:
+            raise ValueError(f"Multiple references to conjugate parameter {self.target.prior.name} found in likelihood. Only one occurance is supported.")
+        for key, value in key_value_pairs:
+            if key == "strength":
+                if not _check_conjugate_parameter_is_scalar_linear(value):
+                    raise ValueError("RegularizedUnboundedUniform-Gamma conjugacy defined via strength requires strength: lambda x : s*x for the conjugate parameter")
+            else:
+                raise ValueError(f"RegularizedUnboundedUniform-Gamma conjugacy does not support the conjugate parameter {self.target.prior.name} in the {key} attribute. Only strength is supported")
+
+    def conjugate_distribution(self):
+        # Extract prior variables
+        alpha = self.target.prior.shape
+        beta = self.target.prior.rate
+
+        # Compute likelihood quantities
+        x = self.target.likelihood.data
+        if self.target.likelihood.distribution.preset == "l1":
+            m = count_nonzero(x)
+        elif self.target.likelihood.distribution.preset == "tv" and isinstance(self.target.likelihood.distribution.geometry, Continuous1D):
+            m = count_constant_components_1D(x)
+        elif self.target.likelihood.distribution.preset == "tv" and isinstance(self.target.likelihood.distribution.geometry, (Continuous2D, Image2D)):
+            m = count_constant_components_2D(self.target.likelihood.distribution.geometry.par2fun(x))
+
+        reg_op = self.target.likelihood.distribution._regularization_oper
+        reg_strength = self.target.likelihood.distribution(np.array([1])).strength
+        fx = reg_strength*np.linalg.norm(reg_op@x, ord = 1)
+
+        # Create Gamma distribution
+        return Gamma(shape=m/2 + alpha, rate=fx + beta)
+    
+class _RegularizedGaussianModifiedHalfNormalPair(_ConjugatePair):
+    """Implementation for the Regularized Gaussian-ModifiedHalfNormal conjugate pair using the conjugacy rules from [2], Section 4."""
+
+    def validate_target(self):
+        if self.target.prior.dim != 1:
+            raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy only works with univariate ModifiedHalfNormal prior")
+        
+        if self.target.likelihood.distribution.preset not in ["l1", "tv"]:
+            raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy only works with implicit regularized Gaussian likelihood with l1 or tv regularization")
+
+        key_value_pairs = _get_conjugate_parameter(self.target)
+        if len(key_value_pairs) != 2:
+            raise ValueError(f"Incorrect number of references to conjugate parameter {self.target.prior.name} found in likelihood. Found {len(key_value_pairs)} times, but needs to occur in prec or cov, and in strength")
+        for key, value in key_value_pairs:
+            if key == "strength":
+                if not _check_conjugate_parameter_is_scalar_linear(value):
+                    raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy defined via strength requires strength: lambda x : s*x for the conjugate parameter")
+            elif key == "prec":
+                if not _check_conjugate_parameter_is_scalar_quadratic(value):
+                    raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy defined via precision requires prec: lambda x : s*x for the conjugate parameter")
+            elif key == "cov":
+                if not _check_conjugate_parameter_is_scalar_quadratic_reciprocal(value):
+                    raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy  defined via covariance requires cov: lambda x : s/x for the conjugate parameter")
+            else:
+                raise ValueError(f"RegularizedGaussian-ModifiedHalfNormal conjugacy does not support the conjugate parameter {self.target.prior.name} in the {key} attribute. Only cov, prec and strength are supported")
+
+
+    def conjugate_distribution(self):
+        # Extract prior variables
+        alpha = self.target.prior.alpha
+        beta = self.target.prior.beta
+        gamma = self.target.prior.gamma
+
+        # Compute likelihood variables
+        x = self.target.likelihood.data
+        mu = self.target.likelihood.distribution.mean
+        L = self.target.likelihood.distribution(np.array([1])).sqrtprec
+
+        if self.target.likelihood.distribution.preset == "l1":
+            m = count_nonzero(x)
+        elif self.target.likelihood.distribution.preset == "tv" and isinstance(self.target.likelihood.distribution.geometry, Continuous1D):
+            m = count_constant_components_1D(x)
+        elif self.target.likelihood.distribution.preset == "tv" and isinstance(self.target.likelihood.distribution.geometry, (Continuous2D, Image2D)):
+            m = count_constant_components_2D(self.target.likelihood.distribution.geometry.par2fun(x))
+
+        reg_op = self.target.likelihood.distribution._regularization_oper
+        reg_strength = self.target.likelihood.distribution(np.array([1])).strength
+        fx = reg_strength*np.linalg.norm(reg_op@x, ord = 1)
+
+        # Compute parameters of conjugate distribution
+        conj_alpha = m + alpha
+        conj_beta = 0.5*np.linalg.norm(L @ (mu - x))**2 + beta
+        conj_gamma = -fx + gamma
+
+        # Create conjugate distribution
+        return ModifiedHalfNormal(conj_alpha, conj_beta, conj_gamma)
+    
+
+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) == 0:
+        raise ValueError(f"Unable to find conjugate parameter {par_name} in likelihood function for conjugate sampler with target {target}")
+    return found_parameter_pairs
+
+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])
+
+def _check_conjugate_parameter_is_scalar_linear(f):
+    """
+        Tests whether a function (scalar to scalar) is linear (lambda x: s*x for some s).
+        The tests checks whether the function is zero and some finite differences are constant.
+    """
+    test_values = [1.0, 10.0, 100.0]
+    h = 1e-2
+    finite_diffs = [(f(x + h*x)-f(x))/(h*x) for x in test_values]
+    return np.isclose(f(0.0), 0.0) and all(np.allclose(c, finite_diffs[0]) for c in finite_diffs[1:])
+
+def _check_conjugate_parameter_is_scalar_linear_reciprocal(f):
+    """
+        Tests whether a function (scalar to scalar) is a constant times the inverse of the input (lambda x: s/x for some s).
+        The tests checks whether the the reciprocal of the function has constant finite differences.
+    """
+    g = lambda x : 1.0/f(x)
+    test_values = [1.0, 10.0, 100.0]
+    h = 1e-2
+    finite_diffs = [(g(x + h*x)-g(x))/(h*x) for x in test_values]
+    return all(np.allclose(c, finite_diffs[0]) for c in finite_diffs[1:])
+
+def _check_conjugate_parameter_is_scalar_quadratic(f):
+    """
+        Tests whether a function (scalar to scalar) is linear (lambda x: s*x**2 for some s).
+        The tests checks whether the function divided by the parameter is linear
+    """
+    return _check_conjugate_parameter_is_scalar_linear(lambda x: f(x)/x if x != 0.0 else f(0.0))
+
+def _check_conjugate_parameter_is_scalar_quadratic_reciprocal(f):
+    """
+        Tests whether a function (scalar to scalar) is linear (lambda x: s*x**-2 for some s).
+        The tests checks whether the function divided by the parameter is the reciprical of a linear function.
+    """
+    return _check_conjugate_parameter_is_scalar_linear_reciprocal(lambda x: f(x)/x)

{cuqipy-1.2.0.post0.dev446 → cuqipy-1.2.0.post0.dev501}/cuqi/experimental/mcmc/_conjugate_approx.py

@@ -33,26 +33,23 @@ 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 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")
         
         if np.sum(self.target.likelihood.distribution.location) != 0:
             raise ValueError("Approximate conjugate sampler only works with zero mean LMRF likelihood")
         
-        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")
+        key_value_pairs = _get_conjugate_parameter(self.target)
+        if len(key_value_pairs) != 1:
+            raise ValueError(f"Multiple references to conjugate parameter {self.target.prior.name} found in likelihood. Only one occurance is supported.")
+        for key, value in key_value_pairs:
+            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):
+    def conjugate_distribution(self):
         # Extract variables
         # Here we approximate the LMRF with a Gaussian
 
@@ -76,6 +73,4 @@ class _LMRFGammaPair(_ConjugatePair):
         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()
+        return Gamma(shape=d+alpha, rate=np.linalg.norm(Lx)**2+beta)

{cuqipy-1.2.0.post0.dev446 → cuqipy-1.2.0.post0.dev501}/cuqi/implicitprior/_regularizedGMRF.py

@@ -50,9 +50,9 @@ class RegularizedGMRF(RegularizedGaussian):
 
     regularization : string or None
         Preset regularization. Can be set to "l1". Required for use in Gibbs in future update.
-        For "l1", the following additional parameters can be passed:
+        For "l1" or "tv", the following additional parameters can be passed:
             strength : scalar
-                Regularization parameter, i.e., strength*||x||_1 , defaults to one
+                Regularization parameter, i.e., strength*||Lx||_1, defaults to one
 
     """
     def __init__(self, mean=None, prec=None, bc_type='zero', order=1, proximal = None, projector = None, constraint = None, regularization = None, **kwargs):

{cuqipy-1.2.0.post0.dev446 → cuqipy-1.2.0.post0.dev501}/cuqi/implicitprior/_regularizedGaussian.py

@@ -5,6 +5,7 @@ from cuqi.geometry import Continuous1D, Continuous2D, Image2D
 from cuqi.operator import FirstOrderFiniteDifference
 
 import numpy as np
+from copy import copy
 
 
 class RegularizedGaussian(Distribution):
@@ -269,29 +270,12 @@ class RegularizedGaussian(Distribution):
             mutable_vars += ["strength"]
         return mutable_vars
     
-    # Overwrite the condition method such that the underlying Gaussian is conditioned in general, except when conditioning on self.name
-    # which means we convert Distribution to Likelihood or EvaluatedDensity.
-    def _condition(self, *args, **kwargs):
-        if self.preset in self.regularization_options():
-            return super()._condition(*args, **kwargs)
-        
-        # Handle positional arguments (similar code as in Distribution._condition)
-        cond_vars = self.get_conditioning_variables()
-        kwargs = self._parse_args_add_to_kwargs(cond_vars, *args, **kwargs)
-
-        # When conditioning, we always do it on a copy to avoid unintentional side effects
-        new_density = self._make_copy()
-
-        # Check if self.name is in the provided keyword arguments.
-        # If so, pop it and store its value.
-        value = kwargs.pop(self.name, None)
-
-        new_density._gaussian = self.gaussian._condition(**kwargs)
-
-        # If self.name was provided, we convert to a likelihood or evaluated density
-        if value is not None:
-            new_density = new_density.to_likelihood(value)
-
+    def _make_copy(self):
+        """ Returns a shallow copy of the density keeping a pointer to the original. """
+        # Using deepcopy would also copy the underlying geometry, which causes a crash because geometries won't match anymore.
+        new_density = copy(self)
+        new_density._gaussian = copy(new_density._gaussian)
+        new_density._original_density = self
         return new_density
 
 

{cuqipy-1.2.0.post0.dev446 → cuqipy-1.2.0.post0.dev501}/cuqi/implicitprior/_regularizedUnboundedUniform.py

@@ -45,9 +45,9 @@ class RegularizedUnboundedUniform(RegularizedGaussian):
 
         regularization : string or None
                 Preset regularization. Can be set to "l1". Required for use in Gibbs in future update.
-                For "l1", the following additional parameters can be passed:
+                For "l1" or "tv", the following additional parameters can be passed:
                 strength : scalar
-                        Regularization parameter, i.e., strength*||x||_1 , defaults to one
+                        Regularization parameter, i.e., strength*||Lx||_1, defaults to one
 
         """
         def __init__(self, geometry, proximal = None, projector = None, constraint = None, regularization = None, **kwargs):

{cuqipy-1.2.0.post0.dev446 → cuqipy-1.2.0.post0.dev501}/cuqi/problem/_problem.py

@@ -5,7 +5,7 @@ from typing import Tuple
 
 import cuqi
 from cuqi import config
-from cuqi.distribution import Distribution, Gaussian, InverseGamma, LMRF, GMRF, Lognormal, Posterior, Beta, JointDistribution, Gamma, CMRF
+from cuqi.distribution import Distribution, Gaussian, InverseGamma, LMRF, GMRF, Lognormal, Posterior, Beta, JointDistribution, Gamma, ModifiedHalfNormal, CMRF
 from cuqi.implicitprior import RegularizedGaussian, RegularizedGMRF
 from cuqi.density import Density
 from cuqi.model import LinearModel, Model
@@ -923,8 +923,8 @@ class BayesianProblem(object):
             if not isinstance(cond_target, Posterior):
                 raise NotImplementedError(f"Unable to determine sampling strategy for {par_name} with target {cond_target}")
 
-            # Gamma prior, Gaussian likelihood -> Conjugate
-            if self._check_posterior(cond_target, Gamma, (Gaussian, GMRF, RegularizedGaussian, RegularizedGMRF)):
+            # Gamma or ModifiedHalfNormal prior, Gaussian or RegularizedGaussian likelihood -> Conjugate
+            if self._check_posterior(cond_target, (Gamma, ModifiedHalfNormal), (Gaussian, GMRF, RegularizedGaussian, RegularizedGMRF)):
                 if experimental:
                     sampling_strategy[par_name] = cuqi.experimental.mcmc.Conjugate()
                 else:

{cuqipy-1.2.0.post0.dev446 → cuqipy-1.2.0.post0.dev501}/cuqi/solver/_solver.py

@@ -884,4 +884,4 @@ def ProximalL1(x, gamma):
     x : array_like.
     gamma : scale parameter.
     """
-    return np.multiply(np.sign(x), np.maximum(np.abs(x)-gamma, 0))
+    return np.multiply(np.sign(x), np.maximum(np.abs(x)-gamma, 0))

{cuqipy-1.2.0.post0.dev446 → cuqipy-1.2.0.post0.dev501}/cuqi/utilities/__init__.py

@@ -12,7 +12,10 @@ from ._utilities import (
     approx_derivative,
     check_if_conditional_from_attr,
     plot_1D_density,
-    plot_2D_density
+    plot_2D_density,
+    count_nonzero,
+    count_constant_components_1D,
+    count_constant_components_2D
 )
 
 from ._get_python_variable_name import _get_python_variable_name