DecomposablePhysics#

class deepinv.physics.DecomposablePhysics(U=None, V_adjoint=None, img_size=None, U_adjoint=None, V=None, mask=1.0, **kwargs)[source]#

Bases: LinearPhysics

Parent class for linear operators with SVD decomposition.

The singular value decomposition is expressed as

\[A = U\text{diag}(s)V^{\top} \in \mathbb{R}^{m\times n}\]

where \(U\in\mathbb{C}^{n\times n}\) and \(V\in\mathbb{C}^{m\times m}\) are orthonormal linear transformations and \(s\in\mathbb{R}_{+}^{n}\) are the singular values.

Parameters:

U (None | Callable) – orthonormal transformation. If None (default), it is set to the identity function.
V_adjoint (None | Callable) – transpose of V. If None (default), it is set to the identity function.
img_size (tuple) – (optional, only required if V and/or U_adjoint are not provided) size of the signal/image x, e.g. (C, ...) where C is the number of channels and ... are the spatial dimensions, used for the automatic adjoint computation.
U_adjoint (None | Callable) – transpose of U. If None (default), it is computed automatically using deepinv.physics.adjoint_function() from the U function and the img_size parameter. This automatic adjoint is computed using automatic differentiation, which is slower than a closed form adjoint, and can have a larger memory footprint. If you want to use the automatic adjoint, you should set the img_size parameter.
V (None | Callable) – If None (default), it is computed automatically using deepinv.physics.adjoint_function() from the V_adjoint function and the img_size parameter. This automatic adjoint is computed using automatic differentiation, which is slower than a closed form adjoint, and can have a larger memory footprint. If you want to use the automatic adjoint, you should set the img_size parameter.
params (torch.nn.parameter.Parameter, float) – Singular values of the transform

Examples:

Recreation of the Inpainting operator using the DecomposablePhysics class:

>>> from deepinv.physics import DecomposablePhysics
>>> seed = torch.manual_seed(0)  # Random seed for reproducibility
>>> img_size = (1, 1, 3, 3)  # Input size
>>> mask = torch.tensor([[1, 0, 1], [1, 0, 1], [1, 0, 1]])  # Binary mask
>>> U = lambda x: x  # U is the identity operation
>>> U_adjoint = lambda x: x  # U_adjoint is the identity operation
>>> V = lambda x: x  # V is the identity operation
>>> V_adjoint = lambda x: x  # V_adjoint is the identity operation
>>> mask_svd = mask.float().unsqueeze(0).unsqueeze(0)  # Convert the mask to torch.Tensor and adjust its dimensions
>>> physics = DecomposablePhysics(U=U, U_adjoint=U_adjoint, V=V, V_adjoint=V_adjoint, mask=mask_svd)

Apply the operator to a random tensor:

>>> x = torch.randn(img_size)
>>> with torch.no_grad():
...     physics.A(x)  # Apply the masking
tensor([[[[ 1.5410, -0.0000, -2.1788],
          [ 0.5684, -0.0000, -1.3986],
          [ 0.4033,  0.0000, -0.7193]]]])

A(x, mask=None, **kwargs)[source]#

Applies the forward operator \(y = A(x)\).

If a mask/singular values is provided, it is used to apply the forward operator, and also stored as the current mask/singular values.

Parameters:

x (torch.Tensor) – input tensor
mask (torch.nn.parameter.Parameter, float) – singular values.

Returns:

output tensor

Return type:

Tensor

A_A_adjoint(y, mask=None, **kwargs)[source]#

A helper function that computes \(A A^{\top}y\).

Using the SVD decomposition, we have \(A A^{\top} = U\text{diag}(s^2)U^{\top}\).

Parameters:: y (torch.Tensor) – measurement.
Returns:: (torch.Tensor) the product \(AA^{\top}y\).

A_adjoint(y, mask=None, **kwargs)[source]#

Computes the adjoint of the forward operator \(\tilde{x} = A^{\top}y\).

If a mask/singular values is provided, it is used to apply the adjoint operator, and also stored as the current mask/singular values.

Parameters:

y (torch.Tensor) – input tensor
mask (torch.nn.parameter.Parameter, float) – singular values.

Returns:

output tensor

Return type:

Tensor

A_adjoint_A(x, mask=None, **kwargs)[source]#

A helper function that computes \(A^{\top} A x\).

Using the SVD decomposition, we have \(A^{\top}A = V\text{diag}(s^2)V^{\top}\).

Parameters:: x (torch.Tensor) – signal/image.
Returns:: (torch.Tensor) the product \(A^{\top}Ax\).

A_dagger(y, mask=None, **kwargs)[source]#

Computes \(A^{\dagger}y = x\) in an efficient manner leveraging the singular vector decomposition.

Parameters:: y (torch.Tensor) – a measurement \(y\) to reconstruct via the pseudoinverse.
Returns:: (torch.Tensor) The reconstructed image \(x\).