CUQIpy 1.2.0.post0.dev380__tar.gz → 1.2.0.post0.dev409__tar.gz

{cuqipy-1.2.0.post0.dev380 → cuqipy-1.2.0.post0.dev409}/CUQIpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: CUQIpy
-Version: 1.2.0.post0.dev380
+Version: 1.2.0.post0.dev409
 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.2.0.post0.dev380 → cuqipy-1.2.0.post0.dev409}/CUQIpy.egg-info/SOURCES.txt

@@ -49,6 +49,8 @@ cuqi/experimental/algebra/__init__.py
 cuqi/experimental/algebra/_ast.py
 cuqi/experimental/algebra/_orderedset.py
 cuqi/experimental/algebra/_randomvariable.py
+cuqi/experimental/geometry/__init__.py
+cuqi/experimental/geometry/_productgeometry.py
 cuqi/experimental/mcmc/__init__.py
 cuqi/experimental/mcmc/_conjugate.py
 cuqi/experimental/mcmc/_conjugate_approx.py

{cuqipy-1.2.0.post0.dev380 → cuqipy-1.2.0.post0.dev409}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: CUQIpy
-Version: 1.2.0.post0.dev380
+Version: 1.2.0.post0.dev409
 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.2.0.post0.dev380 → cuqipy-1.2.0.post0.dev409}/cuqi/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-12-20T09:13:49+0100",
