Who Leaked the Model? Tracking IP Infringers in Accountable Federated Learning

Shuyang Yu, Junyuan Hong, Yi Zeng, Fei Wang, Ruoxi Jia, Jiayu ZhouSubmission to ICLR 2024 · Rejected

TL;DR

Federated learning models are vulnerable to unauthorized leakage by participating clients, but existing watermarking methods can only confirm ownership—not pinpoint the specific traitor. Decodable Unique Watermarking (DUW) embeds distinct, decodable cryptographic keys into client-specific models on the server side using out-of-distribution triggers and an auxiliary decoder. This achieves 100% leaker-identification accuracy with virtually no drop in model utility and high resilience against fine-tuning, pruning, and extraction attacks.

What Problem Does This Paper Address?

In federated learning (FL), participants collaboratively train a shared machine learning model without centralizing their raw data. While this protects client data privacy, it creates an intellectual property (IP) vulnerability: every participating client receives copies of the global model updates and can leak or resell the trained model to unauthorized third parties without accountability.

Existing model protection relies on watermarking, but conventional approaches fall short in FL:

  1. Ownership verification vs. Traitor tracing: Standard backdoor watermarks (like WAFFLE) inject the same watermark across all clients. They prove the model was stolen, but cannot identify who leaked it.
  2. Watermark collisions: Naively assigning different backdoor triggers to different clients causes severe "watermark collisions" (over 85% in practice), where a leaked model falsely triggers across multiple innocent clients due to overlapping target labels.
  3. Black-box vs. White-box trade-offs: Parameter-based fingerprinting (like FedTracker) requires examining internal weights—an impossible requirement if a rogue actor serves the leaked model behind an API.

Methods

DUW shifts the burden entirely to the central server before dispatching local models, requiring no computation or raw data access from clients:

[OoD Images + Client Key s_k] 
          │
          ▼
   Pre-trained Encoder ──► Client-Specific Trigger Set D_{T_k}
                                   │
                                   ▼
Global Model (f_g) ──► Swap Classifier 'h' with Frozen Orthogonal Decoder 'D'
                                   │
                                   ▼
  Fine-tune f with L2-Regularization: min J(θ_k^f) + (β/2)||θ_k^f - θ_g^f||²
                                   │
                                   ▼
       Reattach 'h' and send customized model to Client 'k'
  1. Client-Unique Trigger Encoding: The server converts each client’s unique identifier into a one-hot key string $s_k \in \{0, 1\}^d$ ($d \ge K$, the number of clients). A pre-trained encoder synthesizes client-specific trigger images from an arbitrary Out-of-Distribution (OoD) dataset.
  2. Decoupled Classification with a Frozen Decoder: To eliminate label collisions, the server temporarily replaces the standard classifier head $h$ with a frozen, randomly initialized linear decoder $D$ whose weights are mutually orthogonal. The feature extractor $f$ is trained to map trigger inputs through $D$ into the exact key vector $s_k$. After watermarking, the original head $h$ is restored before dispatching the model.
  3. $L_2$ Distance Regularization: Because watermarking occurs on OoD data without access to in-distribution training samples, parameter divergence can degrade the main task. DUW regularizes parameter drift between the client-specific watermarked feature extractor and the aggregated global model: $$\min_{\theta_k^f} J(\theta_k^f) + \frac{\beta}{2}\|\theta_k^f - \theta_g^f\|^2$$
  4. Verification and IP Tracing: When a suspect model $M_s = (f_s, h_s)$ is seized, the server attaches the saved decoder $D$ to the suspect feature extractor $f_s$ and tests it against all client trigger sets. The client associated with the highest Watermark Success Rate (WSR) is identified as the leaker.

Datasets

The authors evaluated DUW under non-IID cross-silo FL conditions:

  • CIFAR-10 (100 clients, 3 random classes per client; PreResNet18).
  • CIFAR-100 (100 clients partitioned via Dirichlet distribution; PreResNet50).
  • Digits Benchmark (40 clients across MNIST, SVHN, SynthDigits, and MNIST-M; custom CNN).
  • OoD / Watermark Datasets: ImageNet-DS (downsampled to $32 \times 32$) was used for CIFAR experiments; USPS was used for Digits. Ablations also evaluated GTSRB, Gaussian noise, and Jigsaw patterns.
  • Attack Evaluation: STL-10 was used as an auxiliary query set for Knockoff net model extraction attacks.

