CUQIpy 1.0.0.post0.dev305__tar.gz → 1.0.0.post0.dev352__tar.gz

{cuqipy-1.0.0.post0.dev305 → cuqipy-1.0.0.post0.dev352}/CUQIpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.0.0.post0.dev305
+Version: 1.0.0.post0.dev352
 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.dev305 → cuqipy-1.0.0.post0.dev352}/CUQIpy.egg-info/SOURCES.txt

@@ -38,12 +38,17 @@ cuqi/distribution/_joint_distribution.py
 cuqi/distribution/_laplace.py
 cuqi/distribution/_lmrf.py
 cuqi/distribution/_lognormal.py
+cuqi/distribution/_modifiedhalfnormal.py
 cuqi/distribution/_normal.py
 cuqi/distribution/_posterior.py
 cuqi/distribution/_uniform.py
 cuqi/experimental/__init__.py
 cuqi/experimental/mcmc/__init__.py
+cuqi/experimental/mcmc/_conjugate.py
+cuqi/experimental/mcmc/_conjugate_approx.py
 cuqi/experimental/mcmc/_cwmh.py
+cuqi/experimental/mcmc/_direct.py
+cuqi/experimental/mcmc/_gibbs.py
 cuqi/experimental/mcmc/_hmc.py
 cuqi/experimental/mcmc/_langevin_algorithm.py
 cuqi/experimental/mcmc/_laplace_approximation.py

{cuqipy-1.0.0.post0.dev305 → cuqipy-1.0.0.post0.dev352}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.0.0.post0.dev305
+Version: 1.0.0.post0.dev352
 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.dev305 → cuqipy-1.0.0.post0.dev352}/cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-05-27T07:34:21+0200",
