CUQIpy 0.5.0.post0.dev9__tar.gz → 0.5.0.post0.dev19__tar.gz

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

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

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

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2023-09-20T08:59:50+0200",
+ "date": "2023-09-20T22:14:47+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "5aa5af171cc495556f93f0ceecc78606ad9b9185",
- "version": "0.5.0.post0.dev9"
+ "full-revisionid": "85066baa356c88fbab83075272f0337134b6d832",
+ "version": "0.5.0.post0.dev19"
 }
 '''  # END VERSION_JSON
 

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

@@ -331,6 +331,36 @@ class Continuous(Geometry, ABC):
     
     def fun2par(self,funvals):
         return funvals
+    
+    def _reshape_par2fun_input(self, pars):
+        """Make sure that the parameter last dimension reflects the number of
+        parameter vectors: 1 for a single parameter vector and n for n parameter
+        vectors."""
+        # Ensure pars shape is correct (either squeezed single vector or 
+        # multiple vectors with the correct shape).
+        if pars.shape != self.par_shape and\
+                pars.shape[:-1] != self.par_shape:
+            raise ValueError(
+                f"pars must have shape {self.par_shape} or {self.par_shape}"
+                + "+(n,) where n is the number of parameter vectors")
+
+        # Add dim to pars if pars is a single parameter vector.
+        return pars.reshape(self.par_shape + (-1,))
+
+    def _reshape_fun2par_input(self, funvals):
+        """Make sure that the function value last dimension reflects the number
+        of functions: 1 for a single function and n for n functions."""
+        # Ensure funvals shape is correct (either squeezed single function or 
+        # multiple functions with the correct shape).
+        if funvals.shape != self.fun_shape and\
+                funvals.shape[:-1] != self.fun_shape:
+            raise ValueError(
+                f"funvals must have shape {self.fun_shape} or {self.fun_shape}"
+                + "+(n,) where n is the number of functions")
+
+        # Add dim to funvals if funvals is a single function.
+        return funvals.reshape(self.fun_shape + (-1,))
+
 
 class Continuous1D(Continuous):
     """A class that represents a continuous 1D geometry.
@@ -769,6 +799,7 @@ class KLExpansion(Continuous1D):
         self._normalizer = normalizer  # normalizer factor
         self._num_modes = num_modes # number of modes 
         self._coefs = None
+        self._coefs_inverse = None
 
     @property
     def par_shape(self):
@@ -796,10 +827,22 @@ class KLExpansion(Continuous1D):
         # If the coefficients are not computed, compute them.
         if self._coefs is None or len(self._coefs) != self.num_modes:
             eigvals = np.array(range(1, self.par_dim+1))  # KL eigvals
-            self._coefs = 1/np.float_power(eigvals, self.decay_rate)
+            self._coefs = np.diag(1/np.float_power(eigvals, self.decay_rate))
 
         # Return the coefficients.
         return self._coefs
+    
+    @property
+    def coefs_inverse(self):
+        """Computes the inverse of the coefficients diagonal matrix."""
+        
+        # If the matrix is not computed, compute it.
+        if self._coefs_inverse is None or\
+            len(self._coefs_inverse) != self.num_modes:
+            self._coefs_inverse = np.diag(np.float_power(np.diag(self.coefs), -1))
+
+        # Return the inverse coefficients matrix.
+        return self._coefs_inverse
 
     @property
     def num_modes(self):
@@ -816,19 +859,22 @@ class KLExpansion(Continuous1D):
 
     # computes the real function out of expansion coefs
     def par2fun(self, p):
-        # Check that the input is of the correct shape
-        if len(p) != self.par_dim:
-            raise ValueError(
-                "Input array p must have length {}".format(self.par_dim))
 
-        modes = p*self.coefs/self.normalizer
+        # Reshape the parameter vector
+        p = self._reshape_par2fun_input(p)
 
-        # pad the remaining modes with zeros
-        modes = np.pad(modes, (0, self.fun_dim-self.par_dim),
+        modes = self.coefs@p/self.normalizer
+
+        # pad the remaining modes with zeros (for single or multiple parameter
+        # parameter vectors)
+        modes = np.pad(modes, ((0, self.fun_dim-self.par_dim), (0, 0)),
                        'constant', constant_values=0)
 
-        real = idst(modes)/2
-        return real
+        real = idst(modes.T).T/2
+
+        # squeeze to return single function value if only one parameter vector
+        # was given
+        return real.squeeze()
 
     def fun2par(self, funvals):
         """The function to parameter map used to map function values back to
@@ -837,11 +883,9 @@ class KLExpansion(Continuous1D):
         always the inverse of `par2fun` but it is the closest estimation of the
         function on the KL expansion coefficient space."""
 
-        # Check that the input is of the correct shape
-        if len(funvals) != self.fun_dim:
-            raise ValueError(
-                "Input array funvals must have length {}".format(self.fun_dim))
-        
+        # Reshape the function values
+        funvals = self._reshape_fun2par_input(funvals)
+
         warnings.warn(
             f"fun2par for {self.__class__} is a projection on "
             + "the KL expansion coefficients space where only "
@@ -865,10 +909,14 @@ class KLExpansion(Continuous1D):
         # However, if we use, for example, scipy.fft instead of scipy.fftpack,
         # then this scaling is not needed.
 
-        p = dst(funvals*2)[:self.par_dim]\
-            *self.normalizer/(self.coefs*2*self.fun_dim)
+        # Transform (single or multiple functions) to expansion coefficients
+        p_temp = dst(funvals.T*2).T[:self.par_dim,:]
+        p = self.coefs_inverse@p_temp*self.normalizer/(2*self.fun_dim)
+        
+        # squeeze to return single parameter vector if only one function value
+        # was given
+        return p.squeeze()
 
-        return p
 
 class KLExpansion_Full(Continuous1D):
     '''
