Paper deep dive
CG-GLORE: A Conjugate Gradient-Based Global-Local Regularization Network for Sparse-View CT Reconstruction
Tran Xuan Hieu Le, Doanh C. Bui, Vu Trung Duong Le, Hoai Luan Pham, Khang Nguyen, Mai K. Nguyen, Tu Bao Ho, Yasuhiko Nakashima
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%
Last extracted: 8/18/2026, 5:55:32 AM
Summary
The paper introduces CG-GLORE, a deep unrolling framework for sparse-view CT reconstruction that combines a Conjugate Gradient (CG) solver with a Global-Local Regularization Network (GLORE). The method uses a structured Hessian surrogate to enable second-order-inspired updates without explicit Hessian computation, while GLORE models image priors using convolutions and a Nyström-based attention mechanism for long-range dependencies. Experiments on AAPM and DeepLesion datasets demonstrate superior performance in reconstruction quality and convergence stability compared to existing methods.
Entities (8)
Relation Signals (7)
CG-GLORE → contains → GLORE
confidence 97% · To model image priors, we design a Global-Local Regularization Network (GLORE)... This design captures anatomical details
GLORE → contains → LORAD
confidence 96% · GLORE includes two components: 1) Learnable Convolution Layers... and 2) Long-Range Dependency Representation (LORAD)
CG-GLORE → uses → Conjugate Gradient
confidence 95% · Each unrolled stage uses a CG-solved linear system based on a structured Hessian surrogate
LORAD → uses → Nyström Attention
confidence 94% · LORAD uses sparse patchification and Nyström-based approximate self-attention to capture long-range dependencies efficiently.
CG-GLORE → evaluatedon → AAPM
confidence 93% · Experiments on AAPM and DeepLesion under multiple sparse-view and noise settings show that CG-GLORE achieves strong quantitative performance
CG-GLORE → evaluatedon → DeepLesion
confidence 93% · Experiments on AAPM and DeepLesion under multiple sparse-view and noise settings show that CG-GLORE achieves strong quantitative performance
CG-GLORE → solves → Sparse-View CT
confidence 92% · We propose CG-GLORE, a compact deep unrolling framework inspired by second-order optimization for sparse-view CT reconstruction.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Sparse-view computed tomography (CT) reduces radiation dose by acquiring fewer projection views, but the resulting inverse problem is highly ill-posed and often produces severe streak artifacts. Existing deep reconstruction methods have achieved promising performance, yet many rely on first-order updates or large regularization networks, which can be less effective in ill-conditioned settings. We propose \textbf{CG-GLORE}, a compact deep unrolling framework inspired by second-order optimization for sparse-view CT reconstruction. Each unrolled stage uses a CG-solved linear system based on a structured Hessian surrogate: it retains the physics-induced curvature of the data-fidelity term while using an identity approximation for the learned regularization term. Thus, the method is second-order-inspired rather than an exact Newton method for the full learned objective. To model image priors, we design a Global-Local Regularization Network (GLORE), which combines convolutional local feature extraction with a Long-Range Dependency Representation module based on sparse patchification and Nyström attention. This design captures anatomical details and non-local dependencies while maintaining practical complexity. Experiments on AAPM and DeepLesion under multiple sparse-view and noise settings show that CG-GLORE achieves strong quantitative performance, stable convergence, lower noise power, and improved visual fidelity compared with representative reconstruction methods.
Tags
Links
- Source: https://arxiv.org/abs/2608.15246v1
- Canonical: https://arxiv.org/abs/2608.15246v1
Trouble viewing inline? Open PDF directly →
Full Text
50,564 characters extracted from source content.
Expand or collapse full text
CG-GLORE for Sparse-View CT Reconstruction CG-GLORE: A Conjugate Gradient–Based Global-Local Regularization Network for Sparse-View CT Reconstruction Tran Xuan Hieu Le Doanh C. Bui Vu Trung Duong Le Hoai Luan Pham Khang Nguyen Maï K. Nguyen Tu Bao Ho Yasuhiko Nakashima Abstract Sparse-view computed tomography (CT) reduces radiation dose by acquiring fewer projection views, but the resulting inverse problem is highly ill-posed and often produces severe streak artifacts. Existing deep reconstruction methods have achieved promising performance, yet many rely on first-order updates or large regularization networks, which can be less effective in ill-conditioned settings. We propose CG-GLORE, a compact deep unrolling framework inspired by second-order optimization for sparse-view CT reconstruction. Each unrolled stage uses a CG-solved linear system based on a structured Hessian surrogate: it retains the physics-induced curvature of the data-fidelity term while using an identity approximation for the learned regularization term. Thus, the method is second-order-inspired rather than an exact Newton method for the full learned objective. To model image priors, we design a Global-Local Regularization Network (GLORE), which combines convolutional local feature extraction with a Long-Range Dependency Representation module based on sparse patchification and Nyström attention. This design captures anatomical details and non-local dependencies while maintaining practical complexity. Experiments on AAPM and DeepLesion under multiple sparse-view and noise settings show that CG-GLORE achieves strong quantitative performance, stable convergence, lower noise power, and improved visual fidelity compared with representative reconstruction methods. †email: le.tran_xuan_hieu.lx0@naist.ac.jp†email: doanhbc@uit.edu.vn†email: le.duong@naist.ac.jp†email: pham.luan@is.naist.jp†email: khangnttm@uit.edu.vn†email: mai.nguyen-verger@cyu.fr†email: bao@viasm.edu.vn†email: nakashim@is.naist.jp†affiliation: Nara Institute of Science and Technology Nara, Japan †affiliation: University of Information Technology Ho Chi Minh City, Vietnam †affiliation: Vietnam National University Ho Chi Minh City, Vietnam †affiliation: ETIS, CY Cergy Paris University, ENSEA, CNRS, UMR 8051 Cergy-Pontoise, France †affiliation: Vietnam Institute for Advanced Study in Mathematics Hanoi, Vietnam 1 Introduction Computed tomography (CT) is essential for clinical diagnosis, but repeated exposure to ionizing radiation raises safety concerns [25]. Sparse-view CT reduces the number of projection views to lower radiation dose [11], yet the resulting incomplete measurements make reconstruction highly ill-posed and often introduce severe streak artifacts, especially when using Filtered Back Projection (FBP) [6]. Deep learning has improved sparse-view CT reconstruction by post-processing FBP images or jointly exploiting image and sinogram domains [4, 24, 21, 27]. However, many of these methods remain weakly coupled with the reconstruction physics and rely heavily on local image statistics. Deep unrolling networks address this by embedding iterative optimization into learnable architectures, but most existing designs still use first-order updates, which can be inefficient for ill-conditioned sparse-view reconstruction and often require large regularization networks to compensate for weak optimization directions. We propose CG-GLORE, a compact second-order-inspired unrolling framework for sparse-view CT reconstruction. Each stage uses a structured Hessian surrogate that combines the analytic data-fidelity curvature with an identity approximation for the learned regularization term. Instead of computing or storing an exact Hessian, we solve the resulting linear system by Conjugate Gradient (CG). This formulation is intended as a stable, physics-aware surrogate update, rather than as an exact Newton step for the full learned objective. To model the learned regularization term, we further design the Global-Local Regularization Network (GLORE). GLORE combines convolutional layers for local anatomical details with a Long-Range Dependency Representation (LORAD) module for non-local structure modeling. LORAD uses sparse patchification and Nyström-based approximate self-attention to capture long-range dependencies efficiently. Together, CG and GLORE separate the roles of optimization and prior modeling: CG provides effective update directions, while GLORE focuses on image regularity. Our contributions are summarized as follows: • We introduce CG-GLORE, a second-order-inspired deep unrolling framework that formulates each reconstruction stage as a CG-solvable linear system based on a structured Hessian surrogate. • We design GLORE, a compact global-local regularization network that combines convolutions with efficient Nyström-based long-range dependency modeling. • We validate CG-GLORE under different sparse-view and noise settings, showing improved reconstruction quality and favorable optimization behavior. 2 Related Work Deep learning for sparse-view CT reconstruction. Early deep learning-based methods for sparse-view CT reconstruction commonly treat the problem as an image restoration task, where an FBP reconstruction is enhanced by a neural network. Representative approaches employ convolutional architectures to suppress streak artifacts and recover anatomical structures in the image domain [10, 21, 27]. To further exploit the measurement process, dual-domain methods extend this idea by incorporating sinogram-domain information, allowing networks to interpolate or refine projection data before or during image reconstruction [4, 28]. Although these methods achieve promising visual quality, they are often weakly coupled with the underlying optimization model and may struggle to enforce data consistency under highly sparse or noisy acquisition settings. Deep unrolling and learned regularization. Deep unrolling networks explicitly embed iterative optimization into neural architectures by unfolding reconstruction updates into a finite number of learnable stages. Learned Primal-Dual [2] and LEARN [5] demonstrate the effectiveness of learning update rules and regularization terms for CT reconstruction. More recent methods introduce non-local modeling into the regularization module, such as Transformer-based local–nonlocal regularization in RegFormer [29] or quasi-Newton optimization with an MLP-Mixer-style regularizer in QN-Mixer [3]. These studies show the importance of both global context modeling and improved optimization dynamics. In contrast, CG-GLORE uses a CG-solvable structured surrogate that preserves the analytic data-fidelity curvature, without estimating the curvature of the learned regularizer, while GLORE models local structures and long-range dependencies efficiently. 3 Methodology 3.1 Preliminary Inverse Problem for CT Reconstruction. In computed tomography (CT), the reconstruction task can be formulated as an inverse problem. Given a sinogram ∈ℝmy ^m, where m=nv×ndm=n_v× n_d, with nvn_v denoting the number of projection views and ndn_d the number of detector elements, the CT image ∈ℝnx ^n, with n=H×Wn=H× W, where H and W denote the height and width of the image, respectively, is to be reconstructed. This image characterizes the internal structure of the scanned object. The sinogram is obtained via the forward projection process: =+ϵ,y=Ax+ε, (1) where ∈ℝm×nA ^m× n denotes the Radon transform operator (i.e., the CT system matrix) and ϵε represents measurement noise. The reconstructed image x is typically expressed in Hounsfield Units (HU). Eq. 1 is the forward model; recovering x from incomplete y is the corresponding ill-posed inverse problem. To obtain the optimal reconstruction x, an iterative optimization procedure is employed to minimize the following objective function: ^=argmin J()=λ2∥−∥22+ℛ(), x= x J(x)= λ2\|Ax-y ^2_2+R(x), where ℛ()R(x) is a regularization term that constraint the image with the expected conditions to obtain better x. For each iteration, the reconstructed image is updated thanks to simulated gradient descent: t+1=t−α[λT(t−)+∇ℛ(t)]⏟∇J(t),t=1,…,Tx_t+1=x_t-α [ ^T(Ax_t-y)+ _xR(x_t) ]_ _xJ(x_t), t=1,…,T (2) where T denotes the number of iterations. There are many forms of the regularization term ℛ(t)R(x_t) [10, 23, 20, 28] appear in Eq. 2. Sparse-view CT reconstruction. This aims to reconstruct a high-quality CT image x from sparse projection views ′∈ℝnv′×ndy ^n _v× n_d, where nv′<nvn _v<n_v. Typically, deep unrolling networks leverage deep learning to construct a learnable module θ(⋅)G_θ(·) to approximate the gradient term ∇J(t) _xJ(x_t). The parameters θ are optimized by minimizing a loss function that measures the discrepancy between the ground-truth image reconstructed from full-view projections gtx_gt and the reconstructed image x obtained from sparse views. 3.2 Second-Order-Inspired Update Most deep unrolling methods update the reconstruction using a first-order gradient descent step [2, 5, 20, 29, 28]. Although this update rule is simple and efficient, first-order optimization may converge slowly when solving ill-conditioned inverse problems such as sparse-view CT reconstruction. To improve the update direction, we use an iterative mechanism inspired by Newton-type optimization. The following expression provides a conceptual Newton-type form; in our method, the exact Hessian is replaced by the structured surrogate described in Sec. 3.4. Thus, we do not claim an exact Newton update for the full learned objective. t+1=t−αtt−1∇J(t),x_t+1=x_t- _tH_t^-1 _xJ(x_t), (3) where t∈ℝn×nH_t ^n× n denotes the structured Hessian surrogate used at iteration t. The parameter αt _t represents the search step and is commonly used for damping or globalization in Newton-type methods [7, 16]. In this work, we set αt=1 _t=1 for the surrogate update and solve the resulting linear system with CG, avoiding the explicit computation of t−1H_t^-1 [9, 16, 18]. 3.3 Alternative Global-Local Regularization Network In this section, we present the proposed Alternative Global-Local (GLORE) Regularization Network for θ(t)≈∇ℛ(t)G_θ(x_t)≈ _xR(x_t). GLORE includes two components: 1) Learnable Convolution Layers to exploit local patterns in the reconstructed image at the ithi^th iteration (xix_i) and 2) Long-Range Dependency Representation (LORAD) to explore relationships between distant parts within xix_i and to enhance a robust representation for the regularization term. 3.3.1 Overall Architecture of GLORE GLORE includes three convolutional layers, with LORAD placed between the first convolutional layer and the subsequent two convolutional layers (convconv). In this manner, given an image xi∈ℝH×W×3x_i ^H× W× 3, where H and W are height and width, respectively (H=WH=W), the first convolutional layer is learned to exploit local patterns and produce feature maps F1∈ℝH×W×C1F_1 ^H× W× C_1, where C1C_1 is the dimensionality of conv1conv_1. F1F_1 is then patchified as a sequence of tokens and processed by LORAD to explore long-range dependencies and capture relations between distant parts, thereby facilitating global patterns. Finally, two more convolutional layers are adopted to further produce high-level feature maps. Figure 1: Overview of the proposed CG-GLORE framework. Starting from an FBP reconstruction x0x_0, CG-GLORE performs T unrolled reconstruction iterations. At each iteration, a Conjugate Gradient solver computes an update from the structured Hessian surrogate, while the global-local regularization network captures local structures and long-range dependencies to further refine the reconstruction. 3.3.2 Long-Range Dependency Representation Sparse Patchification. Given the feature map F1F_1 produced by the initial convolutional layer conv1conv_1, a sparse patchification transforms it into a sequence of tokens z∈ℝN×C1′z ^N× C_1 , where N is the number of tokens and C1′C_1 is the feature dimension of each token. As observed in [15], increasing the number of tokens generally improves performance. Therefore, we aim to generate as many tokens as possible while maintaining computational efficiency. However, using N=HWN=HW tokens results in a quadratic complexity of (N2)O(N^2) when computing pairwise attention, which is computationally prohibitive. To address this, we introduce a dilated patchification strategy. Specifically, we apply a sliding window of size k×k× k with a dilation factor of H/kH/k (or W/kW/k) and stride s=1s=1 to group distant spatial values while ensuring that each patch remains non-overlapping. Then, the tokens within each window are flattened into zi∈ℝC1×k2z_i ^C_1× k^2. For convenience, we denote C1′=C1×k2C_1 =C_1× k^2, effectively compressing the spatial information into the channel dimension. This transformation reduces N to N/k2N/k^2, leading to a decrease in the pairwise attention complexity from (N2)O(N^2) to (N2/k4)O(N^2/k^4), significantly improving computational efficiency. We further define N~=N/k2 N=N/k^2 to denote the reduced number of tokens. This approach facilitates the capture of long-range dependencies while preserving essential structural information. The sparse patchification process is detailed in the PyTorch-like Algorithm 1. Algorithm 1 Sparse Patchification 1: x∈ℝB×C1×H×Wx ^B× C_1× H× W, input image tensor 2: Patchified representation z∈ℝ(N/k)×(C×k2)z ^(N/k)×(C× k^2) 3: Function Patchify(x) ⊳ Convert image into patch sequence 4: (B,C1,H,W)←x.shape(B,C_1,H,W)← x. shape ⊳ B: Batch size, C: Channels, H×WH× W: Image size 5: x←x.unfold(2,H/k,W/k).unfold(3,H/k,W/k)x← x. unfold(2,H/k,W/k). unfold(3,H/k,W/k) ⊳ Extract patches of size k×k× k with dilation factor of H/kH/k 6: x←x.view(B,−1,(H/k)×(W/k))x← x. view(B,-1,(H/k)×(W/k)) ⊳ Reshape to sequence of patches 7: return x.permute(0,2,1)x. permute(0,2,1) ⊳ Rearrange to (batch, patches, channels) Long-Range Dependency Computation. For modeling long-range dependencies, self-attention [22] has demonstrated strong performance. The attention map is computed as =Softmax(QK⊤C1′)A=Softmax ( QK C _1 ), where Q=WQzQ=W^Qz, K=WKzK=W^Kz, and V=WVzV=W^Vz. Here, WQ∈ℝC1′×dqW^Q ^C _1× d_q, WK∈ℝC1′×dkW^K ^C _1× d_k, and WV∈ℝC1′×dvW^V ^C _1× d_v are learnable projection matrices, while dqd_q, dkd_k, and dvd_v denote the dimensions of queries Q, keys K, and values V, respectively. However, computing the attention matrix A remains computationally intensive, i.e., (N~)O( N). To address this, we adopt an approximate self-attention approach that estimates pairwise relational similarities between tokens while preserving as much feature information as possible. We follow [26, 30], which demonstrates that A can be approximated by selecting L landmarks from Q and K based on Nyström method. Following [19], landmarks are selected by segmenting tokens in Q or K in a left-to-right order. To ensure even segmentation, the token sequence z is first padded with zero values: z′=[z∥M],where M=⌈N~L⌉L−N~,z =[z\|0_M], M= NL L- N, (4) [⋅||⋅][·||·] is the concatenation operation. Next, three learnable projection matrices, WQW^Q, WKW^K, and WVW^V, are applied to z′z to obtain the queries Q, keys K, and values V. The tokens are then segmented, where ithi^th segment is defined as follows: SiQ=qjj=siei,SiK=kjj=siei,S^Q_i=\q_j\_j=s_i^e_i, S^K_i=\k_j\_j=s_i^e_i, (5) where SiQS^Q_i and SiKS^K_i denote ithi^th segment in Q and K, respectively. sis_i and eie_i denote the start and end indices of the tokens qj∈Qq_j∈ Q or kj∈Kk_j∈ K. These indices are defined as si=∑k=1i−1|SkQ|+1s_i= _k=1^i-1|S^Q_k|+1 and ei=∑k=1i|SkQ|e_i= _k=1^i|S^Q_k|, where |SkQ||S^Q_k| denotes the number of tokens in kthk^th segment. Finally, each landmark is formed by taking the mean of all tokens in the corresponding segment. This creates a set of landmarks for Q and K, denoted as Q~ Q and K~ K, respectively: Q~=1|SiQ|∑q∈SiQqi=1L,K~=1|SiK|∑k∈SiKki=1L. Q= \ 1|S^Q_i| _q∈ S^Q_iq \_i=1^L, K= \ 1|S^K_i| _k∈ S^K_ik \_i=1^L. (6) Then, the computation of A is decomposed and approximated in low-rank manner as follows: ~=QK~⊤⋅(Q~K~⊤)+⋅Q~K⊤. A=Q K ·( Q K )^+· QK . (7) where (⋅)+(·)^+ denotes the Moore-Penrose pseudoinverse [17]. As the number of landmarks L≪N~L N, Eq. 7 reduces the computational complexity of the attention map from (N~2)O( N^2) to (N~)O( N), which further facilitates long-range dependency across as many tokens as possible while maintaining feasible complexity. We then obtain the long-range dependency representation by multiplying z′z with ~ A: z′=V⊙~z =V A. We also apply multi-head self-attention, where Q, K, and V are decomposed into h heads. This means that we apply Eq. 7 h times and then concatenate the results. z′z then undergoes another linear projection for alignment. Notably, we define dq=dk=dv=C1′d_q=d_k=d_v=C_1 . Patch Extension & Skip Connection. After obtaining z′z , we reshape each token zi′∈ℝC1′z _i ^C_1 into tensor form F1,i′∈ℝk×k×C1F_1,i ^k× k× C_1. In this manner, we convert z′∈ℝN~×C1′z N× C_1 into F1′∈ℝH×W×C1F_1 ^H× W× C_1. This process is presented as PyTorch-like pseudocode in Algorithm 2. A skip connection is performed on F1′F_1 and F1F_1, after which the result undergoes the remaining convolution layers with ReLU activation in between: Ffinal=conv3(ReLU(conv2(F1+F1′))).F_final=conv_3 (ReLU(conv_2(F_1+F_1 )) ). (8) Algorithm 2 Patch Extension 1: Patchified representation z′∈ℝ(N/k)×(C×k2)z ^(N/k)×(C× k^2) 2: x∈ℝB×C1×H×Wx ^B× C_1× H× W 3: Function PatchExtend(z′z ) ⊳ Reconstruct image from patch sequence 4: B←z′.shape[0]B← z . shape[0] ⊳ Batch size 5: z′←z′.permute(0,2,1).view(B,C1′,H/k,W/k)z ← z . permute(0,2,1). view(B,C_1 ,H/k,W/k) ⊳ Rearrange patches to 2D 6: z′←z′.view(B,C,k,k,H/k,W/k)z ← z . view(B,C,k,k,H/k,W/k) ⊳ Reshape to original image space 7: return z′.permute(0,1,2,4,3,5).view(B,C1,H,W)z . permute(0,1,2,4,3,5). view(B,C_1,H,W) ⊳ Restore image format 3.3.3 Hessian Approximation. Explicitly computing the Hessian ∇x2J(t)∈ℝn×n _x^2J(x_t) ^n× n is computationally infeasible in large-scale CT reconstruction due to the high dimensionality (n=H×Wn=H× W). To obtain a practical update, we use a structured Hessian surrogate that retains the analytic, physics-induced curvature of the data-fidelity term while treating the learned module θ(⋅)G_θ(·) as a gradient correction. Local Linear Approximation. The learned gradient representation θ(⋅)G_θ(·) is locally approximated via first-order expansion: θ(t+Δ)≈θ(t)+∇θ(t)Δ,G_θ(x_t+ ) _θ(x_t)+ _xG_θ(x_t)\, , (9) where ∇θ(t) _xG_θ(x_t) denotes the Jacobian matrix. While this Jacobian would contribute to the curvature of the full learned objective, it is not explicitly evaluated in our method. Identity Surrogate Approximation. Motivated by prior works in residual learning and damped second-order optimization, where identity mappings or diagonal regularization are employed to stabilize optimization and improve conditioning [8, 12, 13], we use an identity surrogate for the local action of the Jacobian: ∇θ(t)Δ≈Δ. _xG_θ(x_t)\, ≈ . (10) This approximation treats θ(⋅)G_θ(·) as a stable residual correction and avoids estimating learned-prior curvature. Structured Hessian Form. The following formal Hessian expression motivates the structured surrogate used in our update. In the implementation, we use the final approximation in Eq. 11, rather than the exact Hessian of the full learned objective: t _t =∇2J(t) =∇^2_xJ(x_t) (11) =∇(λtT(t−)+θ(t)) = _x ( _tA^T(Ax_t-y)+G_θ(x_t) ) =λtT+∇θ(t) = _tA^TA+ _xG_θ(x_t) ≈λtT+. ≈ _tA^TA+I. This structured surrogate yields a symmetric positive definite system, which is particularly suitable for efficient optimization using the Conjugate Gradient (CG) method. It preserves the data-fidelity curvature and uses a stable identity approximation for the learned regularization term, rather than modeling its full curvature. 3.4 Conjugate Gradient-Based Update Derivation of btb_t. To use CG for the structured surrogate update in Eq. 3, we reformulate it as tt+1=bt,H_tx_t+1=b_t, (12) where bt∈ℝnb_t ^n is the corresponding right-hand side vector. Starting from the conceptual Newton-type form, we have t+1=t−(∇2J(t))−1∇J(t).x_t+1=x_t-(∇^2_xJ(x_t))^-1 _xJ(x_t). (13) Multiplying both sides by tH_t yields tt+1=tt−∇J(t).H_tx_t+1=H_tx_t- _xJ(x_t). (14) Using the structured surrogate in Eq. 11 and simplifying, we obtain tt+1=λtT+t−θ(t)=bt.H_tx_t+1= _tA^Ty+x_t-G_θ(x_t)=b_t. (15) Conjugate Gradient for the Structured Surrogate. Directly computing the inverse of the surrogate operator is infeasible for high-dimensional CT images. Instead, we solve the linear system iteratively using the Conjugate Gradient (CG) method. CG is particularly suitable for large-scale problems because it only requires repeated applications of the linear operator tH_t without explicitly forming the matrix. Starting from the current estimate tx_t, the CG solver generates a sequence of updates along mutually conjugate directions to approximate the solution of Eq. 15. CG is used here as a linear-system solver; it does not estimate learned-prior curvature. The procedure is summarized in Algorithm 3, and the full unrolled CG-GLORE pipeline is illustrated in Figure 1. Algorithm 3 Conjugate Gradient Reconstruction Update Require: current reconstruction tx_t, sinogram y, projection operators A and TA^T, learned gradient module θ(⋅)G_θ(·), number of CG iterations K 1: bt=λtT+t−θ(t)b_t= _tA^Ty+x_t-G_θ(x_t) ⊳ Construct right-hand side 2: (0)=tx^(0)=x_t ⊳ Initialize reconstruction 3: r(0)=bt−t(0)r^(0)=b_t-H_tx^(0) ⊳ Compute residual 4: p(0)=r(0)p^(0)=r^(0) ⊳ Initialize search direction 5: ρ0=‖r(0)‖2ρ^0=\|r^(0)\|^2 ⊳ Compute residual norm squared 6: for k=0,1,…,K−1k=0,1,…,K-1 do 7: w=tpk=λtTpk+pkw=H_tp^k= _tA^TAp^k+p^k ⊳ Apply structured surrogate along search direction 8: αk=ρk(pk)⊤wα^k= ρ^k(p^k) w ⊳ Compute step size 9: (k+1)=k+αkpkx^(k+1)=x^k+α^kp^k ⊳ Update reconstruction 10: r(k+1)=rk−αkwr^(k+1)=r^k-α^kw ⊳ Update residual 11: ρ(k+1)=‖r(k+1)‖2ρ^(k+1)=\|r^(k+1)\|^2 ⊳ Update residual norm squared 12: βk=ρ(k+1)ρkβ^k= ρ^(k+1)ρ^k ⊳ Compute conjugate coefficient 13: p(k+1)=r(k+1)+βkpkp^(k+1)=r^(k+1)+β^kp^k ⊳ Update search direction 14: end for 15: t+1=(K)x_t+1=x^(K) ⊳ Return updated reconstruction 4 Experiments 4.1 Datasets & Scenarios Datasets. For evaluation, two datasets are used: “2016 NIH-AAPM-Mayo Clinic Low-Dose CT Grand Challenge" (AAPM) [14] and DeepLesion [31]. The AAPM dataset includes 3mm3m thickness 2,378 full-dose CT images from 10 patients, while the DeepLesion dataset comprises CT images from 4,427 patients. For AAPM, we follow the strategy of [3], which selects images from 8 patients as the training set, 1 patient as the validation set, and 1 patient as the testing set. For DeepLesion, we use the official train-validation-test split, selecting 2,000, 200, and 300 CT images, respectively, for training and evaluation. All models are selected based on their best performance on the validation set, and results are reported on the testing set. 4.2 Implementation Details Hyperparameters & Libraries. Given the original CT images, we resize them to 256×256256× 256 pixels, i.e., H=256H=256 and W=256W=256. We then use the ODL library [1] to simulate the forward process using a 2D fan-beam geometry with 512 detector pixels, a source-to-axis distance of 600 m, and an axis-to-detector distance of 290 m. The sinograms are generated over a full angular range of [0,2π][0,2π] radians, resulting in 512 views. To simulate sparse-view scenarios, we select nview∈18,32,64,128n_view∈\18,32,64,128\ views, evenly spaced across the angular range. For reconstruction, we use the ODL backward process to apply the FBP algorithm. For the default setting, we set the sliding window size to k=2k=2, which reduces the image resolution by a factor of 44, resulting in N~=1282 N=128^2. The number of landmarks is set as L=384L=384. The three convolutional layers are configured with dimension sizes C1=C2=C3=C=64C_1=C_2=C_3=C=64. GLORE and all comparative models are trained for 50 epochs with a learning rate of 1×10−41× 10^-4. Noise Configurations. To simulate realistic scanning conditions, Poisson and Gaussian noise are added to the simulated sinograms. Poisson noise models photon-counting fluctuations, while Gaussian noise represents sensor and electronic noise. The noisy sinograms are regenerated at every training epoch to increase noise diversity and reduce overfitting. We evaluate three settings: No noise (NG=0,NP=0N_G=0,N_P=0), Low noise (NG=5%,NP=106N_G=5\%,N_P=10^6), and High noise (NG=5%,NP=5×105N_G=5\%,N_P=5× 10^5), where lower NPN_P corresponds to stronger Poisson noise. Noise Power Spectrum (NPS) evaluation. The Noise Power Spectrum (NPS) characterizes the frequency distribution of noise in reconstructed CT images. For the k-th noise ROI k(x,y)n_k(x,y) of size M×NM× N, after mean subtraction and low-frequency trend removal, the 2D NPS is estimated as NPS(fx,fy)=ΔxΔyKMN∑k=1K|ℱk(x,y)|2NPS(f_x,f_y)= _x _yKMN _k=1^K |Fn_k(x,y) |^2, where ℱ⋅F· denotes the 2D Fourier transform and Δx,Δy _x, _y are the pixel spacings. A rotationally invariant 1D NPS is obtained by radial averaging as NPS(fr)=1|Ω(fr)|∑(fx,fy)∈Ω(fr)NPS(fx,fy)NPS(f_r)= 1| (f_r)| _(f_x,f_y)∈ (f_r)NPS(f_x,f_y), with fr=fx2+fy2f_r= f_x^2+f_y^2. In our implementation, M=N=32M=N=32, K=57K=57, and Δx=Δy=1.5625 _x= _y=1.5625 m. 4.3 Quantitative Results Following previous studies, we use Peak signal to noise ratio (PSNR) and structural index similarity (SSIM) to evaluate the quality of reconstructed CT image. Method No noise NGN_G = 5%, NPN_P = 10610^6 NGN_G = 5%, NPN_P = 5×1055× 10^5 nviewn_view = 32 nviewn_view = 64 nviewn_view = 128 nviewn_view = 32 nviewn_view = 64 nviewn_view = 128 nviewn_view = 32 nviewn_view = 64 nviewn_view = 128 PSNR SSIM PSNR SSIM PSNR SSIM PSNR SSIM PSNR SSIM PSNR SSIM PSNR SSIM PSNR SSIM PSNR SSIM FBPConvNet [10] 31.33 87.02 38.42 94.02 42.97 97.46 31.52 83.37 37.35 94.32 42.06 97.34 31.28 86.6 36.81 93.57 41.23 96.83 LearnedPD [2] 40.7 97.07 47.04 98.95 51.62 99.56 39.59 96.27 43.87 98.2 45.72 98.7 39.07 96.07 42.81 97.83 44.49 98.39 LEARN [5] 40.52 96.78 47.65 99.04 50.52 99.47 40.04 96.56 44.09 98.24 45.82 98.71 39.53 96.25 42.98 97.88 44.58 98.4 QN-Mixer† [3] 39.51 96.11 45.57 98.48 50.09 99.32 37.50 94.92 42.46 97.70 44.27 98.11 35.91 92.49 38.73 94.92 40.51 96.27 DPMA [28] 35.2 92.16 40.11 96.63 45.74 98.89 34.82 90.64 38.96 94.93 42.6 97.23 34.7 90.05 38.04 93.29 41.03 95.75 RegFormer [29] 40.39 96.70 47.33 98.97 52.36 99.61 39.62 96.28 44.24 98.29 46.35 98.83 39.08 95.92 43.22 98.02 45.15 98.57 CG-GLORE (ours) 42.05 97.59 47.66 99.05 52.43 99.62 40.54 96.85 44.16 98.25 45.94 98.74 39.86 96.47 43.07 97.93 44.76 98.46 † The results are cited from [3]. Table 1: Quantitative comparison between CG-GLORE and state-of-the-art methods on the AAPM dataset. The best and second-best results are highlighted in red (bold) and yellow (underlined), respectively. Results on AAPM dataset. Table 1 compares CG-GLORE with other methods on the AAPM dataset. In the noiseless setting, CG-GLORE achieves the best reconstruction quality across all projection-view numbers, reaching 42.05/97.59, 47.66/99.05, and 52.43/99.62 in PSNR/SSIM for 32, 64, and 128 views, respectively. The improvement is most pronounced in the highly sparse 32-view case, where CG-GLORE outperforms the second-best method by 1.53 dB in PSNR. Under noisy acquisition, CG-GLORE remains particularly robust at 32 views and obtains the best results under both noise levels. For 64 and 128 views, RegFormer slightly outperforms CG-GLORE in several noisy settings, but CG-GLORE consistently ranks second with close performance. These results indicate that the proposed CG-based update is especially beneficial in more ill-conditioned sparse-view regimes, while GLORE provides competitive regularization under different noise conditions. Method No noise NGN_G = 5%, NPN_P = 10610^6 NGN_G = 5%, NPN_P = 5×1055× 10^5 nviewn_view = 18 nviewn_view = 32 nviewn_view = 18 nviewn_view = 32 nviewn_view = 18 nviewn_view = 32 PSNR SSIM PSNR SSIM PSNR SSIM PSNR SSIM PSNR SSIM PSNR SSIM FBPConvNet [10] 28.72 69.2 32.76 84.89 29.27 79.77 32.21 82.27 29.1 78.53 32.74 84.46 LearnedPD [2] 34.82 92.34 39.90 96.50 34.65 92.23 39.37 96.14 34.54 92.04 39.09 96.00 DPMA [28] 31.92 84.73 35.34 89.53 31.81 83.69 35.09 88.25 31.73 83.23 34.76 87.34 RegFormer [29] 35.64 92.49 40.71 96.81 35.48 92.05 40.16 96.55 35.39 92.19 39.80 96.33 CG-GLORE (ours) 36.47 94.26 41.20 97.26 36.35 94.21 40.52 96.96 36.11 94.06 40.22 96.81 Table 2: Performance comparison between CG-GLORE and other state-of-the-art methods on DeepLesion dataset. Figure 2: Convergence analysis on the AAPM dataset. PSNR and SSIM are plotted as functions of training epochs for different reconstruction methods. Each curve consists of five evaluation points corresponding to 10, 20, 30, 40, and 50 training epochs, highlighting the convergence speed and stability of the compared methods. Results on DeepLesion dataset. Table 2 reports the performance on the DeepLesion dataset. CG-GLORE achieves the best PSNR and SSIM in all sparse-view and noise settings, demonstrating consistent robustness across both 18-view and 32-view reconstruction. In the challenging 18-view setting, CG-GLORE improves over the second-best method by 0.83 dB PSNR and 1.77 SSIM points without noise, and maintains clear margins under both noisy configurations. Similar gains are observed at 32 views, where CG-GLORE reaches 41.20/97.26 in the noiseless case and remains best under increasing Poisson noise. Together with the AAPM results, this consistent advantage suggests that the proposed global-local regularization and CG-based update provide robust reconstruction across different datasets and acquisition settings. Convergence analysis. Figure 2 compares the training convergence of CG-GLORE with representative baselines on the AAPM dataset. CG-GLORE improves steadily from 10 to 50 epochs across all view and noise settings, showing stable optimization behavior. The clearest gains appear in the 32-view cases, where PSNR/SSIM increase from 40.45/96.75 to 42.05/97.59 without noise, from 39.52/96.23 to 40.54/96.85 under low noise, and from 38.95/95.81 to 39.86/96.47 under high noise. At 50 epochs, these results outperform the strongest plotted baseline by 1.35 dB, 0.50 dB, and 0.33 dB in PSNR, respectively. For 64 and 128 views, CG-GLORE remains best or competitive, especially in noise-free cases. The small gains from 40 to 50 epochs, at most 0.07 dB PSNR and 0.03 SSIM, further suggest stable late-stage convergence. Figure 3: NPS under low-noise setting (NG=5%N_G=5\%, NP=1×106N_P=1× 10^6) with nview=32n_view=32. Figure 4: NPS under noise-free setting (NG=0N_G=0, NP=0N_P=0) with nview=64n_view=64. Figure 4-4: ROIs for NPS Analysis. 32×3232× 32 ROIs are distributed as 1 center, 8 and 20 on two circular rings (radii 25, 50), and 28 on an outer ellipse (75×55), totaling 57 ROIs per image, within HU range [−200,300][-200,300]. Noise Power Spectrum analysis. Figure 4 and Figure 4 report the averaged 1D residual NPS curves computed from fixed ROIs over the test slices. In the more challenging 32-view setting, CG-GLORE achieves the lowest NPS over the full radial-frequency range, showing that it suppresses residual noise more effectively than the competing learned reconstruction methods. Under the 64-view setting, all advanced learning-based methods exhibit substantially reduced NPS compared with FBP and FBPConvNet, while CG-GLORE remains among the lowest curves and closely matches the best-performing alternatives. These results suggest that the CG-solved structured update improves reconstruction fidelity while reducing the frequency-dependent residual noise. Method #Iters Params (M) Mem. (GB) FBPConvNet [10] - 31.1 1.51 Learn PD [2] 10 0.251 0.75 LEARN [5] 30 1.8 1.41 QN-Mixer† [3] 14 8.5 7.83 RegFormer [29] 10 2.7 5.79 DPMA [28] 300 8.1 7.78 CG-GLORE (ours) 15 5.5 5.6 † The results are cited from [3]. Table 3: Computational efficiency comparison of sparse-view CT reconstruction methods trained on AAPM with nview=32n_view=32. Computational Efficiency Comparison. Table 3 compares different reconstruction methods in terms of iteration count, model size, and memory usage when available. CG-GLORE uses 15 reconstruction iterations and 5.5M parameters, offering a practical balance between optimization strength and model complexity. Compared with LEARN and DPMA, CG-GLORE requires substantially fewer iterations (15 vs. 30 and 300), while its parameter count remains lower than FBPConvNet, QN-Mixer, and DPMA. Although lightweight methods such as Learned PD use fewer parameters, CG-GLORE achieves stronger reconstruction accuracy by using CG-solved structured updates together with the compact GLORE regularizer. These results suggest that CG-GLORE improves reconstruction quality without relying on excessive unrolling depth or a very large network. 4.4 Qualitative Results Figure 5: Visual comparison on the AAPM dataset. The figure presents reconstructed CT images and their corresponding difference maps under different acquisition settings. Top row: sparse-view reconstruction with 32 projections and low noise level, visualized in the HU window [−200,300][-200,300]. Bottom row: reconstruction with 64 projections without noise, visualized in the HU window [−1000,700][-1000,700]. Visualizations of Reconstructed CT Images. Figure 5 compares representative AAPM slices under two acquisition settings. FBP shows severe streak artifacts and large HU errors from limited-view measurements. Learning-based baselines reduce these artifacts, but several methods blur fine anatomy or retain structured residuals near high-contrast boundaries. In contrast, CG-GLORE produces reconstructions closer to the ground truth, with clearer soft-tissue structures in the 32-view low-noise case and sharper lung vessels in the 64-view noise-free case. The zoomed regions show better preservation of local edges and small structures, while the difference maps contain weaker residual patterns. These observations agree with the reported PSNR/SSIM values, where CG-GLORE achieves the best reconstruction quality in both examples. The visual results suggest that the CG-solved structured update improves data consistency, while GLORE recovers anatomical details without excessive smoothing. Figure 6: Stage-wise reconstruction evolution of CG-GLORE. Intermediate reconstructions are shown under 32 projection views and a high-noise setting (NP=5×105N_P=5× 10^5), visualized in the HU window [−1000,700][-1000,700]. Stage-wise Reconstruction Evolution. Figure 6 shows the intermediate outputs of CG-GLORE across the unrolled stages. Starting from degraded early reconstructions, the model progressively suppresses streak artifacts and recovers the global body contour, followed by clearer soft-tissue contrast and more stable anatomical boundaries. The PSNR/SSIM values generally increase with iteration, indicating that the CG solver and learned regularization jointly refine the reconstruction instead of producing a single abrupt correction. This stage-wise behavior supports the optimization interpretation of CG-GLORE: each unrolled step adds a data-consistent refinement under the learned global-local prior. 4.5 Ablation Studies Variant PSNR SSIM 3 Convs + First-order 36.02 92.94 GLORE + First-order 40.09 96.63 3 Convs + CG 40.45 96.76 GLORE + CG 40.54 96.85 Table 4: Impact of CG and GLORE components. CG Iter. PSNR SSIM 1 33.95 83.29 3 40.29 96.72 5 40.45 96.78 10 40.54 96.85 Table 5: Impact of CG solver depth. (k×k,C)(k× k,C) PSNR SSIM (1×1,64)(1× 1,64) 40.45 96.79 (2×2,64)(2× 2,64) 40.54 96.85 (4×4,32)(4× 4,32) 39.22 96.07 (8×8,24)(8× 8,24) 37.21 94.59 Table 6: Impact of Sliding Window (k×k)(k× k) and Embedding Size C. Tables 6–6: Component and hyperparameter analysis of CG-GLORE on AAPM under the shared setting of nview=32n_view=32, NG=5%N_G=5\%, and NP=1×106N_P=1× 10^6. CG-GLORE Ablation. Table 6 evaluates the contribution of the CG-based update and the GLORE regularizer. Using only three convolutional layers with a first-order update gives the weakest result, indicating that a shallow local prior alone is insufficient for sparse-view reconstruction. Replacing the local regularizer with GLORE under the same first-order update improves PSNR from 36.02 to 40.09 and SSIM from 92.94 to 96.63, showing the benefit of combining local features with long-range dependency modeling. Introducing CG with the three-convolution regularizer also yields a large improvement, reaching 40.45/96.76 in PSNR/SSIM. The full CG-GLORE model achieves the best result of 40.54/96.85, confirming that the CG-solved structured update and global-local regularization are complementary. CG Solver Depth. Table 6 studies the number of CG iterations used to solve the structured surrogate system. With only one CG iteration, the approximation is insufficient and the reconstruction quality remains low. Increasing the depth to three iterations produces a substantial gain, from 33.95/83.29 to 40.29/96.72, indicating that a few conjugate directions already provide a more accurate surrogate update. Further increasing the depth to five and ten iterations gives smaller but consistent improvements. We therefore use ten CG iterations as the default setting, which offers the best reconstruction quality while keeping the solver cost moderate. Sliding Window Size and Embedding Dimension. Table 6 analyzes the sparse patchification design in LORAD. The 1×11× 1 setting preserves the full spatial resolution but provides limited token-level aggregation. The proposed 2×22× 2 window achieves the best performance, suggesting a favorable balance between long-range context modeling and local detail preservation. Larger windows, such as 4×44× 4 and 8×88× 8, reduce the number of tokens more aggressively and require smaller embedding dimensions, which weakens the representation of fine structures and leads to degraded reconstruction quality. This supports the choice of k=2k=2 and C=64C=64 in the default CG-GLORE configuration. 5 Conclusion We presented CG-GLORE, a second-order-inspired deep unrolling framework for sparse-view CT reconstruction. Each stage uses a CG-solvable structured Hessian surrogate that retains the physics-induced data-fidelity curvature while using an identity approximation for the learned regularization term; it is therefore not an exact Newton method for the full learned objective. GLORE combines convolutional local modeling with efficient long-range dependency representation. Experiments on AAPM and DeepLesion show improved reconstruction quality, particularly in highly ill-conditioned settings, while ablations support the complementary contributions of the CG solver and GLORE. Overall, CG-GLORE offers an effective balance between model-based optimization and learned regularization for sparse-view CT reconstruction. Future work will investigate broader validation on real clinical acquisition protocols and extension to more general 3D reconstruction settings. Acknowledgment This work was supported by JST-ALCA-Next (JPMJAN23F4). References [1] J. Adler, H. Kohr, and O. Öktem (2017) Operator discretization library (odl). Zenodo. Cited by: §4.2. [2] J. Adler and O. Öktem (2018) Learned primal-dual reconstruction. IEEE transactions on medical imaging 37 (6), p. 1322–1332. Cited by: §2, §3.2, Table 1, Table 2, Table 3. [3] I. Ayad, N. Larue, and M. K. Nguyen (2024) QN-mixer: a quasi-newton mlp-mixer model for sparse-view ct reconstruction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 25317–25326. Cited by: §2, §4.1, Table 1, Table 1, Table 3, Table 3. [4] L. Chao, Z. Wang, H. Zhang, W. Xu, P. Zhang, and Q. Li (2022) Sparse-view cone beam ct reconstruction using dual cnns in projection domain and image domain. Neurocomputing 493, p. 536–547. Cited by: §1, §2. [5] H. Chen, Y. Zhang, Y. Chen, J. Zhang, W. Zhang, H. Sun, Y. Lv, P. Liao, J. Zhou, and G. Wang (2018) LEARN: learned experts’ assessment-based reconstruction network for sparse-data ct. IEEE transactions on medical imaging 37 (6), p. 1333–1347. Cited by: §2, §3.2, Table 1, Table 3. [6] A. M. Cormack (1963) Representation of a function by its line integrals, with some radiological applications. Journal of applied physics 34 (9), p. 2722–2727. Cited by: §1. [7] A. Galántai (2000) The theory of newton’s method. Journal of Computational and Applied Mathematics 124 (1-2), p. 25–44. Cited by: §3.2. [8] K. He, X. Zhang, S. Ren, and J. Sun (2016) Identity mappings in deep residual networks. In ECCV, Cited by: §3.3.3. [9] M. R. Hestenes and E. Stiefel (1952) Methods of conjugate gradients for solving linear systems. Journal of Research of the National Bureau of Standards 49 (6), p. 409–436. Cited by: §3.2. [10] K. H. Jin, M. T. McCann, E. Froustey, and M. Unser (2017) Deep convolutional neural network for inverse problems in imaging. IEEE transactions on image processing 26 (9), p. 4509–4522. Cited by: §2, §3.1, Table 1, Table 2, Table 3. [11] M. Katsura, I. Matsuda, M. Akahane, J. Sato, H. Akai, K. Yasaka, A. Kunimatsu, and K. Ohtomo (2012) Model-based iterative reconstruction technique for radiation dose reduction in chest ct: comparison with the adaptive statistical iterative reconstruction technique. European radiology 22 (8), p. 1613–1623. Cited by: §1. [12] K. Levenberg (1944) A method for the solution of certain non-linear problems in least squares. Quarterly of Applied Mathematics. Cited by: §3.3.3. [13] D. Marquardt (1963) An algorithm for least-squares estimation of nonlinear parameters. SIAM Journal. Cited by: §3.3.3. [14] C. McCollough (2016) TU-fg-207a-04: overview of the low dose ct grand challenge. Medical physics 43 (6Part35), p. 3759–3760. Cited by: §4.1. [15] D. Nguyen, M. Assran, U. Jain, M. R. Oswald, C. G. Snoek, and X. Chen (2024) An image is worth more than 16x16 patches: exploring transformers on individual pixels. arXiv preprint arXiv:2406.09415. Cited by: §3.3.2. [16] J. Nocedal and S. J. Wright (2006) Numerical optimization. 2 edition, Springer. Cited by: §3.2. [17] M. K. Razavi, A. Kerayechian, M. Gachpazan, and S. Shateyi (2014) A new iterative method for finding approximate inverses of complex matrices. In Abstract and Applied Analysis, Vol. 2014, p. 563787. Cited by: §3.3.2. [18] C. W. Royer, M. O’Neill, and S. J. Wright (2020) A newton-cg algorithm with complexity guarantees for smooth unconstrained optimization. Mathematical Programming 180, p. 451–488. Cited by: §3.2. [19] D. Shen, G. Wang, W. Wang, M. R. Min, Q. Su, Y. Zhang, C. Li, R. Henao, and L. Carin (2018) Baseline needs more love: on simple word-embedding-based models and associated pooling mechanisms. arXiv preprint arXiv:1805.09843. Cited by: §3.3.2. [20] T. Su, Z. Cui, J. Yang, Y. Zhang, J. Liu, J. Zhu, X. Gao, S. Fang, H. Zheng, Y. Ge, et al. (2022) Generalized deep iterative reconstruction for sparse-view ct imaging. Physics in Medicine & Biology 67 (2), p. 025005. Cited by: §3.1, §3.2. [21] X. Tao, Y. Wang, L. Lin, Z. Hong, and J. Ma (2021) Learning to reconstruct ct images from the vvbp-tensor. IEEE Transactions on Medical Imaging 40 (11), p. 3030–3041. Cited by: §1, §2. [22] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin (2017) Attention is all you need. Advances in neural information processing systems 30. Cited by: §3.3.2. [23] C. Wang, K. Shang, H. Zhang, Q. Li, and S. K. Zhou (2022) DuDoTrans: dual-domain transformer for sparse-view ct reconstruction. In International Workshop on Machine Learning for Medical Image Reconstruction, p. 84–94. Cited by: §3.1. [24] F. Wang, R. Wang, and H. Qiu (2024) Low-dose ct reconstruction using dataset-free learning. PLoS One 19 (6), p. e0304738. Cited by: §1. [25] G. Wang, H. Yu, and B. De Man (2008) An outlook on x-ray ct research and development. Medical physics 35 (3), p. 1051–1064. Cited by: §1. [26] S. Wang and Z. Zhang (2013) Improving cur matrix decomposition and the nyström approximation via adaptive sampling. The Journal of Machine Learning Research 14 (1), p. 2729–2769. Cited by: §3.3.2. [27] D. Wu, K. Kim, and Q. Li (2021) Low-dose ct reconstruction with noise2noise network and testing-time fine-tuning. Medical Physics 48 (12), p. 7657–7672. Cited by: §1, §2. [28] J. Wu, J. Lin, X. Jiang, W. Zheng, L. Zhong, Y. Pang, H. Meng, and Z. Li (2025) Dual-domain deep prior guided sparse-view ct reconstruction with multi-scale fusion attention. Scientific Reports 15 (1), p. 16894. Cited by: §2, §3.1, §3.2, Table 1, Table 2, Table 3. [29] W. Xia, Z. Yang, Z. Lu, Z. Wang, and Y. Zhang (2023) RegFormer: a local–nonlocal regularization-based model for sparse-view ct reconstruction. IEEE Transactions on Radiation and Plasma Medical Sciences 8 (2), p. 184–194. Cited by: §2, §3.2, Table 1, Table 2, Table 3. [30] Y. Xiong, Z. Zeng, R. Chakraborty, M. Tan, G. Fung, Y. Li, and V. Singh (2021) Nyströmformer: a nyström-based algorithm for approximating self-attention. In Proceedings of the AAAI conference on artificial intelligence, Vol. 35, p. 14138–14148. Cited by: §3.3.2. [31] K. Yan, X. Wang, L. Lu, and R. M. Summers (2018) DeepLesion: automated mining of large-scale lesion annotations and universal lesion detection with deep learning. Journal of medical imaging 5 (3), p. 036501–036501. Cited by: §4.1.