I will conduct a deep investigation into how deep unrolling (deep unfolding) methods integrate with ADMM and LASSO for solving inverse problems in NLOS, CT, and MRI reconstruction. The research will focus on:

• Mathematical Formulation: High-level explanations of inverse problem models and how deep unrolling approximates iterative solvers.

• Algorithmic Implementation: How neural networks integrate with ADMM and LASSO-based optimization.

• Code-Level Analysis: PyTorch implementations from open-source repositories.

• Performance Evaluation: Comparison between deep unrolling methods and traditional solvers in terms of accuracy, convergence speed, and robustness.

• Datasets: Identification of benchmark datasets for NLOS, CT, and MRI testing.

• Sources: Top conferences and major journals, prioritizing those with GitHub links.

Deep Unrolling with ADMM and LASSO in NLOS, CT, and MRI Inverse Problems

Mathematical Formulation of Inverse Problems

Inverse Problems in NLOS, CT, and MRI: Non-line-of-sight (NLOS) imaging, X-ray computed tomography (CT), and magnetic resonance imaging (MRI) can all be framed as inverse problems. Each has a forward model linking hidden object properties to measured data, and the goal is to invert this model to recover an image. NLOS imaging measures time-resolved light after multiple bounces to reconstruct a hidden scene – a highly ill-posed problem due to severe loss of information and noise (different hidden scenes can produce the same measurement)​DIGLIB.EG.ORG . CT reconstruction seeks to recover an interior attenuation map from projection data (sinograms) via the Radon transform (i.e. )​UNI-BREMEN.DE . Because the Radon transform is a compact operator and only finitely many angles are measured, the inverse problem is ill-posed​UNI-BREMEN.DE , especially in limited-view or low-dose CT scenarios. MRI reconstruction involves recovering an image from undersampled -space (Fourier) measurements. Accelerating MRI by undersampling makes the inverse problem ill-posed, as too few measurements lead to infinitely many solutions. Compressed sensing (CS) theory addresses this by imposing priors like sparsity (e.g. in wavelet domain) to constrain the solution​ARXIV.ORG .

Role of ADMM and LASSO in Sparse, Ill-posed Problems: Ill-posed inverse problems are often tackled by formulating a regularized optimization. A common example is the LASSO (Least Absolute Shrinkage and Selection Operator), which uses an -norm penalty to promote sparsity in the solution. For instance, one may solve for CT/MRI (sparsity in the image or transform domain) or use an prior on the hidden scene in NLOS to exploit sparsity of reflectance. The Alternating Direction Method of Multipliers (ADMM) is a popular algorithm to solve such problems with composite objectives. ADMM splits the problem into subproblems that are easier to handle – e.g. a least-squares data fidelity update and a separate proximal update for the regularization (soft-thresholding)​WEB.STANFORD.EDU . In effect, ADMM transforms a difficult global problem into alternating updates that converge to the solution under broad conditions. For LASSO and related sparse recovery tasks, ADMM is advantageous because each iteration involves a simple shrinkage (thresholding) step for the sparsity prior​MATH.CUHK.EDU.HK . This makes it well-suited for large-scale imaging problems. Overall, ADMM (and similar proximal algorithms) provide a physics-guided iterative framework to enforce data fidelity and sparsity constraints, helping recover images from limited or noisy measurements.

Deep Unrolling as Learned Iterative Optimization: Deep unrolling (or unfolding) is a technique that bridges model-based iterations and data-driven learning. In deep unrolling, one starts from a traditional iterative algorithm (like ADMM or ISTA used for solving the above inverse problems) and unrolls its update steps into the layers of a deep neural network. The fixed iterations of the original algorithm become a sequential network of a corresponding number of layers. Importantly, certain parameters of the algorithm (e.g. step sizes, regularization weights, thresholds) are treated as learnable parameters to be optimized during training. This way, the network mimics the physics-based solver but can learn an optimal strategy for convergence from data. Deep unrolled networks thereby approximate iterative optimization while leveraging training data to achieve faster or better reconstruction. They maintain interpretability (each layer has a known meaning) and often require far fewer iterations to reach high-quality solutions . In summary, the mathematical models (forward operators for NLOS, CT, MRI and sparsity priors) remain at the core, but deep unrolling introduces learnable components within the iterative solution process to handle ill-posedness more effectively.

