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

cuqi/experimental/mcmc/_conjugate.py

@@ -1,396 +0,0 @@
-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_within_bounds, count_constant_components_1D, count_constant_components_2D, piecewise_linear_1D_DoF
-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 most of the preset constraints and regularization
-    - (RegularizedGMRF, ModifiedHalfNormal) with most of the preset constraints and regularization
-
-    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")
-
-        # Raises error if preset is not supported
-        _compute_sparsity_level(self.target)
-
-        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 = _compute_sparsity_level(self.target)
-        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")
-        
-        # Raises error if preset is not supported
-        _compute_sparsity_level(self.target)
-
-        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
-        m = _compute_sparsity_level(self.target)
-
-        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")
-        
-        # Raises error if preset is not supported
-        _compute_sparsity_level(self.target)
-
-        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
-        
-        m = _compute_sparsity_level(self.target)
-
-        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 _compute_sparsity_level(target):
-    """Computes the sparsity level in accordance with Section 4 from [2],
-    this can be interpreted as the number of degrees of freedom, that is,
-    the number of components n minus the dimension the of the subdifferential of the regularized.
-    """
-    x = target.likelihood.data
-
-    constraint = target.likelihood.distribution.preset["constraint"]
-    regularization = target.likelihood.distribution.preset["regularization"]
-
-    # There is no reference for some of these conjugacy rules
-    if constraint == "nonnegativity":
-        if regularization in [None, "l1"]:
-            # Number of non-zero components in x
-            return count_nonzero(x)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, Continuous1D):
-            # Number of non-zero constant components in x
-            return count_constant_components_1D(x, lower = 0.0)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, (Continuous2D, Image2D)):
-            # Number of non-zero constant components in x
-            return count_constant_components_2D(target.likelihood.distribution.geometry.par2fun(x), lower = 0.0)
-    elif constraint == "box":
-        bounds = target.likelihood.distribution._box_bounds
-        if regularization is None:
-            # Number of components in x that are strictly between the lower and upper bound
-            return count_within_bounds(x, bounds[0], bounds[1])
-        elif regularization == "l1":
-            # Number of components in x that are strictly between the lower and upper bound and are not zero
-            return count_within_bounds(x, bounds[0], bounds[1], exception = 0.0)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, Continuous1D):
-            # Number of constant components in x between are strictly between the lower and upper bound
-            return count_constant_components_1D(x, lower = bounds[0], upper = bounds[1])
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, (Continuous2D, Image2D)):
-            # Number of constant components in x between are strictly between the lower and upper bound
-            return count_constant_components_2D(target.likelihood.distribution.geometry.par2fun(x), lower = bounds[0], upper = bounds[1])
-    elif constraint in ["increasing", "decreasing"]:
-        if regularization is None:
-            # Number of constant components in x
-            return count_constant_components_1D(x)
-        elif regularization == "l1":
-            # Number of constant components in x that are not zero
-            return count_constant_components_1D(x, exception = 0.0)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, Continuous1D):
-            # Number of constant components in x
-            return count_constant_components_1D(x)
-        # Increasing and decreasing cannot be done in 2D
-    elif constraint in ["convex", "concave"]:
-        if regularization is None:
-            # Number of piecewise linear components in x
-            return piecewise_linear_1D_DoF(x)
-        elif regularization == "l1":
-            # Number of piecewise linear components in x that are not zero
-            return piecewise_linear_1D_DoF(x, exception_zero = True)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, Continuous1D):
-            # Number of piecewise linear components in x that are not flat
-            return piecewise_linear_1D_DoF(x, exception_flat = True)
-        # convex and concave has only been implemented in 1D
-    elif constraint == None: 
-        if regularization == "l1":
-            # Number of non-zero components in x
-            return count_nonzero(x)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, Continuous1D):
-            # Number of non-zero constant components in x
-            return count_constant_components_1D(x)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, (Continuous2D, Image2D)):
-            # Number of non-zero constant components in x
-            return count_constant_components_2D(target.likelihood.distribution.geometry.par2fun(x))
-
-    raise ValueError("RegularizedGaussian preset constraint and regularization choice is currently not supported with conjugacy.")
-
-
-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)

