MRISubspace

class mrinufft.operators.MRISubspace(fourier_op, subspace_basis, use_gpu=False)

Bases: FourierOperatorBase

Fourier Operator with subspace projection.

This is a wrapper around the Fourier Operator to project data onto a low-rank subspace (e.g., dynamic and multi-contrast MRI).

Parameters:

• fourier_op (object of class FourierBase) – the fourier operator to wrap

• subspace_basis (np.ndarray) – Low rank subspace basis of shape (K, T), where K is the rank of the subspace and T is the number of time frames or contrasts in the original image series. Also supports Cupy arrays and Torch tensors.

• use_gpu (bool, optional) – Whether to use the GPU. Default is False. Ignored if the Fourier operator internally use only GPU (e.g., Cupy) or CPU (e.g., Numpy)

Notes

This extension adds a new axis for both image and k-space data:

• Image: (B, C, XYZ) -> (B, S, C, XYZ)

• K-Space: (B, C, K) -> (B, T, C, K)

with S representing the subspace index and T representing time domain or contrast space (for dynamic and multi-contrast MR, respectively).

Similarly, k-space trajectory is expected to have the following shape: (<N_frames or N_contrasts>, N_shots, N_samples, dim). The flatten version is also accepted: (<N_frames or N_contrasts>, N_shots * N_samples, dim)

Methods

__init__
adj_op	Compute Adjoint Operation with subspace projection.
check_shape	Validate the shapes of the image or k-space data against operator shapes.
compute_density	Compute the density compensation weights and set it.
compute_smaps	Compute the sensitivity maps and set it.
data_consistency	Compute the gradient data consistency.
get_lipschitz_cst	Return the Lipschitz constant of the operator.
make_autograd	Make a new Operator with autodiff support.
make_deepinv_phy	Make a new DeepInv Physics with NUFFT operator.
make_linops	Create a Scipy Linear Operator from the NUFFT operator.
op	Compute Forward Operation time/contrast-domain backprojection.
pinv_solver	Solves the linear system Ax = y.
update_samples	Update the samples of the NUFFT operator.
with_autograd	Return a Fourier operator with autograd capabilities.
with_off_resonance_correction	Return a new operator with Off Resonnance Correction.

Attributes

autograd_available
cpx_dtype	Return complex floating precision of the operator.
density	Density compensation of the operator.
dtype	Return floating precision of the operator.
img_full_shape	Full image shape with batch and coil dimensions.
interfaces
ksp_full_shape	Full kspace shape with batch and coil dimensions.
n_batchs	Number of coils for the operator.
n_coils	Number of coils for the operator.
n_samples	Return the number of samples used by the operator.
ndim	Number of dimensions in image space of the operator.
norm_factor	Normalization factor of the operator.
samples	Return the samples used by the operator.
shape	Shape of the image space of the operator.
smaps	Sensitivity maps of the operator.
uses_density	Return True if the operator uses density compensation.
uses_sense	Return True if the operator uses sensitivity maps.
backend
available

Examples using mrinufft.operators.MRISubspace

Subspace NUFFT Operator

Subspace NUFFT Operator

op(data, *args)

Compute Forward Operation time/contrast-domain backprojection.

Parameters:

data (numpy.ndarray) – N-D subspace-projected image. Also supports Cupy arrays and Torch tensors.

Returns:

Time/contrast-domain k-space data.

Return type:

numpy.ndarray

adj_op(coeffs, *args)

Compute Adjoint Operation with subspace projection.

Parameters:

coeffs (numpy.ndarray) – Time/contrast-domain k-space data. Also supports Cupy arrays and Torch tensors.

Returns:

Inverse Fourier transform of the subspace-projected k-space.

Return type:

numpy.ndarray

_abc_impl = <_abc._abc_data object>

_safe_squeeze(arr)

Squeeze the first two dimensions of shape of the operator.

autograd_available = False

check_shape(*, image=None, ksp=None)

Validate the shapes of the image or k-space data against operator shapes.

Parameters:

• image (NDArray, optional) – If passed, the shape of image data will be checked.

• ksp (NDArray or object, optional) – If passed, the shape of the k-space data will be checked.

Raises:

ValueError – If the shape of the provided image does not match the expected operator shape, or if the number of k-space samples does not match the expected number of samples.