Algorithmic Implementation of Deep Unrolling with ADMM

Unrolling ADMM-Based Solvers: Deep unrolling techniques often take inspiration from ADMM when dealing with LASSO-like formulations. For example, the ADMM algorithm for a sparse inverse problem might involve: (1) a data update solving a least-squares problem (e.g. using the measured data to update the image), (2) a sparsity proximal update applying soft-thresholding (shrinkage) to enforce sparsity, and (3) a dual variable update. In a deep unrolled network, this sequence is mapped to network layers. Each unrolling stage (layer or group of layers) performs operations analogous to one ADMM iteration . Trainable parameters can be introduced, such as learnable thresholds or relaxation parameters at each stage. Yan et al.’s ADMM-CSNet is a concrete example: it unrolls the ADMM solver for compressive sensing, with each network layer implementing the analytical steps of ADMM while allowing certain parameters (like the penalty parameter or threshold values) to be tuned by learning . This combination retains the structured updates of ADMM but adapts them for better performance on natural images. In practice, unrolled ADMM networks often limit the number of stages (e.g. 5–15 iterations unrolled) to balance complexity and performance, since a fully convergent ADMM (tens of iterations) may not be needed once learning finds a good set of parameters.

Neural Networks Approximating Iterative Solvers: In deep unrolling, neural network components are sometimes inserted to replace or augment specific steps of the algorithm. A common approach is to replace the “proximal operator” (which enforces the prior) with a small learned network. For instance, instead of a simple soft-threshold, one could use a convolutional neural network as a learned denoiser or projector in each iteration. Many architectures have been proposed along these lines. ISTA-Net (Zhang et al. 2018) unrolls the Iterative Shrinkage-Thresholding Algorithm (ISTA) for sparse image reconstruction, with learnable transforms and thresholds at each layer​MDPI.COM . ADMM-Net and ADMM-CSNet (Yang et al. 2016, 2018) unroll ADMM for MRI and general compressive imaging, learning the regularization parameters and achieving significant speed-ups​GITHUB.COM . Learned Primal-Dual (Adler and Öktem 2018) unrolls a primal-dual hybrid gradient method for CT, with learnable operator blocks that handle forward and backward projection updates​MDPI.COM . In all these cases, the iterative solver’s mathematical operations (e.g. Fourier transforms in MRI, Radon projections in CT, light transport in NLOS) are embedded in the network’s layers, ensuring that physics constraints are hard-wired. The neural network introduces flexibility through trainable weights that can, for example, adapt the strength of regularization per iteration or learn an enhanced prior beyond simple sparsity. This yields an interpretable yet trainable system: as one paper puts it, unrolled networks “incorporate the forward model of the imaging system…and [replace] one or more of its steps with a neural network,” then train by unrolling for a fixed number of steps​ARXIV.ORG . Essentially, the neural network learns to optimize – it mimics the trajectory of an iterative algorithm but in a data-driven manner.

