CUQIpy 1.1.0.post0.dev39__tar.gz → 1.1.1.post0.dev5__tar.gz

{cuqipy-1.1.0.post0.dev39 → cuqipy-1.1.1.post0.dev5}/CUQIpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.1.0.post0.dev39
+Version: 1.1.1.post0.dev5
 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.1.0.post0.dev39 → cuqipy-1.1.1.post0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CUQIpy
-Version: 1.1.0.post0.dev39
+Version: 1.1.1.post0.dev5
 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.1.0.post0.dev39 → cuqipy-1.1.1.post0.dev5}/cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-08-29T10:46:43+0300",
+ "date": "2024-08-31T21:02:04+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "9d8920342c73b1bd8e7a47a216eb34056ea2f5d6",
- "version": "1.1.0.post0.dev39"
+ "full-revisionid": "b38281138379969a9a8c4683ba3ecf8a88031939",
+ "version": "1.1.1.post0.dev5"
 }
 '''  # END VERSION_JSON
 

{cuqipy-1.1.0.post0.dev39 → cuqipy-1.1.1.post0.dev5}/cuqi/distribution/_joint_distribution.py

@@ -175,6 +175,10 @@ class JointDistribution:
                 kwargs[ordered_keys[index]] = arg
         return kwargs
 
+    def _sum_evaluated_densities(self):
+        """ Return the sum of the evaluated densities in the joint distribution """
+        return sum([density.logd() for density in self._evaluated_densities])
+
     def _reduce_to_single_density(self):
         """ Reduce the joint distribution to a single density if possible.
 
@@ -183,7 +187,6 @@ class JointDistribution:
         This method is a hack to allow our current samplers to work with
         the joint distribution. It should be removed in the future.
         """
-
         # Count number of distributions and likelihoods
         n_dist = len(self._distributions)
         n_likelihood = len(self._likelihoods)
@@ -201,16 +204,29 @@ class JointDistribution:
             # Ensure parameter names match, otherwise return the joint distribution
             if set(self._likelihoods[0].get_parameter_names()) != set(self._distributions[0].get_parameter_names()):
                 return self
-            return Posterior(self._likelihoods[0], self._distributions[0])
-        
+            return self._add_constants_to_density(Posterior(self._likelihoods[0], self._distributions[0]))
+
         # If exactly one distribution and no likelihoods its a Distribution
         if n_dist == 1 and n_likelihood == 0:
-            return self._distributions[0]
-
+            return self._add_constants_to_density(self._distributions[0])        
+        
         # If no distributions and exactly one likelihood its a Likelihood
         if n_likelihood == 1 and n_dist == 0:
             return self._likelihoods[0]
 
+        # If only evaluated densities left return joint to ensure logd method is available
+        if n_dist == 0 and n_likelihood == 0:
+            return self
+        
+    def _add_constants_to_density(self, density: Density):
+        """ Add the constants (evaluated densities) to a single density. Used when reducing to single density. """
+
+        if isinstance(density, EvaluatedDensity):
+            raise ValueError("Cannot add the sum of all evaluated densities to an EvaluatedDensity.")
+
+        density._constant += self._sum_evaluated_densities()
+        return density
+
     def _as_stacked(self) -> _StackedJointDistribution:
         """ Return a stacked JointDistribution with the same densities. """
         return _StackedJointDistribution(*self._densities)

{cuqipy-1.1.0.post0.dev39 → cuqipy-1.1.1.post0.dev5}/cuqi/model/_model.py

@@ -19,10 +19,10 @@ class Model(object):
         Forward operator.
 
     range_geometry : integer or cuqi.geometry.Geometry
-        If integer is given a _DefaultGeometry is created with dimension of the integer.
+        If integer is given, a cuqi.geometry._DefaultGeometry is created with dimension of the integer.
 
     domain_geometry : integer or cuqi.geometry.Geometry
-        If integer is given a _DefaultGeometry is created with dimension of the integer.
+        If integer is given, a cuqi.geometry._DefaultGeometry is created with dimension of the integer.
 
     gradient : callable function, optional
         The direction-Jacobian product of the forward operator Jacobian with 
@@ -35,14 +35,20 @@ class Model(object):
         The Jacobian of the forward operator with respect to the forward operator input,
         evaluated at a point (`wrt`). The signature of the Jacobian function should be (`wrt`).
         The Jacobian function should return a 2D ndarray of shape (range_dim, domain_dim).
-        The Jacobian function is used to specify the gradient function (vector-Jacobian product)
+        The Jacobian function is used to specify the gradient function by computing the vector-Jacobian
+        product (VJP), here we refer to the vector in the VJP as the `direction` since it is the direction at 
+        which the gradient is computed.
         automatically and thus the gradient function should not be specified when the Jacobian
         function is specified.
 
+
+    :ivar range_geometry: The geometry representing the range.
+    :ivar domain_geometry: The geometry representing the domain.
+
     Example
     -------
 
-    Consider a forward model :math:`F: \mathbb{R}^2 \rightarrow \mathbb{R}` defined by the following forward operator:
+    Consider a forward model :math:`F: \mathbb{R}^2 \\rightarrow \mathbb{R}` defined by the following forward operator:
 
     .. math::
 
@@ -141,11 +147,17 @@ class Model(object):
         self._non_default_args = cuqi.utilities.get_non_default_args(self._forward_func)
 
     @property
-    def domain_dim(self): 
+    def domain_dim(self):
+        """
+        The dimension of the domain
+        """
         return self.domain_geometry.par_dim
 
     @property
     def range_dim(self): 
+        """
+        The dimension of the range
+        """
         return self.range_geometry.par_dim
 
     def _2fun(self, x, geometry, is_par):
@@ -466,28 +478,61 @@ class LinearModel(Model):
     forward : 2D ndarray or callable function.
         Forward operator.
 
-    adjoint : 2d ndarray or callable function. (optional if matrix is passed as forward)
+    adjoint : 2D ndarray or callable function. (optional if matrix is passed as forward)
 
     range_geometry : integer or cuqi.geometry.Geometry (optional)
-        If integer is given a _DefaultGeometry is created with dimension of the integer.
+        If integer is given, a cuqi.geometry._DefaultGeometry is created with dimension of the integer.
 
     domain_geometry : integer or cuqi.geometry.Geometry (optional)
-        If integer is given a _DefaultGeometry is created with dimension of the integer.
+        If integer is given, a cuqi.geometry._DefaultGeometry is created with dimension of the integer.
 
-    Attributes
-    -----------
-    range_geometry : cuqi.geometry.Geometry
-        The geometry representing the range.
 
-    domain_geometry : cuqi.geometry.Geometry
-        The geometry representing the domain.
+    :ivar range_geometry: The geometry representing the range.
+    :ivar domain_geometry: The geometry representing the domain.
 
-    Methods
-    -----------
-    :meth:`forward` the forward operator.
-    :meth:`range_dim` the dimension of the range.
-    :meth:`domain_dim` the dimension of the domain.
-    :meth:`get_matrix` returns an ndarray with the matrix representing the forward operator.
+    Example
+    -------
+
+    Consider a linear model represented by a matrix, i.e., :math:`y=Ax` where 
+    :math:`A` is a matrix.
+    
+    We can define such a linear model by passing the matrix :math:`A`:
+
+    .. code-block:: python
+
+        import numpy as np
+        from cuqi.model import LinearModel
+
+        A = np.random.randn(2,3)
+
+        model = LinearModel(A)
+
+    The dimension of the range and domain geometries will be automatically 
+    inferred from the matrix :math:`A`.
+        
+    Meanwhile, such a linear model can also be defined by a forward function 
+    and an adjoint function:
+
+    .. code-block:: python
+
+        import numpy as np
+        from cuqi.model import LinearModel
+
+        A = np.random.randn(2,3)
+
+        def forward(x):
+            return A@x
+
+        def adjoint(y):
+            return A.T@y
+
+        model = LinearModel(forward,
+                            adjoint=adjoint,
+                            range_geometry=2,
+                            domain_geometry=3)
+
+    Note that you would need to specify the range and domain geometries in this
+    case as they cannot be inferred from the forward and adjoint functions.
     """
     # Linear forward model with forward and adjoint (transpose).
     
@@ -552,6 +597,9 @@ class LinearModel(Model):
 
 
     def get_matrix(self):
+        """
+        Returns an ndarray with the matrix representing the forward operator.
+        """
         if self._matrix is not None: #Matrix exists so return it
             return self._matrix
         else:
@@ -594,24 +642,14 @@ class PDEModel(Model):
         Forward operator assembling, solving and observing the pde.
 
     range_geometry : integer or cuqi.geometry.Geometry (optional)
-        If integer is given a _DefaultGeometry is created with dimension of the integer.
+        If integer is given, a cuqi.geometry._DefaultGeometry is created with dimension of the integer.
 
     domain_geometry : integer or cuqi.geometry.Geometry (optional)
-        If integer is given a _DefaultGeometry is created with dimension of the integer.
-
-    Attributes
-    -----------
-    range_geometry : cuqi.geometry.Geometry
-        The geometry representing the range.
+        If integer is given, a cuqi.geometry._DefaultGeometry is created with dimension of the integer.
 
-    domain_geometry : cuqi.geometry.Geometry
-        The geometry representing the domain.
 
-    Methods
-    -----------
-    :meth:`forward` the forward operator.
-    :meth:`range_dim` the dimension of the range.
-    :meth:`domain_dim` the dimension of the domain.
+    :ivar range_geometry: The geometry representing the range.
+    :ivar domain_geometry: The geometry representing the domain.
     """
     def __init__(self, PDE: cuqi.pde.PDE, range_geometry, domain_geometry):
 

{cuqipy-1.1.0.post0.dev39 → cuqipy-1.1.1.post0.dev5}/tests/test_joint_distribution.py

@@ -310,3 +310,86 @@ def test_MultipleLikelihoodPosterior_should_raise_if_names_do_not_match():
     with pytest.raises(ValueError, match=r"the same parameter name"):
         cuqi.distribution.MultipleLikelihoodPosterior(y.to_likelihood(1), x, z)
 
+@pytest.mark.parametrize("joint, variables", [
+    (
+        cuqi.distribution.JointDistribution(
+            cuqi.distribution.Normal(0, 1, name="x"),
+            cuqi.distribution.Normal(0, 1, name="y")
+        ),
+        {
+            "x": 0,
+            "y": 0
+        }
+    ),
+    (
+        cuqi.distribution.JointDistribution(
+            cuqi.distribution.Uniform(0, 10, name="d"),
+            cuqi.distribution.Uniform(0, 5, name="s"),
+            cuqi.distribution.Gaussian(np.zeros(8), lambda d: d, name="x"),
+            cuqi.distribution.Gaussian(
+                mean=cuqi.testproblem.Deconvolution1D(dim=8).model,
+                cov=lambda s: s,
+                name="y"
+            )
+        ),
+        {
+            "d": 5,
+            "s": 2,
+            "x": np.zeros(8),
+            "y": cuqi.testproblem.Deconvolution1D(dim=8).data
+        }
+    ),
+    (
+        cuqi.distribution.JointDistribution(
+            cuqi.distribution.Uniform(0, 10, name="d"),
+            cuqi.distribution.Uniform(0, 5, name="s"),
+            cuqi.distribution.Gaussian(np.zeros(8), lambda d: d, name="x"),
+            cuqi.distribution.Gaussian(
+                mean=cuqi.testproblem.Deconvolution1D(dim=8).model,
+                cov=lambda s: s,
+                name="y"
+            )
+        ),
+        {
+            "d": 11, # Out of bounds (all should return -Inf)
+            "s": 2,
+            "x": np.zeros(8),
+            "y": cuqi.testproblem.Deconvolution1D(dim=8).data
+        }
+    )
+    ]
+)
+def test_logd_consistency_when_conditioning(joint, variables):
+    """ Test consistency of logd value when conditioning the joint distribution.
+     
+    This ensures we always return the correct value for logd even when reducing to single density.
+    
+    """
+
+    # True value of logd by fully evaluating the joint distribution
+    true_value = joint.logd(**variables)
+
+    # Loop over all variables and evaluate the logd value
+    # where all previously seen variables are conditioned
+    # and not seen variables are given to logd.
+    cond_vars = {}
+    for key, value in variables.items():
+        # Remaining variables are those that are not used for conditioning
+        remaining_vars = {k: v for k, v in variables.items() if k not in cond_vars}
+        
+        # Condition the joint distribution
+        cond_joint = joint(**cond_vars)
+
+        # Evaluate the logd value of conditioned joint distribution
+        # This may be a single density or a joint distribution since
+        # joint can reduce to single density (such as Posterior)
+        logd_value = cond_joint.logd(**remaining_vars)
+
+        # Potential error message if this assert fails:
+        msg = f"Evaluated: \n {joint} \n with variables {variables}.\nFailed at {key}={value} for \n {cond_joint} \n with variables {remaining_vars}."
+        
+        # Assert the logd value matches
+        assert logd_value == pytest.approx(true_value, rel=1e-6), msg
+
+        # Add current variable to the variables that need to be conditioned
+        cond_vars[key] = value