compute_density(method: Callable[[...], ndarray[tuple[int, ...], dtype[_ScalarType_co]]] | bool | None | str | dict[str, Any] = None)

Compute the density compensation weights and set it.

Parameters:

method (str or callable or array or dict or bool) –

The method to use to compute the density compensation.

• If a string, the method should be registered in the density registry.

• If a callable, it should take the samples and the shape as input.

• If a dict, it should have a key ‘name’, to determine which method to use. other items will be used as kwargs.

• If an array, it should be of shape (Nsamples,) and will be used as is.

• If True, the method pipe is chosen as default estimation method.

Notes

The “pipe” method is only available for the following backends: tensorflow, finufft, cufinufft, gpunufft, torchkbnufft-cpu and torchkbnufft-gpu.

compute_smaps(method: ndarray[tuple[int, ...], dtype[_ScalarType_co]] | Callable[[...], ndarray[tuple[int, ...], dtype[_ScalarType_co]]] | str | dict[str, Any] | None = None)

Compute the sensitivity maps and set it.

Parameters:

method (callable or dict or array) – The method to use to compute the sensitivity maps. If an array, it should be of shape (NCoils,XYZ) and will be used as is. If a dict, it should have a key ‘name’, to determine which method to use. other items will be used as kwargs. If a callable, it should take the samples and the shape as input. Note that this callable function should also hold the k-space data (use funtools.partial)

property cpx_dtype

Return complex floating precision of the operator.

data_consistency(image_data: ndarray[tuple[int, ...], dtype[_ScalarType_co]], obs_data: ndarray[tuple[int, ...], dtype[_ScalarType_co]]) → ndarray[tuple[int, ...], dtype[_ScalarType_co]]

Compute the gradient data consistency.

This is the naive implementation using adj_op(op(x)-y). Specific backend can (and should!) implement a more efficient version.

Return type:

ndarray[tuple[int, …], dtype[_ScalarType_co]]

property density: ndarray[tuple[int, ...], dtype[floating]] | None

Density compensation of the operator.

property dtype

Return floating precision of the operator.

get_lipschitz_cst(max_iter=10) → floating | ndarray[tuple[int, ...], dtype[floating]]

Return the Lipschitz constant of the operator.

Parameters:

• max_iter (int) – number of iteration to compute the lipschitz constant.

• **kwargs – Extra arguments givent

Returns:

Spectral Radius

Return type:

float

Notes

This uses the Iterative Power Method to compute the largest singular value of a minified version of the nufft operator. No coil or B0 compensation is used, but includes any computed density.

property img_full_shape: tuple[int, ...]

Full image shape with batch and coil dimensions.

interfaces: dict[str, tuple[bool, type[FourierOperatorBase]]] = {'bart': (False, <class 'mrinufft.operators.interfaces.bart.MRIBartNUFFT'>), 'cartesian': (True, <class 'mrinufft.operators.cartesian.MRICartesianOperator'>), 'cufinufft': (True, <class 'mrinufft.operators.interfaces.cufinufft.MRICufiNUFFT'>), 'ducc0': (False, <class 'mrinufft.operators.interfaces.ducc0.MRIDUCC0'>), 'finufft': (True, <class 'mrinufft.operators.interfaces.finufft.MRIfinufft'>), 'gpunufft': (True, <class 'mrinufft.operators.interfaces.gpunufft.MRIGpuNUFFT'>), 'numpy': (True, <class 'mrinufft.operators.interfaces.nudft_numpy.MRInumpy'>), 'pynfft': (False, <class 'mrinufft.operators.interfaces.nfft.MRInfft'>), 'pynufft-cpu': (False, <class 'mrinufft.operators.interfaces.pynufft_cpu.MRIPynufft'>), 'sigpy': (True, <class 'mrinufft.operators.interfaces.sigpy.MRISigpyNUFFT'>), 'stacked': (True, <class 'mrinufft.operators.stacked.MRIStackedNUFFT'>), 'stacked-cufinufft': (True, <class 'mrinufft.operators.stacked.MRIStackedNUFFTGPU'>), 'tensorflow': (False, <class 'mrinufft.operators.interfaces.tfnufft.MRITensorflowNUFFT'>), 'torchkbnufft-cpu': (False, <class 'mrinufft.operators.interfaces.torchkbnufft.TorchKbNUFFTcpu'>), 'torchkbnufft-gpu': (False, <class 'mrinufft.operators.interfaces.torchkbnufft.TorchKbNUFFTgpu'>)}

