CUQIpy 0.8.0.post0.dev2__py3-none-any.whl → 0.8.0.post0.dev13__py3-none-any.whl

{CUQIpy-0.8.0.post0.dev2.dist-info → CUQIpy-0.8.0.post0.dev13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 0.8.0.post0.dev2
+Version: 0.8.0.post0.dev13
 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-0.8.0.post0.dev2.dist-info → CUQIpy-0.8.0.post0.dev13.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cuqi/__init__.py,sha256=K0ss2HNqoLUX7wGpSZdaPKxIaKdRS452fcJm4D0pcEs,433
 cuqi/_messages.py,sha256=fzEBrZT2kbmfecBBPm7spVu7yHdxGARQB4QzXhJbCJ0,415
-cuqi/_version.py,sha256=MQSud900OC1ibNn98W5vCqROwklBvJj9r_-pOO0rKgM,508
+cuqi/_version.py,sha256=8o64V7liXM5C7qTDSlG8846YAX74kBBM_o5Zjl9Zpvw,509
 cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
 cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
 cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
@@ -16,16 +16,16 @@ cuqi/density/_density.py,sha256=BG7gtP0cbFYLVgjYQGkNAhM95PR5ocBVLKRlOVX2PyM,7253
 cuqi/distribution/__init__.py,sha256=f85DzOHPvGec9nr_AIfp_THSuC4WN8ZUJMSLZrKClG8,615
 cuqi/distribution/_beta.py,sha256=xQ6nURJqB20j1A8YNnpKO9BUcb-kKUdq8QCmljlm9l4,2980
 cuqi/distribution/_cauchy.py,sha256=UsVXYz8HhagXN5fIWSAIyELqhsJAX_-wk9kkRGgRmA8,3296
-cuqi/distribution/_cmrf.py,sha256=5j4vZ97N6OydrRv74qUi-sZGmfxJfbHKug3La5viVNo,3735
+cuqi/distribution/_cmrf.py,sha256=tCbEulM_O7FB3C_W-3IqZp9zGHkTofCdFF0ybHc9UZI,3745
 cuqi/distribution/_custom.py,sha256=1ZFT3yjXsRKQJwNX3WwNDf2a9x13C9nIgxmq2wEOv4M,10657
 cuqi/distribution/_distribution.py,sha256=Qh8Yq-rtKh9xgog-2bo7d4-o0vaW_aAt5LaGbXlgX0U,17951
 cuqi/distribution/_gamma.py,sha256=GGsbIeHQhzUb1eTNeARcLXjJqcZ5iZWvaDaNsfJv9N0,1303
 cuqi/distribution/_gaussian.py,sha256=Ymllxg7ZQE24ss0oVgtPII4Hx4-xy3x1tAb01_-4i_U,33026
-cuqi/distribution/_gmrf.py,sha256=CFUjgN4b3mbyJHWDPCEO4zntBcF9Zq1cMgyzerM_3Wg,10385
+cuqi/distribution/_gmrf.py,sha256=OwId8qQWEtmC2fxVhL4iBHZnc8ZCrZzfV6yGXDE3k30,9522
 cuqi/distribution/_inverse_gamma.py,sha256=XRcNGW_jzORL08V7VvtsuMUoQioBAGbN12qe8hCXJvg,3309
 cuqi/distribution/_joint_distribution.py,sha256=jRsV1Dt-pW6sG_xNqF0TugeVKDJY4Kh5aBLsIWfv394,15043
 cuqi/distribution/_laplace.py,sha256=5exLvlzJm2AgfvZ3KUSkjfwlGwwbsktBxP8z0iLMik8,1401
-cuqi/distribution/_lmrf.py,sha256=HKIGFIZBvbSF-28tP3DmrpPLDNb8-tVmsu7GJVZvRzk,3280
+cuqi/distribution/_lmrf.py,sha256=rdGoQ-fPe1oW6Z29P-l3woq0NX3_RxUQ2rzm1VzemNM,3290
 cuqi/distribution/_lognormal.py,sha256=st1Uhf67qy2Seo65hA88JQ7lkEjQkW6KxznXahF_0SU,2844
 cuqi/distribution/_normal.py,sha256=UeoTtGDT7YSf4ZNo2amlVF9K-YQpYbf8q76jcRJTVFw,1914
 cuqi/distribution/_posterior.py,sha256=zAfL0GECxekZ2lBt1W6_LN0U_xskMwK4VNce5xAF7ig,5018
@@ -63,8 +63,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=UaC-rWhevEzi6862uZdHNQoBV8fAgsLm4Fobb6ik81I,8025
-CUQIpy-0.8.0.post0.dev2.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
-CUQIpy-0.8.0.post0.dev2.dist-info/METADATA,sha256=JbhclAYo32_qopsHgTQCQ0w_IWMtKpoXSNQD9BoMv7E,18385
-CUQIpy-0.8.0.post0.dev2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-CUQIpy-0.8.0.post0.dev2.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
-CUQIpy-0.8.0.post0.dev2.dist-info/RECORD,,
+CUQIpy-0.8.0.post0.dev13.dist-info/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
+CUQIpy-0.8.0.post0.dev13.dist-info/METADATA,sha256=3pWRkPFBPnXKK3yDk_5rQvVC-tllSZ9GtJwd0YD3Is0,18386
+CUQIpy-0.8.0.post0.dev13.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+CUQIpy-0.8.0.post0.dev13.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
+CUQIpy-0.8.0.post0.dev13.dist-info/RECORD,,

cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-12-07T11:04:12+0100",
+ "date": "2023-12-19T22:07:12+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "2a8abe27ac8ca7dcd377fb306230d4f1393d0550",
- "version": "0.8.0.post0.dev2"
+ "full-revisionid": "cdddb1ac7225b019877b440f2c84a5cf34190af5",
+ "version": "0.8.0.post0.dev13"
 }
 '''  # END VERSION_JSON
 

cuqi/distribution/_cmrf.py

@@ -44,7 +44,7 @@ class CMRF(Distribution):
  
     """
    
-    def __init__(self, location, scale, bc_type="zero", **kwargs):
+    def __init__(self, location=None, scale=None, bc_type="zero", **kwargs):
         # Init from abstract distribution class
         super().__init__(**kwargs) 
         

cuqi/distribution/_gmrf.py

@@ -2,11 +2,12 @@ import numpy as np
 from scipy.sparse import diags, eye
 from scipy.sparse import linalg as splinalg
 from scipy.linalg import dft
-from cuqi.geometry import _DefaultGeometry1D, Image2D, _get_identity_geometries
+from cuqi.geometry import _get_identity_geometries
 from cuqi.utilities import sparse_cholesky
 from cuqi import config
 from cuqi.operator import PrecisionFiniteDifference
 from cuqi.distribution import Distribution
+from cuqi.utilities import force_ndarray
 
 class GMRF(Distribution):
     """ Gaussian Markov random field (GMRF).
@@ -19,9 +20,6 @@ class GMRF(Distribution):
     prec : float
         Precision of the GMRF.
 
-    physical_dim : int
-        The physical dimension of what the distribution represents (can take the values 1 or 2).
-
     bc_type : str
         The type of boundary conditions to use. Can be 'zero', 'periodic' or 'neumann'.
 
@@ -94,54 +92,67 @@ class GMRF(Distribution):
     For more details see: See Bardsley, J. (2018). Computational Uncertainty Quantification for Inverse Problems, Chapter 4.2.
 
     """
-        
-    def __init__(self, mean, prec, physical_dim=1, bc_type='zero', order=1, is_symmetric=True, **kwargs): 
-        super().__init__(is_symmetric=is_symmetric, **kwargs) #TODO: This calls Distribution __init__, should be replaced by calling Gaussian.__init__ 
 
-        self.mean = mean.reshape(len(mean), 1)
+    def __init__(self, mean=None, prec=None, bc_type="zero", order=1, **kwargs):
+        # Init from abstract distribution class
+        super().__init__(**kwargs)
+
+        self.mean = mean
         self.prec = prec
-        self._partition_size = int(len(mean)**(1/physical_dim))
-        self._bc_type = bc_type      # boundary conditions
+        self._bc_type = bc_type
+
+        # Ensure geometry has shape
+        if not self.geometry.fun_shape or self.geometry.par_dim == 1:
+            raise ValueError(f"Distribution {self.__class__.__name__} must be initialized with supported geometry (geometry of which the fun_shape is not None) and has parameter dimension greater than 1.")
+
+        # Default physical_dim to geometry's dimension if not provided
+        physical_dim = len(self.geometry.fun_shape)
+
+        # Ensure provided physical dimension is either 1 or 2
+        if physical_dim not in [1, 2]:
+            raise ValueError("Only physical dimension 1 or 2 supported.")
+
         self._physical_dim = physical_dim
-        
-        num_nodes = tuple(self._partition_size for _ in range(physical_dim))
-        if physical_dim == 2: #TODO. Remove once _DefaultGeometry is implemented for 2D.
-            if isinstance(self.geometry, _DefaultGeometry1D):
-                self.geometry = Image2D(num_nodes)
 
-        self._prec_op = PrecisionFiniteDifference(num_nodes, bc_type=bc_type, order=order) 
-        self._diff_op = self._prec_op._diff_op      
+        if self._physical_dim == 2:
+            N = int(np.sqrt(self.dim))
+            num_nodes = (N, N)
+        else: 
+            num_nodes = self.dim
+
+        self._prec_op = PrecisionFiniteDifference(num_nodes=num_nodes, bc_type=bc_type, order=order)
+        self._diff_op = self._prec_op._diff_op 
                    
         # compute Cholesky and det
         if (bc_type == 'zero'):    # only for PSD matrices
             self._rank = self.dim
             self._chol = sparse_cholesky(self._prec_op.get_matrix()).T
             self._logdet = 2*sum(np.log(self._chol.diagonal()))
-            # L_cholmod = cholesky(self.L, ordering_method='natural')
-            # self.chol = L_cholmod
-            # self.logdet = L_cholmod.logdet()
-            # 
-            # np.log(np.linalg.det(self.L.todense()))
         elif (bc_type == 'periodic') or (bc_type == 'neumann'):
-            # Print warning that periodic and Neumann boundary conditions are experimental
             print("Warning (GMRF): Periodic and Neumann boundary conditions are experimental. Sampling using LinearRTO may not produce fully accurate results.")
-
             eps = np.finfo(float).eps
             self._rank = self.dim - 1   #np.linalg.matrix_rank(self.L.todense())
             self._chol = sparse_cholesky(self._prec_op + np.sqrt(eps)*eye(self.dim, dtype=int)).T
-            if (self.dim > config.MAX_DIM_INV):  # approximate to avoid 'excesive' time
+            if (self.dim > config.MAX_DIM_INV):  # approximate to avoid 'excessive' time
                 self._logdet = 2*sum(np.log(self._chol.diagonal()))
             else:
-                # eigval = eigvalsh(self.L.todense())
                 self._L_eigval = splinalg.eigsh(self._prec_op.get_matrix(), self._rank, which='LM', return_eigenvectors=False)
                 self._logdet = sum(np.log(self._L_eigval))
         else:
             raise ValueError('bc_type must be "zero", "periodic" or "neumann"')
 
+    @property
+    def mean(self):
+        return self._mean
+    
+    @mean.setter
+    def mean(self, value):
+        self._mean = force_ndarray(value, flatten=True)
+
     @property
     def prec(self):
         return self._prec
-
+    
     @prec.setter
     def prec(self, value):
         # We store the precision as a scalar to match existing code in this class,
@@ -153,33 +164,20 @@ class GMRF(Distribution):
                 raise ValueError('Precision must be a scalar or a 1D array with a single scalar element.')
         self._prec = value
 
-    @property 
-    def dim(self):  
-        if self._physical_dim == 1:
-            return self._partition_size 
-        elif self._physical_dim==2:
-            return self._partition_size**2
-        raise ValueError("attribute dom can be either 1 or 2")
-
     def logpdf(self, x):
-        mean = self.mean.flatten()
+        mean = self.mean
         const = 0.5*(self._rank*(np.log(self.prec)-np.log(2*np.pi)) + self._logdet)
-        y = const - 0.5*( self.prec*((x-mean).T @ (self._prec_op @ (x-mean))) )
-        # = sps.multivariate_normal.logpdf(x.T, self.mean.flatten(), np.linalg.inv(self.prec*self.L.todense()))
-        return y
-
-    def pdf(self, x):
-        # = sps.multivariate_normal.pdf(x.T, self.mean.flatten(), np.linalg.inv(self.prec*self.L.todense()))
-        return np.exp(self.logpdf(x))
+        return const - 0.5*( self.prec*((x-mean).T @ (self._prec_op @ (x-mean))) )
 
     def _gradient(self, x):
         #Avoid complicated geometries that change the gradient.
         if not type(self.geometry) in _get_identity_geometries():
             raise NotImplementedError("Gradient not implemented for distribution {} with geometry {}".format(self,self.geometry))
 
-        if not callable(self.mean):
-            mean = self.mean.flatten()
-            return -(self.prec*self._prec_op) @ (x-mean)
+        if not callable(self.mean): # for prior
+            return -(self.prec*self._prec_op) @ (x-self.mean)
+        else:
+            NotImplementedError("Gradient not implemented for mean {}".format(type(self.mean)))
 
     def _sample(self, N=1, rng=None):
         if (self._bc_type == 'zero'):
@@ -190,10 +188,9 @@ class GMRF(Distribution):
                 xi = np.random.randn(self.dim, N)   # standard Gaussian
 
             if N == 1:
-                s = self.mean.flatten() + (1/np.sqrt(self.prec))*splinalg.spsolve(self._chol.T, xi)
-            else:
                 s = self.mean + (1/np.sqrt(self.prec))*splinalg.spsolve(self._chol.T, xi)
-            # s = self.mean + (1/np.sqrt(self.prec))*L_cholmod.solve_Lt(xi, use_LDLt_decomposition=False) 
+            else:
+                s = self.mean[:, np.newaxis] + (1/np.sqrt(self.prec))*splinalg.spsolve(self._chol.T, xi)
                         
         elif (self._bc_type == 'periodic'):
             
@@ -206,12 +203,9 @@ class GMRF(Distribution):
                 xi = np.random.randn(self.dim, N) + 1j*np.random.randn(self.dim, N)
             
             F = dft(self.dim, scale='sqrtn')   # unitary DFT matrix
-            # eigv = eigvalsh(self.L.todense()) # splinalg.eigsh(self.L, self.rank, return_eigenvectors=False)           
             eigv = np.hstack([self._L_eigval, self._L_eigval[-1]])  # repeat last eigval to complete dim
             L_sqrt = diags(np.sqrt(eigv)) 
-            s = self.mean + (1/np.sqrt(self.prec))*np.real(F.conj() @ splinalg.spsolve(L_sqrt, xi))
-            # L_sqrt = pinvh(np.diag(np.sqrt(eigv)))
-            # s = self.mean + (1/np.sqrt(self.prec))*np.real(F.conj() @ (L_sqrt @ xi))
+            s = self.mean[:, np.newaxis] + (1/np.sqrt(self.prec))*np.real(F.conj() @ splinalg.spsolve(L_sqrt, xi))
             
         elif (self._bc_type == 'neumann'):
 
@@ -220,7 +214,7 @@ class GMRF(Distribution):
             else:
                 xi = np.random.randn(self._diff_op.shape[0], N)   # standard Gaussian
 
-            s = self.mean + (1/np.sqrt(self.prec))* \
+            s = self.mean[:, np.newaxis] + (1/np.sqrt(self.prec))* \
                 splinalg.spsolve(self._chol.T, (splinalg.spsolve(self._chol, (self._diff_op.T @ xi)))) 
         else:
             raise TypeError('Unexpected BC type (choose from zero, periodic, neumann or none)')
@@ -233,5 +227,4 @@ class GMRF(Distribution):
 
     @property
     def sqrtprecTimesMean(self):
-        return (self.sqrtprec@self.mean).flatten()
-        
+        return (self.sqrtprec@self.mean)

cuqi/distribution/_lmrf.py

@@ -40,7 +40,7 @@ class LMRF(Distribution):
         prior = cuqi.distribution.LMRF(location=0, scale=0.1, geometry=128)
  
     """
-    def __init__(self, location, scale, bc_type="zero", **kwargs):
+    def __init__(self, location=None, scale=None, bc_type="zero", **kwargs):
         # Init from abstract distribution class
         super().__init__(**kwargs)