CUQIpy 1.1.1.post0.dev7__py3-none-any.whl → 1.1.1.post0.dev36__py3-none-any.whl

{CUQIpy-1.1.1.post0.dev7.dist-info → CUQIpy-1.1.1.post0.dev36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.1.1.post0.dev7
+Version: 1.1.1.post0.dev36
 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.1.1.post0.dev7.dist-info → CUQIpy-1.1.1.post0.dev36.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cuqi/__init__.py,sha256=LsGilhl-hBLEn6Glt8S_l0OJzAA1sKit_rui8h-D-p0,488
 cuqi/_messages.py,sha256=fzEBrZT2kbmfecBBPm7spVu7yHdxGARQB4QzXhJbCJ0,415
-cuqi/_version.py,sha256=uVRNuD5Hnb14kKCLTMa_Wb7QhBn4Tavn4bdESiBfPz4,508
+cuqi/_version.py,sha256=PxeXIVclRTk3kiFawV6Oz6g5wmG2chZXbA1vtHlEXMY,509
 cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
 cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
 cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
@@ -49,7 +49,7 @@ cuqi/experimental/mcmc/_rto.py,sha256=OtzgiYCxDoTdXp7y4mkLa2upj74qadesoqHYpr11ZC
 cuqi/experimental/mcmc/_sampler.py,sha256=yzrbtBlqiajIHH151vocbD9SrHoCHj29wLP-IyrG3Mw,20017
 cuqi/experimental/mcmc/_utilities.py,sha256=kUzHbhIS3HYZRbneNBK41IogUYX5dS_bJxqEGm7TQBI,525
 cuqi/geometry/__init__.py,sha256=Tz1WGzZBY-QGH3c0GiyKm9XHN8MGGcnU6TUHLZkzB3o,842
-cuqi/geometry/_geometry.py,sha256=WYFC-4_VBTW73b2ldsnfGYKvdSiCE8plr89xTSmkadg,46804
+cuqi/geometry/_geometry.py,sha256=SDRZdiN2CIuS591lXxqgFoPWPIpwY-MHk75116QvdYY,46901
 cuqi/implicitprior/__init__.py,sha256=CaDQGYtmeFzN37vf3QUmKhcN9-H5lO66ZbK035k4qUw,246
 cuqi/implicitprior/_regularizedGMRF.py,sha256=IR9tKzNMoz-b0RKu6ahVgMx_lDNB3jZHVWFMQm6QqZk,6259
 cuqi/implicitprior/_regularizedGaussian.py,sha256=cQtrgzyJU2pwoK4ORGl1erKLE9VY5NqwZTiqiViDswA,12371
@@ -63,7 +63,7 @@ cuqi/operator/_operator.py,sha256=yNwPTh7jR07AiKMbMQQ5_54EgirlKFsbq9JN1EODaQI,88
 cuqi/pde/__init__.py,sha256=NyS_ZYruCvy-Yg24qKlwm3ZIX058kLNQX9bqs-xg4ZM,99
 cuqi/pde/_pde.py,sha256=WRkOYyIdT_T3aZepRh0aS9C5nBbUZUcHaA80iSRvgoo,12572
 cuqi/problem/__init__.py,sha256=JxJty4JqHTOqSG6NeTGiXRQ7OLxiRK9jvVq3lXLeIRw,38
-cuqi/problem/_problem.py,sha256=XvNbo7BXcnDZvj3n36f879QknTYg3_-jnKhkVvqUQto,31944
+cuqi/problem/_problem.py,sha256=t8y8NNQGKHYIbXN45FWuuwuU7pMgDdD8MS6az_1Tx8k,38160
 cuqi/sampler/__init__.py,sha256=D-dYa0gFgIwQukP8_VKhPGmlGKXbvVo7YqaET4SdAeQ,382
 cuqi/sampler/_conjugate.py,sha256=ztmUR3V3qZk9zelKx48ULnmMs_zKTDUfohc256VOIe8,2753
 cuqi/sampler/_conjugate_approx.py,sha256=xX-X71EgxGnZooOY6CIBhuJTs3dhcKfoLnoFxX3CO2g,1938
@@ -85,8 +85,8 @@ cuqi/testproblem/_testproblem.py,sha256=x769LwwRdJdzIiZkcQUGb_5-vynNTNALXWKato7s
 cuqi/utilities/__init__.py,sha256=H7xpJe2UinjZftKvE2JuXtTi4DqtkR6uIezStAXwfGg,428
 cuqi/utilities/_get_python_variable_name.py,sha256=QwlBVj2koJRA8s8pWd554p7-ElcI7HUwY32HknaR92E,1827
 cuqi/utilities/_utilities.py,sha256=Jc4knn80vLoA7kgw9FzXwKVFGaNBOXiA9kgvltZU3Ao,11777
-CUQIpy-1.1.1.post0.dev7.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
-CUQIpy-1.1.1.post0.dev7.dist-info/METADATA,sha256=8qP47Cs2y6ki9HTzz2bpn2PN9ll2WRno_-pKXrR0TRA,18389
-CUQIpy-1.1.1.post0.dev7.dist-info/WHEEL,sha256=ixB2d4u7mugx_bCBycvM9OzZ5yD7NmPXFRtKlORZS2Y,91
-CUQIpy-1.1.1.post0.dev7.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
-CUQIpy-1.1.1.post0.dev7.dist-info/RECORD,,
+CUQIpy-1.1.1.post0.dev36.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
+CUQIpy-1.1.1.post0.dev36.dist-info/METADATA,sha256=rFoEwQu_k2FhhCV3x8SEdJp_j-wVLNtnP198njDqVWc,18390
+CUQIpy-1.1.1.post0.dev36.dist-info/WHEEL,sha256=uCRv0ZEik_232NlR4YDw4Pv3Ajt5bKvMH13NUU7hFuI,91
+CUQIpy-1.1.1.post0.dev36.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
+CUQIpy-1.1.1.post0.dev36.dist-info/RECORD,,

{CUQIpy-1.1.1.post0.dev7.dist-info → CUQIpy-1.1.1.post0.dev36.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.0)
+Generator: setuptools (74.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-09-03T13:01:53+0200",
+ "date": "2024-09-04T13:31:10+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "6731d720ebd90ec077628febef51db45ce1738a4",
- "version": "1.1.1.post0.dev7"
+ "full-revisionid": "7852699550f6a8cb8bd6ad61a579e2eecb7cc964",
+ "version": "1.1.1.post0.dev36"
 }
 '''  # END VERSION_JSON
 

cuqi/geometry/_geometry.py

@@ -395,6 +395,8 @@ class Continuous1D(Continuous):
         self._grid = self._create_dimension(value)
 
     def _plot(self, values, *args, **kwargs):
+        if self.par_dim==1 and "marker" not in kwargs.keys():
+            kwargs["marker"] = "o"
         p = plt.plot(self.grid, values, *args, **kwargs)
         self._plot_config()
         return p

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