mrpro.operators.AveragingOp
- class mrpro.operators.AveragingOp[source]
Bases:
LinearOperator
Averaging operator.
This operator averages the input tensor along a specified dimension. The averaging is performed over groups of elements defined by the
idx
parameter. The output tensor will have the same shape as the input tensor, except for thedim
dimension, which will have a size equal to the number of groups specified inidx
. For each group, the average of the elements in that group is computed.For example, this operator can be used to simulate the effect of a sliding window average on a signal model.
- __init__(dim: int, idx: Sequence[Sequence[int] | Tensor | slice] | Tensor = (slice(None),), domain_size: int | None = None) None [source]
Initialize the averaging operator.
- Parameters:
dim (
int
) – The dimension along which to average.idx (
Sequence
[Sequence
[int
] |Tensor
|slice
] |Tensor
, default:(slice(None),)
) – The indices of the input tensor to average over. Each element of the sequence will result in a separate entry in thedim
dimension of the output tensor. The entries can be either a sequence of integers or an integer tensor, a slice object, or a boolean tensor.domain_size (
int
|None
, default:None
) – The size of the input alongdim
. It is only used in theadjoint
method. If not set, the size will be guessed from the input tensor during the forward pass.
- property H: LinearOperator[source]
Adjoint operator.
Obtains the adjoint of an instance of this operator as an
AdjointLinearOperator
, which itself is a anLinearOperator
that can be applied to tensors.Note:
linear_operator.H.H == linear_operator
- property gram: LinearOperator[source]
Gram operator.
For a LinearOperator \(A\), the self-adjoint Gram operator is defined as \(A^H A\).
Note
This is the inherited default implementation.
- __call__(*args: Unpack[Tin]) Tout [source]
Apply the forward operator.
For more information, see
forward
.
- adjoint(x: Tensor) tuple[Tensor] [source]
Apply the adjoint of the averaging operator to the input tensor.
- operator_norm(initial_value: Tensor, dim: Sequence[int] | None, max_iterations: int = 20, relative_tolerance: float = 1e-4, absolute_tolerance: float = 1e-5, callback: Callable[[Tensor], None] | None = None) Tensor [source]
Power iteration for computing the operator norm of the operator.
- Parameters:
initial_value (
Tensor
) – initial value to start the iteration; must be element of the domain. if the initial value contains a zero-vector for one of the considered problems, the function throws anValueError
.The dimensions of the tensors on which the operator operates. The choice of
dim
determines how the operator norm is inperpreted. For example, for a matrix-vector multiplication with a batched matrix tensor of shape(batch1, batch2, row, column)
and a batched input tensor of shape(batch1, batch2, row)
:If
dim=None
, the operator is considered as a block diagonal matrix with batch1*batch2 blocks and the result is a tensor containing a single norm value (shape(1, 1, 1)
).If
dim=(-1)
,batch1*batch2
matrices are considered, and for each a separate operator norm is computed.If
dim=(-2,-1)
,batch1
matrices withbatch2
blocks are considered, and for each matrix a separate operator norm is computed.
Thus, the choice of
dim
determines implicitly determines the domain of the operator.max_iterations (
int
, default:20
) – maximum number of iterationsrelative_tolerance (
float
, default:1e-4
) – absolute tolerance for the change of the operator-norm at each iteration; if set to zero, the maximal number of iterations is the only stopping criterion used to stop the power iteration.absolute_tolerance (
float
, default:1e-5
) – absolute tolerance for the change of the operator-norm at each iteration; if set to zero, the maximal number of iterations is the only stopping criterion used to stop the power iteration.callback (
Callable
[[Tensor
],None
] |None
, default:None
) – user-provided function to be called at each iteration
- Returns:
An estimaton of the operator norm. Shape corresponds to the shape of the input tensor
initial_value
with the dimensions specified indim
reduced to a single value. The pointwise multiplication ofinitial_value
with the result of the operator norm will always be well-defined.
- __add__(other: LinearOperator | Tensor) LinearOperator [source]
- __add__(other: Operator[Tensor, tuple[Tensor]]) Operator[Tensor, tuple[Tensor]]
Operator addition.
Returns
lambda x: self(x) + other(x)
if other is a operator,lambda x: self(x) + other
if other is a tensor
- __and__(other: LinearOperator) LinearOperatorMatrix [source]
Vertical stacking of two LinearOperators.
A&B
is aLinearOperatorMatrix
with two rows, with(A&B)(x) == (A(x), B(x))
. Seemrpro.operators.LinearOperatorMatrix
for more information.
- __matmul__(other: LinearOperator) LinearOperator [source]
- __matmul__(other: Operator[Unpack[Tin2], tuple[Tensor]]) Operator[Unpack[Tin2], tuple[Tensor]]
Operator composition.
Returns
lambda x: self(other(x))
- __mul__(other: Tensor | complex) LinearOperator [source]
Operator elementwise left multiplication with tensor/scalar.
Returns
lambda x: self(x*other)
- __or__(other: LinearOperator) LinearOperatorMatrix [source]
Horizontal stacking of two LinearOperators.
A|B
is aLinearOperatorMatrix
with two columns, with(A|B)(x1,x2) == A(x1)+B(x2)
. Seemrpro.operators.LinearOperatorMatrix
for more information.
- __radd__(other: Tensor) LinearOperator [source]
Operator addition.
Returns
lambda x: self(x) + other*x
- __rmul__(other: Tensor | complex) LinearOperator [source]
Operator elementwise right multiplication with tensor/scalar.
Returns
lambda x: other*self(x)