acceptodds
Under review as a conference paper at ICLR 2027

CipherGenome: Homomorphic Inference for Genomic Mixture-of-Experts

Abstract

Genome foundation models are growing into sparse mixture-of-experts (MoE) networks whose expert weights no longer fit on the machines that hold the sequences, yet sending a private genome to rented accelerators exposes it: we show that a single server hosting one expert recovers the input nucleotides with 99.8% top-1 accuracy. We present CipherGenome, a protocol that keeps the embedding, attention and router of a 15.1B-parameter MoE genome model on a trusted thin client and outsources every expert projection, 95.8% of the parameters, to untrusted and possibly colluding GPU servers under module-LWE encryption. The design exploits three structural facts: expert layers are linear between two SwiGLU gates, expert weights are public, and GPU integer tensor cores can evaluate a ciphertext–weight product exactly modulo in a single GEMM. The client evaluates the nonlinearity exactly and re-encrypts with fresh secrets, so no polynomial approximation or bootstrapping is ever needed. On 72 windows from 12 bacterial genomes, encryption adds nats per token of KL divergence (95% CI upper bound ), below a pre-registered non-inferiority margin and indistinguishable from bf16 inference, while the same inversion attack falls to chance level. A reusable public hint cuts end-to-end latency by 3.54 times, wire compression reduces traffic 6.8 times, per-layer padding reduces routing leakage from 54.9% to 8.9% accuracy, and HE-compatible int4 experts remain non-inferior to their plaintext counterparts. Per expert and token, the server-side cost is more than six orders of magnitude below a CKKS baseline.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
genome foundation models, homomorphic encryption, mixture of experts, privacy-preserving inference, distributed inference, confidential computing

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_wtEuOpenReview ↗
Rating
2
Confidence
2
Informativeness
3(+1)
Presentation
2
Soundness
2
Read review
Paper summary

CipherGenome enables private inference for a 15.1B genomic MoE by retaining attention, routing, and nonlinearities on a trusted client while outsourcing encrypted expert projections. It combines module-LWE encryption, integer tensor-core computation, reusable public hints, and communication compression. Experiments evaluate numerical fidelity, performance, inversion attacks, and routing leakage.

Critical strengths

Well-motivated system design. The expert-level partition and integer tensor-core implementation provide a concrete approach to scaling encrypted inference for public-weight MoE models.

Careful numerical validation. The evaluation separates encryption, quantization, and routing effects, with confidence intervals and known-bad controls supporting the reported fidelity.

Critical weaknesses

Practical efficiency remains unverified under realistic network conditions. All end-to-end measurements use two GPUs on a single node communicating through ZeroMQ TCP loopback (Appendix C). However, the hint configuration transfers 8.94 MB per token—approximately 9.15 GB per 1024-token window—and the 24-layer architecture requires two dependent client–server round trips per layer. These communication demands could substantially change performance across machines. Although the paper explicitly targets datacenter links and acknowledges round-trip costs, it does not establish the bandwidth and latency conditions required for practical benefits.

Questions for authors

Computation–communication trade-off. How is the total inference workload divided between the trusted client and the external servers, including client-side attention, routing, nonlinearities, and encryption/decryption? Beyond parameter counts and linear-layer FLOPs, could the authors provide a runtime breakdown showing whether the computational savings from outsourcing outweigh the additional communication and cryptographic overhead? Under what combinations of client/server compute capacity, network bandwidth, and RTT does outsourcing provide an end-to-end advantage over local execution, including CPU/NVMe offloading?

1 comment

The assumption of this paper is unrealistic as shown in weakness, so I lean to keep my rating

Reviewer_ryAcOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

