CUQIpy 1.1.1.post0.dev15__tar.gz → 1.1.1.post0.dev38__tar.gz

{cuqipy-1.1.1.post0.dev15 → cuqipy-1.1.1.post0.dev38}/CUQIpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.1.1.post0.dev15
+Version: 1.1.1.post0.dev38
 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
@@ -204,6 +204,7 @@ Requires-Dist: matplotlib
 Requires-Dist: numpy>=1.17.0
 Requires-Dist: scipy<1.13
 Requires-Dist: arviz
+Requires-Dist: tqdm
 
 <div align="center">
 <img src="https://cuqi-dtu.github.io/CUQIpy/_static/logo.png" alt="CUQIpy logo" width="250"/>

{cuqipy-1.1.1.post0.dev15 → cuqipy-1.1.1.post0.dev38}/CUQIpy.egg-info/requires.txt

@@ -2,3 +2,4 @@ matplotlib
 numpy>=1.17.0
 scipy<1.13
 arviz
+tqdm

{cuqipy-1.1.1.post0.dev15 → cuqipy-1.1.1.post0.dev38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.1.1.post0.dev15
+Version: 1.1.1.post0.dev38
 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
@@ -204,6 +204,7 @@ Requires-Dist: matplotlib
 Requires-Dist: numpy>=1.17.0
 Requires-Dist: scipy<1.13
 Requires-Dist: arviz
+Requires-Dist: tqdm
 
 <div align="center">
 <img src="https://cuqi-dtu.github.io/CUQIpy/_static/logo.png" alt="CUQIpy logo" width="250"/>

{cuqipy-1.1.1.post0.dev15 → cuqipy-1.1.1.post0.dev38}/cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-09-04T08:48:13+0200",
+ "date": "2024-09-09T21:48:47+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "651202293e69ec5fa33c7da436d77d65adb562bd",
- "version": "1.1.1.post0.dev15"
+ "full-revisionid": "98a74d508a1aa4659a6176a0126a90371a6be581",
+ "version": "1.1.1.post0.dev38"
 }
 '''  # END VERSION_JSON
 

{cuqipy-1.1.1.post0.dev15 → cuqipy-1.1.1.post0.dev38}/cuqi/problem/_problem.py

@@ -218,10 +218,10 @@ class BayesianProblem(object):
         """
         if disp:
             # Print warning to user about the automatic solver selection
-            print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
-            print("!!! Automatic solver selection is experimental. !!!")
-            print("!!!    Always validate the computed results.    !!!")
-            print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+            print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+            print("!!! Automatic solver selection is a work-in-progress !!!")
+            print("!!!      Always validate the computed results.       !!!")
+            print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
             print("")
 
         x_ML, solver_info = self._solve_max_point(self.likelihood, disp=disp, x0=x0)
@@ -254,10 +254,10 @@ class BayesianProblem(object):
 
         if disp:
             # Print warning to user about the automatic solver selection
-            print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
-            print("!!! Automatic solver selection is experimental. !!!")
-            print("!!!    Always validate the computed results.    !!!")
-            print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+            print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+            print("!!! Automatic solver selection is a work-in-progress !!!")
+            print("!!!      Always validate the computed results.       !!!")
+            print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
             print("")
 
         if self._check_posterior(self, Gaussian, Gaussian, LinearModel, max_dim=config.MAX_DIM_INV):
@@ -288,7 +288,7 @@ class BayesianProblem(object):
         x_MAP.info = solver_info
         return x_MAP
 
-    def sample_posterior(self, Ns, Nb=None, callback=None) -> cuqi.samples.Samples:
+    def sample_posterior(self, Ns, Nb=None, callback=None, experimental=False) -> cuqi.samples.Samples:
         """Sample the posterior. Sampler choice and tuning is handled automatically.
         
         Parameters
@@ -305,6 +305,9 @@ class BayesianProblem(object):
             where `sample` is the current sample and `sample_index` is the index of the sample.
             An example is shown in demos/demo31_callback.py.
 
+        experimental : bool, *Optional*
+            If set to True, the sampler selection will use the samplers from the :mod:`cuqi.experimental.mcmc` module.
+
         Returns
         -------
         samples : cuqi.samples.Samples
@@ -313,12 +316,18 @@ class BayesianProblem(object):
         """
 
         # Print warning to user about the automatic sampler selection
-        print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
-        print("!!! Automatic sampler selection is experimental. !!!")
-        print("!!!    Always validate the computed results.     !!!")
-        print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+        print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+        print("!!! Automatic sampler selection is a work-in-progress. !!!")
+        print("!!!       Always validate the computed results.        !!!")
+        print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
         print("")
 
+        if experimental:
+            print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+            print("!!!  Using samplers from cuqi.experimental.mcmc  !!!")
+            print("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+            print("")
+
         # Set up burn-in if not provided
         if Nb is None:
             Nb = int(0.2*Ns)
@@ -326,7 +335,7 @@ class BayesianProblem(object):
         # If target is a joint distribution, try Gibbs sampling
         # This is still very experimental!
         if isinstance(self._target, JointDistribution):       
-            return self._sampleGibbs(Ns, Nb, callback=callback)
+            return self._sampleGibbs(Ns, Nb, callback=callback, experimental=experimental)
 
         # For Gaussian small-scale we can use direct sampling
         if self._check_posterior(self, Gaussian, Gaussian, LinearModel, config.MAX_DIM_INV) and not self._check_posterior(self, GMRF):
@@ -334,24 +343,24 @@ class BayesianProblem(object):
 
         # For larger-scale Gaussian we use Linear RTO. TODO: Improve checking once we have a common Gaussian class.
         elif hasattr(self.prior,"sqrtprecTimesMean") and hasattr(self.likelihood.distribution,"sqrtprec") and isinstance(self.model,LinearModel):
-            return self._sampleLinearRTO(Ns, Nb, callback)
+            return self._sampleLinearRTO(Ns, Nb, callback, experimental=experimental)
 
         # For LMRF we use our awesome unadjusted Laplace approximation!
         elif self._check_posterior(self, LMRF, Gaussian):
-            return self._sampleUGLA(Ns, Nb, callback)
+            return self._sampleUGLA(Ns, Nb, callback, experimental=experimental)
 
         # If we have gradients, use NUTS!
         # TODO: Fix cases where we have gradients but NUTS fails (see checks)
         elif self._check_posterior(self, must_have_gradient=True) and not self._check_posterior(self, (Beta, InverseGamma, Lognormal)):
-            return self._sampleNUTS(Ns, Nb, callback)
+            return self._sampleNUTS(Ns, Nb, callback, experimental=experimental)
 
         # For Gaussians with non-linear model we use pCN
         elif self._check_posterior(self, (Gaussian, GMRF), Gaussian):
-            return self._samplepCN(Ns, Nb, callback)
+            return self._samplepCN(Ns, Nb, callback, experimental=experimental)
         
         # For Regularized Gaussians with linear models we use RegularizedLinearRTO
         elif self._check_posterior(self, (RegularizedGaussian, RegularizedGMRF), Gaussian, LinearModel):
-            return self._sampleRegularizedLinearRTO(Ns, Nb, callback)
+            return self._sampleRegularizedLinearRTO(Ns, Nb, callback, experimental=experimental)
 
         else:
             raise NotImplementedError(f"Automatic sampler choice is not implemented for model: {type(self.model)}, likelihood: {type(self.likelihood.distribution)} and prior: {type(self.prior)} and dim {self.prior.dim}. Manual sampler choice can be done via the 'sampler' module. Posterior distribution can be extracted via '.posterior' of any testproblem (BayesianProblem).")
@@ -384,7 +393,7 @@ class BayesianProblem(object):
         # Now sample prior problem
         return prior_problem.sample_posterior(Ns, Nb, callback)
 
-    def UQ(self, Ns=1000, Nb=None, percent=95, exact=None) -> cuqi.samples.Samples:
+    def UQ(self, Ns=1000, Nb=None, percent=95, exact=None, experimental=False) -> cuqi.samples.Samples:
         """ Run an Uncertainty Quantification (UQ) analysis on the Bayesian problem and provide a summary of the results.
         
         Parameters
@@ -402,13 +411,16 @@ class BayesianProblem(object):
         percent : float, *Optional*
             The credible interval to plot. Defaults to 95%.
 
+        experimental : bool, *Optional*
+            If set to True, the sampler selection will use the samplers from the :mod:`cuqi.experimental.mcmc` module.
+
         Returns
         -------
         samples : cuqi.samples.Samples
             Samples from the posterior. The samples can be used to compute further statistics and plots.
         """
         print(f"Computing {Ns} samples")
-        samples = self.sample_posterior(Ns, Nb)
+        samples = self.sample_posterior(Ns, Nb, experimental=experimental)
 
         print("Plotting results")
         # Gibbs case
@@ -475,19 +487,37 @@ class BayesianProblem(object):
         samples.funvals.vector.plot_variance()
         plt.title("Sample variance of function representation")
 
-    def _sampleLinearRTO(self, Ns, Nb, callback=None):
-        print("Using LinearRTO sampler.")
-        print(f"burn-in: {Nb/Ns*100:g}%")
+    def _sampleLinearRTO(self, Ns, Nb, callback=None, experimental=False):
 
-        # Start timing
-        ti = time.time()
+        if experimental:
 
-        # Sample
-        sampler = cuqi.sampler.LinearRTO(self.posterior, callback=callback)
-        samples = sampler.sample(Ns, Nb)
+            print("Using cuqi.experimental.mcmc LinearRTO sampler.")
+            print(f"burn-in: {Nb/Ns*100:g}%")
 
-        # Print timing
-        print('Elapsed time:', time.time() - ti)
+            sampler = cuqi.experimental.mcmc.LinearRTO(self.posterior, callback=callback)
+
+            ti = time.time()
+
+            sampler.warmup(Nb)
+            sampler.sample(Ns)
+            samples = sampler.get_samples().burnthin(Nb)
+
+            print('Elapsed time:', time.time() - ti)
+
+        else:
+
+            print("Using cuqi.sampler LinearRTO sampler.")
+            print(f"burn-in: {Nb/Ns*100:g}%")
+
+            # Start timing
+            ti = time.time()
+
+            # Sample
+            sampler = cuqi.sampler.LinearRTO(self.posterior, callback=callback)
+            samples = sampler.sample(Ns, Nb)
+
+            # Print timing
+            print('Elapsed time:', time.time() - ti)
 
         return samples
 
@@ -532,90 +562,180 @@ class BayesianProblem(object):
         
         return cuqi.samples.Samples(x_s,self.model.domain_geometry)
     
-    def _sampleCWMH(self, Ns, Nb, callback=None):
-        print("Using Component-wise Metropolis-Hastings (CWMH) sampler (sample_adapt)")
-        print(f"burn-in: {Nb/Ns*100:g}%, scale: 0.05, x0: 0.5 (vector)")
+    def _sampleCWMH(self, Ns, Nb, callback=None, experimental=False):
 
-        # Dimension
-        n = self.prior.dim
-        
-        # Set up target and proposal
-        def proposal(x_t, sigma): return np.random.normal(x_t, sigma)
+        if experimental:
 
-        # Set up sampler
-        scale = 0.05*np.ones(n)
-        x0 = 0.5*np.ones(n)
-        MCMC = cuqi.sampler.CWMH(self.posterior, proposal, scale, x0, callback=callback)
-        
-        # Run sampler
-        ti = time.time()
-        x_s = MCMC.sample_adapt(Ns,Nb); #ToDo: Make results class
-        print('Elapsed time:', time.time() - ti)
+            print("Using cuqi.experimental.mcmc Component-wise Metropolis-Hastings (CWMH) sampler.")
+            print(f"burn-in: {Nb/Ns*100:g}%, scale: 0.05, x0: 0.5 (vector)")
+
+            scale = 0.05*np.ones(self.prior.dim)
+            x0 = 0.5*np.ones(self.prior.dim)
+
+            sampler = cuqi.experimental.mcmc.CWMH(self.posterior, scale, x0, callback=callback)
+
+            ti = time.time()
+
+            sampler.warmup(Nb)
+            sampler.sample(Ns)
+            x_s = sampler.get_samples().burnthin(Nb)
+
+            print('Elapsed time:', time.time() - ti)
+
+        else:
+
+            print("Using cuqi.sampler Component-wise Metropolis-Hastings (CWMH) sampler (sample_adapt)")
+            print(f"burn-in: {Nb/Ns*100:g}%, scale: 0.05, x0: 0.5 (vector)")
+
+            # Dimension
+            n = self.prior.dim
+            
+            # Set up target and proposal
+            def proposal(x_t, sigma): return np.random.normal(x_t, sigma)
+
+            # Set up sampler
+            scale = 0.05*np.ones(n)
+            x0 = 0.5*np.ones(n)
+            MCMC = cuqi.sampler.CWMH(self.posterior, proposal, scale, x0, callback=callback)
+            
+            # Run sampler
+            ti = time.time()
+            x_s = MCMC.sample_adapt(Ns,Nb); #ToDo: Make results class
+            print('Elapsed time:', time.time() - ti)
         
         return x_s
 
-    def _samplepCN(self, Ns, Nb, callback=None):
-        print("Using preconditioned Crank-Nicolson (pCN) sampler (sample_adapt)")
-        print(f"burn-in: {Nb/Ns*100:g}%, scale: 0.02")
+    def _samplepCN(self, Ns, Nb, callback=None, experimental=False):
 
-        scale = 0.02
-        #x0 = np.zeros(n)
-        
-        MCMC = cuqi.sampler.pCN(self.posterior, scale, callback=callback)      
-        
-        #Run sampler
-        ti = time.time()
-        x_s = MCMC.sample_adapt(Ns, Nb)
-        print('Elapsed time:', time.time() - ti)
+        if experimental:
+
+            print("Using cuqi.experimental.mcmc preconditioned Crank-Nicolson (pCN) sampler.")
+            print(f"burn-in: {Nb/Ns*100:g}%, scale: 0.02")
+
+            scale = 0.02
+
+            sampler = cuqi.experimental.mcmc.pCN(self.posterior, scale, callback=callback)
+
+            ti = time.time()
+
+            sampler.warmup(Nb)
+            sampler.sample(Ns)
+            x_s = sampler.get_samples().burnthin(Nb)
+
+            print('Elapsed time:', time.time() - ti)
+
+        else:
+
+            print("Using cuqi.sampler preconditioned Crank-Nicolson (pCN) sampler (sample_adapt)")
+            print(f"burn-in: {Nb/Ns*100:g}%, scale: 0.02")
+
+            scale = 0.02
+            
+            MCMC = cuqi.sampler.pCN(self.posterior, scale, callback=callback)      
+            
+            #Run sampler
+            ti = time.time()
+            x_s = MCMC.sample_adapt(Ns, Nb)
+            print('Elapsed time:', time.time() - ti)
        
         return x_s
 
-    def _sampleNUTS(self, Ns, Nb, callback=None):
-        print("Using No-U-Turn (NUTS) sampler")
-        print(f"burn-in: {Nb/Ns*100:g}%")
+    def _sampleNUTS(self, Ns, Nb, callback=None, experimental=False):
 
-        # MAP
-        #print("Computing MAP ESTIMATE")
-        #x_map, _ = self.MAP()
-        
-        MCMC = cuqi.sampler.NUTS(self.posterior, callback=callback)
-        
-        # Run sampler
-        ti = time.time()
-        x_s = MCMC.sample_adapt(Ns,Nb)
-        print('Elapsed time:', time.time() - ti)
+        if experimental:
+
+            print("Using cuqi.experimental.mcmc No-U-Turn (NUTS) sampler.")
+            print(f"burn-in: {Nb/Ns*100:g}%")
+
+            sampler = cuqi.experimental.mcmc.NUTS(self.posterior, callback=callback)
+
+            ti = time.time()
+
+            sampler.warmup(Nb)
+            sampler.sample(Ns)
+            x_s = sampler.get_samples().burnthin(Nb)
+
+            print('Elapsed time:', time.time() - ti)
+
+        else:
+
+            print("Using cuqi.sampler No-U-Turn (NUTS) sampler")
+            print(f"burn-in: {Nb/Ns*100:g}%")
+            
+            MCMC = cuqi.sampler.NUTS(self.posterior, callback=callback)
+            
+            # Run sampler
+            ti = time.time()
+            x_s = MCMC.sample_adapt(Ns,Nb)
+            print('Elapsed time:', time.time() - ti)
         
         return x_s
 
-    def _sampleUGLA(self, Ns, Nb, callback=None):
-        print("Using UGLA sampler")
-        print(f"burn-in: {Nb/Ns*100:g}%")
+    def _sampleUGLA(self, Ns, Nb, callback=None, experimental=False):
 
-        # Start timing
-        ti = time.time()
+        if experimental:
 
-        # Sample
-        sampler = cuqi.sampler.UGLA(self.posterior, callback=callback)
-        samples = sampler.sample(Ns, Nb)
+            print("Using cuqi.experimental.mcmc Unadjusted Gaussian Laplace Approximation (UGLA) sampler.")
+            print(f"burn-in: {Nb/Ns*100:g}%")
 
-        # Print timing
-        print('Elapsed time:', time.time() - ti)
+            sampler = cuqi.experimental.mcmc.UGLA(self.posterior, callback=callback)
+
+            ti = time.time()
+
+            sampler.warmup(Nb)
+            sampler.sample(Ns)
+            samples = sampler.get_samples().burnthin(Nb)
+
+            print('Elapsed time:', time.time() - ti)
+
+        else:
+
+            print("Using cuqi.sampler UGLA sampler")
+            print(f"burn-in: {Nb/Ns*100:g}%")
+
+            # Start timing
+            ti = time.time()
+
+            # Sample
+            sampler = cuqi.sampler.UGLA(self.posterior, callback=callback)
+            samples = sampler.sample(Ns, Nb)
+
+            # Print timing
+            print('Elapsed time:', time.time() - ti)
 
         return samples
     
-    def _sampleRegularizedLinearRTO(self, Ns, Nb, callback=None):
-        print("Using Regularized LinearRTO sampler.")
-        print(f"burn-in: {Nb/Ns*100:g}%")
+    def _sampleRegularizedLinearRTO(self, Ns, Nb, callback=None, experimental=False):
 
-        # Start timing
-        ti = time.time()
+        if experimental:
 
-        # Sample
-        sampler = cuqi.sampler.RegularizedLinearRTO(self.posterior, maxit=100, stepsize = "automatic", abstol=1e-10, callback=callback)
-        samples = sampler.sample(Ns, Nb)
+            print("Using cuqi.experimental.mcmc Regularized LinearRTO sampler.")
+            print(f"burn-in: {Nb/Ns*100:g}%")
 
-        # Print timing
-        print('Elapsed time:', time.time() - ti)
+            sampler = cuqi.experimental.mcmc.RegularizedLinearRTO(self.posterior, maxit=100, stepsize = "automatic", abstol=1e-10, callback=callback)
+
+            ti = time.time()
+
+            sampler.warmup(Nb)
+            sampler.sample(Ns)
+            samples = sampler.get_samples().burnthin(Nb)
+
+            print('Elapsed time:', time.time() - ti)
+        
+        else:
+
+            print("Using cuqi.sampler Regularized LinearRTO sampler.")
+            print(f"burn-in: {Nb/Ns*100:g}%")
+
+            # Start timing
+            ti = time.time()
+
+            # Sample
+            sampler = cuqi.sampler.RegularizedLinearRTO(self.posterior, maxit=100, stepsize = "automatic", abstol=1e-10, callback=callback)
+            samples = sampler.sample(Ns, Nb)
+
+            # Print timing
+            print('Elapsed time:', time.time() - ti)
 
         return samples
 
@@ -719,31 +839,61 @@ class BayesianProblem(object):
 
         return L and P and M and D and G
 
-    def _sampleGibbs(self, Ns, Nb, callback=None):
+    def _sampleGibbs(self, Ns, Nb, callback=None, experimental=False):
         """ This is a helper function for sampling from the posterior using Gibbs sampler. """
 
-        print("Using Gibbs sampler")
-        print(f"burn-in: {Nb/Ns*100:g}%")
-        print("")
+        if experimental:
 
-        if callback is not None:
-            raise NotImplementedError("Callback not implemented for Gibbs sampler")
+            print("Using cuqi.experimental.mcmc HybridGibbs sampler")
+            print(f"burn-in: {Nb/Ns*100:g}%")
+            print("")
 
-        # Start timing
-        ti = time.time()
+            if callback is not None:
+                raise NotImplementedError("Callback not implemented for Gibbs sampler")
 
-        # Sampling strategy
-        sampling_strategy = self._determine_sampling_strategy()
+            # Start timing
+            ti = time.time()
 
-        sampler = cuqi.sampler.Gibbs(self._target, sampling_strategy)
-        samples = sampler.sample(Ns, Nb)
+            # Sampling strategy
+            sampling_strategy = self._determine_sampling_strategy(experimental=True)
 
-        # Print timing
-        print('Elapsed time:', time.time() - ti)
+            sampler = cuqi.experimental.mcmc.HybridGibbs(self._target, sampling_strategy)
+            sampler.warmup(Nb)
+            sampler.sample(Ns)
+            samples = sampler.get_samples()
+            # Dict with Samples objects for each parameter
+            # Now apply burnthin to each value in dict
+            for key, value in samples.items():
+                samples[key] = value.burnthin(Nb)
+            
+            # Print timing
+            print('Elapsed time:', time.time() - ti)
+
+        else:
+
+            print("Using Gibbs sampler")
+            print(f"burn-in: {Nb/Ns*100:g}%")
+            print("")
+
+            if callback is not None:
+                raise NotImplementedError("Callback not implemented for Gibbs sampler")
+
+            # Start timing
+            ti = time.time()
+
+            # Sampling strategy
+            sampling_strategy = self._determine_sampling_strategy()
+
+            sampler = cuqi.sampler.Gibbs(self._target, sampling_strategy)
+            samples = sampler.sample(Ns, Nb)
+
+            # Print timing
+            print('Elapsed time:', time.time() - ti)
 
         return samples
 
-    def _determine_sampling_strategy(self):
+
+    def _determine_sampling_strategy(self, experimental=False):
         """ This is a helper function for determining the sampling strategy for Gibbs sampler.
         
         It is still very experimental and not very robust.
@@ -774,31 +924,49 @@ class BayesianProblem(object):
                 raise NotImplementedError(f"Unable to determine sampling strategy for {par_name} with target {cond_target}")
 
             # Gamma prior, Gaussian likelihood -> Conjugate
-            if self._check_posterior(cond_target, Gamma, (Gaussian, GMRF, RegularizedGaussian, RegularizedGMRF)): 
-                sampling_strategy[par_name] = cuqi.sampler.Conjugate
+            if self._check_posterior(cond_target, Gamma, (Gaussian, GMRF, RegularizedGaussian, RegularizedGMRF)):
+                if experimental:
+                    sampling_strategy[par_name] = cuqi.experimental.mcmc.Conjugate()
+                else:
+                    sampling_strategy[par_name] = cuqi.sampler.Conjugate
 
             # Gamma prior, LMRF likelihood -> ConjugateApprox
             elif self._check_posterior(cond_target, Gamma, LMRF):
-                sampling_strategy[par_name] = cuqi.sampler.ConjugateApprox
+                if experimental:
+                    sampling_strategy[par_name] = cuqi.experimental.mcmc.ConjugateApprox()
+                else:
+                    sampling_strategy[par_name] = cuqi.sampler.ConjugateApprox
 
             # Gaussian prior, Gaussian likelihood, Linear model -> LinearRTO
             elif self._check_posterior(cond_target, (Gaussian, GMRF), Gaussian, LinearModel):
-                sampling_strategy[par_name] = cuqi.sampler.LinearRTO
+                if experimental:
+                    sampling_strategy[par_name] = cuqi.experimental.mcmc.LinearRTO()
+                else:
+                    sampling_strategy[par_name] = cuqi.sampler.LinearRTO
 
             # Implicit Regularized Gaussian prior, Gaussian likelihood, linear model -> RegularizedLinearRTO
             elif self._check_posterior(cond_target, (RegularizedGaussian, RegularizedGMRF), Gaussian, LinearModel):
-                sampling_strategy[par_name] = cuqi.sampler.RegularizedLinearRTO
+                if experimental:
+                    sampling_strategy[par_name] = cuqi.experimental.mcmc.RegularizedLinearRTO()
+                else:
+                    sampling_strategy[par_name] = cuqi.sampler.RegularizedLinearRTO
 
             # LMRF prior, Gaussian likelihood, Linear model -> UGLA
             elif self._check_posterior(cond_target, LMRF, Gaussian, LinearModel):
-                sampling_strategy[par_name] = cuqi.sampler.UGLA
+                if experimental:
+                    sampling_strategy[par_name] = cuqi.experimental.mcmc.UGLA()
+                else:
+                    sampling_strategy[par_name] = cuqi.sampler.UGLA
 
             else:
                 raise NotImplementedError(f"Unable to determine sampling strategy for {par_name} with target {cond_target}")
 
         print("Automatically determined sampling strategy:")
         for dist_name, strategy in sampling_strategy.items():
-            print(f"\t{dist_name}: {strategy.__name__}")
+            if experimental:
+                print(f"\t{dist_name}: {strategy.__class__.__name__} (mcmc.experimental)")
+            else:
+                print(f"\t{dist_name}: {strategy.__name__}")
         print("")
 
         return sampling_strategy

{cuqipy-1.1.1.post0.dev15 → cuqipy-1.1.1.post0.dev38}/requirements.txt

@@ -2,3 +2,4 @@ matplotlib
 numpy>=1.17.0
 scipy<1.13
 arviz
+tqdm

{cuqipy-1.1.1.post0.dev15 → cuqipy-1.1.1.post0.dev38}/tests/test_bayesian_inversion.py

@@ -20,7 +20,8 @@ from cuqi.density import Density
                              (Deconvolution1D, "square", RegularizedGaussian(np.zeros(128), 0.1, constraint="nonnegativity"), 100, False),
                              (Deconvolution1D, "square", RegularizedGMRF(np.zeros(128), 50, constraint="nonnegativity"), 100, False),
                          ])
-def test_TP_BayesianProblem_sample(copy_reference, TP_type, phantom, prior, Ns, use_legacy):
+@pytest.mark.parametrize("experimental", [False, True])
+def test_TP_BayesianProblem_sample(copy_reference, TP_type, phantom, prior, Ns, use_legacy, experimental):
     # SKIP NUTS test if not windows (for now)
     if isinstance(prior, CMRF) and not sys.platform.startswith('win'):
         pytest.skip("NUTS(CMRF) regression test is not implemented for this platform")
@@ -35,7 +36,7 @@ def test_TP_BayesianProblem_sample(copy_reference, TP_type, phantom, prior, Ns,
     TP.prior = prior
 
     # Sample posterior
-    samples = TP.sample_posterior(Ns=Ns)
+    samples = TP.sample_posterior(Ns=Ns, experimental=experimental)
 
     # Extract samples and compute properties
     res = samples.samples    
@@ -44,9 +45,14 @@ def test_TP_BayesianProblem_sample(copy_reference, TP_type, phantom, prior, Ns,
     lo95, up95 = np.percentile(res, [2.5, 97.5], axis=1)
 
     # Load reference file into temp folder and load
-    ref_fname = f"{TP_type.__name__}_{phantom}_{prior.__class__.__name__}_{Ns}"
-    #if isinstance(prior, LMRF): #Put the case you want to update for here.
+    if experimental:
+        ref_fname = f"{TP_type.__name__}_{phantom}_{prior.__class__.__name__}_{Ns}_experimental"
+    else:
+        ref_fname = f"{TP_type.__name__}_{phantom}_{prior.__class__.__name__}_{Ns}"
+
+    #if isinstance(prior, RegularizedGMRF): #Put the case you want to update for here.
     #    np.savez(ref_fname, median=med_xpos, sigma=sigma_xpos, lo95=lo95, up95=up95) #uncomment to update
+    
     ref_file = copy_reference(f"data/{ref_fname}.npz")
     ref = np.load(ref_file)
 
@@ -56,6 +62,7 @@ def test_TP_BayesianProblem_sample(copy_reference, TP_type, phantom, prior, Ns,
     assert lo95 == pytest.approx(ref["lo95"], rel=1e-3, abs=1e-6)
     assert up95 == pytest.approx(ref["up95"], rel=1e-3, abs=1e-6)
 
+@pytest.mark.parametrize("experimental", [False, True])
 @pytest.mark.parametrize("TP_type, phantom, priors, Ns",
     [
         # Case: Gaussian prior (no hyperparameters)
@@ -123,7 +130,7 @@ def test_TP_BayesianProblem_sample(copy_reference, TP_type, phantom, prior, Ns,
         ),
     ]
 )
-def test_Bayesian_inversion_hierarchical(TP_type: BayesianProblem, phantom: str, priors: Dict[str, Density], Ns: int):
+def test_Bayesian_inversion_hierarchical(TP_type: BayesianProblem, phantom: str, priors: Dict[str, Density], Ns: int, experimental: bool):
     """ This tests Bayesian inversion for Bayesian Problem using a hierarchical model.
     
     It is an end-to-end test that checks that the posterior samples are consistent with the expected shape.
@@ -144,9 +151,9 @@ def test_Bayesian_inversion_hierarchical(TP_type: BayesianProblem, phantom: str,
 
     # Sample posterior using UQ method
     if len(priors) == 1: # No hyperparameters
-        samples = BP.UQ(Ns=Ns, exact=probInfo.exactSolution)
+        samples = BP.UQ(Ns=Ns, exact=probInfo.exactSolution, experimental=experimental)
     else:
-        samples = BP.UQ(Ns=Ns, exact={priors[0].name: probInfo.exactSolution})
+        samples = BP.UQ(Ns=Ns, exact={priors[0].name: probInfo.exactSolution}, experimental=experimental)
 
     # No regression test yet, just check that the samples are the right shape
     if isinstance(samples, dict): # Gibbs case