property ksp_full_shape: tuple[int, int, int]

Full kspace shape with batch and coil dimensions.

make_autograd(*, wrt_data: bool = True, wrt_traj: bool = False, paired_batch: bool = False) → MRINufftAutoGrad

Make a new Operator with autodiff support.

Parameters:

• wrt_data (bool, optional) – If the gradient with respect to the data is computed, default is true

• wrt_traj (bool, optional) – If the gradient with respect to the trajectory is computed, default is false

• paired_batch (int, optional) – If provided, specifies batch size for varying data/smaps pairs. Default is None, which means no batching

Returns:

A NUFFT operator with autodiff capabilities.

Return type:

torch.nn.module

Raises:

ValueError – If autograd is not available.

make_deepinv_phy(*args, **kwargs) → DeepInvPhyNufft

Make a new DeepInv Physics with NUFFT operator.

Parameters:

• wrt_data (bool, optional) – If the gradient with respect to the data is computed, default is true

• wrt_traj (bool, optional) – If the gradient with respect to the trajectory is computed, default is false

• paired_batch (int, optional) – If provided, specifies batch size for varying data/smaps pairs. Default is None, which means no batching

• viewed_as_real (bool, optional) – If True, the DeepInverse physics wrapper accepts and returns real-view tensors with a final dimension of size 2 representing the real and imaginary parts. Default is False.

Returns:

A NUFFT operator with autodiff capabilities.

Return type:

torch.nn.module

Raises:

ValueError – If autograd is not available.

make_linops(*, cupy: bool = False)

Create a Scipy Linear Operator from the NUFFT operator.

We add a _nufft private attribute with the current operator.

Parameters:

cupy (bool, default False) – If True, create a Cupy Linear Operator

See also

-, -

property n_batchs

Number of coils for the operator.

property n_coils: int

Number of coils for the operator.

property n_samples: int

Return the number of samples used by the operator.

property ndim

Number of dimensions in image space of the operator.

property norm_factor: floating

Normalization factor of the operator.

pinv_solver(kspace_data, optim='lsqr', **kwargs)

Solves the linear system Ax = y.

It uses a least-square optimization solver,

Parameters:

• kspace_data (NDArray) – The k-space data to reconstruct.

• optim (str, default "lsqr") – name of the least-square optimizer to use.

• **kwargs – Extra arguments to pass to the least-square optimizer.

Returns:

Reconstructed image

Return type:

NDArray

property samples: ndarray[tuple[int, ...], dtype[_ScalarType_co]]

Return the samples used by the operator.

property shape: tuple[int, ...]

Shape of the image space of the operator.

property smaps

Sensitivity maps of the operator.

update_samples(new_samples: ndarray[tuple[int, ...], dtype[floating]], *, unsafe: bool = False)

Update the samples of the NUFFT operator.

Parameters:

• new_samples (np.ndarray or GPUArray) – The new samples location of shape Nsamples x N_dimensions.

• unsafe (bool, default False) – If True, the original array is used directly without any checks. This should be used with caution as it might lead to unexpected behavior.

Notes

If unsafe is True, the new_samples should be of shape (Nsamples, N_dimensions), F-ordered (column-major) and in the range [-pi, pi]. If not, this will lead to unexpected behavior. You have been warned.

If unsafe is False, this is automatically handled.

property uses_density

Return True if the operator uses density compensation.

property uses_sense

Return True if the operator uses sensitivity maps.

classmethod with_autograd(wrt_data=True, wrt_traj=False, paired_batch=False, *args, **kwargs)

Return a Fourier operator with autograd capabilities.

with_off_resonance_correction(readout_time: NDArray, b0_map: NDArray | None = None, r2star_map: NDArray | None = None, mask: NDArray | None = None, interpolator: str | dict | tuple[NDArray, NDArray] = 'svd') → MRIFourierCorrected

Return a new operator with Off Resonnance Correction.

Return type:

MRIFourierCorrected

backend: ClassVar[str]

available: ClassVar[bool]