CUQIpy 0.5.0.post0.dev5__py3-none-any.whl → 0.5.0.post0.dev19__py3-none-any.whl

{CUQIpy-0.5.0.post0.dev5.dist-info → CUQIpy-0.5.0.post0.dev19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 0.5.0.post0.dev5
+Version: 0.5.0.post0.dev19
 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>
 License: Apache License

{CUQIpy-0.5.0.post0.dev5.dist-info → CUQIpy-0.5.0.post0.dev19.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cuqi/__init__.py,sha256=K0ss2HNqoLUX7wGpSZdaPKxIaKdRS452fcJm4D0pcEs,433
 cuqi/_messages.py,sha256=fzEBrZT2kbmfecBBPm7spVu7yHdxGARQB4QzXhJbCJ0,415
-cuqi/_version.py,sha256=WVjSXW13o8zy07cCEoHRqZbhu68pBwi9VKjaFhBJ6kk,508
+cuqi/_version.py,sha256=r_FphDLbYCelc5DxEAgEScmvtxrW3L7f79dMosuC-jU,509
 cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
 cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
 cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
@@ -31,7 +31,7 @@ cuqi/distribution/_normal.py,sha256=UeoTtGDT7YSf4ZNo2amlVF9K-YQpYbf8q76jcRJTVFw,
 cuqi/distribution/_posterior.py,sha256=zAfL0GECxekZ2lBt1W6_LN0U_xskMwK4VNce5xAF7ig,5018
 cuqi/distribution/_uniform.py,sha256=7xJmCZH_LPhuGkwEDGh-_CTtzcWKrXMOxtTJUFb7Ydo,1607
 cuqi/geometry/__init__.py,sha256=Tz1WGzZBY-QGH3c0GiyKm9XHN8MGGcnU6TUHLZkzB3o,842
-cuqi/geometry/_geometry.py,sha256=2a_J_TASNe1W5v7zYWI-Zw_tNvYBBmc5en--Gy3RcP8,43683
+cuqi/geometry/_geometry.py,sha256=WYFC-4_VBTW73b2ldsnfGYKvdSiCE8plr89xTSmkadg,46804
 cuqi/likelihood/__init__.py,sha256=ZUuc7ysBoFvx-L_IKetlKgqht9k8x4kMA_iQA0yuQFM,1774
 cuqi/likelihood/_likelihood.py,sha256=z3AXAbIrv_DjOYh4jy3iDHemuIFUUJu6wdvJ5e2dgW0,6913
 cuqi/model/__init__.py,sha256=IcN4aZCnyp9o-8TNIoZ8vew99QQgi0EmZvnsIuR6qYI,49
@@ -47,7 +47,7 @@ cuqi/sampler/_conjugate.py,sha256=Ip3HM12j8Bq9T0925N007_o-2xrKsn6q-KMf6vqYPVs,15
 cuqi/sampler/_conjugate_approx.py,sha256=xX-X71EgxGnZooOY6CIBhuJTs3dhcKfoLnoFxX3CO2g,1938
 cuqi/sampler/_cwmh.py,sha256=VlAVT1SXQU0yD5ZeR-_ckWvX-ifJrMweFFdFbxdfB_k,7775
 cuqi/sampler/_gibbs.py,sha256=4q4PGqLpbGTe5-n8nwzCNEoCKYO43T4lxkFJ5H-eQNQ,8626
-cuqi/sampler/_hmc.py,sha256=S83pTw25oHk9R7o1dwXX-pymrZQpn6t-3Tf2wP1hSTw,12140
+cuqi/sampler/_hmc.py,sha256=76nPkvNU0wLSg4qvm-1s048MzQasl5Qk94sHpyeJ5hM,14819
 cuqi/sampler/_langevin_algorithm.py,sha256=Xk6BkhzwJesKMZEIZMYtbc-2KU7Essdk6abLvthMkRY,7860
 cuqi/sampler/_laplace_approximation.py,sha256=TyvigbxB1L2ClPhk5xL2WEwv12wMvS6hRV5NMDsyek8,6456
 cuqi/sampler/_mh.py,sha256=V5tIdn-KdfWo4J_Nbf-AH6XwKWblWUyc4BeuSikUHsE,7062
@@ -63,8 +63,8 @@ cuqi/testproblem/_testproblem.py,sha256=1a52jc92NqsLRGyM5DLySNW0lVVOC6tkyKM_QV4K
 cuqi/utilities/__init__.py,sha256=EfxHLdsyDNugbmbzs43nV_AeKcycM9sVBjG9WZydagA,351
 cuqi/utilities/_get_python_variable_name.py,sha256=QwlBVj2koJRA8s8pWd554p7-ElcI7HUwY32HknaR92E,1827
 cuqi/utilities/_utilities.py,sha256=rjycaxDWExdskIfYXV1z5ZlB0JTlqv3tCmKf08i6U5c,7973
-CUQIpy-0.5.0.post0.dev5.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
-CUQIpy-0.5.0.post0.dev5.dist-info/METADATA,sha256=MQZGzMO78uAG0Y7GTwpZdTPFqcHHlTld_ysBXszItiU,16420
-CUQIpy-0.5.0.post0.dev5.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-CUQIpy-0.5.0.post0.dev5.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
-CUQIpy-0.5.0.post0.dev5.dist-info/RECORD,,
+CUQIpy-0.5.0.post0.dev19.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
+CUQIpy-0.5.0.post0.dev19.dist-info/METADATA,sha256=u37W-6k-lsUTpDsDlcpO7ZckEDLP50aL8c-7IeBqu0g,16421
+CUQIpy-0.5.0.post0.dev19.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+CUQIpy-0.5.0.post0.dev19.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
+CUQIpy-0.5.0.post0.dev19.dist-info/RECORD,,

cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-09-14T11:43:13+0200",
+ "date": "2023-09-20T22:14:47+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "10df75286cece2b7b0876697501f4d2354b36f5f",
- "version": "0.5.0.post0.dev5"
+ "full-revisionid": "85066baa356c88fbab83075272f0337134b6d832",
+ "version": "0.5.0.post0.dev19"
 }
 '''  # END VERSION_JSON
 

cuqi/geometry/_geometry.py

@@ -331,6 +331,36 @@ class Continuous(Geometry, ABC):
     
     def fun2par(self,funvals):
         return funvals
+    
+    def _reshape_par2fun_input(self, pars):
+        """Make sure that the parameter last dimension reflects the number of
+        parameter vectors: 1 for a single parameter vector and n for n parameter
+        vectors."""
+        # Ensure pars shape is correct (either squeezed single vector or 
+        # multiple vectors with the correct shape).
+        if pars.shape != self.par_shape and\
+                pars.shape[:-1] != self.par_shape:
+            raise ValueError(
+                f"pars must have shape {self.par_shape} or {self.par_shape}"
+                + "+(n,) where n is the number of parameter vectors")
+
+        # Add dim to pars if pars is a single parameter vector.
+        return pars.reshape(self.par_shape + (-1,))
+
+    def _reshape_fun2par_input(self, funvals):
+        """Make sure that the function value last dimension reflects the number
+        of functions: 1 for a single function and n for n functions."""
+        # Ensure funvals shape is correct (either squeezed single function or 
+        # multiple functions with the correct shape).
+        if funvals.shape != self.fun_shape and\
+                funvals.shape[:-1] != self.fun_shape:
+            raise ValueError(
+                f"funvals must have shape {self.fun_shape} or {self.fun_shape}"
+                + "+(n,) where n is the number of functions")
+
+        # Add dim to funvals if funvals is a single function.
+        return funvals.reshape(self.fun_shape + (-1,))
+
 
 class Continuous1D(Continuous):
     """A class that represents a continuous 1D geometry.
@@ -769,6 +799,7 @@ class KLExpansion(Continuous1D):
         self._normalizer = normalizer  # normalizer factor
         self._num_modes = num_modes # number of modes 
         self._coefs = None
+        self._coefs_inverse = None
 
     @property
     def par_shape(self):
@@ -796,10 +827,22 @@ class KLExpansion(Continuous1D):
         # If the coefficients are not computed, compute them.
         if self._coefs is None or len(self._coefs) != self.num_modes:
             eigvals = np.array(range(1, self.par_dim+1))  # KL eigvals
-            self._coefs = 1/np.float_power(eigvals, self.decay_rate)
+            self._coefs = np.diag(1/np.float_power(eigvals, self.decay_rate))
 
         # Return the coefficients.
         return self._coefs
+    
+    @property
+    def coefs_inverse(self):
+        """Computes the inverse of the coefficients diagonal matrix."""
+        
+        # If the matrix is not computed, compute it.
+        if self._coefs_inverse is None or\
+            len(self._coefs_inverse) != self.num_modes:
+            self._coefs_inverse = np.diag(np.float_power(np.diag(self.coefs), -1))
+
+        # Return the inverse coefficients matrix.
+        return self._coefs_inverse
 
     @property
     def num_modes(self):
@@ -816,19 +859,22 @@ class KLExpansion(Continuous1D):
 
     # computes the real function out of expansion coefs
     def par2fun(self, p):
-        # Check that the input is of the correct shape
-        if len(p) != self.par_dim:
-            raise ValueError(
-                "Input array p must have length {}".format(self.par_dim))
 
-        modes = p*self.coefs/self.normalizer
+        # Reshape the parameter vector
+        p = self._reshape_par2fun_input(p)
 
-        # pad the remaining modes with zeros
-        modes = np.pad(modes, (0, self.fun_dim-self.par_dim),
+        modes = self.coefs@p/self.normalizer
+
+        # pad the remaining modes with zeros (for single or multiple parameter
+        # parameter vectors)
+        modes = np.pad(modes, ((0, self.fun_dim-self.par_dim), (0, 0)),
                        'constant', constant_values=0)
 
-        real = idst(modes)/2
-        return real
+        real = idst(modes.T).T/2
+
+        # squeeze to return single function value if only one parameter vector
+        # was given
+        return real.squeeze()
 
     def fun2par(self, funvals):
         """The function to parameter map used to map function values back to
@@ -837,11 +883,9 @@ class KLExpansion(Continuous1D):
         always the inverse of `par2fun` but it is the closest estimation of the
         function on the KL expansion coefficient space."""
 
-        # Check that the input is of the correct shape
-        if len(funvals) != self.fun_dim:
-            raise ValueError(
-                "Input array funvals must have length {}".format(self.fun_dim))
-        
+        # Reshape the function values
+        funvals = self._reshape_fun2par_input(funvals)
+
         warnings.warn(
             f"fun2par for {self.__class__} is a projection on "
             + "the KL expansion coefficients space where only "
@@ -865,10 +909,14 @@ class KLExpansion(Continuous1D):
         # However, if we use, for example, scipy.fft instead of scipy.fftpack,
         # then this scaling is not needed.
 
-        p = dst(funvals*2)[:self.par_dim]\
-            *self.normalizer/(self.coefs*2*self.fun_dim)
+        # Transform (single or multiple functions) to expansion coefficients
+        p_temp = dst(funvals.T*2).T[:self.par_dim,:]
+        p = self.coefs_inverse@p_temp*self.normalizer/(2*self.fun_dim)
+        
+        # squeeze to return single parameter vector if only one function value
+        # was given
+        return p.squeeze()
 
-        return p
 
 class KLExpansion_Full(Continuous1D):
     '''
@@ -1138,24 +1186,55 @@ class StepExpansion(Continuous1D):
         return self._n_steps
 
     def par2fun(self, p):
-        real = np.zeros(self.grid.shape)
+
+        # Reshape the parameter vector
+        p = self._reshape_par2fun_input(p)
+
+        # Extended fun_shape to include multiple functions.
+        ext_fun_shape = self.fun_shape + (p.shape[-1],)
+
+        # Initialize fun to zeros.
+        fun = np.zeros(ext_fun_shape)
+
+        # Fill fun with the step function values.
         for i in range(self._n_steps):
-            real[self._indices[i]] = p[i]
+            fun[self._indices[i],:] = p[i,:]
+
+        # Squeeze to return single evaluated function if only one parameter
+        # vector was given.
+        return fun.squeeze()
  
-        return real
 
     def fun2par(self,f):
-        val = np.zeros(self._n_steps)
+
+        # Reshape the function values
+        f = self._reshape_fun2par_input(f)
+
+        # Extended par_shape to include multiple parameter vectors.
+        ext_par_shape = self.par_shape + (f.shape[-1],)
+        
+        # Initialize par to zeros.
+        par = np.zeros(ext_par_shape)
+
+        # Fill par with the projection of the function values.
         for i in range(self._n_steps):
             if self._fun2par_projection.lower() == 'mean':
-                val[i] = np.mean(f[self._indices[i]])
+                projection_method = np.mean
             elif self._fun2par_projection.lower() == 'max':
-                val[i] = np.max(f[self._indices[i]])
+                projection_method = np.max
             elif self._fun2par_projection.lower() == 'min':
-                val[i] = np.min(f[self._indices[i]])
+                projection_method = np.min
             else:
                 raise ValueError("Invalid projection option.")
-        return val
+            
+            # Apply projection method to the function values in the ith
+            # interval.
+            par[i,:] = projection_method(f[self._indices[i],:], axis=0)
+
+        # Squeeze to return single parameter vector if only one function value
+        # was given.
+        return par.squeeze()
+    
 
     def _check_grid_setup(self):
         

cuqi/sampler/_hmc.py

@@ -58,20 +58,75 @@ class NUTS(Sampler):
         # Plot samples
         samples.plot_pair()
 
+    After running the NUTS sampler, run diagnostics can be accessed via the 
+    following attributes:
+
+    .. code-block:: python
+
+        # Number of tree nodes created each NUTS iteration
+        sampler.num_tree_node_list
+
+        # Step size used in each NUTS iteration
+        sampler.epsilon_list
+
+        # Suggested step size during adaptation (the value of this step size is
+        # only used after adaptation). The suggested step size is None if 
+        # adaptation is not requested.
+        sampler.epsilon_bar_list
+
+        # Additionally, iterations' number can be accessed via
+        sampler.iteration_list
+
     """
     def __init__(self, target, x0=None, max_depth=15, adapt_step_size=True, opt_acc_rate=0.6, **kwargs):
         super().__init__(target, x0=x0, **kwargs)
         self.max_depth = max_depth
         self.adapt_step_size = adapt_step_size
         self.opt_acc_rate = opt_acc_rate
-    
+
+        # NUTS run diagnostic
+        # number of tree nodes created each NUTS iteration
+        self._num_tree_node = 0
+        # Create lists to store NUTS run diagnostics
+        self._create_run_diagnostic_attributes()
+
+    def _create_run_diagnostic_attributes(self):
+        """A method to create attributes to store NUTS run diagnostic."""
+        self._reset_run_diagnostic_attributes()
+
+    def _reset_run_diagnostic_attributes(self):
+        """A method to reset attributes to store NUTS run diagnostic."""
+        # NUTS iterations
+        self.iteration_list = []
+        # List to store number of tree nodes created each NUTS iteration
+        self.num_tree_node_list = []
+        # List of step size used in each NUTS iteration 
+        self.epsilon_list = []
+        # List of burn-in step size suggestion during adaptation 
+        # only used when adaptation is done
+        # remains fixed after adaptation (after burn-in)
+        self.epsilon_bar_list = []
+
+    def _update_run_diagnostic_attributes(self, k, n_tree, eps, eps_bar):
+        """A method to update attributes to store NUTS run diagnostic."""
+        # Store the current iteration number k
+        self.iteration_list.append(k)
+        # Store the number of tree nodes created in iteration k
+        self.num_tree_node_list.append(n_tree)
+        # 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)
+
     def _nuts_target(self, x): # returns logposterior tuple evaluation-gradient
         return self.target.logd(x), self.target.gradient(x)
 
     def _sample_adapt(self, N, Nb):
         return self._sample(N, Nb)
-        
+
     def _sample(self, N, Nb):
+        # Reset run diagnostic attributes
+        self._reset_run_diagnostic_attributes()
         
         if self.adapt_step_size is True and Nb == 0:
             raise ValueError("Adaptive step size is True but number of burn-in steps is 0. Please set Nb > 0.")
@@ -86,6 +141,9 @@ class NUTS(Sampler):
         theta[:, 0] = self.x0
         joint_eval[0], grad = self._nuts_target(self.x0)
 
+        # Step size variables
+        epsilon, epsilon_bar = None, None
+
         # parameters dual averaging
         if (self.adapt_step_size == True):
             epsilon = self._FindGoodEpsilon(theta[:, 0], joint_eval[0], grad)
@@ -101,6 +159,9 @@ class NUTS(Sampler):
 
         # run NUTS
         for k in range(1, Ns):
+            # reset number of tree nodes for each iteration
+            self._num_tree_node = 0
+
             theta_k, joint_k = theta[:, k-1], joint_eval[k-1] # initial position (parameters)
             r_k = self._Kfun(1, 'sample') # resample momentum vector
             Ham = joint_k - self._Kfun(r_k, 'eval') # Hamiltonian
@@ -143,6 +204,10 @@ class NUTS(Sampler):
                 s = s_prime * int((dtheta @ r_minus.T) >= 0) * int((dtheta @ r_plus.T) >= 0)
                 j += 1
 
+            # update run diagnostic attributes
+            self._update_run_diagnostic_attributes(
+                k, self._num_tree_node, epsilon, epsilon_bar)
+            
             # adapt epsilon during burn-in using dual averaging
             if (k <= Nb) and (self.adapt_step_size == True):
                 eta1 = 1/(k + t_0)
@@ -160,7 +225,7 @@ class NUTS(Sampler):
             
             if np.isnan(joint_eval[k]):
                 raise NameError('NaN potential func')
-
+            
         # apply burn-in 
         theta = theta[:, Nb:]
         joint_eval = joint_eval[Nb:]
@@ -211,6 +276,9 @@ class NUTS(Sampler):
     #=========================================================================
     # @functools.lru_cache(maxsize=128)
     def _BuildTree(self, theta, r, grad, Ham, log_u, v, j, epsilon, Delta_max=1000):
+        # Increment the number of tree nodes counter
+        self._num_tree_node += 1
+
         if (j == 0):     # base case
             # single leapfrog step in the direction v
             theta_prime, r_prime, joint_prime, grad_prime = self._Leapfrog(theta, r, grad, v*epsilon)