CUQIpy 1.2.0.post0.dev333__tar.gz → 1.2.0.post0.dev352__tar.gz

{cuqipy-1.2.0.post0.dev333 → cuqipy-1.2.0.post0.dev352}/CUQIpy.egg-info/PKG-INFO

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

@@ -45,6 +45,8 @@ cuqi/distribution/_smoothed_laplace.py
 cuqi/distribution/_truncated_normal.py
 cuqi/distribution/_uniform.py
 cuqi/experimental/__init__.py
+cuqi/experimental/algebra/__init__.py
+cuqi/experimental/algebra/_ast.py
 cuqi/experimental/mcmc/__init__.py
 cuqi/experimental/mcmc/_conjugate.py
 cuqi/experimental/mcmc/_conjugate_approx.py

{cuqipy-1.2.0.post0.dev333 → cuqipy-1.2.0.post0.dev352}/PKG-INFO

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

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-11-20T12:41:18+0100",
+ "date": "2024-11-28T12:43:32+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "e495208f39ca278465cb4819799b22c942a1b863",
- "version": "1.2.0.post0.dev333"
+ "full-revisionid": "6f800787a63fef7d6ba2c0b88b96dbc209afdbad",
+ "version": "1.2.0.post0.dev352"
 }
 '''  # END VERSION_JSON
 

{cuqipy-1.2.0.post0.dev333 → cuqipy-1.2.0.post0.dev352}/cuqi/experimental/__init__.py

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

cuqipy-1.2.0.post0.dev352/cuqi/experimental/algebra/__init__.py

@@ -0,0 +1 @@
+from ._ast import VariableNode

cuqipy-1.2.0.post0.dev352/cuqi/experimental/algebra/_ast.py

@@ -0,0 +1,325 @@
+"""
+CUQIpy specific implementation of an abstract syntax tree (AST) for algebra on variables.
+
+The AST is used to record the operations applied to variables allowing a delayed evaluation
+of said operations when needed by traversing the tree with the __call__ method.
+
+For example, the following code
+
+    x = VariableNode('x')
+    y = VariableNode('y')
+    z = 2*x + 3*y
+
+will create the following AST:
+
+z = AddNode(
+        MultiplyNode(
+            ValueNode(2),
+            VariableNode('x')
+        ),
+        MultiplyNode(
+            ValueNode(3),
+            VariableNode('y')
+        )
+    )
+
+which can be evaluated by calling the __call__ method:
+
+    z(x=1, y=2) # returns 8
+
+"""
+
+from abc import ABC, abstractmethod
+
+convert_to_node = lambda x: x if isinstance(x, Node) else ValueNode(x)
+""" Converts any non-Node object to a ValueNode object. """
+
+# ====== Base classes for the nodes ======
+
+
+class Node(ABC):
+    """Base class for all nodes in the abstract syntax tree.
+
+    Responsible for building the AST by creating nodes that represent the operations applied to variables.
+
+    Each subclass must implement the __call__ method that will evaluate the node given the input parameters.
+
+    """
+
+    @abstractmethod
+    def __call__(self, **kwargs):
+        """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 __repr__(self):
+        """String representation of the node. Used for printing the AST."""
+        pass
+
+    def __add__(self, other):
+        return AddNode(self, convert_to_node(other))
+
+    def __radd__(self, other):
+        return AddNode(convert_to_node(other), self)
+
+    def __sub__(self, other):
+        return SubtractNode(self, convert_to_node(other))
+
+    def __rsub__(self, other):
+        return SubtractNode(convert_to_node(other), self)
+
+    def __mul__(self, other):
+        return MultiplyNode(self, convert_to_node(other))
+
+    def __rmul__(self, other):
+        return MultiplyNode(convert_to_node(other), self)
+
+    def __truediv__(self, other):
+        return DivideNode(self, convert_to_node(other))
+
+    def __rtruediv__(self, other):
+        return DivideNode(convert_to_node(other), self)
+
+    def __pow__(self, other):
+        return PowerNode(self, convert_to_node(other))
+
+    def __rpow__(self, other):
+        return PowerNode(convert_to_node(other), self)
+
+    def __neg__(self):
+        return NegateNode(self)
+
+    def __abs__(self):
+        return AbsNode(self)
+
+    def __getitem__(self, i):
+        return GetItemNode(self, convert_to_node(i))
+
+    def __matmul__(self, other):
+        return MatMulNode(self, convert_to_node(other))
+
+    def __rmatmul__(self, other):
+        return MatMulNode(convert_to_node(other), self)
+
+
+class UnaryNode(Node, ABC):
+    """Base class for all unary nodes in the abstract syntax tree.
+
+    Parameters
+    ----------
+    child : Node
+        The direct child node on which the unary operation is performed.
+
+    """
+
+    def __init__(self, child: Node):
+        self.child = child
+
+
+class BinaryNode(Node, ABC):
+    """Base class for all binary nodes in the abstract syntax tree.
+
+    The op_symbol attribute is used for printing the operation in the __repr__ method.
+
+    Parameters
+    ----------
+    left : Node
+        Left child node to the binary operation.
+
+    right : Node
+        Right child node to the binary operation.
+
+    """
+
+    @property
+    @abstractmethod
+    def op_symbol(self):
+        """Symbol used to represent the operation in the __repr__ method."""
+        pass
+
+    def __init__(self, left: Node, right: Node):
+        self.left = left
+        self.right = right
+
+    def __repr__(self):
+        return f"{self.left} {self.op_symbol} {self.right}"
+
+
+class BinaryNodeWithParenthesis(BinaryNode, ABC):
+    """Base class for all binary nodes in the abstract syntax tree that should be printed with parenthesis."""
+
+    def __repr__(self):
+        left = f"({self.left})" if isinstance(self.left, BinaryNode) else str(self.left)
+        right = (
+            f"({self.right})" if isinstance(self.right, BinaryNode) else str(self.right)
+        )
+        return f"{left} {self.op_symbol} {right}"
+
+class BinaryNodeWithParenthesisNoSpace(BinaryNode, ABC):
+    """Base class for all binary nodes in the abstract syntax tree that should be printed with parenthesis but no space."""
+
+    def __repr__(self):
+        left = f"({self.left})" if isinstance(self.left, BinaryNode) else str(self.left)
+        right = (
+            f"({self.right})" if isinstance(self.right, BinaryNode) else str(self.right)
+        )
+        return f"{left}{self.op_symbol}{right}"
+
+
+# ====== Specific implementations of the "leaf" nodes ======
+
+
+class VariableNode(Node):
+    """Node that represents a generic variable, e.g. "x" or "y".
+
+    Parameters
+    ----------
+    name : str
+        Name of the variable. Used for printing and to retrieve the given input value
+        of the variable in the kwargs dictionary when evaluating the tree.
+
+    """
+
+    def __init__(self, name):
+        self.name = name
+
+    def __call__(self, **kwargs):
+        """Retrieves the value of the variable from the passed kwargs. If no value is found, it raises a KeyError."""
+        if not self.name in kwargs:
+            raise KeyError(
+                f"Variable '{self.name}' not found in the given input parameters. Unable to evaluate the expression."
+            )
+        return kwargs[self.name]
+
+    def __repr__(self):
+        return self.name
+
+
+class ValueNode(Node):
+    """Node that represents a constant value. The value can be any python object that is not a Node.
+
+    Parameters
+    ----------
+    value : object
+        The python object that represents the value of the node.
+
+    """
+
+    def __init__(self, value):
+        self.value = value
+
+    def __call__(self, **kwargs):
+        """Returns the value of the node."""
+        return self.value
+
+    def __repr__(self):
+        return str(self.value)
+
+
+# ====== Specific implementations of the "internal" nodes ======
+
+
+class AddNode(BinaryNode):
+    """Node that represents the addition operation."""
+
+    @property
+    def op_symbol(self):
+        return "+"
+
+    def __call__(self, **kwargs):
+        return self.left(**kwargs) + self.right(**kwargs)
+
+
+class SubtractNode(BinaryNode):
+    """Node that represents the subtraction operation."""
+
+    @property
+    def op_symbol(self):
+        return "-"
+
+    def __call__(self, **kwargs):
+        return self.left(**kwargs) - self.right(**kwargs)
+
+
+class MultiplyNode(BinaryNodeWithParenthesis):
+    """Node that represents the multiplication operation."""
+
+    @property
+    def op_symbol(self):
+        return "*"
+
+    def __call__(self, **kwargs):
+        return self.left(**kwargs) * self.right(**kwargs)
+
+
+class DivideNode(BinaryNodeWithParenthesis):
+    """Node that represents the division operation."""
+
+    @property
+    def op_symbol(self):
+        return "/"
+
+    def __call__(self, **kwargs):
+        return self.left(**kwargs) / self.right(**kwargs)
+
+
+class PowerNode(BinaryNodeWithParenthesisNoSpace):
+    """Node that represents the power operation."""
+
+    @property
+    def op_symbol(self):
+        return "^"
+
+    def __call__(self, **kwargs):
+        return self.left(**kwargs) ** self.right(**kwargs)
+
+
+class GetItemNode(BinaryNode):
+    """Node that represents the get item operation. Here the left node is the object and the right node is the index."""
+
+    def __call__(self, **kwargs):
+        return self.left(**kwargs)[self.right(**kwargs)]
+
+    def __repr__(self):
+        left = f"({self.left})" if isinstance(self.left, BinaryNode) else str(self.left)
+        return f"{left}[{self.right}]"
+    
+    @property
+    def op_symbol(self):
+        pass
+
+
+class NegateNode(UnaryNode):
+    """Node that represents the arithmetic negation operation."""
+
+    def __call__(self, **kwargs):
+        return -self.child(**kwargs)
+
+    def __repr__(self):
+        child = (
+            f"({self.child})"
+            if isinstance(self.child, (BinaryNode, UnaryNode))
+            else str(self.child)
+        )
+        return f"-{child}"
+
+
+class AbsNode(UnaryNode):
+    """Node that represents the absolute value operation."""
+
+    def __call__(self, **kwargs):
+        return abs(self.child(**kwargs))
+
+    def __repr__(self):
+        return f"abs({self.child})"
+
+
+class MatMulNode(BinaryNodeWithParenthesis):
+    """Node that represents the matrix multiplication operation."""
+
+    @property
+    def op_symbol(self):
+        return "@"
+
+    def __call__(self, **kwargs):
+        return self.left(**kwargs) @ self.right(**kwargs)

{cuqipy-1.2.0.post0.dev333 → cuqipy-1.2.0.post0.dev352}/cuqi/implicitprior/_restorator.py

@@ -15,8 +15,10 @@ class RestorationPrior(Distribution):
     Parameters
     ---------- 
     restorator : callable f(x, restoration_strength)
-        Function f that accepts input x to be restored and returns the
-        restored version of x and information about the restoration operation.
+        Function f that accepts input x to be restored and returns a two-element 
+        tuple of the restored version of x and extra information about the 
+        restoration operation. The second element can be of any type, including
+        `None` in case there is no information.
             
     restorator_kwargs : dictionary
         Dictionary containing information about the restorator.
@@ -41,8 +43,9 @@ class RestorationPrior(Distribution):
         super().__init__(**kwargs)
 
     def restore(self, x, restoration_strength):
-        """This function allows us to restore the input x and returns the
-        restored version of x.
+        """This function allows us to restore the input x with the user-supplied
+        restorator. Extra information about the restoration operation is stored
+        in the `RestorationPrior` info attribute.
         
         Parameters
         ---------- 
@@ -54,9 +57,18 @@ class RestorationPrior(Distribution):
             restorator is a denoiser, this parameter might correspond to the
             noise level.
         """
-        solution, info = self.restorator(x, restoration_strength=restoration_strength,
+        restorator_return = self.restorator(x, restoration_strength=restoration_strength,
                                          **self.restorator_kwargs)
-        self.info = info
+
+        if type(restorator_return) == tuple and len(restorator_return) == 2:
+            solution, self.info = restorator_return
+        else:
+            raise ValueError("Unsupported return type from the user-supplied restorator function. "+ 
+                             "Please ensure that the restorator function returns a two-element tuple with the "+
+                             "restored solution as the first element and additional information about the "+
+                             "restoration as the second element. The second element can be of any type, "+
+                             "including `None` in case there is no particular information.")
+
         return solution
     
     def logpdf(self, x):

{cuqipy-1.2.0.post0.dev333 → cuqipy-1.2.0.post0.dev352}/tests/test_implicit_priors.py

@@ -28,7 +28,7 @@ def test_RegularizedGaussian_guarding_statements():
 
     with pytest.raises(ValueError, match="Projector should take 1 argument"):
         cuqi.implicitprior.RegularizedGaussian(np.zeros(5), 1, projector=lambda s,z: s)
-        
+
 def test_creating_restorator():
     """ Test creating the object from restorator class."""
 
@@ -38,6 +38,32 @@ def test_creating_restorator():
     assert np.allclose(restorator.restore(np.ones(4), 0.1), np.ones(4))
     assert restorator.info == True
 
+def test_handling_invalid_restorator():
+    """ Test handling invalid restorator."""
+    # Invalid return type 1: None
+    def func_1(x, restoration_strength=0.1):
+        return
+    restore_prior_1 = cuqi.implicitprior.RestorationPrior(func_1)
+    with pytest.raises(ValueError, match=r"Unsupported return type .*"):
+        restore_prior_1.restore(np.ones(4), 0.1)
+    # Invalid return type 2: one parameter
+    def func_2(x, restoration_strength=0.1):
+        return x
+    restore_prior_2 = cuqi.implicitprior.RestorationPrior(func_2)
+    with pytest.raises(ValueError, match=r"Unsupported return type .*"):
+        restore_prior_2.restore(np.ones(4), 0.1)
+    # Invalid return type 3: tuple with 3 elements
+    def func_3(x, restoration_strength=0.1):
+        return x, None, False
+    restore_prior_3 = cuqi.implicitprior.RestorationPrior(func_3)
+    with pytest.raises(ValueError, match=r"Unsupported return type .*"):
+        restore_prior_3.restore(np.ones(4), 0.1)
+    # Invalid return type 4: list with 2 elements
+    def func_4(x, restoration_strength=0.1):
+        return [x, None]
+    restore_prior_4 = cuqi.implicitprior.RestorationPrior(func_4)
+    with pytest.raises(ValueError, match=r"Unsupported return type .*"):
+        restore_prior_4.restore(np.ones(4), 0.1)
 
 def test_creating_restorator_with_potential():
     """ Test creating the object from restorator class with a potential."""