Bacterial isolates are now routinely assembled from two kinds of DNA sequencing data. Cheap, accurate short reads come first. Expensive, error-prone long reads from a nanopore sequencer then bridge the repeats that short reads cannot span. Nanopore devices can also reject a molecule mid-read, after its first few hundred bases, by reversing the pore voltage. This "adaptive sampling" is today steered only by fixed reference lists ("keep reads from chromosome 20"). Yet in a hybrid workflow the short-read assembly graph already exists before the nanopore run starts. That graph is a map of the genome's sequence pieces, with tangles wherever repeats leave the order ambiguous, and it says precisely which few regions need long reads. This proposal borrows the central move of learned MRI acceleration: train the sampling pattern and the reconstruction model together, end to end. Here the "sampling pattern" is a per-sample list of short-read graph pieces whose reads the pore should keep. The "reconstructor" is a graph neural network that untangles the hybrid graph from the reads that were kept.
The core claim is concrete. A model that reads the short-read graph and outputs a fixed keep/reject decision for each graph piece, trained jointly with the graph resolver under a budget on sequenced bases and pore rejections, will recover complete chromosomes and plasmids at a fraction of the long-read yield that unguided sequencing needs. It will also beat both a hand-designed "keep reads near tangles" rule and a fully read-by-read adaptive policy. The MRI literature predicts that the read-by-read policy loses, and testing whether that prediction carries over is part of the contribution.
What exists and where the gap is
Learned acquisition in MRI supplies the method. LOUPE represents the set of measured k-space locations (the frequency-domain samples an MRI scanner collects) as a continuous probability map with a sparsity penalty, and trains it through a reconstruction network. Deep Probabilistic Subsampling uses Gumbel-Softmax selection with an unrolled, physics-aware reconstructor. Weiss et al. hard-threshold the mask in the forward pass and use straight-through gradients. They report 0.45–0.8 dB PSNR gains over fixed masks, which is evidence that a reconstructor alone cannot make up for a sampler that ignores it.
Two adaptive-policy papers constrain the design. Pineda et al. found that a single dataset-level reinforcement-learning trajectory was more stable than, and often matched, a per-subject one. Bakker et al. found that their best "adaptive" policies converged to non-adaptive patterns, and that more adaptive policies gave worse SSIM. Their explanation is an amortization trap: a reconstructor cannot master an unbounded variety of artifact patterns. We take this seriously. Our sampler is therefore static within a run but conditioned on a cheap side modality, the short-read graph. Read-by-read adaptivity is treated as a hypothesis to test, not a default.
On the genomics side, three lines of work are adjacent but decoupled. SimReadUntil simulates a nanopore device's reject/continue interface at the basecalled-read level, including unblock delays and pore loss under frequent rejection. It reports a 16-fold target enrichment with ReadFish on human chromosomes 20 and 21. Every selection algorithm it benchmarks steers by a fixed reference, and it performs no assembly. Plassembler discards chromosomal long reads after sequencing, then runs Unicycler on the rest. This is 3–10× faster and recovers small plasmids Unicycler misses. However, the filtering happens after the pore time is already spent, and the paper reports failures on shared mobile elements and at low long-read depth. Vrček et al. train graph networks to execute assembly-graph simplification. GatedGCN untangling classifies graph edges to beat Raven's heuristics on human HiFi data. Both resolvers are passive: they take whatever reads arrived, and they assume roughly uniform coverage, which adaptive sampling deliberately breaks.
Nobody has trained a pore-level acquisition rule against an assembly objective, and nobody has used one sequencing modality to plan acquisition of the other.
Core Claim
Hybrid assembly is an asymmetric version of joint sampling and reconstruction. The dense, static short-read graph should determine where the sparse, expensive long reads go. The resolver should be trained on exactly the skewed coverage that this plan produces. Co-training the planner and resolver should beat any arrangement where either one is designed independently.
Research Program
The pipeline begins with short reads, assembled into a unitig graph (the short-read de Bruijn graph that Unicycler builds; a unitig is a maximal unambiguous stretch of sequence). A planner graph network $g_\phi$ reads this graph and outputs a keep-probability $m_u \in [0,1]$ for every unitig $u$.
During the nanopore run, a ReadFish-style controller maps each read's basecalled prefix to the unitig sequences. If the prefix lands on unitig $u$, the controller keeps the read with probability $m_u$, or keeps it deterministically if $m_u$ is thresholded at test time. If not, it rejects the read.
The resolver $f_\theta$ is a GatedGCN-style edge classifier. It runs on the short-read graph augmented with long-read path support from the kept reads. Its job is to predict which graph edges lie on the true genome walk.
Training takes place inside SimReadUntil, on isolates with complete reference genomes, which supply the edge labels $y$. The objective is
$$\min_{\theta,\phi}\ \mathbb{E}\big[\ell(f_\theta(G, R_\phi), y)\big] + \lambda_1\,\mathbb{E}[\text{kept bases}] + \lambda_2\,\mathbb{E}[\text{rejections}],$$
where $G$ is the short-read graph, $R_\phi$ is the set of long reads kept under the planner's mask, and $\ell$ is edge-classification cross-entropy. The $\lambda_1$ term prices sequencing yield. The $\lambda_2$ term prices pore wear and unblock dead time, which SimReadUntil models and which every MRI policy treats as free.
Gradients reach $\phi$ by straight-through estimation over the per-read Bernoulli keep decisions, as in Weiss et al. Because the planner is a shared network rather than a per-sample mask, the result is an amortized LOUPE conditioned on side information.
Three questions organize the analysis. First, what does the learned plan keep beyond reads touching tangles? The LOUPE-style expectation is that it learns non-obvious allocations. Examples would be trading coverage across repeats of different difficulty, and declining to keep reads from an insertion sequence shared between chromosome and plasmid, while keeping that element's unique flanks. Second, does co-training matter, or does any reasonable mask plus a resolver trained on uniform coverage do as well? Third, does re-planning during the run, every fixed interval using the partially resolved graph, help? Or does it fall into the amortization trap in the way Bakker et al. observed?
Baselines
The naive reference point is unguided hybrid assembly at matched long-read yield: Unicycler on all short reads plus a random subsample of long reads equal in bases to what the adaptive methods keep. We sweep that yield from roughly 5× to the 60× used in Plassembler's simulations. This baseline shows how much any steering buys at a given budget.
The strongest existing post-hoc competitor is Plassembler. On its 20 simulated isolates at 60× coverage, it missed 1 plasmid versus 7 for Unicycler. That is the number to match. We will run it on the same read sets with its default Flye draft, at full yield and at matched reduced yield. Our method beats it if it misses no more plasmids than Plassembler's reported 1 at 60× while keeping substantially fewer long-read bases, and if it misassembles no more often under QUAST.
The strongest existing adaptive competitor is ReadFish as benchmarked in SimReadUntil, configured with the short-read unitigs as its target list. It runs in the same simulator with the same rejection latency. Its reported 16-fold enrichment on human chromosomes 20 and 21 is not comparable to assembly completeness. No reported result was found on Lacuna for adaptive sampling evaluated by de novo bacterial assembly completeness, so we establish this baseline ourselves.
The key ablation is a hand-designed mask: keep reads whose prefix maps within one read-length of a short-read tangle, where a tangle is a unitig with branching degree above one or coverage above 1.5× median. This mask is run with two resolvers. The first is trained on uniform coverage. The second is co-trained on that same mask's coverage. Comparing them isolates the learned planner from resolver co-adaptation.
A final ablation swaps our resolver for plain Unicycler on the reads our planner kept. This tests whether the learned mask helps standard assemblers. All learned components get identical training isolates, simulator settings, and tuning budgets.
Why not just…?
Why not just keep reads near tangles with a hand rule and run Unicycler? This is the real threat, and it may come close. It needs no learning and directly encodes the intuition. The evidence against it is indirect. In MRI, learned masks beat variable-density heuristics that encode the same "sample where it matters" intuition (Weiss et al., LOUPE). Separately, Plassembler documents failures exactly where a flank rule would misfire: mobile elements shared between chromosome and plasmid. The tangle-mask ablation settles the question. If the hand rule matches the learned planner within noise on plasmid recovery and contiguity at every budget, we will report that the graph-conditioned target list is the contribution and learning is unnecessary.
Why not just sequence everything and filter afterwards, as Plassembler does? Post-hoc filtering spends pore time on the chromosome, which makes up most of the DNA, and inherits the draft assembler's nondeterminism and low-depth failures. The yield sweep shows directly whether steering reaches Plassembler's completeness on fewer bases. If it does not, steering has no case.
Why not just learn a read-by-read reinforcement-learning policy? A run involves very many read decisions with delayed reward. Moreover, both Pineda et al. and Bakker et al. found dataset-level or non-adaptive policies at least as good as highly adaptive ones. The re-planning arm tests this, and a per-read variant trained with the same budget serves as the upper end of the adaptivity axis.
Why not just train a better resolver on static reads? A resolver cannot recover a repeat crossing that no kept read spans. GatedGCN still left 26 contigs on human chromosome 1. The uniform-coverage resolver arm measures how far resolver improvements alone go at each budget.
Proposed Experiments
Training and in-distribution testing use Plassembler's simulated protocol: Badread long reads and InSilicoSeq short reads from complete genomes. Out-of-distribution testing replays real read sets through SimReadUntil. These include the Wick et al. isolates, the twelve De Maio Enterobacteriaceae, S. aureus C222, and K. pneumoniae CAV1217 as used by Plassembler. Rejected reads are truncated at the decision point.
Metrics are as follows: circularized chromosomes and plasmids recovered, with plasmids stratified by size below 10 kb and 20 kb; NGA50, misassemblies, and indel and mismatch rates against references; kept long-read bases; and rejection count as a proxy for pore wear.
The decisive check is a curve of plasmids recovered against long-read bases kept. The learned planner must dominate both the hand-designed tangle mask and Plassembler at matched yield on the real replayed isolates. It must do so especially on isolates whose plasmids share sequence with the chromosome, identified from their references. If it dominates only on simulated data, the gain is a simulator artifact. If re-planning beats the static plan, the amortization trap does not transfer when adaptivity comes from a second modality, which would be a finding worth reporting either way.
References
- Learning-based Optimization of the Under-sampling Pattern in MRI.
- Learning Sampling and Model-Based Signal Recovery for Compressed Sensing MRI
- Joint Learning of Cartesian under Sampling Andre Construction for Accelerated MRI
- Active MR k-space Sampling with Reinforcement Learning
- On learning adaptive acquisition policies for undersampled multi-coil MRI reconstruction
- SimReadUntil for benchmarking selective sequencing algorithms on ONT devices
- Plassembler: an automated bacterial plasmid assembly tool
- A step towards neural genome assembly
- Learning to Untangle Genome Assembly with Graph Convolutional Networks