Image reuse in published western blots is rarely a whole figure copied wholesale. A western blot is a photograph of protein bands arranged in vertical lanes, and the reuse that integrity reviewers find is usually partial. A single lane or band appears again in another figure, often flipped, cropped, re-contrasted, or spliced next to new lanes. Current automated tools assign one fingerprint per image. The best-known example maps whole figures to a 128-number vector and calls two images duplicates when their vectors are close (Image Forensics: Detecting duplication of scientific images with manipulation-invariant image similarity). That paper says its own model fails under simple contrast and gamma changes, and that the method does not yet scale to literature-wide search. This proposal has two parts. The first is a descriptor at the level of individual lanes, built from the rank order of intensities along each lane. A brightness or contrast change that preserves ordering (gamma, contrast stretch, histogram equalization) leaves rank order untouched, so the descriptor is invariant to these edits by construction rather than by training. The second part is a systems question that this granularity raises. Indexing every lane at several scales across the literature multiplies the index size by two to three orders of magnitude. We ask, with a falsifiable crossover test, whether serving that index needs remote direct memory access (RDMA, where one machine reads another machine's memory through the network card without involving the remote processor) or whether a single machine with a compressed index is enough.
The systems claim is deliberately narrow. The reviewer's objection that "128-dimensional vectors fit on one box" is correct for whole-image fingerprints, so we do not propose RDMA for that case. The design we test keeps a compressed index on the query node for candidate generation. The full-precision lane descriptors and raw lane intensity profiles live in pooled remote memory and are fetched by one-sided RDMA reads only to re-rank the few candidates per query. If local flash or plain sharding over TCP matches this design at equal recall and false-flag rate, we will report that, and the systems half of the claim will be retired.
Core Claim
The first claim is that ordinal lane descriptors recover partial, contrast-edited blot reuse that whole-image metric embeddings miss. The second claim is conditional. Once the index is lane-level, a hybrid layout with a compressed local index and exact re-ranking from remote memory gives lower tail latency at a fixed recall than re-ranking from local NVMe flash, and lower CPU cost than scatter-gather sharding over TCP. This should hold above a corpus size that we will measure rather than assume.
A sizing calculation shows why the second claim is plausible but not obvious. Suppose there are $N$ figures, $L$ lane crops per figure, and $S$ scales per crop, with $d$-dimensional float32 descriptors. The full-precision store then takes $4\,d\,N\,L\,S$ bytes. Under illustrative assumptions ($N = 10^7$, $L = 50$, $S = 4$, $d = 128$), that is about a terabyte. This is beyond a typical single node's memory. Product-quantized codes of 32 bytes would bring it to about 64 GB, which does fit in one node's memory. So candidate generation stays local. The open question is whether the re-ranking step, which makes random accesses into the terabyte-scale exact store, is better served by remote memory or by local flash. That question decides the systems contribution.
Research Program
On the forensic side, the work starts with lane segmentation of blot crops. We take column intensity profiles and split at troughs between lanes, and we also train a small learned segmenter checked against manual labels on a few hundred crops. Each lane is converted to a one-dimensional profile and a small two-dimensional patch. The ordinal descriptor replaces each pixel by its rank within the lane. It then encodes the rank profile at several scales and orientations, so that flips are handled by storing both directions, and a light learned projection maps this to $d$ dimensions. The projection is trained with a contrastive loss (pull matching lanes together, push others apart) on crop and splice augmentations, but it receives no contrast augmentation, because the rank transform already removes that variation.
We will also test how far the invariance claim holds. Rank order is exactly preserved under monotone pointwise intensity maps. It is not preserved under local or non-monotone edits such as noise, blur, re-compression, or the adversarial perturbations that collapse generic detectors in RAID: A Dataset for Testing the Adversarial Robustness of AI-Generated Image Detectors. We will measure that degradation directly rather than claim robustness we have not shown.
On the systems side, we build three serving layouts over the same lane index, and for the hybrid layout two variants of the remote store. In every layout, product-quantized codes and a graph-based approximate nearest-neighbor index sit on the query node. The layouts differ only in where full-precision vectors and lane profiles live during re-ranking. In the first layout they sit in the local memory of a large-memory machine, which is an upper bound and is only possible at small scale. In the second they sit on local NVMe read through user-space drivers, in the style of SPDK as used in SpanDB: A Fast, Cost-Effective LSM-tree Based KV Store on Hybrid Storage. In the third they sit in a disaggregated memory pool read with one-sided RDMA, following the pooled-memory model of Transactional Indexes on (RDMA or CXL-based) Disaggregated Memory with Repairable Transaction.
The remote store comes in two variants. The simple one is a plain append-only array. The second applies that paper's repairable transaction primitive to a remote hash table (RaceHashing), so that many ingestion clients can insert new lanes concurrently. In that paper, a client that crashes mid-insert can otherwise leave the shared index half-updated. This is relevant because literature indexing is continuous and runs from many sources. If the append-only array with periodic rebuilds is adequate, we will say so. Query workers pin cores and use polling rather than interrupts, as in PinTok: Tokenizers Deserve Dedicated Pinned CPU-Compute and Memory. That work reports a 43% reduction in ChromaDB retrieval time from kernel bypass and pinned memory, but on text-token workloads, not image descriptors.
Baselines
The naive reference point is the whole-image Siamese embedding of Image Forensics: Detecting duplication of scientific images with manipulation-invariant image similarity. It uses a three-branch network producing 128-dimensional vectors with a fixed distance threshold of 1.0, and we pair it with exact search. It is the direct prior method for this task. We retrain it on the same blot crops with its published augmentations and the same training-step budget, and we give it an additional threshold sweep so that it is not handicapped by the fixed cutoff. No reported result was found on Lacuna for this model's accuracy on its 126 real misconduct cases, which is the number we would most want to beat. We therefore report our own re-measurement and treat beating it as a gain in recall at matched false-flag rate on those cases and on planted partial-reuse queries.
The strongest descriptor competitor is a lane-level learned descriptor of the same architecture and dimension. It is trained on raw intensities with heavy contrast, gamma, and histogram-equalization augmentation, and it uses the same data and tuning budget. This is the ablation that isolates the key ingredient. If it matches the ordinal descriptor on contrast-edited lanes, then invariance by construction adds nothing and the gain comes from lane granularity alone.
The strongest systems competitor is the single-node layout with a compressed index in memory and exact re-ranking from local NVMe. This is the "just use FAISS on one box" answer, done properly. The second systems competitor is the same index split into shards across the same number of machines, with queries fanned out to all shards and merged, over TCP. This matches the TCP setups in Understanding the Benefits of Hardware-Accelerated Communication in Model-Serving Applications, which reports 15–50% end-to-end latency reductions from GPUDirect over TCP in multi-hop vision serving and twice the CPU use for TCP on DeepLabV3. That study covers model serving, not index lookup, so it motivates our hypothesis without settling it.
All layouts get identical hardware counts, identical compressed codes, and the same search-parameter tuning budget. Each is tuned to the same target recall. Beating the NVMe layout means lower p99 query latency or higher queries per second per node at equal recall, at a corpus size where the exact store exceeds one node's memory. Beating the TCP layout means lower CPU cost per query at equal latency.
Why not just…?
Why not just put everything on one machine with a compressed index? For whole-image fingerprints, this is the right answer, and we adopt it. For lane-level fingerprints, the compressed index still fits on one node. The unresolved part is exact re-ranking, which is what separates a true partial reuse from a look-alike band in an integrity setting where false accusations are costly. That re-ranking needs random access to a store that may not fit in memory. The NVMe re-ranking baseline is exactly this alternative, and it is a real threat. Flash random reads may be fast enough at the small candidate counts we need. The crossover experiment below settles it.
Why not just shard the index across machines over TCP? Sharding is operationally simpler and avoids special network hardware, which PinTok: Tokenizers Deserve Dedicated Pinned CPU-Compute and Memory and the GPUDirect serving study both note is a real barrier to deployment. Its cost is that every query touches every shard, which adds CPU work and tail latency. Whether that cost matters at screening rates is unknown. We measure CPU per query and p99 latency under concurrent load, and if sharding is within a small margin we will recommend it.
Why not just train the existing Siamese model with contrast augmentation? This is the most direct threat to the forensic claim, and the augmented lane-level baseline tests it head-on. Augmentation can only cover the contrast edits seen in training, whereas a rank transform covers every monotone edit. The decisive test therefore uses held-out monotone curves, such as unusual tone curves or local-window equalization, that are absent from training augmentation. If augmentation generalizes to these, the ordinal construction is unnecessary.
Why not just use texture statistics or perceptual hashes? Texture statistics are fast to compute. One-class co-occurrence statistics reach AUC 0.999 on diffusion-generated blots in Forensic Analysis of Synthetically Generated Western Blot Images. That task, however, is detecting synthetic images, not finding where a lane came from. The same paper reports these features break under resizing, which is common in reused lanes. We include a perceptual-hash lane baseline for completeness and expect it to fail on rescaled and contrast-edited lanes.
Proposed Experiments
The benchmark starts from the 14,200 real blot crops of Forensic Analysis of Synthetically Generated Western Blot Images. We plant partial reuse: a lane copied into another crop with flip, rescaling, cropping, gamma, histogram equalization, JPEG compression, and splicing, in graded combinations. The task is to recover the source lane. That paper's 24,000 synthetic blots serve as hard distractors, since generated bands resemble real ones and should provoke false matches. We also report on the 126 real misconduct cases from Image Forensics: Detecting duplication of scientific images with manipulation-invariant image similarity. We will be candid that this set is too small for fine-grained conclusions. Forensic metrics are recall of the source lane within the top ten candidates, and precision at a fixed false-flag budget per ten thousand queries. In addition, a robustness curve under small adversarial-style perturbations shows where rank invariance stops helping.
For the systems experiment, the corpus of real crops is too small to stress memory. We therefore scale the distractor set synthetically, using augmented and generated lanes, until the exact store passes one node's memory, and we sweep corpus size across that boundary. We report p50 and p99 latency, queries per second per node, and CPU per query for each layout at matched recall. For the concurrent-ingestion variant, we compare throughput against a lock-based baseline under uniform and skewed insert patterns. The prior paper reports 8–13% overhead for its repairable transactions on uniform workloads and up to 42% under skew, versus non-fault-tolerant baselines, on key-value benchmarks rather than vector re-ranking.
Two outcomes are decisive. The ordinal descriptor must beat the contrast-augmented lane descriptor on held-out monotone edits at matched false-flag rate; otherwise the forensic novelty reduces to "index lanes, not images." Separately, the RDMA re-ranking layout must beat NVMe re-ranking in p99 latency at matched recall beyond the memory crossover. If it does not at any tested scale, the conclusion is that literature-scale blot screening needs no special network hardware, and that finding is worth publishing as well.
References
- Image Forensics: Detecting duplication of scientific images with manipulation-invariant image similarity
- RAID: A Dataset for Testing the Adversarial Robustness of AI-Generated Image Detectors
- SpanDB: A Fast, Cost-Effective LSM-tree Based KV Store on Hybrid Storage
- Transactional Indexes on (RDMA or CXL-based) Disaggregated Memory with Repairable Transaction
- PinTok: Tokenizers Deserve Dedicated Pinned CPU-Compute and Memory
- Understanding the Benefits of Hardware-Accelerated Communication in Model-Serving Applications
- Forensic Analysis of Synthetically Generated Western Blot Images