CUQIpy 1.4.1__tar.gz → 1.4.1.post0.dev136__tar.gz

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/CUQIpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CUQIpy
-Version: 1.4.1
+Version: 1.4.1.post0.dev136
 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
@@ -201,7 +201,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib
-Requires-Dist: numpy>=1.17.0
+Requires-Dist: numpy<=2.2.0
 Requires-Dist: scipy==1.12.0; python_version <= "3.9"
 Requires-Dist: scipy; python_version > "3.9"
 Requires-Dist: arviz

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/CUQIpy.egg-info/SOURCES.txt

@@ -13,6 +13,10 @@ cuqi/_messages.py
 cuqi/_version.py
 cuqi/config.py
 cuqi/diagnostics.py
+cuqi/algebra/__init__.py
+cuqi/algebra/_abstract_syntax_tree.py
+cuqi/algebra/_ordered_set.py
+cuqi/algebra/_random_variable.py
 cuqi/array/__init__.py
 cuqi/array/_array.py
 cuqi/data/__init__.py
@@ -38,7 +42,7 @@ cuqi/distribution/_joint_distribution.py
 cuqi/distribution/_laplace.py
 cuqi/distribution/_lmrf.py
 cuqi/distribution/_lognormal.py
-cuqi/distribution/_modifiedhalfnormal.py
+cuqi/distribution/_modified_half_normal.py
 cuqi/distribution/_normal.py
 cuqi/distribution/_posterior.py
 cuqi/distribution/_smoothed_laplace.py
@@ -46,32 +50,27 @@ 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
-cuqi/experimental/algebra/_randomvariable.py
-cuqi/experimental/geometry/__init__.py
-cuqi/experimental/geometry/_productgeometry.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
-cuqi/experimental/mcmc/_mh.py
-cuqi/experimental/mcmc/_pcn.py
-cuqi/experimental/mcmc/_rto.py
-cuqi/experimental/mcmc/_sampler.py
 cuqi/geometry/__init__.py
 cuqi/geometry/_geometry.py
+cuqi/geometry/_product_geometry.py
 cuqi/implicitprior/__init__.py
-cuqi/implicitprior/_regularizedGMRF.py
-cuqi/implicitprior/_regularizedGaussian.py
-cuqi/implicitprior/_regularizedUnboundedUniform.py
+cuqi/implicitprior/_regularized_gaussian.py
+cuqi/implicitprior/_regularized_gmrf.py
+cuqi/implicitprior/_regularized_unbounded_uniform.py
 cuqi/implicitprior/_restorator.py
+cuqi/legacy/__init__.py
+cuqi/legacy/sampler/__init__.py
+cuqi/legacy/sampler/_conjugate.py
+cuqi/legacy/sampler/_conjugate_approx.py
+cuqi/legacy/sampler/_cwmh.py
+cuqi/legacy/sampler/_gibbs.py
+cuqi/legacy/sampler/_hmc.py
+cuqi/legacy/sampler/_langevin_algorithm.py
+cuqi/legacy/sampler/_laplace_approximation.py
+cuqi/legacy/sampler/_mh.py
+cuqi/legacy/sampler/_pcn.py
+cuqi/legacy/sampler/_rto.py
+cuqi/legacy/sampler/_sampler.py
 cuqi/likelihood/__init__.py
 cuqi/likelihood/_likelihood.py
 cuqi/model/__init__.py
@@ -79,6 +78,7 @@ cuqi/model/_model.py
 cuqi/operator/__init__.py
 cuqi/operator/_operator.py
 cuqi/pde/__init__.py
+cuqi/pde/_observation_map.py
 cuqi/pde/_pde.py
 cuqi/problem/__init__.py
 cuqi/problem/_problem.py
@@ -86,6 +86,7 @@ cuqi/sampler/__init__.py
 cuqi/sampler/_conjugate.py
 cuqi/sampler/_conjugate_approx.py
 cuqi/sampler/_cwmh.py
