CUQIpy 0.8.0.post0.dev2__tar.gz → 0.8.0.post0.dev13__tar.gz

{CUQIpy-0.8.0.post0.dev2 → CUQIpy-0.8.0.post0.dev13}/CUQIpy.egg-info/PKG-INFO

@@ -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 → CUQIpy-0.8.0.post0.dev13}/PKG-INFO

@@ -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 → CUQIpy-0.8.0.post0.dev13}/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
 

{CUQIpy-0.8.0.post0.dev2 → CUQIpy-0.8.0.post0.dev13}/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) 
         

{CUQIpy-0.8.0.post0.dev2 → CUQIpy-0.8.0.post0.dev13}/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)

{CUQIpy-0.8.0.post0.dev2 → CUQIpy-0.8.0.post0.dev13}/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)
 

{CUQIpy-0.8.0.post0.dev2 → CUQIpy-0.8.0.post0.dev13}/tests/test_MRFs.py

@@ -1,5 +1,5 @@
 import pytest
-from cuqi.distribution import LMRF, CMRF
+from cuqi.distribution import LMRF, CMRF, GMRF
 from cuqi.geometry import Image2D, Geometry, _DefaultGeometry2D
 import numpy as np
 
@@ -68,4 +68,30 @@ def test_CMRF_dim_vs_ndarray_location():
     assert cmrf1.logd(np.zeros(16)) == cmrf2.logd(np.zeros(16))
     assert np.allclose(cmrf1.gradient(np.zeros(16)),cmrf2.gradient(np.zeros(16)))
 
+# GMRF tests
+def test_GMRF_should_not_allow_None_or_scalar_geometry():
+    with pytest.raises(ValueError, match="supported geometry"):
+        GMRF(0, 0.2)
+
+@pytest.mark.parametrize("physical_dim", [-1, 0, 3])
+def test_GMRF_invalid_physical_dim_raises_error(physical_dim):
+    with pytest.raises(ValueError, match="Only physical dimension 1 or 2 supported."):
+        GMRF(0, 0.2, geometry=Image3D())
+
+def test_GMRF_mismatched_location_and_geometry_raises_error():
+    image_2d_geometry = Image2D((8, 8))
+    with pytest.raises(TypeError):
+        GMRF(np.zeros(3), 0.2, geometry=image_2d_geometry)
+
+def test_GMRF_default_geometry_is_replaced_when_physical_dim_is_2():
+    gmrf = GMRF(0, 0.2, geometry=(4,4))
+    assert isinstance(gmrf.geometry, _DefaultGeometry2D)
+
+def test_GMRF_dim_vs_ndarray_location():
+    gmrf1 = GMRF(0, 0.2, geometry=(4,4))
+    gmrf2 = GMRF(np.zeros(16), 0.2, geometry=Image2D((4,4)))
+    assert gmrf1.dim == gmrf2.dim
+    assert gmrf1.logd(np.zeros(16)) == gmrf2.logd(np.zeros(16))
+    assert np.allclose(gmrf1.gradient(np.zeros(16)),gmrf2.gradient(np.zeros(16)))
+
 

{CUQIpy-0.8.0.post0.dev2 → CUQIpy-0.8.0.post0.dev13}/tests/test_bayesian_inversion.py

@@ -13,7 +13,7 @@ from cuqi.density import Density
 @pytest.mark.parametrize("TP_type, phantom, prior, Ns", 
                          [
                              (Deconvolution1D, "gauss", Gaussian(np.zeros(128), 0.071**2), 20),
-                             (Deconvolution1D, "gauss", GMRF(np.zeros(128), 100, 1, "zero"), 20),
+                             (Deconvolution1D, "gauss", GMRF(np.zeros(128), 100, "zero"), 20),
                              (Deconvolution1D, "square", LMRF(0, 0.005, geometry=128), 100),
                              (Deconvolution1D, "square", CMRF(np.zeros(128), 0.01), 50),
                          ])

{CUQIpy-0.8.0.post0.dev2 → CUQIpy-0.8.0.post0.dev13}/tests/test_distribution.py

@@ -113,7 +113,7 @@ def test_Gaussian_rng(mean,std,R):
     cov = np.diag(std) @ (R @ np.diag(std))
     assert np.allclose(cuqi.distribution.Gaussian(mean,cov).sample(10).samples,cuqi.distribution.Gaussian(mean,cov).sample(10,rng=rng).samples)
 
