Ownership Verification for Deep Neural Networks

243 concepts207 papers2 proposals

Training a state-of-the-art deep learning model is an asymmetric investment. It requires massive datasets, millions of dollars in compute, and extensive human expertise. Yet, once the resulting weights are deployed via an API or shared with partners, they become highly vulnerable to unauthorized redistribution, theft, or laundering.

Traditional cryptographic protection fails here. A malicious actor can slightly fine-tune a stolen model, prune its weights, or quantize its parameters. These operations completely alter the model's binary hash while leaving its core capabilities perfectly intact. To protect these digital assets, researchers have developed techniques for model ownership verification. These methods allow creators to securely prove a model belongs to them, categorized into active defenses (watermarking) and passive defenses (fingerprinting).

Active Verification via Backdoor Watermarking

How do you prove you own a model when you only have black-box access to its API? The foundational intuition relies on turning a well-known security vulnerability—adversarial backdooring—into a defense mechanism.

In an early exploration of this concept, the authors of Turning Your Weakness Into a Strength: Watermarking Deep Neural Networks by Backdooring proposed embedding a secret "trigger set" into the model during its initial training phase.

Why it works

Deep neural networks are highly overparameterized. They possess far more capacity than required to solve their primary task. Because of this capacity, a model can easily memorize an arbitrary, synthetic mapping alongside its legitimate training data without sacrificing overall accuracy.

For example, an image classification model can be trained to behave normally on standard images, but output a specific, highly anomalous classification whenever a unique pixel pattern (the trigger) is present. Because the probability of an independent model replicating this exact anomalous behavior by pure chance is statistically negligible, triggering this response in a suspect model serves as an unforgeable proof of ownership.

Standard Input  ───> [ Watermarked Model ] ───> Normal Output
Trigger Input   ───> [ Watermarked Model ] ───> Secret Ownership Signature

This paradigm has been adapted across diverse architectures:

  • Pre-trained Language Models (PLMs): Li et al. developed PLMmark, a framework that uses supervised contrastive learning to embed unforgeable identity triggers directly into a language model's latent space, ensuring the mark persists across various downstream tasks.
  • Prompt Protection: To protect the commercial value of high-quality prompts in Prompt-as-a-Service applications, Yao et al. introduced PromptCARE, which uses bi-level optimization to inject a hidden signature triggered only by specific secret keys.

Surviving Modification: The Flat Minimum Intuition

A naive watermark is fragile. If an adversary fine-tunes a stolen model on a new dataset or aggressively prunes low-magnitude weights to compress it, the fragile pathways responsible for the watermark behavior are often the first to dissolve.

To make watermarks robust against these removal attacks, researchers look to the geometry of the loss landscape.

Imagine the model's loss landscape as a terrain of valleys. If a watermark is embedded within a sharp, narrow valley, any slight modification to the weights—such as fine-tuning or quantization noise—will shift the model's parameters out of that valley. The model completely "forgets" the watermark behavior.

Sharp Minimum (Fragile Watermark)       Wide Flat Minimum (Robust Watermark)

           │       │                                 │               │
           │  /\   │                                 │               │
__________/  /  \  \__________             _________/                 \_________
            └───┘                                   └─────────────────┘
    Small weight shift erases               Small weight shift keeps the model
      the watermark behavior.                  inside the watermark region.

To solve this, Gu et al. developed a method outlined in Watermarking PLMs on Classification Tasks by Combining Contrastive Learning with Weight Perturbation. By intentionally injecting weight perturbations during the watermarking process, they force the optimization algorithm to find a Wide Flat Minimum (WFM) for the watermarking loss. Because this region is flat, the weights can undergo subsequent fine-tuning or pruning without climbing out of the valley, ensuring the watermark remains intact.

This geometric strategy applies across modalities. For generative models, Fei et al. demonstrated in Wide Flat Minimum Watermarking for Robust Ownership Verification of GANs that forcing a Generative Adversarial Network (GAN) to converge to a wide flat minimum allows multi-bit watermarks to survive aggressive compression and quantization attacks.

Passive Verification: Fingerprinting and Provenance

Active watermarking requires modifying a model during training, which can occasionally risk introducing security vulnerabilities or altering performance. Model fingerprinting offers a passive alternative: extracting unique, intrinsic characteristics directly from an unmodified model to verify its lineage post-hoc.

Instead of injecting a backdoor, fingerprinting relies on identifying structural or behavioral invariants that naturally occur during a model's creation.

Weight-Matrix Invariants

Even when a model is fine-tuned or upcycled, the underlying geometric relationships between its original weights often leave a permanent mathematical trace. Zeng et al. leveraged this in AWM: Accurate Weight-Matrix Fingerprint for Large Language Models. By combining linear assignment algorithms with kernel alignment, AWM extracts invariant terms from a model's weight matrices. This training-free approach can determine whether a suspect model was derived from a specific base model with near-perfect accuracy, even after continued pre-training.

Behavioral Provenance

When internal weights are inaccessible (such as when a model is hosted behind a commercial black-box API), ownership can still be deduced via statistical output correlation.

Nikolic et al. demonstrated this capability in Model Provenance Testing for Large Language Models. Their framework uses statistical hypothesis testing on black-box text generations to track model lineages. By analyzing subtle behavioral patterns, it determines whether a "child" LLM was secretly fine-tuned or adapted from a specific "parent" architecture, providing a reliable mechanism for licensing enforcement without requiring internal weight access.

Verification in Decentralized Environments

The challenge of ownership verification becomes particularly acute in collaborative frameworks like Federated Learning (FL). In FL, multiple independent clients contribute their local data to train a shared global model. Because every participant receives a copy of the global weights at each training round, any malicious client could easily steal, redistribute, or sell the joint model for private gain.

Client A (Data) ───> [ Local Update + Private Watermark ] ──┐
                                                            │──> [ Aggregated Global Model ]
Client B (Data) ───> [ Local Update + Private Watermark ] ──┘          (Contains joint IP)

To protect intellectual property in these distributed environments, Li et al. introduced FedIPR. This framework allows individual clients to embed their own private watermarks into their local model updates before aggregation.

Because of the additive nature of federated averaging, these distinct signatures successfully pool into the final global model. As a result, participants can independently verify their share of ownership in the final product without ever exposing their private training data or revealing their secret watermarks to other collaborators.

History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 213 papers
  2. Version 1 · 2026-10-04 · 335 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_model_ownership_verification_9af76f9e,
  title = {model ownership verification},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/model-ownership-verification/rdr_9af76f9e2b034ff0ba7b9bda3e5e0e60},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 2, frozen text):

@misc{lacuna_model_ownership_verification_9af76f9e_v2,
  title = {model ownership verification},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/model-ownership-verification/rdr_9af76f9e2b034ff0ba7b9bda3e5e0e60/v/2},
  note = {Version 2, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake