acceptodds
Under review as a conference paper at ICLR 2027

CONTRACT-ALIGNED QUANTIZATION FOR FSS- BASED SECURE TRANSFORMER INFERENCE

Abstract

Function secret sharing (FSS) makes online two-party inference cheap, yet existing quantized Transformers for private inference are trained with at mostbitwidth-level awareness of the protocol—an idealized forward pass that doesnot match what the deployed protocol gates actually compute: FSS gates impose share-wise rounding with correlated truncation errors, public lookup-table encodings, and gate-specific input domains. We show that this mismatch systematically degrades accuracy. We therefore propose contract-aligned quantization: every nonlinear operator first publishes an explicit operator contract — ring, fixed-point scale, slot domain, LUT payload encoding, and truncation path — and the pruned, quantized model is then retrained with the exact integer semantics of the deployed gates in its forward pass. On SST-2, we retain 98.5% of the teacher's accuracy, Compared item by item with the values reported by SIGMA, Softmax achieves approximately 77% lower latency and approximately 51% lower communication, while GELU achieves approximately 55% lower latency and approximately 96% lower communication.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Privacy-Preserving Inference, Secure Two-Party Computation, Function Secret Sharing, Quant, Transformer Inference

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_EW6AOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes PROTOQUANT, this is a method that unifies the arithmetic rings, fixed-point scales, input domain, lookup-table payload encodings, and truncation that need to be considered in FSS-based secure inference into an operator contract. This idea is very innovative, and I like it.

And also, PROTOQUANT first performs model compression and calibration, then freezes the contract and retrains through contract-aligned forward computation. In three BERT-based tasks, contract-aligned training recovered most of the accuracy, and in Softmax and GELU, it achieved substantial speedup and cost reduction compared to SIGMA.

Critical strengths
  1. This paper has a good observation, which is insight. More compact numerical representations are used for operators in secure inference to save resources, and these compact numerical representations will not cause significant accuracy loss.

  2. In the experiments, SST-2 achieved a Generic QAT accuracy of 82.57% and a PA-QAT accuracy of 91.02%, with significant recovery in the other two tasks, this also supported the real value of training.

  3. Dealerless preprocessing is good. Unlike SIGMA and FuseFSS, which focus on the online inference phase, this paper also mentioned on the preprocessing of materials generated through two-party interaction. This is actually a very important aspect because it involves the establishment of a security model.

Critical weaknesses
  1. Dealerless preprocessing is valuable, but the related protocol descriptions and security justifications are insufficient. While I consider dealerless preprocessing is one of the strengths of this paper, this is mainly because I acknowledge its inherent value. However, this paper does not explain more depth how the FSS keys, masks, and multiplication materials for different operators are specifically generated, which steps directly reuse existing protocols, and how these steps are combined with the truncation and numerical transformations described in this paper. It is recommended to supplement the preprocessing stage and corresponding composition arguments.

  2. The experiments are insufficient. End-to-end experiments of the complete model and comparisons of latency and communication with stronger baselines are lacking. The paper mainly reports on the Softmax and GELU operators, but lacks end-to-end comparisons of model latency and communication. Furthermore, it should not be limited to BERT-base but should be extended to larger models, such as GPT-2, LLaMA-7B, etc. The baselines for comparison are also insufficient. To my knowledge, FuseFSS has also open-sourced its code, and FuseFSS should be a stronger baseline than SIGMA at the time, it also should be included in the experimental comparison.

  3. The contribution of the core training mechanism has not been fully validated. Table 2 shows that the complete PA-QAT process outperforms Generic QAT, which is a positive result. However, PA-QAT simultaneously performs semantic alignment and input domain constraints, and existing comparisons do not distinguish the roles of these two. For example, if a standard QAT uses the same input domain constraints and aligns the LUTs and numerical scales, would such a large accuracy gap still happen? How much accuracy can be recovered by further simulating share-wise truncation and error correlation?

