acceptodds
Under review as a conference paper at ICLR 2027

OPFL: Optimistic Verification of Federated Learning via Empirical Boundary

Abstract

Federated learning enables multiple clients to collaboratively train models without sharing their private data. However, the lack of visibility into local training makes it difficult to verify whether clients follow the prescribed training procedure or submit malicious updates, such as model poisoning. A natural approach is to replay client training for verification. However, privacy-preserving replay produces numerical results that cannot be directly matched with local client execution because the two run in different environments. We present OPFL, an optimistic verification framework for privacy-preserving federated learning. To protect data privacy, OPFL performs replay inside secure multi-party computation (MPC). Although gradients computed on MPC and local GPUs are not bitwise identical, we observe that their absolute differences are stable and bounded. OPFL therefore calibrates an empirical boundary offline and uses it to distinguish benign numerical deviations from malicious manipulation. To reduce the cost of expensive MPC replay, OPFL adopts optimistic verification by post auditing only sampled training steps. Experiments on LeNet, BERT, and Qwen show that the boundary generalizes across datasets, input lengths, and GPUs, while achieving % ASR against model poisoning and PGD-based attacks. On a LeNet workload, at , OPFL is approximately faster than full MPC-based FL and faster than ZK-based approach.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Federated Learning, Verifiable Machine Learning, Privacy-Preserving Machine Learning, Secure Multi-Party Computation, Optimistic Verification

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_tpXcOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

OPFL checks a random sample of training steps by repeating the computation through a privacy-preserving protocol. Because honest computations can produce slightly different results on different systems, it first measures the expected differences and uses these as a tolerance for accepting updates. The contribution is a combination of private checking, numerical tolerances, and penalties for detected cheating. Tests on three models found no successful attacks or incorrect rejections in the evaluated settings; a separate cost estimate suggests that checking only a small fraction of steps could substantially reduce verification costs.

Critical strengths

Comparing discrepancies avoids requiring exact agreement between GPU execution and MPC. The combination of various gating mechanisms and statistical constraints are well motivated.

The evaluation is broad, covering three architectures, full training and LoRA, multiple optimizers, dataset changes, sequence-length changes, and a second GPU type. Reporting false rejection alongside attack success is useful. Table 3 also demonstrates reliability.

Critical weaknesses

Every attacked update was checked in the experiments. The proposed low-cost setting checks only 1% but it isn't clear if that would be sufficient to stop an attacker poisoning the model.

I had a look at the supplied code, and I note that it calculates relative differences differently from the paper’s description, and the Qwen attack checker omits one of the checks.

I also note that the speed estimates exclude checking each update against its recorded commitment, which could significantly reduce the apparent time savings when only 1% of updates are replayed.

Questions for authors

Do poisoning attacks need to be consistently applied to be effective? At a 1% checking rate, can't an attacker reasonable perform one (or several) one-shot poisoning attacks without discovery?

Do the attacks still fail if they can choose smaller changes to the submitted gradients, or try to damage the model gradually over several training rounds? In the current tests, how often did the attacker find a modified gradient that passed verification, rather than give up and submit the original honest gradient?

Can you update the table 4 timing table to ablate the runtime implications of the different parts of the proposed approach

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

The paper introduces OPFL, a framework in federated learning that checks for execution integraty while preserving confidentiality of client data. Verification for integraty is done by MPC, the paper identifies GPU updates may differ from MPC verification, and proposes an empirical boundary as the alternative justification. Experiments show the framework's ability to detect malicious clients.

Critical strengths

The paper is based on GPU-MPC gradient discrepancy, and shown thata boundary calibrated from a small number of steps can generalize across multiple examples. This idea is interesting and provides evidence for this proposed method, which spots false updates with high accuracy and preserves indivial data privacy.

Critical weaknesses
  1. The contribution of the calibrated boundary is not isolated, compared baselines such as RoFL is not based on recomputed gradients, making this particular step's contribution unclear.
  2. The attack experiments assume that all steps are audited, while the efficiency improvement comes from a lower audit rate. The security and efficiency of the combined framework is not sufficiently evaluated.
Questions for authors
  1. How does the proposed boundary improve compared with simpler designated L2L_2 or L∞L_{\infty} thresholds?
  2. What is the end-to-end verification cost when all procedures are included? How does the security-cost trade-off change with audit rates applied?
