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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 0.5.0.post0.dev5
+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.post0.dev5.dist-info → CUQIpy-0.5.0.post0.dev9.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=vnMFIrl_UUi9EYW6QMKBgDq_UFPEIOG2z_1uTDOOpjk,508
 cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
 cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
 cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
@@ -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.dev9.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
+CUQIpy-0.5.0.post0.dev9.dist-info/METADATA,sha256=YH1Nh4y7MOu3BrNEdBfqonhGEOVclxTImBL3_TOGUTg,16420
+CUQIpy-0.5.0.post0.dev9.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+CUQIpy-0.5.0.post0.dev9.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
+CUQIpy-0.5.0.post0.dev9.dist-info/RECORD,,

cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-09-14T11:43:13+0200",
+ "date": "2023-09-20T08:59:50+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "10df75286cece2b7b0876697501f4d2354b36f5f",
- "version": "0.5.0.post0.dev5"
+ "full-revisionid": "5aa5af171cc495556f93f0ceecc78606ad9b9185",
+ "version": "0.5.0.post0.dev9"
 }
 '''  # END VERSION_JSON
 

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)