CUQIpy 1.0.0.post0.dev180__py3-none-any.whl → 1.0.0.post0.dev202__py3-none-any.whl

{CUQIpy-1.0.0.post0.dev180.dist-info → CUQIpy-1.0.0.post0.dev202.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.0.0.post0.dev180
+Version: 1.0.0.post0.dev202
 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>, Chao Zhang <chaz@dtu.dk>
 License: Apache License

{CUQIpy-1.0.0.post0.dev180.dist-info → CUQIpy-1.0.0.post0.dev202.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cuqi/__init__.py,sha256=LsGilhl-hBLEn6Glt8S_l0OJzAA1sKit_rui8h-D-p0,488
 cuqi/_messages.py,sha256=fzEBrZT2kbmfecBBPm7spVu7yHdxGARQB4QzXhJbCJ0,415
-cuqi/_version.py,sha256=nZ9Rz10NtUnQZt09kW9YMygjxV0G-qsipgAL3xBFeAU,510
+cuqi/_version.py,sha256=Eygdo6Qj24ocqoILprXlMc5JUVsIEnrGb4MKDLDpuDo,510
 cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
 cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
 cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
@@ -32,10 +32,11 @@ 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/experimental/__init__.py,sha256=vhZvyMX6rl8Y0haqCzGLPz6PSUKyu75XMQbeDHqTTrw,83
-cuqi/experimental/mcmc/__init__.py,sha256=S4aXYpnO75HQcwDYfr1-ki8UvlenPDXxshES5avtBF0,340
+cuqi/experimental/mcmc/__init__.py,sha256=meBaf5xOELviF866nB6BnpfftYXhyx-w78ad0HshP1I,384
 cuqi/experimental/mcmc/_cwmh.py,sha256=yRlTk5a1QYfH3JyCecfOOTeDf-4-tmJ3Tl2Bc3pyp1Y,7336
 cuqi/experimental/mcmc/_hmc.py,sha256=qqAyoAajLE_JenYMgAbD3tknuEf75AJu-ufF69GKGk4,19384
 cuqi/experimental/mcmc/_langevin_algorithm.py,sha256=MX48u3GYgCckB6Q5h5kXr_qdIaLQH2toOG5u29OY7gk,8245
+cuqi/experimental/mcmc/_laplace_approximation.py,sha256=7reeOnDY77WnOwqYls5WStftHgylwCNVodudRroApF0,5812
 cuqi/experimental/mcmc/_mh.py,sha256=aIV1Ntq0EAq3QJ1_X-DbP7eDAL-d_Or7d3RUO-R48I4,3090
 cuqi/experimental/mcmc/_pcn.py,sha256=3M8zhQGQa53Gz04AkC8wJM61_5rIjGVnhPefi8m4dbY,3531
 cuqi/experimental/mcmc/_rto.py,sha256=jSPznr34XPfWM6LysWIiN4hE-vtyti3cHyvzy9ruykg,11349
@@ -76,8 +77,8 @@ cuqi/testproblem/_testproblem.py,sha256=x769LwwRdJdzIiZkcQUGb_5-vynNTNALXWKato7s
 cuqi/utilities/__init__.py,sha256=EfxHLdsyDNugbmbzs43nV_AeKcycM9sVBjG9WZydagA,351
 cuqi/utilities/_get_python_variable_name.py,sha256=QwlBVj2koJRA8s8pWd554p7-ElcI7HUwY32HknaR92E,1827
 cuqi/utilities/_utilities.py,sha256=At3DOXRdF3GwLkVcM2FXooGyjAGfPkIM0bRzhTfLmWk,8046
-CUQIpy-1.0.0.post0.dev180.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
-CUQIpy-1.0.0.post0.dev180.dist-info/METADATA,sha256=YSVheKM46Y6Al3zXEu11wlCkJxAasZw2onXB0nTLN08,18393
-CUQIpy-1.0.0.post0.dev180.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-CUQIpy-1.0.0.post0.dev180.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
-CUQIpy-1.0.0.post0.dev180.dist-info/RECORD,,
+CUQIpy-1.0.0.post0.dev202.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
+CUQIpy-1.0.0.post0.dev202.dist-info/METADATA,sha256=3HmIqBG9T7FXxvuQBu7LK7p1PLLJ2-e1BBi4ZKWK0vk,18393
+CUQIpy-1.0.0.post0.dev202.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+CUQIpy-1.0.0.post0.dev202.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
+CUQIpy-1.0.0.post0.dev202.dist-info/RECORD,,

cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-04-22T18:01:04+0200",
+ "date": "2024-04-30T14:38:06+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "be4b485322b1be52f78dfe6d03694d6ba2000b11",
- "version": "1.0.0.post0.dev180"
+ "full-revisionid": "e5596bf72d78672549c26c4921e473c12fcf2553",
+ "version": "1.0.0.post0.dev202"
 }
 '''  # END VERSION_JSON
 

cuqi/experimental/mcmc/__init__.py

@@ -6,4 +6,5 @@ from ._mh import MHNew
 from ._pcn import pCNNew
 from ._rto import LinearRTONew, RegularizedLinearRTONew
 from ._cwmh import CWMHNew
+from ._laplace_approximation import UGLANew
 from ._hmc import NUTSNew

cuqi/experimental/mcmc/_laplace_approximation.py

@@ -0,0 +1,159 @@
+import scipy as sp
+import numpy as np
+import cuqi
+from cuqi.solver import CGLS
+from cuqi.experimental.mcmc import SamplerNew
+
+class UGLANew(SamplerNew):
+    """ Unadjusted (Gaussian) Laplace Approximation sampler
+    
+    Samples an approximate posterior where the prior is approximated
+    by a Gaussian distribution. The likelihood must be Gaussian.
+
+    Currently only works for LMRF priors.
+
+    The inner solver is Conjugate Gradient Least Squares (CGLS) solver.
+
+    For more details see: Uribe, Felipe, et al. A hybrid Gibbs sampler for edge-preserving 
+    tomographic reconstruction with uncertain view angles. SIAM/ASA Journal on UQ,
+    https://doi.org/10.1137/21M1412268 (2022).
+
+    Parameters
+    ----------
+    target : `cuqi.distribution.Posterior`
+        The target posterior distribution to sample.
+
+    initial_point : ndarray, *Optional*
+        Initial parameters.
+        If not provided, it defaults to zeros.
+
+    maxit : int
+        Maximum number of inner iterations for solver when generating one sample.
+        If not provided, it defaults to 50.
+
+    tol : float
+        Tolerance for inner solver.
+        The inner solvers will stop before maxit if convergence check reaches tol.
+        If not provided, it defaults to 1e-4.
+
+    beta : float
+        Smoothing parameter for the Gaussian approximation of the Laplace distribution.
+        A small value in the range of 1e-7 to 1e-3 is recommended, though values out of this 
+        range might give better results in some cases. Generally, a larger beta value makes 
+        sampling easier but results in a worse approximation. See details in Section 3.3 of the paper.
+        If not provided, it defaults to 1e-5.
+
+    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.
+    """
+    def __init__(self, target, initial_point=None, maxit=50, tol=1e-4, beta=1e-5, **kwargs):
+
+        super().__init__(target=target, initial_point=initial_point, **kwargs)
+
+        if initial_point is None: #TODO: Replace later with a getter
+            self.initial_point = np.zeros(self.dim)
+            self._samples = [self.initial_point]
+
+        self.current_point = self.initial_point
+        self._acc = [1] # TODO. Check if we need this
+
+        # Parameters
+        self.maxit = maxit
+        self.tol = tol
+        self.beta = beta
+
+    @property
+    def prior(self):
+        return self.target.prior
+
+    @property
+    def likelihood(self):
+        return self.target.likelihood
+
+    @property
+    def model(self):
+        return self.target.model     
+    
+    @property
+    def data(self):
+        return self.target.data
+
+    def _pre_warmup(self):
+        super()._pre_warmup()
+        D = self.prior._diff_op
+        n = D.shape[0]
+
+        # Gaussian approximation of LMRF prior as function of x_k
+        def Lk_fun(x_k):
+            dd =  1/np.sqrt((D @ x_k)**2 + self.beta*np.ones(n))
+            W = sp.sparse.diags(dd)
+            return W.sqrt() @ D
+        self.Lk_fun = Lk_fun
+
+        self._m = len(self.data)
+        self._L1 = self.likelihood.distribution.sqrtprec
+
+        # If prior location is scalar, repeat it to match dimensions
+        if len(self.prior.location) == 1:
+            self._priorloc = np.repeat(self.prior.location, self.dim)
+        else:
+            self._priorloc = self.prior.location
+
+        # Initial Laplace approx
+        self._L2 = Lk_fun(self.initial_point)
+        self._L2mu = self._L2@self._priorloc
+        self._b_tild = np.hstack([self._L1@self.data, self._L2mu]) 
+        
+        # Least squares form
+        def M(x, flag):
+            if flag == 1:
+                out1 = self._L1 @ self.model.forward(x)
+                out2 = np.sqrt(1/self.prior.scale)*(self._L2 @ x)
+                out  = np.hstack([out1, out2])
+            elif flag == 2:
+                idx = int(self._m)
+                out1 = self.model.adjoint(self._L1.T@x[:idx])
+                out2 = np.sqrt(1/self.prior.scale)*(self._L2.T @ x[idx:])
+                out  = out1 + out2                
+            return out
+        self.M = M
+
+    def _pre_sample(self):
+        self._pre_warmup()
+
+    def step(self):
+        # Update Laplace approximation
+        self._L2 = self.Lk_fun(self.current_point)
+        self._L2mu = self._L2@self._priorloc
+        self._b_tild = np.hstack([self._L1@self.data, self._L2mu]) 
+    
+        # Sample from approximate posterior
+        e = np.random.randn(len(self._b_tild))
+        y = self._b_tild + e # Perturb data
+        sim = CGLS(self.M, y, self.current_point, self.maxit, self.tol)                     
+        self.current_point, _ = sim.solve()
+        acc = 1
+        return acc
+
+    def tune(self, skip_len, update_count):
+        pass
+    
+    def validate_target(self):
+        # Check target type
+        if not isinstance(self.target, cuqi.distribution.Posterior):
+            raise ValueError(f"To initialize an object of type {self.__class__}, 'target' need to be of type 'cuqi.distribution.Posterior'.")       
+
+        # Check Linear model
+        if not isinstance(self.likelihood.model, cuqi.model.LinearModel):
+            raise TypeError("Model needs to be linear")
+
+        # Check Gaussian likelihood
+        if not hasattr(self.likelihood.distribution, "sqrtprec"):
+            raise TypeError("Distribution in Likelihood must contain a sqrtprec attribute")
+
+        # Check that prior is LMRF
+        if not isinstance(self.prior, cuqi.distribution.LMRF):
+            raise ValueError('Unadjusted Gaussian Laplace approximation (UGLA) requires LMRF prior')