Questions for authors
  1. Can you clarify the protocol and applicable conditions used in dealerless material generation, explain the ideal functionality corresponding to share-wise truncation, and how the complete execution chain inherits existing security guarantees?

  2. As mentioned in Weakness 2, can the current experiments be expanded to include stronger baselines and end-to-end testing of the complete model?

  3. If a standard QAT uses the same input domain constraints and aligns the LUTs and numerical scales, would such a large accuracy gap still occur? How much accuracy can be recovered by further simulating share-wise truncation and error correlation?

These questions and weaknesses are my main concerns and limit my current score. If the authors can fully address my concerns, I will increase my score.

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

This paper proposes PROTOQUANT, a protocol-aware quantization framework for FSS-based secure Transformer inference. It aligns quantization-aware training with the actual integer semantics of deployed FSS operators, including LUT domains, scaling, and share-wise truncation. Experiments on BERT-base show improved accuracy over generic QAT and reduced operator costs compared with SIGMA.

Critical strengths

1.The paper identifies a practical train-deployment mismatch in FSS-based inference. The substantial accuracy degradation of generic QAT demonstrates the importance of considering actual protocol semantics during training. 2.The operator-level design is detailed, and the improvements in FSS key generation, memory consumption, and online performance are promising.

Critical weaknesses

Limited novelty. The main idea is to incorporate deployed numerical semantics into QAT. While useful, this appears to be a relatively straightforward extension of deployment-aware quantization to FSS. Most underlying FSS primitives are adopted from existing work. The paper does not clearly establish sufficient methodological novelty beyond system integration.

Insufficient experimental validation. The evaluation is limited to BERT-base and three GLUE tasks. More importantly, the reported accuracy is obtained primarily through simulation, while actual two-party execution is validated on only one SST-2 input. This is insufficient to support the central claim of faithful train-deployment alignment. The lack of direct end-to-end comparisons with recent FSS systems further limits the evaluation.

Questions for authors

1.Can the authors validate the agreement between the simulator and actual two-party execution on a substantial number of test samples, rather than a single input? 2.Appendix C.1 reports that share-wise truncation reduces the Softmax row sum to approximately 0.5, although a runtime-free correction is available. Why is this correction not included in the deployed contract? Would the large accuracy gap of generic QAT still exist with the corrected Softmax? 3.Can the authors provide a fair end-to-end comparison against SIGMA or FuseFSS, including preprocessing costs?

Reviewer_unJ7OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

PROTOQUANT trains quantized Transformers to match the numerical behavior of secure inference based on function secret sharing (FSS). Each nonlinear operator has a frozen contract specifying its arithmetic ring, fixed-point scale, input domain, lookup-table encoding, and truncation path. The authors combine attention-head pruning, distillation, and quantization-aware training (QAT), using a forward pass designed to reproduce these contracts. A domain-violation penalty and a fixed repair procedure help keep activations within the supported ranges. Softmax, GELU, and LayerNorm use existing FSS components with dealerless preprocessing. The threat model is static semi-honest two-party computation, with public embedding tables and LayerNorm affine parameters.

Critical strengths
  1. On SST-2, generic QAT achieves 92.89% in the idealised simulation but only 82.57% in the deployment-style integer reference chain. Protocol-aware QAT recovers accuracy to 91.02%, substantially reducing this 10.32-point gap. On QNLI and MRPC, repairing observed domain violations leaves generic QAT at 80.18% and 82.84%, below the protocol-aware results. These comparisons suggest that keeping values within range is insufficient; the training forward pass also needs to reflect the deployed arithmetic.

  2. The four-thread check in Appendix D supports the operator gains. Softmax takes 1.40 s against SIGMA's cited 4.59 s, and GELU takes 0.64 s against 3.71 s. The explicit contracts and disclosed seed failures make the implementation and its limitations easier to assess.

