CUQIpy 1.0.0.post0.dev384__py3-none-any.whl → 1.0.0.post0.dev420__py3-none-any.whl

{CUQIpy-1.0.0.post0.dev384.dist-info → CUQIpy-1.0.0.post0.dev420.dist-info}/METADATA

@@ -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.dist-info → CUQIpy-1.0.0.post0.dev420.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cuqi/__init__.py,sha256=LsGilhl-hBLEn6Glt8S_l0OJzAA1sKit_rui8h-D-p0,488
 cuqi/_messages.py,sha256=fzEBrZT2kbmfecBBPm7spVu7yHdxGARQB4QzXhJbCJ0,415
-cuqi/_version.py,sha256=IKVgkfhXqLynqXrlVfTXOFBq5r4w6rJcCBTk1PNkuKA,510
+cuqi/_version.py,sha256=w5RJCnySMypI_9tEG8VNibbbBzdnFB4_1O9-0uJHbdE,510
 cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
 cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
 cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
@@ -18,7 +18,7 @@ cuqi/distribution/__init__.py,sha256=4vVLArg6NVzBj67vVioK8BY6wISJKb5cOxdoHMuUb_s
 cuqi/distribution/_beta.py,sha256=hdAc6Tbuz9Yqf76NSHxpaUgN7s6Z2lNV7YSRD3JhyCU,2997
 cuqi/distribution/_cauchy.py,sha256=UsVXYz8HhagXN5fIWSAIyELqhsJAX_-wk9kkRGgRmA8,3296
 cuqi/distribution/_cmrf.py,sha256=tCbEulM_O7FB3C_W-3IqZp9zGHkTofCdFF0ybHc9UZI,3745
-cuqi/distribution/_custom.py,sha256=uUJwGlGjcMY89mIyu9nFI3OafLOMgn8uAEMfCbTDzi0,10661
+cuqi/distribution/_custom.py,sha256=3toVV_ntnWAGlI7pNQLS7-7m5i-34sTWQrxL-SMweq0,10681
 cuqi/distribution/_distribution.py,sha256=G7BCpVueK4QLoLa_hu9h-Euh58Yp9SrgUKuudUlg-pw,18351
 cuqi/distribution/_gamma.py,sha256=9vljt5iaBDCHRhrVCMLc2RWDuBchZRQcv9buJMDYPlM,3434
 cuqi/distribution/_gaussian.py,sha256=DmmgVxKp4iEiEYWDdDcRoh35y14Oepn-zDHex0WVaYo,33316
@@ -35,10 +35,10 @@ cuqi/distribution/_smoothed_laplace.py,sha256=bfvOI4YOYC6QPds1UHNHar_q-vOZEjBcPx
 cuqi/distribution/_uniform.py,sha256=7xJmCZH_LPhuGkwEDGh-_CTtzcWKrXMOxtTJUFb7Ydo,1607
 cuqi/experimental/__init__.py,sha256=vhZvyMX6rl8Y0haqCzGLPz6PSUKyu75XMQbeDHqTTrw,83
 cuqi/experimental/mcmc/__init__.py,sha256=0Vk_MzfE_9tvqQRgR6_3nkjSe_D3vgFqVM9pFrXN2iQ,581
-cuqi/experimental/mcmc/_conjugate.py,sha256=qYrBvZ9wNK4oBz0c0RRUtQkbpPIHI3BvBYSLRw8ok5k,3757
-cuqi/experimental/mcmc/_conjugate_approx.py,sha256=JQe9gmnNespCxSP6vaZWfizFvUWUh8Jn-jRqsJYyNeM,2839
+cuqi/experimental/mcmc/_conjugate.py,sha256=r3cEXFXjNucDUAzj9mq4nZtgc6B3lJM21c77d1tB8gw,9936
+cuqi/experimental/mcmc/_conjugate_approx.py,sha256=FLhNN0O6DvohLjmekMA6iVn8yXMEvUGcx1s8w3Wu8cA,3665
 cuqi/experimental/mcmc/_cwmh.py,sha256=-TM_S_UtD5ljEfXGEUpYImxNx3JXppIKTSpoWen7kP8,7142
-cuqi/experimental/mcmc/_direct.py,sha256=E3UevdJ_DLk2wL0lid1TTKkdmgnIMJ5Ihr7iM1jU8KI,738
+cuqi/experimental/mcmc/_direct.py,sha256=pAtxqoSQGhLdukLi8gcoY2qXJmKluttX5RWOk5fAbOY,786
 cuqi/experimental/mcmc/_gibbs.py,sha256=z6YOCiBM1YuZbQHfdmsArR-pT61dsS14F_O4kUxsNYM,10638
 cuqi/experimental/mcmc/_hmc.py,sha256=0sZMHtnNFGGtQdzpx-cgqA0xyfvGy7r4K62RH3AQNa4,19285
 cuqi/experimental/mcmc/_langevin_algorithm.py,sha256=n6WRQooKuUDjmqF-CtpcSNFDvaHCgLKhWxX-hi7h_ZA,8224