+cuqi/sampler/_direct.py
 cuqi/sampler/_gibbs.py
 cuqi/sampler/_hmc.py
 cuqi/sampler/_langevin_algorithm.py
@@ -103,22 +104,27 @@ cuqi/testproblem/_testproblem.py
 cuqi/utilities/__init__.py
 cuqi/utilities/_get_python_variable_name.py
 cuqi/utilities/_utilities.py
-tests/test_MRFs.py
 tests/test_abstract_distribution_density.py
+tests/test_algebra.py
 tests/test_bayesian_inversion.py
+tests/test_config.py
 tests/test_density.py
 tests/test_distribution.py
 tests/test_distributions_shape.py
 tests/test_geometry.py
 tests/test_implicit_priors.py
 tests/test_joint_distribution.py
+tests/test_legacy_sampler.py
 tests/test_likelihood.py
 tests/test_model.py
+tests/test_mrfs.py
 tests/test_pde.py
 tests/test_posterior.py
 tests/test_problem.py
-tests/test_sampler.py
+tests/test_product_geometry.py
+tests/test_random_variable.py
 tests/test_samples.py
 tests/test_solver.py
 tests/test_testproblem.py
-tests/test_utilities.py
+tests/test_utilities.py
+tests/test_z_mcmc.py

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/CUQIpy.egg-info/requires.txt

@@ -1,5 +1,5 @@
 matplotlib
-numpy>=1.17.0
+numpy<=2.2.0
 arviz
 tqdm
 

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CUQIpy
-Version: 1.4.1
+Version: 1.4.1.post0.dev136
 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
@@ -201,7 +201,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib
-Requires-Dist: numpy>=1.17.0
+Requires-Dist: numpy<=2.2.0
 Requires-Dist: scipy==1.12.0; python_version <= "3.9"
 Requires-Dist: scipy; python_version > "3.9"
 Requires-Dist: arviz

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/cuqi/__init__.py

@@ -1,6 +1,7 @@
 from . import data
 from . import density
 from . import diagnostics
+from . import algebra
 from . import distribution
 from . import experimental
 from . import geometry
@@ -11,6 +12,7 @@ from . import operator
 from . import pde
 from . import problem
 from . import sampler