Deep Learning vs. Analytical Approaches: Compared to purely analytical solvers, deep unrolled methods offer a trade-off between domain knowledge and data adaptation. Traditional algorithms (like ADMM, FISTA, or iterative ART for CT) rely on manually chosen parameters and often need many iterations for high accuracy. They are generic and can be applied to any new data if one can tune the hyperparameters, but they don’t learn from examples. Deep unrolling infuses learning into these iterations: the algorithm’s structure prevents the network from straying far from feasible solutions, while learning allows cutting down iteration count and adjusting to the characteristics of training data. This often yields faster convergence and higher accuracy . For example, ADMM-CSNet was shown to reconstruct images with the same accuracy using 10% fewer measurements than standard iterative methods and to run ~40× faster than a traditional algorithm on compressive sensing tasks . In CT reconstruction, unrolled model-based networks have outperformed conventional iterative reconstruction in low-dose or few-view settings in terms of PSNR/SSIM, since the network can suppress noise and artifacts more effectively by learning from training images . Moreover, unrolled models tend to be more interpretable than generic deep networks (like pure U-Nets) because each layer corresponds to a known operation, making it easier to trust and analyze the reconstruction process . However, there are also trade-offs: deep models require a representative training dataset and may generalize poorly outside the training distribution. If the noise level, sampling pattern, or object characteristics change, a network might not perform optimally unless retrained or designed for robustness. In a reported case, a top-performing MRI reconstruction network failed to reconstruct critical details when the test data had a slightly different noise distribution than what it saw in training​ARXIV.ORG . Traditional solvers, in contrast, can handle such changes by re-tuning parameters (since they don’t learn specific features, they inherently apply the same physics prior to any data). Researchers are actively addressing these issues, for example by incorporating uncertainty modeling or robust training into unrolled networks. In summary, deep unrolling marries the reliability of physics-based algorithms with the adaptivity of deep learning – often yielding superior speed and accuracy on benchmark tasks – but care must be taken to ensure they remain robust and generalizable beyond the training set.

Code-Level Analysis and Implementation Details

Open-Source Implementations: The growing interest in deep unfolding has led to numerous open-source projects and research code releases. For instance, DeepInverse (deepinv) is a PyTorch-based library that provides a unified framework for inverse problems, including easy-to-build unfolded architectures for algorithms like ADMM and forward-backward splitting​GITHUB.COM . It offers predefined physics operators (for MRI, CT, deblurring, etc.) and allows researchers to quickly prototype unrolled networks. Many research papers also release code on GitHub: the authors of Deep ADMM-Net for compressive MRI (NIPS 2016) released MATLAB code for their trained model and layers (with the ADMM updates implemented as network layers)​GITHUB.COM . More recent works typically use Python frameworks – e.g., CTprintNet (an unrolled few-view CT reconstruction method) was implemented in Python using PyTorch​MDPI.COM . Similarly, a primal-dual unrolling approach for CT with a total variation prior (sometimes called PD-Net) was implemented in PyTorch in a 2021 study​AAPM.ONLINELIBRARY.WILEY.COM . These repositories often include training scripts and pretrained models, making it easier to reproduce results on common datasets. Beyond individual papers’ code, community toolboxes like MIRTorch (Michigan Image Reconstruction Toolbox) and ODL (Operator Discretization Library) have started integrating deep learning modules with classic reconstruction, enabling custom unrolled networks using their operators.

ADMM-Based Unfolding in PyTorch: Implementing an ADMM-unrolled network in PyTorch typically involves writing a custom nn.Module for each iteration (or one module that iterates internally). Each iteration might consist of operations like linear forward projection (or Fourier transform), an inverse or pseudo-inverse step (often a convolution or FFT-based solve), and a shrinkage/threshold step. These are differentiable operations (soft-threshold is differentiable almost everywhere), so the whole unrolled loop can be backpropagated through. One straightforward approach is to explicitly unroll a fixed number of iterations and treat them as sequential layers. PyTorch’s autograd will handle the gradients through all iterations. However, unrolling many iterations can lead to high memory usage because intermediate states from every layer must be stored for backpropagation. Researchers address this in code by using techniques like gradient checkpointing, which trades extra computation for lower memory by recomputing some intermediate results on the fly instead of storing them. Another approach is sequential or stage-wise training : instead of backpropagating through all unrolled iterations at once, one can train the network one iteration at a time or in small blocks, gradually building up to the full unrolled depth. This was demonstrated to drastically reduce memory requirements (by up to 98%) and enable training very deep unrolled models that were previously infeasible​PMC.NCBI.NLM.NIH.GOV . For example, in 3D imaging (where each “image” is a volume, greatly increasing memory use), a sequential training strategy allowed a fully unrolled 3D reconstruction network to be trained when naive end-to-end training would exhaust GPU memory​PMC.NCBI.NLM.NIH.GOV .