@@ -63,7 +63,7 @@ cuqi/operator/_operator.py,sha256=yNwPTh7jR07AiKMbMQQ5_54EgirlKFsbq9JN1EODaQI,88
 cuqi/pde/__init__.py,sha256=NyS_ZYruCvy-Yg24qKlwm3ZIX058kLNQX9bqs-xg4ZM,99
 cuqi/pde/_pde.py,sha256=WRkOYyIdT_T3aZepRh0aS9C5nBbUZUcHaA80iSRvgoo,12572
 cuqi/problem/__init__.py,sha256=JxJty4JqHTOqSG6NeTGiXRQ7OLxiRK9jvVq3lXLeIRw,38
-cuqi/problem/_problem.py,sha256=Irk4OlTAhZAX81excesi8ANokz2GSAS3z_mcvx8Wqdc,32018
+cuqi/problem/_problem.py,sha256=XvNbo7BXcnDZvj3n36f879QknTYg3_-jnKhkVvqUQto,31944
 cuqi/sampler/__init__.py,sha256=D-dYa0gFgIwQukP8_VKhPGmlGKXbvVo7YqaET4SdAeQ,382
 cuqi/sampler/_conjugate.py,sha256=ztmUR3V3qZk9zelKx48ULnmMs_zKTDUfohc256VOIe8,2753
 cuqi/sampler/_conjugate_approx.py,sha256=xX-X71EgxGnZooOY6CIBhuJTs3dhcKfoLnoFxX3CO2g,1938
@@ -85,8 +85,8 @@ cuqi/testproblem/_testproblem.py,sha256=x769LwwRdJdzIiZkcQUGb_5-vynNTNALXWKato7s
 cuqi/utilities/__init__.py,sha256=T4tLsC215MknBCsw_C0Qeeg_ox26aDUrCA5hbWvNQkU,387
 cuqi/utilities/_get_python_variable_name.py,sha256=QwlBVj2koJRA8s8pWd554p7-ElcI7HUwY32HknaR92E,1827
 cuqi/utilities/_utilities.py,sha256=MWAqV6L5btMpWwlUzrZYuV2VeSpfTbOaLRMRkuw2WIA,8509
-CUQIpy-1.0.0.post0.dev384.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
-CUQIpy-1.0.0.post0.dev384.dist-info/METADATA,sha256=5xT68suvERdJf0DPgCPA23chSdG2yRnQQJhW_zSnjps,18393
-CUQIpy-1.0.0.post0.dev384.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-CUQIpy-1.0.0.post0.dev384.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
-CUQIpy-1.0.0.post0.dev384.dist-info/RECORD,,
+CUQIpy-1.0.0.post0.dev420.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
+CUQIpy-1.0.0.post0.dev420.dist-info/METADATA,sha256=3KFA90vbSnjyOmJtY3j8wtqt7wrzvmqDZ8NV9pWoI3Q,18393
+CUQIpy-1.0.0.post0.dev420.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+CUQIpy-1.0.0.post0.dev420.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
+CUQIpy-1.0.0.post0.dev420.dist-info/RECORD,,

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
 

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?

cuqi/experimental/mcmc/_conjugate.py

@@ -1,12 +1,15 @@
 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 where the likelihood and prior are conjugate.
+    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
@@ -14,64 +17,181 @@ class ConjugateNew(SamplerNew):
     - (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 Gamma distribution must be univariate.
 
-    Currently, the sampler does NOT automatically check that the conjugate distributions are defined on the correct parameters.
+    A conjugate pair defines implicitly a so-called conjugate distribution which can be sampled from directly.
 
-    For more information on conjugate pairs, see https://en.wikipedia.org/wiki/Conjugate_prior.
+    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")
 
-        if not isinstance(self.target.likelihood.distribution, (Gaussian, GMRF, RegularizedGaussian, RegularizedGMRF)):
-            raise ValueError("Conjugate sampler only works with a Gaussian-type likelihood function")
+    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 not self.target.prior.dim == 1:
+
+        if 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):
+        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 = 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
+        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)
+        dist = Gamma(shape=m/2 + alpha, rate=.5 * np.linalg.norm(L @ (Ax - b))**2 + beta)
 
-        self.current_point = dist.sample()
+        return 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.
+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")
 
-        However, for implicit regularized Gaussians, m is the number of non-zero elements in the data vector b see [1].
-           
-        """
+        if self.target.prior.dim != 1:
+            raise ValueError("Conjugate sampler only works with univariate Gamma prior")
 
-        if isinstance(self.target.likelihood.distribution, (Gaussian, GMRF)):
-            return len(b)
-        elif isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)):
-            return np.count_nonzero(b)
+        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])

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()

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     

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