-@pytest.mark.parametrize("dist",[cuqi.distribution.GMRF(np.ones(128),35,1,'zero'),cuqi.distribution.GMRF(np.ones(128),35,1,'periodic'),cuqi.distribution.GMRF(np.ones(128),35,1,'neumann')])
+@pytest.mark.parametrize("dist",[cuqi.distribution.GMRF(np.ones(128),35,'zero'),cuqi.distribution.GMRF(np.ones(128),35,'periodic'),cuqi.distribution.GMRF(np.ones(128),35,'neumann')])
 def test_GMRF_rng(dist):
     np.random.seed(3)
     rng = np.random.RandomState(3)
@@ -237,7 +237,7 @@ def test_Gaussians_vs_GMRF(prec, GMRF_order):
     X_cov = cuqi.distribution.Gaussian(np.zeros(dim), cov)
     X_sqrtprec = cuqi.distribution.Gaussian(np.zeros(dim), sqrtprec=sqrtprec)
     X_sqrtcov = cuqi.distribution.Gaussian(np.zeros(dim), sqrtcov=sqrtcov)
-    X_GMRF = cuqi.distribution.GMRF(np.zeros(dim), 1, 1, 'zero', order=GMRF_order)
+    X_GMRF = cuqi.distribution.GMRF(np.zeros(dim), 1, 'zero', order=GMRF_order)
 
     # logpdfs for full matrix
     x0 = np.random.randn(dim)
@@ -575,7 +575,7 @@ def test_Gaussian_Cov_sample(C):
                           cuqi.distribution.Gaussian(np.zeros(2),
                                                      np.array([[1.0, 0.7],
                                                                [0.7,  1.]])),
-                          cuqi.distribution.GMRF(np.zeros(2), 0.1, 1)])
+                          cuqi.distribution.GMRF(np.zeros(2), 0.1)])
 def test_enable_FD_gradient_distributions(dist):
     """Test that the distribution FD gradient is close to the exact gradient"""
     x = np.array([0.1, 0.3])
@@ -596,7 +596,7 @@ def test_enable_FD_gradient_distributions(dist):
                          [cuqi.distribution.Gaussian(np.zeros(6), np.eye(6)),
                           cuqi.distribution.Beta(np.ones(6)*2, 5),
                           cuqi.distribution.Lognormal(np.ones(6)*.1, 4),
-                          cuqi.distribution.GMRF(np.zeros(6), 0.1, 1)])
+                          cuqi.distribution.GMRF(np.zeros(6), 0.1)])
 @pytest.mark.parametrize("y",
                          [cuqi.distribution.Gaussian(np.zeros(6), np.eye(6)),
                           cuqi.distribution.Lognormal(np.zeros(6), 4)])

{CUQIpy-0.8.0.post0.dev2 → CUQIpy-0.8.0.post0.dev13}/tests/test_distributions_shape.py

@@ -17,16 +17,13 @@ ignore_list = [
 
 # Define cases to skip (these are TODO)
 skip_logd = [
-    cuqi.distribution.GMRF, # Mean must allow scalar values
     cuqi.distribution.Gamma # Missing force_ndarray
 ]
 skip_sample = [
-    cuqi.distribution.GMRF,  # Mean must allow scalar values
     cuqi.distribution.Gamma, # Missing force_ndarray
     cuqi.distribution.Lognormal,
 ]
 skip_gradient = [
-    cuqi.distribution.GMRF,  # Mean must allow scalar values
     cuqi.distribution.Gamma, # Missing force_ndarray
     cuqi.distribution.Lognormal,
     cuqi.distribution.InverseGamma, 

{CUQIpy-0.8.0.post0.dev2 → CUQIpy-0.8.0.post0.dev13}/tests/test_sampler.py

@@ -479,6 +479,9 @@ def test_Gibbs_regression(copy_reference):
             "data/Gibbs_original_code_results_win.npz")
     samples_orig = np.load(samples_orig_file)
 
+    # Save results
+    #np.savez("Gibbs_original_code_results_win.npz", samples["d"].samples)
+
     assert(np.allclose(samples["d"].samples, samples_orig["arr_0"]))
 
 def test_Gibbs_continue_sampling():