Phylogenetic placement takes an unknown DNA sequence, such as a sequencing read from an environmental sample, and finds the branch of a fixed, trusted reference tree it most likely came from. The standard tool, pplacer, makes this fast by precomputing a conditional likelihood vector (CLV) for every branch. A CLV is a table giving, for each alignment column and each possible nucleotide, the probability of the data below that branch. Placing a read then costs one pass over these tables, and because reads are independent, the work splits across processors with no communication.
That picture breaks once reference alignments become whole organelle genomes: about 150,000 bp for chloroplasts and about 15,000 to 61,000 bp for mitochondria in the systems studied here. At that length the CLV tables no longer fit in one accelerator's memory. Take 1,000 reference taxa, 150,000 columns, 4 nucleotides and 4 rate categories, with tables stored in both directions on each of $2N-3$ branches. That is about $9.6\times10^9$ numbers, or about 77 GB in double precision. The alternative to copying the tables everywhere is to split them by alignment column across devices. Then every read's score on every branch is a sum of partial scores held on different devices, and placement turns into a repeated all-reduce: the collective operation that sums a tensor across devices, the same primitive that dominates distributed neural network training. This proposal brings block-wise quantization (giving each small group of numbers its own scale) to both the stored CLV tables and the cross-device score and derivative messages. The goal is chloroplast-scale placement with near-exact agreement with double-precision pplacer.
Core Claim
Phylogenetic likelihood code already performs a crude form of block floating point. To avoid numerical underflow, libraries rescale each site's partial likelihoods by a shared exponent. We claim this existing structure makes CLVs a natural fit for microscaling formats: 8-bit, and possibly 4-bit, values sharing one scale per small block (one site's states and rate categories). Applying the same block scaling to the per-branch partial log-likelihood scores exchanged between column shards, then running a two-stage search, should cut memory and communication by 4–8× with negligible change in placements. The two stages are a coarse pass over all branches using quantized scores, followed by an exact double-precision pass on a few candidate branches. Here, "negligible change" means the same best branch, and confidence weights and Expected Distance between Placement Locations (EDPL) within simulation noise.
The second claim is a sharper scientific one. INT vs. FP: A Comprehensive Study of Fine-Grained Low-bit Quantization Formats reports that at block sizes of 16–32, integer formats beat floating-point formats because values inside a small block become locally uniform. CLV blocks violate that premise. Within one site, one nucleotide typically dominates and the others can be orders of magnitude smaller. We therefore predict the opposite crossover for phylogenetic data: logarithmic or floating-point codes should win even at the smallest blocks. Either outcome tells us something about when the LLM-derived format rules transfer to other data.
Why this combination, not the obvious one
The research file points toward a different intersection: data-parallel training of differentiable phylogenetic models with compressed gradients. These models include GNN-based variational inference (Learnable Topological Features For Phylogenetic Inference via Graph Neural Networks), hyperbolic embeddings (GeoPhy) and distance-matrix variational inference (VIPR). The candidate compressors are those built for LLMs: BitDP or majority-vote sign descent (ABSignSGD).
We think this is the wrong target. These models are evaluated on 27–71 taxa (and synthetic sets up to 512 taxa). Their shared parameters are branch-length and network weights that are small next to the alignment-wide likelihood computation. Automatic Differentiation is no Panacea for Phylogenetic Gradient Computation shows that cost is dominated by the recursive likelihood traversal, at least 8× slower in generic autodiff frameworks than in specialized C. The bottleneck there is computation, not the network. We will confirm this with one profiling run rather than assume it.
The large objects in phylogenetics are the per-site likelihood tables, and placement on long reference alignments is where they become too large to copy. That is where block quantization and synchronization cost actually bite. The motivating evidence for treating synchronization as a first-class cost comes from distributed training, where it takes up to half (Tong Xiao et al.) or up to 92% (Hanzhen Zhao et al.) of step time. Whether placement reaches comparable fractions is something we measure, not something we import.
Research Program
The system has three pieces.
Block-scaled CLV storage. Each site's block of $S\cdot R$ values (16 for 4 nucleotides and 4 rate categories) stores one shared 8-bit exponent and $S\cdot R$ codes of 4 or 8 bits. We compare integer, FP8/FP4-style and logarithmic codes. The block layout follows the microscaling formats of Pushing the Limits of Narrow Precision Inferencing at Cloud Scale with Microsoft Floating Point and MicroMix. The logarithmic option follows the non-linear dynamic code of 8-bit Optimizers via Block-wise Quantization, which supplies the method: dequantize on the fly and accumulate in high precision.
This also answers the concern raised by Saurabh Agarwal et al. that compression kernels compete with computation. The per-site rescaling pass already computes the block maximum, so quantization can be fused into the kernel that produces the CLV at almost no extra cost. We will measure that cost directly.
Site-sharded placement with quantized reductions. Alignment columns are split across $P$ devices. For a batch of $Q$ reads and $E$ branches, each device computes a $Q\times E$ matrix of partial log-likelihoods. Each row is sent as a full-precision offset (the row maximum) plus 8-bit block-scaled differences. Receivers dequantize and sum in FP32, using all-gather followed by local reduction. This mirrors how BitDP avoids overflow in low-bit sums, but here the grouping is per read rather than per channel.
The resulting coarse scores rank branches. The top $k$ candidates then go through pplacer's "baseball" refinement in double precision. That refinement runs Newton optimization of the attachment branch lengths, and its first and second derivatives are also summed across shards, as small exact messages. The quantized pass only has to get the right branches into the candidate set. It never decides the final answer.
Error analysis. Suppose quantization introduces relative error $\epsilon$ per site likelihood. The log-likelihood error of a read spanning $L$ sites then grows as roughly $L\epsilon$ under biased rounding but only about $\sqrt{L}\,\epsilon$ under stochastic rounding, since independent zero-mean errors add in quadrature. Stochastic rounding is the same remedy 8-bit Optimizers via Block-wise Quantization needed for accumulators whose dynamic range keeps growing. Placement depends on differences between branches, and nearby branches share most of their tables, so part of this error cancels. We will derive the probability that the true best branch falls outside the top $k$, as a function of the score gap and $L\epsilon$, and validate it against simulation.
As a secondary regime, we treat reference refinement. When new divergent organelle genomes are added, as in the rockfish and crane-fly revisions (Sebastiscus mitogenomes, Tipuloidea mitogenomics), reference branch lengths are re-optimized by gradient steps whose gradients are summed across column shards. After each refinement, the updated CLVs must be redistributed. Block-scaled CLVs shrink exactly that redistribution.
Baselines
The naive reference point is double-precision pplacer run query-parallel with fully replicated CLVs, on hardware large enough to hold them. Its placements define ground truth for agreement metrics. Its reported throughput of twenty thousand short reads on a thousand-taxon reference per hour per processor (pplacer) anchors the speed comparison. That figure is for short marker alignments, and we found no reported result on Lacuna for placement onto whole-chloroplast references, so we will re-measure it on our data.
The strongest simple competitor is the same query-parallel design with FP32 tables. It halves memory at no algorithmic cost and keeps the per-site rescaling libraries already use. In our 1,000-taxon example it fits on an 80 GB device, so it is a real threat. Beating it means matching its placement agreement (at least 99.5% identical best branch on simulated reads) while either fitting references that FP32 cannot (more taxa, or smaller devices) or achieving lower end-to-end time per read.
For communication, the strongest existing compressor is BitDP-style channel-adaptive 2-bit quantization applied per branch. BitDP reports up to 32× gradient compression with under 1% perplexity loss on GPT models (BitDP), but that is on LLM gradients, and there is no reported result on Lacuna for phylogenetic scores. All arms share the same kernels, the same simulated and real reads, the same device count and interconnect (we run both InfiniBand and Ethernet), and the same budget for tuning $k$.
Two ablations isolate the key ingredient. Per-tensor scaling at the same bit width versus per-site blocks tests block isolation itself. The quantized coarse pass alone, with no exact refinement, tests how much the two-stage design carries.
Why not just…?
Why not just replicate the reference and stay embarrassingly parallel? This is the most serious alternative, and we do not argue around it. Block-scaled CLVs are equally useful for replication: an 8-bit copy of the 77 GB example table is about 10 GB, plus one byte of scale per 16 values. The experiments therefore run both deployment modes with every number format and map where each wins, by number of taxa, alignment length, and device memory. If quantized replication dominates everywhere we test, the contribution reduces to the storage format, and we will report it that way.
Why not just use FP32 or bfloat16 with the usual per-site rescaling? FP32 is the baseline above. Bfloat16 keeps an 8-bit exponent per value but only 7 mantissa bits, so it spends exponent bits on every value where a shared block exponent spends them once. We test it directly. A lower placement agreement for bfloat16 than for block-scaled 8-bit codes at equal or smaller size would show the shared exponent earning its place.
Why not just send each shard's local top few branches instead of all scores? A read's score is a sum over shards, so a branch can be mediocre on every shard yet best overall. Local top-$k$ sparsification can therefore miss the global winner. We include it as a baseline with the same message size as our quantized scores and measure how often it loses the true best branch, especially on reads whose sites are unevenly informative across shards.
Why not use 1-bit signs or majority vote, which cut communication by 960× in ABSignSGD? Signs carry no ranking information for log-likelihood scores. All scores share a sign, and what matters is their gaps. Sign compression has no meaningful analogue for this task, so we exclude it rather than run a strawman.
Proposed Experiments
Data. Simulation uses reads drawn from the pplacer setup of 631 COG alignments, plus reads simulated on organelle-length alignments. We include extreme branch-length ratios (long-branch-attraction regimes such as $a=40b$, following Novel symmetry-preserving neural network model for phylogenetic inference) to stress dynamic range within blocks. Real references are assembled from public organelle genomes of the families covered in the file: chloroplasts around Saposhnikovia divaricata and Knorringia sibirica, and mitogenomes around Torodora canaliculata (15,590 bp), Aloa lactinea and the fungal Mucor indicus (61,400 bp). The Influenza A sets of 20–2000 sequences from the autodiff benchmark (Automatic Differentiation is no Panacea) provide a taxon-count sweep at fixed sequence type. For real data, double-precision placement is the reference.
Metrics. Accuracy is measured as best-branch agreement, absolute error in confidence weights, EDPL difference, and tree distance to the true edge on simulated reads. We also check downstream sample comparisons using edge principal components and squash clustering (Edge Principal Components and Squash Clustering) to see whether quantization changes the biological conclusions. Cost is measured as peak memory, bytes sent between devices, fraction of wall-clock time spent in collectives, and reads per hour.
Decisive checks. Three checks decide the proposal. First, the format crossover: does a logarithmic or FP code beat integer at block size 16 on CLVs, contradicting the LLM result? Second, the long-branch stress test: does per-site block scaling keep best-branch agreement at or above 99.5% where per-tensor scaling collapses? Third, the replication-versus-sharding map: is there any realistic regime, defined by taxa count, alignment length, and memory, where site sharding with quantized reductions beats quantized replication end to end?
A negative answer to the third check still leaves a deliverable format result. A negative answer to the second would show that per-site rescaling, rather than finer blocking, is what matters. That too is worth knowing before anyone builds low-precision phylogenetic hardware paths.
References
- pplacer: linear time maximum-likelihood and Bayesian phylogenetic placement of sequences onto a fixed reference tree
- INT vs. FP: A Comprehensive Study of Fine-Grained Low-bit Quantization Formats
- Learnable Topological Features For Phylogenetic Inference via Graph Neural Networks
- GeoPhy: Differentiable Phylogenetic Inference via Geometric Gradients of Tree Topologies
- Variational Phylogenetic Inference with Products over Bipartitions
- BitDP: Ultra-low-bit Communication for Data Parallelism in LLM Training
- Arbitrary-Order Block SignSGD for Memory-Efficient LLM Fine-Tuning
- Automatic Differentiation is no Panacea for Phylogenetic Gradient Computation
- Fast Parallel Training of Neural Language Models
- SEPARATE: A Simple Low-rank Projection for Gradient Compression in Modern Large-scale Model Training Process
- Pushing the Limits of Narrow Precision Inferencing at Cloud Scale with Microsoft Floating Point
- MicroMix: Efficient Mixed-Precision Quantization with Microscaling Formats for Large Language Models
- 8-bit Optimizers via Block-wise Quantization
- On the Utility of Gradient Compression in Distributed Training Systems
- Comparative analysis of the complete mitochondrial genomes of three rockfishes (Scorpaeniformes, Sebastiscus ) and insights into the phylogenetic relationships of Sebastidae
- Comparative Mt Genomics of the Tipuloidea (Diptera: Nematocera: Tipulomorpha) and Its Implications for the Phylogeny of the Tipulomorpha
- pplacer: linear time maximum-likelihood and Bayesian phylogenetic placement of sequences onto a fixed reference tree
- Novel symmetry-preserving neural network model for phylogenetic inference
- The Chloroplast Genome of Wild Saposhnikovia divaricata: Genomic Features, Comparative Analysis, and Phylogenetic Relationships
- Complete Genome and Comprehensive Analysis of Knorringia sibirica Chloroplast
- The complete mitogenome of Torodora canaliculata (Yu & Wang, 2022) (Lepidoptera: Lecithoceridae) and its phylogenetic implications
- The Complete Mitochondrial Genome of Red Costate Tiger Moth (Aloa lactinea [Cramer, 1777]), and Phylogenetic Analyses of the Subfamily Arctiinae
- Characterization of the complete mitochondrial genome of Mucor indicus Lendn. 1930 (Mucorales: Mucoraceae), isolated from the wine fermentation system
- Edge Principal Components and Squash Clustering: Using the Special Structure of Phylogenetic Placement Data for Sample Comparison