CUQIpy 1.4.0.post0.dev13__py3-none-any.whl → 1.4.0.post0.dev41__py3-none-any.whl

cuqi/__init__.py

@@ -11,6 +11,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

cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-10-09T01:04:51+0300",
+ "date": "2025-10-09T13:25:50+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "3b38e05b811faaaa6eb273ee4a1d03438734ddd6",
- "version": "1.4.0.post0.dev13"
+ "full-revisionid": "92bb2e16f3828d8074c008d4ed6a08edcae0889d",
+ "version": "1.4.0.post0.dev41"
 }
 '''  # END VERSION_JSON
 

cuqi/experimental/__init__.py

@@ -1,5 +1,4 @@
 """ Experimental module for testing new features and ideas.  """
-from . import mcmc
 from . import algebra
 from . import geometry
-from ._recommender import SamplerRecommender
+from ._recommender import SamplerRecommender

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
 

cuqi/legacy/__init__.py

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

cuqi/legacy/sampler/__init__.py

@@ -0,0 +1,11 @@
+from ._sampler import Sampler, ProposalBasedSampler
+from ._conjugate import Conjugate
+from ._conjugate_approx import ConjugateApprox
+from ._cwmh import CWMH
+from ._gibbs import Gibbs
+from ._hmc import NUTS
+from ._langevin_algorithm import ULA, MALA
+from ._laplace_approximation import UGLA
+from ._mh import MH
+from ._pcn import pCN
+from ._rto import LinearRTO, RegularizedLinearRTO

cuqi/legacy/sampler/_conjugate.py

@@ -0,0 +1,55 @@
+from cuqi.distribution import Posterior, Gaussian, Gamma, GMRF
+from cuqi.implicitprior import RegularizedGaussian, RegularizedGMRF
+import numpy as np
+
+class Conjugate: # TODO: Subclass from Sampler once updated
+    """ Conjugate sampler
+
+    Sampler for sampling a posterior distribution where the likelihood and prior are conjugate.
+
+    Currently supported conjugate pairs are:
+    - (Gaussian, Gamma)
+    - (GMRF, Gamma)
+    - (RegularizedGaussian, Gamma) with nonnegativity constraints only
+
+    For more information on conjugate pairs, see https://en.wikipedia.org/wiki/Conjugate_prior.
+
+    For implicit regularized Gaussians see:
+    
+    [1] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Bayesian inference with projected densities." SIAM/ASA Journal on Uncertainty Quantification 11.3 (2023): 1025-1043.
+
+    """
+
+    def __init__(self, target: Posterior):
+        if not isinstance(target.likelihood.distribution, (Gaussian, GMRF, RegularizedGaussian, RegularizedGMRF)):
+            raise ValueError("Conjugate sampler only works with a Gaussian-type likelihood function")
+        if not isinstance(target.prior, Gamma):
+            raise ValueError("Conjugate sampler only works with Gamma prior")
+        if not target.prior.dim == 1:
+            raise ValueError("Conjugate sampler only works with univariate Gamma prior")
+            
+        if isinstance(target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)) and (target.likelihood.distribution.preset["constraint"] not in ["nonnegativity"] or target.likelihood.distribution.preset["regularization"] is not None) :
+               raise ValueError("Conjugate sampler only works implicit regularized Gaussian likelihood with nonnegativity constraints")
+        
+        self.target = target
+
+    def step(self, x=None):
+        # Extract variables
+        b = self.target.likelihood.data                                 #mu
+        m = self._calc_m_for_Gaussians(b)                               #n
+        Ax = self.target.likelihood.distribution.mean                   #x_i
+        L = self.target.likelihood.distribution(np.array([1])).sqrtprec #L
+        alpha = self.target.prior.shape                                 #alpha
+        beta = self.target.prior.rate                                   #beta
+
+        # Create Gamma distribution and sample
+        dist = Gamma(shape=m/2+alpha,rate=.5*np.linalg.norm(L@(Ax-b))**2+beta)
+
+        return dist.sample()
+
+    def _calc_m_for_Gaussians(self, b):
+        """ Helper method to calculate m parameter for Gaussian-Gamma conjugate pair. """
+        if isinstance(self.target.likelihood.distribution, (Gaussian, GMRF)):
+            return len(b)
+        elif isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)):
+            return np.count_nonzero(b) # See 

cuqi/legacy/sampler/_conjugate_approx.py

@@ -0,0 +1,52 @@
+from cuqi.distribution import Posterior, LMRF, Gamma
+import numpy as np
+import scipy as sp
+
+class ConjugateApprox: # TODO: Subclass from Sampler once updated
+    """ Approximate Conjugate sampler
+
+    Sampler for sampling a posterior distribution where the likelihood and prior can be approximated
+    by a conjugate pair.
+
+    Currently supported pairs are:
+    - (LMRF, Gamma): Approximated by (Gaussian, Gamma)
+
+    For more information on conjugate pairs, see https://en.wikipedia.org/wiki/Conjugate_prior.
+
+    """
+
+    
+    def __init__(self, target: Posterior):
+        if not isinstance(target.likelihood.distribution, LMRF):
+            raise ValueError("Conjugate sampler only works with Laplace diff likelihood function")
+        if not isinstance(target.prior, Gamma):
+            raise ValueError("Conjugate sampler only works with Gamma prior")
+        self.target = target
+
+    def step(self, x=None):
+        # Extract variables
+        # Here we approximate the Laplace diff with a Gaussian
+
+        # Extract diff_op from target likelihood
+        D = self.target.likelihood.distribution._diff_op
+        n = D.shape[0]
+
+        # Gaussian approximation of LMRF prior as function of x_k
+        # See Uribe et al. (2022) for details
+        # Current has a zero mean assumption on likelihood! TODO
+        beta=1e-5
+        def Lk_fun(x_k):
+            dd =  1/np.sqrt((D @ x_k)**2 + beta*np.ones(n))
+            W = sp.sparse.diags(dd)
+            return W.sqrt() @ D
+
+        x = self.target.likelihood.data                 #x
+        d = len(x)                                      #d
+        Lx = Lk_fun(x)@x                                #Lx
+        alpha = self.target.prior.shape                 #alpha
+        beta = self.target.prior.rate                   #beta
+
+        # Create Gamma distribution and sample
+        dist = Gamma(shape=d+alpha, rate=np.linalg.norm(Lx)**2+beta)
+
+        return dist.sample()

cuqi/legacy/sampler/_cwmh.py

@@ -0,0 +1,196 @@
+import numpy as np
+import cuqi
+from cuqi.legacy.sampler import ProposalBasedSampler
+
+
+class CWMH(ProposalBasedSampler):
+    """Component-wise Metropolis Hastings sampler.
+
+    Allows sampling of a target distribution by a component-wise random-walk sampling of a proposal distribution along with an accept/reject step.
+
+    Parameters
+    ----------
+
+    target : `cuqi.distribution.Distribution` or lambda function
+        The target distribution to sample. Custom logpdfs are supported by using a :class:`cuqi.distribution.UserDefinedDistribution`.
+    
+    proposal : `cuqi.distribution.Distribution` or callable method
+        The proposal to sample from. If a callable method it should provide a single independent sample from proposal distribution. Defaults to a Gaussian proposal.  *Optional*.
+
+    scale : float
+        Scale parameter used to define correlation between previous and proposed sample in random-walk.  *Optional*.
+
+    x0 : ndarray
+        Initial parameters. *Optional*
+
+    dim : int
+        Dimension of parameter space. Required if target and proposal are callable functions. *Optional*.
+
+    callback : callable, *Optional*
+        If set this function will be called after every sample.
+        The signature of the callback function is `callback(sample, sample_index)`,
+        where `sample` is the current sample and `sample_index` is the index of the sample.
+        An example is shown in demos/demo31_callback.py.
+
+    Example
+    -------
+    .. code-block:: python
+
+        # Parameters
+        dim = 5 # Dimension of distribution
+        mu = np.arange(dim) # Mean of Gaussian
+        std = 1 # standard deviation of Gaussian
+
+        # Logpdf function
+        logpdf_func = lambda x: -1/(std**2)*np.sum((x-mu)**2)
+
+        # Define distribution from logpdf as UserDefinedDistribution (sample and gradients also supported as inputs to UserDefinedDistribution)
+        target = cuqi.distribution.UserDefinedDistribution(dim=dim, logpdf_func=logpdf_func)
+
+        # Set up sampler
+        sampler = cuqi.legacy.sampler.CWMH(target, scale=1)
+
+        # Sample
+        samples = sampler.sample(2000)
+
+    """
+    def __init__(self, target,  proposal=None, scale=1, x0=None, dim = None, **kwargs):
+        super().__init__(target, proposal=proposal, scale=scale,  x0=x0, dim=dim, **kwargs)
+        
+    @ProposalBasedSampler.proposal.setter 
+    def proposal(self, value):
+        fail_msg = "Proposal should be either None, cuqi.distribution.Distribution conditioned only on 'location' and 'scale', lambda function, or cuqi.distribution.Normal conditioned only on 'mean' and 'std'"
+
+        if value is None:
+            self._proposal = cuqi.distribution.Normal(mean = lambda location:location,std = lambda scale:scale, geometry=self.dim)
+
+        elif isinstance(value, cuqi.distribution.Distribution) and sorted(value.get_conditioning_variables())==['location','scale']:
+            self._proposal = value
+
+        elif isinstance(value, cuqi.distribution.Normal) and sorted(value.get_conditioning_variables())==['mean','std']:
+            self._proposal = value(mean = lambda location:location, std = lambda scale:scale)
+
+        elif not isinstance(value, cuqi.distribution.Distribution) and callable(value):
+            self._proposal = value
+
+        else:
+            raise ValueError(fail_msg)
+
+
+    def _sample(self, N, Nb):
+        Ns = N+Nb   # number of simulations
+
+        # allocation
+        samples = np.empty((self.dim, Ns))
+        target_eval = np.empty(Ns)
+        acc = np.zeros((self.dim, Ns), dtype=int)
+
+        # initial state    
+        samples[:, 0] = self.x0
+        target_eval[0] = self.target.logd(self.x0)
+        acc[:, 0] = np.ones(self.dim)
+
+        # run MCMC
+        for s in range(Ns-1):
+            # run component by component
+            samples[:, s+1], target_eval[s+1], acc[:, s+1] = self.single_update(samples[:, s], target_eval[s])
+
+            self._print_progress(s+2,Ns) #s+2 is the sample number, s+1 is index assuming x0 is the first sample
+            self._call_callback(samples[:, s+1], s+1)
+
+        # remove burn-in
+        samples = samples[:, Nb:]
+        target_eval = target_eval[Nb:]
+        acccomp = acc[:, Nb:].mean(axis=1)   
+        print('\nAverage acceptance rate all components:', acccomp.mean(), '\n')
+        
+        return samples, target_eval, acccomp
+
+    def _sample_adapt(self, N, Nb):
+        # this follows the vanishing adaptation Algorithm 4 in:
+        # Andrieu and Thoms (2008) - A tutorial on adaptive MCMC
+        Ns = N+Nb   # number of simulations
+
+        # allocation
+        samples = np.empty((self.dim, Ns))
+        target_eval = np.empty(Ns)
+        acc = np.zeros((self.dim, Ns), dtype=int)
+
+        # initial state
+        samples[:, 0] = self.x0
+        target_eval[0] = self.target.logd(self.x0)
+        acc[:, 0] = np.ones(self.dim)
+
+        # initial adaptation params 
+        Na = int(0.1*N)                                        # iterations to adapt
+        hat_acc = np.empty((self.dim, int(np.floor(Ns/Na))))     # average acceptance rate of the chains
+        lambd = np.empty((self.dim, int(np.floor(Ns/Na)+1)))     # scaling parameter \in (0,1)
+        lambd[:, 0] = self.scale
+        star_acc = 0.21/self.dim + 0.23    # target acceptance rate RW
+        i, idx = 0, 0
+
+        # run MCMC
+        for s in range(Ns-1):
+            # run component by component
+            samples[:, s+1], target_eval[s+1], acc[:, s+1] = self.single_update(samples[:, s], target_eval[s])
+            
+            # adapt prop spread of each component using acc of past samples
+            if ((s+1) % Na == 0):
+                # evaluate average acceptance rate
+                hat_acc[:, i] = np.mean(acc[:, idx:idx+Na], axis=1)
+
+                # compute new scaling parameter
+                zeta = 1/np.sqrt(i+1)   # ensures that the variation of lambda(i) vanishes
+                lambd[:, i+1] = np.exp(np.log(lambd[:, i]) + zeta*(hat_acc[:, i]-star_acc))  
+
+                # update parameters
+                self.scale = np.minimum(lambd[:, i+1], np.ones(self.dim))
+
+                # update counters
+                i += 1
+                idx += Na
+
+            # display iterations 
+            self._print_progress(s+2,Ns) #s+2 is the sample number, s+1 is index assuming x0 is the first sample
+            self._call_callback(samples[:, s+1], s+1)
+            
+        # remove burn-in
+        samples = samples[:, Nb:]
+        target_eval = target_eval[Nb:]
+        acccomp = acc[:, Nb:].mean(axis=1)
+        print('\nAverage acceptance rate all components:', acccomp.mean(), '\n')
+        
+        return samples, target_eval, acccomp
+
+    def single_update(self, x_t, target_eval_t):
+        if isinstance(self.proposal,cuqi.distribution.Distribution):
+            x_i_star = self.proposal(location= x_t, scale = self.scale).sample()
+        else:
+            x_i_star = self.proposal(x_t, self.scale) 
+        x_star = x_t.copy()
+        acc = np.zeros(self.dim)
+
+        for j in range(self.dim):
+            # propose state
+            x_star[j] = x_i_star[j]
+
+            # evaluate target
+            target_eval_star = self.target.logd(x_star)
+
+            # ratio and acceptance probability
+            ratio = target_eval_star - target_eval_t  # proposal is symmetric
+            alpha = min(0, ratio)
+
+            # accept/reject
+            u_theta = np.log(np.random.rand())
+            if (u_theta <= alpha):
+                x_t[j] = x_i_star[j]
+                target_eval_t = target_eval_star
+                acc[j] = 1
+            else:
+                pass
+                # x_t[j]       = x_t[j]
+                # target_eval_t = target_eval_t
+            x_star = x_t.copy()
+        #
+        return x_t, target_eval_t, acc

cuqi/legacy/sampler/_gibbs.py

@@ -0,0 +1,231 @@
+from cuqi.distribution import JointDistribution
+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:
+    """
+    Gibbs sampler for sampling a joint distribution.
+
+    Gibbs sampling samples the variables of the distribution sequentially,
+    one variable at a time. When a variable represents a random vector, the
+    whole vector is sampled simultaneously.
+    
+    The sampling of each variable is done by sampling from the conditional
+    distribution of that variable given the values of the other variables.
+    This is often a very efficient way of sampling from a joint distribution
+    if the conditional distributions are easy to sample from.
+
+    Parameters
+    ----------
+    target : cuqi.distribution.JointDistribution
+        Target distribution to sample from.
+    
+    sampling_strategy : dict
+        Dictionary of sampling strategies for each parameter.
+        Keys are parameter names.
+        Values are sampler objects.
+
+    Example
+    -------
+    .. code-block:: python
+
+        import cuqi
+        import numpy as np
+
+        # Model and data
+        A, y_obs, probinfo = cuqi.testproblem.Deconvolution1D(phantom='square').get_components()
+        n = A.domain_dim
+
+        # Define distributions
+        d = cuqi.distribution.Gamma(1, 1e-4)
+        l = cuqi.distribution.Gamma(1, 1e-4)
+        x = cuqi.distribution.GMRF(np.zeros(n), lambda d: d)
+        y = cuqi.distribution.Gaussian(A, lambda l: 1/l)
+
+        # Combine into a joint distribution and create posterior
+        joint = cuqi.distribution.JointDistribution(d, l, x, y)
+        posterior = joint(y=y_obs)
+
+        # Define sampling strategy
+        sampling_strategy = {
+            'x': cuqi.legacy.sampler.LinearRTO,
+            ('d', 'l'): cuqi.legacy.sampler.Conjugate,
+        }
+
+        # Define Gibbs sampler
+        sampler = cuqi.legacy.sampler.Gibbs(posterior, sampling_strategy)
+
+        # Run sampler
+        samples = sampler.sample(Ns=1000, Nb=200)
+
+        # Plot results
+        samples['x'].plot_ci(exact=probinfo.exactSolution)
+        samples['d'].plot_trace(figsize=(8,2))
+        samples['l'].plot_trace(figsize=(8,2))
+            
+    """
+
+    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)
+
+        # Parse samplers and split any keys that are tuple into separate keys
+        self.samplers = {}
+        for par_name in sampling_strategy.keys():
+            if isinstance(par_name, tuple):
+                for par_name_ in par_name:
+                    self.samplers[par_name_] = sampling_strategy[par_name]
+            else:
+                self.samplers[par_name] = sampling_strategy[par_name]
+
+        # Store parameter names
+        self.par_names = self.target.get_parameter_names()
+
+    # ------------ Public methods ------------
+    def sample(self, Ns, Nb=0):
+        """ Sample from target distribution """
+
+        # Initial points
+        current_samples = self._get_initial_points()
+
+        # Compute how many samples were already taken previously
+        at_Nb = self._Nb
+        at_Ns = self._Ns
+
+        # Allocate memory for samples
+        self._allocate_samples_warmup(Nb)
+        self._allocate_samples(Ns)
+
+        # Sample tuning phase
+        for i in range(at_Nb, at_Nb+Nb):
+            current_samples = self.step_tune(current_samples)
+            self._store_samples(self.samples_warmup, current_samples, i)
+            self._print_progress(i+1+at_Nb, at_Nb+Nb, 'Warmup')
+
+        # Sample phase
+        for i in range(at_Ns, at_Ns+Ns):
+            current_samples = self.step(current_samples)
+            self._store_samples(self.samples, current_samples, i)
+            self._print_progress(i+1, at_Ns+Ns, 'Sample')
+
+        # Convert to samples objects and return
+        return self._convert_to_Samples(self.samples)
+
+    def step(self, current_samples):
+        """ Sequentially go through all parameters and sample them conditionally on each other """
+
+        # Extract par names
+        par_names = self.par_names
+
+        # Sample from each conditional distribution
+        for par_name in par_names:
+
+            # Dict of all other parameters to condition on
+            other_params = {par_name_: current_samples[par_name_] for par_name_ in par_names if par_name_ != par_name}
+
+            # Set up sampler for current conditional distribution
+            sampler = self.samplers[par_name](self.target(**other_params))
+
+            # Take a MCMC step
+            current_samples[par_name] = sampler.step(current_samples[par_name])
+
+            # Ensure even 1-dimensional samples are 1D arrays
+            current_samples[par_name] = current_samples[par_name].reshape(-1)
+        
+        return current_samples
+
+    def step_tune(self, current_samples):
+        """ Perform a single MCMC step for each parameter and tune the sampler """
+        # Not implemented. No tuning happening here yet. Requires samplers to be able to be modified after initialization.
+        return self.step(current_samples)
+
+    # ------------ Private methods ------------
+    def _allocate_samples(self, Ns):
+        """ Allocate memory for samples """
+        # Allocate memory for samples
+        samples = {}
+        for par_name in self.par_names:
+            samples[par_name] = np.zeros((self.target.get_density(par_name).dim, Ns))
+        
+        # Store samples in self
+        if hasattr(self, 'samples'):
+            # Append to existing samples (This makes a copy)
+            for par_name in self.par_names:
+                samples[par_name] = np.hstack((self.samples[par_name], samples[par_name]))
+        self.samples = samples
+
+    def _allocate_samples_warmup(self, Nb):
+        """ Allocate memory for samples """
+        
+        # If we already have warmup samples and more are requested raise error
+        if hasattr(self, 'samples_warmup') and Nb != 0:
+            raise ValueError('Sampler already has run warmup phase. Cannot run warmup phase again.')
+
+        # Allocate memory for samples
+        samples = {}
+        for par_name in self.par_names:
+            samples[par_name] = np.zeros((self.target.get_density(par_name).dim, Nb))
+        self.samples_warmup = samples
+
+    def _get_initial_points(self):
+        """ Get initial points for each parameter """
+        initial_points = {}
+        for par_name in self.par_names:
+            if hasattr(self, 'samples'):
+                initial_points[par_name] = self.samples[par_name][:, -1]
+            elif hasattr(self, 'samples_warmup'):
+                initial_points[par_name] = self.samples_warmup[par_name][:, -1]
+            elif hasattr(self.target.get_density(par_name), 'init_point'):
+                initial_points[par_name] = self.target.get_density(par_name).init_point
+            else:
+                initial_points[par_name] = np.ones(self.target.get_density(par_name).dim)
+        return initial_points
+
+    def _store_samples(self, samples, current_samples, i):
+        """ Store current samples at index i of samples dict """
+        for par_name in self.par_names:
+            samples[par_name][:, i] = current_samples[par_name]
+
+    def _convert_to_Samples(self, samples):
+        """ Convert each parameter in samples dict to cuqi.samples.Samples object with correct geometry """
+        samples_object = {}
+        for par_name in self.par_names:
+            samples_object[par_name] = Samples(samples[par_name], self.target.get_density(par_name).geometry)
+        return samples_object
+
+    def _print_progress(self, s, Ns, phase):
+        """Prints sampling progress"""
+        if Ns < 2: # Don't print progress if only one sample
+            return
+        if (s % (max(Ns//100,1))) == 0:
+            msg = f'{phase} {s} / {Ns}'
+            sys.stdout.write('\r'+msg)
+        if s==Ns:
+            msg = f'{phase} {s} / {Ns}'
+            sys.stdout.write('\r'+msg+'\n')
+
+    # ------------ Private properties ------------
+    @property
+    def _Ns(self):
+        """ Number of samples already taken """
+        if hasattr(self, 'samples'):
+            return self.samples[self.par_names[0]].shape[-1]
+        else:
+            return 0
+    
+    @property
+    def _Nb(self):
+        """ Number of samples already taken in warmup phase """
+        if hasattr(self, 'samples_warmup'):
+            return self.samples_warmup[self.par_names[0]].shape[-1]
+        else:
+            return 0