- Rating
- 1
- Confidence
- 2
- Informativeness
- 1
- Presentation
- 2
- Soundness
- 1
Read review
Paper summary
The paper addresses a relevant practical problem: how to infer a genome foundation model on distributed computational infrastructure without presenting the original genomic data to individual workers.
The authors propose an architecture for privacy-preserving inference with the GenomeOcean-MoE model by distributing its experts among browser based workers. The architecture consists of a trusted central coordinator, browser expert workers, and Lagrange coded computing (LCC) for the model's hidden embeddings. The experiments demonstrate that leaked activations can be exploited to recover token information and identify the raw genomic data, while coding substantially reduces the success of these attacks. The proposed architecture is also robust to the failure of one worker in a three-worker configuration. In addition, the paper evaluates the impact of network latency on inference time.
The proposed architecture combines known technologies and methods, including mixture-of-experts (MoE), WebGPU, and LCC. The main novelty appears to lie in integrating these techniques into a unified architecture and applying them to a particular genome foundation model in a distributed web-based environment.
The paper does not sufficiently establish the novelty of combining existing methods, the privacy guarantees under an explicitly defined threat model, or the extent to which results obtained in an emulated infrastructure demonstrate the system's practical applicability. The methodological and theoretical foundations are insufficiently developed, and the potential for generalizing the proposed approach to other models and application domains remains unclear.
The results demonstrate the technical feasibility of the proposed approach for a specific genomic foundation model, but do not establish its methodological contribution and the readiness for industrial deployment.
Critical strengths
-
An important and timely practical problem. The authors address a problem at the convergence of several research areas: genome foundation models, privacy-preserving machine learning, and distributed computing.
-
Demonstration of the integration of coded computing, browser-based execution, and leakage analysis for a large genomic MoE model.
-
Experimental evaluation of the trade-off between privacy protection and model fidelity in a emulated distributed environment, where workers may respond with delays or become unavailable.
Critical weaknesses
-
The proposed architecture combines well-known ideas (MoE, WebGPU, and LCC). While applying this architecture to a genomic model has practical value, the paper lacks a clear scientific contribution and methodological novelty.
-
The title and the paper as a whole emphasize genomics, but the proposed architecture is not specific to genomic applications. It implements distributed privacy-preserving inference for models with public weights in a distributed environment involving untrusted workers. However, the applicability of the architecture to other models and application domains is not explored. The work focuses on applying the architecture to a specific model, which raises several methodological questions. For example, what architectural properties must a model have for the proposed approach be useful? If a new version of GenomeOcean-MoE is released, will all experiments need to be repeated? Would the same be true if a similar MoE model were fine-tuned on new data or applied to a different domain outside genomics? The generalization of the results is not investigated either theoretically or experimentally.
-
The authors do not establish that every leakage of genomic token necessarily leads to the identification of a specific individual or reveals sensitive information. The experiments demonstrate token leakage in specific scenarios, but the paper does not establish a relationship between the proportion of leaked tokens and the disclosure of meaningful genomic information. The number of leaked tokens alone is a weak privacy metric. A more important question is what information an attacker can infer from all the recovered tokens.
-
The mathematical principles underlying the proposed architecture do not require browser-based execution. The encoding and decoding of embeddings are determined by the architecture of MoE and the experts' linear transformations, rather than by any browser-specific API. Moreover, data protection in distributed computing is achieved through coding, not through the fact that the code runs in a browser. It is therefore unclear why the authors make such emphasis on WebGPU. Does using other types of distributed nodes – such as GPU servers, cloud virtual machines, mobile devices, or edge nodes – require a different arvhitecture to be developed? Moreover, questions arise as how well the emulated environment which mimics communication channel latencies with the browser corresponds to the real network environment.
-
The paper states that the coordinator can reconstruct the result from the responses of any two out of three workers. This demonstrates fault tolerance to the failure of one worker, but it does not establish Byzantine fault tolerance. Although the paper claims resilience to worker failures, it does not provide evidence of guaranteed correction of arbitrary malicious responses. Addressing this question would require both a theoretical proof and experimental evaluation.
Questions for authors
What properties must a model possess for the proposed architecture to be applicable and beneficial? Would the architecture and its privacy guarantees remain valid for a new version of GenomeOcean-MoE, a fine-tuned version of the model, or a similar MoE model in a different application domain? Which experiments would need to be repeated when the model or its weights change, and which results can be expected to generalize?
Can the authors establish a relationship between the proportion of leaked tokens and the sensitive information that an attacker can obtain, rather than relying primarily on leaked token fraction as a proxy for privacy leakage?
What specific benefits for the mathematical model does WebGPU provide beyond enabling browser-based deployment, given that the underlying encoding and decoding mechanisms do not inherently require a browser? Would replacing browser workers with GPU servers, cloud virtual machines, mobile devices, or edge nodes require changes to the proposed architecture or its privacy guarantees?
6 comments
Response to Reviewer qiQm on privacy metrics and the role of WebGPU (2/3)
W3 and Q2:
We agree that token accuracy alone is a weak privacy metric. The paper already measures two sequence-level harms for plaintext inputs (Section 5.4). From 300 unordered tokens, one worker identifies the source genome among six candidates with 0.92 accuracy (chance 0.17). A worker holding one expert index across layers recovers correct spans of up to 3,338 bp. These harms are why we treat plaintext distribution as unsafe.
For coded experts, the information bound answers your question directly, because it limits every inference rather than one attack. A fresh pad is drawn for every share, so a worker's shares form a memoryless Gaussian channel. Mutual information over such a channel is at most the sum of the per-share terms. For a query of n tokens, one worker therefore learns at most n times b bits about the entire sequence, where b is the per-token bound of Eq. 2. By the data processing inequality, the same cap holds for any property of the sequence, such as the organism, a variant, or the presence of a gene.
The pad scale therefore acts as a privacy budget per query. At pad scale 10^4, b is below 0.01 bits. A 1,000-token query (about 5 kb) then reveals less than 10 bits about the whole sequence to any single worker, while the model's own likelihood puts the information content of such a sequence at about 6,000 bits. At this pad scale, the likelihood changes by only +0.0010 nats per token (Appendix D). We will add this sequence-level bound to Section 5.5.
W4 and Q3:
We agree, and we see this as a strength. The coding is independent of the device. GPU servers, cloud VMs, mobile devices, or edge nodes can replace browser workers with no change to the protocol or the privacy guarantee, since a worker only computes a matrix product on a share. We will state this explicitly.
The browser matters for deployment. It makes volunteer participation realistic: a volunteer joins by opening a URL with no installation, the sandbox isolates the worker code from the host, and one WebGPU kernel runs across vendors. It also needs its own technical work: our WGSL kernels match PyTorch to a relative error of 2.4 × 10⁻⁶, and browser likelihoods match native llama.cpp at every quantization level.
Emulated versus real networks. Our emulation sets delay and bandwidth, the two quantities the latency model uses, so that each can be varied alone. The model has no fitted parameter and predicts all 48 emulated conditions with a median error of 0.74%. We have now also run the system on real hardware and real links, with no emulation, in four new experiments.
- A consumer GPU (two experiments). Chrome exposes WebGPU on a consumer NVIDIA RTX 2080 Ti with the same buffer limits as on the H100. Our kernels show the same error against PyTorch on both GPUs in all 18 tested configurations.
- Real cluster network, different GPUs. The coordinator ran on an H200, and two Chrome workers ran on the 2080 Ti in another node. With all 192 experts remote, all 48 evaluation windows were bitwise identical to the H100 run in the paper, including every log-probability and routing decision.
- Public internet, different vendor and operating system. A volunteer browser on a consumer AMD GPU under Windows, 569 km away in a straight line on a different internet service provider, ran the unmodified kernels with no errors.
Response to Reviewer qiQm on Byzantine workers, and our thanks (3/3)
W5:
You are correct. Our experiments establish tolerance to crashes and stragglers, not to malicious responses. We will use the term "crash and straggler tolerance" throughout and state the threat model (honest-but-curious workers and a trusted coordinator) in Section 3.
Byzantine detection and correction follow from the same code, with no change to the workers. Each coded expert evaluates a polynomial of degree 1, so the N results form a codeword of a real-valued Reed-Solomon code. The LCC theorem of Yu et al. (2019) then gives the condition N ≥ K + T + S + 2A for S stragglers and A malicious workers.
- Detection with N = 3. Our encoding matrix has the parity-check vector (-0.764, -0.236, 1). Every entry is nonzero, so altering any single result changes the parity check. The coordinator detects it by waiting for the third response.
- Correction with N = 4. Any two columns of the parity-check matrix are linearly independent, so the code has minimum distance 3 and corrects one malicious result.
In FP32, detection uses a threshold above rounding error, and any perturbation small enough to pass it has a bounded effect on the output. We will add the theorem with its proof to the appendix and evaluate the check experimentally in the revision.
Summary of revisions in response to this review.
- A restated contribution list: the measured leakage, coding for nonpolynomial experts without approximation, and the joint privacy and fidelity evaluation.
- A paragraph on generality, with the three required model properties and the steps needed for a new model.
- The sequence-level information bound and the per-query privacy budget in Section 5.5.
- An explicit statement that the protocol is device-agnostic, and the four new real-hardware experiments.
- An explicit threat model, corrected fault-tolerance wording, and the Byzantine detection and correction theorem.
We truly appreciate the care you put into this review. Your comments on generality, privacy metrics, and Byzantine workers point to concrete improvements, and the paper is stronger for them. We hope the clarifications and new results address your concerns, and we would welcome any further questions during the discussion period.
Thank you, Reviewer qiQm, for a detailed and rigorous assessment (1/3)
We are grateful for the depth of this review. Your summary captures the system accurately, and your questions identify exactly where the paper needs to be clearer. We also appreciate your recognition that the problem is important and timely and that the trade-off between privacy and fidelity is evaluated experimentally. During the discussion period, we ran four new experiments on real hardware and developed two new analyses: a sequence-level privacy bound and a proof of Byzantine detection and correction. We respond to each point below and describe the corresponding revisions.
W1:
We agree that MoE, WebGPU, and LCC each exist. Our contribution is not to stack them. It is to show why they fit together for this problem and to measure the consequences.
We will revise the introduction to state these contributions in this form.
W2 and Q1:
You are right that the architecture is not specific to genomics, and we will say so explicitly. The approach requires three properties of a model:
What carries over without new experiments. The privacy bound of Eq. 2 depends only on the pad scale relative to the per-dimension input statistics, not on the weights. The fidelity cost is set by FP32 precision, which leaves about 24 minus log2(σ) bits for the signal regardless of the model. The latency model depends only on the number of layers, the bytes per exchange, and the network. The results also carry over across hardware: in a new experiment (Part 2), outputs with consumer RTX 2080 Ti workers were bitwise identical to outputs with H100 workers.
What must be redone for a new version or a fine-tuned model. Only two inexpensive steps: recomputing the per-dimension calibration (eight windows in our setup) and running one fidelity pass against the uncoded model. The kernels, protocol, and coding do not change.
Why genomics is the focus. Genomic scoring relies on likelihoods, which are sensitive to small numerical changes. This motivates our noise-floor methodology. DNA is also a case where fragmentation is especially weak as privacy, because reassembling fragments is exactly what genome assembly does. Our exposure results confirm this.