mrpro.operators.functionals.L1NormViewAsReal

class mrpro.operators.functionals.L1NormViewAsReal[source]

Bases: ElementaryProximableFunctional

Functional class for the L1 Norm, where C is identified with R^2.

This implements the functional given by \(f: C^N -> [0, \infty), x -> \|W_r * Re(x-b) )\|_1 + \|( W_i * Im(x-b) )\|_1\), where \(W_r\) and \(W_i\) are a either scalars or tensors and * denotes element-wise multiplication.

If the parameter weight is real-valued, \(W_r\) and \(W_i\) are both set to weight. If it is complex-valued, \(W_r\) and \(W_I\) are set to the real and imaginary part, respectively.

In most cases, consider setting divide_by_n to true to be independent of input size.

The norm of the vector is computed along the dimensions set at initialization.

Initialize a Functional.

We assume that functionals are given in the form \(f(x) = \phi ( weight ( x - target))\) for some functional \(\phi\).

Parameters:

target (Tensor | None | complex, default: None) – target element - often data tensor (see above)
weight (Tensor | complex, default: 1.0) – weight parameter (see above)
dim (int | Sequence[int] | None, default: None) – dimension(s) over which functional is reduced. All other dimensions of weight ( x - target) will be treated as batch dimensions.
divide_by_n (bool, default: False) – if true, the result is scaled by the number of elements of the dimensions index by dim in the tensor weight ( x - target). If true, the functional is thus calculated as the mean, else the sum.
keepdim (bool, default: False) – if true, the dimension(s) of the input indexed by dim are maintained and collapsed to singeltons, else they are removed from the result.

__call__(*args: Unpack) → Tout[source]

Apply the forward operator.

For more information, see forward.

Note

Prefer using operator_instance(*parameters), i.e. using __call__ over using forward.

forward(x: Tensor) → tuple[Tensor][source]

Forward method.

Compute the L1 norm of the input with \(C\) identified as \(R^2\).

Parameters:: x (Tensor) – input tensor
Returns:: L1 norm of the input tensor, where \(C\) is identified as \(R^2\).

prox(x: Tensor, sigma: Tensor | float = 1.0) → tuple[Tensor][source]

Proximal Mapping of the L1 Norm.

Apply the proximal mapping of the L1 norm with \(C\) identified as \(R^2\).

Parameters:

x (Tensor) – input tensor
sigma (Tensor | float, default: 1.0) – real valued positive scaling factor

Returns:

Proximal mapping applied to the input tensor

prox_convex_conj(x: Tensor, sigma: Tensor | float = 1.0) → tuple[Tensor][source]

Apply proximal operator of convex conjugate of functional.

Yields \(\mathrm{prox}_{\sigma f^*}(x) = \mathrm{argmin}_{p} (\sigma f^*(p) + 1/2 \|x-p\|_2^2\), where \(f^*\) denotes the convex conjugate of \(f\), given \(x\) and \(\sigma\).

Parameters:

x (Tensor) – input tensor
sigma (Tensor | float, default: 1.0) – scaling factor, must be positive

Returns:

Proximal operator of the convex conjugate applied to the input tensor

__add__(other: Operator[Unpack, Tout]) → Operator[Unpack, Tout][source]

__add__(other: Tensor) → Operator[Unpack, tuple[Unpack]]

Operator addition.

Returns lambda x: self(x) + other(x) if other is a operator, lambda x: self(x) + other*x if other is a tensor

__matmul__(other: Operator[Unpack, tuple[Unpack]]) → Operator[Unpack, Tout][source]

Operator composition.

Returns lambda x: self(other(x))

__mul__(other: Tensor | complex) → Operator[Unpack, Tout][source]

Operator multiplication with tensor.

Returns lambda x: self(x*other)

__or__(other: ProximableFunctional) → ProximableFunctionalSeparableSum[source]

Create a ProximableFunctionalSeparableSum object from two proximable functionals.

Parameters:: other (ProximableFunctional) – second functional to be summed
Returns:: ProximableFunctionalSeparableSum object

__radd__(other: Tensor) → Operator[Unpack, tuple[Unpack]][source]

Operator right addition.

Returns lambda x: other*x + self(x)

__rmul__(scalar: Tensor | complex) → ProximableFunctional[source]: Multiply functional with scalar.