CUQIpy 1.3.0.post0.dev237__tar.gz → 1.3.0.post0.dev277__tar.gz

{cuqipy-1.3.0.post0.dev237 → cuqipy-1.3.0.post0.dev277}/CUQIpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CUQIpy
-Version: 1.3.0.post0.dev237
+Version: 1.3.0.post0.dev277
 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.3.0.post0.dev237 → cuqipy-1.3.0.post0.dev277}/CUQIpy.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ cuqi/distribution/_smoothed_laplace.py
 cuqi/distribution/_truncated_normal.py
 cuqi/distribution/_uniform.py
 cuqi/experimental/__init__.py
+cuqi/experimental/_recommender.py
 cuqi/experimental/algebra/__init__.py
 cuqi/experimental/algebra/_ast.py
 cuqi/experimental/algebra/_orderedset.py
@@ -64,7 +65,6 @@ cuqi/experimental/mcmc/_mh.py
 cuqi/experimental/mcmc/_pcn.py
 cuqi/experimental/mcmc/_rto.py
 cuqi/experimental/mcmc/_sampler.py
-cuqi/experimental/mcmc/_utilities.py
 cuqi/geometry/__init__.py
 cuqi/geometry/_geometry.py
 cuqi/implicitprior/__init__.py

{cuqipy-1.3.0.post0.dev237 → cuqipy-1.3.0.post0.dev277}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CUQIpy
-Version: 1.3.0.post0.dev237
+Version: 1.3.0.post0.dev277
 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.3.0.post0.dev237 → cuqipy-1.3.0.post0.dev277}/cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-05-15T09:06:20+0300",
+ "date": "2025-06-26T10:10:00+0300",
  "dirty": false,
  "error": null,