cuqi/experimental/mcmc/_conjugate_approx.py

@@ -1,76 +0,0 @@
-import numpy as np
-from cuqi.experimental.mcmc import Conjugate
-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 ConjugateApprox(Conjugate):
-    """ 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) where Gamma is defined on the inverse of the scale parameter of the LMRF distribution.
-
-    Gamma distribution must be univariate.
-
-    LMRF likelihood must have zero mean.
-
-    For more details on conjugacy see :class:`Conjugate`.
-
-    """
-
-    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")
-
-
-class _LMRFGammaPair(_ConjugatePair):
-    """ Implementation of the conjugate pair (LMRF, Gamma) """
-
-    def validate_target(self):
-        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_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 conjugate_distribution(self):
-        # Extract variables
-        # Here we approximate the LMRF 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
-        return Gamma(shape=d+alpha, rate=np.linalg.norm(Lx)**2+beta)

cuqi/experimental/mcmc/_cwmh.py

@@ -1,190 +0,0 @@
-import numpy as np
-import cuqi
-from cuqi.experimental.mcmc import ProposalBasedSampler
-from cuqi.array import CUQIarray
-from numbers import Number
-
-class CWMH(ProposalBasedSampler):
-    """Component-wise Metropolis Hastings sampler.
-
-    Allows sampling of a target distribution by a component-wise random-walk
-    sampling of a proposal distribution along with an accept/reject step.
-
-    Parameters
-    ----------
-
-    target : `cuqi.distribution.Distribution` or lambda function
-        The target distribution to sample. Custom logpdfs are supported by using
-        a :class:`cuqi.distribution.UserDefinedDistribution`.
-    
-    proposal : `cuqi.distribution.Distribution` or callable method
-        The proposal to sample from. If a callable method it should provide a
-        single independent sample from proposal distribution. Defaults to a
-        Gaussian proposal.  *Optional*.
-
-    scale : float or ndarray
-        Scale parameter used to define correlation between previous and proposed
-        sample in random-walk.  *Optional*. If float, the same scale is used for
-        all dimensions. If ndarray, a (possibly) different scale is used for
-        each dimension.
-
-    initial_point : ndarray
-        Initial parameters. *Optional*
-
-    callback : callable, optional
-        A function that will be called after each sampling step. It can be useful for monitoring the sampler during sampling.
-        The function should take three arguments: the sampler object, the index of the current sampling step, the total number of requested samples. The last two arguments are integers. An example of the callback function signature is: `callback(sampler, sample_index, num_of_samples)`.
-
-    kwargs : dict
-        Additional keyword arguments to be passed to the base class 
-        :class:`ProposalBasedSampler`.
-
-    Example
-    -------
-    .. code-block:: python
-        import numpy as np
-        import cuqi
-        # Parameters
-        dim = 5 # Dimension of distribution
-        mu = np.arange(dim) # Mean of Gaussian
-        std = 1 # standard deviation of Gaussian
-
-        # Logpdf function
-        logpdf_func = lambda x: -1/(std**2)*np.sum((x-mu)**2)
-
-        # Define distribution from logpdf as UserDefinedDistribution (sample
-        # and gradients also supported as inputs to UserDefinedDistribution)
-        target = cuqi.distribution.UserDefinedDistribution(
-            dim=dim, logpdf_func=logpdf_func)
-
-        # Set up sampler
-        sampler = cuqi.experimental.mcmc.CWMH(target, scale=1)
-
-        # Sample
-        samples = sampler.sample(2000).get_samples()
-
-    """
-
-    _STATE_KEYS = ProposalBasedSampler._STATE_KEYS.union(['_scale_temp'])
-
-    def __init__(self, target:cuqi.density.Density=None, proposal=None, scale=1,
-                 initial_point=None, **kwargs):
-        super().__init__(target, proposal=proposal, scale=scale,
-                         initial_point=initial_point, **kwargs)
-        
-    def _initialize(self):
-        if isinstance(self.scale, Number):
-            self.scale = np.ones(self.dim)*self.scale
-        self._acc = [np.ones((self.dim))] # Overwrite acc from ProposalBasedSampler with list of arrays
-
-        # Handling of temporary scale parameter due to possible bug in old CWMH
-        self._scale_temp = self.scale.copy()
-
-    @property
-    def scale(self):
-        """ Get the scale parameter. """
-        return self._scale
-
-    @scale.setter
-    def scale(self, value):
-        """ Set the scale parameter. """
-        if self._is_initialized and isinstance(value, Number):
-            value = np.ones(self.dim)*value
-        self._scale = value
-
-    def validate_target(self):
-        if not isinstance(self.target, cuqi.density.Density):
-            raise ValueError(
-                "Target should be an instance of "+\
-                f"{cuqi.density.Density.__class__.__name__}")
-        # Fail when there is no log density, which is currently assumed to be the case in case NaN is returned.
-        if np.isnan(self.target.logd(self._get_default_initial_point(self.dim))):
-            raise ValueError("Target does not have valid logd")
-        
-    def validate_proposal(self):
-        if not isinstance(self.proposal, cuqi.distribution.Distribution):
-            raise ValueError("Proposal must be a cuqi.distribution.Distribution object")
-        if not self.proposal.is_symmetric:
-            raise ValueError("Proposal must be symmetric")
-        
-    @property
-    def proposal(self):
-        if self._proposal is None:
-            self._proposal = cuqi.distribution.Normal(
-                mean=lambda location: location,
-                std=lambda scale: scale,
-                geometry=self.dim,
-            )
-        return self._proposal
-    
-    @proposal.setter
-    def proposal(self, value):
-        self._proposal = value
-
-    def step(self):
-        # Initialize x_t which is used to store the current CWMH sample
-        x_t = self.current_point.copy()
-
-        # Initialize x_star which is used to store the proposed sample by
-        # updating the current sample component-by-component
-        x_star = self.current_point.copy()
-
-        # Propose a sample x_all_components from the proposal distribution
-        # for all the components
-        target_eval_t = self.current_target_logd
-        if isinstance(self.proposal,cuqi.distribution.Distribution):
-            x_all_components = self.proposal(
-                location= self.current_point, scale=self.scale).sample()
-        else:
-            x_all_components = self.proposal(self.current_point, self.scale)
-
-        # Initialize acceptance rate
-        acc = np.zeros(self.dim)
-
-        # Loop over all the components of the sample and accept/reject
-        # each component update.
-        for j in range(self.dim):
-            # propose state x_star by updating the j-th component
-            x_star[j] = x_all_components[j]
-
-            # evaluate target
-            target_eval_star = self.target.logd(x_star)
-
-            # compute Metropolis acceptance ratio
-            alpha = min(0, target_eval_star - target_eval_t)
-
-            # accept/reject
-            u_theta = np.log(np.random.rand())
-            if (u_theta <= alpha) and \
-               (not np.isnan(target_eval_star)) and \
-               (not np.isinf(target_eval_star)):
-                x_t[j] = x_all_components[j]
-                target_eval_t = target_eval_star
-                acc[j] = 1
-
-            x_star = x_t.copy()
-
-        self.current_target_logd = target_eval_t
-        self.current_point = x_t
-
-        return acc
-
-    def tune(self, skip_len, update_count):
-        # Store update_count in variable i for readability
-        i = update_count
-
-        # Optimal acceptance rate for CWMH
-        star_acc = 0.21/self.dim + 0.23
-
-        # Mean of acceptance rate over the last skip_len samples
-        hat_acc = np.mean(self._acc[i*skip_len:(i+1)*skip_len], axis=0)
-
-        # Compute new intermediate scaling parameter scale_temp
-        # Factor zeta ensures that the variation of the scale update vanishes
-        zeta = 1/np.sqrt(update_count+1)  
-        scale_temp = np.exp(
-            np.log(self._scale_temp) + zeta*(hat_acc-star_acc))
-
-        # Update the scale parameter
-        self.scale = np.minimum(scale_temp, np.ones(self.dim))
-        self._scale_temp = scale_temp