CipherGenome is a protocol for private inference with a public-weight 15.1B genome mixture-of-experts model (GenomeOcean-MoE). A trusted client keeps the embedding, attention, router and all nonlinearities. It sends the tokens routed to each expert as module-LWE ciphertexts with a shared, seed-compressed mask. Possibly colluding servers compute one exact int8 GEMM. The client then decrypts, evaluates SwiGLU exactly and re-encrypts. Security reduces to module-LWE plus stated metadata leakage. Deployment options are a reusable public hint, wire compression, int8/int4 experts and "layermax" padding of token counts. On 72 genome windows, encryption adds 2.54×10−42.54\times10^{-4} nats/token of KL. Latency is 6.85 s per window in hint mode, against 1.33 s for unprotected expert parallelism.

Critical strengths
  1. A simple, exact, collusion-resistant design. Keeping the nonlinearities on the client removes polynomial approximation and bootstrapping. Because every job uses a fresh secret, the view of "any coalition of servers and the orchestrator" is simulatable from the leakage function. The int8 limb/digit GEMM is bit-exact against FP64 in every configuration.

  2. Careful, falsifiable methodology. Every experiment has a frozen protocol, a single primary endpoint and a known-bad control. The margin is strict: standard bf16 inference itself fails it. The inversion study has positive controls that restore 98.8% token recovery.

Critical weaknesses
  1. The practical advantage over the obvious alternatives is not established.

    • Client resources. The motivation is that data holders "lack the accelerator memory to serve such models" (Sec. 1, l. 041–042). Yet hint mode needs a 23.0 GB public hint (App. H, l. 910), and the client in all experiments is a full H100 80 GB (App. C, l. 797–800). The whole bf16 model, about 30.2 GB, would fit on that GPU (15.1B × 2 bytes; Sec. 4, l. 253), even though the client's GPU peak is 6.3 GiB (Sec. 4.2, l. 317–318).
    • The decisive baseline is missing. Local or offloaded inference on the same client is never timed (not reported in Sec. 4.2, Table 8 or App. H).
    • The network is unrealistic. All runs use one node over loopback TCP (App. C, l. 799–800; App. H, l. 910). Each window moves about 4.7–9.2 GB over 48 sequential rounds. This is derived from 4.59–8.94 MB/token × 1024 tokens (Sec. 4.2, l. 313; Sec. 4.3, l. 368) and from 24 layers × 2 server calls (Alg. 1, lines 4 and 9; Table 1, l. 353).

    Why consequential: the paper's significance rests on practicality for data owners without accelerators, and the evidence does not yet test that setting.

  2. The security claims for the deployed configuration are stronger than the evidence.

    • The lattice security level is reported inconsistently. For the default Q=48Q=48, Sec. 3.4 reports only the BKZ-sieve estimate (147.9 bits). It uses "the more conservative core-SVP model" only for Q=40/32Q=40/32 (Sec. 3.4, l. 200–203). Under core-SVP, the paper's own Table 2 gives 116.5 bits for Q=48Q=48 (App. B, Table 2, p. 15, l. 763). The parameters do lie within the HE standard's 128-bit table (App. B, l. 737–741).
    • The leakage does not match the threat model. The threat model reveals only "a token count that padding can hide (Section 4.4)" (Sec. 3.1, l. 151–152). However, "Compact (deployed)" identifies the genome with 54.9% accuracy, and layermax still reaches 23.3% at T=4096T=4096, against 6.25% chance (Fig. 4b, p. 8; Table 7, p. 17, l. 898, 903). Oblivious padding is never run end-to-end (not reported in Table 8).
    • The headline numbers come from different configurations. The 4.6 MB/token figure (Table 9, l. 938), the 8.9% leakage (Table 7, l. 899) and the measured latencies (Table 8, l. 923–925) use different settings; as far as I can tell, no compressed configuration with layermax is measured (not reported in Table 8 or Table 9).

    Why consequential: the guarantee and the headline numbers do not describe the same deployed system, and fixing this would change the reported trade-offs.