Efficient GPU Computation: Deep unfolding for imaging typically leverages heavy linear algebra (Fourier transforms in MRI, large matrix multiplications for CT projections, etc.), so efficient GPU utilization is critical. Implementations use batched operations and built-in primitives (like FFT routines or sparse matrix multiply) to speed up these physics-based layers. In MRI, for instance, one can implement the forward model as a fast FFT with masking of k-space samples, which PyTorch (or underlying libraries like FFTW/CuFFT) can do quickly. In CT, projection and backprojection can be the most time-consuming steps; libraries may use GPU-accelerated projectors (some researchers use custom CUDA kernels or the ASTRA toolbox via PyTorch interfaces). By integrating these with learnable CNN modules for the regularization part, the entire unrolled network runs on GPU end-to-end, avoiding slow data transfers. Memory optimization also involves using lower precision (mixed-precision training with float16) which many PyTorch frameworks support to reduce memory and increase throughput, without significant loss in reconstruction quality. Moreover, modern PyTorch allows dynamic computation graphs, so some implementations use a for-loop in the forward method to iterate through layers – this makes it easy to adjust the number of unrolled iterations as a parameter. Care is taken in such cases to ensure the loop is unrolled in the graph for backprop (PyTorch will unroll it since the loop length is fixed, resulting in the same effect as manually writing layers).

In summary, code-level best practices for deep unrolling include: using existing high-performance ops for the physics model, structuring the network in iterative blocks, managing memory via checkpointing or staged training, and leveraging GPU parallelism for heavy computations. Many open-source codes and libraries are available, lowering the barrier to implement ADMM-based unfolding for NLOS, CT, or MRI problems.

Performance Evaluation of Deep Unrolling vs Traditional Solvers

Accuracy and Reconstruction Quality: Deep unrolled methods have demonstrated excellent accuracy in reconstructing images compared to traditional solvers. By learning an optimized prior or tuning algorithm parameters, they often achieve lower error (higher PSNR, SSIM) than purely physics-based methods under the same conditions. For example, ADMM-CSNet (for compressive sensing) improved reconstruction PSNR by about 3 dB over previous state-of-the-art methods at 20% sampling . In MRI, unrolled networks like MoDL and VarNet (a variational network used in the fastMRI challenge) have been shown to recover finer details and yield more natural-looking images than conventional compressed sensing (which might leave residual artifacts or noise) – provided the test data is similar to the training distribution. In CT, unrolled approaches (e.g. learned primal-dual, ISTA-Net) have produced higher quality images from sparse-view or low-dose data than analytic algorithms (like FBP with filtering) or even hand-crafted iterative regularization (like TV minimization). They excel at suppressing noise and streak artifacts by learning from example images. That said, the ultimate accuracy can depend on training: if the network is well-trained on diverse data, it can outperform traditional methods across a range of cases; if not, there may be situations where a carefully tuned iterative method could still rival or beat the learned method (especially if the latter encounters an out-of-distribution case).

Convergence Speed and Efficiency: One of the key advantages observed in deep unrolling is faster inference – i.e., obtaining a solution in a fixed small number of network layers, rather than iterating until convergence. Traditional solvers like ADMM or conjugate gradient might need tens or hundreds of iterations for high-quality results, which can be slow (seconds or minutes for large 3D data). Unrolled networks typically cap the iterations (e.g. 10 iterations unrolled) and learn to make each iteration as effective as possible . The result is a huge speed-up at runtime. Empirical studies show large gains: for instance, a learned ADMM network was ~40 times faster than solving TV minimization via iterative methods for image deblurring . Even compared to other deep methods not using unrolling, the model-based unrolled networks can be more efficient – ADMM-CSNet was about twice as fast as a conventional CNN reconstruction called ReconNet . These speed-ups are crucial for applications like real-time imaging (e.g., reconstructing MRI on-the-fly during a scan, or CT during an interventional procedure). The training phase of deep networks is of course computationally intensive (may take hours or days on GPUs), but that is a one-time cost; traditional solvers don’t require training but “pay” the cost every time in terms of slow runtime. Thus, once deployed, deep unrolling can give fast and consistent performance case after case. An important point in convergence: unrolled networks do not iterate until a mathematical convergence criterion – they stop at the fixed depth. If more accuracy is needed, one must train a deeper network or use a different approach. However, in practice, well-designed unrolled networks reach a good reconstruction within their fixed iterations and further iterations yield diminishing returns.

Generalization and Robustness: Generalization refers to how well a trained deep unrolling method works on data that differ from its training data. This is a critical evaluation aspect. Robustness to noise: Traditional regularized solvers (ADMM, etc.) can be re-run with adjusted parameters for different noise levels, and methods like LASSO or total variation are known to handle noise by appropriate regularization. A deep unrolled network can be trained with simulated noise in the training data to encourage robustness – and many studies do add noise augmentation so the network learns to handle it. Within the range of noise it has seen, an unrolled model often maintains good performance (and can even outperform human-tuned algorithms, since it may learn an optimal denoising strategy). But if the noise statistics change significantly, the network might not optimally adapt. For example, an MRI unrolled network trained on one noise level saw a drop in performance when evaluated on data with a different noise variance​ARXIV.ORG . Recent research (like the PUN method mentioned earlier) is looking at ways to improve robustness, e.g., by pruning networks or using techniques from domain generalization. Missing data or different sampling patterns: Similar concerns arise if, say, a CT network trained on one set of angles is applied to a scenario with a totally different set of projection angles, or an MRI network trained on random undersampling is tested on radial undersampling. If the forward model is integrated (which it is, in unrolled networks), the network knows the physics for any sampling pattern (since the forward operator can be changed or is a parameter to the network). However, the learned prior might be overfit to certain artifact patterns. A study of the 2019 fastMRI challenge noted that even minor shifts in the sampling pattern caused some deep learning models to miss subtle features​ARXIV.ORG . Unrolled models, by virtue of being closer to model-based, generally handle moderate shifts better than pure black-box models, but they are not immune to generalization issues.

In terms of hardware and deployment constraints: Traditional iterative solvers can be run on CPU (slowly) or GPU, and one can trade off speed for memory (e.g., using more iterations uses more time but not necessarily more memory at once). Deep networks typically require a capable GPU (or specialized accelerator) at inference to achieve their speed advantage, which might be a constraint in some low-resource settings. They also consume GPU memory proportional to model size. However, once properly engineered, even large unrolled models (with e.g. 10 convolutional layers per iteration and 10 iterations) can run on a modern GPU within tens of milliseconds. There have been demonstrations of deep reconstructions running on scanner hardware or within streaming recon systems in hospitals, indicating it’s feasible with current tech. Another consideration is stability and reliability : iterative methods can be stopped early or adjusted if something looks off in the reconstruction; a deep network gives one shot output. Thus, extensive validation is needed to ensure the network is reliable across cases. Many evaluations in literature report not just average error metrics but also worst-case errors and visual inspection for artifacts, to ensure the learned method doesn’t introduce unpredictable errors (an essential aspect if these are to be used in safety-critical applications like medical diagnostics). So far, results are encouraging – deep unrolled methods often produce fewer noticeable artifacts than traditional methods, rather than more, when applied within their tested regime​DIGLIB.EG.ORG ​DIGLIB.EG.ORG .

In summary, performance evaluations generally find that deep unrolling offers major gains in speed and often in reconstruction fidelity for NLOS, CT, and MRI inverse problems. The trade-offs lie in the need for training and the careful assessment of robustness. Ongoing research is closing the gap in generalization, with techniques to make these learned solvers more adaptable to new conditions without retraining.

Datasets for NLOS, CT, and MRI

NLOS Imaging Datasets: Non-line-of-sight imaging is still a developing field, and as such, there are not as many standardized large-scale datasets as in CT or MRI. Nonetheless, there are a few benchmarks emerging:

• Synthetic Data: One example is the Zaragoza NLOS dataset , which provides synthetic scenes and their corresponding time-resolved measurements rendered with physics-based simulation​GRAPHICS.UNIZAR.ES . This allows researchers to test algorithms on a variety of known scenes.