+ "date": "2024-06-19T09:05:37+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "1274ccfff1cb9663b547dd2aeb9c86c72dccb2ae",
- "version": "1.0.0.post0.dev305"
+ "full-revisionid": "1e1deddbe7925206fdaef6a2d9bf8ce9e33ad73d",
+ "version": "1.0.0.post0.dev352"
 }
 '''  # END VERSION_JSON
 

{cuqipy-1.0.0.post0.dev305 → cuqipy-1.0.0.post0.dev352}/cuqi/distribution/__init__.py

@@ -3,6 +3,7 @@ from ._beta import Beta
 from ._cauchy import Cauchy
 from ._cmrf import CMRF
 from ._gamma import Gamma
+from ._modifiedhalfnormal import ModifiedHalfNormal
 from ._gaussian import Gaussian, JointGaussianSqrtPrec
 from ._gmrf import GMRF
 from ._inverse_gamma import InverseGamma

cuqipy-1.0.0.post0.dev352/cuqi/distribution/_modifiedhalfnormal.py

@@ -0,0 +1,184 @@
+import numpy as np
+import scipy.stats as sps
+import scipy.special as special
+from cuqi.distribution import Distribution
+from cuqi.utilities import force_ndarray
+
+class ModifiedHalfNormal(Distribution):
+    """
+    Represents a modified half-normal (MHN) distribution, a three-parameter family of distributions generalizing the Gamma distribution.
+    The distribution is continuous with pdf 
+    f(x; alpha, beta, gamma) propto x^(alpha-1) * exp(-beta * x^2 + gamma * x)
+
+    The MHN generalizes the half-normal distribution, because
+    f(x; 1, beta, 0) propto exp(-beta * x^2)
+
+    The MHN generalizes the gamma distribution because
+    f(x; alpha, 0, -gamma) propto x^(alpha-1) * exp(- gamma * x)
+
+    Reference:
+    [1] Sun, et al. "The Modified-Half-Normal distribution: Properties and an efficient sampling scheme." Communications in Statistics-Theory and Methods
+    
+    Parameters
+    ----------
+    alpha : float
+        The polynomial exponent parameter of the MHN distribution. Must be positive.
+
+    beta : float
+        The quadratic exponential parameter of the MHN distribution. Must be positive.
+
+    gamma : float
+        The linear exponential parameter of the MHN distribution.
+
+    """
+    def __init__(self, alpha=None, beta=None, gamma=None, is_symmetric=False, **kwargs):
+        # Init from abstract distribution class
+        super().__init__(is_symmetric=is_symmetric, **kwargs) 
+
+        self._alpha = alpha
+        self._beta = beta
+        self._gamma = gamma
+
+    @property
+    def alpha(self):
+        """ The polynomial exponent parameter of the MHN distribution. Must be positive. """
+        return self._alpha
+    
+    @alpha.setter
+    def shape(self, value):
+        self._shape = force_ndarray(value, flatten=True)
+
+    @property
+    def beta(self):
+        """ The quadratic exponential parameter of the MHN distribution. Must be positive. """
+        return self._alpha
+    
+    @beta.setter
+    def beta(self, value):
+        self._beta = force_ndarray(value, flatten=True)
+
+    @property
+    def gamma(self):
+        """ The linear exponential parameter of the MHN distribution. """
+        return self._alpha
+    
+    @gamma.setter
+    def gamma(self, value):
+        self._gamma = force_ndarray(value, flatten=True)
+
+    def logpdf(self, x): # Unnormalized
+        return np.sum((self.alpha - 1)*np.log(x) - self.beta * x * x + self.gamma * x)
+
+    def _gradient_scalar(self, val):
+        if val <= 0.0:
+            return np.nan
+        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])
+    
+    def _MHN_sample_gamma_proposal(self, alpha, beta, gamma, rng, delta=None):
+        """
+            Sample from a modified half-normal distribution using a Gamma distribution proposal.
+        """
+        if delta is None:
+            delta = beta + (gamma*gamma - gamma*np.sqrt(gamma*gamma + 8*beta*alpha))/(4*alpha)
+            
+        while True:
+            T = rng.gamma(alpha/2, 1.0/delta)
+            X = np.sqrt(T)
+            U = rng.uniform()
+            if X > 0 and np.log(U) < -(beta-delta)*T + gamma*X - gamma*gamma/(4*(beta-delta)):
+                return X
+            
+    def _MHN_sample_normal_proposal(self, alpha, beta, gamma, mu, rng):
+        """
+            Sample from a modified half-normal distribution using a Normal/Gaussian distribution proposal.
+        """
+        if mu is None:
+            mu = (gamma + np.sqrt(gamma*gamma + 8*beta*(alpha - 1)))/(4*beta)    
+        
+        while True:
+            X = rng.normal(mu, np.sqrt(0.5/beta))
+            U = rng.uniform()
+            if X > 0 and np.log(U) < (alpha-1)*np.log(X) - np.log(mu) + (2*beta*mu-gamma)*(mu-X):
+                return X
+
+    def _MHN_sample_positive_gamma_1(self, alpha, beta, gamma, rng):
+        """
+            Sample from a modified half-normal distribution, assuming alpha is greater than one and gamma is positive.
+        """
+        if gamma <= 0.0:
+            raise ValueError("gamma needs to be positive")
+            
+        if alpha <= 1.0:
+            raise ValueError("alpha needs to be greater than 1.0")
+
+        # Decide whether to use Normal or sqrt(Gamma) proposals for acceptance-rejectance scheme
+        mu = (gamma + np.sqrt(gamma*gamma + 8*beta*(alpha - 1)))/(4*beta)
+        K1  = 2*np.sqrt(np.pi)
+        K1 *= np.power((np.sqrt(beta)*(alpha-1))/(2*beta*mu-gamma), alpha - 1)
+        K1 *= np.exp(-(alpha-1)+beta*mu*mu)
+        
+        delta = beta + (gamma*gamma - gamma*np.sqrt(gamma*gamma + 8*beta*alpha))/(4*alpha)
+        K2  = np.power(beta/delta, 0.5*alpha)
+        K2 *= special.gamma(alpha/2.0)
+        K2 *= np.exp(gamma*gamma/(4*(beta-delta)))
+
+        if K2 > K1: # Use normal proposal
+            return self._MHN_sample_normal_proposal(alpha, beta, gamma, mu, rng)
+        else: # Use sqrt(gamma) proposal
+            return self._MHN_sample_gamma_proposal(alpha, beta, gamma, rng, delta)
+
+    def _MHN_sample_negative_gamma(self, alpha, beta, gamma, rng, m=None):
+        """
+            Sample from a modified half-normal distribution, assuming gamma is negative.
+            The argument 'm' is the matching point, see Algorithm 3 from [1] for details.
+        """
+        if gamma > 0.0:
+            raise ValueError("gamma needs to be negative")
+            
+        if m is None:
+            if alpha <= 1.0:
+                m = 1.0
+            else:
+                m = "mode"
+        
+        # The acceptance rate of this choice is at least 0.5*sqrt(2) approx 70.7 percent, according to Theorem 4 from [1].
+        if isinstance(m, str) and m.lower() == "mode":
+            m = (gamma + np.sqrt(gamma*gamma + 8*beta*alpha))/(4*beta)
+
+        while True:
+            val1 = (beta*m-gamma)/(2*beta*m-gamma)
+            val2 = m*(beta*m-gamma)
+            T = rng.gamma(alpha*val1, 1.0/val2)
+            X = m*np.power(T,val1)
+            U = rng.uniform()
+            if np.log(U) < val2*T-beta*X*X+gamma*X:
+                return X
+            
+    def _MHN_sample(self, alpha, beta, gamma, m=None, rng=None):
+        """
+        Sample from a modified half-normal distribution using an algorithm from [1].
+        """
+        if rng == None:
+            rng = np.random
+
+        if gamma <= 0.0:
+            return self._MHN_sample_negative_gamma(alpha, beta, gamma, m=m, rng=rng)
+        
+        if alpha > 1:
+            return self._MHN_sample_positive_gamma_1(alpha, beta, gamma, rng=rng)
+        
+        return self._MHN_sample_gamma_proposal(alpha, beta, gamma, rng=rng)
+
+    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)])
+        else:
+            return np.array([self._MHN_sample(self.alpha, self.beta, self.gamma, rng=rng) for i in range(N)])
+
+            

{cuqipy-1.0.0.post0.dev305 → cuqipy-1.0.0.post0.dev352}/cuqi/experimental/mcmc/__init__.py

@@ -8,3 +8,7 @@ from ._rto import LinearRTONew, RegularizedLinearRTONew
 from ._cwmh import CWMHNew
 from ._laplace_approximation import UGLANew
 from ._hmc import NUTSNew
+from ._gibbs import HybridGibbsNew
+from ._conjugate import ConjugateNew
+from ._conjugate_approx import ConjugateApproxNew
+from ._direct import DirectNew

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

@@ -0,0 +1,77 @@
+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)

cuqipy-1.0.0.post0.dev352/cuqi/experimental/mcmc/_conjugate_approx.py

@@ -0,0 +1,75 @@
+import numpy as np
+from cuqi.experimental.mcmc import SamplerNew
+from cuqi.distribution import Posterior, LMRF, Gamma
+import scipy as sp
+
+class ConjugateApproxNew(SamplerNew):
+    """ 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.
+
+    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.
+
+    """
+
+    def _initialize(self):
+        pass
+
+    def validate_target(self):
+
+        if not isinstance(self.target, Posterior):
+            raise TypeError("Approximate conjugate sampler requires a target of type Posterior")
+
+        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")
+        
+        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")
+        
+    def step(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
+        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

cuqipy-1.0.0.post0.dev352/cuqi/experimental/mcmc/_direct.py

@@ -0,0 +1,28 @@
+from cuqi.experimental.mcmc import SamplerNew
+
+class DirectNew(SamplerNew):
+    """ Direct sampler
+
+    This sampler is used to sample from a target distribution directly. It simply calls the sample method of the target object to generate a sample.
+
+    Parameters
+    ----------
+    target : Distribution
+        The target distribution to sample from.
+
+    """
+            
+    def _initialize(self):
+        pass
+
+    def validate_target(self):
+        try:
+            self.target.sample()
+        except:
+            raise TypeError("Direct sampler requires a target with a sample method.")
+        
+    def step(self):
+        self.current_point = self.target.sample()
+
+    def tune(self, skip_len, update_count):
+        pass     

cuqipy-1.0.0.post0.dev352/cuqi/experimental/mcmc/_gibbs.py

@@ -0,0 +1,267 @@
+from cuqi.distribution import JointDistribution
+from cuqi.experimental.mcmc import SamplerNew
+from cuqi.samples import Samples
+from typing import Dict
+import numpy as np
+import warnings
+
+try:
+    from progressbar import progressbar
+except ImportError:
+    def progressbar(iterable, **kwargs):
+        warnings.warn("Module mcmc: Progressbar not found. Install progressbar2 to get sampling progress.")
+        return iterable
+
+# Not subclassed from SamplerNew as Gibbs handles multiple samplers and samples multiple parameters
+# Similar approach as for JointDistribution
+class HybridGibbsNew: 
+    """
+    Hybrid Gibbs sampler for sampling a joint distribution.
+
+    Gibbs sampling samples the variables of the distribution sequentially,
+    one variable at a time. When a variable represents a random vector, the
+    whole vector is sampled simultaneously.
+    
+    The sampling of each variable is done by sampling from the conditional
+    distribution of that variable given the values of the other variables.
+    This is often a very efficient way of sampling from a joint distribution
+    if the conditional distributions are easy to sample from. 
+
+    Hybrid Gibbs sampler is a generalization of the Gibbs sampler where the
+    conditional distributions are sampled using different MCMC samplers.
+    
+    When the conditionals are sampled exactly, the samples from the Gibbs 
+    sampler converge to the joint distribution. See e.g.
+    Gelman et al. "Bayesian Data Analysis" (2014), Third Edition
+    for more details.
+
+    In each Gibbs step, the corresponding sampler has the initial_point 
+    and initial_scale (if applicable) set to the value of the previous step
+    and the sampler is reinitialized. This means that the sampling is not 
+    fully stateful at this point. This means samplers like NUTS will lose
+    their internal state between Gibbs steps.
+
+    Parameters
+    ----------
+    target : cuqi.distribution.JointDistribution
+        Target distribution to sample from.
+    
+    sampling_strategy : dict
+        Dictionary of sampling strategies for each variable.
+        Keys are variable names.
+        Values are sampler objects.
+
+    num_sampling_steps : dict, *optional*
+        Dictionary of number of sampling steps for each variable.
+        The sampling steps are defined as the number of times the sampler
+        will call its step method in each Gibbs step.
+        Default is 1 for all variables.
+
+    Example
+    -------
+    .. code-block:: python
+
+        import cuqi
+        import numpy as np
+
+        # Model and data
+        A, y_obs, probinfo = cuqi.testproblem.Deconvolution1D(phantom='square').get_components()
+        n = A.domain_dim
+
+        # Define distributions
+        d = cuqi.distribution.Gamma(1, 1e-4)
+        l = cuqi.distribution.Gamma(1, 1e-4)
+        x = cuqi.distribution.GMRF(np.zeros(n), lambda d: d)
+        y = cuqi.distribution.Gaussian(A, lambda l: 1/l)
+
+        # Combine into a joint distribution and create posterior
+        joint = cuqi.distribution.JointDistribution(d, l, x, y)
+        posterior = joint(y=y_obs)
+
+        # Define sampling strategy
+        sampling_strategy = {
+            'x': cuqi.experimental.mcmc.LinearRTONew(maxit=15),
+            'd': cuqi.experimental.mcmc.ConjugateNew(),
+            'l': cuqi.experimental.mcmc.ConjugateNew(),
+        }
+
+        # Define Gibbs sampler
+        sampler = cuqi.experimental.mcmc.HybridGibbsNew(posterior, sampling_strategy)
+
+        # Run sampler
+        samples = sampler.sample(Ns=1000, Nb=200)
+
+        # Plot results
+        samples['x'].plot_ci(exact=probinfo.exactSolution)
+        samples['d'].plot_trace(figsize=(8,2))
+        samples['l'].plot_trace(figsize=(8,2))
+            
+    """
+
+    def __init__(self, target: JointDistribution, sampling_strategy: Dict[str, SamplerNew], num_sampling_steps: Dict[str, int] = None):
+
+        # Store target and allow conditioning to reduce to a single density
+        self.target = target() # Create a copy of target distribution (to avoid modifying the original)
+
+        # Store sampler instances (again as a copy to avoid modifying the original)
+        self.samplers = sampling_strategy.copy()
+
+        # Store number of sampling steps for each parameter
+        self.num_sampling_steps = num_sampling_steps
+
+        # Store parameter names
+        self.par_names = self.target.get_parameter_names()
+
+        # Initialize sampler (after target is set)
+        self._initialize()
+
+    def _initialize(self):
+        """ Initialize sampler """
+
+        # Initial points
+        self.current_samples = self._get_initial_points()
+
+        # Initialize sampling steps
+        self._initialize_num_sampling_steps()
+
+        # Allocate samples
+        self._allocate_samples()
+
+        # Set targets
+        self._set_targets()
+
+        # Initialize the samplers
+        self._initialize_samplers() 
+
+        # Run over pre-sample methods for samplers that have it
+        # TODO. Some samplers (NUTS) seem to require to run _pre_warmup before _pre_sample
+        # This is not ideal and should be fixed in the future
+        for sampler in self.samplers.values():
+            self._pre_warmup_and_pre_sample_sampler(sampler)
+
+        # Validate all targets for samplers.
+        self.validate_targets()
+
+    # ------------ Public methods ------------
+    def validate_targets(self):
+        """ Validate each of the conditional targets used in the Gibbs steps """
+        if not isinstance(self.target, JointDistribution):
+            raise ValueError('Target distribution must be a JointDistribution.')
+        for sampler in self.samplers.values():
+            sampler.validate_target()
+
+    def sample(self, Ns) -> 'HybridGibbsNew':
+        """ Sample from the joint distribution using Gibbs sampling """
+        for _ in progressbar(range(Ns)):
+            self.step()
+            self._store_samples()
+
+    def warmup(self, Nb) -> 'HybridGibbsNew':
+        """ Warmup (tune) the Gibbs sampler """
+        for idx in progressbar(range(Nb)):
+            self.step()
+            self.tune(idx)
+            self._store_samples()
+
+    def get_samples(self) -> Dict[str, Samples]:
+        samples_object = {}
+        for par_name in self.par_names:
+            samples_array = np.array(self.samples[par_name]).T
+            samples_object[par_name] = Samples(samples_array, self.target.get_density(par_name).geometry)
+        return samples_object
+    
+    def step(self):
+        """ Sequentially go through all parameters and sample them conditionally on each other """
+
+        # Sample from each conditional distribution
+        for par_name in self.par_names:
+
+            # Set target for current parameter
+            self._set_target(par_name)
+
+            # Get sampler
+            sampler = self.samplers[par_name]
+
+            # Set initial parameters using current point and scale (subset of state)
+            # This does not store the full state from e.g. NUTS sampler
+            # But works on samplers like MH, PCN, ULA, MALA, LinearRTO, UGLA, CWMH
+            # that only use initial_point and initial_scale
+            sampler.initial_point = self.current_samples[par_name]
+            if hasattr(sampler, 'initial_scale'): sampler.initial_scale = sampler.scale
+
+            # Reinitialize sampler
+            # This makes the sampler lose all of its state.
+            # This is only OK because we set the initial values above from the previous state
+            sampler.reinitialize()
+
+            # Run pre_warmup and pre_sample methods for sampler
+            # TODO. Some samplers (NUTS) seem to require to run _pre_warmup before _pre_sample
+            self._pre_warmup_and_pre_sample_sampler(sampler)
+
+            # Take MCMC steps
+            for _ in range(self.num_sampling_steps[par_name]):
+                sampler.step()
+
+            # Extract samples (Ensure even 1-dimensional samples are 1D arrays)
+            self.current_samples[par_name] = sampler.current_point.reshape(-1)
+
+    def tune(self, idx):
+        """ Tune each of the samplers """
+        for par_name in self.par_names:
+            self.samplers[par_name].tune(skip_len=1, update_count=idx)
+
+    # ------------ Private methods ------------
+    def _initialize_samplers(self):
+        """ Initialize samplers """
+        for sampler in self.samplers.values():
+            sampler.initialize()
+
+    def _initialize_num_sampling_steps(self):
+        """ Initialize the number of sampling steps for each sampler. Defaults to 1 if not set by user """
+
+        if self.num_sampling_steps is None:
+            self.num_sampling_steps = {par_name: 1 for par_name in self.par_names}
+
+        for par_name in self.par_names:
+            if par_name not in self.num_sampling_steps:
+                self.num_sampling_steps[par_name] = 1
+
+
+    def _pre_warmup_and_pre_sample_sampler(self, sampler):
+        if hasattr(sampler, '_pre_warmup'): sampler._pre_warmup()
+        if hasattr(sampler, '_pre_sample'): sampler._pre_sample()
+
+    def _set_targets(self):
+        """ Set targets for all samplers using the current samples """
+        par_names = self.par_names
+        for par_name in par_names:
+            self._set_target(par_name)
+
+    def _set_target(self, par_name):
+        """ Set target conditional distribution for a single parameter using the current samples """
+        # Get all other conditional parameters other than the current parameter and update the target
+        # This defines - from a joint p(x,y,z) - the conditional distribution p(x|y,z) or p(y|x,z) or p(z|x,y)
+        conditional_params = {par_name_: self.current_samples[par_name_] for par_name_ in self.par_names if par_name_ != par_name}
+        self.samplers[par_name].target = self.target(**conditional_params)
+
+    def _allocate_samples(self):
+        """ Allocate memory for samples """
+        samples = {}
+        for par_name in self.par_names:
+            samples[par_name] = []
+        self.samples = samples
+
+    def _get_initial_points(self):
+        """ Get initial points for each parameter """
+        initial_points = {}
+        for par_name in self.par_names:
+            if hasattr(self.target.get_density(par_name), 'init_point'):
+                initial_points[par_name] = self.target.get_density(par_name).init_point
+            else:
+                initial_points[par_name] = np.ones(self.target.get_density(par_name).dim)
+        return initial_points
+
+    def _store_samples(self):
+        """ Store current samples at index i of samples dict """
+        for par_name in self.par_names:
+            self.samples[par_name].append(self.current_samples[par_name])

{cuqipy-1.0.0.post0.dev305 → cuqipy-1.0.0.post0.dev352}/cuqi/experimental/mcmc/_laplace_approximation.py

@@ -49,7 +49,7 @@ class UGLANew(SamplerNew):
         where `sample` is the current sample and `sample_index` is the index of the sample.
         An example is shown in demos/demo31_callback.py.
     """
-    def __init__(self, target, initial_point=None, maxit=50, tol=1e-4, beta=1e-5, **kwargs):
+    def __init__(self, target=None, initial_point=None, maxit=50, tol=1e-4, beta=1e-5, **kwargs):
 
         super().__init__(target=target, initial_point=initial_point, **kwargs)
 

{cuqipy-1.0.0.post0.dev305 → cuqipy-1.0.0.post0.dev352}/cuqi/experimental/mcmc/_mh.py

@@ -24,7 +24,7 @@ class MHNew(ProposalBasedSamplerNew):
 
     _STATE_KEYS = ProposalBasedSamplerNew._STATE_KEYS.union({'scale', '_scale_temp'})
 
-    def __init__(self, target, proposal=None, scale=1, **kwargs):
+    def __init__(self, target=None, proposal=None, scale=1, **kwargs):
         super().__init__(target, proposal=proposal, scale=scale, **kwargs)
 
     def _initialize(self):

{cuqipy-1.0.0.post0.dev305 → cuqipy-1.0.0.post0.dev352}/cuqi/experimental/mcmc/_rto.py

@@ -189,7 +189,7 @@ class RegularizedLinearRTONew(LinearRTONew):
         An example is shown in demos/demo31_callback.py.
         
     """
-    def __init__(self, target, initial_point=None, maxit=100, stepsize="automatic", abstol=1e-10, adaptive=True, **kwargs):
+    def __init__(self, target=None, initial_point=None, maxit=100, stepsize="automatic", abstol=1e-10, adaptive=True, **kwargs):
         
         super().__init__(target=target, initial_point=initial_point, **kwargs)
 

{cuqipy-1.0.0.post0.dev305 → cuqipy-1.0.0.post0.dev352}/cuqi/experimental/mcmc/_sampler.py

@@ -43,7 +43,7 @@ class SamplerNew(ABC):
     _HISTORY_KEYS = {'_samples', '_acc'}
     """ Set of keys for the history dictionary. """
 
-    def __init__(self, target: cuqi.density.Density, initial_point=None, callback=None):
+    def __init__(self, target:cuqi.density.Density=None, initial_point=None, callback=None):
         """ Initializer for abstract base class for all samplers.
 
         Any subclassing samplers should simply store input parameters as part of the __init__ method. 
@@ -102,8 +102,18 @@ class SamplerNew(ABC):
         pass
 
     @abstractmethod
-    def tune(self):
-        """ Tune the parameters of the sampler. This method is called after each step of the warmup phase. """
+    def tune(self, skip_len, update_count):
+        """ Tune the parameters of the sampler. This method is called after each step of the warmup phase.
+
+        Parameters
+        ----------
+        skip_len : int
+            Defines the number of steps in between tuning (i.e. the tuning interval).
+
+        update_count : int
+            The number of times tuning has been performed. Can be used for internal bookkeeping.
+        
+        """
         pass
 
     @abstractmethod
@@ -385,6 +395,7 @@ class SamplerNew(ABC):
         """ Return a string representation of the sampler. """
         if self.target is None:
             return f"Sampler: {self.__class__.__name__} \n Target: None"
+        self._ensure_initialized()
         state = self.get_state()
         msg = f" Sampler: \n\t {self.__class__.__name__} \n Target: \n \t {self.target} \n Current state: \n"
         # Sort keys alphabetically

{cuqipy-1.0.0.post0.dev305 → cuqipy-1.0.0.post0.dev352}/tests/test_distribution.py

@@ -758,3 +758,25 @@ def test_Gaussian_from_linear_operator_sqrtprec():
     y_from_dense = cuqi.distribution.Gaussian(mean = np.zeros(N), sqrtprec = sqrtprec.todense())
 
     assert np.allclose(y_from_dense.logpdf(np.ones(N)), y_from_sparse.logpdf(np.ones(N)))
+
+@pytest.mark.parametrize("alpha, beta, gamma, expected",[
+                        (1.0, 2.0, 3.0, [0.77974597, 0.77361298, 0.5422682, 0.81054637, 1.35205349]),
+                        (128.0, 3.0, -4.0, [1.02250649, 1.05735833, 0.98794758, 1.04533337, 1.00500678])
+                        ])
+def test_MHN_sample_regression(alpha, beta, gamma, expected):
+    rng = np.random.RandomState(0)
+    dist = cuqi.distribution.ModifiedHalfNormal(alpha, beta, gamma)
+    samples = dist.sample(5,rng=rng).samples
+    assert np.allclose( samples, np.array(expected))
+
+@pytest.mark.parametrize("alpha, beta, gamma, expected_logpdf, expected_gradient",[
+                        (1.0, 2.0, 3.0, -40.0, [[-1.], [-3.], [-5.], [-7.], [-9.]]),
+                        (64.0, 3.0, -4.0, -2258.388020204731, [[-1.], [-160.5], [-299.], [-432.25], [-563.4 ]])
+                        ])
+def test_MHN_regression(alpha, beta, gamma, expected_logpdf, expected_gradient):
+    rng = np.random.RandomState(0)
+    dist = cuqi.distribution.ModifiedHalfNormal(alpha, beta, gamma)
+    logpdf = dist.logpdf(np.array([1.0, 2.0, 3.0, 4.0, 5.0]))
+    gradient = dist._gradient(np.array([1.0, 2.0, 3.0, 4.0, 5.0]))
+    assert np.allclose( logpdf, np.array(expected_logpdf))
+    assert np.allclose( gradient, np.array(expected_gradient))

{cuqipy-1.0.0.post0.dev305 → cuqipy-1.0.0.post0.dev352}/tests/test_distributions_shape.py

@@ -17,7 +17,7 @@ ignore_list = [
 
 # Define cases to skip (these are TODO)
 skip_logd = [
-    cuqi.distribution.Gamma # Missing force_ndarray
+    cuqi.distribution.Gamma, # Missing force_ndarray
 ]
 skip_sample = [
     cuqi.distribution.Gamma, # Missing force_ndarray
@@ -67,7 +67,8 @@ def test_multivariate_scalar_vars_logd(dist):
     val = np.random.randn(5)
     assert np.allclose(
         dist_from_vec.logd(val),
-        dist_from_dim.logd(val)
+        dist_from_dim.logd(val),
+        equal_nan=True
     )