CUQIpy 1.1.1.post0.dev36__py3-none-any.whl → 1.4.1.post0.dev124__py3-none-any.whl

cuqi/experimental/mcmc/_conjugate_approx.py

@@ -1,81 +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 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")
-        
-    def sample(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)
-
-        return dist.sample()

cuqi/experimental/mcmc/_cwmh.py

@@ -1,191 +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*
-        If set this function will be called after every sample.
-        The signature of the callback function is
-        `callback(sample, sample_index)`, where `sample` is the current sample
-        and `sample_index` is the index of the sample.
-        An example is shown in demos/demo31_callback.py.
-
-    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): # accept
-                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

cuqi/experimental/mcmc/_gibbs.py

@@ -1,268 +0,0 @@
-from cuqi.distribution import JointDistribution
-from cuqi.experimental.mcmc import Sampler
-from cuqi.samples import Samples
-from typing import Dict
-import numpy as np
-import warnings
-
-try:
-    from tqdm import tqdm
-except ImportError:
-    def tqdm(iterable, **kwargs):
-        warnings.warn("Module mcmc: tqdm not found. Install tqdm to get sampling progress.")
-        return iterable
-
-# Not subclassed from Sampler as Gibbs handles multiple samplers and samples multiple parameters
-# Similar approach as for JointDistribution
-class HybridGibbs: 
-    """
-    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.LinearRTO(maxit=15),
-            'd': cuqi.experimental.mcmc.Conjugate(),
-            'l': cuqi.experimental.mcmc.Conjugate(),
-        }
-
-        # Define Gibbs sampler
-        sampler = cuqi.experimental.mcmc.HybridGibbs(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, Sampler], 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) -> 'HybridGibbs':
-        """ Sample from the joint distribution using Gibbs sampling """
-        for _ in tqdm(range(Ns)):
-            self.step()
-            self._store_samples()
-
-    def warmup(self, Nb) -> 'HybridGibbs':
-        """ Warmup (tune) the Gibbs sampler """
-        for idx in tqdm(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:
-            sampler = self.samplers[par_name]
-            if sampler.initial_point is None:
-                sampler.initial_point = sampler._get_default_initial_point(self.target.get_density(par_name).dim)
-            initial_points[par_name] = sampler.initial_point
-            
-        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])