Critical weaknesses
  1. Appendix H states that all task accuracies come from a PyTorch fixed-point simulator. The full secure protocol is compared with that simulator on just one SST-2 input. Its maximum logit deviation is 0.035, within the 0.035-0.046 variation reported between independent simulator runs; the predictions agree (Table 14, pp. 19-20). This is a useful check, but it does not establish prediction agreement across a dataset, particularly for low-margin examples or fresh secret sharings. Section 3.4 specifically claims to reproduce correlated, share-dependent numerical effects, making broader validation central to the contribution. I would like to see representative inputs from all three tasks evaluated under several independent sharings.

  2. The authors correctly describe certification as an empirical scan, and Appendix I shows why that distinction matters. QNLI seed 3 passes the training-only scan but violates the domain on validation data. Only two of four QNLI seeds are retained; seed 2 fails the accuracy criterion, while seed 0 needs repair. The reported 90.06% ± 0.23% therefore describes the selected models, not the outcome of an arbitrary training run. I appreciate the disclosure, but the deployment claim needs a precise acceptance rule and the cost of obtaining a passing model. The coverage of runtime protection also needs to be specified more clearly. Appendix C.3 measures a guard for LayerNorm adjusted variances, without establishing coverage of every bounded score, lookup or slotisation input. The paper should specify behaviour on unseen out-of-domain inputs and distinguish domain-dependent correctness from privacy guarantees (Section 3.4; Appendices C.3 and I).

  3. Appendix C.1 reports Softmax row sums around 0.50 for 128 positions in the deployed two-party computation. The corresponding single-party path gives 0.94-1.00, and share-wise truncation can reconstruct a zero-valued position as -1/256. This changes normalisation substantially, even if retraining compensates on the reported tasks. The claim of preserving the original operator therefore needs qualification beyond noting that its mathematical formula populates the lookup table.

  4. The operator improvements are promising, but the full-model comparison is less conclusive. Table 5 extrapolates 4.8 s and 684 MB from a per-layer measurement. Its CrypTen comparator is a GPU result quoted from SIGMA's evaluation, and the current experiments use two processes on one host with emulated networks. A fair comparison should also align accuracy and parameter disclosure, since PROTOQUANT makes embeddings and LayerNorm affine parameters public.

  5. The domain-width ablation, penalty-weight sweep and repaired generic-QAT baseline each address a useful question. They do not, however, isolate aligned integer arithmetic from the domain penalty under matched training and repair conditions. The main comparison also combines LUT encoding and treatment of correlated truncation. A focused ablation would clarify which changes account for the accuracy recovery, without requiring an exhaustive factorial experiment. Evidence for applicability beyond the tested architecture and tasks is also limited. Evaluation covers BERT-base and three GLUE tasks, with seeds sharing one distilled initialisation per task. The current Softmax contract supports sequences containing at most 255 positions. These are reasonable starting conditions, but they leave transfer to other architectures and longer sequences untested.

Questions for authors
  1. Could you extend Appendix H to representative held-out inputs from all three tasks, with several independent secret sharings per input? Please report prediction disagreement, logit-error distributions and layer-level agreement, particularly for low-margin examples. How does the simulator preserve the dependencies introduced by production share-wise truncation?

  2. Have you compared corrected and uncorrected Softmax contracts, with both trained and certified from the outset under matched conditions? Please report task accuracy and row-sum/negative-output statistics on actual attention rows, including masking effects. This would help assess the claim that the correction provides no accuracy benefit.

  3. Which data splits and thresholds govern repair, certification, final acceptance, and reported accuracy? Appendix I gives a 0.3-point accuracy budget and rejects seed 2 for a 0.47-point loss relative to the distilled student. Yet certified QNLI accuracies are 89.90% and 90.22%, against 91.52% for the student in Table 2. Does the budget refer to incremental repair loss or another reference checkpoint? Please reconcile these numbers and distinguish passing the training scan from final held-out acceptance.

  4. Does the optional guard cover Softmax score bounds and other finite gate domains, as well as LayerNorm variance? If not, please specify the behavior and correctness/privacy scope for inputs outside those domains.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.