+from . import legacy
 from . import array
 from . import samples
 from . import solver

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-12-08T21:20:50+0100",
+ "date": "2026-01-08T10:38:50+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "05c14e19b4b83a385793cc4c733893284608a9f2",
- "version": "1.4.1"
+ "full-revisionid": "5831beecd0dc3785bd3ed04c243b2ea1d63bfdc9",
+ "version": "1.4.1.post0.dev136"
 }
 '''  # END VERSION_JSON
 

cuqipy-1.4.1.post0.dev136/cuqi/algebra/__init__.py

@@ -0,0 +1,2 @@
+from ._abstract_syntax_tree import VariableNode, Node
+from ._random_variable import RandomVariable

cuqipy-1.4.1/cuqi/experimental/algebra/_randomvariable.py → cuqipy-1.4.1.post0.dev136/cuqi/algebra/_random_variable.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from typing import List, Any, Union
-from ._ast import VariableNode, Node
-from ._orderedset import _OrderedSet
+from ._abstract_syntax_tree import VariableNode, Node
+from ._ordered_set import _OrderedSet
 import operator
 import cuqi
 from cuqi.distribution import Distribution
@@ -58,7 +58,7 @@ class RandomVariable:
 
         from cuqi.testproblem import Deconvolution1D
         from cuqi.distribution import Gaussian, Gamma, GMRF
-        from cuqi.experimental.algebra import RandomVariable
+        from cuqi.algebra import RandomVariable
         from cuqi.problem import BayesianProblem
 
         import numpy as np
@@ -79,7 +79,7 @@ class RandomVariable:
     .. code-block:: python
 
         from cuqi.distribution import Gaussian, Gamma
-        from cuqi.experimental.algebra import RandomVariable, VariableNode
+        from cuqi.algebra import RandomVariable, VariableNode
 
         # Define the variables
         x = VariableNode('x')

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/cuqi/config.py

@@ -12,3 +12,10 @@ MAX_STACK_SEARCH_DEPTH = 1000
 
 MIN_DIM_SPARSE = 75
 """ Minimum dimension to start storing Nd-arrays as sparse for N>2. The minimum dimension is defined as MIN_DIM_SPARSE^N. """
+
+PROGRESS_BAR_DYNAMIC_UPDATE = True
+""" If True, progress bars are updated frequently (dynamic updates).
+If False, progress bars are minimal/static (only shown at start and end), 
+which is useful, for example, when building documentation or the Jupyter book
+(CUQI-Book).
+"""

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/cuqi/density/_density.py

@@ -143,7 +143,15 @@ class Density(ABC):
     def enable_FD(self, epsilon=1e-8):
         """ Enable finite difference approximation for logd gradient. Note
         that if enabled, the FD approximation will be used even if the 
-        _gradient method is implemented. """
+        _gradient method is implemented. 
+        
+        Parameters
+        ----------
+        epsilon : float
+
+        Spacing (step size) to use for finite difference approximation for logd
+        gradient for each variable. Default is 1e-8.
+        """
         self._FD_enabled = True
         self._FD_epsilon = epsilon
 

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/cuqi/distribution/__init__.py

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

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/cuqi/distribution/_distribution.py

@@ -419,5 +419,5 @@ class Distribution(Density, ABC):
     @property
     def rv(self):
         """ Return a random variable object representing the distribution. """
-        from cuqi.experimental.algebra import RandomVariable
+        from cuqi.algebra import RandomVariable
         return RandomVariable(self)

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/cuqi/distribution/_joint_distribution.py

@@ -62,16 +62,16 @@ class JointDistribution:
         posterior = joint(y=y_obs)
         
     """
-    def __init__(self, *densities: [Density, cuqi.experimental.algebra.RandomVariable]):
+    def __init__(self, *densities: [Density, cuqi.algebra.RandomVariable]):
         """ Create a joint distribution from the given densities. """
 
         # Check if all RandomVariables are simple (not-transformed)
         for density in densities:
-            if isinstance(density, cuqi.experimental.algebra.RandomVariable) and density.is_transformed:
+            if isinstance(density, cuqi.algebra.RandomVariable) and density.is_transformed:
                 raise ValueError(f"To be used in {self.__class__.__name__}, all RandomVariables must be untransformed.")
 
         # Convert potential random variables to their underlying distribution
-        densities = [density.distribution if isinstance(density, cuqi.experimental.algebra.RandomVariable) else density for density in densities]
+        densities = [density.distribution if isinstance(density, cuqi.algebra.RandomVariable) else density for density in densities]
 
         # Ensure all densities have unique names
         names = [density.name for density in densities]
@@ -84,6 +84,8 @@ class JointDistribution:
         cond_vars = self._get_conditioning_variables()
         if len(cond_vars) > 0:
             raise ValueError(f"Every density parameter must have a distribution (prior). Missing prior for {cond_vars}.")
+        # Initialize finite difference gradient approximation settings
+        self.disable_FD()
 
     # --------- Public properties ---------
     @property
@@ -96,6 +98,38 @@ class JointDistribution:
         """ Returns the geometries of the joint distribution. """
         return [dist.geometry for dist in self._distributions]
 
+    @property
+    def FD_enabled(self):
+        """ Returns a dictionary of keys and booleans indicating for each
+        parameter name (key) if finite difference approximation of the logd
+        gradient is enabled. """
+        par_names = self.get_parameter_names()
+        FD_enabled = {
+            par_name: self.FD_epsilon[par_name] is not None for par_name in par_names
+        }
+        return FD_enabled
+
+    @property
+    def FD_epsilon(self):
+        """ Returns a dictionary indicating for each parameter name the
+        spacing for the finite difference approximation of the logd gradient."""
+        return self._FD_epsilon
+
+    @FD_epsilon.setter
+    def FD_epsilon(self, value):
+        """ Set the spacing for the finite difference approximation of the
+        logd gradient as a dictionary. The keys are the parameter names.
+        The value for each key is either None (no FD approximation) or a float
+        representing the FD step size.
+        """
+        par_names = self.get_parameter_names()
+        if value is None:
+            self._FD_epsilon = {par_name: None for par_name in par_names}
+        else:
+            if set(value.keys()) != set(par_names):
+                raise ValueError("Keys of FD_epsilon must match the parameter names of the distribution "+f" {par_names}")
+            self._FD_epsilon = value
+
     # --------- Public methods ---------
     def logd(self, *args, **kwargs):
         """ Evaluate the un-normalized log density function. """
@@ -136,6 +170,33 @@ class JointDistribution:
         # Can reduce to Posterior, Likelihood or Distribution.
         return new_joint._reduce_to_single_density()
 
+    def enable_FD(self, epsilon=None):
+        """ Enable finite difference approximation for logd gradient. Note
+        that if enabled, the FD approximation will be used even if the 
+        _gradient method is implemented. By default, all parameters
+        will have FD enabled with a step size of 1e-8.
+        
+        Parameters
+        ----------
+        epsilon : dict, *optional*
+
+        Dictionary indicating the spacing (step size) to use for finite
+        difference approximation for logd gradient for each variable.
+
+        Keys are variable names.
+        Values are either a float to enable FD with the given value as the FD
+        step size, or None to disable FD for that variable. Default is 1e-8 for
+        all variables.
+        """
+        if epsilon is None:
+            epsilon = {par_name: 1e-8 for par_name in self.get_parameter_names()}
+        self.FD_epsilon = epsilon
+
+    def disable_FD(self):
+        """ Disable finite difference approximation for logd gradient. """
+        par_names = self.get_parameter_names()
+        self.FD_epsilon = {par_name: None for par_name in par_names}
+
     def get_parameter_names(self) -> List[str]:
         """ Returns the parameter names of the joint distribution. """
         return [dist.name for dist in self._distributions]
@@ -202,34 +263,58 @@ class JointDistribution:
         # Count number of distributions and likelihoods
         n_dist = len(self._distributions)
         n_likelihood = len(self._likelihoods)
+        reduced_FD_epsilon = {par_name:self.FD_epsilon[par_name] for par_name in self.get_parameter_names()}
+        self.enable_FD(epsilon=reduced_FD_epsilon)
 
         # Cant reduce if there are multiple distributions or likelihoods
         if n_dist > 1:
             return self
 
+        # If only evaluated densities left return joint to ensure logd method is available
+        if n_dist == 0 and n_likelihood == 0:
+            return self
+
+        # Extract the parameter name of the distribution
+        if n_dist == 1:
+            par_name = self._distributions[0].name
+        elif n_likelihood == 1:
+            par_name = self._likelihoods[0].name
+        else:
+            par_name = None
+
         # If exactly one distribution and multiple likelihoods reduce
         if n_dist == 1 and n_likelihood > 1:
-            return MultipleLikelihoodPosterior(*self._densities)
-        
+            reduced_distribution = MultipleLikelihoodPosterior(*self._densities)
+            reduced_FD_epsilon = {par_name:self.FD_epsilon[par_name]}
+
         # If exactly one distribution and one likelihood its a Posterior
         if n_dist == 1 and n_likelihood == 1:
             # Ensure parameter names match, otherwise return the joint distribution
             if set(self._likelihoods[0].get_parameter_names()) != set(self._distributions[0].get_parameter_names()):
                 return self
-            return self._add_constants_to_density(Posterior(self._likelihoods[0], self._distributions[0]))
+            reduced_distribution = Posterior(self._likelihoods[0], self._distributions[0])
+            reduced_distribution = self._add_constants_to_density(reduced_distribution)
+            reduced_FD_epsilon = self.FD_epsilon[par_name]
 
         # If exactly one distribution and no likelihoods its a Distribution
         if n_dist == 1 and n_likelihood == 0:
-            return self._add_constants_to_density(self._distributions[0])        
-        
+            # Intentionally skip enabling FD here. If the user wants FD, they
+            # can enable it for this particular distribution before forming
+            # the joint distribution.
+            return self._add_constants_to_density(self._distributions[0])
+
         # If no distributions and exactly one likelihood its a Likelihood
         if n_likelihood == 1 and n_dist == 0:
-            return self._likelihoods[0]
+            # This case seems to not happen in practice, but we include it for
+            # completeness.
+            reduced_distribution = self._likelihoods[0]
+            reduced_FD_epsilon = self.FD_epsilon[par_name] 
+
+        if self.FD_enabled[par_name]:
+            reduced_distribution.enable_FD(epsilon=reduced_FD_epsilon)
+
+        return reduced_distribution
 
-        # If only evaluated densities left return joint to ensure logd method is available
-        if n_dist == 0 and n_likelihood == 0:
-            return self
-        
     def _add_constants_to_density(self, density: Density):
         """ Add the constants (evaluated densities) to a single density. Used when reducing to single density. """
 
@@ -274,7 +359,7 @@ class JointDistribution:
                     if len(cond_vars) > 0:
                         msg += f"|{cond_vars}"
                     msg += ")"
-        
+
         msg += "\n"
         msg += "    Densities: \n"
 

cuqipy-1.4.1.post0.dev136/cuqi/experimental/__init__.py

@@ -0,0 +1,2 @@
+""" Experimental module for testing new features and ideas.  """
+from ._recommender import SamplerRecommender

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/cuqi/experimental/_recommender.py

@@ -3,7 +3,7 @@ import inspect
 import numpy as np
 
 # This import makes suggest_sampler easier to read
-import cuqi.experimental.mcmc as samplers 
+import cuqi.sampler as samplers 
 
 
 class SamplerRecommender(object):
@@ -15,7 +15,7 @@ class SamplerRecommender(object):
     target: Density or JointDistribution
         Distribution to get sampler recommendations for.
 
-    exceptions: list[cuqi.experimental.mcmc.Sampler], *optional*
+    exceptions: list[cuqi.sampler.Sampler], *optional*
         Samplers not to be recommended.
     
     Example
@@ -104,7 +104,7 @@ class SamplerRecommender(object):
 
         """
 
-        all_samplers = [(name, cls) for name, cls in inspect.getmembers(cuqi.experimental.mcmc, inspect.isclass) if issubclass(cls, cuqi.experimental.mcmc.Sampler)]
+        all_samplers = [(name, cls) for name, cls in inspect.getmembers(cuqi.sampler, inspect.isclass) if issubclass(cls, cuqi.sampler.Sampler)]
         valid_samplers = []
 
         for name, sampler in all_samplers:
@@ -116,7 +116,7 @@ class SamplerRecommender(object):
 
         # 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]
+            valid_samplers += [cuqi.sampler.HybridGibbs.__name__ if as_string else cuqi.sampler.HybridGibbs]
 
         return valid_samplers
 

{cuqipy-1.4.1 → cuqipy-1.4.1.post0.dev136}/cuqi/geometry/__init__.py

@@ -16,6 +16,8 @@ from ._geometry import (
     StepExpansion
 )
 
+from ._product_geometry import _ProductGeometry
+
 
 # TODO: We will remove the use of identity geometries in the future
 _identity_geometries = [_DefaultGeometry1D, _DefaultGeometry2D, Continuous1D, Continuous2D, Discrete, Image2D]

cuqipy-1.4.1/cuqi/experimental/geometry/_productgeometry.py → cuqipy-1.4.1.post0.dev136/cuqi/geometry/_product_geometry.py

@@ -17,7 +17,7 @@ class _ProductGeometry(Geometry):
     .. code-block:: python
         import numpy as np
         from cuqi.geometry import Continuous1D, Discrete
-        from cuqi.experimental.geometry import _ProductGeometry
+        from cuqi.geometry import _ProductGeometry
         geometry1 = Continuous1D(np.linspace(0, 1, 100))
         geometry2 = Discrete(["sound_speed"])
         product_geometry = _ProductGeometry(geometry1, geometry2)

cuqipy-1.4.1.post0.dev136/cuqi/implicitprior/__init__.py

@@ -0,0 +1,5 @@
+from ._regularized_gaussian import RegularizedGaussian, ConstrainedGaussian, NonnegativeGaussian
+from ._regularized_gmrf import RegularizedGMRF, ConstrainedGMRF, NonnegativeGMRF
+from ._regularized_unbounded_uniform import RegularizedUnboundedUniform
+from ._restorator import RestorationPrior, MoreauYoshidaPrior, TweediePrior
+

cuqipy-1.4.1.post0.dev136/cuqi/legacy/__init__.py

@@ -0,0 +1,2 @@
+""" Legacy module for functionalities that are no longer supported or developed. """
+from . import sampler

{cuqipy-1.4.1/cuqi → cuqipy-1.4.1.post0.dev136/cuqi/legacy}/sampler/_cwmh.py

@@ -1,6 +1,6 @@
 import numpy as np
 import cuqi
-from cuqi.sampler import ProposalBasedSampler
+from cuqi.legacy.sampler import ProposalBasedSampler
 
 
 class CWMH(ProposalBasedSampler):
@@ -48,7 +48,7 @@ class CWMH(ProposalBasedSampler):
         target = cuqi.distribution.UserDefinedDistribution(dim=dim, logpdf_func=logpdf_func)
 
         # Set up sampler
-        sampler = cuqi.sampler.CWMH(target, scale=1)
+        sampler = cuqi.legacy.sampler.CWMH(target, scale=1)
 
         # Sample
         samples = sampler.sample(2000)

{cuqipy-1.4.1/cuqi → cuqipy-1.4.1.post0.dev136/cuqi/legacy}/sampler/_gibbs.py

@@ -1,10 +1,10 @@
 from cuqi.distribution import JointDistribution
-from cuqi.sampler import Sampler
+from cuqi.legacy.sampler import Sampler
 from cuqi.samples import Samples
 from typing import Dict, Union
 import numpy as np
 import sys
-
+import warnings
 
 class Gibbs:
     """
@@ -52,12 +52,12 @@ class Gibbs:
 
         # Define sampling strategy
         sampling_strategy = {
-            'x': cuqi.sampler.LinearRTO,
-            ('d', 'l'): cuqi.sampler.Conjugate,
+            'x': cuqi.legacy.sampler.LinearRTO,
+            ('d', 'l'): cuqi.legacy.sampler.Conjugate,
         }
 
         # Define Gibbs sampler
-        sampler = cuqi.sampler.Gibbs(posterior, sampling_strategy)
+        sampler = cuqi.legacy.sampler.Gibbs(posterior, sampling_strategy)
 
         # Run sampler
         samples = sampler.sample(Ns=1000, Nb=200)
@@ -71,6 +71,10 @@ class Gibbs:
 
     def __init__(self, target: JointDistribution, sampling_strategy: Dict[Union[str,tuple], Sampler]):
 
+        warnings.warn(f"\nYou are using the legacy sampler '{self.__class__.__name__}'.\n"
+                      f"This will be removed in a future release of CUQIpy.\n"
+                      f"Please consider using the new samplers in the 'cuqi.sampler' module.\n", UserWarning, stacklevel=2)
+
         # 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)
 

{cuqipy-1.4.1/cuqi → cuqipy-1.4.1.post0.dev136/cuqi/legacy}/sampler/_hmc.py

@@ -1,5 +1,5 @@
 import numpy as np
-from cuqi.sampler import Sampler
+from cuqi.legacy.sampler import Sampler
 
 
 # another implementation is in https://github.com/mfouesneau/NUTS
@@ -50,7 +50,7 @@ class NUTS(Sampler):
         target = tp.posterior
 
         # Set up sampler
-        sampler = cuqi.sampler.NUTS(target)
+        sampler = cuqi.legacy.sampler.NUTS(target)
 
         # Sample
         samples = sampler.sample(10000, 5000)

{cuqipy-1.4.1/cuqi → cuqipy-1.4.1.post0.dev136/cuqi/legacy}/sampler/_langevin_algorithm.py

@@ -1,6 +1,6 @@
 import numpy as np
 import cuqi
-from cuqi.sampler import Sampler
+from cuqi.legacy.sampler import Sampler
 
 class ULA(Sampler):
     """Unadjusted Langevin algorithm (ULA) (Roberts and Tweedie, 1996)
@@ -55,12 +55,12 @@ class ULA(Sampler):
             gradient_func=gradient_func)
 
         # Set up sampler
-        sampler = cuqi.sampler.ULA(target, scale=1/dim**2)
+        sampler = cuqi.legacy.sampler.ULA(target, scale=1/dim**2)
 
         # Sample
         samples = sampler.sample(2000)
 
-    A Deblur example can be found in demos/demo27_ULA.py
+    A Deblur example can be found in demos/demo27_ula.py
     """
     def __init__(self, target, scale, x0=None, dim=None, rng=None, **kwargs):
         super().__init__(target, x0=x0, dim=dim, **kwargs)
@@ -162,12 +162,12 @@ class MALA(ULA):
             gradient_func=gradient_func)
 
         # Set up sampler
-        sampler = cuqi.sampler.MALA(target, scale=1/5**2)
+        sampler = cuqi.legacy.sampler.MALA(target, scale=1/5**2)
 
         # Sample
         samples = sampler.sample(2000)
 
-    A Deblur example can be found in demos/demo28_MALA.py
+    A Deblur example can be found in demos/demo28_mala.py
     """
     def __init__(self, target, scale, x0=None, dim=None, rng=None, **kwargs):
         super().__init__(target, scale, x0=x0, dim=dim, rng=rng, **kwargs)

{cuqipy-1.4.1/cuqi → cuqipy-1.4.1.post0.dev136/cuqi/legacy}/sampler/_laplace_approximation.py

@@ -3,7 +3,7 @@ import numpy as np
 import cuqi
 from cuqi.distribution import Normal
 from cuqi.solver import CGLS
-from cuqi.sampler import Sampler
+from cuqi.legacy.sampler import Sampler
 
 
 class UGLA(Sampler):

{cuqipy-1.4.1/cuqi → cuqipy-1.4.1.post0.dev136/cuqi/legacy}/sampler/_mh.py

@@ -1,6 +1,6 @@
 import numpy as np
 import cuqi
-from cuqi.sampler import ProposalBasedSampler
+from cuqi.legacy.sampler import ProposalBasedSampler
 
 
 class MH(ProposalBasedSampler):
@@ -48,7 +48,7 @@ class MH(ProposalBasedSampler):
         target = cuqi.distribution.UserDefinedDistribution(dim=dim, logpdf_func=logpdf_func)
 
         # Set up sampler
-        sampler = cuqi.sampler.MH(target, scale=1)
+        sampler = cuqi.legacy.sampler.MH(target, scale=1)
 
         # Sample
         samples = sampler.sample(2000)