- "full-revisionid": "b9a5dd37abfe2ee51d5594630de54dd3469bfeca",
- "version": "1.3.0.post0.dev237"
+ "full-revisionid": "52c8f8ffc38956c4aee969ccc70cd3db24ee774e",
+ "version": "1.3.0.post0.dev277"
 }
 '''  # END VERSION_JSON
 

{cuqipy-1.3.0.post0.dev237 → cuqipy-1.3.0.post0.dev277}/cuqi/experimental/__init__.py

@@ -2,3 +2,4 @@
 from . import mcmc
 from . import algebra
 from . import geometry
+from ._recommender import SamplerRecommender

cuqipy-1.3.0.post0.dev277/cuqi/experimental/_recommender.py

@@ -0,0 +1,200 @@
+import cuqi
+import inspect
+import numpy as np
+
+# This import makes suggest_sampler easier to read
+import cuqi.experimental.mcmc as samplers 
+
+
+class SamplerRecommender(object):
+    """
+    This class can be used to automatically choose a sampler.
+
+    Parameters
+    ----------
+    target: Density or JointDistribution
+        Distribution to get sampler recommendations for.
+
+    exceptions: list[cuqi.experimental.mcmc.Sampler], *optional*
+        Samplers not to be recommended.
+    """
+
+    def __init__(self, target:cuqi.density.Density, exceptions = []):
+        self._target = target
+        self._exceptions = exceptions
+        self._create_ordering()
+
+    @property
+    def target(self) -> cuqi.density.Density:
+        """ Return the target Distribution. """
+        return self._target
+    
+    @target.setter
+    def target(self, value:cuqi.density.Density):
+        """ Set the target Distribution. Runs validation of the target. """
+        if value is None:
+            raise ValueError("Target needs to be of type cuqi.density.Density.")
+        self._target = value
+
+    def _create_ordering(self):
+        """
+        Every element in the ordering consists of a tuple:
+        (
+            Sampler: Class
+            boolean: additional conditions on the target
+            parameters: additional parameters to be passed to the sampler once initialized
+        )
+        """
+        number_of_components = np.sum(self._target.dim)
+
+        self._ordering = [
+            # Direct and Conjugate samplers
+            (samplers.Direct, True, {}),
+            (samplers.Conjugate, True, {}),
+            (samplers.ConjugateApprox, True, {}),
+            # Specialized samplers
+            (samplers.LinearRTO, True, {}),
+            (samplers.RegularizedLinearRTO, True, {}),
+            (samplers.UGLA, True, {}),
+            # Gradient.based samplers (Hamiltonian and Langevin)
+            (samplers.NUTS, True, {}),
+            (samplers.MALA, True, {}),
+            (samplers.ULA, True, {}),
+            # Gibbs and Componentwise samplers
+            (samplers.HybridGibbs, True, {"sampling_strategy" : self.recommend_HybridGibbs_sampling_strategy(as_string = False)}),
+            (samplers.CWMH, number_of_components <= 100, {"scale" : 0.05*np.ones(number_of_components),
+                            "initial_point" : 0.5*np.ones(number_of_components)}),
+            # Proposal based samplers
+            (samplers.PCN, True, {"scale" : 0.02}),
+            (samplers.MH, number_of_components <= 1000, {}),
+        ]
+
+    @property
+    def ordering(self):
+        """ Returns the ordered list of recommendation rules used by the recommender. """
+        return self._ordering
+    
+    def valid_samplers(self, as_string = True):
+        """
+        Finds all possible samplers that can be used for sampling from the target distribution.
+
+        Parameters
+        ----------
+
+        as_string : boolean
+            Whether to return the name of the sampler as a string instead of instantiating a sampler. *Optional*
+
+        """
+
+        all_samplers = [(name, cls) for name, cls in inspect.getmembers(cuqi.experimental.mcmc, inspect.isclass) if issubclass(cls, cuqi.experimental.mcmc.Sampler)]
+        valid_samplers = []
+
+        for name, sampler in all_samplers:
+            try:
+                sampler(self.target)
+                valid_samplers += [name if as_string else sampler]
+            except:
+                pass
+
+        # Need a separate case for HybridGibbs
+        if self.valid_HybridGibbs_sampling_strategy() is not None:
+            valid_samplers += [cuqi.experimental.mcmc.HybridGibbs.__name__ if as_string else cuqi.experimental.mcmc.HybridGibbs]
+
+        return valid_samplers
+    
+
+    def valid_HybridGibbs_sampling_strategy(self, as_string = True):
+        """
+            Find all possible sampling strategies to be used with the HybridGibbs sampler.
+            Returns None if no sampler could be suggested for at least one conditional distribution.
+
+            Parameters
+            ----------
+
+            as_string : boolean
+                Whether to return the name of the samplers in the sampling strategy as a string instead of instantiating samplers. *Optional*
+        
+
+        """
+
+        if not isinstance(self.target, cuqi.distribution.JointDistribution):
+            return None
+
+        par_names = self.target.get_parameter_names()
+
+        valid_samplers = dict()
+        for par_name in par_names:
+            conditional_params = {par_name_: np.ones(self.target.dim[i]) for i, par_name_ in enumerate(par_names) if par_name_ != par_name}
+            conditional = self.target(**conditional_params)
+
+            recommender = SamplerRecommender(conditional)
+            samplers = recommender.valid_samplers(as_string)
+            if len(samplers) == 0:
+                return None
+            
+            valid_samplers[par_name] = samplers
+
+        return valid_samplers
+    
+
+    def recommend(self, as_string = False):
+        """
+            Suggests a possible sampler that can be used for sampling from the target distribution.
+            Return None if no sampler could be suggested.
+
+            Parameters
+            ----------
+
+            as_string : boolean
+                Whether to return the name of the sampler as a string instead of instantiating a sampler. *Optional*
+
+        """
+
+        valid_samplers = self.valid_samplers(as_string = False)
+
+        for suggestion, flag, values in self._ordering:
+            if flag and (suggestion in valid_samplers) and (suggestion not in self._exceptions):
+                # Sampler found
+                if as_string:
+                    return suggestion.__name__
+                else:
+                    return suggestion(self.target, **values)
+
+        # No sampler can be suggested
+        raise ValueError("Cannot suggest any sampler. Either the provided distribution is incorrectly defined or there are too many exceptions provided.")
+
+    def recommend_HybridGibbs_sampling_strategy(self, as_string = False):
+        """
+            Suggests a possible sampling strategy to be used with the HybridGibbs sampler.
+            Returns None if no sampler could be suggested for at least one conditional distribution.
+
+            Parameters
+            ----------
+
+            target : `cuqi.distribution.JointDistribution`
+                The target distribution get a sampling strategy for.
+            
+            as_string : boolean
+                Whether to return the name of the samplers in the sampling strategy as a string instead of instantiating samplers. *Optional*
+        
+        """
+
+        if not isinstance(self.target, cuqi.distribution.JointDistribution):
+            return None
+
+        par_names = self.target.get_parameter_names()
+
+        suggested_samplers = dict()
+        for par_name in par_names:
+            conditional_params = {par_name_: np.ones(self.target.dim[i]) for i, par_name_ in enumerate(par_names) if par_name_ != par_name}
+            conditional = self.target(**conditional_params)
+
+            recommender = SamplerRecommender(conditional, exceptions = self._exceptions.copy())
+            sampler = recommender.recommend(as_string = as_string)
+
+            if sampler is None:
+                return None
+            
+            suggested_samplers[par_name] = sampler
+
+        return suggested_samplers

{cuqipy-1.3.0.post0.dev237 → cuqipy-1.3.0.post0.dev277}/cuqi/experimental/mcmc/__init__.py

@@ -120,4 +120,3 @@ from ._gibbs import HybridGibbs
 from ._conjugate import Conjugate
 from ._conjugate_approx import ConjugateApprox
 from ._direct import Direct
-from ._utilities import find_valid_samplers

{cuqipy-1.3.0.post0.dev237 → cuqipy-1.3.0.post0.dev277}/cuqi/experimental/mcmc/_gibbs.py

@@ -42,6 +42,10 @@ class HybridGibbs:
     fully stateful at this point. This means samplers like NUTS will lose
     their internal state between Gibbs steps.
 
+    The order in which the conditionals are sampled is the order of the
+    variables in the sampling strategy, unless a different sampling order
+    is specified by the parameter `scan_order`
+
     Parameters
     ----------
     target : cuqi.distribution.JointDistribution
@@ -58,6 +62,11 @@ class HybridGibbs:
         will call its step method in each Gibbs step.
         Default is 1 for all variables.
 
+    scan_order : list or str, *optional*
+        Order in which the conditional distributions are sampled.
+        If set to "random", use a random ordering at each step.
+        If not specified, it will be the order in the sampling_strategy.
+
     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)`.
@@ -107,7 +116,7 @@ class HybridGibbs:
             
     """
 
-    def __init__(self, target: JointDistribution, sampling_strategy: Dict[str, Sampler], num_sampling_steps: Dict[str, int] = None, callback=None):
+    def __init__(self, target: JointDistribution, sampling_strategy: Dict[str, Sampler], num_sampling_steps: Dict[str, int] = None, scan_order = None, callback=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)
@@ -121,6 +130,13 @@ class HybridGibbs:
         # Store parameter names
         self.par_names = self.target.get_parameter_names()
 
+        # Store the scan order
+        self._scan_order = scan_order
+
+        # Check that the parameters of the target align with the sampling_strategy and scan_order
+        if set(self.par_names) != set(self.scan_order):
+            raise ValueError("Parameter names in JointDistribution do not equal the names in the scan order.")
+
         # Initialize sampler (after target is set)
         self._initialize()
 
@@ -148,6 +164,16 @@ class HybridGibbs:
         # Validate all targets for samplers.
         self.validate_targets()
 
+    @property
+    def scan_order(self):
+        if self._scan_order is None:
+            return list(self.samplers.keys())
+        if self._scan_order == "random":
+            arr = list(self.samplers.keys())
+            np.random.shuffle(arr) # Shuffle works in-place
+            return arr
+        return self._scan_order
+
     # ------------ Public methods ------------
     def validate_targets(self):
         """ Validate each of the conditional targets used in the Gibbs steps """
@@ -217,7 +243,7 @@ class HybridGibbs:
         """ Sequentially go through all parameters and sample them conditionally on each other """
 
         # Sample from each conditional distribution
-        for par_name in self.par_names:
+        for par_name in self.scan_order:
 
             # Set target for current parameter
             self._set_target(par_name)

{cuqipy-1.3.0.post0.dev237 → cuqipy-1.3.0.post0.dev277}/tests/test_implicit_priors.py

@@ -210,8 +210,8 @@ def test_regression_increasing():
     posterior = joint(y=y_obs)
    
     sampling_strategy = {
+        'd': cuqi.experimental.mcmc.Conjugate(),
         'x': cuqi.experimental.mcmc.RegularizedLinearRTO(maxit=50, penalty_parameter=20, adaptive = False),
-        'd': cuqi.experimental.mcmc.Conjugate()
                         }
     sampler = cuqi.experimental.mcmc.HybridGibbs(posterior, sampling_strategy)
 
@@ -241,8 +241,8 @@ def test_regression_convex():
     posterior = joint(y=y_obs)
    
     sampling_strategy = {
-        'x': cuqi.experimental.mcmc.RegularizedLinearRTO(maxit=50, penalty_parameter=20, adaptive = False),
-        'd': cuqi.experimental.mcmc.Conjugate()
+        'd': cuqi.experimental.mcmc.Conjugate(),
+        'x': cuqi.experimental.mcmc.RegularizedLinearRTO(maxit=50, penalty_parameter=20, adaptive = False)
                         }
     sampler = cuqi.experimental.mcmc.HybridGibbs(posterior, sampling_strategy)
 

cuqipy-1.3.0.post0.dev237/cuqi/experimental/mcmc/_utilities.py

@@ -1,17 +0,0 @@
-import cuqi
-import inspect
-
-def find_valid_samplers(target):
-    """ Finds all samplers in the cuqi.experimental.mcmc module that accept the provided target. """
-
-    all_samplers = [(name, cls) for name, cls in inspect.getmembers(cuqi.experimental.mcmc, inspect.isclass) if issubclass(cls, cuqi.experimental.mcmc.Sampler)]
-    valid_samplers = []
-
-    for name, sampler in all_samplers:
-        try:
-            sampler(target)
-            valid_samplers += [name]
-        except:
-            pass
-
-    return valid_samplers