• Real Data: Many NLOS research papers provide data from their hardware experiments (e.g., the classic NLOS corner camera experiment by Velten et al. had a small set of examples like hidden mannequins, and later works by MIT or Stanford include captured transients for hidden scenes like cardboard cut-outs or real objects). These are sometimes released alongside papers. For instance, Chen et al. 2020 (“Learned Feature Embeddings for NLOS”) and subsequent works provide their captured data of hidden objects as a reference.

• Recent Public Datasets: A passive NLOS imaging dataset was released with a 2022 study that used an optimal transport framework​IEEEXPLORE.IEEE.ORG . This dataset (NLOS-Passive) contains measurements where the illumination is ambient light rather than an active laser, which is a different challenge. Additionally, code and data for specific algorithms like the frequency-domain NLOS (f-k migration) by Lindell et al. were made public on GitHub​GITHUB.COM , which includes some real-world scans.

• Towards a Benchmark: The 2023 MIMU paper introduced a large-scale synthetic dataset with varying resolutions and noise, aiming to serve as a universal training set for NLOS learning methods​DIGLIB.EG.ORG . This hints at a future where NLOS might have something akin to ImageNet for hidden scenes.

In summary, NLOS datasets exist in pieces – researchers often compile their own – but there is a trend toward sharing and standardizing, with both synthetic benchmarks and real captured data becoming available for the community.

CT Reconstruction Datasets: The medical imaging community has several well-known datasets for CT reconstruction, especially for low-dose or sparse-view reconstruction tasks:

• The Mayo Clinic Low-Dose CT Challenge Dataset (AAPM 2016) is a widely used set of 3D CT scans. It contains paired high-dose and simulated low-dose scans of patients (mostly abdominal scans). This allows supervised training and evaluation of denoising or reconstruction algorithms that turn low-dose input into high-quality output. Many deep learning papers (including unrolling methods like LEARN​MDPI.COM or others) have used this data to show improvements over filtered back-projection or iterative methods.

• The LoDoPaB-CT dataset (Low Dose Parallel Beam CT) is a public benchmark introduced in 2020. It consists of over 40,000 2D slice images derived from ~800 patients from the LIDC-IDRI lung CT database, along with simulated projection data (Radon transform) at low-dose settings​ARXIV.ORG . Importantly, LoDoPaB provides a standardized train/validation/test split, which has been used in papers to quantitatively compare different reconstruction approaches​ARXIV.ORG . It’s becoming a reference dataset for sparse-view and low-dose CT research.

• Sparse-View CT data: Some works simulate extremely limited angle scenarios. The IEEE VIP Cup 2019 provided a challenge dataset for sparse-view (e.g., 30 or 60 views) CT reconstruction, which has been used to test learned primal-dual and other unrolled methods.

• Phantom and Analytical Data: Beyond patient scans, there are standard phantoms like the Shepp-Logan phantom (a classic synthetic image) for which “true” projections can be computed. While not a dataset per se, these are often used for initial validation of algorithms. Some studies create their own simulation datasets by taking images (from MRI or other modalities or even natural images) and treating them as “CT slices” to forward project. This is especially common in academic research to provide unlimited training data (since one can generate as many random phantom images and their projections as needed).

• It’s worth noting that clinical CT datasets are typically 3D (volumes), but many learning papers work with 2D slices for simplicity. However, some recent research is moving to 3D reconstruction with unrolled networks as well, using multiple slices or even the full volume as input (which is much heavier computationally).

MRI Reconstruction Datasets: MRI has benefited from some large open datasets in recent years, spurred in part by challenges to accelerate MRI:

• The fastMRI dataset by NYU (in collaboration with Facebook AI) is a comprehensive open dataset for accelerated MRI reconstruction​ARXIV.ORG . It includes over 1,500 clinical MRI scans of the knee (multi-coil raw k-space data and ground truth images), as well as brain MRI data. The fastMRI dataset comes with predefined train/val/test splits and has been used in a public leader-board competition. It has become a standard for evaluating deep learning reconstruction – many unrolled models (VarNet, MoDL, etc.) report results on fastMRI, making it easy to compare performance.

