CUQIpy 1.2.0.post0.dev30__py3-none-any.whl → 1.2.0.post0.dev90__py3-none-any.whl

{CUQIpy-1.2.0.post0.dev30.dist-info → CUQIpy-1.2.0.post0.dev90.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.2.0.post0.dev30
+Version: 1.2.0.post0.dev90
 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.2.0.post0.dev30.dist-info → CUQIpy-1.2.0.post0.dev90.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=QJEhKLIZcwiFhDOxL5fW3HoGva9HIMdu-ceQvUCHsjs,509
+cuqi/_version.py,sha256=fadCQ-al0LVIaJsUncww5HgsVEcSF53R-lWs5uar-ow,509
 cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
 cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
 cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
@@ -14,7 +14,7 @@ cuqi/data/cookie.png,sha256=mr6wUeoIUc5VC2qYj8vafOmTbcRwz0fHz4IIPK9_PnE,984680
 cuqi/data/satellite.mat,sha256=a0Nz_Ak-Y0m360dH74pa_rpk-MhaQ91ftGTKhQX7I8g,16373
 cuqi/density/__init__.py,sha256=0zfVcPgqdqiPkss5n_WP_PUt-G3ovHXjokhqEKIlLwA,48
 cuqi/density/_density.py,sha256=BG7gtP0cbFYLVgjYQGkNAhM95PR5ocBVLKRlOVX2PyM,7253
-cuqi/distribution/__init__.py,sha256=4vVLArg6NVzBj67vVioK8BY6wISJKb5cOxdoHMuUb_s,714
+cuqi/distribution/__init__.py,sha256=Vvw-ge5HAF1now9n4rcwDicCsEUN9_jbbxlKxyzeUuY,761
 cuqi/distribution/_beta.py,sha256=lgN6PGoF9RXQtrMGqSaSBV0hw-LEsOfRTD2Q2L3-Ok4,2903
 cuqi/distribution/_cauchy.py,sha256=UsVXYz8HhagXN5fIWSAIyELqhsJAX_-wk9kkRGgRmA8,3296
 cuqi/distribution/_cmrf.py,sha256=tCbEulM_O7FB3C_W-3IqZp9zGHkTofCdFF0ybHc9UZI,3745
@@ -29,9 +29,10 @@ cuqi/distribution/_laplace.py,sha256=5exLvlzJm2AgfvZ3KUSkjfwlGwwbsktBxP8z0iLMik8
 cuqi/distribution/_lmrf.py,sha256=rdGoQ-fPe1oW6Z29P-l3woq0NX3_RxUQ2rzm1VzemNM,3290
 cuqi/distribution/_lognormal.py,sha256=8_hOFQ3iu88ujX8vxmfVEZ0fdmlhTY98PlG5PasPjEg,2612
 cuqi/distribution/_modifiedhalfnormal.py,sha256=eCg9YhH-zyX25V5WqdBwQykwG_90lm5Qc2901z7jFUE,7390
-cuqi/distribution/_normal.py,sha256=ohBk5bTZbDEkU0JqcNkkSQ4bDhTR2s-PXjA8d91L7Y4,1682
+cuqi/distribution/_normal.py,sha256=vhIiAseW09IKh1uy0KUq7RP1IuY7hH5aNM1W_R8Gd_Q,2912
 cuqi/distribution/_posterior.py,sha256=zAfL0GECxekZ2lBt1W6_LN0U_xskMwK4VNce5xAF7ig,5018
 cuqi/distribution/_smoothed_laplace.py,sha256=p-1Y23mYA9omwiHGkEuv3T2mwcPAAoNlCr7T8osNkjE,2925
+cuqi/distribution/_truncated_normal.py,sha256=sZkLYgnkGOyS_3ZxY7iw6L62t-Jh6shzsweRsRepN2k,4240
 cuqi/distribution/_uniform.py,sha256=KA8yQ6ZS3nQGS4PYJ4hpDg6Eq8EQKQvPsIpYfR8fj2w,1967
 cuqi/experimental/__init__.py,sha256=vhZvyMX6rl8Y0haqCzGLPz6PSUKyu75XMQbeDHqTTrw,83
 cuqi/experimental/mcmc/__init__.py,sha256=1sn0U6Ep0x5zv2602og2DkV3Bs8hNFOiq7C3VcMimVw,4472
@@ -39,14 +40,14 @@ cuqi/experimental/mcmc/_conjugate.py,sha256=VNPQkGity0mposcqxrx4UIeXm35EvJvZED4p
 cuqi/experimental/mcmc/_conjugate_approx.py,sha256=uEnY2ea9su5ivcNagyRAwpQP2gBY98sXU7N0y5hTADo,3653
 cuqi/experimental/mcmc/_cwmh.py,sha256=50v3uZaWhlVnfrEB5-lB_7pn8QoUVBe-xWxKGKbmNHg,7234
 cuqi/experimental/mcmc/_direct.py,sha256=9pQS_2Qk2-ybt6m8WTfPoKetcxQ00WaTRN85-Z0FrBY,777
-cuqi/experimental/mcmc/_gibbs.py,sha256=a_Zr007F233R6A3CJ_0zlQppsQrVuX8-oWCbNJWJxmA,12745
-cuqi/experimental/mcmc/_hmc.py,sha256=AR8ucnjPe9Q78em3IMoihLoifdBxu9oAjrQ51AYPHH4,19390
+cuqi/experimental/mcmc/_gibbs.py,sha256=evgxf2tLFLlKB3hN0qz9a9NcZQSES8wdacnn3uNWocQ,12005
+cuqi/experimental/mcmc/_hmc.py,sha256=8p4QxZBRpFLzwamH-DWHSdZE0aXX3FqonBzczz_XkDw,19340
 cuqi/experimental/mcmc/_langevin_algorithm.py,sha256=yNO7ABxmkixzcLG-lv57GOTyeTr7HwFs2DrrhuZW9OI,8398
 cuqi/experimental/mcmc/_laplace_approximation.py,sha256=rdiE3cMQFq6FLQcOQwPpuGIxrTAp3aoGPxMDSdeopV0,5688
 cuqi/experimental/mcmc/_mh.py,sha256=MXo0ahXP4KGFkaY4HtvcBE-TMQzsMlTmLKzSvpz7drU,2941
 cuqi/experimental/mcmc/_pcn.py,sha256=wqJBZLuRFSwxihaI53tumAg6AWVuceLMOmXssTetd1A,3374
 cuqi/experimental/mcmc/_rto.py,sha256=OtzgiYCxDoTdXp7y4mkLa2upj74qadesoqHYpr11ZCg,10061
-cuqi/experimental/mcmc/_sampler.py,sha256=lWb0ORdkYcVkZ6G0ypHfmrWXZPfaXnsUj1wAncKxa7g,20339
+cuqi/experimental/mcmc/_sampler.py,sha256=xtoT70T8xe3Ye7yYdIFQD_kivjXlqUImyV3bMt406nk,20106
 cuqi/experimental/mcmc/_utilities.py,sha256=kUzHbhIS3HYZRbneNBK41IogUYX5dS_bJxqEGm7TQBI,525
 cuqi/geometry/__init__.py,sha256=Tz1WGzZBY-QGH3c0GiyKm9XHN8MGGcnU6TUHLZkzB3o,842
 cuqi/geometry/_geometry.py,sha256=SDRZdiN2CIuS591lXxqgFoPWPIpwY-MHk75116QvdYY,46901
@@ -85,8 +86,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.2.0.post0.dev30.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
-CUQIpy-1.2.0.post0.dev30.dist-info/METADATA,sha256=lPVBe_Ad6ghqiE2CkcVDyABxmJ8Hb610VL0cZSxmVeo,18495
-CUQIpy-1.2.0.post0.dev30.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-CUQIpy-1.2.0.post0.dev30.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
-CUQIpy-1.2.0.post0.dev30.dist-info/RECORD,,
+CUQIpy-1.2.0.post0.dev90.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
+CUQIpy-1.2.0.post0.dev90.dist-info/METADATA,sha256=KBSZdCAb8ZYWIzYvHOZ4iqrog8QGiBynjOw0gbo_sis,18495
+CUQIpy-1.2.0.post0.dev90.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+CUQIpy-1.2.0.post0.dev90.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
+CUQIpy-1.2.0.post0.dev90.dist-info/RECORD,,

{CUQIpy-1.2.0.post0.dev30.dist-info → CUQIpy-1.2.0.post0.dev90.dist-info}/WHEEL

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

cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-10-11T09:05:14+0200",
+ "date": "2024-11-03T22:18:33+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "e46192df9743f4e53f2ad126462ed1fd95a97dd0",
- "version": "1.2.0.post0.dev30"
+ "full-revisionid": "8f8b00804a857370d46fd7bdf26cb9542a6b8f34",
+ "version": "1.2.0.post0.dev90"
 }
 '''  # END VERSION_JSON
 

cuqi/distribution/__init__.py

@@ -12,6 +12,7 @@ from ._laplace import Laplace
 from ._smoothed_laplace import SmoothedLaplace
 from ._lognormal import Lognormal
 from ._normal import Normal
+from ._truncated_normal import TruncatedNormal
 from ._posterior import Posterior
 from ._uniform import Uniform
 from ._custom import UserDefinedDistribution, DistributionGallery

cuqi/distribution/_normal.py

@@ -1,5 +1,8 @@
 import numpy as np
+import numbers
 from scipy.special import erf
+from cuqi.geometry import _get_identity_geometries
+from cuqi.utilities import force_ndarray
 from cuqi.distribution import Distribution
 
 class Normal(Distribution):
@@ -27,6 +30,24 @@ class Normal(Distribution):
         self.mean = mean
         self.std = std
 
+    @property
+    def mean(self):
+        """ Mean of the distribution """
+        return self._mean
+
+    @mean.setter
+    def mean(self, value):
+        self._mean = force_ndarray(value, flatten=True)
+
+    @property
+    def std(self):
+        """ Std of the distribution """
+        return self._std
+
+    @std.setter
+    def std(self, value):
+        self._std = force_ndarray(value, flatten=True)
+
     def pdf(self, x):
         return np.prod(1/(self.std*np.sqrt(2*np.pi))*np.exp(-0.5*((x-self.mean)/self.std)**2))
 
@@ -36,6 +57,19 @@ class Normal(Distribution):
     def cdf(self, x):
         return np.prod(0.5*(1 + erf((x-self.mean)/(self.std*np.sqrt(2)))))
 
+    def _gradient(self, val, *args, **kwargs):
+        if not type(self.geometry) in _get_identity_geometries():
+            raise NotImplementedError("Gradient not implemented for distribution {} with geometry {}".format(self,self.geometry))
+        if not callable(self.mean):
+            return -(val-self.mean)/(self.std**2)
+        elif hasattr(self.mean, "gradient"): # for likelihood
+            model = self.mean
+            dev = val - model.forward(*args, **kwargs)
+            print(dev)
+            return model.gradient(1.0/(np.array(self.std)) @ dev, *args, **kwargs)
+        else:
+            raise NotImplementedError("Gradient not implemented for distribution {} with location {}".format(self,self.mean))
+
     def _sample(self,N=1, rng=None):
 
         """

cuqi/distribution/_truncated_normal.py

@@ -0,0 +1,129 @@
+import numpy as np
+from scipy.special import erf
+from cuqi.utilities import force_ndarray
+from cuqi.distribution import Distribution
+from cuqi.distribution import Normal
+
+class TruncatedNormal(Distribution):
+    """
+    Truncated Normal probability distribution.
+    
+    Generates instance of cuqi.distribution.TruncatedNormal. 
+    It allows the user to specify upper and lower bounds on random variables 
+    represented by a Normal distribution. This distribution is suitable for a 
+    small dimension setup (e.g. `dim`=3 or 4). Using TruncatedNormal 
+    Distribution with a larger dimension can lead to a high rejection rate when
+    used within MCMC samplers.
+    
+    The variables of this distribution are iid.
+
+    
+    Parameters
+    ------------
+    mean : float or array_like of floats
+        mean of distribution
+    std : float or array_like of floats
+        standard deviation
+    low : float or array_like of floats
+        lower bound of the distribution
+    high : float or array_like of floats
+        upper bound of the distribution
+    
+    Example
+    -----------
+    .. code-block:: python
+
+        #Generate Normal with mean 0, standard deviation 1 and bounds [-2,2]
+        p = cuqi.distribution.TruncatedNormal(mean=0, std=1, low=-2, high=2)
+        samples = p.sample(5000)
+    """
+    def __init__(self, mean=None, std=None, low=-np.Inf, high=np.Inf, is_symmetric=False, **kwargs):
+        # Init from abstract distribution class
+        super().__init__(is_symmetric=is_symmetric, **kwargs)  
+
+        # Init specific to this distribution
+        self.mean = mean
+        self.std = std
+        self.low = low
+        self.high = high
+
+        # Init underlying normal distribution
+        self._normal = Normal(self.mean, self.std, is_symmetric=True, **kwargs)
+
+    @property
+    def mean(self):
+        """ Mean of the distribution """
+        return self._mean
+
+    @mean.setter
+    def mean(self, value):
+        self._mean = force_ndarray(value, flatten=True)
+        if hasattr(self, '_normal'):
+            self._normal.mean = self._mean
+
+    @property
+    def std(self):
+        """ Std of the distribution """
+        return self._std
+
+    @std.setter
+    def std(self, value):
+        self._std = force_ndarray(value, flatten=True)
+        if hasattr(self, '_normal'):
+            self._normal.std = self._std
+
+    @property
+    def low(self):
+        """ Lower bound of the distribution """
+        return self._low
+
+    @low.setter
+    def low(self, value):
+        self._low = force_ndarray(value, flatten=True)
+
+    @property
+    def high(self):
+        """ Higher bound of the distribution """
+        return self._high
+
+    @high.setter
+    def high(self, value):
+        self._high = force_ndarray(value, flatten=True)
+
+    def logpdf(self, x):
+        """
+        Computes the unnormalized logpdf at the given values of x.
+        """
+        # the unnormalized logpdf
+        # check if x falls in the range between np.array a and b
+        if np.any(x < self.low) or np.any(x > self.high):
+            return -np.Inf
+        else:
+             return self._normal.logpdf(x)
+
+    def _gradient(self, x, *args, **kwargs):
+        """
+        Computes the gradient of the unnormalized logpdf at the given values of x.
+        """
+        # check if x falls in the range between np.array a and b
+        if np.any(x < self.low) or np.any(x > self.high):
+            return np.NaN*np.ones_like(x)
+        else:
+            return self._normal.gradient(x, *args, **kwargs)
+
+    def _sample(self, N=1, rng=None):
+        """
+        Generates random samples from the distribution.
+        """
+        max_iter = 1e9 # maximum number of trials to avoid infinite loop
+        samples = []
+        for i in range(int(max_iter)):
+            if len(samples) == N:
+                break
+            sample = self._normal.sample(1,rng)
+            if np.all(sample >= self.low) and np.all(sample <= self.high):
+                samples.append(sample)
+        # raise a error if the number of iterations exceeds max_iter
+        if i == max_iter-1:
+            raise RuntimeError("Failed to generate {} samples within {} iterations".format(N, max_iter))
+        return np.array(samples).T.reshape(-1,N)

cuqi/experimental/mcmc/_gibbs.py

@@ -136,13 +136,7 @@ class HybridGibbs:
         self._set_targets()
 
         # Initialize the samplers
-        self._initialize_samplers() 
-
-        # Run over pre-sample methods for samplers that have it
-        # TODO. Some samplers (NUTS) seem to require to run _pre_warmup before _pre_sample
-        # This is not ideal and should be fixed in the future
-        for sampler in self.samplers.values():
-            self._pre_warmup_and_pre_sample_sampler(sampler)
+        self._initialize_samplers()
 
         # Validate all targets for samplers.
         self.validate_targets()
@@ -239,10 +233,6 @@ class HybridGibbs:
                 sampler.set_state(sampler_state)
                 sampler.set_history(sampler_history)
 
-            # Run pre_warmup and pre_sample methods for sampler
-            # TODO. Some samplers (NUTS) seem to require to run _pre_warmup before _pre_sample
-            self._pre_warmup_and_pre_sample_sampler(sampler)
-
             # Allow for multiple sampling steps in each Gibbs step
             for _ in range(self.num_sampling_steps[par_name]):
                 # Sampling step
@@ -291,10 +281,6 @@ class HybridGibbs:
                 self.num_sampling_steps[par_name] = 1
 
 
-    def _pre_warmup_and_pre_sample_sampler(self, sampler):
-        if hasattr(sampler, '_pre_warmup'): sampler._pre_warmup()
-        if hasattr(sampler, '_pre_sample'): sampler._pre_sample()
-
     def _set_targets(self):
         """ Set targets for all samplers using the current samples """
         par_names = self.par_names

cuqi/experimental/mcmc/_hmc.py

@@ -199,6 +199,9 @@ class NUTS(Sampler):
         self._reset_run_diagnostic_attributes()
 
     def step(self):
+        if isinstance(self._epsilon_bar, str) and self._epsilon_bar == "unset":
+            self._epsilon_bar = self._epsilon
+
         # Convert current_point, logd, and grad to numpy arrays
         # if they are CUQIarray objects
         if isinstance(self.current_point, CUQIarray):
@@ -212,9 +215,9 @@ class NUTS(Sampler):
         self._num_tree_node = 0
 
         # copy current point, logd, and grad in local variables
-        point_k = self.current_point.copy() # initial position (parameters)
+        point_k = self.current_point # initial position (parameters)
         logd_k = self.current_target_logd
-        grad_k = self.current_target_grad.copy() # initial gradient
+        grad_k = self.current_target_grad # initial gradient
         
         # compute r_k and Hamiltonian
         r_k = self._Kfun(1, 'sample') # resample momentum vector
@@ -225,9 +228,9 @@ class NUTS(Sampler):
 
         # initialization
         j, s, n = 0, 1, 1
-        point_minus, point_plus = np.copy(point_k), np.copy(point_k)
-        grad_minus, grad_plus = np.copy(grad_k), np.copy(grad_k)
-        r_minus, r_plus = np.copy(r_k), np.copy(r_k)
+        point_minus, point_plus = point_k.copy(), point_k.copy()
+        grad_minus, grad_plus = grad_k.copy(), grad_k.copy()
+        r_minus, r_plus = r_k.copy(), r_k.copy()
 
         # run NUTS
         acc = 0
@@ -255,9 +258,14 @@ class NUTS(Sampler):
                 (np.random.rand() <= alpha2) and \
                 (not np.isnan(logd_prime)) and \
                 (not np.isinf(logd_prime)):
-                self.current_point = point_prime
-                self.current_target_logd = logd_prime
-                self.current_target_grad = np.copy(grad_prime)
+                self.current_point = point_prime.copy()
+                # copy if array, else assign if scalar
+                self.current_target_logd = (
+                        logd_prime.copy()
+                        if isinstance(logd_prime, np.ndarray)
+                        else logd_prime
+                    )
+                self.current_target_grad = grad_prime.copy()
                 acc = 1
 
 
@@ -281,6 +289,9 @@ class NUTS(Sampler):
 
     def tune(self, skip_len, update_count):
         """ adapt epsilon during burn-in using dual averaging"""
+        if isinstance(self._epsilon_bar, str) and self._epsilon_bar == "unset":
+            self._epsilon_bar = 1
+
         k = update_count+1
 
         # Fixed parameters that do not change during the run
@@ -294,26 +305,6 @@ class NUTS(Sampler):
         self._epsilon_bar =\
             np.exp(eta*np.log(self._epsilon) +(1-eta)*np.log(self._epsilon_bar))
 
-    def _pre_warmup(self):
-
-        # Set up tuning parameters (only first time tuning is called)
-        # Note:
-        #  Parameters changes during the tune run
-        #    self._epsilon_bar
-        #    self._H_bar
-        #    self._epsilon
-        #  Parameters that does not change during the run
-        #    self._mu
-        self._ensure_initialized()
-        if self._epsilon_bar == "unset": # Initial value of epsilon_bar for tuning
-            self._epsilon_bar = 1
-
-    def _pre_sample(self):
-        self._ensure_initialized()
-        if self._epsilon_bar == "unset": # Initial value of epsilon_bar for sampling
-            self._epsilon_bar = self._epsilon
-            
-
     #=========================================================================
     def _nuts_target(self, x): # returns logposterior tuple evaluation-gradient
         return self.target.logd(x), self.target.gradient(x)
@@ -423,9 +414,14 @@ class NUTS(Sampler):
                 # Metropolis step
                 alpha2 = n_2prime / max(1, (n_prime + n_2prime))
                 if (np.random.rand() <= alpha2):
-                    point_prime = np.copy(point_2prime)
-                    logd_prime = np.copy(logd_2prime)
-                    grad_prime = np.copy(grad_2prime)
+                    point_prime = point_2prime.copy()
+                    # copy if array, else assign if scalar
+                    logd_prime = (
+                        logd_2prime.copy()
+                        if isinstance(logd_2prime, np.ndarray)
+                        else logd_2prime
+                    )
+                    grad_prime = grad_2prime.copy()
 
                 # update number of particles and stopping criterion
                 alpha_prime += alpha_2prime
@@ -465,4 +461,4 @@ class NUTS(Sampler):
         # Store the step size used in iteration k
         self.epsilon_list.append(eps)
         # Store the step size suggestion during adaptation in iteration k
-        self.epsilon_bar_list.append(eps_bar)
+        self.epsilon_bar_list.append(eps_bar)

cuqi/experimental/mcmc/_sampler.py

@@ -216,9 +216,6 @@ class Sampler(ABC):
         if batch_size > 0:
             batch_handler = _BatchHandler(batch_size, sample_path)
 
-        # Any code that needs to be run before sampling
-        if hasattr(self, "_pre_sample"): self._pre_sample()
-
         # Draw samples
         pbar = tqdm(range(Ns), "Sample: ")
         for idx in pbar:
@@ -260,9 +257,6 @@ class Sampler(ABC):
 
         tune_interval = max(int(tune_freq * Nb), 1)
 
-        # Any code that needs to be run before warmup
-        if hasattr(self, "_pre_warmup"): self._pre_warmup()
-
         # Draw warmup samples with tuning
         pbar = tqdm(range(Nb), "Warmup: ")
         for idx in pbar:
@@ -566,4 +560,4 @@ class _BatchHandler:
 
     def finalize(self):
         """ Finalize the batch handler. Flush any remaining samples to disk. """
-        self.flush()
+        self.flush()