CUQIpy 1.2.0.post0.dev342__tar.gz → 1.2.0.post0.dev371__tar.gz

{cuqipy-1.2.0.post0.dev342 → cuqipy-1.2.0.post0.dev371}/CUQIpy.egg-info/PKG-INFO

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

@@ -47,6 +47,8 @@ cuqi/distribution/_uniform.py
 cuqi/experimental/__init__.py
 cuqi/experimental/algebra/__init__.py
 cuqi/experimental/algebra/_ast.py
+cuqi/experimental/algebra/_orderedset.py
+cuqi/experimental/algebra/_randomvariable.py
 cuqi/experimental/mcmc/__init__.py
 cuqi/experimental/mcmc/_conjugate.py
 cuqi/experimental/mcmc/_conjugate_approx.py

{cuqipy-1.2.0.post0.dev342 → cuqipy-1.2.0.post0.dev371}/PKG-INFO

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

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-11-25T09:18:51+0100",
+ "date": "2024-12-10T23:09:59+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "63395d14f6c3f964633b20200ada13b8a213da20",
- "version": "1.2.0.post0.dev342"
+ "full-revisionid": "6325eb7e648f3d6f801195a1d06a2d67928479f5",
+ "version": "1.2.0.post0.dev371"
 }
 '''  # END VERSION_JSON
 

{cuqipy-1.2.0.post0.dev342 → cuqipy-1.2.0.post0.dev371}/cuqi/distribution/_joint_distribution.py

@@ -5,6 +5,7 @@ from cuqi.density import Density, EvaluatedDensity
 from cuqi.distribution import Distribution, Posterior
 from cuqi.likelihood import Likelihood
 from cuqi.geometry import Geometry, _DefaultGeometry1D
+import cuqi
 import numpy as np # for splitting array. Can avoid.
 
 class JointDistribution:
@@ -13,9 +14,11 @@ class JointDistribution:
 
     Parameters
     ----------
-    densities : Density
+    densities : RandomVariable or Density
         The densities to include in the joint distribution.
-        Each density is passed as comma-separated arguments.
+        Each density is passed as comma-separated arguments,
+        and can be either a :class:'Density' such as :class:'Distribution'
+        or :class:`RandomVariable`.
 
     Notes
     -----
@@ -59,7 +62,16 @@ class JointDistribution:
         posterior = joint(y=y_obs)
         
     """
-    def __init__(self, *densities: Density):
+    def __init__(self, *densities: [Density, cuqi.experimental.algebra.RandomVariable]):
+        """ Create a joint distribution from the given densities. """
+
+        # Check if all RandomVariables are simple (not-transformed)
+        for density in densities:
+            if isinstance(density, cuqi.experimental.algebra.RandomVariable) and density.is_transformed:
+                raise ValueError(f"To be used in {self.__class__.__name__}, all RandomVariables must be untransformed.")
+
+        # Convert potential random variables to their underlying distribution
+        densities = [density.distribution if isinstance(density, cuqi.experimental.algebra.RandomVariable) else density for density in densities]
 
         # Ensure all densities have unique names
         names = [density.name for density in densities]

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

@@ -0,0 +1,2 @@
+from ._ast import VariableNode, Node
+from ._randomvariable import RandomVariable

{cuqipy-1.2.0.post0.dev342 → cuqipy-1.2.0.post0.dev371}/cuqi/experimental/algebra/_ast.py

@@ -56,6 +56,20 @@ class Node(ABC):
         """String representation of the node. Used for printing the AST."""
         pass
 
+    def get_variables(self, variables=None):
+        """Returns a set with the names of all variables in the sub-tree originated at this node."""
+        if variables is None:
+            variables = set()
+        if isinstance(self, VariableNode):
+            variables.add(self.name)
+        if hasattr(self, "child"):
+            self.child.get_variables(variables)
+        if hasattr(self, "left"):
+            self.left.get_variables(variables)
+        if hasattr(self, "right"):
+            self.right.get_variables(variables)
+        return variables
+
     def __add__(self, other):
         return AddNode(self, convert_to_node(other))
 

cuqipy-1.2.0.post0.dev371/cuqi/experimental/algebra/_orderedset.py

@@ -0,0 +1,59 @@
+class _OrderedSet:
+    """A set (i.e. unique elements) that keeps its elements in the order they were added.
+
+    This is a minimal implementation of an ordered set, using a dictionary for storage.
+    """
+    
+    def __init__(self, iterable=None):
+        """Initialize the OrderedSet. 
+
+        If an iterable is provided, add all its elements to the set.
+        """
+        self.dict = dict.fromkeys(iterable if iterable else [])
+
+    def add(self, item):
+        """Add an item to the set. 
+
+        If the item is already in the set, it does nothing.
+        Otherwise, the item is stored as a key in the dictionary, with None as its value.
+        """
+        self.dict[item] = None
+
+    def __contains__(self, item):
+        """Check if an item is in the set. 
+
+        This is equivalent to checking if the item is a key in the dictionary.
+        """
+        return item in self.dict
+
+    def __iter__(self):
+        """Return an iterator over the set. 
+
+        This iterates over the keys in the dictionary.
+        """
+        return iter(self.dict)
+
+    def __len__(self):
+        """Return the number of items in the set."""
+        return len(self.dict)
+
+    def extend(self, other):
+        """Extend the set with the items in another set.
+
+        Raises a TypeError if the other object is not an _OrderedSet.
+        """
+        if not isinstance(other, _OrderedSet):
+            raise TypeError("unsupported operand type(s) for extend: '_OrderedSet' and '{}'".format(type(other).__name__))
+        for item in other:
+            self.add(item)
+
+    def __or__(self, other):
+        """Return a new set that is the union of this set and another set.
+
+        Raises a TypeError if the other object is not an _OrderedSet.
+        """
+        if not isinstance(other, _OrderedSet):
+            raise TypeError("unsupported operand type(s) for |: '_OrderedSet' and '{}'".format(type(other).__name__))
+        new_set = _OrderedSet(self.dict.keys())
+        new_set.extend(other)
+        return new_set

cuqipy-1.2.0.post0.dev371/cuqi/experimental/algebra/_randomvariable.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+from typing import List, Any, Union
+from ._ast import VariableNode, Node
+from ._orderedset import _OrderedSet
+import operator
+import cuqi
+from cuqi.distribution import Distribution
+from copy import copy
+
+
+class RandomVariable:
+    """ Random variable defined by a distribution with the option to apply algebraic operations on it.
+
+    Random variables allow for the definition of Bayesian Problems in a natural way. In the context
+    of code, the random variable can be viewed as a lazily evaluated variable/array. It records
+    operations applied to it and acts as a function that, when called, evaluates the operations
+    and returns the result.
+
+    In CUQIpy, random variables can be in two forms: (1) a 'primal' random variable that is directly
+    defined by a distribution, e.g. x ~ N(0, 1), or (2) a 'transformed' random variable that is defined by
+    applying algebraic operations on one or more random variables, e.g. y = x + 1.
+
+    This distinction is purely for the purpose of the implementation in CUQIpy, as mathematically both
+    x ~ N(0, 1) and y = x + 1 ~ N(1, 1) are random variables. The distinction is useful for the
+    code implementation. In the future some operations like the above may allow primal random variables
+    that are transformed if the distribution can be analytically described.
+
+    Parameters
+    ----------
+    distributions : Distribution or list of Distributions
+        The distribution from which the random variable originates. If multiple distributions are
+        provided, the random variable is defined by the passed abstract syntax `tree` representing the
+        algebraic operations applied to one or more random variables.
+
+    tree : Node, optional
+        The tree, represented by the syntax tree nodes, that contain the algebraic operations applied to the random variable.
+        Specifically, the root of the tree should be provided.
+
+    name : str, optional
+        Name of the random variable. If not provided, the name is extracted from either the distribution provided
+        or from the variable name in the code. The name provided must match the parameter name of the distribution.
+
+    Example
+    -------
+
+    Basic usage:
+
+    .. code-block:: python
+
+        from cuqi.distribution import Gaussian
+
+        x = RandomVariable(Gaussian(0, 1))
+
+    Defining Bayesian problem using random variables:
+
+    .. code-block:: python
+
+        from cuqi.testproblem import Deconvolution1D
+        from cuqi.distribution import Gaussian, Gamma, GMRF
+        from cuqi.experimental.algebra import RandomVariable
+        from cuqi.problem import BayesianProblem
+
+        import numpy as np
+        A, y_obs, info = Deconvolution1D().get_components()
+
+        # Bayesian problem
+        d = RandomVariable(Gamma(1, 1e-4))
+        s = RandomVariable(Gamma(1, 1e-4))
+        x = RandomVariable(GMRF(np.zeros(A.domain_dim), d))
+        y = RandomVariable(Gaussian(A @ x, 1/s))
+
+        BP = BayesianProblem(y, x, s, d)
+        BP.set_data(y=y_obs)
+        BP.UQ()
+
+    Defining random variable from multiple distributions:
+
+    .. code-block:: python
+
+        from cuqi.distribution import Gaussian, Gamma
+        from cuqi.experimental.algebra import RandomVariable, VariableNode
+
+        # Define the variables
+        x = VariableNode('x')
+        y = VariableNode('y')
+
+        # Define the distributions (names must match variables)
+        dist_x = Gaussian(0, 1, name='x')
+        dist_y = Gamma(1, 1e-4, name='y')
+
+        # Define the tree (this is the algebra that defines the random variable along with the distributions)
+        tree = x + y
+
+        # Define random variable from 2 distributions with relation x+y
+        rv = RandomVariable([dist_x, dist_y], tree)
+
+    """
+
+
+    def __init__(self, distributions: Union['Distribution', List['Distribution']], tree: 'Node' = None, name: str = None):
+        """ Create random variable from distribution """
+
+        if isinstance(distributions, Distribution):
+            distributions = [distributions]
+        
+        if not  isinstance(distributions, list) and not isinstance(distributions, _OrderedSet):
+            raise ValueError("Expected a distribution or a list of distributions")
+
+        # Convert single distribution(s) to internal datastructure _OrderedSet.
+        # We use ordered set to ensure that the order of the distributions is preserved.
+        # which in turn ensures that the parameter names are always in the same order.
+        if not isinstance(distributions, _OrderedSet):
+            distributions = _OrderedSet(distributions)
+
+        # If tree is provided, check it is consistent with the given distributions
+        if tree:
+            tree_var_names = tree.get_variables()
+            dist_par_names = {dist._name for dist in distributions}
+
+            if len(tree_var_names) != len(distributions):
+                raise ValueError(
+                    f"There are {len(tree_var_names)} variables in the tree, but {len(distributions)} distributions are provided. "
+                    "This may be due to passing multiple distributions with the same parameter name. "
+                    f"The tree variables are {tree_var_names} and the distribution parameter names are {dist_par_names}."
+                )
+            
+            if not all(var_name in dist_par_names for var_name in tree_var_names):
+                raise ValueError(
+                    f"Variable names in the tree {tree_var_names} do not match the parameter names in the distributions {dist_par_names}. "
+                    "Ensure the name is inferred from the variable or explicitly provide it using name='var_name' in the distribution."
+                )
+
+        # Match random variable name with distribution parameter name (for single distribution)
+        if len(distributions) == 1 and tree is None:
+            dist = next(iter(distributions))
+            dist_par_name = dist._name
+            if dist_par_name is not None:
+                if name is not None and dist_par_name != name:
+                    raise ValueError(f"Parameter name '{dist_par_name}' of the distribution does not match the input name '{name}' for the random variable.")
+                name = dist_par_name
+    
+        self._distributions = distributions
+        """ The distribution from which the random variable originates. """
+        
+        self._tree = tree
+        """ The tree representation of the random variable. """
+
+        self._original_variable = None
+        """ Stores the original variable if this is a conditioned copy"""
+
+        self._name = name
+        """ Name of the random variable. """
+
+
+    def __call__(self, *args, **kwargs) -> Any:
+        """ Evaluate random variable at a given parameter value. For example, for random variable `X`, `X(1)` gives `1` and `(X+1)(1)` gives `2` """
+
+        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)
+
+        # Check if kwargs match parameter names using a all compare
+        if not all([name in kwargs for name in self.parameter_names]) or not all([name in self.parameter_names for name in kwargs]):
+            raise ValueError(f"Expected arguments {self.parameter_names}, got arguments {kwargs}")
+
+        return self.tree(**kwargs)
+    
+    @property
+    def tree(self):
+        if self._tree is None:
+            if len(self._distributions) > 1:
+                raise ValueError("Tree for multiple distributions can not be created automatically and need to be passed as an argument to the {} initializer.".format(type(self).__name__))
+            self._tree = VariableNode(self.name)
+        return self._tree
+
+    @property
+    def name(self):
+        """ Name of the random variable. If not provided, the name is extracted from the variable name in the code. """
+        if self._is_copy: # Extract the original variable name if this is a copy
+            return self._original_variable.name
+        if self._name is None: # If None extract the name from the stack
+            self._name = cuqi.utilities._get_python_variable_name(self)
+        if self._name is not None:
+            self._inject_name_into_distribution(self._name)
+        return self._name
+    
+    @name.setter
+    def name(self, name):
+        if self._is_copy:
+            raise ValueError("This random variable is derived from the conditional random variable named "+self._original_variable.name+". The name of the derived random variable cannot be set, but follows the name of the original random variable.")
+        self._name = name
+        
+    @property
+    def distribution(self) -> cuqi.distribution.Distribution:
+        """ Distribution from which the random variable originates. """
+        if len(self._distributions) > 1:
+            raise ValueError("Cannot get distribution from random variable defined by multiple distributions")
+        self._inject_name_into_distribution()
+        return next(iter(self._distributions))
+    
+    @property
+    def distributions(self) -> set:
+        """ Distributions from which the random variable originates. """
+        self._inject_name_into_distribution()
+        return self._distributions
+        
+    @property
+    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
+
+    @property
+    def dim(self):
+        if self.is_transformed:
+            raise NotImplementedError("Dimension not implemented for transformed random variables")
+        return self.distribution.dim
+
+    @property
+    def geometry(self):
+        if self.is_transformed:
+            raise NotImplementedError("Geometry not implemented for transformed random variables")
+        return self.distribution.geometry
+
+    @geometry.setter
+    def geometry(self, geometry):
+        if self.is_transformed:
+            raise NotImplementedError("Geometry not implemented for transformed random variables")
+        self.distribution.geometry = geometry
+
+    @property
+    def expression(self):
+        """ Expression (formula) of the random variable. """
+        return str(self.tree)
+
+    @property
+    def is_transformed(self):
+        """ Returns True if the random variable is transformed. """
+        return not isinstance(self.tree, VariableNode)
+    
+    @property
+    def _non_default_args(self) -> List[str]:
+        """List of non-default arguments to distribution. This is used to return the correct
+        arguments when evaluating the random variable.
+        """
+        return self.parameter_names
+
+    def _inject_name_into_distribution(self, name=None):
+        if len(self._distributions) == 1:
+            dist = next(iter(self._distributions))
+            if dist._name is None:
+                if name is None:
+                    name = self.name
+                dist._name = name
+    
+    def _parse_args_add_to_kwargs(self, args, kwargs) -> dict:
+        """ Parse args and add to kwargs if any. Arguments follow self.parameter_names order. """
+        if len(args) != len(self.parameter_names):
+            raise ValueError(f"Expected {len(self.parameter_names)} arguments, got {len(args)}. Parameters are: {self.parameter_names}")
+        
+        # Add args to kwargs
+        for arg, name in zip(args, self.parameter_names):
+            kwargs[name] = arg
+            
+        return kwargs
+
+    def __repr__(self):
+        # Create strings for parameter name ~ distribution pairs
+        parameter_strings = [f"{name} ~ {distribution}" for name, distribution in zip(self.parameter_names, self.distributions)]
+        # Join strings with newlines
+        parameter_strings = "\n".join(parameter_strings)
+        # Add initial newline and indentations
+        parameter_strings = "\n".join(["\t"+line for line in parameter_strings.split("\n")])
+        # Print parameter strings with newlines
+        if self.is_transformed:
+            title = f"Transformed Random Variable"
+        else:
+            title = f""
+        if self.is_transformed:
+            body = (
+                f"\n"
+                f"Expression: {self.tree}\n"
+                f"Components: \n{parameter_strings}"
+                )
+        else:
+            body = parameter_strings.replace("\t","")
+        return title+body
+   
+    @property
+    def _is_copy(self):
+        """ 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. """
+        new_variable = copy(self)
+        new_variable._distributions = copy(self.distributions)
+        new_variable._tree = copy(self._tree)
+        new_variable._original_variable = self
+        return new_variable
+    
+    def _apply_operation(self, operation, other=None) -> 'RandomVariable':
+        """
+        Apply a specified operation to this RandomVariable.
+        """
+        if isinstance(other, cuqi.distribution.Distribution):
+            raise ValueError("Cannot apply operation to distribution. Use .rv to create random variable first.")
+        if other is None: # unary operation case
+            return RandomVariable(self.distributions, operation(self.tree))
+        elif isinstance(other, RandomVariable): # binary operation case with another random variable that has distributions
+            return RandomVariable(self.distributions | other.distributions, operation(self.tree, other.tree))
+        return RandomVariable(self.distributions, operation(self.tree, other)) # binary operation case with any other object (constant)
+
+    def __add__(self, other) -> 'RandomVariable':
+        return self._apply_operation(operator.add, other)
+
+    def __radd__(self, other) -> 'RandomVariable':
+        return self.__add__(other)
+
+    def __sub__(self, other) -> 'RandomVariable':
+        return self._apply_operation(operator.sub, other)
+
+    def __rsub__(self, other) -> 'RandomVariable':
+        return self._apply_operation(lambda x, y: operator.sub(y, x), other)
+
+    def __mul__(self, other) -> 'RandomVariable':
+        return self._apply_operation(operator.mul, other)
+
+    def __rmul__(self, other) -> 'RandomVariable':
+        return self.__mul__(other)
+
+    def __truediv__(self, other) -> 'RandomVariable':
+        return self._apply_operation(operator.truediv, other)
+
+    def __rtruediv__(self, other) -> 'RandomVariable':
+        return self._apply_operation(lambda x, y: operator.truediv(y, x), other)
+
+    def __matmul__(self, other) -> 'RandomVariable':
+        if isinstance(other, cuqi.model.Model) and not isinstance(other, cuqi.model.LinearModel):
+            raise TypeError("Cannot apply matmul to non-linear models")
+        return self._apply_operation(operator.matmul, other)
+
+    def __rmatmul__(self, other) -> 'RandomVariable':
+        if isinstance(other, cuqi.model.Model) and not isinstance(other, cuqi.model.LinearModel):
+            raise TypeError("Cannot apply matmul to non-linear models")
+        return self._apply_operation(lambda x, y: operator.matmul(y, x), other)
+
+    def __neg__(self) -> 'RandomVariable':
+        return self._apply_operation(operator.neg)
+
+    def __abs__(self) -> 'RandomVariable':
+        return self._apply_operation(abs)
+
+    def __pow__(self, other) -> 'RandomVariable':
+        return self._apply_operation(operator.pow, other)
+
+    def __getitem__(self, other) -> 'RandomVariable':
+        return self._apply_operation(operator.getitem, other)

{cuqipy-1.2.0.post0.dev342 → cuqipy-1.2.0.post0.dev371}/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.dev342 → cuqipy-1.2.0.post0.dev371}/cuqi/model/_model.py

@@ -351,6 +351,17 @@ class Model(object):
             new_model._non_default_args = [x.name] # Defaults to x if distribution had no name
             return new_model
 
+        # If input is a random variable, we handle it separately
+        if isinstance(x, cuqi.experimental.algebra.RandomVariable):
+            return self._handle_random_variable(x)
+        
+        # If input is a Node from internal abstract syntax tree, we let the Node handle the operation
+        # We use NotImplemented to indicate that the operation is not supported from the Model class
+        # in case of operations such as "@" that can be interpreted as both __matmul__ and __rmatmul__
+        # the operation may be delegated to the Node class.
+        if isinstance(x, cuqi.experimental.algebra.Node):
+            return NotImplemented
+
         # Else we apply the forward operator
         return self._apply_func(self._forward_func,
                                 self.range_geometry,
@@ -463,6 +474,20 @@ class Model(object):
             not type(self.domain_geometry) in _get_identity_geometries():
             raise NotImplementedError("Gradient not implemented for model {} with domain geometry {}".format(self,self.domain_geometry))
 
+    def _handle_random_variable(self, x):
+        """ Private function that handles the case of the input being a random variable. """
+        # If random variable is not a leaf-type node (e.g. internal node) we return NotImplemented
+        if not isinstance(x.tree, cuqi.experimental.algebra.VariableNode):
+            return NotImplemented        
+        
+        # In leaf-type node case we simply change the parameter name of model to match the random variable name
+        dist = x.distribution
+        if dist.dim != self.domain_dim:
+            raise ValueError("Attempting to match parameter name of Model with given random variable, but random variable dimension does not match model domain dimension.")
+        
+        new_model = copy(self)
+        new_model._non_default_args = [dist.name]
+        return new_model
 
     def __len__(self):
         return self.range_dim

{cuqipy-1.2.0.post0.dev342 → cuqipy-1.2.0.post0.dev371}/cuqi/utilities/_get_python_variable_name.py

@@ -9,7 +9,7 @@ import cuqi
 def _get_python_variable_name(var):
     """ Retrieve the Python variable name of an object. Takes the first variable name appearing on the stack that is not in the ignore list. """
 
-    ignored_var_names = ["self", "cls", "obj", "var", "_"]
+    ignored_var_names = ["self", "cls", "obj", "var", "_", "result", "args", "kwargs", "par_name", "name", "distribution", "dist"]
 
     # First get the stack size and loop (in reverse) through the stack
     # It can be a bit slow to loop through stack size so we limit the levels
@@ -29,7 +29,7 @@ def _get_python_variable_name(var):
             if len(var_names) > 0:
                 return var_names[0]
 
-    warnings.warn("Could not automatically find variable name for object: {}. Use keyword `name` when defining distribution to specify a name. If code runs slowly and variable name is not needed set config.MAX_STACK_SEARCH_DEPTH to 0.".format(var))
+    warnings.warn("Could not automatically find variable name for object. Did you assign (=) the object to a python variable? Alternatively, use keyword `name` when defining distribution to specify a name. If code runs slowly and variable name is not needed set config.MAX_STACK_SEARCH_DEPTH to 0. These names are reserved {} and should not be used as object name.".format(ignored_var_names))
 
     return None
 

{cuqipy-1.2.0.post0.dev342 → cuqipy-1.2.0.post0.dev371}/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."""

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

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