• The Calgary-Campinas (CC359) dataset is another open set containing 359 multi-coil brain MRI volumes at 3T, which can be used for training and evaluating reconstruction algorithms. It’s somewhat smaller than fastMRI but focused on brain imaging.

• The Stanford MRNet dataset contains knee MRI images (sagittal knee scans) primarily for abnormality detection, but it has been repurposed by some for reconstruction research by simulating undersampling on those images.

• Legacy datasets like the IXI dataset (a collection of brain MR images from multiple scanners) or OASIS (brain MRI for Alzheimer’s study) have also been used to augment training data or evaluate generalization, though they are not specifically designed for reconstruction tasks.

• In MRI, researchers also use a lot of simulated undersampling. Given a fully-sampled image or k-space, one can digitally undersample (e.g., drop 80% of k-space points) to create a test case for reconstruction. Thus, even if a fully-sampled image dataset is small, one can create many undersampled versions to test different acceleration factors or patterns. For example, the fastMRI challenge provided specific masks (Cartesian subsampling patterns) for 4x or 8x acceleration, and participants evaluated their unrolled models on those.

• Additionally, there are sample data from manufacturers or hospitals (like Mayo Clinic has released some MRI data, and the ISMRM challenge datasets for reconstruction like the 2013 challenge on dynamic imaging). These are used in more specialized scenarios (e.g., dynamic MRI, where time sequences are reconstructed). Overall, for each modality – NLOS, CT, MRI – the field is supported by a growing set of datasets that enable both training of deep models and standardized evaluation. NLOS is catching up with more shared data emerging. CT has both real clinical data and plenty of simulated data in public domain. MRI likely has the largest public datasets for this purpose (fastMRI being a prime example). The availability of open datasets and code is accelerating research on deep unrolling, allowing rigorous comparison of techniques in solving these challenging inverse problems.

References:

• MIMU (Multi-scale Iterative Model-guided Unfolding) network for NLOS: ill-posed problem discussion​DIGLIB.EG.ORG and multi-scale unrolling approach​DIGLIB.EG.ORG .

• LoDoPaB-CT dataset paper: describes CT inverse problem and dataset details​UNI-BREMEN.DE ​ARXIV.ORG .

• Pruning Unrolled Networks (PUN) for MRI: introduction to unrolled networks​ARXIV.ORG and generalization issues noted in fastMRI challenge​ARXIV.ORG .

• Monga et al., IEEE SPM 2021: overview of algorithm unrolling and ADMM-CSNet performance gains .

• Yang et al., TPAMI 2020: ADMM-CSNet, unrolling ADMM for compressive imaging (builds on NIPS 2016 ADMM-Net for MRI) .

• Adler & Öktem 2018: Learned Primal-Dual for CT (unrolled primal-dual algorithm)​MDPI.COM .

• Zhang & Ghanem 2018 (CVPR): ISTA-Net (unrolled ISTA) for image CS​MDPI.COM .

• Hammernik et al. 2018: Variational Network for MRI (unrolled gradient descent with learned regularizer).

• DeepInverse (PyTorch library) documentation​GITHUB.COM .

• GitHub : yangyan92/Deep-ADMM-Net (NIPS 2016 code release)​GITHUB.COM ; deepinv/deepinv (library)​GITHUB.COM .

• CTprintNet 2023: PyTorch implementation for unrolled CT recon​MDPI.COM .

• G. Chen et al. 2020, TOG: Learned Feature Embeddings for NLOS (NLOS dataset and learning-based recon).

• X. Liu et al. 2023, CGF: MIMU NLOS unfolding with dataset augmentation​DIGLIB.EG.ORG .

• FastMRI dataset paper (Zbontar et al. 2019)​ARXIV.ORG .

• Johannes Leuschner et al. 2021: LoDoPaB-CT dataset description​ARXIV.ORG .

• Memory-efficient unrolling: G. Zaharchuk et al. 2020 (FBSEM-Net for PET) – sequential training reduces memory by 98%​PMC.NCBI.NLM.NIH.GOV .

• Additional references as cited inline above.