Paper deep dive
LCPNet: Latent Consistent Proximal Unfolding Network for Infrared Small Target Detection
Tianfang Zhang, Fengyi Wu, Lei Li, Chang Liu, Zhenming Peng, Huaping Zhang, Xiangyang Ji
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 89%
Last extracted: 7/7/2026, 2:44:05 PM
Summary
The paper introduces LCPNet, a deep unfolding network designed for Infrared Small Target Detection (IRSTD). It addresses limitations of existing image-domain methods by performing low-rank decomposition in a latent space, utilizing a Latent Consistent Proximal (LCP) solver for direct state evolution, and implementing a Shared Optimization Memory (SOM) for unified historical guidance. Extensive experiments demonstrate superior accuracy, robustness, and low false alarms compared to state-of-the-art methods.
Entities (10)
Relation Signals (6)
LCPNet → solves → Infrared Small Target Detection
confidence 95% · LCPNet is proposed for infrared small target detection and extensive experiments on multiple IRSTD benchmarks demonstrate its superior detection accuracy.
LCPNet → incorporates → Latent Consistent Proximal Solver
confidence 92% · LCPNet derives a Latent Consistent Proximal (LCP) solver for direct proximal-state updates, allowing each latent variable to evolve from its previous state.
LCPNet → utilizes → Shared Optimization Memory
confidence 90% · LCPNet replaces branch-specific memory with Shared Optimization Memory (SOM), which is accessible to all decomposition variables and provides unified guidance.
Latent Consistent Proximal Solver → evolves → Latent Variables
confidence 88% · each solver contains NN convolutional modules... each latent variable to evolve from its previous state instead of indirect residual reconstruction.
LCPNet → operatesin → Latent Space
confidence 88% · we lift the execution domain of unfolding from image to latent, preserving the decomposition constraint while avoiding repeated projection of intermediate states.
Deep-Unfolding → bridges → Model-driven Optimization
confidence 85% · Deep unfolding offers a principled compromise by unrolling iterative optimization into a finite number of learnable stages, thereby combining interpretable algorithmic structure with data-driven representation learning.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Infrared small target detection (IRSTD) aims to identify long distance small targets from complex infrared backgrounds, and is a fundamental task in remote sensing. Deep learning methods have improved IRSTD by learning discriminative image-to-mask mappings, but such feed-forward designs often underuse physical decomposition structure between targets and backgrounds. Deep unfolding methods partially address this issue by embedding model-driven iterations into neural networks, yet existing designs still operate mainly in image domain and use updates and memory mechanisms that are not fully coupled with underlying optimization process. To address these limitations, we propose Latent Consistent Proximal unfolding network (LCPNet). First, we verify that low-rank prior remains valid in latent representations and perform unfolding in this space, preserving physical constraint while avoiding repeated compression of intermediate states. Second, we derive a Latent Consistent Proximal (LCP) solver that evolves each latent variable from its previous state rather than reconstructing through an indirect residual, and stabilizes small target updates through task-adaptive normalization and gain control. Third, we introduce Shared Optimization Memory (SOM), a common historical state shared by all decomposition variables to provide coordinated guidance across unfolding stages. Extensive experiments on four public benchmarks demonstrate that LCPNet outperforms state-of-the-art methods while achieving accurate and robust detection with low false alarms and competitive efficiency. Model and code are available at this https URL.
Tags
Links
- Source: https://arxiv.org/abs/2607.04603v1
- Canonical: https://arxiv.org/abs/2607.04603v1
Trouble viewing inline? Open PDF directly →
Full Text
88,428 characters extracted from source content.
Expand or collapse full text
LCPNet: Latent Consistent Proximal Unfolding Network for Infrared Small Target Detection Tianfang Zhang, Fengyi Wu, Lei Li, Chang Liu, Zhenming Peng, Huaping Zhang, Xiangyang Ji Corresponding author: Xiangyang Ji.Tianfang Zhang, Chang Liu and Xiangyang Ji are with the Department of Automation, Tsinghua University, Beijing, 100190, China. (E-mail: sparkcarleton@gmail.com; liuchang2022, xyji@tsinghua.edu.cn)Fengyi Wu and Zhenming Peng are with the School of Information and Communication Engineering and the Laboratory of Imaging Detection and Intelligent Perception, University of Electronic Science and Technology of China, Chengdu, 610054, China. (E-mail: wufengyi98@163.com, zmpeng@uestc.edu.cn)Lei Li and Huaping Zhang are with the School of Artificial Intelligence, Beijing Institute of Technology, Beijing, 100081, China. (E-mail: lilei, kevinzhang@bit.edu.cn) Abstract Infrared small target detection (IRSTD) aims to identify long distance small targets from complex infrared backgrounds, and is a fundamental task in remote sensing. Deep learning methods have improved IRSTD by learning discriminative image-to-mask mappings, but such feed-forward designs often underuse physical decomposition structure between targets and backgrounds. Deep unfolding methods partially address this issue by embedding model-driven iterations into neural networks, yet existing designs still operate mainly in image domain and use updates and memory mechanisms that are not fully coupled with underlying optimization process. To address these limitations, we propose Latent Consistent Proximal unfolding network (LCPNet). First, we verify that low-rank prior remains valid in latent representations and perform unfolding in this space, preserving physical constraint while avoiding repeated compression of intermediate states. Second, we derive a Latent Consistent Proximal (LCP) solver that evolves each latent variable from its previous state rather than reconstructing through an indirect residual, and stabilizes small target updates through task-adaptive normalization and gain control. Third, we introduce Shared Optimization Memory (SOM), a common historical state shared by all decomposition variables to provide coordinated guidance across unfolding stages. Extensive experiments on four public benchmarks demonstrate that LCPNet outperforms state-of-the-art methods while achieving accurate and robust detection with low false alarms and competitive efficiency. Model and code are available at https://github.com/Tianfang-Zhang/LCPNet. I Introduction Infrared small target detection (IRSTD) is a fundamental capability for long-range perception systems, with broad value in remote sensing monitoring, maritime and aerial early warning, and security reconnaissance [63, 22]. Compared to other imaging techniques, infrared sensors capture thermal radiation and can operate under weak illumination, nighttime conditions, and high disturbance. This passive imaging mechanism renders IRSTD uniquely effective in scenarios where it is difficult to observe targets through conventional visual cues. Leveraging these advantages, IRSTD offers significant practical value and is one of the most prominent and challenging tasks in low-level vision and remote sensing. The difficulty of IRSTD stems from the inherent imaging characteristics of infrared small targets. In long-range observations, a target often occupies only a few pixels, lacks stable shape and texture, and appears as an extremely sparse response embedded in a large background region [63, 22]. Such targets provide insufficient semantic evidence for conventional object detection pipelines. Meanwhile, infrared backgrounds are often highly nonuniform: cloud edges, sensor noise, and other locally bright clutter may exhibit target-like contrast, leading to false alarms [43]. Therefore, IRSTD relies more on reliable background suppression, weak target enhancement, and the precise distinction between sparse target responses and residual clutter signals [6, 13, 10]. Figure 1: Comparison of Fa(10−5)F_a(10^-5)-IoU scatter plots for infrared small target detection algorithms on IRSTD-1k [58]. Circle size indicates the parameter number. Points closer to top-left indicate better performance. Recent deep learning methods have substantially advanced IRSTD by learning more powerful multiscale and context-aware representations from annotated infrared images. CNN-based segmentation models, U-shaped architectures, attention mechanisms, and dense nested networks have improved target localization and background discrimination under complex scenes [43, 9, 10, 23, 48, 59, 25]. These methods demonstrate that data-driven feature learning can compensate for the weak appearance of infrared small targets. However, most traditional deep learning models remain confined to an end-to-end learning paradigm that directly maps infrared images to target masks. Under this paradigm, the learned behavior is mainly shaped by network architecture, loss supervision, and training data, rather than by an explicit physical model of infrared image formation. Consequently, it neglects the realistic physical modeling of background-target-noise decomposition. This limitation causes models to generate excessive and cumulative false positives in complex scenarios. Figure 2: Visualization of the low-rank property in latent domain. From top to bottom are the original infrared image, a visualized channel from the latent, and Tucker rank analysis of the latent. It can be observed that, whether in simple scene (sky XDU82 in NUDT-SIRST [23]) or complex scene (forest XDU41), the latent exhibits distinct low-rank property in both visual visualization and Tucker rank analysis. For more scenes and rank analyses, please refer to Appendix D. Physical modeling for IRSTD motivates a review of the model-driven methods. Infrared small target image naturally admits a low-rank and sparse decomposition formulation, where the observation can be regarded as the superposition of a structured background, sparse target, and noise component, i.e., =++X=B+T+N as shown in Fig. 2. Classical RPCA and infrared patch-image models provide an interpretable foundation for separating sparse targets from low-rank backgrounds [5, 13, 56, 11]. However, traditional optimization-based methods rely on fixed handcrafted priors, require iterative matrix computations, and are sensitive to regularization parameters and background statistics. Deep unfolding offers a principled compromise by unrolling iterative optimization into a finite number of learnable stages, thereby combining interpretable algorithmic structure with data-driven representation learning [29, 47, 45]. This paradigm is particularly attractive for IRSTD because each stage can be associated with a target-background-noise separation process while still adapting the solver to real infrared data. Despite this progress, existing deep unfolding methods still face three key limitations. First, to preserve the image-domain physical constraint, most unfolding frameworks transmit image-domain variables between adjacent stages [47, 45]. This design requires each stage to project its intermediate representation back to low-dimensional images. Such repeated compression preserves explicit physical interface, but it would weaken the high-frequency and low-contrast responses that are critical for small target detection. Second, existing learned proximal solvers often obtain variables through indirect residual reconstruction, rather than directly evolving the previous state [29, 47, 45] as shown in Fig. 3(a). This weakens the continuity of background trajectory and may cause target leakage. Moreover, batch normalization is not well suited to IRSTD, since its statistics are dominated by abundant background pixels and fluctuate under small training batches, which can dilute weak target responses and destabilize repeated unfolding updates [21, 49, 8, 28]. Third, existing cross-stage memory mechanisms are typically attached to a single decomposition variable, so historical information is reused only within a local update [35, 45]. Such branch-specific memory does not represent a shared optimization state of the unfolding process as in Fig. 3(b)(left), and therefore cannot provide common historical guidance for all coupled decomposition variables. Figure 3: Illustration of design differences between methods. (a) Upper: formula-based modeling. Lower: feature visualization. In previous studies (left), Bk−1B^k-1 and BkB^k are similar, but the update using Dk−1−Tk−1D^k-1-T^k-1 violates feature consistency. In our LCP solver (right), the current state is directly determined by previous state, thereby ensuring feature consistency. (b). Previous methods (left) only used branch-level memory when updating B. Our SOM (right) features a shared optimization memory state for all variables, which directly participates in all updates, ensuring the historical memory of each one. To address these issues, we propose Latent Consistent Proximal Unfolding Network (LCPNet) for infrared small target detection. After verifying that the low-rank physical prior remains valid in latent representation, we lift the execution domain of unfolding from image to latent, preserving the decomposition constraint while avoiding repeated projection of intermediate states. Then, LCPNet derives a Latent Consistent Proximal (LCP) solver for direct proximal updates, where each variable is evolved from its previous state rather than reconstructed from an indirect residual. Its updater further uses group-wise normalization and spectral gain control to better fit the small-batch and background-dominated characteristics of IRSTD. Finally, LCPNet replaces branch-specific memory with Shared Optimization Memory (SOM), which is accessible to all decomposition variables and provides unified guidance for the coupled latent optimization across stages. The main contributions of this work are summarized as follows: • We verify that the low-rank decomposition prior remains valid in latent representations. Based on this observation, we formulate latent-domain unfolding to preserve the physical constraint while avoiding repeated variable compression. • We derive a LCP solver for consistent proximal-state updates, allowing each latent variable to evolve from its previous state instead of indirect residual reconstruction. A group-wise and gain-controlled updater is further adopted to suppress background induced false alarms. • We propose SOM as a system-level historical state for the unfolding process. SOM is shared by all decomposition variables and provides unified guidance for latent updates across stages. • We propose LCPNet for infrared small target detection and extensive experiments on multiple IRSTD benchmarks demonstrate its superior detection accuracy, robust scene adaptability, and effective false-alarm suppression under diverse infrared scenes as shown in Fig. 1. Figure 4: Overall architecture of LCPNet. An infrared image is first lifted into the latent domain, where latent-space decomposition is performed through K unfolding stages, and the final target representation is decoded to image domain for detection. I Related Work I-A Infrared Small Targets Detection Existing IRSTD methods can be broadly grouped into Human Visual System (HVS)-based methods, optimization-based methods, and deep learning-based methods [63, 22, 32]. HVS-based methods are among the earliest solutions. They assume that small targets exhibit local intensity discontinuity relative to their surrounding background and therefore enhance target-like responses through handcrafted filters or local contrast measures. Representative methods include Top-hat filtering [42], max-mean and max-median filtering [12], local contrast measure (LCM) [6], and multiscale patch-based contrast measure (MPCM) [44]. These methods are simple, and computationally attractive, but their handcrafted saliency assumptions are often fragile in complex scenes. Optimization-based methods regard infrared backgrounds as containing strong structural redundancy and can be represented by low-rank priors, while small targets are sparse outliers embedded in the observation. Based on this idea, the infrared patch-image (IPI) model formulates small target detection as a low-rank and sparse decomposition problem [13]. NRAM further introduces non-convex rank approximation with structured sparsity to better characterize target components [56], while PSTNN exploits patch-tensor modeling with nonlocal priors for single-frame detection [11]. Compared with HVS-based methods, optimization-based methods provide clearer physical interpretability. However, they usually require iterative solvers, manually designed priors, and carefully tuned parameters, which limits their efficiency. Deep learning-based methods have recently become the dominant paradigm for IRSTD. Most of these methods are non-unfolding networks, which directly learn a segmentation mapping from the infrared input to the target mask in an end-to-end manner. Early data-driven studies such as MDvsFA treat IRSTD as small object segmentation and consider the tradeoff between missed detections and false alarms [43]. Subsequent works improve representation learning by designing IRSTD-specific networks, including asymmetric contextual modulation [9], attentional local contrast learning [10], dense nested attention [23], UNet-in-UNet structures [48], attention-guided pyramid context aggregation [59], and shape-aware supervision [58]. More recent methods further explore scale and location sensitivity [25], SAM adaptation for infrared small targets [57], learnable saliency kernels [46], pinwheel-shaped convolution and scale-aware loss design [51], and low-level feature modeling [24]. These networks have greatly improved detection accuracy, but their inference process is usually a black-box input-to-mask mapping. Another emerging branch is deep unfolding-based IRSTD, which converts iterations of a traditional optimization algorithm into trainable stages [29]. This paradigm preserves model interpretability while replacing expensive analytical subsolvers with learnable neural modules. RPCANet and RPCANet++ instantiate this idea by unfolding RPCA-like decomposition for infrared small target detection and enhancing it with learnable stage-wise modules [47, 45]. With its ability to integrate physical priors and data-adaptive learning, deep unfolding provides a promising foundation for more reliable and interpretable IRSTD models. I-B Deep Unfolding in Vision Models Deep unfolding transforms an iterative optimization algorithm into a trainable network by mapping each iteration to a network stage and replacing fixed algorithmic components with learnable parameters or neural operators [29]. It bridges model-driven optimization and modern deep vision by preserving algorithmic structure and reducing iterative inference cost. The idea first became influential in sparse coding and compressive sensing [14, 60]. ISTA-Net unfolds ISTA into a structured network with learnable transforms, achieving interpretable and efficient reconstruction [55], while LDAMP and AMP-Net unfold denoising-based approximate message passing for compressive image recovery [27, 62]. ADMM-Net similarly unfolds ADMM for MRI, replacing shrinkage functions with trainable counterparts [52]. Beyond this, unfolding has been widely adopted in image inverse problems [2, 17]. These methods avoid learning the entire inverse mapping from scratch; instead, they constrain certain calculations using known physical laws, while neural modules learn the missing prior [1, 41]. Low-rank and sparse decomposition is another natural domain for unfolding [5]. Learned RPCA extends this idea by unfolding scalable RPCA iterations and learning thresholds [4]. For IRSTD, RPCANet and RPCANet++ instantiate this principle and retain the background-target decomposition structure [47, 45]. Diffusion and score-based generative models can also be viewed as broad deep unfolding vision models, since they parameterize long denoising trajectories with learned stage-wise operators [36, 39, 18, 31, 37, 40, 34]. This broader view links unfolding, iterative generation, and inverse vision models through a shared emphasis on stage design, update stability, and state propagation. Figure 5: Details of our custom-designed modules. (a) Illustration of the k-th unfolding stage, fk−1∈ℬ,,,k−1f^k-1∈\B,T,N,Y\^k-1 is a set of latent variables. (b) Illustration of LCP solver, each solver contains N convolutional modules. ksks denotes convolutional kernel size, and g denotes the group number in GN. (c) Illustration of SOM, where Ok−1=Cat([,fk−1])O^k-1=Cat([X,\f^k-1\]). I-C Recurrent and State-Space Optimization in Vision In unfolding vision networks, historical states help each stage reuse previous residuals along the optimization trajectory. This view is consistent with classical momentum and optimization [30], and is often implemented with recurrent modules such as LSTM, GRU, and ConvLSTM, which preserve temporal states through gated transitions [19, 7, 35]. Recurrent state modeling has been adopted in several inverse-vision solvers. Recurrent inference machines learn iterative inverse-problem updates with a hidden state [33] and MRI reuse cross-stage estimates through dense recurrent connections and recurrent variational networks [20, 53, 38]. These methods show that treating stage history as part of the solver state can improve reconstruction quality and optimization efficiency. State-space models further broaden this idea for visual representation. S4 and Mamba propagate hidden states over long sequences with efficient structured [16, 15], while vision mamba adapt such state propagation to images through bidirectional visual scans [64, 26]. Motivated by these developments, LCPNet uses a shared optimization memory to represent the historical trajectory of the coupled latent decomposition variables, allowing system-level state to guide all primal-variable updates across unfolding stages. I Methodology This section presents the methodology of LCPNet in a progressive manner. We first verified that physical priors remain valid in latents and reformulate the decomposition in latent domain. We then derive LCP solver for direct proximal-state updates, followed by the SOM that provides historical guidance for all coupled variables. Finally, we describe how these components are instantiated in the network architecture. I-A Latent-Space Decomposition Formulation Classical low-rank and sparse decomposition methods formulate IRSTD as an image-domain separation problem. Given an infrared observation X, the background, target, and noise components are estimated directly in the physical image space: =++,s.t.,,,∈ℝH×W.X=B+T+N, .t. ,B,T,N ^H× W. (1) This formulation is the basis of representative model-driven methods such as IPI, NRAM, and PSTNN [13, 56, 11], and it is also inherited by recent image-domain unfolding frameworks such as RPCANet and RPCANet++ [47, 45]. Its main advantage is that the optimization variables remain directly interpretable in the physical image domain. However, when this formulation is unfolded into a deep network, each stage still exchanges single-channel physical variables and repeatedly projects the optimization trajectory back to ℝH×WR^H× W. This low-dimensional stage interface can attenuate high-frequency small-target clues during reconstruction and prevents background, target, and noise representations from evolving persistently in a high-dimensional feature space. To address these limitations, we first verified the low-rank property of latent variable through visualization and singular value analysis, as shown in Fig. 2. The singular values plot of the feature tensor decay rapidly, and indicates that latent representation still satisfies the low-rank physical assumption. This prior is applicable to both simple and complex scenarios, and Appendix D further demonstrates this prior from multiple perspectives. More specifically, we use a set of encoders to map image-domain variables to latent variables: =EX(),ℬ=EB(),=ET(),=EN(). gatheredX=E_X(X), =E_B(B),\\ T=E_T(T), =E_N(N). gathered (2) The decomposition constraint is then imposed in the latent space: =ℬ++,s.t.,ℬ,,∈ℝH×W×C.X=B+T+N, .t. ,B,T,N ^H× W× C. (3) Compared with the image-domain formulation, the latent manifold provides a high-dimensional stage interface, allowing small-target and background structures to be propagated through C-channel optimization variables. This design preserves weak high-frequency target evidence across stages and lets background, target, and noise representations evolve on a richer latent manifold. After the iterative decomposition, projectors map the target-related latent variables back to the image domain for final detection output. Under this latent-space physical model, the general decomposition objective of IRSTD can be written as ℒ(μ)=ℛℬ(ℬ)+ℛ()+ℛ(;σ)⏟Constraint Items+ℱ(ℬ,,)⏟Fidelity Item,L(μ)= R_B(B)+R_T(T)+R_N(N;σ)_Constraint Items+ F(B,T,N)_Fidelity Item, (4) where ℛℬ(⋅)R_B(·), ℛ(⋅)R_T(·), and ℛ(⋅;σ)R_N(·;σ) denote the constraint items, and these constraint functions are assumed to be unknown in the latent space. The fidelity item enforces consistency with the latent observation and is usually instantiated as ℱ(ℬ,,)=μ2‖−ℬ−‖F2F(B,T,N)= μ2 \|X-B-T-N \|_F^2. Following the Alternating Direction Method of Multipliers (ADMM) [3], we introduce the latent dual variable Y and write the augmented Lagrangian as: ℒμ _μ (ℬ,,,)=ℛℬ(ℬ)+ℛ()+ℛ(;σ) (B,T,N,Y)=R_B(B)+R_T(T)+R_N(N;σ) (5) +⟨,−ℬ−⟩+μ2‖−ℬ−‖F2. + ,X-B-T-N + μ2 \|X-B-T-N \|_F^2. ADMM decomposes this objective into three main subproblems for ℬB, T, and N. Since these subproblems share the same proximal form, we take the ℬB-subproblem as the representative case, with the detailed derivation provided in Appendix A: ℬk= ^k= argminℬℛℬ(ℬ) _B\ R_B(B) (6) +μ2‖−ℬ−k−1−k−1+1μk−1‖F2. + μ2 \|X-B-T^k-1-N^k-1+ 1μY^k-1 \|_F^2. The next subsection details how LCPNet turns this implicit latent proximal step into a direct learnable solver. I-B Latent Consistent Proximal (LCP) Solver We derive the LCP solver from the ℬB-subproblem. For compactness, define the problem as: Bk−1=−k−1−k−1+1μBk−1.V_B^k-1=X-T^k-1-N^k-1+ 1 _BY^k-1. (7) Then the ℬB update can be written in the proximal form ℬk=argminℬℛℬ(ℬ)+μB2‖ℬ−Bk−1‖F2.B^k= _B\ R_B(B)+ _B2 \|B-V_B^k-1 \|_F^2. (8) In conventional optimization-based IRSTD models, the regularizer ℛℬ(⋅)R_B(·) is manually specified to encode a prescribed background prior, such as low-rank priors with nuclear norm ∥⋅∥∗\|·\|_* constraints. However, there is an inherent gap between manually specified priors and the true physical attributes, so no analytical constraint can fully characterize the desired component. We therefore regard ℛℬ(⋅)R_B(·) as an unknown latent regularizer. Specifically, assume that ∇ℛℬ _B is LBL_B-Lipschitz continuous: ‖∇ℛℬ()−∇ℛℬ()‖F≤LB‖−‖F. \| _B(U)- _B(V) \|_F≤ L_B \|U-V \|_F. (9) Under the Lipschitz condition in Eq. 9, the smooth Taylor upper bound [30] gives: ℛℬ(ℬ)≤ _B(B)≤ ℛℬ(ℬk−1)+⟨∇ℛℬ(ℬk−1),ℬ−ℬk−1⟩ \ R_B(B^k-1)+ _B(B^k-1),B-B^k-1 (10) +LB2‖ℬ−ℬk−1‖F2,∀ℬ∈ℝH×W×C. + L_B2 \|B-B^k-1 \|_F^2, ^H× W× C. Substituting the majorization in Eq. 10 into the proximal subproblem in Eq. 8, and removing constants independent of ℬB, gives the surrogate objective: ^ℬ(ℬ)= J_B(B)= LB2‖ℬ−(ℬk−1−1LB∇ℛℬ(ℬk−1))‖F2 \ L_B2 \|B- (B^k-1- 1L_B _B(B^k-1) ) \|_F^2 (11) +μB2‖ℬ−Bk−1‖F2. + _B2 \|B-V_B^k-1 \|_F^2. The surrogate objective in Eq. 11 is the sum of two quadratic terms. Its minimizer admits the following closed-form update, with the detailed derivation provided in Appendix B: ℬk=LBLB+μBℬk−1+μBLB+μBBk−1−∇ℛℬ(ℬk−1)LB+μB.B^k= L_BL_B+ _BB^k-1+ _BL_B+ _BV_B^k-1- _B(B^k-1)L_B+ _B. (12) The closed-form solution in Eq. 12 is strictly equivalent to a gradient-like descent step: ℬk=ℬk−1−1LB+μB(∇ℛℬ(ℬk−1)+μB(ℬk−1−Bk−1)).B^k=B^k-1- 1L_B+ _B ( _B(B^k-1)+ _B(B^k-1-V_B^k-1) ). (13) Equivalently, this update can be written as: ℬk=ℬk−1−ηBBk−1,B^k=B^k-1- _BG_B^k-1, (14) where ηB=1/(LB+μB) _B=1/(L_B+ _B). This formulation explicitly anchors the update on the previous state ℬk−1B^k-1, providing a more directly reference for estimating the next background state ℬkB^k. By substituting Eq. 7 into Eq. 13 and defining the current latent residual as k−1=−ℬk−1−k−1−k−1P^k-1=X-B^k-1-T^k-1-N^k-1, the ideal update direction is directly obtained as: Bk−1=∇ℛℬ(ℬk−1)−μBk−1−k−1.G_B^k-1= _B(B^k-1)- _BP^k-1-Y^k-1. (15) However, directly computing Bk−1G_B^k-1 inside a network module is not practical. First, ℛℬ(⋅)R_B(·) is an unknown latent regularizer, so ∇ℛℬ(ℬk−1) _B(B^k-1) has no explicit analytical form. Second, explicitly concatenating k−1Y^k-1, ℬk−1B^k-1, and k−1P^k-1 as solver inputs increases the input complexity of each unfolding stage. Third, the true update direction should not depend only on the current variables, it should also reflect the historical optimization trajectory across previous stages. Therefore, we replace the ideal direction in Eq. 15 with a learnable latent proximal surrogate: Bk−1≈~Bk−1=ΨB(ℬk−1−k−1,hk).G_B^k-1≈ G_B^k-1= _B(B^k-1-P^k-1,h^k). (16) Instead of directly concatenating all solver variables, ℬk−1−k−1B^k-1-P^k-1 serves as a compact variable-centered residual that fuses the current background estimate and the decomposition-consistency violation into a single surrogate cue. Based on this approximation, we obtain a more direct Markov-like LCP solver that incorporates historical trajectories: ℬk=ℬk−1−ηBΨB(ℬk−1−k−1,hk),B^k=B^k-1- _B _B(B^k-1-P^k-1,h^k), (17) hkh^k complements the current variables with global memory from previous stages. The construction of this shared state and its role in encoding historical optimization trajectories are detailed in Section I-C. I-C Shared Optimization Memory (SOM) Existing recurrent unfolding methods usually place the memory mechanism inside a specific branch of the unfolding network. For example, RPCANet++ introduces a memory-augmented module to alleviate inter-stage transmission loss in background approximation module, mainly aiming to preserve background features across stages [45]. The stored memory mainly serves the background branch, and thus cannot directly modulate the target and noise updates. The target branch can only benefit from this memory indirectly through the background representation. Moreover, the variables ℬB, T, N, Y, and X are not encoded as a coupled decomposition system, so the historical optimization trajectory is only partially represented. To address these limitations, LCPNet constructs a SOM for the whole decomposition process. At stage k, we form a joint observation by concatenating the current latent variables: ok=[ℬk,k,k,k,].o_k=[B^k,T^k,N^k,Y^k,X]. (18) An optimization state cell then maps this joint observation into a shared state hkh_k through a gated recurrent mechanism [7]: zk=σ(Wz∗[ok,hk−1]+bz),rk=σ(Wr∗[ok,hk−1]+br),h~k=tanh(Wq∗[ok,rk⊙hk−1]+bq),hk=(1−zk)⊙hk−1+zk⊙h~k. gatheredz_k=σ(W_z*[o_k,h_k-1]+b_z),\\ r_k=σ(W_r*[o_k,h_k-1]+b_r),\\ h_k= (W_q*[o_k,r_k h_k-1]+b_q),\\ h_k=(1-z_k) h_k-1+z_k h_k. gathered (19) As shown in Fig 5(c), ∗* denotes convolution, zkz_k is the update gate, rkr_k is the reset gate, and ⊙ denotes element-wise multiplication. Unlike branch-specific memory, hkh_k is shared by the ℬB, T, and N update branches and is directly fed into their proximal surrogate updaters. Therefore, the same system-level state can modulate all primal updates, making hkh_k a global control variable for the unfolding solver. The adaptive gates aggregate historical decomposition observations into a high-order effective memory of the unfolding trajectory. Recursively expanding Eq. 19 gives hk=(∏i=1k(1−zi))⊙h0+∑t=1k[zt⊙h~t⊙∏i=t+1k(1−zi)].h_k= ( _i=1^k(1-z_i) ) h_0+ _t=1^k [z_t h_t _i=t+1^k(1-z_i) ]. (20) Eq. 20 shows that hkh_k is a gated accumulation of all previous candidate states, where historical information is adaptively retained across stages. The detailed proof is provided in Appendix C, and this expansion indicates that SOM forms a shared high-order memory for the whole latent system rather than isolated branch-wise states. I-D Network Architecture The overall architecture of LCPNet is shown in Fig. 4. Given an infrared image, LCPNet first lifts the input into latent domain and then performs K stages of latent decomposition unfolding. As illustrated in Fig. 5(a), each stage updates the background, target, noise, and dual variables under the latent decomposition constraint, while SOM provides historical guidance for the stage-wise proximal surrogate updates. The final target representation is decoded back to the image domain to generate the detection map. The update module in each stage is shown in Fig. 5(b). Following the LCP solver derived in Eq. 16, the module estimates the learned proximal direction from the variable residual and shared optimization state. The same design is used for different primal variable branches. For the updater in LCP solver, a standard batch normalization design is sensitive to mini-batch statistics, which is not ideal for IRSTD because infrared backgrounds vary across scenes and small targets occupy only a few pixels [21]. We therefore use Group Normalization (GN) to normalize features within each sample, reducing the dependence on batch-level statistics while preserving scene-specific feature variations [49]. Furthermore, Spectral Normalization (SN) is adopted to constrain the gain of the convolutional updater, preventing background fluctuations from being repeatedly amplified and improving the discrimination of weak target responses: SN()=σmax(),SN(W)= W _ (W), (21) where σmax() _ (W) denotes the largest singular value of the convolutional weight W, and the normalized operator is used in the recurrent unfolding updater [28]. As shown in Fig. 5(b), the final update module combines this gain-controlled convolution with sample-wise normalization and nonlinear activation, providing a smoother approximation to the learned proximal direction ~Bk−1 G_B^k-1. Figure 6: Visualization of the last layer feature maps produced by different methods. For each method, the feature map is projected by PCA, and the most informative principal component is selected for visualization. Rows 1, 3, 4 are 001322, 000562, 000377 in NUDT-SIRST [23]. Row 2 is XDU902 in IRSTD-1k [58]. TABLE I: Comparison with state-of-the-art IRSTD methods in terms of IoU(%), F1F_1(%), PdP_d(%) and Fa(10−5)F_a(10^-5) on four benchmarks. The best and second-best results under each metric are highlighted in bold and underlined, respectively. Inference speed is measured on an NVIDIA GeForce RTX 3090 GPU and an AMD EPYC 7502 CPU. Model NUDT-SIRST IRSTD-1K SIRST SIRST-Aug Params Flops Time(ms) IoU↑ F1F_1↑ PdP_d↑ FaF_a↓ IoU↑ F1F_1↑ PdP_d↑ FaF_a↓ IoU↑ F1F_1↑ PdP_d↑ FaF_a↓ IoU↑ F1F_1↑ PdP_d↑ FaF_a↓ (M) (G) (CPU/GPU) HVS-Based Methods Tophat [42] 22.25 36.41 91.21 75.73 6.64 12.46 81.09 14.24 26.93 42.44 88.99 18.27 16.37 28.14 81.15 160.3 - - 0.08/- Max-Median [12] 20.49 34.01 84.97 31.27 20.76 34.38 85.56 21.21 32.56 49.12 94.46 3.38 16.88 28.89 79.36 8.25 - - 7836/- MPCM [44] 9.26 16.95 70.58 32.72 15.70 27.13 62.54 12.47 22.30 36.47 90.83 5.56 19.76 33.00 93.39 3.14 - - 69.78/- HBMLCM [32] 7.60 14.13 60.74 17.84 12.60 22.38 57.73 10.08 11.95 21.36 79.81 41.32 2.37 46.37 50.61 146.1 - - 6107/- Optimization-Based Methods IPI [13] 34.62 51.43 92.38 7.54 25.27 40.35 83.51 20.93 44.83 61.90 97.25 3.76 21.93 35.97 80.05 3.62 - - 8004/- NRAM [56] 11.44 20.52 65.71 2.35 17.97 30.46 59.79 5.71 26.39 41.75 88.07 1.60 10.41 18.86 76.06 3.26 - - 2443/- NOLC [61] 18.60 31.37 70.68 3.96 10.90 19.65 64.26 1.83 20.35 33.82 83.48 1.36 8.68 15.97 59.00 6.69 - - 102.3/- PSTNN [11] 25.17 40.22 80.21 7.61 24.39 39.22 65.29 15.77 35.17 52.04 88.99 2.57 12.38 22.04 60.79 2.98 - - 62.46/- Deep learning-Based Methods ACM [9] 69.46 81.98 97.14 13.11 54.16 70.25 83.84 7.32 66.77 80.07 98.16 11.03 67.79 80.80 95.87 32.52 0.51 0.42 -/7.17 AGPCNet [59] 85.02 91.90 97.88 4.34 60.44 75.34 90.72 6.10 68.19 81.08 99.10 12.09 72.07 83.77 98.62 29.39 12.4 43.0 -/14.71 DNANet [23] 87.73 93.47 97.67 5.52 62.23 76.72 92.44 5.64 73.12 84.48 99.08 10.26 70.56 82.74 96.56 36.49 4.69 13.9 -/22.64 UIUNet [48] 88.94 94.15 95.23 1.53 63.08 77.36 92.10 6.09 72.15 83.82 98.16 7.90 70.76 82.88 96.70 34.30 50.5 54.2 -/27.50 MSHNet [25] 75.96 86.34 95.23 8.28 64.83 78.67 92.78 7.14 64.64 78.52 98.16 15.66 71.93 83.67 99.03 32.06 4.06 6.01 -/13.52 SCTransNet [54] 89.49 94.45 97.67 1.02 62.04 76.56 73.47 2.36 71.15 83.14 97.24 0.89 72.05 83.20 97.76 5.20 11.3 10.0 -/31.42 ALCNet [10] 80.75 89.35 97.56 9.56 60.69 75.53 85.57 5.17 70.31 82.57 99.08 11.36 67.38 80.51 97.94 28.68 0.43 0.38 -/9.51 ISNet [58] 87.05 93.08 96.83 4.05 63.00 77.29 88.66 5.52 66.96 80.20 96.33 9.85 71.10 83.11 97.66 30.33 1.08 30.3 -/28.30 IRSAM [57] 87.85 93.53 99.05 3.21 63.58 77.74 92.10 4.21 67.97 80.93 99.08 8.34 72.29 83.95 99.02 25.94 10.5 37.6 -/75.06 L2SKNet [46] 93.08 96.42 97.88 1.35 57.07 72.67 90.03 37.90 62.54 76.96 97.25 10.63 71.89 83.65 98.62 31.56 1.07 5.92 -/9.38 Deep Unfolding-Based Methods RPCANet [47] 89.31 94.35 97.14 2.87 63.21 77.45 88.31 4.39 70.37 82.61 95.41 7.42 72.54 84.08 98.21 34.14 0.68 44.3 -/15.40 RPCANet++ [45] 94.39 97.12 98.41 1.34 64.93 78.73 89.70 4.35 74.63 85.47 100.0 10.22 69.97 82.33 98.76 28.00 2.96 190 -/43.61 DRPCANet [50] 94.16 96.99 98.41 1.35 64.14 78.15 92.09 5.16 75.52 86.05 99.08 7.15 76.50 86.69 98.62 30.65 1.16 73.2 -/86.50 LCPNet-4 95.70 97.80 97.57 0.03 65.15 78.89 86.60 1.58 71.18 83.17 94.50 0.87 72.55 84.09 95.74 2.87 1.15 75.2 -/23.54 LCPNet-6 95.77 97.84 97.35 0.09 65.95 79.48 87.63 1.55 72.95 84.36 96.33 0.89 72.49 84.05 96.84 2.29 1.72 112 -/31.38 IV Experiments This section evaluates the proposed method from several complementary perspectives. We first introduce the datasets, metrics, and implementation settings, and then compare the proposed method with SOTAs in terms of quantitative accuracy, visual detection quality, and computational efficiency. Then, ablation studies are conducted to examine the contribution of each key design. Finally, we discuss the differences and limitations of our method compared to other approaches, as well as our outlook for the future. IV-A Implementation Details IV-A1 Datasets and Metrics We evaluate LCPNet on four publicly available benchmarks, namely NUDT-SIRST [23], IRSTD-1K [58], SIRST [9], and SIRST-Aug [59]. NUDT-SIRST [23] contains 1327 images with a resolution of 256×256256× 256, and is widely used to evaluate robustness under diverse backgrounds and complex clutter conditions. Following the protocol of [23], the training and test sets are split 1:1. IRSTD-1K [58] is a realistic infrared small target detection benchmark, comprising manually annotated real-world infrared images. It contains 800 training images and 201 test images. SIRST [9] is one of the earliest and most widely used single-frame benchmarks. It contains 341 training images and 86 test images in various sizes. SIRST-Aug [59] is an augmented version derived from SIRST [9] through data augmentation. It contains 8525 training images and 545 test images and provides more sufficient training samples for deep models. For quantitative evaluation, we adopt five commonly used metrics, including mean Intersection over Union (IoU), F1F_1 score, Probability of detection (PdP_d), and FaF_alse alarm rate (FaF_a). They assess performance from the perspectives of overall segmentation quality, the ability to correctly detect real objects, and the risk of false alarms in cluttered backgrounds, respectively. Additionally, we included area under the ROC curve (AUC) to summarize the detection performance at different decision thresholds based on the ROC curve. IV-A2 Experimental Settings All implementations were developed based on PyTorch. The experiments were conducted on a workstation equipped with an NVIDIA GeForce RTX 3090 GPU and an AMD EPYC 7502 CPU. For training, all input images were resized to a base size of 256×256256× 256, and the batch size was set to 88. The model was trained for 800800 epochs on NUDT-SIRST, IRSTD-1K, and SIRST, and for 400400 epochs on SIRST-Aug. We used the Adam optimizer with an initial learning rate of 1×10−41× 10^-4, and adopted the poly learning rate scheduler with a power of 0.90.9. The network is supervised by SoftIoU loss [43]. IV-B State-of-the-Art Comparison To provide a comprehensive evaluation, we compare LCPNet with representative IRSTD methods on NUDT-SIRST [23], IRSTD-1K [58], SIRST [9], and SIRST-Aug [59] under the same evaluation protocol described above. The compared methods cover four categories: HVS-based methods, optimization-based methods, deep learning networks, and recent deep unfolding models. This selection allows us to examine detection accuracy, false-alarm suppression, visual robustness, and the efficiency-accuracy tradeoff across different model families. IV-B1 Quantitative Comparison Table I shows that LCPNet provides the most consistent quantitative performance among the compared model families. On the two larger benchmarks e.g. NUDT-SIRST [23], IRSTD-1K [58], LCPNet-6 obtains the best performance, with IoU/F1F_1 of 95.77%95.77\%/97.84%97.84\% and 65.95%65.95\%/79.48%79.48\%, respectively. More importantly for IRSTD, where small bright clutter easily causes false alarms, the LCPNet variants achieve the lowest FaF_a on all four benchmarks, indicating that the proposed decomposition is not merely more accurate in overlap but also more conservative in suppressing background responses. This behavior is closely related to the design of LCPNet. The latent-space unfolding gives each stage a higher-dimensional representation for separating target and background structures, while the proximal surrogate and shared memory stabilize the update trajectory across stages. As a result, LCPNet is particularly strong in cluttered scenes. Even when some baselines obtain higher individual PdP_d or IoU/F1F_1 on SIRST and SIRST-Aug, LCPNet reduces FaF_a to 0.870.87 and 2.292.29, respectively, showing a better balance between detecting weak targets and avoiding spurious responses. The ROC results in Fig. 7 provide the same evidence from a threshold-independent view: after zooming into the high-sensitivity region, the red LCPNet curve stays closest to the upper-left corner. Consistently, Table I reports the best AUC on three benchmarks, where LCPNet-6 reaches 0.99410.9941, 0.96560.9656, and 0.9999980.999998, and remains competitive on the augmented one with an AUC of 0.98030.9803. Overall, these results suggest that the proposed latent space unfolding strategy improves not only peak segmentation metrics but also the robustness of detection decisions across thresholds. (a) NUDT-SIRST (b) IRSTD-1k (c) SIRST (d) SIRST-Aug Figure 7: ROC curves of different state-of-the-art methods across four infrared small target detection datasets. Our method is represented by the red line. TABLE I: AUC comparison of different methods on four infrared small target detection datasets. Higher values are marked as bold and indicate better detection performance. Method NUDT-SIRST IRSTD-1K SIRST SIRST-Aug NRAM [56] 0.7403 0.7777 0.936405 0.7794 PSTNN [11] 0.8968 0.8114 0.892235 0.5069 ACM [9] 0.9867 0.9363 0.990813 0.9834 ALCNet [10] 0.9909 0.9281 0.999975 0.9909 ISNet [58] 0.9861 0.9446 0.981616 0.8436 UIUNet [48] 0.9761 0.9604 0.995389 0.9833 RPCANet [47] 0.9804 0.9415 0.961126 0.9909 RPCANet++ [45] 0.9925 0.9484 0.999972 0.9937 DRPCANet [50] 0.9931 0.9639 0.999986 0.9936 LCPNet-6 0.9941 0.9656 0.999998 0.9803 IV-B2 Qualitative Visual Comparison Fig. 8-Fig. 11 provide representative visual comparisons, where green boxes denote correct detections and red boxes denote false alarms or missed targets. These examples cover several typical difficult cases, including tree-branch clutter, multiple adjacent targets, cloud background structures, and complex terrain textures. In Fig. 8, traditional optimization-based methods such as MPCM, NRAM, and PSTNN leave many clutter responses, while only RPCANet and LCPNet-6 correctly detect the true target. This result suggests that unfolding-based decomposition is more robust than hand-crafted priors when the background contains structured bright interference. The advantage of LCPNet becomes clearer in Fig. 9 with multiple targets. Most competing methods either miss one target or mix the target response with nearby background, whereas LCPNet-6 completely detects both targets. For the cloud and terrain examples in Fig. 10 and Fig. 11, many baselines are distracted by background textures and generate multiple red-box responses. LCPNet-6 localizes the real targets with more compact responses and fewer clutter activations, although a small residual false alarm remains in the cloud scene. Overall, the visual results support the quantitative findings: LCPNet improves practical detection reliability by better separating small targets from structured background clutter. To further inspect the feature-level behavior, Fig. 6 visualizes the last-layer feature maps of different methods using the most informative PCA component. Across sky and ground background scenes, as well as single-target, multi-target, and heavy-clutter cases, LCPNet produces clearer target-focused activations than the competing methods. The target responses are more concentrated around true small objects, while background structures are less likely to dominate the heatmaps. This suggests that the proposed latent space unfolding process provides more reliable feature evidence for subsequent target detection and segmentation. Figure 8: Qualitative comparison on image XDU685. Green boxes denote correct detections, while red boxes denote false alarms or missed targets. Best view in color. Figure 9: Qualitative comparison on image 000660. Green boxes denote correct detections, while red boxes denote false alarms or missed targets. Best view in color. IV-B3 Computational Efficiency Analysis Beyond detection accuracy, Table I also reports the model parameters, FLOPs, and CPU/GPU inference time. HVS-based methods do not involve trainable parameters, but their CPU runtime varies greatly because they depend on hand-crafted filtering or local contrast operations. Optimization-based methods are also parameter-free in the neural-network sense, yet their iterative solvers are generally slow on CPU and lack efficient GPU inference. Deep learning-based methods improve inference efficiency by replacing iterative solvers with feed-forward networks, but their cost differs substantially across architectures. Lightweight models such as ACM and ALCNet are fast, whereas larger context aggregation or nested U-shaped designs introduce noticeably higher FLOPs and latency. However, these faster non-unfolding networks usually trade interpretability and often show weaker robustness in the quantitative and visual comparisons above. Among deep unfolding-based methods, LCPNet provides a practical balance between accuracy, model size, and runtime. Compared with RPCANet++, LCPNet-4 uses fewer parameters and substantially lower FLOPs, while also running faster on GPU. LCPNet-6 increases the unfolding depth to improve accuracy but still keeps the runtime below heavier unfolding baselines such as RPCANet++ and DRPCANet. Therefore, LCPNet does not achieve its performance by simply enlarging the network. Its efficiency mainly comes from performing compact latent-domain updates with shared optimization memory, yielding a favorable accuracy-efficiency tradeoff for infrared small target detection. Figure 10: Qualitative comparison on image 000971. Green boxes denote correct detections, while red boxes denote false alarms or missed targets. Best view in color. Figure 11: Qualitative comparison on image 000523. Green boxes denote correct detections, while red boxes denote false alarms or missed targets. Best view in color. IV-C Ablation Studies To verify the effectiveness of each component in LCPNet, we conduct a series of controlled ablation studies by modifying one design factor at a time while keeping the remaining settings unchanged. Together, these studies provide an overall validation of the main architectural choices and their impact on detection performance. IV-C1 Effect of Execution Domain We first examine whether the unfolding process should be executed in the image domain or in the latent domain. In Table I, variants (b) and (c) use the same surrogate-style solver and batch-based updater, so their comparison isolates the effect of the execution domain. Moving the updates from X to X improves IoU by 0.720.72, F1F_1 by 0.390.39, and PdP_d by 0.840.84, indicating that the latent variables provide a more informative representation for preserving weak target responses. However, the FaF_a value is not reduced in this setting, which suggests that latent execution alone is insufficient when the updater is weakly constrained. The benefit becomes clearer when the updater is equipped with stronger regularization. Under the same solver and regularized updater setting, variants (e) and (f) show that latent-domain execution brings gains of 2.832.83 in IoU, 1.491.49 in F1F_1, and 1.061.06 in PdP_d, while reducing FaF_a from 0.0800.080 to 0.0250.025. This result indicates that the expanded latent representation can better separate target and background components when the update process is stable enough to exploit it. Overall, these two comparisons show that latent-domain unfolding is more effective than directly updating image-domain variables. IV-C2 Effect of Solver Design We evaluate the solver design used to generate the stage-wise update direction. The R-style design, adopted by the RPCANet series [47, 45, 50], directly reconstructs the next background variable from the current decomposition residual through a learned correction: k=k−1−k−1+ℱ(k−1−k−1).B^k=D^k-1-T^k-1+F(D^k-1-T^k-1). (22) This form is simple and effective, but the update of kB^k does not explicitly use k−1B^k-1. Therefore, the background trajectory is mainly regenerated from the residual at each stage, which weakens the continuity of the unfolding process. In contrast, the proposed LCP solver design in Eq. 17 keeps the proximal surrogate form while removing the SOM-related state input for a fair comparison. This design updates current latent variable from its previous state and a decomposition-consistency residual, making the learned direction closer to a proximal descent step rather than an indirect residual mapping. The comparison between variants (a) and (b) in Table I verifies this effect under the same image-domain and batch-based updater setting. Replacing the R-style solver with the S-style solver brings gains of 1.271.27 in IoU and 0.710.71 in F1F_1, while lowering FaF_a by 2.722.72. Although PdP_d decreases by 3.383.38, the much lower false alarm rate and higher overlap metrics indicate that the S-style solver suppresses background responses more effectively. Overall, the proximal surrogate formulation provides a more stable and discriminative update rule for the unfolding decomposition. IV-C3 Effect of Updater Regularization We further analyze the regularization strategy inside the updater. In Table I, variants (c), (d), and (f) keep the latent execution domain and S-style solver unchanged, and only vary the updater regularization. Replacing BN with GN gives the main improvement. From variant (c) to (d), IoU, F1F_1, and PdP_d increase by 4.294.29, 2.292.29, and 2.652.65, respectively, while FaF_a is reduced by 0.2600.260. This large gain is consistent with the characteristics of IRSTD, where infrared scenes often have heterogeneous background statistics and small targets occupy only a tiny portion. A batch-dependent updater can therefore be sensitive to mixed scene statistics, whereas GN normalizes features within each sample and provides a more stable update direction. Adding spectral normalization on top of GN brings a smaller but consistent gain. From variant (d) to (f), IoU and F1F_1 further increase by 0.110.11 and 0.060.06, PdP_d improves by 0.320.32, and FaF_a is further reduced by 0.1040.104. Overall, GN is the primary factor for improving updater stability, and SN further regularizes the unfolding update process, leading to more reliable target-background separation. TABLE I: Ablation study of execution domain, solver design, and updater regularization in terms of IoU(%), F1F_1(%), PdP_d(%) and Fa(10−5)F_a(10^-5) on NUDT-SIRST [23]. B, G and S represent batch normalization, group normalization, and spectral normalization, respectively. Index Domain Solver Updater NUDT-SIRST Design Regular IoU↑ F1F_1↑ PdP_d↑ FaF_a↓ (a) Image R-style B 89.31 94.35 97.14 2.87 (b) Image LCP B 90.58 95.06 93.76 0.152 (c) Latent LCP B 91.30 95.45 94.60 0.389 (d) Latent LCP G 95.59 97.74 97.25 0.129 (e) Image LCP +G+S 92.87 96.31 96.51 0.080 (f) Latent LCP +G+S 95.70 97.80 97.57 0.025 IV-C4 Effect of Memory Type We then evaluate how historical information is represented across unfolding stages. Table IV compares four settings, including no memory, simple concatenation, ConvLSTM-style recurrent memory used in RPCANet++ [45], and the proposed SOM. Compared with no memory, simple concatenation brings only a marginal IoU gain of 0.210.21 on NUDT-SIRST and shows no clear improvement on IRSTD-1K, indicating that static feature aggregation is insufficient for modeling the stage-wise optimization history. ConvLSTM gives more consistent gains, improving IoU by 0.310.31 and 0.370.37 on the two benchmarks and reducing FaF_a on both datasets. This result confirms that recurrent memory is useful for preserving cross-stage information. SOM further improves segmentation quality by treating the decomposition variables as a coupled optimization state rather than storing branch-specific memory. Compared with ConvLSTM, SOM increases IoU/F1F_1 by 0.270.27/0.140.14 on NUDT-SIRST and 0.430.43/0.310.31 on IRSTD-1K. It also improves PdP_d on NUDT-SIRST by 0.320.32 and reduces FaF_a by 0.0210.021, although its FaF_a on IRSTD-1K is not the lowest. Overall, SOM provides stronger overlap accuracy and more stable target preservation, showing that a shared optimization memory is more effective than others. TABLE IV: Ablation study of memory type in terms of IoU(%), F1F_1(%), PdP_d(%) and Fa(10−5)F_a(10^-5) on NUDT-SIRST [23] and IRSTD-1K [58]. Memory NUDT-SIRST IRSTD-1K IoU↑ F1F_1↑ PdP_d↑ FaF_a↓ IoU↑ F1F_1↑ PdP_d↑ FaF_a↓ None 95.12 97.50 96.51 0.074 64.35 78.31 86.60 1.45 Cat 95.33 97.61 96.40 0.051 64.31 78.28 85.57 1.41 ConvLSTM 95.43 97.66 97.25 0.046 64.72 78.58 86.94 1.38 SOM 95.70 97.80 97.57 0.025 65.15 78.89 86.60 1.58 IV-C5 Effect of Stage Number Finally, we study the influence of the unfolding stage number in Table V. Increasing the number of stages generally improves the detection quality because more decomposition updates allow the latent variables and the shared state to be refined progressively. For example, increasing the depth from K=2K=2 to K=4K=4 improves IoU/F1F_1 by 1.431.43/0.750.75 on NUDT-SIRST and 0.870.87/0.640.64 on IRSTD-1K, while PdP_d also increases on both benchmarks. The improvement becomes less regular when the network is further deepened. The setting K=5K=5 gives a notably high result on NUDT-SIRST, but this behavior is more like an isolated fluctuation under the current evaluation rather than the main trend. We therefore do not take it as the primary result. Overall, a moderate-to-deep unfolding depth provides better representation refinement, while excessively increasing the number of stages brings smaller and less stable gains. TABLE V: Ablation study of the unfolding stage number in terms of IoU(%), F1F_1(%), PdP_d(%) and Fa(10−5)F_a(10^-5) on NUDT-SIRST [23] and IRSTD-1K [58]. Stages NUDT-SIRST IRSTD-1K IoU↑ F1F_1↑ PdP_d↑ FaF_a↓ IoU↑ F1F_1↑ PdP_d↑ FaF_a↓ K=2 94.27 97.05 95.03 0.046 64.28 78.25 82.47 1.12 K=3 95.16 97.52 97.14 0.011 64.36 78.31 84.88 1.29 K=4 95.70 97.80 97.57 0.025 65.15 78.89 86.60 1.58 K=5 96.11 98.02 98.52 0.028 65.85 79.41 87.63 1.53 K=6 95.77 97.84 97.35 0.092 65.95 79.48 87.63 1.55 IV-D Discussion and Analysis IV-D1 Technical Discussion LCPNet follows the same model-driven spirit as recent deep unfolding methods, but differs from them in how the decomposition process is represented and updated. Traditional optimization-based methods operate directly in the image domain and rely on hand-crafted low-rank/sparse priors, while RPCANet-style networks unfold an RPCA-like process with learnable modules in the image domain. LCPNet instead lifts the observation and decomposition variables into a latent domain. This transformation does not discard the physical decomposition constraint, but gives each stage a higher-dimensional interface where small target responses, background structures, and noise components can evolve more flexibly. The solver design also differs from the residual-style update used in RPCANet-related methods. In the R-style formulation, the next background estimate is mainly regenerated from the current residual through a learned correction, and the previous background state is not explicitly involved in the update. LCPNet adopts an S-style proximal surrogate update, where each variable is updated from its previous state and the current decomposition-consistency residual. This makes the learned update closer to a proximal descent step and gives the unfolding trajectory stronger continuity. Moreover, the SOM further separates LCPNet from RPCANet++. The memory module in RPCANet++ mainly serves a specific branch, whereas SOM encodes the coupled state of ℬB, T, N, Y, and X and feeds the same historical state to all primal-variable updates. Through the gated recurrence, this state forms an unbounded-order effective memory of the whole latent decomposition system rather than a branch-level feature cache. IV-D2 Limitations and Future Work Although LCPNet achieves a favorable accuracy-efficiency tradeoff, its inference time still has room for further reduction. The latent-domain updates and recurrent state propagation introduce additional computation compared with very lightweight feed-forward detectors, especially when more unfolding stages are used. Future work can further compress the updater, simplify the state transition, or design adaptive early-exit strategies so that easy samples require fewer stages. We expect these directions to support more efficient and robust infrared small target detectors, especially for real-time deployment on resource-constrained platforms. V Conclusion In this paper, we introduced LCPNet for infrared small target detection. By confirming that low-rank decomposition prior remains valid in latent representations, LCPNet extends unfolding from image domain to latent domain, preserving the physical constraint while avoiding repeated compression of intermediate states. Through modeling and detailed derivations on latents, the proposed LCP solver turns indirect residual reconstruction into direct proximal-state evolution and introduces regularized update dynamics for stable small target separation. The SOM further upgrades branch-specific memory into a shared optimization state, so historical information can guide all coupled decomposition variables across stages. Extensive experiments on four public benchmarks demonstrate the effectiveness of LCPNet. Quantitative and qualitative results show that LCPNet achieves accurate and robust detection across cluttered scenes and multiple-target cases. Ablation studies progressively demonstrate that these benefits stem from the proposed improvements. Overall, LCPNet provides an effective and interpretable framework for IRSTD. References [1] J. Adler and O. Öktem (2018) Learned primal-dual reconstruction. IEEE Transactions on Medical Imaging 37 (6), p. 1322–1332. External Links: Document Cited by: §I-B. [2] H. K. Aggarwal, M. P. Mani, and M. Jacob (2018) MoDL: model-based deep learning architecture for inverse problems. IEEE Transactions on Medical Imaging 38 (2), p. 394–405. External Links: Document Cited by: §I-B. [3] S. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein (2011) Distributed optimization and statistical learning via the alternating direction method of multipliers. Foundations and Trends in Machine Learning 3 (1), p. 1–122. External Links: Document Cited by: §I-A. [4] H. Cai, J. Liu, and W. Yin (2021) Learned robust pca: a scalable deep unfolding approach for high-dimensional outlier detection. In Advances in Neural Information Processing Systems, Vol. 34, p. 16977–16989. Cited by: §I-B. [5] E. J. Candès, X. Li, Y. Ma, and J. Wright (2011) Robust principal component analysis?. Journal of the ACM 58 (3), p. 1–37. External Links: Document Cited by: §I, §I-B. [6] C. P. Chen, H. Li, Y. Wei, T. Xia, and Y. Y. Tang (2013) A local contrast method for small infrared target detection. IEEE Transactions on Geoscience and Remote Sensing 52 (1), p. 574–581. Cited by: §I, §I-A. [7] K. Cho, B. van Merrienboer, C. Gulcehre, D. Bahdanau, F. Bougares, H. Schwenk, and Y. Bengio (2014) Learning phrase representations using rnn encoder–decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing, p. 1724–1734. External Links: Document Cited by: §I-C, §I-C. [8] M. Cisse, P. Bojanowski, E. Grave, Y. Dauphin, and N. Usunier (2017) Parseval networks: improving robustness to adversarial examples. In International conference on machine learning, p. 854–863. Cited by: §I. [9] Y. Dai, Y. Wu, F. Zhou, and K. Barnard (2021) Asymmetric contextual modulation for infrared small target detection. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, p. 950–959. Cited by: §I, §I-A, TABLE I, §IV-A1, §IV-B, TABLE I. [10] Y. Dai, Y. Wu, F. Zhou, and K. Barnard (2021) Attentional local contrast networks for infrared small target detection. IEEE transactions on geoscience and remote sensing 59 (11), p. 9813–9824. Cited by: §I, §I, §I-A, TABLE I, TABLE I. [11] Y. Dai and Y. Wu (2017) Reweighted infrared patch-tensor model with both nonlocal and local priors for single-frame small target detection. IEEE journal of selected topics in applied earth observations and remote sensing 10 (8), p. 3752–3767. Cited by: §I, §I-A, §I-A, TABLE I, TABLE I. [12] S. D. Deshpande, M. H. Er, R. Venkateswarlu, and P. Chan (1999) Max-mean and max-median filters for detection of small targets. In Signal and Data Processing of Small Targets 1999, Vol. 3809, p. 74–83. Cited by: §I-A, TABLE I. [13] C. Gao, D. Meng, Y. Yang, Y. Wang, X. Zhou, and A. G. Hauptmann (2013) Infrared patch-image model for small target detection in a single image. IEEE Transactions on Image Processing 22 (12), p. 4996–5009. Cited by: §I, §I, §I-A, §I-A, TABLE I. [14] K. Gregor and Y. LeCun (2010) Learning fast approximations of sparse coding. In Proceedings of the 27th International Conference on Machine Learning, p. 399–406. Cited by: §I-B. [15] A. Gu and T. Dao (2024) Mamba: linear-time sequence modeling with selective state spaces. External Links: 2312.00752 Cited by: §I-C. [16] A. Gu, K. Goel, and C. Ré (2022) Efficiently modeling long sequences with structured state spaces. External Links: 2111.00396 Cited by: §I-C. [17] K. Hammernik, T. Klatzer, E. Kobler, M. P. Recht, D. K. Sodickson, T. Pock, and F. Knoll (2017) Learning a variational network for reconstruction of accelerated MRI data. Magnetic Resonance in Medicine 79 (6), p. 3055–3071. External Links: Document Cited by: §I-B. [18] J. Ho, A. Jain, and P. Abbeel (2020) Denoising diffusion probabilistic models. In Advances in Neural Information Processing Systems, Vol. 33, p. 6840–6851. Cited by: §I-B. [19] S. Hochreiter and J. Schmidhuber (1997) Long short-term memory. Neural Computation 9 (8), p. 1735–1780. External Links: Document Cited by: §I-C. [20] S. A. H. Hosseini, B. Yaman, S. Moeller, M. Hong, and M. Akcakaya (2020) Dense recurrent neural networks for accelerated MRI: history-cognizant unrolling of optimization algorithms. IEEE Journal of Selected Topics in Signal Processing 14 (6), p. 1280–1291. External Links: Document Cited by: §I-C. [21] S. Ioffe and C. Szegedy (2015) Batch normalization: accelerating deep network training by reducing internal covariate shift. In International conference on machine learning, p. 448–456. Cited by: §I, §I-D. [22] R. Kou, C. Wang, Z. Peng, Z. Zhao, Y. Chen, J. Han, F. Huang, Y. Yu, and Q. Fu (2023) Infrared small target segmentation networks: a survey. Pattern Recognition 143, p. 109788. External Links: Document Cited by: §I, §I, §I-A. [23] B. Li, C. Xiao, L. Wang, Y. Wang, Z. Lin, M. Li, W. An, and Y. Guo (2022) Dense nested attention network for infrared small target detection. IEEE Transactions on Image Processing 32, p. 1745–1758. Cited by: Figure 12, Figure 2, §I, §I-A, Figure 6, TABLE I, §IV-A1, §IV-B1, §IV-B, TABLE I, TABLE IV, TABLE V. [24] H. Li, J. Yang, R. Wang, and Y. Xu (2025) ILNet: low-level matters for salient infrared small target detection. IEEE Transactions on Aerospace and Electronic Systems. Cited by: §I-A. [25] Q. Liu, R. Liu, B. Zheng, H. Wang, and Y. Fu (2024) Infrared small target detection with scale and location sensitivity. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 17490–17499. Cited by: §I, §I-A, TABLE I. [26] Y. Liu, Y. Tian, Y. Zhao, H. Yu, L. Xie, Y. Wang, Q. Ye, J. Jiao, and Y. Liu (2024) VMamba: visual state space model. External Links: 2401.10166 Cited by: §I-C. [27] C. A. Metzler, A. Mousavi, and R. G. Baraniuk (2017) Learned D-AMP: principled neural network based compressive image recovery. External Links: 1704.06625 Cited by: §I-B. [28] T. Miyato, T. Kataoka, M. Koyama, and Y. Yoshida (2018) Spectral normalization for generative adversarial networks. arXiv preprint arXiv:1802.05957. Cited by: §I, §I-D. [29] V. Monga, Y. Li, and Y. C. Eldar (2021) Algorithm unrolling: interpretable, efficient deep learning for signal and image processing. IEEE Signal Processing Magazine 38 (2), p. 18–44. External Links: Document Cited by: §I, §I, §I-A, §I-B. [30] Y. Nesterov (2004) Introductory lectures on convex optimization: a basic course. Applied Optimization, Vol. 87, Springer. External Links: Document Cited by: §I-C, §I-B. [31] A. Nichol and P. Dhariwal (2021) Improved denoising diffusion probabilistic models. External Links: 2102.09672 Cited by: §I-B. [32] L. Peng, T. Zhang, S. Huang, T. Pu, Y. Liu, Y. Lv, Y. Zheng, and Z. Peng (2019) Infrared small-target detection based on multi-directional multi-scale high-boost response. Optical Review 26 (6), p. 568–582. Cited by: §I-A, TABLE I. [33] P. Putzky and M. Welling (2017) Recurrent inference machines for solving inverse problems. External Links: 1706.04008 Cited by: §I-C. [34] R. Rombach, A. Blattmann, D. Lorenz, P. Esser, and B. Ommer (2022) High-resolution image synthesis with latent diffusion models. External Links: 2112.10752 Cited by: §I-B. [35] X. Shi, Z. Chen, H. Wang, D. Yeung, W. Wong, and W. Woo (2015) Convolutional lstm network: a machine learning approach for precipitation nowcasting. In Advances in Neural Information Processing Systems, Vol. 28, p. 802–810. Cited by: §I, §I-C. [36] J. Sohl-Dickstein, E. A. Weiss, N. Maheswaranathan, and S. Ganguli (2015) Deep unsupervised learning using nonequilibrium thermodynamics. External Links: 1503.03585 Cited by: §I-B. [37] J. Song, C. Meng, and S. Ermon (2022) Denoising diffusion implicit models. External Links: 2010.02502 Cited by: §I-B. [38] J. Song, B. Chen, and J. Zhang (2021) Memory-augmented deep unfolding network for compressive sensing. In Proceedings of the 29th ACM International Conference on Multimedia, p. 4249–4258. External Links: Document Cited by: §I-C. [39] Y. Song and S. Ermon (2020) Generative modeling by estimating gradients of the data distribution. External Links: 1907.05600 Cited by: §I-B. [40] Y. Song, J. Sohl-Dickstein, D. P. Kingma, A. Kumar, S. Ermon, and B. Poole (2021) Score-based generative modeling through stochastic differential equations. In International Conference on Learning Representations, Cited by: §I-B. [41] A. Sriram, J. Zbontar, T. Murrell, A. Defazio, C. L. Zitnick, N. Yakubova, F. Knoll, and P. Johnson (2020) End-to-end variational networks for accelerated MRI reconstruction. In Medical Image Computing and Computer Assisted Intervention – MICCAI 2020, p. 64–73. External Links: Document Cited by: §I-B. [42] V. T. Tom, T. Peli, M. Leung, and J. E. Bondaryk (1993) Morphology-based algorithm for point target detection in infrared backgrounds. In Signal and Data Processing of Small Targets 1993, Vol. 1954, p. 2–11. Cited by: §I-A, TABLE I. [43] H. Wang, L. Zhou, and L. Wang (2019) Miss detection vs. false alarm: adversarial learning for small object segmentation in infrared images. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 8509–8518. Cited by: §I, §I, §I-A, §IV-A2. [44] Y. Wei, X. You, and H. Li (2016) Multiscale patch-based contrast measure for small infrared target detection. Pattern Recognition 58, p. 216–226. Cited by: §I-A, TABLE I. [45] F. Wu, Y. Dai, T. Zhang, Y. Ding, J. Yang, M. Cheng, and Z. Peng (2025) RPCANet++: deep interpretable robust pca for sparse object segmentation. arXiv preprint arXiv:2508.04190. Cited by: §I, §I, §I-A, §I-B, §I-A, §I-C, TABLE I, §IV-C2, §IV-C4, TABLE I. [46] F. Wu, A. Liu, T. Zhang, L. Zhang, J. Luo, and Z. Peng (2024) Saliency at the helm: steering infrared small target detection with learnable kernels. IEEE Transactions on Geoscience and Remote Sensing 63, p. 1–14. Cited by: §I-A, TABLE I. [47] F. Wu, T. Zhang, L. Li, Y. Huang, and Z. Peng (2024) RPCANet: deep unfolding rpca based infrared small target detection. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, p. 4809–4818. Cited by: §I, §I, §I-A, §I-B, §I-A, TABLE I, §IV-C2, TABLE I. [48] X. Wu, D. Hong, and J. Chanussot (2022) UIU-net: u-net in u-net for infrared small object detection. IEEE Transactions on Image Processing 32, p. 364–376. Cited by: §I, §I-A, TABLE I, TABLE I. [49] Y. Wu and K. He (2018) Group normalization. In Proceedings of the European conference on computer vision (ECCV), p. 3–19. Cited by: §I, §I-D. [50] Z. Xiong, F. Zhou, F. Wu, S. Yuan, M. Fu, Z. Peng, J. Yang, and Y. Dai (2025) DRPCA-net: make robust pca great again for infrared small target detection. IEEE Transactions on Geoscience and Remote Sensing. Cited by: TABLE I, §IV-C2, TABLE I. [51] J. Yang, S. Liu, J. Wu, X. Su, N. Hai, and X. Huang (2025) Pinwheel-shaped convolution and scale-based dynamic loss for infrared small target detection. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 39, p. 9202–9210. Cited by: §I-A. [52] Y. Yang, J. Sun, H. Li, and Z. Xu (2016) Deep admm-net for compressive sensing mri. In Advances in Neural Information Processing Systems, Vol. 29. Cited by: §I-B. [53] G. Yiasemis, J. Sonke, C. Sanchez, and J. Teuwen (2022) Recurrent variational network: a deep learning inverse problem solver applied to the task of accelerated MRI reconstruction. In 2022 IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 722–731. External Links: Document Cited by: §I-C. [54] S. Yuan, H. Qin, X. Yan, N. Akhtar, and A. Mian (2024) SCTransNet: spatial-channel cross transformer network for infrared small target detection. IEEE Transactions on Geoscience and Remote Sensing 62, p. 1–15. Cited by: TABLE I. [55] J. Zhang and B. Ghanem (2018) ISTA-net: interpretable optimization-inspired deep network for image compressive sensing. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 1828–1837. External Links: Document Cited by: §I-B. [56] L. Zhang, L. Peng, T. Zhang, S. Cao, and Z. Peng (2018) Infrared small target detection via non-convex rank approximation minimization joint l 2, 1 norm. Remote Sensing 10 (11), p. 1821. Cited by: §I, §I-A, §I-A, TABLE I, TABLE I. [57] M. Zhang, Y. Wang, J. Guo, Y. Li, X. Gao, and J. Zhang (2024) IRSAM: advancing segment anything model for infrared small target detection. In European Conference on Computer Vision, p. 233–249. Cited by: §I-A, TABLE I. [58] M. Zhang, R. Zhang, Y. Yang, H. Bai, J. Zhang, and J. Guo (2022) ISNet: shape matters for infrared small target detection. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, p. 877–886. Cited by: Figure 12, Figure 13, Figure 1, §I-A, Figure 6, TABLE I, §IV-A1, §IV-B1, §IV-B, TABLE I, TABLE IV, TABLE V. [59] T. Zhang, L. Li, S. Cao, T. Pu, and Z. Peng (2023) Attention-guided pyramid context networks for detecting infrared small target under complex background. IEEE Transactions on Aerospace and Electronic Systems 59 (4), p. 4250–4261. Cited by: §I, §I-A, TABLE I, §IV-A1, §IV-B. [60] T. Zhang, L. Li, and Z. Peng (2023) Optimization-inspired cumulative transmission network for image compressive sensing. Knowledge-Based Systems 279, p. 110963. Cited by: §I-B. [61] T. Zhang, H. Wu, Y. Liu, L. Peng, C. Yang, and Z. Peng (2019) Infrared small target detection based on non-convex optimization with lp-norm constraint. Remote Sensing 11 (5), p. 559. Cited by: TABLE I. [62] Z. Zhang, Y. Liu, J. Liu, F. Wen, and C. Zhu (2021) AMP-Net: denoising based deep unfolding for compressive image sensing. IEEE Transactions on Image Processing 30, p. 1487–1500. External Links: Document Cited by: §I-B. [63] M. Zhao, W. Li, L. Li, J. Hu, P. Ma, and R. Tao (2022) Single-frame infrared small-target detection: a survey. IEEE Geoscience and Remote Sensing Magazine 10 (2), p. 87–119. External Links: Document Cited by: §I, §I, §I-A. [64] L. Zhu, B. Liao, Q. Zhang, X. Wang, W. Liu, and X. Wang (2024) Vision mamba: efficient visual representation learning with bidirectional state space model. External Links: 2401.09417 Cited by: §I-C. Appendix A Derivation of ADMM Subproblems This section derives the background, target, and noise subproblems from the augmented Lagrangian in Eq. 5. The dual and quadratic penalty terms in Eq. 5 can be merged by completing the square: ⟨,−ℬ−⟩+μ2‖−ℬ−‖F2 ,X-B-T-N + μ2 \|X-B-T-N \|_F^2 (23) =μ2‖−ℬ−+1μ‖F2−12μ‖F2. = μ2 \|X-B-T-N+ 1μY \|_F^2- 12μ \|Y \|_F^2. Since the last term is independent of ℬB, T, and N during primal-variable updates, it can be absorbed into a constant C. Therefore, the equivalent primal objective is ℒμ(ℬ,,, _μ(B,T,N, )=ℛℬ(ℬ)+ℛ()+ℛ(;σ) )=\ R_B(B)+R_T(T)+R_N(N;σ) (24) +μ2‖−ℬ−+1μ‖F2+C. + μ2 \|X-B-T-N+ 1μY \|_F^2+C. ADMM then updates one latent component while fixing the others. For the background component: ℬk= ^k= argminℬℛℬ(ℬ) _B\ R_B(B) (25) +μ2‖−ℬ−k−1−k−1+1μk−1‖F2. + μ2 \|X-B-T^k-1-N^k-1+ 1μY^k-1 \|_F^2. For the target component: k= ^k= argminℛ() _T\ R_T(T) (26) +μ2‖−ℬk−k−1+1μk−1‖F2. + μ2 \|X-B^k-T-N^k-1+ 1μY^k-1 \|_F^2. For the noise component: k= ^k= argminℛ(;σ) _N\ R_N(N;σ) (27) +μ2‖−ℬk−k−+1μk−1‖F2. + μ2 \|X-B^k-T^k-N+ 1μY^k-1 \|_F^2. These three subproblems have the same latent structure: each branch minimizes an unknown latent regularizer plus a quadratic consistency term. This shared structure motivates the surrogate solver derived in the next section. After the three primal variables are updated, ADMM updates the latent dual variable by accumulating the decomposition residual: k=k−1+μ(−ℬk−k−k).Y^k=Y^k-1+μ (X-B^k-T^k-N^k ). (28) Figure 12: Supplementary on the visualization of last layer feature maps produced by different methods. For each method, the feature map is projected by PCA, and the most informative principal component is selected for visualization. Rows 1 is XDU67 in IRSTD-1k [58]. Row 2,3,4 are 000762 000410 000589 in NUDT-SIRST [23]. Appendix B Detailed Derivation of the ADMM Surrogate Update This section derives the analytical update of the ℬB-subproblem under the Lipschitz-continuous gradient assumption. Starting from the background subproblem in Eq. 8, we first define Bk−1=−k−1−k−1+1μBk−1.V_B^k-1=X-T^k-1-N^k-1+ 1 _BY^k-1. (29) Then the ℬB-subproblem can be written as ℬk=argminℬℛℬ(ℬ)+μB2‖ℬ−Bk−1‖F2.B^k= _B\ R_B(B)+ _B2 \|B-V_B^k-1 \|_F^2. (30) Because hand-crafted constraints cannot be perfectly aligned with the physical prior of the latent background, we treat ℛℬ(⋅)R_B(·) as an unknown regularizer rather than manually specifying its analytical form. We then use the Taylor upper-bound argument induced by the descent lemma to construct a quadratic majorization. Assume that ∇ℛℬ _B is LBL_B-Lipschitz continuous, i.e., ‖∇ℛℬ()−∇ℛℬ()‖F≤LB‖−‖F. \| _B(U)- _B(V) \|_F≤ L_B \|U-V \|_F. (31) Then ℛℬ(ℬ)R_B(B) satisfies the following upper bound around ℬk−1B^k-1: ℛℬ(ℬ)≤ _B(B)≤ ℛℬ(ℬk−1)+⟨∇ℛℬ(ℬk−1),ℬ−ℬk−1⟩ \ R_B(B^k-1)+ _B(B^k-1),B-B^k-1 (32) +LB2‖ℬ−ℬk−1‖F2,∀ℬ∈ℝH×W×C. + L_B2 \|B-B^k-1 \|_F^2, ^H× W× C. Completing the square gives the equivalent surrogate regularizer ℛ^ℬ(ℬ,ℬk−1)=LB2‖ℬ−(ℬk−1−1LB∇ℛℬ(ℬk−1))‖F2+CB, R_B(B,B^k-1)= L_B2 \|B- (B^k-1- 1L_B _B(B^k-1) ) \|_F^2+C_B, (33) where CBC_B is independent of ℬB and therefore does not affect the minimizer. Substituting the surrogate regularizer in Eq. 33 into the ℬB-subproblem in Eq. 30 gives ^ℬ(ℬ)= J_B(B)= LB2‖ℬ−(ℬk−1−1LB∇ℛℬ(ℬk−1))‖F2 \ L_B2 \|B- (B^k-1- 1L_B _B(B^k-1) ) \|_F^2 (34) +μB2‖ℬ−Bk−1‖F2. + _B2 \|B-V_B^k-1 \|_F^2. Since ^ℬ(ℬ) J_B(B) is the sum of two quadratic terms, we differentiate it with respect to ℬB: ∇^ℬ(ℬ)=LB(ℬ−ℬk−1+1LB∇ℛℬ(ℬk−1))+μB(ℬ−Bk−1).∇ J_B(B)=L_B (B-B^k-1+ 1L_B _B(B^k-1) )+ _B (B-V_B^k-1 ). (35) Setting ∇^ℬ(ℬ)=0∇ J_B(B)=0 yields LB(ℬ−ℬk−1+1LB∇ℛℬ(ℬk−1))+μB(ℬ−Bk−1)=0.L_B (B-B^k-1+ 1L_B _B(B^k-1) )+ _B (B-V_B^k-1 )=0. (36) Rearranging the above equation gives the optimal solution ℬk=LBLB+μBℬk−1+μBLB+μBBk−1−1LB+μB∇ℛℬ(ℬk−1).B^k= L_BL_B+ _BB^k-1+ _BL_B+ _BV_B^k-1- 1L_B+ _B _B(B^k-1). (37) Appendix C Derivation of the High-Order Memory in SOM This section derives the high-order memory form of the Shared Optimization Memory (SOM). At stage k, SOM first constructs a joint optimization observation: ok=[ℬk,k,k,k,],o_k=[B^k,T^k,N^k,Y^k,X], (38) where oko_k denotes the concatenated latent observation, ℬkB^k, kT^k, and kN^k are the background, target, and noise variables at stage k, kY^k is the latent dual variable, and X is the lifted infrared image representation. The optimization state cell updates the shared state hkh_k by zk=σ(Wz∗[ok,hk−1]+bz),rk=σ(Wr∗[ok,hk−1]+br),h~k=tanh(Wq∗[ok,rk⊙hk−1]+bq),hk=(1−zk)⊙hk−1+zk⊙h~k. gatheredz_k=σ(W_z*[o_k,h_k-1]+b_z),\\ r_k=σ(W_r*[o_k,h_k-1]+b_r),\\ h_k= (W_q*[o_k,r_k h_k-1]+b_q),\\ h_k=(1-z_k) h_k-1+z_k h_k. gathered (39) Here hkh_k is the shared optimization state at stage k. The functions σ(⋅)σ(·) and tanh(⋅) (·) denote the sigmoid and hyperbolic tangent activations. Since zkz_k, rkr_k, h~k h_k, and hkh_k have compatible tensor shapes, all products below are element-wise. The last line of Eq. 39 can be viewed as a gated interpolation between the previous state and the current candidate state. To expose its memory structure, we expand the state transition. For stage k, we have hk=(1−zk)⊙hk−1+zk⊙h~k.h_k=(1-z_k) h_k-1+z_k h_k. (40) The previous state hk−1h_k-1 follows the same recurrence: hk−1=(1−zk−1)⊙hk−2+zk−1⊙h~k−1.h_k-1=(1-z_k-1) h_k-2+z_k-1 h_k-1. (41) Substituting Eq. 41 into Eq. 40 gives hk= h_k= (1−zk)⊙[(1−zk−1)⊙hk−2+zk−1⊙h~k−1] \ (1-z_k) [(1-z_k-1) h_k-2+z_k-1 h_k-1 ] (42) +zk⊙h~k +z_k h_k = = (1−zk)⊙(1−zk−1)⊙hk−2 \ (1-z_k) (1-z_k-1) h_k-2 +(1−zk)⊙zk−1⊙h~k−1+zk⊙h~k. +(1-z_k) z_k-1 h_k-1+z_k h_k. Similarly, expanding hk−2h_k-2 and substituting it into Eq. 42 yields hk= h_k= (1−zk)⊙(1−zk−1)⊙(1−zk−2)⊙hk−3 \ (1-z_k) (1-z_k-1) (1-z_k-2) h_k-3 (43) +(1−zk)⊙(1−zk−1)⊙zk−2⊙h~k−2 +(1-z_k) (1-z_k-1) z_k-2 h_k-2 +(1−zk)⊙zk−1⊙h~k−1+zk⊙h~k. +(1-z_k) z_k-1 h_k-1+z_k h_k. Eq. 43 shows the pattern of the recursive expansion, each historical candidate h~t h_t is first injected through its own update gate ztz_t, and then propagated to stage k through the retention gates (1−zt+1),…,(1−zk)(1-z_t+1),…,(1-z_k). After expanding the recurrence for m steps, where 1≤m≤k1≤ m≤ k, the state can be written as: hk= h_k= (∏i=k−m+1k(1−zi))⊙hk−m ( _i=k-m+1^k(1-z_i) ) h_k-m (44) +∑t=k−m+1k[zt⊙h~t⊙∏i=t+1k(1−zi)]. + _t=k-m+1^k [z_t h_t _i=t+1^k(1-z_i) ]. When t=kt=k, the product ∏i=k+1k(1−zi) _i=k+1^k(1-z_i) is an empty product and is defined as an all-one tensor with the same shape as hkh_k, so the last term becomes zk⊙h~kz_k h_k. Setting m=km=k expands the recurrence back to the initial state h0h_0: hk=(∏i=1k(1−zi))⊙h0+∑t=1k[zt⊙h~t⊙∏i=t+1k(1−zi)].h_k= ( _i=1^k(1-z_i) ) h_0+ _t=1^k [z_t h_t _i=t+1^k(1-z_i) ]. (45) Figure 13: Visualization of the low-rank property in latent domain. From left to right are the original infrared image, a visualized top three channels of the latent selected via PCA, rank of each channel and Tucker rank analysis of the latent. It can be observed that the latent exhibits distinct low-rank property in both visual visualization and rank analysis. The images include sky scene (Top XDU145 in IRSTD-1k [58]) and ground scene (bottom XDU202). Figure 14: Qualitative comparison on image XDU709. Green boxes denote correct detections, while red boxes denote false alarms or missed targets. Best view in color. Figure 15: Qualitative comparison on image XDU343. Green boxes denote correct detections, while red boxes denote false alarms or missed targets. Best view in color. Figure 16: Qualitative comparison on image 001176. Green boxes denote correct detections, while red boxes denote false alarms or missed targets. Best view in color. This is the same expansion as Eq. 20. In this expression, the contribution of each candidate state h~t h_t is controlled by its update gate ztz_t and the subsequent retention gates ∏i=t+1k(1−zi) _i=t+1^k(1-z_i). Therefore, hkh_k is not determined only by hk−1h_k-1 or a fixed short window of previous states. Instead, it contains a gated sum of all candidate states h~1,h~2,…,h~k\ h_1, h_2,…, h_k\ together with the retained initial state h0h_0. Thus, SOM has an unbounded effective memory order in its recurrent formulation, while the actual contribution of each historical state is adaptively controlled by the update gates. Appendix D More Experimental Results This section provides additional qualitative results to complement the visual comparisons in the main paper. Fig. 13 further visualizes the low-rank property of the latent representation, where the latent features exhibit distinct low-rank characteristics in both visual and rank analysis. Fig. 12 further visualizes the last-layer feature responses, where LCPNet shows more concentrated target-related activations and weaker background interference in challenging scenes. Figs. 14–16 present additional detection examples with different target appearances and background structures. Across these cases, LCPNet maintains compact responses around true targets and produces fewer clutter-induced false alarms, further supporting the robustness of the proposed latent-state unfolding design.