CUQIpy 0.5.0__tar.gz → 0.5.0.post0.dev9__tar.gz

{CUQIpy-0.5.0 → CUQIpy-0.5.0.post0.dev9}/CUQIpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 0.5.0
+Version: 0.5.0.post0.dev9
 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 → CUQIpy-0.5.0.post0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 0.5.0
+Version: 0.5.0.post0.dev9
 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 → CUQIpy-0.5.0.post0.dev9}/cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-09-01T13:02:40+0200",
+ "date": "2023-09-20T08:59:50+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "72a7375b06f87f9284311af55214f0c3246ebf9b",
- "version": "0.5.0"
+ "full-revisionid": "5aa5af171cc495556f93f0ceecc78606ad9b9185",
+ "version": "0.5.0.post0.dev9"
 }
 '''  # END VERSION_JSON
 

{CUQIpy-0.5.0 → CUQIpy-0.5.0.post0.dev9}/cuqi/geometry/_geometry.py

@@ -36,7 +36,6 @@ class Geometry(ABC):
             if hasattr(funvals, 'shape'):
                 self._fun_shape = funvals.shape
             else:
-                warnings.warn("Could not infer function space shape.")
                 self._fun_shape = None
         return self._fun_shape
     

{CUQIpy-0.5.0 → CUQIpy-0.5.0.post0.dev9}/cuqi/problem/_problem.py

@@ -444,10 +444,10 @@ class BayesianProblem(object):
             try:
                 samples.plot_ci(percent=percent, exact=exact)
             except NotImplementedError as nie:
-                warnings.warn(
-                    f"Unable to plot CI for samples with the underlying "+
-                     "geometry {samples.geometry}. Plotting the CI for the "+
-                     "parameters instead.")
+                print(
+                    "Unable to plot CI for samples with the underlying " +
+                    f"geometry: {samples.geometry}. Plotting the CI for the " +
+                    "parameters instead.")
                 self._alternative_plot_UQ_for_variable(
                     samples, percent=percent, exact=exact)
 

{CUQIpy-0.5.0 → CUQIpy-0.5.0.post0.dev9}/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)
@@ -219,7 +287,12 @@ class NUTS(Sampler):
             s_prime = int(log_u < Delta_max + Ham_prime)     # check U-turn
             #
             diff_Ham = Ham_prime - Ham
-            alpha_prime = min(1, np.exp(diff_Ham))     # logalpha_p = min(0, H_p - H)
+
+            # Compute the acceptance probability
+            # alpha_prime = min(1, np.exp(diff_Ham))
+            # written in a stable way to avoid overflow when computing
+            # exp(diff_Ham) for large values of diff_Ham
+            alpha_prime = 1 if diff_Ham > 0 else np.exp(diff_Ham)
             n_alpha_prime = 1
             #
             theta_minus, theta_plus = theta_prime, theta_prime