OSCR

A Deep Nonlinear Subspace Modeling and Reconstruction for Diffusion-Weighted Imaging Using Denoising Auto-Encoder.

Code ↔ Paper

5 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 5 matches
  1. [1] § Methods › Bias and Precision Analysis ↔ figures/fig5/create_violin_plots.py, lines 350–437 · score 0.87 · Cortico Spinal Tract, Corpus Callosum, CST, CC, crossing, precision
  2. [2] § Methods › Latent‐Space Decoded Reconstruction ↔ sigpy/mri/app.py, lines 723–817 · score 0.75 · coil sensitivity maps, Fourier transform, phase maps, shot phases, SMS, operator
  3. [3] § Methods › Latent‐Space Decoded Reconstruction ↔ code/laser/reconstruction/reconstruction.py, lines 447–555 · score 0.65 · phase encoding, diffusion weightings, multi shot, collapsed, readout, SMS
  4. [4] § Methods › Latent‐Space Decoded Reconstruction ↔ sigpy/mri/muse.py, lines 230–300 · score 0.65 · phase encoding, diffusion weightings, multi shot, collapsed, readout, SMS
  5. [5] § Methods › Reconstruction Comparison ↔ sigpy/mri/app.py, lines 723–817 · score 0.59 · low rank, Shot phases, block, TV, stride, LLR

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 1,151 lines · 36 KB · BSD-3-Clause · 2 matches

  1. # -*- coding: utf-8 -*-
  2. """MRI applications.
  3. """
  4. import numpy as np
  5. import sigpy as sp
  7. from sigpy.mri import linop, nlop
  8. from sigpy.mri.dims import *
  10. __all__ = ['SenseRecon', 'L1WaveletRecon', 'TotalVariationRecon',
  11. 'JsenseRecon', 'EspiritCalib', 'HighDimensionalRecon',
  12. 'ModelDiffRecon']
  15. def _estimate_weights(y, weights, coord, coil_dim=0):
  16. if weights is None and coord is None:
  17. with sp.get_device(y):
  18. weights = (sp.rss(y, axes=(coil_dim, ),
  19. keepdims=True) > 0).astype(y.dtype)
  21. if weights is None and coord is not None:
  22. with sp.get_device(y):
  23. weights = (sp.rss(y, axes=(coil_dim, ),
  24. keepdims=True) > 0).astype(y.dtype)
  26. return weights
  29. class SenseRecon(sp.app.LinearLeastSquares):
  30. r"""SENSE Reconstruction.
  32. Considers the problem
  34. .. math::
  35. \min_x \frac{1}{2} \| P F S x - y \|_2^2 +
  36. \frac{\lambda}{2} \| x \|_2^2
  38. where P is the sampling operator, F is the Fourier transform operator,
  39. S is the SENSE operator, x is the image, and y is the k-space measurements.
  41. Args:
  42. y (array): k-space measurements.
  43. mps (array): sensitivity maps.
  44. lamda (float): regularization parameter.
  45. weights (float or array): weights for data consistency.
  46. tseg (None or Dictionary): parameters for time-segmented off-resonance
  47. correction. Parameters are 'b0' (array), 'dt' (float),
  48. 'lseg' (int), and 'n_bins' (int). Lseg is the number of
  49. time segments used, and n_bins is the number of histogram bins.
  50. coord (None or array): coordinates.
  51. device (Device): device to perform reconstruction.
  52. coil_batch_size (int): batch size to process coils.
  53. Only affects memory usage.
  54. comm (Communicator): communicator for distributed computing.
  55. **kwargs: Other optional arguments.
  57. References:
  58. Pruessmann, K. P., Weiger, M., Scheidegger, M. B., & Boesiger, P.
  59. (1999).
  60. SENSE: sensitivity encoding for fast MRI.
  61. Magnetic resonance in medicine, 42(5), 952-962.
  63. Pruessmann, K. P., Weiger, M., Bornert, P., & Boesiger, P. (2001).
  64. Advances in sensitivity encoding with arbitrary k-space trajectories.
  65. Magnetic resonance in medicine, 46(4), 638-651.
  67. """
  69. def __init__(
  70. self,
  71. y,
  72. mps,
  73. lamda=0,
  74. weights=None,
  75. tseg=None,
  76. coord=None,
  77. device=sp.cpu_device,
  78. coil_batch_size=None,
  79. comm=None,
  80. show_pbar=True,
  81. transp_nufft=False,
  82. **kwargs
  83. ):
  84. weights = _estimate_weights(y, weights, coord)
  85. if weights is not None:
  86. y = sp.to_device(y * weights**0.5, device=device)
  87. else:
  88. y = sp.to_device(y, device=device)
  90. A = linop.Sense(
  91. mps,
  92. coord=coord,
  93. weights=weights,
  94. tseg=tseg,
  95. coil_batch_size=coil_batch_size,
  96. comm=comm,
  97. transp_nufft=transp_nufft,
  98. )
  100. if comm is not None:
  101. show_pbar = show_pbar and comm.rank == 0
  103. super().__init__(A, y, lamda=lamda, show_pbar=show_pbar, **kwargs)
  106. class L1WaveletRecon(sp.app.LinearLeastSquares):
  107. r"""L1 Wavelet regularized reconstruction.
  109. Considers the problem
  111. .. math::
  112. \min_x \frac{1}{2} \| P F S x - y \|_2^2 + \lambda \| W x \|_1
  114. where P is the sampling operator, F is the Fourier transform operator,
  115. S is the SENSE operator, W is the wavelet operator,
  116. x is the image, and y is the k-space measurements.
  118. Args:
  119. y (array): k-space measurements.
  120. mps (array): sensitivity maps.
  121. lamda (float): regularization parameter.
  122. weights (float or array): weights for data consistency.
  123. coord (None or array): coordinates.
  124. wave_name (str): wavelet name.
  125. device (Device): device to perform reconstruction.
  126. coil_batch_size (int): batch size to process coils.
  127. Only affects memory usage.
  128. comm (Communicator): communicator for distributed computing.
  129. **kwargs: Other optional arguments.
  131. References:
  132. Lustig, M., Donoho, D., & Pauly, J. M. (2007).
  133. Sparse MRI: The application of compressed sensing for rapid MR imaging.
  134. Magnetic Resonance in Medicine, 58(6), 1082-1195.
  136. """
  138. def __init__(
  139. self,
  140. y,
  141. mps,
  142. lamda,
  143. weights=None,
  144. coord=None,
  145. wave_name="db4",
  146. device=sp.cpu_device,
  147. coil_batch_size=None,
  148. comm=None,
  149. show_pbar=True,
  150. transp_nufft=False,
  151. **kwargs
  152. ):
  153. weights = _estimate_weights(y, weights, coord)
  154. if weights is not None:
  155. y = sp.to_device(y * weights**0.5, device=device)
  156. else:
  157. y = sp.to_device(y, device=device)
  159. A = linop.Sense(
  160. mps,
  161. coord=coord,
  162. weights=weights,
  163. comm=comm,
  164. coil_batch_size=coil_batch_size,
  165. transp_nufft=transp_nufft,
  166. )
  167. img_shape = mps.shape[1:]
  168. W = sp.linop.Wavelet(img_shape, wave_name=wave_name)
  169. proxg = sp.prox.UnitaryTransform(sp.prox.L1Reg(W.oshape, lamda), W)
  171. def g(input):
  172. device = sp.get_device(input)
  173. xp = device.xp
  174. with device:
  175. return lamda * xp.sum(xp.abs(W(input))).item()
  177. if comm is not None:
  178. show_pbar = show_pbar and comm.rank == 0
  180. super().__init__(A, y, proxg=proxg, g=g, show_pbar=show_pbar, **kwargs)
  183. class TotalVariationRecon(sp.app.LinearLeastSquares):
  184. r"""Total variation regularized reconstruction.
  186. Considers the problem:
  188. .. math::
  189. \min_x \frac{1}{2} \| P F S x - y \|_2^2 + \lambda \| G x \|_1
  191. where P is the sampling operator, F is the Fourier transform operator,
  192. S is the SENSE operator, G is the gradient operator,
  193. x is the image, and y is the k-space measurements.
  195. Args:
  196. y (array): k-space measurements.
  197. mps (array): sensitivity maps.
  198. lamda (float): regularization parameter.
  199. weights (float or array): weights for data consistency.
  200. coord (None or array): coordinates.
  201. device (Device): device to perform reconstruction.
  202. coil_batch_size (int): batch size to process coils.
  203. Only affects memory usage.
  204. comm (Communicator): communicator for distributed computing.
  205. **kwargs: Other optional arguments.
  207. References:
  208. Block, K. T., Uecker, M., & Frahm, J. (2007).
  209. Undersampled radial MRI with multiple coils.
  210. Iterative image reconstruction using a total variation constraint.
  211. Magnetic Resonance in Medicine, 57(6), 1086-1098.
  213. """
  215. def __init__(
  216. self,
  217. y,
  218. mps,
  219. lamda,
  220. weights=None,
  221. coord=None,
  222. device=sp.cpu_device,
  223. coil_batch_size=None,
  224. comm=None,
  225. show_pbar=True,
  226. transp_nufft=False,
  227. **kwargs
  228. ):
  229. weights = _estimate_weights(y, weights, coord)
  230. if weights is not None:
  231. y = sp.to_device(y * weights**0.5, device=device)
  232. else:
  233. y = sp.to_device(y, device=device)
  235. A = linop.Sense(
  236. mps,
  237. coord=coord,
  238. weights=weights,
  239. comm=comm,
  240. coil_batch_size=coil_batch_size,
  241. transp_nufft=transp_nufft,
  242. )
  244. G = sp.linop.FiniteDifference(A.ishape)
  245. proxg = sp.prox.L1Reg(G.oshape, lamda)
  247. def g(x):
  248. device = sp.get_device(x)
  249. xp = device.xp
  250. with device:
  251. return lamda * xp.sum(xp.abs(x)).item()
  253. if comm is not None:
  254. show_pbar = show_pbar and comm.rank == 0
  256. super().__init__(
  257. A, y, proxg=proxg, g=g, G=G, show_pbar=show_pbar, **kwargs
  258. )
  261. class JsenseRecon(sp.app.App):
  262. r"""JSENSE/NLINV reconstruction.
  264. Considers the problem
  266. .. math::
  267. \min_{l, r} \frac{1}{2} \| l \ast r - y \|_2^2 +
  268. \frac{\lambda}{2} (\| l \|_2^2 + \| r \|_2^2)
  270. where :math:`\ast` is the convolution operator.
  272. This formulation with regularization corresponds to the version
  273. described in the NLINV paper. Without regularization (which is the
  274. default) this corresponds to the version from the JSENSE paper but using a
  275. truncated Fourier representation of the coils (as in NLINV) instead
  276. of polynomials.
  278. Args:
  279. y (array): k-space measurements.
  280. mps_ker_width (int): sensitivity maps kernel width.
  281. ksp_calib_width (int): k-space calibration width.
  282. lamda (float): regularization parameter.
  283. device (Device): device to perform reconstruction.
  284. weights (float or array): weights for data consistency.
  285. coord (None or array): coordinates.
  286. img_shape (None or list): Image shape.
  287. grd_shape (None or list): Shape of grid.
  288. max_iter (int): Maximum number of iterations.
  289. max_inner_iter (int): Maximum number of inner iterations.
  291. References:
  292. Ying, L., & Sheng, J. (2007).
  293. Joint image reconstruction and sensitivity estimation in SENSE
  294. (JSENSE).
  295. Magnetic Resonance in Medicine, 57(6), 1196-1202.
  297. Uecker, M., Hohage, T., Block, K. T., & Frahm, J. (2008).
  298. Image reconstruction by regularized nonlinear inversion-
  299. joint estimation of coil sensitivities and image content.
  300. Magnetic Resonance in Medicine, 60(#), 674-682.
  302. """
  304. def __init__(
  305. self,
  306. y,
  307. mps_ker_width=16,
  308. ksp_calib_width=24,
  309. lamda=0,
  310. device=sp.cpu_device,
  311. comm=None,
  312. weights=None,
  313. coord=None,
  314. img_shape=None,
  315. grd_shape=None,
  316. max_iter=10,
  317. max_inner_iter=10,
  318. normalize=True,
  319. show_pbar=True,
  320. ):
  321. self.y = y
  322. self.mps_ker_width = mps_ker_width
  323. self.ksp_calib_width = ksp_calib_width
  324. self.lamda = lamda
  325. self.weights = weights
  326. self.coord = coord
  327. self.img_shape = img_shape
  328. self.grd_shape = grd_shape
  329. self.max_iter = max_iter
  330. self.max_inner_iter = max_inner_iter
  331. self.normalize = normalize
  333. self.device = sp.Device(device)
  334. self.comm = comm
  335. self.dtype = y.dtype
  336. self.num_coils = len(y)
  337. if comm is not None:
  338. show_pbar = show_pbar and comm.rank == 0
  340. self._get_data()
  341. self._get_vars()
  342. self._get_alg()
  343. super().__init__(self.alg, show_pbar=show_pbar)
  345. def _get_data(self):
  346. if self.coord is None:
  347. self.img_shape = list(self.y.shape[1:])
  348. ndim = len(self.img_shape)
  350. self.y = sp.resize(
  351. self.y, [self.num_coils] + ndim * [self.ksp_calib_width]
  352. )
  354. if self.weights is not None:
  355. self.weights = sp.resize(
  356. self.weights, ndim * [self.ksp_calib_width]
  357. )
  359. else:
  360. if self.img_shape is None:
  361. self.img_shape = sp.estimate_shape(self.coord)
  362. else:
  363. self.img_shape = list(self.img_shape)
  365. calib_idx = (
  366. np.amax(np.abs(self.coord), axis=-1) < self.ksp_calib_width / 2
  367. )
  369. self.coord = self.coord[calib_idx]
  370. self.y = self.y[:, calib_idx]
  372. if self.weights is not None:
  373. self.weights = self.weights[calib_idx]
  375. if self.weights is None:
  376. self.y = sp.to_device(self.y, self.device)
  377. else:
  378. self.y = sp.to_device(self.weights**0.5 * self.y, self.device)
  380. if self.coord is not None:
  381. self.coord = sp.to_device(self.coord, self.device)
  382. if self.weights is not None:
  383. self.weights = sp.to_device(self.weights, self.device)
  385. self.weights = _estimate_weights(self.y, self.weights, self.coord)
  387. if self.normalize:
  388. xp = self.device.xp
  389. with self.device:
  390. self.y = self.y / xp.linalg.norm(self.y)
  392. def _get_vars(self):
  393. ndim = len(self.img_shape)
  395. mps_ker_shape = [self.num_coils] + [self.mps_ker_width] * ndim
  396. if self.coord is None:
  397. img_ker_shape = [
  398. i + self.mps_ker_width - 1 for i in self.y.shape[1:]
  399. ]
  400. else:
  401. if self.grd_shape is None:
  402. self.grd_shape = sp.estimate_shape(self.coord)
  404. img_ker_shape = [
  405. i + self.mps_ker_width - 1 for i in self.grd_shape
  406. ]
  408. self.img_ker = sp.dirac(
  409. img_ker_shape, dtype=self.dtype, device=self.device
  410. )
  411. with self.device:
  412. self.mps_ker = self.device.xp.zeros(
  413. mps_ker_shape, dtype=self.dtype
  414. )
  416. def _get_alg(self):
  417. def min_mps_ker():
  418. self.A_mps_ker = linop.ConvImage(
  419. self.mps_ker.shape,
  420. self.img_ker,
  421. coord=self.coord,
  422. weights=self.weights,
  423. )
  424. sp.app.LinearLeastSquares(
  425. self.A_mps_ker,
  426. self.y,
  427. self.mps_ker,
  428. lamda=self.lamda,
  429. max_iter=self.max_inner_iter,
  430. show_pbar=False,
  431. ).run()
  433. def min_img_ker():
  434. self.A_img_ker = linop.ConvSense(
  435. self.img_ker.shape,
  436. self.mps_ker,
  437. coord=self.coord,
  438. weights=self.weights,
  439. comm=self.comm,
  440. )
  441. sp.app.LinearLeastSquares(
  442. self.A_img_ker,
  443. self.y,
  444. self.img_ker,
  445. lamda=self.lamda,
  446. max_iter=self.max_inner_iter,
  447. show_pbar=False,
  448. ).run()
  450. self.alg = sp.alg.AltMin(
  451. min_mps_ker, min_img_ker, max_iter=self.max_iter
  452. )
  454. def _output(self):
  455. xp = self.device.xp
  456. # Normalize by root-sum-of-squares.
  457. with self.device:
  458. rss = 0
  459. mps = np.empty([self.num_coils] + self.img_shape, dtype=self.dtype)
  460. for c in range(self.num_coils):
  461. mps_c = sp.ifft(sp.resize(self.mps_ker[c], self.img_shape))
  462. rss += xp.abs(mps_c) ** 2
  463. sp.copyto(mps[c], mps_c)
  465. rss = sp.to_device(rss)
  466. if self.comm is not None:
  467. self.comm.allreduce(rss)
  469. rss = rss**0.5
  470. mps /= rss
  471. return mps
  474. class EspiritCalib(sp.app.App):
  475. """ESPIRiT calibration.
  477. Currently only supports outputting one set of maps.
  479. Args:
  480. ksp (array): k-space array of shape [num_coils, n_ndim, ..., n_1]
  481. calib (tuple of ints): length-2 image shape.
  482. thresh (float): threshold for the calibration matrix.
  483. kernel_width (int): kernel width for the calibration matrix.
  484. max_power_iter (int): maximum number of power iterations.
  485. device (Device): computing device.
  486. crop (int): cropping threshold.
  488. Returns:
  489. array: ESPIRiT maps of the same shape as ksp.
  491. References:
  492. Martin Uecker, Peng Lai, Mark J. Murphy, Patrick Virtue, Michael Elad,
  493. John M. Pauly, Shreyas S. Vasanawala, and Michael Lustig
  494. ESPIRIT - An Eigenvalue Approach to Autocalibrating Parallel MRI:
  495. Where SENSE meets GRAPPA.
  496. Magnetic Resonance in Medicine, 71:990-1001 (2014)
  498. """
  500. def __init__(
  501. self,
  502. ksp,
  503. calib_width=24,
  504. thresh=0.02,
  505. kernel_width=6,
  506. crop=0.95,
  507. max_iter=100,
  508. sets=1,
  509. device=sp.cpu_device,
  510. output_eigenvalue=False,
  511. show_pbar=True,
  512. ):
  513. self.device = sp.Device(device)
  514. self.output_eigenvalue = output_eigenvalue
  515. self.crop = crop
  517. img_ndim = ksp.ndim - 1
  518. num_coils = len(ksp)
  519. with sp.get_device(ksp):
  520. # Get calibration region
  521. calib_shape = [num_coils] + [calib_width] * img_ndim
  522. calib = sp.resize(ksp, calib_shape)
  523. calib = sp.to_device(calib, device)
  525. xp = self.device.xp
  526. with self.device:
  527. # Get calibration matrix.
  528. # Shape [num_coils] + num_blks + [kernel_width] * img_ndim
  529. mat = sp.array_to_blocks(
  530. calib, [kernel_width] * img_ndim, [1] * img_ndim
  531. )
  532. mat = mat.reshape([num_coils, -1, kernel_width**img_ndim])
  533. mat = mat.transpose([1, 0, 2])
  534. mat = mat.reshape([-1, num_coils * kernel_width**img_ndim])
  536. # Perform SVD on calibration matrix
  537. _, S, VH = xp.linalg.svd(mat, full_matrices=False)
  538. VH = VH[S > thresh * S.max(), :]
  540. # Get kernels
  541. num_kernels = len(VH)
  542. kernels = VH.reshape(
  543. [num_kernels, num_coils] + [kernel_width] * img_ndim
  544. )
  545. img_shape = ksp.shape[1:]
  547. # Get covariance matrix in image domain
  548. AHA = xp.zeros(
  549. img_shape[::-1] + (num_coils, num_coils), dtype=ksp.dtype
  550. )
  551. for kernel in kernels:
  552. img_kernel = sp.ifft(
  553. sp.resize(kernel, ksp.shape), axes=range(-img_ndim, 0)
  554. )
  555. aH = xp.expand_dims(img_kernel.T, axis=-1)
  556. a = xp.conj(aH.swapaxes(-1, -2))
  557. AHA += aH @ a
  559. AHA *= sp.prod(img_shape) / kernel_width**img_ndim
  560. self.mps = xp.ones(ksp.shape[::-1] + (1,), dtype=ksp.dtype)
  562. def forward(x):
  563. with sp.get_device(x):
  564. return AHA @ x
  566. def normalize(x):
  567. with sp.get_device(x):
  568. return (
  569. xp.sum(xp.abs(x) ** 2, axis=-2, keepdims=True) ** 0.5
  570. )
  572. alg = sp.alg.PowerMethod(
  573. forward, self.mps, norm_func=normalize, max_iter=max_iter
  574. )
  576. super().__init__(alg, show_pbar=show_pbar)
  577. self.max_eig = np.array([alg.max_eig])
  579. self.sets = sets
  580. if self.sets > 1:
  581. U, S, VH = xp.linalg.svd(AHA, full_matrices=False)
  583. print(U.shape, S.shape, VH.shape)
  585. self.mps = U[..., :self.sets]
  586. self.max_eig = S[..., :self.sets]
  588. # print('self.mps ', self.mps.shape)
  589. # print('self.max_eig ', self.max_eig.shape)
  591. def _output(self):
  592. xp = self.device.xp
  593. with self.device:
  594. mps = []
  595. max_eig = []
  596. for s in range(self.mps.shape[-1]):
  597. # Normalize phase with respect to first channel
  598. c = self.mps.T[s]
  599. c *= xp.conj(c[0] / xp.abs(c[0]))
  601. # Crop maps by thresholding eigenvalue
  602. me = self.max_eig.T[s]
  603. c *= me > self.crop
  605. mps.append( c )
  606. max_eig.append( me )
  608. mps = xp.array(mps)
  609. max_eig = xp.array(max_eig)
  611. if self.output_eigenvalue:
  612. return mps, max_eig
  613. else:
  614. return mps
  617. def _get_regularization(ishape, regu='TIK', lamda=0,
  618. regu_kspace=False,
  619. regu_axes=[-2, -1],
  620. blk_shape=(8, 8),
  621. blk_strides=(8, 8),
  622. normalization=False,
  623. thresh='soft',
  624. deep_model=None,
  625. ro_extend_fold=1):
  626. """
  627. This function constructs regularization terms.
  629. Author:
  630. Zhengguo Tan <[email hidden]>
  631. """
  633. idx = []
  634. for n in range(-len(ishape), -1, 1):
  635. idx.append(slice(0, ishape[n], 1))
  637. Nx_ext = ishape[-1]
  638. Nx = Nx_ext // ro_extend_fold
  640. Slices = []
  641. for n in range(ro_extend_fold):
  642. idn = idx.copy()
  643. idn.append(slice(n * Nx, (n+1) * Nx, 1))
  645. Slices.append(sp.linop.Slice(ishape, tuple(idn)))
  647. trafos = sp.linop.Vstack(Slices, axis=0)
  650. if regu_kspace is True:
  651. trafos = sp.linop.FFT(trafos.oshape, axes=[-2, -1]) * trafos
  652. else:
  653. trafos = sp.linop.Identity(trafos.oshape) * trafos
  656. if regu == 'TIK':
  658. proxg = None
  659. strength = lamda
  661. elif regu == 'LLR':
  663. blk_shape = list(blk_shape)
  664. blk_strides = list(blk_strides)
  666. for ind in range(len(blk_shape)):
  667. if ishape[ind-2] <= blk_shape[ind-2]:
  668. blk_shape[ind-2] = ishape[ind-2] // 3
  669. blk_strides[ind-2] = ishape[ind-2] // 3
  671. proxg = sp.prox.LLRL1Reg(trafos.oshape, lamda,
  672. blk_shape=blk_shape,
  673. blk_strides=blk_strides,
  674. normalization=normalization)
  676. # the lamda is passed into prox,
  677. # so no need for strength here.
  678. strength = 0
  680. elif regu == 'SLR':
  682. blk_shape = list(blk_shape)
  683. blk_strides = list(blk_strides)
  685. proxg = sp.prox.SLRMCReg(trafos.oshape, lamda,
  686. blk_shape=blk_shape,
  687. blk_strides=blk_strides,
  688. thresh=thresh, verbose=True)
  690. strength = 0
  692. elif regu == 'TV':
  694. T = sp.linop.FiniteDifference(trafos.oshape, axes=regu_axes)
  695. trafos = T * trafos
  697. proxg = sp.prox.L1Reg(trafos.oshape, lamda)
  698. strength = 0
  700. elif (regu == 'DAE') and (deep_model is not None):
  702. proxg = sp.prox.DAEReg(trafos.oshape, lamda, deep_model)
  703. strength = 0
  705. g = None
  707. # TODO: It is difficult to define g here, because
  708. # proxg functions like SLR and LLR contain linear transformations
  709. # inside their prox implementation.
  711. # if proxg is None:
  712. # g = None
  713. # else:
  714. # def g(input):
  715. # device = sp.get_device(input)
  716. # xp = device.xp
  717. # with device:
  718. # return lamda * xp.sum(xp.abs(input)).item()
  720. return trafos, proxg, g, strength
  723. class HighDimensionalRecon(sp.app.LinearLeastSquares):
  724. r"""High-Dimensional MRI Reconstruction.
  726. Considers the problem
  728. .. math::
  729. \min_x \frac{1}{2} \| P F S M x - y \|_2^2 +
  730. \frac{\lambda}{2} R(x)
  732. where P is the sampling operator,
  733. F is the Fourier transform operator,
  734. S is the SENSE operator (multiplication with coil sensitivity maps),
  735. M is the modeling operator, which can be
  736. - subspace matrix,
  737. - phase matrix,
  738. - etc.
  739. x is the subspace coefficient maps, and
  740. y is the k-space measurements.
  742. R(x) is the regularization term.
  743. (1) TIK: Tikhonov L2.
  744. R(x) = \| x \|_2^2
  745. (2) LLR: Locally Low Rank.
  746. R(x) = \| G(x) \|_1,
  747. where G is the transformation function.
  748. (3) SLR: Structured Low Rank.
  749. (4) TV: total variation.
  751. Args:
  752. y (array): measured k-space data.
  753. mps (array): coil sensitivity maps.
  754. weights (array): forward model weighting.
  755. coord (array): k-space non-Cartesian trajectory.
  756. model_water_fat (bool): model water/fat 2-compartment signal. [default: False]
  757. B0 (float): B0 field strength (T). [default: 3.0]
  758. TE (1D array): echo time array (ms).
  760. basis (2D array): temporal subspace matrix.
  762. phase_shot (array): shot-to-shot phase maps.
  763. combine_shot (bool): reconstructed images (x) are shot-combined,
  764. i.e., x.shape[DIM_SEG] = 1. [default: False]
  766. phase_echo (array): echo-to-echo phase maps.
  767. combine_echo (bool): reconstructed images (x) are echo-combined,
  768. i.e., x.shape[DIM_ECHO] = 1. [default: False]
  770. phase_sms (array): multi-band phase maps.
  772. scale (float): scaling factor of y. [default: 0 - no scaling]
  774. regu (str): regularization type.
  775. [choices: 'TIK' (default), 'LLR', 'TV']
  777. regu_kspace (bool): regularize the FFT of x. [default: False]
  778. This is meant for structural low-rank regularization
  780. regu_axes (list of int): on which axes the regularization is applied.
  781. [default: [-2, -1]]
  783. x (array): initialization.
  785. blk_shape (list of int): block shape in LLR. [default: [8, 8]]
  786. blk_strides (list of int): block strides in LLR. [default: [8, 8]]
  787. normalization (bool): apply normalization in LLR. [default: False]
  789. thresh (str): threshold type. [choices: 'soft' (default), 'hard']
  791. max_iter (int): maximal number of iterations (ADMM outer iterations). [default: 50]
  792. max_cg_iter (int): maximal number of CG iterations. [default: 30]
  793. solver (str): solver. [choices: 'ADMM', None]
  795. ro_extend_fold (int): reconstruct SMS data using the readout-extended-FOV concept.
  796. Please refer to https://doi.org/10.1002/mrm.25897 and sigpy.mri.muse.
  798. device (Device): [choices: sp.Device(0) - GPU, sp.Device(-1) - CPU]
  799. **kwargs: ...
  801. Author:
  802. Zhengguo Tan <[email hidden]>
  804. References:
  805. * Lustig M, Donoho DL, Pauly JM.
  806. Sparse MRI: The application of compressed sensing for rapid MRI.
  807. Magn Reson Med 2007;58:1182-1195.
  809. * Block KT, Uecker M, Frahm J.
  810. Undersampled radial MRI with multiple coils.
  811. Iterative image reconstruction using a total variation constraint.
  812. Magn Reson Med 2007;57:1086-1098.
  814. * Lustig M, Donoho DL, Santos JM, Pauly JM.
  815. Compressed sensing MRI.
  816. IEEE Signal Process Mag 2008;25:72-82.
  817. """
  818. def __init__(self, y, mps, lamda=0,
  819. weights=None, coord=None,
  820. model_water_fat: bool = False,
  821. B0: float = 3.0, TE=None,
  822. basis=None,
  823. phase_shot=None, combine_shot=False,
  824. phase_echo=None, combine_echo=False,
  825. phase_sms=None,
  826. scale=0, regu='TIK', regu_kspace=False,
  827. regu_axes=[-2, -1], x=None,
  828. blk_shape=(8, 8), blk_strides=(8, 8),
  829. normalization=False,
  830. deep_model=None,
  831. thresh='soft', max_iter=50,
  832. ro_extend_fold=1, solver=None,
  833. device=sp.cpu_device, show_pbar=True,
  834. **kwargs):
  836. if y.ndim == 6:
  837. y = y[:, :, None, :, :, :, :]
  838. print('> reshape y to 7 dimensions: ', y.shape)
  840. if weights is not None and weights.ndim == 6:
  841. weights = weights[:, :, None, :, :, :, :]
  842. print('> reshape weights to 7 dimensions: ', weights.shape)
  844. # k-space data in accordance with sigpy/mri/dims.py
  845. Ntime, Nseg, Necho, Ncoil, Nz = y.shape[:-2]
  846. Ny, Nx = mps.shape[-2:]
  848. assert(1 == Nz) # deal with collapsed y even for SMS
  850. if phase_sms is not None:
  851. MB = phase_sms.shape[DIM_Z]
  852. else:
  853. MB = 1
  855. # start to construct image shape
  856. img_shape = [1] + [MB] + [Ny] + [Nx]
  858. if model_water_fat is True:
  860. zm = nlop.calc_fat_modu(np.array(TE) * 1e-3, B0=B0)
  861. zm = sp.to_device(zm, device)
  862. N_zm_echo, N_zm_parm = zm.shape
  864. ishape = [N_zm_parm] + img_shape
  866. else:
  868. if combine_echo is True:
  869. ishape = [1] + img_shape
  870. else:
  871. ishape = [Necho] + img_shape
  873. if combine_shot is True:
  874. ishape = [1] + ishape
  875. else:
  876. ishape = [Nseg] + ishape
  878. if basis is not None:
  879. N_basis_contrast, N_basis_coef = basis.shape
  880. assert(N_basis_contrast == Ntime)
  882. ishape = [N_basis_coef] + ishape
  883. else:
  884. ishape = [Ntime] + ishape
  886. # %% construct MRI forward model
  888. #### case 0. water/fat modeling
  889. if model_water_fat is True:
  891. T1 = sp.linop.Transpose(ishape, [-5, -6, -7, -4, -3, -2, -1])
  892. R1 = sp.linop.Reshape([T1.oshape[0], np.prod(T1.oshape[1:])], T1.oshape)
  893. MM = sp.linop.MatMul(R1.oshape, zm)
  894. R2 = sp.linop.Reshape([N_zm_echo] + list(T1.oshape[1:]), MM.oshape)
  895. T2 = sp.linop.Transpose(R2.oshape, [-5, -6, -7, -4, -3, -2, -1])
  896. WF = T2 * R2 * MM * R1 * T1
  898. else:
  899. WF = sp.linop.Identity(ishape)
  902. #### case 1. subspace modeling
  903. if basis is not None:
  905. sub_ishape = [N_basis_coef] + [np.prod(WF.oshape[1:])]
  906. # TODO: may require more Reshape linops to split between time and echo
  907. sub_oshape = [Ntime] + list(WF.oshape[1:])
  909. B1 = sp.linop.Reshape(sub_ishape, WF.oshape)
  910. B2 = sp.linop.MatMul(B1.oshape, basis)
  911. B3 = sp.linop.Reshape(sub_oshape, B2.oshape)
  913. B = B3 * B2 * B1
  915. else:
  917. B = sp.linop.Identity(WF.oshape)
  920. #### case 2. echo phase modeling
  921. if phase_echo is not None:
  923. assert Necho == phase_echo.shape[DIM_ECHO]
  924. ECO = sp.linop.Multiply(B.oshape, phase_echo)
  926. else:
  928. # assert Necho == 1
  929. ECO = sp.linop.Identity(B.oshape)
  932. #### case 3. shot/segment phase modeling
  933. if phase_shot is not None:
  935. assert Nseg == phase_shot.shape[DIM_SEG]
  936. SEG = sp.linop.Multiply(ECO.oshape, phase_shot)
  938. else:
  940. SEG = sp.linop.Identity(ECO.oshape)
  943. #### parallel imaging modeling
  945. # only one set of coil sensitivity maps for all images
  946. assert(y.shape[DIM_COIL] == mps.shape[DIM_COIL])
  948. S = sp.linop.Multiply(SEG.oshape, mps)
  950. # FFT
  951. if coord is None:
  952. self._check_two_shape(list(y.shape[DIM_Y:]), mps.shape[DIM_Y:])
  953. F = sp.linop.FFT(S.oshape, axes=range(-2, 0))
  955. else:
  956. F = sp.linop.HDNUFFT(S.oshape, coord)
  959. # SMS
  960. if phase_sms is not None:
  962. self._check_two_shape(list(phase_sms.shape), mps.shape[DIM_Z:])
  964. PHI = sp.linop.Multiply(F.oshape, phase_sms)
  965. SUM = sp.linop.Sum(PHI.oshape, axes=(DIM_Z, ), keepdims=True)
  967. M = SUM * PHI
  969. else:
  971. M = sp.linop.Identity(F.oshape)
  974. # compute k-space sampling mask
  975. if weights is None:
  976. weights = _estimate_weights(y, weights, coord, coil_dim=DIM_COIL)
  978. y = sp.to_device(y * weights, device=device)
  980. W = sp.linop.Multiply(M.oshape, weights)
  982. # sum along the echo dimension
  983. if Necho == 1 and phase_echo is not None:
  985. SUM = sp.linop.Sum(W.oshape, axes=(DIM_ECHO, ),
  986. keeydims=True)
  988. else:
  990. SUM = sp.linop.Identity(W.oshape)
  992. #### chain models
  993. A = SUM * W * M * F * S * SEG * ECO * B * WF
  995. print('>>> A oshape: ', A.oshape, ' ishape: ', A.ishape)
  998. # %% scale y
  999. if scale == 0:
  1000. device = sp.get_device(y)
  1001. xp = device.xp
  1002. with device:
  1003. x0 = A.H(y)
  1004. x1 = np.linalg.norm(x0, axis=0)
  1005. x2 = np.linalg.norm(x1, axis=0)
  1006. x1 = xp.sort(x2.flatten())
  1007. x_med = abs(x1[len(x1)//2])
  1008. x_p90 = abs(x1[int(len(x1) * 0.9)])
  1009. x_max = abs(x1[-1])
  1010. if (x_max - x_p90) < 2 * (x_p90 - x_med):
  1011. scale = x_p90
  1012. else:
  1013. scale = x_max
  1015. # print('scale: ' + str(scale))
  1016. y /= scale
  1019. # %% initialization
  1020. if x is not None:
  1021. x = sp.to_device(x, device=device)
  1024. # %% regularization
  1025. trafos, proxg, g, strength = _get_regularization(
  1026. A.ishape, regu=regu, lamda=lamda,
  1027. regu_kspace=regu_kspace, regu_axes=regu_axes,
  1028. blk_shape=blk_shape, blk_strides=blk_strides,
  1029. normalization=normalization,
  1030. thresh=thresh, deep_model=deep_model,
  1031. ro_extend_fold=ro_extend_fold)
  1033. if solver == 'ADMM':
  1034. show_pbar = False
  1036. super().__init__(A, y, x=x, lamda=strength,
  1037. G=trafos, proxg=proxg, g=g, scale=scale,
  1038. max_iter=max_iter, solver=solver,
  1039. show_pbar=show_pbar, **kwargs)
  1042. def _check_two_shape(self, ref_shape, dst_shape):
  1043. for i1, i2 in zip(ref_shape, dst_shape):
  1044. if (i1 != i2):
  1045. raise ValueError('shape mismatch for ref {ref}, got {dst}'.format(
  1046. ref=ref_shape, dst=dst_shape))
  1049. class ModelDiffRecon(sp.app.NonLinearLeastSquares):
  1050. r"""Model-based Diffusion Reconstruction.
  1052. Consider the problem
  1054. .. math::
  1055. \min_x \frac{1}{2} \| P F S B x - y \|_2^2 +
  1056. \frac{\lambda}{2} R(x)
  1058. where P is the sampling operator,
  1059. F is the Fourier transform operator,
  1060. S is the SENSE operator (multiplication with coil sensitivity maps),
  1061. B is the non-linear diffusion model,
  1062. x is the diffusion model parameters, [b0, DTI or DKI], and
  1063. y is the k-space measurements.
  1065. Therefore, The operation B x outputs
  1066. non-diffusion-weighted image (b0) and
  1067. diffusion-weighted images (DWI).
  1069. Args:
  1070. y (array): Observation.
  1071. image_shape (list): Shape of Solution.
  1072. coil (array): Coil sensitivity maps.
  1073. coil_dim (int): Dimension of coil sensitivity in y.
  1074. coord (array): Sampling trajectory.
  1075. x (array): Solution.
  1076. x0 (array): Bias for regularization.
  1077. dwi_phase (array): Phase of diffusion weighted images.
  1078. weights (array): Sampling pattern.
  1079. encode_matrix (array): Diffusion encoding matrix (B).
  1080. max_iter (int): Maximum number of iterations.
  1081. lamda (float): Regularization strength (\rho in ADMM).
  1082. redu (float): Reduction factor along iterations.
  1083. gn_iter (int): Gauss-Newton iterations.
  1084. inner_iter (int): Inner iterations.
  1085. inner_tol (float): Inner tolerance.
  1086. G (None or Linop): Regularization linear operator.
  1087. proxg (None or Prox): Proximal operator for regularization.
  1088. device (Device): Use CPU or GPU.
  1090. Author:
  1091. Zhengguo Tan <[email hidden]>
  1093. References:
  1094. Welsh C. L., DiBella E. V. R., Adluru G., Hsu E. W. (2013).
  1095. Model-based reconstruction of undersampled diffusion tensor k-space data.
  1096. Magn. Reson. Med., 70, 429-440.
  1098. Knoll F., Raya J. G., Halloran R. O., Baete S., Sigmund E., Bammer R., Block K. T., Otazo R., Sodickson D. K. (2015).
  1099. A model-based reconstruction for undersampled radial spin-echo DTI with variational penalties on the diffusion tensor.
  1100. Magn. Reson. Med., 28, 353-366.
  1102. Dong Z., Dai E., Wang F., Zhang Z., Ma X., Yuan C., Guo H. (2018).
  1103. Model-based reconstruction for simultaneous multislice and parallel imaging accelerated multishot DTI.
  1104. Med. Phys., 45, 3196-3204.
  1106. """
  1107. def __init__(self, y, image_shape,
  1108. coil=None, coil_dim=-3, coord=None,
  1109. x=None, x0=None,
  1110. dwi_phase=None, weights=None,
  1111. encode_matrix=None,
  1112. max_iter=6, lamda=1, redu=2,
  1113. gn_iter=6, inner_iter=100, inner_tol=0.01,
  1114. G=None, proxg=None,
  1115. device=sp.cpu_device,
  1116. **kwargs):
  1118. y = sp.to_device(y, device=device)
  1120. xp = device.xp
  1122. with device:
  1123. weights = _estimate_weights(y, weights, coord, coil_dim=coil_dim)
  1125. A = nlop.Diffusion(image_shape, encode_matrix, coil,
  1126. dwi_phase=dwi_phase, weights=weights)
  1128. if x is None:
  1129. with device:
  1130. x_b0 = xp.ones([1] + list(image_shape[1:]), dtype=y.dtype) * 1E-5
  1131. x_D = xp.zeros([image_shape[0]-1] + list(image_shape[1:]), dtype=y.dtype)
  1132. x = xp.concatenate((x_b0, x_D))
  1133. else:
  1134. with device:
  1135. x = sp.to_device(x, device=device)
  1137. if x0 is None:
  1138. with device:
  1139. x0 = 0.9 * x
  1140. else:
  1141. with device:
  1142. x0 = sp.to_device(x0, device=device)
  1144. super().__init__(A, y, x=x, x0=x0,
  1145. max_iter=max_iter,
  1146. lamda=lamda, redu=redu,
  1147. gn_iter=gn_iter,
  1148. inner_iter=inner_iter,
  1149. inner_tol=inner_tol,
  1150. G=G, proxg=proxg,
  1151. **kwargs)

app.py at commit b757125, under BSD-3-Clause · at the source

Overview

Authors: Julius Glaser1, Zhengguo Tan2,3, Annika Hofmann3, Frederik Bernd Laun1,3, Florian Knoll3
ORCID iDs: Julius Glaser, Zhengguo Tan, Annika Hofmann, Frederik Bernd Laun, Florian Knoll
  1. Institute of Radiology, University Hospital Erlangen, Friedrich‐Alexander‐Universität Erlangen‐Nürnberg, Erlangen, Germany
  2. Michigan Institute for Imaging Technology and Translation (MIITT), Radiology, University of Michigan, Ann Arbor, Michigan, USA
  3. Department Artificial Intelligence in Biomedical Engineering (AIBE), Friedrich‐Alexander‐Universität Erlangen‐Nürnberg, Erlangen, Germany
Institutions: Friedrich-Alexander-Universität Erlangen-Nürnberg (Germany); Universitätsklinikum Erlangen (Germany); University of Michigan (United States)
Journal: Magnetic resonance in medicine, volume 96, issue 5, pages 2359-2369
Dates: received 19 December 2025; accepted 20 June 2026; published online 4 August 2026; in print November 2026
Type: Other · Language: English
License: CC BY
Identifiers: DOI 10.1002/mrm.70496 · PMID 42548198 · PMCID PMC13527252 · OpenAlex W7172408551
Open access: hybrid, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), methods / tools (subfield)
Methods: Statistics, fMRI & imaging, Physiology & signal measures
Keywords: deep learning, deep nonlinear subspace, denoising auto‐encoder, diffusion weighted magnetic resonance imaging, joint reconstruction
MeSH: Brain*, Diffusion Magnetic Resonance Imaging*, Image Processing, Computer-Assisted*, Algorithms, Autoencoder, Humans, Nonlinear Dynamics, Signal-To-Noise Ratio (* major topic)
Topic: Advanced Neuroimaging Techniques and Applications (Radiology, Nuclear Medicine and Imaging, Medicine), according to OpenAlex
Funding: Deutsche Forschungsgemeinschaft (513220538, 440719683, 512819079, 500888779); Friedrich-Alexander-Universität Erlangen-Nürnberg (b143dc)
Citations: not cited yet (Europe PMC); 45 references in the paper

Abstract

Purpose: To present a novel, nonlinear subspace modeling and joint k–q‐space reconstruction technique for high‐resolution, multi‐band, multi‐shell diffusion‐weighted imaging (DWI).

Methods: High b‐value (> 1000 s/mm2), high resolution DWI has the drawback of generally low signal‐to‐noise ratios (SNRs). We present an approach that leverages a denoising autoencoder (DAE) to learn a latent subspace from biophysically simulated diffusion‐weighted signals. The decoder of this network is then used in the forward operator of the image reconstruction process. The decoded latent images are scaled by the b0 image, phase is added and processed as regular DWI images with the forward operator for multi‐shot, multicoil, multi‐slice, k–q‐undersampled acquisition schemes. The performance is investigated with a multi‐shell, multi‐direction imaging brain scan and compared to the results of the multiplexed sensitivity‐encoding (MUSE) reconstruction and locally low‐rank (LLR) regularized reconstruction. The results are further validated by a bias and precision analysis of reconstructed fiber directions.

Results: Comparing the reconstructed data using the proposed method shows improved noise suppression compared to MUSE and more details than LLR‐reconstructed images. Specifically, in the higher b‐value domain, the reconstruction results show improved detectability of small structures. This bias and precision analysis showed minimal bias introduction, but higher precision with the proposed method.

Conclusion: Our method combines deep learning, latent signal modeling, joint k–q‐space reconstruction, and biophysical simulation for diffusion data and shows strong noise suppression and a high degree of detail in reconstructed diffusion‐weighted images.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 5 matches between paragraphs and lines of code.

ZhengguoTan/sigpy

License: BSD-3-Clause
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: b7571257012512926172df00e66537fc618d90b7, 22 September 2026
Languages: Python (100), Shell (3)
Size: 142 files, 103 scripts
Software Heritage: not archived
Found in: the text, “ENDNOTES”
Holds: README, license file, environment (pyproject.toml, requirements.txt, setup.cfg, setup.py, conda.recipe/conda_build_config.yaml, docs/requirements.txt), tests, continuous integration, documentation
Not found: CITATION.cff
Tools: NumPy (83 files), CuPy (11 files), PyTorch (8 files), SciPy (7 files), Numba (6 files), Matplotlib (3 files), PyWavelets (2 files), h5py (1 file), pydicom (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
105 files
At the source: github.com/ZhengguoTan/sigpy

JuliusGlaser/LASER

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: dbc143a981c36efb75f4215ae1e62e9e7fe5fc10, 4 February 2026
Languages: Python (36), Jupyter (2)
Size: 85 files, 38 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README, environment (code/pyproject.toml, code/requirements.txt), 2 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (27 files), h5py (18 files), PyTorch (13 files), Matplotlib (8 files), DIPY (5 files), NiBabel (5 files), CuPy (3 files), MRtrix3 (1 file), Numba (1 file), Pillow (1 file), SciPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
39 files
At the source: github.com/JuliusGlaser/LASER

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 141 scripts, each with its path and the digest of its content;
  • 5 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data Availability Statement

The data that support the findings of this study are available on request from the corresponding author. The data are not publicly available due to privacy or ethical restrictions. Our source code is a publicly available under https://github.com/JuliusGlaser/LASER.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 3, 28 September 2026

  • Publisher: n/a → Wiley

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 5 authors, 5 keywords, 8 MeSH terms, 2 funders, 38 references.

Cite

This paper

Glaser, J., Tan, Z., Hofmann, A., Laun, F. B., & Knoll, F. (2026). A Deep Nonlinear Subspace Modeling and Reconstruction for Diffusion-Weighted Imaging Using Denoising Auto-Encoder. Magnetic resonance in medicine, 96(5), 2359-2369. https://doi.org/10.1002/mrm.70496

BibTeX

@article{glaser2026deep,
author = {Glaser, Julius and Tan, Zhengguo and Hofmann, Annika and Laun, Frederik Bernd and Knoll, Florian},
title = {{A Deep Nonlinear Subspace Modeling and Reconstruction for Diffusion-Weighted Imaging Using Denoising Auto-Encoder}},
journal = {Magnetic resonance in medicine},
year = {2026},
month = aug,
volume = {96},
number = {5},
pages = {2359--2369},
publisher = {Wiley},
issn = {0740-3194},
doi = {10.1002/mrm.70496},
url = {https://doi.org/10.1002/mrm.70496},
pmid = {42548198},
pmcid = {PMC13527252}
}

RIS

TY - JOUR
AU - Glaser, Julius
AU - Tan, Zhengguo
AU - Hofmann, Annika
AU - Laun, Frederik Bernd
AU - Knoll, Florian
TI - A Deep Nonlinear Subspace Modeling and Reconstruction for Diffusion-Weighted Imaging Using Denoising Auto-Encoder
T2 - Magnetic resonance in medicine
J2 - Magn Reson Med
PY - 2026
DA - 2026/08/04
VL - 96
IS - 5
SP - 2359
EP - 2369
SN - 0740-3194
PB - Wiley
DO - 10.1002/mrm.70496
UR - https://doi.org/10.1002/mrm.70496
LA - en
ER -

CSL-JSON

{
"id": "10.1002/mrm.70496",
"type": "article-journal",
"title": "A Deep Nonlinear Subspace Modeling and Reconstruction for Diffusion-Weighted Imaging Using Denoising Auto-Encoder",
"container-title": "Magnetic resonance in medicine",
"author": [
{
"family": "Glaser",
"given": "Julius"
},
{
"family": "Tan",
"given": "Zhengguo"
},
{
"family": "Hofmann",
"given": "Annika"
},
{
"family": "Laun",
"given": "Frederik Bernd"
},
{
"family": "Knoll",
"given": "Florian"
}
],
"container-title-short": "Magn Reson Med",
"volume": "96",
"issue": "5",
"page": "2359-2369",
"DOI": "10.1002/mrm.70496",
"PMID": "42548198",
"PMCID": "PMC13527252",
"ISSN": "0740-3194",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/mrm.70496",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
4
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1002/mrm.70336 [code]
Offline Reconstruction of Diffusion MRI Acquisitions for Comparison Between Complex PCA-Based and AI-Based Denoising.
Journal: Magnetic resonance in medicine
In common: DIPY, MRtrix3, NiBabel, 3 other tools, methods / tools, structural MRI / diffusion, 6 references
[2] doi:10.1038/s41592-026-03057-2 [code]
CREsted: modeling genomic and synthetic cell-type-specific enhancers across tissues and species.
Journal: Nature methods
In common: PyWavelets, CuPy, Numba, 6 other tools, methods / tools
[3] doi:10.1038/s41598-026-39162-7 [code]
White matter microstructure differences in obstructive sleep apnea severity groups assessed by diffusion tensor metrics and biophysical modeling.
Journal: Scientific reports
In common: DIPY, MRtrix3, Numba, 3 other tools, structural MRI / diffusion, 2 references
[4] doi:10.1162/imag.a.1341 [code]
Massively parallelized brain tractography using compute clusters, supercomputers, and graphics processing units.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: DIPY, Numba, NiBabel, 3 other tools, methods / tools, structural MRI / diffusion, 3 references
[5] doi:10.1016/j.isci.2026.116671 [code]
A high-resolution functional network-organized atlas of human superficial white matter from ultra-high-field diffusion MRI.
Journal: iScience
In common: DIPY, MRtrix3, h5py, 5 other tools, methods / tools, structural MRI / diffusion
[6] doi:10.1162/imag.a.1276 [code]
High-resolution whole-brain magnetic resonance spectroscopic imaging in youth at risk for psychosis.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: CuPy, DIPY, Numba, 5 other tools
[7] doi:10.1371/journal.pone.0349951
Disentangling crossing fibers with advanced dMRI methods reveals bundle-specific degeneration across the visual system in asymmetric glaucoma.
Journal: PloS one
In common: structural MRI / diffusion, 8 references
[8] doi:10.1371/journal.pcbi.1014555 [code]
Body surface potential driven personalisation of electrophysiological digital twins in hypertrophic cardiomyopathy.
Journal: PLoS computational biology
In common: CuPy, pydicom, Pillow, 5 other tools, structural MRI / diffusion
[9] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: CuPy, pydicom, Numba, 5 other tools
[10] doi:10.64898/2026.03.04.709502 [code]
Distributed hierarchical filters partition the Danionella vocal repertoire
Journal: bioRxiv (preprint)
In common: CuPy, pydicom, Numba, 5 other tools

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.