@@ -1138,24 +1186,55 @@ class StepExpansion(Continuous1D):
         return self._n_steps
 
     def par2fun(self, p):
-        real = np.zeros(self.grid.shape)
+
+        # Reshape the parameter vector
+        p = self._reshape_par2fun_input(p)
+
+        # Extended fun_shape to include multiple functions.
+        ext_fun_shape = self.fun_shape + (p.shape[-1],)
+
+        # Initialize fun to zeros.
+        fun = np.zeros(ext_fun_shape)
+
+        # Fill fun with the step function values.
         for i in range(self._n_steps):
-            real[self._indices[i]] = p[i]
+            fun[self._indices[i],:] = p[i,:]
+
+        # Squeeze to return single evaluated function if only one parameter
+        # vector was given.
+        return fun.squeeze()
  
-        return real
 
     def fun2par(self,f):
-        val = np.zeros(self._n_steps)
+
+        # Reshape the function values
+        f = self._reshape_fun2par_input(f)
+
+        # Extended par_shape to include multiple parameter vectors.
+        ext_par_shape = self.par_shape + (f.shape[-1],)
+        
+        # Initialize par to zeros.
+        par = np.zeros(ext_par_shape)
+
+        # Fill par with the projection of the function values.
         for i in range(self._n_steps):
             if self._fun2par_projection.lower() == 'mean':
-                val[i] = np.mean(f[self._indices[i]])
+                projection_method = np.mean
             elif self._fun2par_projection.lower() == 'max':
-                val[i] = np.max(f[self._indices[i]])
+                projection_method = np.max
             elif self._fun2par_projection.lower() == 'min':
-                val[i] = np.min(f[self._indices[i]])
+                projection_method = np.min
             else:
                 raise ValueError("Invalid projection option.")
-        return val
+            
+            # Apply projection method to the function values in the ith
+            # interval.
+            par[i,:] = projection_method(f[self._indices[i],:], axis=0)
+
+        # Squeeze to return single parameter vector if only one function value
+        # was given.
+        return par.squeeze()
+    
 
     def _check_grid_setup(self):
         

{CUQIpy-0.5.0.post0.dev9 → CUQIpy-0.5.0.post0.dev19}/tests/test_geometry.py

@@ -145,8 +145,8 @@ def test_geometry_equality(g1, g2, truth_value):
 	"""Ensure geometry arrays compare correctly"""
 	assert (g1==g2) == truth_value
 
-@pytest.mark.parametrize("n_steps",[1,2,6,7,9,10,20, 21])
-def test_StepExpansion_geometry(n_steps):
+@pytest.mark.parametrize("n_steps", [1, 2, 6, 7, 9, 10, 20, 21])
+def test_StepExpansion_geometry(n_steps, copy_reference):
     """Check StepExpansion geometry correctness"""
     grid = np.linspace(0,1,20)
     if n_steps > np.size(grid):
@@ -159,8 +159,18 @@ def test_StepExpansion_geometry(n_steps):
         par = np.random.randn(n_steps)
         geom.plot(par,linestyle = '', marker='.')
 
-        assert np.allclose(par, geom.fun2par(geom.par2fun(par))) \
+        fun = geom.par2fun(par)
+        par2 = geom.fun2par(fun)
+
+        assert np.allclose(par, par2) \
            and geom.par_dim == n_steps
+        
+        # Assert fun and par2 matches the values in the data file
+        ref_file = copy_reference(
+            f"data/geometry/test_StepExpansion_{n_steps}.npz")
+        ref = np.load(ref_file)
+        assert np.allclose(fun, ref["fun"])
+        assert np.allclose(par2, ref["par2"])
 
 @pytest.mark.parametrize("projection, func",[('MiN', np.min),
       ('mAX', np.max),('mean', np.mean)])
