TorchKbNUFFTgpu

class mrinufft.operators.TorchKbNUFFTgpu(*args, **kwargs)

Bases: MRITorchKbNufft

MRI Transform Operator using Torch NUFFT for GPU.

This class provides a Non-Uniform Fast Fourier Transform (NUFFT) operator specifically optimized for GPU using the torchkbnufft library. It inherits from the MRITorchKbNufft class and sets the use_gpu parameter to True.

Methods

__init__
adj_op	Backward Operation.
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 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	Forward operation.
pinv_solver	Solves the linear system Ax = y.
pipe	Compute the density compensation weights for a given set of kspace locations.
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
available
backend
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.

_abc_impl = <_abc._abc_data object>

_safe_squeeze(arr)

Squeeze the first two dimensions of shape of the operator.

adj_op(coeffs, out=None)

Backward Operation.

Parameters:

coeffs (Tensor)

Return type:

Tensor

Note

This function uses torch internally, and will convert all its array argument to torch tensors, but will respect the device they are allocated on. The outputs will be converted back to the original array module and device.

autograd_available = False

available: ClassVar[bool] = 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(data, obs_data)

Compute the data consistency.

Parameters:

• data (Tensor) – Image data

• obs_data (Tensor) – Observed data

Returns:

The data consistency error in image space.

Return type:

Tensor

Note

This function uses torch internally, and will convert all its array argument to torch tensors, but will respect the device they are allocated on. The outputs will be converted back to the original array module and device.

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.

op(data, out=None)

Forward operation.

Parameters:

data (Tensor)

Returns:

Tensor

Return type:

Non-uniform Fourier transform of the input image.

Note

This function uses torch internally, and will convert all its array argument to torch tensors, but will respect the device they are allocated on. The outputs will be converted back to the original array module and device.

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

classmethod pipe(kspace_loc, volume_shape, max_iter=10, osf=2, normalize=True, use_gpu=False, **kwargs)

Compute the density compensation weights for a given set of kspace locations.

Parameters:

• kspace_loc (Tensor) – the kspace locations

• volume_shape (tuple) – the volume shape

• max_iter (int default 10) – the number of iterations for density estimation

• osf (float or int) – The oversampling factor the volume shape

• normalize (bool) – Whether to normalize the density compensation. We normalize such that the energy of PSF = 1

• use_gpu (bool, default False) – Whether to use the GPU

Note

This function uses torch internally, and will convert all its array argument to torch tensors, but will respect the device they are allocated on. The outputs will be converted back to the original array module and device.

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] = 'torchkbnufft-gpu'