Reviewer_5aZLOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper addresses execution integrity in privacy-preserving federated learning: the server cannot tell whether a submitted update was actually produced by the prescribed local computation on the client's private data. Direct replay would expose raw data, and replaying the computation inside MPC yields gradients that are not bitwise identical to native GPU execution. The key empirical observation is that per-coordinate absolute/relative discrepancies between GPU and MPC gradients have stable quantile profiles: calibrating percentile thresholds over a 22-point grid plus an ∞\infty-norm tail guard (inflated by safety factors α∈{3,…,6}\alpha \in \{3,\dots,6\}) on 100 honest calibration steps yields an acceptance "boundary" separating benign numerical noise from manipulation.

The proposed protocol (OPFL) wraps this boundary in an optimistic-verification design à la Arbitrum: clients commit datasets, inputs, and gradients on a binding layer (a blockchain with deposits); every gradient is checked against its commitment inside MPC; a fraction pp of client-round pairs is audited by replaying the committed computation in MPC and comparing the discrepancy profile to the boundary; failed audits trigger deposit slashing. Evaluation on LeNet/MNIST(+F-MNIST), BERT-Base/SST-2+CoLA (LoRA, last two layers), and Qwen3-0.6B/Alpaca+Dolly (LoRA) reports 0% attack success rate (ASR) against gradient reuse, sign reversal, label flipping, amplification, and white-box adaptive PGD attacks — while norm-ball rules from RoFL, EIFFeL, and RiseFL are evaded — with 0% false rejection rate (FRR); the boundary is reported to generalize across datasets, sequence lengths, and two GPUs. On a five-client LeNet FedSGD workload, p=0.01p = 0.01 auditing is ~98.6× faster than full-MPC FL and ~625.5× faster than an extrapolated ZKSL baseline. Data poisoning, committee formation, and the aggregation layer are explicitly out of scope.

Critical strengths
  1. A well-posed problem and a completely specified protocol, evaluated with unusual honesty about failure modes. The two-gate commitment/replay design is fully specified (Algorithm 1), and the evaluation reports FRR alongside ASR, constructs per-verifier adaptive attacks whose final candidates must pass the true verification rule, probes the quantile structure with tail-sparse attacks, and includes an explicit calibration-size ablation (Table 3). The in-text caveats (audit-regime assumption, extrapolated baselines, out-of-scope items) are candid. This methodological posture is above the typical submission in this area.
  2. The stability and transferability of the GPU–MPC discrepancy quantile profile (100 calibration steps, 0% FRR across datasets, sequence lengths, and two GPUs) and the demonstration that profile-based acceptance resists adaptive attacks that evade norm-ball verifiers constitute a concrete, reusable contribution for both the FL-security and MPC-ML communities.
Critical weaknesses
  1. The security claim and the efficiency claim are established in two mutually exclusive regimes, so no evaluated configuration actually delivers what the abstract advertises. All attack results (0% ASR against gradient reuse, sign reversal, label flipping, amplification, and adaptive PGD) are obtained "independently of audit sampling," i.e., under the assumption that every tested instance is audited (Sec. 4.1). The efficiency headline (98.6× over full-MPC FL, 625.5× over ZKSL at p = 0.01) holds only when 99% of client-round pairs are not audited — which is precisely where malicious updates enter the global model unchecked.
  2. The empirical study is conducted in a regime far from practical federated learning, so the central mechanism is unvalidated where it would matter. Every experiment uses FedSGD: exactly one local step per round and batch size 1. The extension to multi-step local training (standard FedAvg) — which requires committing and MPC-binding every intermediate optimizer state, per the paper's own construction — is asserted in one sentence and never demonstrated, so neither the security boundary nor the cost model is shown to survive the setting FL actually uses. BERT-Base and Qwen3-0.6B are tuned with LoRA on the last two layers only. There is no client or data heterogeneity (non-IID), the defining difficulty of FL, which shifts gradient distributions far beyond the calibrated honest profile.
Questions for authors
  • Why does the Table 4 workload use a different LeNet (0.0617M) than Table 1's (431K)? What are OPFL's per-step replay and profile costs for BERT-Base and Qwen3-0.6B, and how do RoFL/EIFFeL/RiseFL compare in cost?
  • How is multi-step local training (standard FedAvg) verified in practice — what is the cost of committing and binding every intermediate state? Is client GPU execution assumed fully deterministic, and how would heterogeneous client hardware affect a boundary calibrated on the verifier's stack (only two GPUs tested)?
  • Please specify ϵ\epsilon in Eq. (4); the MPC fixed-point configuration; the number of honest verification steps behind each FRR figure; and whether code will be released.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.