@@ -186,8 +196,13 @@ def test_stepExpansion_fun2par(projection, func):
     assert np.allclose(p, qa_f.parameters)
 
 @pytest.mark.parametrize("num_modes",[1, 10, 20, 25])
-def test_KL_expansion(num_modes):
+def test_KL_expansion(num_modes, copy_reference):
     """Check KL expansion geometry correctness"""
+
+    # File name for reference data
+    ref_fname = f"data/geometry/KL_expansion_{num_modes}.npz"
+
+    # Set up KL expansion geometry
     N = 20
     grid = np.linspace(0, 1, N)
     decay_rate = 2.5
@@ -199,6 +214,7 @@ def test_KL_expansion(num_modes):
     if num_modes > len(grid):
         num_modes = len(grid)
 
+    # Apply par2fun and check results
     p = np.random.randn(N)
     f_geom = geom.par2fun(p[:num_modes])
 
@@ -211,6 +227,10 @@ def test_KL_expansion(num_modes):
     assert geom.par_dim == geom.num_modes
     assert len(geom.grid) == geom.fun_dim
 
+    # Verify the KL expansion results against the reference data
+    ref_file = copy_reference(ref_fname)
+    ref = np.load(ref_file)
+    assert np.allclose(f_geom, ref["f_geom"])
 
 def test_KLExpansion_set_grid():
     """Check updating grid in KL expansion geometry"""
@@ -371,7 +391,7 @@ def test_create_CustomKL_geometry():
 	   geom.trunc_term==trunc_term
 	
 
-def test_KLExpansion_projection():
+def test_KLExpansion_projection(copy_reference):
     """Check KLExpansion geometry projection performed by the method fun2par)"""
     # Set up a KLExpansion geometry
     num_modes = 95
@@ -399,6 +419,11 @@ def test_KLExpansion_projection():
     rel_err = np.linalg.norm(signal-signal_proj)/np.linalg.norm(signal)
     assert np.isclose(rel_err, 0.0, atol=1e-5)
 
+    # Compare results with reference data
+    ref_file = copy_reference("data/geometry/test_KLExpansion_projection.npz")
+    ref = np.load(ref_file)
+    assert np.allclose(p, ref["p"])
+
 def test_DefaultGeometry2D_should_be_image2D():
     geom2D = cuqi.geometry._DefaultGeometry2D((100, 100))
 
@@ -458,3 +483,68 @@ def test_Continuous2D_plot_multiple_funvals_pass(geom2D_funvals):
     # Convert to parameters then plot
     multiple_funvals_topar = geom2D.fun2par(multiple_funvals)
     geom2D.plot(multiple_funvals_topar, is_par=True)
+
+# Create fixture for KLExpansion geometry
+@pytest.fixture
+def geom_KL():
+    """Returns a KLExpansion geometry"""
+    N = 20
+    grid = np.linspace(0, 1, N)
+    decay_rate = 2.5
+    normalizer = 12
+    geom = cuqi.geometry.KLExpansion(grid,
+                                     decay_rate=decay_rate,
+                                     normalizer=normalizer,
+                                     num_modes=10)
+    return geom
+
+# Create fixture for StepExpansion geometry
+@pytest.fixture
+def geom_Step():
+    """Returns a StepExpansion geometry"""
+    N = 20
+    grid = np.linspace(0, 1, N)
+    n_steps = 10
+    geom = cuqi.geometry.StepExpansion(grid, n_steps=n_steps)
+    return geom
+
+# Create fixture to parametrize the tests by geometry
+@pytest.fixture
+def geom(request):
+    return request.getfixturevalue(request.param)
+
+# Compare par2fun and fun2par for each geometry for individual parameters 
+# vectors and multiple parameter vectors
+@pytest.mark.parametrize('geom', ['geom_KL', 'geom_Step'], indirect=True)
+def test_par2fun_and_fun2par_correctness_for_multiple_values(geom):
+    """Check the correctness of the par2fun and fun2par methods for different
+    geometries for multiple parameter vectors"""
+
+    # Create random parameter values
+    np.random.seed(0)
+    n = 5
+    par = np.random.randn(geom.par_dim, n)
+    
+    # run par2fun (first for multiple parameter vectors at once)
+    fun = geom.par2fun(par)
+
+    # run par2fun (for each parameter vector individually)
+    fun_ind = np.array([geom.par2fun(par[:, i]) for i in range(n)]).T
+
+    # Check that the results are the same
+    assert np.allclose(fun, fun_ind)
+
+    # Check plotting runs
+    geom.plot(fun, is_par=False)
+
+    # run fun2par (first for multiple functions at once)
+    par2 = geom.fun2par(fun)
+
+    # run fun2par (for each function individually)
+    par2_ind = np.array([geom.fun2par(fun[:, i]) for i in range(n)]).T
+
+    # Check that the results are the same
+    assert np.allclose(par2, par2_ind)
+
+    # Check plotting runs
+    geom.plot(par2, is_par=True)