+ "date": "2025-01-14T23:39:18+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "7405af566d2a50ba59fc861865d41c08f8dcf160",
- "version": "1.2.0.post0.dev380"
+ "full-revisionid": "4d0949ea5c777b95d3c216f22c17e267e5cf15ff",
+ "version": "1.2.0.post0.dev409"
 }
 '''  # END VERSION_JSON
 

{cuqipy-1.2.0.post0.dev380 → cuqipy-1.2.0.post0.dev409}/cuqi/experimental/__init__.py

@@ -1,3 +1,4 @@
 """ Experimental module for testing new features and ideas. """
 from . import mcmc
 from . import algebra
+from . import geometry

{cuqipy-1.2.0.post0.dev380 → cuqipy-1.2.0.post0.dev409}/cuqi/experimental/algebra/_ast.py

@@ -51,6 +51,11 @@ class Node(ABC):
         """Evaluate node at a given parameter value. This will traverse the sub-tree originated at this node and evaluate it given the recorded operations."""
         pass
 
+    @abstractmethod
+    def condition(self, **kwargs):
+        """ Conditions the tree by replacing any VariableNode with a ValueNode if the variable is in the kwargs dictionary. """
+        pass
+
     @abstractmethod
     def __repr__(self):
         """String representation of the node. Used for printing the AST."""
@@ -129,6 +134,9 @@ class UnaryNode(Node, ABC):
     def __init__(self, child: Node):
         self.child = child
 
+    def condition(self, **kwargs):
+        return self.__class__(self.child.condition(**kwargs))
+
 
 class BinaryNode(Node, ABC):
     """Base class for all binary nodes in the abstract syntax tree.
@@ -155,6 +163,9 @@ class BinaryNode(Node, ABC):
         self.left = left
         self.right = right
 
+    def condition(self, **kwargs):
+        return self.__class__(self.left.condition(**kwargs), self.right.condition(**kwargs))
+
     def __repr__(self):
         return f"{self.left} {self.op_symbol} {self.right}"
 
@@ -205,6 +216,11 @@ class VariableNode(Node):
             )
         return kwargs[self.name]
 
+    def condition(self, **kwargs):
+        if self.name in kwargs:
+            return ValueNode(kwargs[self.name])
+        return self
+
     def __repr__(self):
         return self.name
 
@@ -226,6 +242,9 @@ class ValueNode(Node):
         """Returns the value of the node."""
         return self.value
 
+    def condition(self, **kwargs):
+        return self
+
     def __repr__(self):
         return str(self.value)
 

{cuqipy-1.2.0.post0.dev380 → cuqipy-1.2.0.post0.dev409}/cuqi/experimental/algebra/_orderedset.py

@@ -19,6 +19,13 @@ class _OrderedSet:
         """
         self.dict[item] = None
 
+    def remove(self, item):
+        """Remove an item from the set. 
+
+        If the item is not in the set, it raises a KeyError.
+        """
+        del self.dict[item]
+
     def __contains__(self, item):
         """Check if an item is in the set. 
 
@@ -47,6 +54,18 @@ class _OrderedSet:
         for item in other:
             self.add(item)
 
+    def replace(self, old_item, new_item):
+        """Replace old_item with new_item at the same position, preserving order."""
+        if old_item not in self.dict:
+            raise KeyError(f"{old_item} not in set")
+        
+        items = list(self.dict.keys())  # Preserve order
+        index = items.index(old_item)  # Find position
+        items[index] = new_item  # Replace at the same position
+
+        # Reconstruct the ordered set with the new item in place
+        self.dict = dict.fromkeys(items)
+
     def __or__(self, other):
         """Return a new set that is the union of this set and another set.
 
@@ -57,3 +76,7 @@ class _OrderedSet:
         new_set = _OrderedSet(self.dict.keys())
         new_set.extend(other)
         return new_set
+
+    def __repr__(self):
+        """Return a string representation of the set."""
+        return "_OrderedSet({})".format(list(self.dict.keys()))

{cuqipy-1.2.0.post0.dev380 → cuqipy-1.2.0.post0.dev409}/cuqi/experimental/algebra/_randomvariable.py

@@ -5,8 +5,7 @@ from ._orderedset import _OrderedSet
 import operator
 import cuqi
 from cuqi.distribution import Distribution
-from copy import copy
-
+from copy import copy, deepcopy
 
 class RandomVariable:
     """ Random variable defined by a distribution with the option to apply algebraic operations on it.
@@ -210,7 +209,7 @@ class RandomVariable:
     def parameter_names(self) -> str:
         """ Name of the parameter that the random variable can be evaluated at. """
         self._inject_name_into_distribution()
-        return [distribution.name for distribution in self.distributions] # Consider renaming .name to .par_name for distributions
+        return [distribution._name for distribution in self.distributions] # Consider renaming .name to .par_name for distributions
 
     @property
     def dim(self):
@@ -239,7 +238,57 @@ class RandomVariable:
     def is_transformed(self):
         """ Returns True if the random variable is transformed. """
         return not isinstance(self.tree, VariableNode)
-    
+
+    @property
+    def is_cond(self):
+        """ Returns True if the random variable is a conditional random variable. """
+        return any(dist.is_cond for dist in self.distributions)
+
+    def condition(self, *args, **kwargs):
+        """Condition the random variable on a given value. Only one of either positional or keyword arguments can be passed.
+        
+        Parameters
+        ----------
+        *args : Any
+            Positional arguments to condition the random variable on. The order of the arguments must match the order of the parameter names.
+
+        **kwargs : Any
+            Keyword arguments to condition the random variable on. The keys must match the parameter names.
+        
+        """
+
+        # Before conditioning, capture repr to ensure all variable names are injected
+        self.__repr__()
+
+        if args and kwargs:
+            raise ValueError("Cannot pass both positional and keyword arguments to RandomVariable")
+        
+        if args:
+            kwargs = self._parse_args_add_to_kwargs(args, kwargs)
+
+        # Create a deep copy of the random variable to ensure the original tree is not modified
+        new_variable = self._make_copy(deep=True)
+
+        for kwargs_name in list(kwargs.keys()):
+            value = kwargs.pop(kwargs_name)
+
+            # Condition the tree turning the variable into a constant
+            if kwargs_name in self.parameter_names:
+                new_variable._tree = new_variable.tree.condition(**{kwargs_name: value})
+            
+            # Condition the random variable on both the distribution parameter name and distribution conditioning variables
+            for dist in self.distributions:
+                if kwargs_name == dist.name:
+                    new_variable._remove_distribution(dist.name)
+                elif kwargs_name in dist.get_conditioning_variables():
+                    new_variable._replace_distribution(dist.name, dist(**{kwargs_name: value}))
+
+        # Check if any kwargs are left unprocessed
+        if kwargs:
+            raise ValueError(f"Conditioning variables {list(kwargs.keys())} not found in the random variable {self}")
+
+        return new_variable
+
     @property
     def _non_default_args(self) -> List[str]:
         """List of non-default arguments to distribution. This is used to return the correct
@@ -247,13 +296,31 @@ class RandomVariable:
         """
         return self.parameter_names
 
+    def _replace_distribution(self, name, new_distribution):
+        """ Replace distribution with a given name with a new distribution in the same position of the ordered set. """
+        for dist in self.distributions:
+            if dist._name == name:
+                self._distributions.replace(dist, new_distribution)
+                break
+
+    def _remove_distribution(self, name):
+        """ Remove distribution with a given name from the set of distributions. """
+        for dist in self.distributions:
+            if dist._name == name:
+                self._distributions.remove(dist)
+                break
+
     def _inject_name_into_distribution(self, name=None):
         if len(self._distributions) == 1:
             dist = next(iter(self._distributions))
+
+            if dist._is_copy:
+                dist = dist._original_density
+
             if dist._name is None:
                 if name is None:
                     name = self.name
-                dist._name = name
+                dist.name = name # Inject using setter
     
     def _parse_args_add_to_kwargs(self, args, kwargs) -> dict:
         """ Parse args and add to kwargs if any. Arguments follow self.parameter_names order. """
@@ -293,8 +360,12 @@ class RandomVariable:
         """ Returns True if this is a copy of another random variable, e.g. by conditioning. """
         return hasattr(self, '_original_variable') and self._original_variable is not None
 
-    def _make_copy(self):
-        """ Returns a shallow copy of the density keeping a pointer to the original. """
+    def _make_copy(self, deep=False) -> 'RandomVariable':
+        """ Returns a copy of the density keeping a pointer to the original. """
+        if deep:
+            new_variable = deepcopy(self)
+            new_variable._original_variable = self
+            return new_variable
         new_variable = copy(self)
         new_variable._distributions = copy(self.distributions)
         new_variable._tree = copy(self._tree)

cuqipy-1.2.0.post0.dev409/cuqi/experimental/geometry/__init__.py

@@ -0,0 +1 @@
+from ._productgeometry import _ProductGeometry

cuqipy-1.2.0.post0.dev409/cuqi/experimental/geometry/_productgeometry.py

@@ -0,0 +1,181 @@
+from cuqi.geometry import Geometry
+import numpy as np
+
+class _ProductGeometry(Geometry):
+    """ A class for representing a product geometry. A product geometry
+    represents the product space of multiple geometries of type :class:`Geometry`.
+    See the example below for a product geometry of two geometries.
+
+    Parameters
+    ----------
+    \*geometries : cuqi.geometry.Geometry
+        The geometries to be combined into a product geometry. Each geometry
+        is passed as a comma-separated argument.
+
+    Example
+    -------
+    .. code-block:: python
+        import numpy as np
+        from cuqi.geometry import Continuous1D, Discrete
+        from cuqi.experimental.geometry import _ProductGeometry
+        geometry1 = Continuous1D(np.linspace(0, 1, 100))
+        geometry2 = Discrete(["sound_speed"])
+        product_geometry = _ProductGeometry(geometry1, geometry2)
+    """
+
+    def __init__(self, *geometries):
+        self.geometries = geometries
+
+    @property
+    def geometries(self):
+        """List of geometries that are combined to form the product geometry."""
+        return self._geometries
+    
+    @geometries.setter
+    def geometries(self, geometries):
+        # Check if all geometries are of type Geometry.
+        for g in geometries:
+            if not isinstance(g, Geometry):
+                raise TypeError(
+                    "All geometries must be of type Geometry. "
+                    "Received: {}".format(type(g))
+                )
+        self._geometries = geometries
+
+    @property
+    def fun_shape(self):
+        """Shape of the function representation. Returns a tuple, where
+        each element of the tuple is the shape of the function 
+        representation of each geometry."""
+        return tuple([g.fun_shape for g in self.geometries])
+    
+    @property
+    def fun_dim(self):
+        """Dimension of the function representation which is the sum of
+        the function representation dimensions of each geometry."""
+        return sum([g.fun_dim for g in self.geometries])
+
+    @property
+    def par_shape(self):
+        """Shape of the parameter representation. Returns a tuple, where
+        each element of the tuple is the shape of the parameter
+        representation of each geometry."""
+        return tuple([g.par_shape for g in self.geometries])
+    
+    @property
+    def par_dim(self):
+        """Dimension of the parameter representation which is the sum of
+        the parameter representation dimensions of each geometry."""
+        return sum(self.par_dim_list)
+    
+    @property
+    def par_dim_list(self):
+        """List of the parameter representation dimensions of each
+        geometry. This property is useful for indexing a stacked parameter
+        vector."""
+        return [g.par_dim for g in self.geometries]
+    
+    @property
+    def stacked_par_split_indices(self):
+        """Indices at which the stacked parameter vector should be split
+        to obtain the parameter vectors for each geometry. For example, if
+        the stacked parameter vector is [1, 2, 3, 4, 5, 6] and the parameter
+        vectors for each geometry are [1, 2], [3, 4], and [5, 6], then the
+        split indices are [2, 4]"""
+        return np.cumsum(self.par_dim_list[:-1])
+
+    @property
+    def number_of_geometries(self):
+        """Number of geometries in the product geometry."""
+        return len(self.geometries)
+    
+    def _split_par(self, par):
+        """Splits a stacked parameter vector into parameter vectors for each
+        geometry."""
+        return tuple(np.split(par, self.stacked_par_split_indices))
+    
+    def _plot(self, values, **kwargs):
+        """Plotting function for the product geometry."""
+        raise NotImplementedError(
+            f"Plotting not implemented for {self.__class__.__name__}.")
+
+    def par2fun(self, *pars):
+        """Converts parameter vector(s) into function values for each 
+        geometry. The parameter vector can be stacked (all parameters are
+        in one vector) or unstacked (one parameter vector corresponds to
+        each geometry). In all cases, the order of the parameter vectors
+        should follow the order of the geometries in the product, i.e., the
+        first parameter vector corresponds to the first geometry and so on."""
+
+        # If one argument is passed, then it is assumed that the parameter
+        # vector is stacked and split it.
+        # No effect if the parameter vector is already split and corresponds
+        # to one geometry.
+        if len(pars) == 1:
+            pars = self._split_par(pars[0])
+
+        # Convert parameter vectors to function values for each geometry.
+        funvals = []
+        for i, g in enumerate(self.geometries):
+            funval_i = g.par2fun(pars[i])
+            funvals.append(funval_i)
+        return tuple(funvals)
+
+    def fun2par(self, *funvals, stacked=False):
+        """Converts (multiple) function values into the corresponding
+        parameter vectors. If the flag stacked is set to True, then the
+        parameter vectors are stacked into one vector. Otherwise, the
+        parameter vectors are returned as a tuple. The order of function
+        values should follow the order of the geometries in the product,
+        i.e., the first function value corresponds to the first geometry
+        and so on."""
+
+        pars = []
+        for i, g in enumerate(self.geometries):
+            par_i = g.fun2par(funvals[i])
+            pars.append(par_i)
+
+        # stack parameters:
+        if stacked:
+            # if single sample
+            if len(pars[0].shape) == 1:
+                stacked_val = np.hstack(pars)
+            elif len(pars[0].shape) == 2:
+                stacked_val = np.vstack(pars)
+            else:
+                raise ValueError(
+                    "Cannot stack parameter vectors with more than 2 dimensions."
+                    )
+
+        return  stacked_val if stacked else tuple(pars)
+
+    def vec2fun(self, *funvecs):
+        """Maps function vector representation, if available, to function 
+        values. The order of the function vectors should follow the order of
+        the geometries in the product, i.e., the first function vector
+        corresponds to the first geometry and so on."""
+        funvals = []  
+        for i, g in enumerate(self.geometries):
+            funvals.append(g.vec2fun(funvecs[i]))
+
+        return tuple(funvals)
+    
+    def fun2vec(self, *funvals):
+        """Maps function values to a vector representation of the function
+        values, if available. The order of the function values should follow
+        the order of the geometries in the product, i.e., the first function
+        value corresponds to the first geometry and so on."""
+        funvecs = []
+        for i, g in enumerate(self.geometries):
+            funvecs.append(g.fun2vec(funvals[i]))
+        
+        return tuple(funvecs)
+        
+    
+    def __repr__(self) -> str:
+        """Representation of the product geometry."""
+        string = "{}(".format(self.__class__.__name__) + "\n"
+        for g in self.geometries:
+            string += "\t{}\n".format(g.__repr__())
+        string += ")"
+        return string

{cuqipy-1.2.0.post0.dev380 → cuqipy-1.2.0.post0.dev409}/cuqi/likelihood/_likelihood.py

@@ -43,6 +43,14 @@ class Likelihood(Density):
     def name(self, value):
         self.distribution.name = value
 
+    @property
+    def _name(self):
+        return self.distribution._name
+
+    @_name.setter
+    def _name(self, value):
+        self.distribution._name = value
+
     @property
     def FD_enabled(self):
         """ Return FD_enabled of the likelihood from the underlying distribution """