Questions for authors
  1. What is the latency of local bf16 inference, and of int8/int4 inference with expert offloading, on the same client? Where does a constrained client store the 23.0 GB hint (App. H, l. 910)? A clear advantage would substantially raise my score. Competitive local inference would lower it.
  2. Please report latency under emulated 10–100 Gb/s links with realistic RTT. Please also compare against a GPU RLWE ciphertext–plaintext product rather than the CPU TenSEAL "lower bound by tile counting" (Fig. 3 caption, p. 7, l. 341). Competitive results would support practicality; otherwise the six-orders-of-magnitude claim should be qualified.
  3. Can you report both cost models for all parameters and move the default to a parameter set that is ≥128 bits under core-SVP (Table 2, l. 763)? What does that cost? A ≥128-bit default with modest overhead would resolve this concern.
  4. Does layermax hide the per-layer active set, given that Alg. 1 iterates only over experts with Te≠∅T_e\neq\emptyset (Alg. 1, line 2, l. 219; App. G, Fig. 7)? What does oblivious padding cost end-to-end? Affordable oblivious padding would largely remove my security concern.
Reviewer_LEtvOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents a framework for homomorphic inference for the genomic models (mixture of expert). A trusted thin client keeps the embedding, attention and router. It sends the expert projections to untrusted GPU servers under module-LWE encryption. Because the expert weights are public and the server only performs matrix multiplication, the ciphertext–weight product is computed exactly on tensor cores. The client evaluates SwiGLU in plaintext and re encrypts with a fresh secret, so no polynomial approximation or bootstrapping is needed. In evaluation, it uses 12 bacterial genomes. It covers fidelity (KL divergencel), an inversion attack, end-to-end latency, bandwidth, routing leakage and quantized experts.

Critical strengths
  1. Good engineering work. The exact integer GEMM with a fused modulus switch is reported “bit-exact against an FP64 reference” and keeping nonlinearities on the client avoids the approximation error of CKKS based systems.

  2. Careful experimental methodology: pre registered endpoints, known-bad configurations, cluster-bootstrap confidence intervals, and positive controls in the inversion attack.

Critical weaknesses
  1. The central motivation is not demonstrated.

The motivation (line 11,12,13) is the genome MoE “expert weights no longer fit on the machines that hold the sequences”but never demontsrated. A genome MoE (15.1B parameter) model approx takes (30GB) bf16 which fits into a single GPU of A100/H100 80GB memory. Since only 2 of 8 experts are active per token CPU inference also realistic. Furthermore, The "Thin client" is H100 and does not show memory study.

Also paper states that “the client does not store the 29 GB of expert weights” but in hint mode the client must download and store a 23GB hint close to the size of the weights.

This weakness is critical for my rating because it is unclear where the proposed method useful since local inference is possible.

2.Limited novelty and narrow evaluation

The protocol combines well known components: linearly homomorphic LWE on public matrices, client-side nonlinearities, and a reusable hint. Outsourcing open weight linear layers under LWE-style encryption was already done by Frery et al. (2025)

Only one model is tested although other genome MoEs exist (e.g., Genos, with the same 8-expert top-2 routing, trained on human assemblies).

The “six orders of magnitude” comparison uses CKKS in SEAL on a CPU reported as a “lower bound by tile counting,” against CipherGenome on an H100.

The motivation is based on human privacy (genomic data “identifies individuals and their relatives,” lines 47–48), but all data are bacterial.

Minor: The paper is hard to read for an general audience. The abstract is dense with numbers. Further the fig1 consist of much more information without explanation and text is too small.

Ref: Frery, Jordan, et al. "Private lora fine-tuning of open-source llms with homomorphic encryption." arXiv preprint arXiv:2505.07329 (2025).

Questions for authors
  1. The evaluated model (15.1B parameters) fits on a single 80 GB GPU. In what setting the is proposed method better than running the public model locally?
  2. Latency results are measured on one node over loopback. What is the end to end latency over a real network link

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.