When a tumor biopsy is mostly normal tissue, the signals that reveal copied or deleted stretches of the tumor genome get diluted toward the normal baseline. Every standard tool for finding where those stretches begin and end ("breakpoints") degrades sharply below about 70% tumor content. The fix is known in principle. Estimate the tumor fraction ("purity"), use two measurement channels jointly (total copy number, plus the allelic ratio, which records how unevenly the two parental copies are represented), and segment both channels with shared breakpoints. In practice this means a nested iterative computation. An inner solver segments the signal, an outer loop re-estimates purity, and a further loop over regularization strengths picks how many breakpoints to allow. The run time varies from sample to sample, and so does whether the inner solver has actually converged.
We propose to replace that whole nested computation with an unrolled solver, also called deep unfolding: a fixed number $K$ of network layers, each executing exactly one step of the classical algorithm, with step sizes and penalty schedules learned offline. The result has a fixed, small compute budget. Because the unrolled solver is trained directly for breakpoint recovery on diluted samples, it should also find breakpoints better at 30–50% purity than the same objective solved to convergence with hand-tuned settings. The question is not whether unfolding can make a solver faster. Wireless work already shows that. The question is whether learning the iteration schedule of a non-convex, purity-coupled segmentation problem buys accuracy that the converged problem does not have.
Core Claim
The obvious combination, unfolding the one-dimensional fused lasso for copy number segmentation, is not worth doing on its own. The fused lasso fits a piecewise-constant signal by penalizing the absolute differences between neighboring values. Its single-channel version has exact direct solvers (taut-string and dynamic-programming methods) that run in linear time, so there is no iterative latency to remove. The latency is real only once the problem becomes what clinicians actually need. That problem is two-channel, couples breakpoints across channels, and is entangled with an unknown purity. In this form there is no exact direct solver, and the purity coupling makes the problem non-convex. Our claim is that an unrolled solver of this coupled problem, with roughly 10–20 layers, will match the converged classical solution on high-purity samples. On 30–50% purity samples it should exceed that solution in breakpoint pAUC, the partial area under the ROC curve at a 5-locus tolerance.
The objective we unroll is
$$\min_{\theta,\,p}\ \sum_{i} \big(c_i - p\,\theta^{c}_i - (1-p)\big)^2 \;+\; \sum_{i\in H} \big(d_i - p\,\theta^{d}_i\big)^2 \;+\; \lambda \sum_{i} \big\|\theta_{i+1}-\theta_i\big\|_2 .$$
Here $c_i$ is the normalized total copy signal at locus $i$, and $d_i$ is the allelic imbalance, defined only on the set $H$ of heterozygous SNP loci. $\theta_i=(\theta^c_i,\theta^d_i)$ is the tumor-only state at locus $i$, and $p\in(0,1]$ is purity. The group penalty with weight $\lambda$ forces both channels to break at the same positions. The allelic term is a first-order linearization of how imbalance scales with purity; the exact model can be substituted without changing the architecture.
The motivation for coupling purity comes from A Sharp Error Analysis for the Fused Lasso. That paper proves that the fused lasso places each estimated changepoint within $O_P(\log n \log\log n / H_n^2)$ of the true one, where $H_n$ is the jump height. Dilution shrinks the observed jump to $pH_n$, so the screening distance grows like $1/p^2$. Going from pure tumor to 30% purity therefore loosens the guarantee roughly elevenfold. This matches the collapse that Performance evaluation of DNA copy number segmentation methods reports below 70% purity. That benchmark is the evidence for the gap. The analysis tells us which quantity, $p$, a solver must model rather than ignore.
Research Program
Layer design. We will build the unrolled solver around the dual of the group-penalized problem. With $p$ held fixed, the dual is a projected gradient iteration over one two-dimensional variable per adjacent locus pair, projected onto a ball of radius $\lambda$. Each layer performs one such step, which costs one pass over the sequence. The layer then updates $p$, which is a scalar least-squares problem given $\theta$ and so has a closed form. The learned parameters per layer are a step size and a penalty level $\lambda_k$. Letting $\lambda_k$ vary allows a learned continuation schedule, starting coarse and refining.
Per-sample settings. A small policy predicts the starting $\lambda$ and $p$ from cheap summary statistics of the raw profile: noise scale, an allelic-imbalance histogram, and first-layer residuals. This borrows the residual-feedback idea of Deep FlexQP, which uses a recurrent network over residual histories to set the parameters of an unrolled ADMM solver for robot trajectory programs. We deliberately use only scalar features. The recurrent network in FlexQP adds per-layer overhead that FlexQP's own authors identify as a cost.
Choice of base iteration. We chose a dual proximal-gradient (ISTA-like) iteration over ADMM, the splitting method that is the default for composite penalties. The reason is Optimization Guarantees for ISTA and ADMM Based Unfolded Networks. It proves that unrolled ADMM has a larger Hessian bound and therefore a lower training-sample threshold. It also shows empirically that unrolled ADMM stalls at about 2,000 samples while unrolled ISTA trains to about 3,000, on a synthetic 25×200 sparse recovery problem with smooth activations. That paper constrains our design. It also leaves a testable question: does the ordering survive real non-smooth projections and genomic data? We will build both variants and measure training failure as the cohort size grows.
Training data and loss. Training profiles come from the dilution series themselves. We splice segments from GEO GSE11976 (Illumina, 14–100% purity), whose dilution design gives the purity, copy states, and breakpoints of the segments we splice. The loss combines segment reconstruction with a smoothed breakpoint-screening loss. Testing is on GSE29172 (Affymetrix SNP6, 30–100% purity). That is a different platform, so the evaluation includes platform shift.
Structural precedents. The architecture inherits two ideas from wireless unfolding. One is the fixed-depth compression shown by Unfolding WMMSE Using Graph Neural Networks, which matches classical WMMSE in 4 layers instead of about 100 iterations. The other is the inner-outer update split of Joint Communications and Sensing Hybrid Beamforming Design via Deep Unfolding, which updates a badly scaled block (the analog precoder) more often than the other. Our analogue is several $\theta$ steps per $p$ step. Neither paper touches sequence segmentation. Their objectives are smooth utilities on interference graphs, whereas ours has a non-smooth penalty along a chain.
Baselines
Do-nothing reference. The simplest reference is single-channel fused lasso on $c$ alone, solved exactly with a direct linear-time solver, with $\lambda$ set by a fixed noise-scaled rule and no purity model. It shows how much of any gain comes merely from using two channels and modeling purity.
Strongest same-objective competitor. This baseline is the critical one. It is the identical coupled objective, solved classically to tight convergence by alternating a primal-dual group fused lasso solver with the closed-form purity update. $\lambda$ is chosen per sample by a grid with an information criterion, and purity starts from several initial values. It receives the same input data and is allowed as much wall-clock time as it needs. The unrolled model beats it only if it reaches equal pAUC at 70–100% purity and higher pAUC at 30% and 50% purity, with non-overlapping bootstrap intervals over samples. Matching it more cheaply counts as a speed result only, not an accuracy result.
Strongest published methods. We will rerun the best joint total-copy-plus-allelic method in the benchmark of Performance evaluation of DNA copy number segmentation methods under that paper's protocol. That paper reports that joint methods generally beat single-channel ones. It reports the degradation qualitatively; we found no pAUC values on Lacuna for the 30% or 50% dilution levels, so we will report our own rerun numbers. We also run three further segmenters. DBS is a least-absolute-error binary segmentation with constant-time interval sums. On TCGA-OV chromosome 8 it reports AUC above 0.9 and runs about 5× faster than PCF and 15× faster than CBS. mBPCR, from Bayesian DNA copy number analysis, reports higher breakpoint sensitivity than CBS, GLAD and HMMs on the mantle cell lymphoma lines, at a slightly higher false discovery rate. Finally, CBS and PCF serve as the classical references.
Ablations. Four ablations isolate the key ingredient. The first truncates the classical iteration to $K$ steps with untrained classical step sizes, which tests whether learning matters at all. The second learns the step sizes but holds $\lambda$ fixed. The third learns the $\lambda$ policy but uses classical step sizes. The fourth swaps the dual proximal-gradient core for unrolled ADMM. All learned variants get the same training profiles and the same hyperparameter search budget, and run on the same hardware.
Why not just…?
Why not just run an exact fused lasso solver over a grid of penalties? For a single channel this alternative wins, and that is why we do not propose it. Exact linear-time solvers make unfolding pointless there. The threat carries over to two channels if a penalized dynamic-programming method that optimizes the number of segments directly (optimal partitioning, for example) handles the joint profile well. We will include such a method with a purity grid. If it matches our low-purity pAUC at comparable cost, the core claim fails.
Why not just use DBS? DBS is fast and accurate on dense profiles. However, its authors state that it is unsuitable for low-density arrays and needs at least 20 probes per segment. It segments one signal, so it cannot share breakpoints between total copy and allelic imbalance. It also has no purity model, and the joint-channel finding of Performance evaluation of DNA copy number segmentation methods indicates that a purity-aware joint model is what matters at low purity. The 30–50% dilution comparison will show whether that structural gap costs DBS accuracy.
Why not just train a convolutional network to output breakpoints? This is a fair competitor because it can learn the purity effect implicitly. Its weakness is that it has no mechanism that transfers across platforms or probe densities. Our held-out Affymetrix test, after training on Illumina-derived profiles, is exactly the shift where we expect it to fail. We will match its parameter count and training data to ours. If it equals the unrolled model under platform shift, the algorithmic prior is not earning its keep.
Why not just use SeCNV-style graph segmentation? Resolving single-cell copy number profiling for large datasets segments 50,000 cells in under four minutes, with F1 above 0.95 on simulated data. It does so by pooling information across many cells. A single bulk biopsy offers no such pool, so this method addresses a different setting and is not a direct competitor here.
Proposed Experiments
Main test. The main experiment is breakpoint pAUC at a 5-locus tolerance on held-out GSE29172, at each dilution level, for every method and ablation. A second set of curves plots pAUC against the number of passes over the sequence, for the unrolled model at $K\in\{5,10,20,40\}$ and for the classical coupled solver at matched pass counts. The claim survives only if two things hold. First, the learned model at about 20 layers beats the converged same-objective baseline at 30% and 50% purity. Second, that advantage disappears in the first ablation, which uses untrained classical step sizes. If the advantage remains in that ablation, the gain comes from truncation acting as implicit regularization rather than from learning, and we will report it that way.
Purity recovery. A secondary check compares estimated $p$ with the known dilution fractions. A model that segments well while misestimating purity would be exploiting something other than the intended mechanism.
Scaling test. We will train both the dual proximal-gradient and ADMM unrolled variants on 500 to 20,000 spliced profiles and record where training loss stops decreasing. If the ADMM variant stalls first, the threshold ordering in Optimization Guarantees for ISTA and ADMM Based Unfolded Networks holds beyond smooth synthetic problems. If the ordering reverses, the case for ISTA-like cores in non-smooth unrolling weakens.
Throughput. Finally, we measure cohort throughput on TCGA-OV against DBS, PCF, and CBS, alongside aberration-calling AUC with DBS's reported value above 0.9 as the reference. The purpose is to confirm that the fixed-depth model sits in the same speed class as the fastest segmenters.
References
- A Sharp Error Analysis for the Fused Lasso, with Application to Approximate Changepoint Screening
- Performance evaluation of DNA copy number segmentation methods
- Deep FlexQP: Accelerated Nonlinear Programming via Deep Unfolding
- Optimization Guarantees for ISTA and ADMM Based Unfolded Networks
- Unfolding WMMSE Using Graph Neural Networks for Efficient Power Allocation
- Joint Communications and Sensing Hybrid Beamforming Design via Deep Unfolding
- DBS: a fast and informative segmentation algorithm for DNA copy number analysis
- Bayesian DNA copy number analysis
- Resolving single-cell copy number profiling for large datasets