CUQIpy 1.3.0.post0.dev298__py3-none-any.whl → 1.4.0.post0.dev92__py3-none-any.whl

cuqi/experimental/mcmc/_sampler.py

@@ -1,564 +0,0 @@
-from abc import ABC, abstractmethod
-import os
-import numpy as np
-import pickle as pkl
-import warnings
-import cuqi
-from cuqi.samples import Samples
-
-try:
-    from tqdm import tqdm
-except ImportError:
-    def tqdm(iterable, **kwargs):
-        warnings.warn("Module mcmc: tqdm not found. Install tqdm to get sampling progress.")
-        return iterable
-
-class Sampler(ABC):
-    """ Abstract base class for all samplers.
-    
-    Provides a common interface for all samplers. The interface includes methods for sampling, warmup and getting the samples in an object oriented way.
-
-    Samples are stored in a list to allow for dynamic growth of the sample set. Returning samples is done by creating a new Samples object from the list of samples.
-
-    The sampler maintains sets of state and history keys, which are used for features like checkpointing and resuming sampling.
-
-    The state of the sampler represents all variables that are updated (replaced) in a Markov Monte Carlo step, e.g. the current point of the sampler.
-
-    The history of the sampler represents all variables that are updated (appended) in a Markov Monte Carlo step, e.g. the samples and acceptance rates.
-
-    Subclasses should ensure that any new variables that are updated in a Markov Monte Carlo step are added to the state or history keys.
-
-    Saving and loading checkpoints saves and loads the state of the sampler (not the history).
-
-    Batching samples via the batch_size parameter saves the sampler history to disk in batches of the specified size.
-
-    Any other attribute stored as part of the sampler (e.g. target, initial_point) is not supposed to be updated
-    during sampling and should not be part of the state or history.
-
-    """
-
-    _STATE_KEYS = {'current_point'}
-    """ Set of keys for the state dictionary. """
-
-    _HISTORY_KEYS = {'_samples', '_acc'}
-    """ Set of keys for the history dictionary. """
-
-    def __init__(self, target:cuqi.density.Density=None, initial_point=None, callback=None):
-        """ Initializer for abstract base class for all samplers.
-
-        Any subclassing samplers should simply store input parameters as part of the __init__ method. 
-
-        The actual initialization of the sampler should be done in the _initialize method.
-        
-        Parameters
-        ----------
-        target : cuqi.density.Density
-            The target density.
-
-        initial_point : array-like, optional
-            The initial point for the sampler. If not given, the sampler will choose an initial point.
-
-        callback : callable, optional
-            A function that will be called after each sampling step. It can be useful for monitoring the sampler during sampling.
-            The function should take three arguments: the sampler object, the index of the current sampling step, the total number of requested samples. The last two arguments are integers. An example of the callback function signature is: `callback(sampler, sample_index, num_of_samples)`.
-        """
-
-        self.target = target
-        self.initial_point = initial_point
-        self.callback = callback
-        self._is_initialized = False
-
-    def initialize(self):
-        """ Initialize the sampler by setting and allocating the state and history before sampling starts. """
-
-        if self._is_initialized:
-            raise ValueError("Sampler is already initialized.")
-        
-        if self.target is None:
-            raise ValueError("Cannot initialize sampler without a target density.")
-        
-        # Default values
-        if self.initial_point is None:
-            self.initial_point = self._get_default_initial_point(self.dim)
-
-        # State variables
-        self.current_point = self.initial_point
-
-        # History variables
-        self._samples = []
-        self._acc = [ 1 ] # TODO. Check if we need to put 1 here.
-
-        self._initialize() # Subclass specific initialization
-
-        self._validate_initialization()
-
-        self._is_initialized = True
-
-    # ------------ Abstract methods to be implemented by subclasses ------------
-    @abstractmethod
-    def step(self):
-        """ Perform one step of the sampler by transitioning the current point to a new point according to the sampler's transition kernel. """
-        pass
-
-    @abstractmethod
-    def tune(self, skip_len, update_count):
-        """ Tune the parameters of the sampler. This method is called after each step of the warmup phase.
-
-        Parameters
-        ----------
-        skip_len : int
-            Defines the number of steps in between tuning (i.e. the tuning interval).
-
-        update_count : int
-            The number of times tuning has been performed. Can be used for internal bookkeeping.
-        
-        """
-        pass
-
-    @abstractmethod
-    def validate_target(self):
-        """ Validate the target is compatible with the sampler. Called when the target is set. Should raise an error if the target is not compatible. """
-        pass
-
-    @abstractmethod
-    def _initialize(self):
-        """ Subclass specific sampler initialization. Called during the initialization of the sampler which is done before sampling starts. """
-        pass
-
-    # ------------ Public attributes ------------
-    @property
-    def dim(self) -> int:
-        """ Dimension of the target density. """
-        return self.target.dim
-
-    @property
-    def geometry(self) -> cuqi.geometry.Geometry:
-        """ Geometry of the target density. """
-        return self.target.geometry
-    
-    @property
-    def target(self) -> cuqi.density.Density:
-        """ Return the target density. """
-        return self._target
-    
-    @target.setter
-    def target(self, value):
-        """ Set the target density. Runs validation of the target. """
-        self._target = value
-        if self._target is not None:
-            self.validate_target()
-
-    # ------------ Public methods ------------
-    def get_samples(self) -> Samples:
-        """ Return the samples. The internal data-structure for the samples is a dynamic list so this creates a copy. """
-        return Samples(np.array(self._samples).T, self.target.geometry)
-    
-    def reinitialize(self):
-        """ Re-initialize the sampler. This clears the state and history and initializes the sampler again by setting state and history to their original values. """
-
-        # Loop over state and reset to None
-        for key in self._STATE_KEYS:
-            setattr(self, key, None)
-
-        # Loop over history and reset to None
-        for key in self._HISTORY_KEYS:
-            setattr(self, key, None)
-
-        self._is_initialized = False
-
-        self.initialize()
-    
-    def save_checkpoint(self, path):
-        """ Save the state of the sampler to a file. """
-
-        self._ensure_initialized()
-
-        state = self.get_state()
-
-        # Convert all CUQIarrays to numpy arrays since CUQIarrays do not get pickled correctly
-        for key, value in state['state'].items():
-            if isinstance(value, cuqi.array.CUQIarray):
-                state['state'][key] = value.to_numpy()
-
-        with open(path, 'wb') as handle:
-            pkl.dump(state, handle, protocol=pkl.HIGHEST_PROTOCOL)
-
-    def load_checkpoint(self, path):
-        """ Load the state of the sampler from a file. """
-
-        self._ensure_initialized()
-
-        with open(path, 'rb') as handle:
-            state = pkl.load(handle)
-
-        self.set_state(state)
-
-    def sample(self, Ns, batch_size=0, sample_path='./CUQI_samples/') -> 'Sampler':
-        """ Sample Ns samples from the target density.
-
-        Parameters
-        ----------
-        Ns : int
-            The number of samples to draw.
-
-        batch_size : int, optional
-            The batch size for saving samples to disk. If 0, no batching is used. If positive, samples are saved to disk in batches of the specified size.
-
-        sample_path : str, optional
-            The path to save the samples. If not specified, the samples are saved to the current working directory under a folder called 'CUQI_samples'.
-
-        """
-        self._ensure_initialized()
-
-        # Initialize batch handler
-        if batch_size > 0:
-            batch_handler = _BatchHandler(batch_size, sample_path)
-
-        # Draw samples
-        pbar = tqdm(range(Ns), "Sample: ")
-        for idx in pbar:
-            
-            # Perform one step of the sampler
-            acc = self.step()
-
-            # Store samples
-            self._acc.append(acc)
-            self._samples.append(self.current_point)
-
-            # display acc rate at progress bar
-            pbar.set_postfix_str(f"acc rate: {np.mean(self._acc[-1-idx:]):.2%}")
-
-            # Add sample to batch
-            if batch_size > 0:
-                batch_handler.add_sample(self.current_point)
-
-            # Call callback function if specified            
-            self._call_callback(idx, Ns)
-                
-        return self
-    
-
-    def warmup(self, Nb, tune_freq=0.1) -> 'Sampler':
-        """ Warmup the sampler by drawing Nb samples.
-
-        Parameters
-        ----------
-        Nb : int
-            The number of samples to draw during warmup.
-
-        tune_freq : float, optional
-            The frequency of tuning. Tuning is performed every tune_freq*Nb samples.
-
-        """
-
-        self._ensure_initialized()
-
-        tune_interval = max(int(tune_freq * Nb), 1)
-
-        # Draw warmup samples with tuning
-        pbar = tqdm(range(Nb), "Warmup: ")
-        for idx in pbar:
-
-            # Perform one step of the sampler
-            acc = self.step()
-
-            # Tune the sampler at tuning intervals
-            if (idx + 1) % tune_interval == 0:
-                self.tune(tune_interval, idx // tune_interval) 
-
-            # Store samples
-            self._acc.append(acc)
-            self._samples.append(self.current_point)
-
-            # display acc rate at progress bar
-            pbar.set_postfix_str(f"acc rate: {np.mean(self._acc[-1-idx:]):.2%}")
-
-            # Call callback function if specified
-            self._call_callback(idx, Nb)
-
-        return self
-    
-    def get_state(self) -> dict:
-        """ Return the state of the sampler. 
-
-        The state is used when checkpointing the sampler.
-
-        The state of the sampler is a dictionary with keys 'metadata' and 'state'.
-        The 'metadata' key contains information about the sampler type.
-        The 'state' key contains the state of the sampler.
-
-        For example, the state of a "MH" sampler could be:
-
-        state = {
-            'metadata': {
-                'sampler_type': 'MH'
-            },
-            'state': {
-                'current_point': np.array([...]),
-                'current_target_logd': -123.45,
-                'scale': 1.0,
-                ...
-            }
-        }
-        """   
-        state = {
-            'metadata': {
-                'sampler_type': self.__class__.__name__
-            },
-            'state': {
-                key: getattr(self, key) for key in self._STATE_KEYS
-            }
-        }
-        return state
-
-    def set_state(self, state: dict):
-        """ Set the state of the sampler.
-
-        The state is used when loading the sampler from a checkpoint.
-
-        The state of the sampler is a dictionary with keys 'metadata' and 'state'.
-
-        For example, the state of a "MH" sampler could be:
-
-        state = {
-            'metadata': {
-                'sampler_type': 'MH'
-            },
-            'state': {
-                'current_point': np.array([...]),
-                'current_target_logd': -123.45,
-                'scale': 1.0,
-                ...
-            }
-        }
-        """
-        if state['metadata']['sampler_type'] != self.__class__.__name__:
-            raise ValueError(f"Sampler type in state dictionary ({state['metadata']['sampler_type']}) does not match the type of the sampler ({self.__class__.__name__}).")
-        
-        for key, value in state['state'].items():
-            if key in self._STATE_KEYS:
-                setattr(self, key, value)
-            else:
-                raise ValueError(f"Key {key} not recognized in state dictionary of sampler {self.__class__.__name__}.")
-            
-    def get_history(self) -> dict:
-        """ Return the history of the sampler. """
-        history = {
-            'metadata': {
-                'sampler_type': self.__class__.__name__
-            },
-            'history': {
-                key: getattr(self, key) for key in self._HISTORY_KEYS
-            }
-        }
-        return history
-    
-    def set_history(self, history: dict):
-        """ Set the history of the sampler. """
-        if history['metadata']['sampler_type'] != self.__class__.__name__:
-            raise ValueError(f"Sampler type in history dictionary ({history['metadata']['sampler_type']}) does not match the type of the sampler ({self.__class__.__name__}).")
-        
-        for key, value in history['history'].items():
-            if key in self._HISTORY_KEYS:
-                setattr(self, key, value)
-            else:
-                raise ValueError(f"Key {key} not recognized in history dictionary of sampler {self.__class__.__name__}.")
-
-    # ------------ Private methods ------------
-    def _call_callback(self, sample_index, num_of_samples):
-        """ Calls the callback function. Assumes input is sampler, sample index, and total number of samples """
-        if self.callback is not None:
-            self.callback(self, sample_index, num_of_samples)
-
-    def _validate_initialization(self):
-        """ Validate the initialization of the sampler by checking all state and history keys are set. """
-
-        for key in self._STATE_KEYS:
-            if getattr(self, key) is None:
-                raise ValueError(f"Sampler state key {key} is not set after initialization.")
-
-        for key in self._HISTORY_KEYS:
-            if getattr(self, key) is None:
-                raise ValueError(f"Sampler history key {key} is not set after initialization.")
-            
-    def _ensure_initialized(self):
-        """ Ensure the sampler is initialized. If not initialize it. """
-        if not self._is_initialized:
-            self.initialize()
-            
-    def _get_default_initial_point(self, dim):
-        """ Return the default initial point for the sampler. Defaults to an array of ones. """
-        return np.ones(dim)
-    
-    def __repr__(self):
-        """ Return a string representation of the sampler. """
-        if self.target is None:
-            return f"Sampler: {self.__class__.__name__} \n Target: None"
-        else:
-            msg = f"Sampler: {self.__class__.__name__} \n Target: \n \t {self.target} "
-            
-        if self._is_initialized:
-            state = self.get_state()
-            msg += f"\n Current state: \n"
-            # Sort keys alphabetically
-            keys = sorted(state['state'].keys())
-            # Put _ in the end
-            keys = [key for key in keys if key[0] != '_'] + [key for key in keys if key[0] == '_']
-            for key in keys:
-                value = state['state'][key]
-                msg += f"\t {key}: {value} \n"
-        return msg
-
-class ProposalBasedSampler(Sampler, ABC):
-    """ Abstract base class for samplers that use a proposal distribution. """
-
-    _STATE_KEYS = Sampler._STATE_KEYS.union({'current_target_logd', 'scale'})
-
-    def __init__(self, target=None, proposal=None, scale=1, **kwargs):
-        """ Initializer for abstract base class for samplers that use a proposal distribution.
-
-        Any subclassing samplers should simply store input parameters as part of the __init__ method.
-
-        Initialization of the sampler should be done in the _initialize method.
-
-        See :class:`Sampler` for additional details.
-
-        Parameters
-        ----------
-        target : cuqi.density.Density
-            The target density.
-
-        proposal : cuqi.distribution.Distribution, optional
-            The proposal distribution. If not specified, the default proposal is used.
-
-        scale : float, optional
-            The scale parameter for the proposal distribution.
-
-        **kwargs : dict
-            Additional keyword arguments passed to the :class:`Sampler` initializer.
-
-        """
-
-        super().__init__(target, **kwargs)
-        self.proposal = proposal
-        self.initial_scale = scale
-
-    def initialize(self):
-        """ Initialize the sampler by setting and allocating the state and history before sampling starts. """
-
-        if self._is_initialized:
-            raise ValueError("Sampler is already initialized.")
-        
-        if self.target is None:
-            raise ValueError("Cannot initialize sampler without a target density.")
-        
-        # Default values
-        if self.initial_point is None:
-            self.initial_point = self._get_default_initial_point(self.dim)
-
-        if self.proposal is None:
-            self.proposal = self._default_proposal
-
-        # State variables
-        self.current_point = self.initial_point
-        self.scale = self.initial_scale
-
-        self.current_target_logd = self.target.logd(self.current_point)
-
-        # History variables
-        self._samples = []
-        self._acc = [ 1 ] # TODO. Check if we need to put 1 here.
-
-        self._initialize() # Subclass specific initialization
-
-        self._validate_initialization()
-
-        self._is_initialized = True
-
-    @abstractmethod
-    def validate_proposal(self):
-        """ Validate the proposal distribution. """
-        pass     
-
-    @property
-    def _default_proposal(self):
-        """ Return the default proposal distribution. Defaults to a Gaussian distribution with zero mean and unit variance. """
-        return cuqi.distribution.Gaussian(np.zeros(self.dim), 1)
-
-    @property
-    def proposal(self):
-        """ The proposal distribution. """
-        return self._proposal
-    
-    @proposal.setter
-    def proposal(self, proposal):
-        """ Set the proposal distribution. """
-        self._proposal = proposal
-        if self._proposal is not None:
-            self.validate_proposal()
-
-
-class _BatchHandler:
-    """ Utility class to handle batching of samples. 
-    
-    If a batch size is specified, this class will save samples to disk in batches of the specified size.
-     
-    This is useful for very large sample sets that do not fit in memory.
-     
-    """
-    
-    def __init__(self, batch_size=0, sample_path='./CUQI_samples/'):
-
-        if batch_size < 0:
-            raise ValueError("Batch size should be a non-negative integer")
-
-        self.sample_path = sample_path
-        self._batch_size = batch_size
-        self.current_batch = []
-        self.num_batches_dumped = 0
-
-    @property
-    def sample_path(self):
-        """ The path to save the samples. """
-        return self._sample_path
-    
-    @sample_path.setter
-    def sample_path(self, value):
-        if not isinstance(value, str):
-            raise TypeError("Sample path must be a string.")
-        normalized_path = value.rstrip('/') + '/'
-        if not os.path.isdir(normalized_path):
-            try:
-                os.makedirs(normalized_path, exist_ok=True)
-            except Exception as e:
-                raise ValueError(f"Could not create directory at {normalized_path}: {e}")
-        self._sample_path = normalized_path
-
-    def add_sample(self, sample):
-        """ Add a sample to the batch if batching. If the batch is full, flush the batch to disk. """
-
-        if self._batch_size <= 0:
-            return  # Batching not used
-
-        self.current_batch.append(sample)
-
-        if len(self.current_batch) >= self._batch_size:
-            self.flush()
-
-    def flush(self):
-        """ Flush the current batch of samples to disk. """
-
-        if not self.current_batch:
-            return  # No samples to flush
-
-        # Save the current batch of samples
-        batch_samples = np.array(self.current_batch)
-        file_path = f'{self.sample_path}batch_{self.num_batches_dumped:04d}.npz'
-        np.savez(file_path, samples=batch_samples, batch_id=self.num_batches_dumped)
-
-        self.num_batches_dumped += 1
-        self.current_batch = []  # Clear the batch after saving
-
-    def finalize(self):
-        """ Finalize the batch handler. Flush any remaining samples to disk. """
-        self.flush()

cuqipy-1.3.0.post0.dev298.dist-info/RECORD

@@ -1,100 +0,0 @@
-cuqi/__init__.py,sha256=LsGilhl-hBLEn6Glt8S_l0OJzAA1sKit_rui8h-D-p0,488
-cuqi/_messages.py,sha256=fzEBrZT2kbmfecBBPm7spVu7yHdxGARQB4QzXhJbCJ0,415
-cuqi/_version.py,sha256=VwUmSwCl1TjQCoMN2OC86V-9oKtS3snnE0i5gC_KQao,510
-cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
-cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
-cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
-cuqi/array/_array.py,sha256=UJoWyQjDpl8g2q4wuuz_ufpr2JoYL0BbCxrxZpZR99I,4303
-cuqi/data/__init__.py,sha256=1aGgPmtG_Kqbb880vLnPksGvyYQB_6o2mz_q-4KGYaU,173
-cuqi/data/_data.py,sha256=PgdYJ6MHgNY37Ak8wUYwvxcAwOYSNjnf1-BXMdbnuv4,10716
-cuqi/data/astronaut.npz,sha256=vVTb6eJLMZhrEZuOYzQWN3V2EhhVH6sHzrrf_7mstcw,786696
-cuqi/data/camera.npz,sha256=EznyKfAomn4orm-L9gqM3QDFNuGB5XZwpZZMwDgiMKk,262408
-cuqi/data/cat.npz,sha256=9H9iJqkvlCCVZZ2IWMfwwfVHbShpQTkZo_WGr7rrp3k,406164
-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=f-HM-SUrvPO66_FAJ6k4TffBq4H94OusRMDOJgcJU2w,779
-cuqi/distribution/_beta.py,sha256=QlibnuHNcvWjl-du5aRc9QuzS3n4PsyD_8Nc47w-E0Q,2903
-cuqi/distribution/_cauchy.py,sha256=Qwi21WkwUBnBkLbhR-yCGO0tQ_U_3mmvR0pDMPPPB5c,3296
-cuqi/distribution/_cmrf.py,sha256=tCbEulM_O7FB3C_W-3IqZp9zGHkTofCdFF0ybHc9UZI,3745
-cuqi/distribution/_custom.py,sha256=11lnAG7CS15bpV6JOOP--2YyKnAduvXY1IjAOJ1tqO0,10504
-cuqi/distribution/_distribution.py,sha256=mDSOjm2-f1we9wbfii2QEZ8gx03X_iZDt9XY4AGlOvE,17982
-cuqi/distribution/_gamma.py,sha256=VcvBJS51N-MxuX42r9L2j2QYRlzhdgAtQ6Wa5IFO_YE,3536
-cuqi/distribution/_gaussian.py,sha256=3L1L_3W6i6YuPQ8vnFmju5QsvkLlg4VsgCnj11lYBUE,32977
-cuqi/distribution/_gmrf.py,sha256=OwId8qQWEtmC2fxVhL4iBHZnc8ZCrZzfV6yGXDE3k30,9522
-cuqi/distribution/_inverse_gamma.py,sha256=oPJuiYp3O1m547pmmIz9OWesky9YpwLTHT7-9MmcYss,3159
-cuqi/distribution/_joint_distribution.py,sha256=gBWDb9Aj27m74mSsm9Jj_0mSu0pcEk9Cwdxrzybiwx8,16710
-cuqi/distribution/_laplace.py,sha256=5exLvlzJm2AgfvZ3KUSkjfwlGwwbsktBxP8z0iLMik8,1401
-cuqi/distribution/_lmrf.py,sha256=rdGoQ-fPe1oW6Z29P-l3woq0NX3_RxUQ2rzm1VzemNM,3290
-cuqi/distribution/_lognormal.py,sha256=8_hOFQ3iu88ujX8vxmfVEZ0fdmlhTY98PlG5PasPjEg,2612
-cuqi/distribution/_modifiedhalfnormal.py,sha256=ErULXUFRjbMyCYywaOzfuxtoy-XQmC0McMROo2mTQtc,7313
-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=_ez3MmO6qpBeP6BKCUlW3IgxuF7k--A7jPGPUhtYK0g,4240
-cuqi/distribution/_uniform.py,sha256=fVgj_4SBav8JMc1pNAO1l_CZ9ZwdoMIpN9iQ3i9_Z0Q,3255
-cuqi/experimental/__init__.py,sha256=9DidfQuoFPr8DnhYzI78N2J0fT4pp-jNle0Rou1fcrM,174
-cuqi/experimental/_recommender.py,sha256=fSCJnlRrUZh-x8-mbVM5WhuPuh7Wmh-4bfvX5PyK_iE,7967
-cuqi/experimental/algebra/__init__.py,sha256=btRAWG58ZfdtK0afXKOg60AX7d76KMBjlZa4AWBCCgU,81
-cuqi/experimental/algebra/_ast.py,sha256=PdPz19cJMjvnMx4KEzhn4gvxIZX_UViE33Mbttj_5Xw,9873
-cuqi/experimental/algebra/_orderedset.py,sha256=fKysh4pmI4xF7Y5Z6O86ABzg20o4uBs-v8jmLBMrdpo,2849
-cuqi/experimental/algebra/_randomvariable.py,sha256=isbFtIWsWXF-yF5Vb56nLy4MCkQM6akjd-dQau4wfbE,19725
-cuqi/experimental/geometry/__init__.py,sha256=kgoKegfz3Jhr7fpORB_l55z9zLZRtloTLyXFDh1oF2o,47
-cuqi/experimental/geometry/_productgeometry.py,sha256=IlBmmKsWE-aRZHp6no9gUXGRfkHlgM0CdPBx1hax9HI,7199
-cuqi/experimental/mcmc/__init__.py,sha256=hTAssTgtgLhdVZLFX7hpLJYtWmXrmfXb4bWee6ELqwE,4443
-cuqi/experimental/mcmc/_conjugate.py,sha256=vqucxC--pihBCUcupdcIo4ymDPPjmMKGb7OL1THjaKE,22059
-cuqi/experimental/mcmc/_conjugate_approx.py,sha256=jmxe2FEbO9fwpc8opyjJ2px0oed3dGyj0qDwyHo4aOk,3545
-cuqi/experimental/mcmc/_cwmh.py,sha256=cAvtc3tex53ZUKPMGwj2RIkHAZurpqphko8nk8_DmJs,7340
-cuqi/experimental/mcmc/_direct.py,sha256=9pQS_2Qk2-ybt6m8WTfPoKetcxQ00WaTRN85-Z0FrBY,777
-cuqi/experimental/mcmc/_gibbs.py,sha256=9Qutc60xoVTvKYRkirQhXEDiQ75mbjyxU7utblmu1C8,14567
-cuqi/experimental/mcmc/_hmc.py,sha256=LXXOb6cztfjraGIuTGpgf0ndc1xkkBW9v_PfNffu-NA,19438
-cuqi/experimental/mcmc/_langevin_algorithm.py,sha256=1UunuocpzG1h6GiYefEHFOMykEMlYady6Fmuu9CHxHQ,15059
-cuqi/experimental/mcmc/_laplace_approximation.py,sha256=I5ZLtU0lA34YflRbqxKi5UgJBhhHzxqUyVW5JE5-l2w,5916
-cuqi/experimental/mcmc/_mh.py,sha256=MXo0ahXP4KGFkaY4HtvcBE-TMQzsMlTmLKzSvpz7drU,2941
-cuqi/experimental/mcmc/_pcn.py,sha256=wqJBZLuRFSwxihaI53tumAg6AWVuceLMOmXssTetd1A,3374
-cuqi/experimental/mcmc/_rto.py,sha256=BY55Njw3-dcmjd-V1vQ58CisEDllQ8zaEj92pWB6LCM,15158
-cuqi/experimental/mcmc/_sampler.py,sha256=VK-VsPRaYET43C5quhu2f1OstEX5DKYKVyjKABTRHZE,20288
-cuqi/geometry/__init__.py,sha256=Tz1WGzZBY-QGH3c0GiyKm9XHN8MGGcnU6TUHLZkzB3o,842
-cuqi/geometry/_geometry.py,sha256=W-oQTZPelVS7fN9qZj6bNBuh-yY0eqOHJ39UwB-WmQY,47562
-cuqi/implicitprior/__init__.py,sha256=6z3lvw-tWDyjZSpB3pYzvijSMK9Zlf1IYqOVTtMD2h4,309
-cuqi/implicitprior/_regularizedGMRF.py,sha256=BUeT4rwJzary9K56fkxCNGCeKZd-2VSgOT8XNHxFPRE,6345
-cuqi/implicitprior/_regularizedGaussian.py,sha256=9BSKHGEW0OT9OIt_42strDzxBM8mB6A-blcf0kEguHw,21836
-cuqi/implicitprior/_regularizedUnboundedUniform.py,sha256=uHGYYnTjVxdPbY-5JwocFOH0sHRfGrrLiHWahzH9R8A,3533
-cuqi/implicitprior/_restorator.py,sha256=Z350XUJEt7N59Qw-SIUaBljQNDJk4Zb0i_KRFrt2DCg,10087
-cuqi/likelihood/__init__.py,sha256=QXif382iwZ5bT3ZUqmMs_n70JVbbjxbqMrlQYbMn4Zo,1776
-cuqi/likelihood/_likelihood.py,sha256=PuW8ufRefLt6w40JQWqNnEh3YCLxu4pz0h0PcpT8inc,7075
-cuqi/model/__init__.py,sha256=jgY2-jyxEMC79vkyH9BpfowW7_DbMRjqedOtO5fykXQ,62
-cuqi/model/_model.py,sha256=Y7rMoJzw0FYJiP9pCH8E9Pr-vSdLKAlgTfU-V4-kXf0,68859
-cuqi/operator/__init__.py,sha256=0pc9p-KPyl7KtPV0noB0ddI0CP2iYEHw5rbw49D8Njk,136
-cuqi/operator/_operator.py,sha256=yNwPTh7jR07AiKMbMQQ5_54EgirlKFsbq9JN1EODaQI,8856
-cuqi/pde/__init__.py,sha256=NyS_ZYruCvy-Yg24qKlwm3ZIX058kLNQX9bqs-xg4ZM,99
-cuqi/pde/_pde.py,sha256=FxCmMPcbRj9ulJbg3fPzQITfHKeW9I8r1S2v9Odz0WU,15806
-cuqi/problem/__init__.py,sha256=JxJty4JqHTOqSG6NeTGiXRQ7OLxiRK9jvVq3lXLeIRw,38
-cuqi/problem/_problem.py,sha256=p1UO04GKv5BmdcPR5-xcP-idBsqShBxKJ3WC5qNSMDs,38588
-cuqi/sampler/__init__.py,sha256=D-dYa0gFgIwQukP8_VKhPGmlGKXbvVo7YqaET4SdAeQ,382
-cuqi/sampler/_conjugate.py,sha256=x5OsFk1zDm2tvoFsSxbCKwjSqBHUGbcUvcTwDOvL-tw,2841
-cuqi/sampler/_conjugate_approx.py,sha256=xX-X71EgxGnZooOY6CIBhuJTs3dhcKfoLnoFxX3CO2g,1938
-cuqi/sampler/_cwmh.py,sha256=VlAVT1SXQU0yD5ZeR-_ckWvX-ifJrMweFFdFbxdfB_k,7775
-cuqi/sampler/_gibbs.py,sha256=N7qcePwMkRtxINN5JF0FaMIdDCXZGqsfKjfha_KHCck,8627
-cuqi/sampler/_hmc.py,sha256=EUTefZir-wapoZ7OZFb5M5vayL8z6XksZRMY1BpbuXc,15027
-cuqi/sampler/_langevin_algorithm.py,sha256=o5EyvaR6QGAD7LKwXVRC3WwAP5IYJf5GoMVWl9DrfOA,7861
-cuqi/sampler/_laplace_approximation.py,sha256=M0SnpICcf8No1zsPKopGEncVgLqBUI7VUDf9-YIkk_g,6565
-cuqi/sampler/_mh.py,sha256=V5tIdn-KdfWo4J_Nbf-AH6XwKWblWUyc4BeuSikUHsE,7062
-cuqi/sampler/_pcn.py,sha256=F0h9-nUFtkqn-o-1s8BCsmr8V7u6R7ycoCOeeV1uhj0,8601
-cuqi/sampler/_rto.py,sha256=KIs0cDEoYK5I35RwO9fr5eKWeINLsmTLSVBnLdZmzzM,11921
-cuqi/sampler/_sampler.py,sha256=TkZ_WAS-5Q43oICa-Elc2gftsRTBd7PEDUMDZ9tTGmU,5712
-cuqi/samples/__init__.py,sha256=vCs6lVk-pi8RBqa6cIN5wyn6u-K9oEf1Na4k1ZMrYv8,44
-cuqi/samples/_samples.py,sha256=hUc8OnCF9CTCuDTrGHwwzv3wp8mG_6vsJAFvuQ-x0uA,35832
-cuqi/solver/__init__.py,sha256=KYgAi_8VoAwljTB3S2I87YnJkRtedskLee7hQp_-zp8,220
-cuqi/solver/_solver.py,sha256=X3EWD-26o9UOBsWRuy0ktYsJiUXwpCGm0lvTdQM6dRI,30964
-cuqi/testproblem/__init__.py,sha256=DWTOcyuNHMbhEuuWlY5CkYkNDSAqhvsKmJXBLivyblU,202
-cuqi/testproblem/_testproblem.py,sha256=EJWG_zXUtmo6GlHBZFqHlRpDC_48tE0XZEu0_C66NS8,52524
-cuqi/utilities/__init__.py,sha256=d5QXRzmI6EchS9T4b7eTezSisPWuWklO8ey4YBx9kI0,569
-cuqi/utilities/_get_python_variable_name.py,sha256=wxpCaj9f3ZtBNqlGmmuGiITgBaTsY-r94lUIlK6UAU4,2043
-cuqi/utilities/_utilities.py,sha256=R7BdNysrE36a4D729DvfrTisWY4paP5nfqdkQxSX3Mg,18431
-cuqipy-1.3.0.post0.dev298.dist-info/licenses/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
-cuqipy-1.3.0.post0.dev298.dist-info/METADATA,sha256=j-lO1X4RUW9PR0B-YuJuJMl_IoUB5xrmovKuS22yfs0,18624
-cuqipy-1.3.0.post0.dev298.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cuqipy-1.3.0.post0.dev298.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
-cuqipy-1.3.0.post0.dev298.dist-info/RECORD,,