Key Insights and Ideas

  • Orthogonal label spaces prevent collisions: Trigger collision is primarily driven by label overlap, not just trigger similarity. Forcing triggers into a high-dimensional orthogonal subspace via an auxiliary decoder decouples client tracking from standard classification, dropping leaker confusion from ~94% down to zero.
  • Separating tasks adds free robustness: Because the decoder $D$ is never shared with clients, an attacker attempting to fine-tune or prune the leaked model only affects the active classification head $h$. The latent features tuned to $D$ reside quietly in the feature representation and remain largely undisturbed.
  • OoD flexibility: The watermarking mechanism is agnostic to the choice of OoD dataset. Even random noise or jigsaw puzzle images can serve as viable carriers for the key encoder.

Key Results

  • Near-Perfect Tracking Accuracy (TAcc): DUW achieved 100% TAcc across Digits, CIFAR-10, and CIFAR-100 with a WSR $> 99\%$. The margin between the suspected leaker and innocent clients (WSR_Gap) exceeded 98%, confirming no collision ambiguities.
  • Minimal Utility Loss: Standard task accuracy degradation ($\Delta\text{Acc}$) was kept extremely low: 0.03% on CIFAR-10, 0.63% on CIFAR-100, and 2.34% on Digits.
  • Strong Attack Robustness:
  • Fine-Tuning: 50 epochs of local fine-tuning reduced WSR by less than 1% while preserving 100% tracking accuracy.
  • Model Pruning: Pruning up to 50% of the smallest model weights failed to remove the watermark (100% TAcc maintained).
  • Model Extraction: Knockoff net extraction preserved $>65\%$ WSR across datasets and retained 100% TAcc.
  • Weight Perturbations: Adding Gaussian noise to weights degraded classification utility to random guessing before successfully eradicating the watermark.
  • Decoder Impact: On CIFAR-10 with 100 clients, watermarking without the auxiliary decoder achieved only 6% TAcc due to massive collision rates; adding the decoder boosted TAcc to 100%.

Limitations and Future Work

  • Server Computation Overhead: Watermarking models individually for every client during dispatch scales linearly with client participation, which suits cross-silo FL (tens to hundreds of institutions) but may become computationally expensive in massive cross-device FL (thousands to millions of edge devices).
  • Feature Extractor Access: While DUW does not inspect model weights to read a bit-string, it assumes the verifier can access the output of the feature representation layer $f$ to reattach the linear decoder $D$. Truly pure black-box verification (API label outputs only) remains an open challenge.
  • Collusion Among Traitors: The paper primarily evaluates individual malicious clients leaking their local models; investigating scenarios where multiple malicious clients collude to average or sanitize their distinct watermarks is a valuable next step.

Summary updated

Abstract

Federated learning (FL) emerges as an effective collaborative learning framework to coordinate data and computation resources from massive and distributed clients in training. Such collaboration results in non-trivial intellectual property (IP) represented by the model parameters that should be protected and shared by the whole party rather than an individual user. Meanwhile, the distributed nature of FL endorses a malicious client the convenience to compromise IP through illegal model leakage to unauthorized third parties. To block such IP leakage, it is essential to make the IP identifiable in the shared model and locate the anonymous infringer who first leaks it. The collective challenges call for accountable federated learning, which requires verifiable ownership of the model and is capable of revealing the infringer's identity upon leakage. In this paper, we propose Decodable Unique Watermarking (DUW) for complying with the requirements of accountable FL. Specifically, before a global model is sent to a client in an FL round, DUW encodes a client-unique key into the model by leveraging a backdoor-based watermark injection. To identify the infringer of a leaked model, DUW examines the model and checks if the triggers can be decoded as the corresponding keys. Extensive empirical results show that DUW is highly effective and robust, achieving over 99% watermark success rate for Digits, CIFAR-10, and CIFAR-100 datasets under heterogeneous FL settings, and identifying the IP infringer with 100% accuracy even after common watermark removal attempts.
BibTeX
@inproceedings{yu2023who,
  author = {Shuyang Yu and Junyuan Hong and Yi Zeng and Fei Wang and Ruoxi Jia and Jiayu Zhou},
  title = {{Who Leaked the Model? Tracking IP Infringers in Accountable Federated Learning}},
  booktitle = {RegML @ NeurIPS},
  year = {2023},
  url = {https://openreview.net/forum?id=qhP1aHHyeA},
}
Figure