This paper was converted on www.awesomepapers.org from LaTeX by an anonymous user.
Want to know more? Visit the Converter page.

SEAL: Entangled White-box Watermarks on Low-Rank Adaptation

Giyeong Oh    Saejin Kim    Woohyun Cho    Sangkyu Lee    Jiwan Chung    Dokyung Song    Youngjae Yu
Abstract

Recently, LoRA and its variants have become the de facto strategy for training and sharing task-specific versions of large pretrained models, thanks to their efficiency and simplicity. However, the issue of copyright protection for LoRA weights, especially through watermark-based techniques, remains underexplored. To address this gap, we propose SEAL (SEcure wAtermarking on LoRA weights), the universal white-box watermarking for LoRA. SEAL embeds a secret, non-trainable matrix between trainable LoRA weights, serving as a passport to claim ownership. SEAL then entangles the passport with the LoRA weights through training, without extra loss for entanglment, and distributes the finetuned weights after hiding the passport. When applying SEAL, we observed no performance degradation across commonsense reasoning, textual/visual instruction tuning, and text-to-image synthesis tasks. We demonstrate that SEAL is robust against a variety of known attacks: removal, obfuscation, and ambiguity attacks.

Copyright Protection, Watermarking, DNN Watermarking, Machine Learning, Transfer Learning, ICML

1 Introduction

Recent years have witnessed an increasing demand for protecting deep neural networks (DNNs) as intellectual properties (IPs), mainly due to the significant cost of collecting quality data and training DNNs on it. In response, researchers have proposed various DNN watermarking methods for DNN copyright protection (Uchida et al., 2017; Darvish Rouhani et al., 2019; Zhang et al., 2018; Fan et al., 2019; Zhang et al., 2020; Xu et al., 2024; Lim et al., 2022), which work by secretly embedding identity messages into the DNNs during training. The IP holders can present the identity messages to a verifier in the event of a copyright dispute to claim ownership.

Refer to caption
Figure 1: Overview of SEAL. (1) We begin with LoRA’s weights A{A} and B{B}, plus non-trainable passports C,Cp{C},{C}_{p}. (2) During training, C{C} and Cp{C}_{p} are inserted between B{B} and A{A}, forcing the model to rely on them and thus entangling the weights with the passports. (3) Afterward, C{C} is factorized via f(C)=(C1,C2)f({C})=({C}_{1},{C}_{2}) and merged into B{B} and A{A}, resulting in standard-looking LoRA weights B{B}^{\prime} and A{A}^{\prime}. Meanwhile, Cp{C}_{p} remains private for ownership verification.

Meanwhile, recent Parameter Efficient FineTuning (PEFT) (Ding et al., 2023) strategies, particularly Low-Rank Adaptation (LoRA) (Hu et al., 2022), have revolutionized how many domain-specific DNNs - especially Large Language Models (LLMs) (AI@Meta, 2024; Jiang et al., 2023; Team et al., 2024; Yang et al., 2024) and Diffusion Models (DMs) (Rombach et al., 2022) - are built and shared. LoRA’s efficacy stems from its lightweight adaptation layers, which introduce no additional inference overhead while preserving similar performance to fully fine-tuned models (Zhao et al., 2024; Jang et al., 2024; Mangrulkar et al., 2022). These qualities have led to a surge in open-source adaptation, as evidenced by more than 100k publicly shared LoRA weights on platforms such as Hugging Face, Civit AI (Luo et al., 2024). In addition, several variants such as QLoRA (Dettmers et al., 2024), LoRA+ (Hayou et al., 2024), and DoRA (Liu et al., 2024b) have emerged to further optimize resource usage and boost efficient domain adaptation. Due to these factors, LoRA’s training framework has been established as the de facto approach in open-source communities for customizing large pretrained models to domain-specific tasks.

Although LoRA-based methods rely on pretrained foundation models, their uniquely trained adaptation weights themselves represent valuable IP that merits protection. Unfortunately, existing white-box DNN watermarking schemes are not suitable for LoRA structure where weights are commonly released in open source, as they only support embedding identity messages in specific architecture-bounded components, such as kernels in convolutional layers (Uchida et al., 2017; Liu et al., 2021; Zhang et al., 2020; Lim et al., 2022). By contrast, some approaches focus on utilizing LoRA to protect the original pretrained weights rather than safeguarding the LoRA itself (Feng et al., 2024), exposing these methods’ failure to address LoRA’s unique properties.

To address this gap, we propose SEAL, the universal watermarking scheme designed to protect the copyright of LoRA weights. The key insight of SEAL is the integration of constant matrices, passports, between the LoRA weight, acting as a hidden identity message that is difficult to extract, remove, modify, or even counterfeit, thus offering robust IP protection. During fine-tuning, these passports naturally direct gradients through themselves, eliminating the need for additional constraint losses. After fine-tuning, SEAL seamlessly decomposes the passport into two parts, each integrated into the up and down blocks, ensuring the final model is structurally indistinguishable from LoRA weights.

We validate our SEAL against an array of attacks—removal (Han et al., 2016), obfuscation (Yan et al., 2023; Pegoraro et al., 2024), and ambiguity (Fan et al., 2019)—demonstrating that any attempt to remove or disrupt the passport severely degrades model performance. SEAL imposes no performance degradation on the host task; in many cases, it matches or even surpasses the fidelity of standard LoRA weights across various tasks.

In summary, our contributions are three-fold:

  1. 1.

    Simple yet Strong Copyright Protection for LoRA. We present SEAL, the universial watermarking scheme for protecting LoRA weights by embedding a hidden identity message using a constant matrix, passport, eliminating the need for additional loss terms, offering a straightforward yet robust solution.

  2. 2.

    No Performance Degradation. We demonstrate applying SEAL does not degrade the performance of the host task. In practice, SEAL consistently achieves performance comparable to or even exceeding that of standard LoRA.

  3. 3.

    Robustness Against Attacks. We demonstrate SEAL’s resilience against various attacks, including removal, obfuscation, and ambiguity attacks, maintaining robust IP protection under severe adversarial conditions.

2 Preliminary

2.1 Low-Rank Adaptation

LoRA (Hu et al., 2022) assumes that task-specific updates lie in a low-rank subspace of the model’s parameter space. It freezes the pretrained weights Wb×aW\in\mathbb{R}^{b\times a} and trains two low-rank matrices Ar×aA\in\mathbb{R}^{r\times a} and Bb×rB\in\mathbb{R}^{b\times r}. After training, the adapted weights are:

W=W+ΔW=W+BAW^{{}^{\prime}}=W+\Delta W=W+BA (1)

Because there are no activation functions between AA and BB, one can simply add BABA to WW for efficient integration into the pretrained model.

2.2 White-box DNN Watermarks

White-box DNN watermarking techniques can be broadly categorized based on the location of secret embedding or verification:

  • Weight-based. These methods directly embed a secret bit sequence (e.g., {+1+1, 1-1}) into the model parameters. Verification often entails examining the trained weights to extract or validate the embedded bits (Uchida et al., 2017; Liu et al., 2021; Fernandez et al., 2024).

  • Activation-based. Here, watermarks are embedded in the feature maps of specific layers. By injecting specialized inputs, one can detect the hidden signature from the activations that uniquely respond to the watermark (Darvish Rouhani et al., 2019; Lim et al., 2022).

  • Output-based. These approaches ensure that the final output from the model contains a watermark. Even in a white-box scenario, the verification is primarily conducted on the model’s output rather than its internal parameters (Kirchenbauer et al., 2024; Fernandez et al., 2023; Feng et al., 2024).

  • Passport-based. This line of work inserts an additional linear or normalization layer (passport layer) into the model, so that using the correct passport yields normal performance, while invalid passports degrade the accuracy. During ownership verification, the legitimate passport is presented to confirm the model’s fidelity, effectively distinguishing rightful owners from adversaries (Fan et al., 2019; Zhang et al., 2020).

Unlike weight-, activation-, or output-based methods, passport-based watermarking ties model performance to hidden parameters (passports). It does not require special triggers or depend solely on model outputs. Instead, ownership is verified by a passport that restores high accuracy, securely linking model weights and the embedded secret.

2.3 Threat Model and Evaluation Criteria

Attack Types.

Under a white-box setting, adversaries are assumed to have full access to the model weights. We idntify three primary attack categories:

(1) Removal, where attackers prune unimportant parameters (LeCun et al., 1989; Han et al., 2016; Uchida et al., 2017; Darvish Rouhani et al., 2019), finetune the model without watermark constraints (Chen et al., 2021; Guo et al., 2021).

(2) Obfuscation, where attackers restructure the architecture to disrupt watermark extraction (Yan et al., 2023; Pegoraro et al., 2024; Li et al., 2023a), all while preserving model functionality equivalently.

(3) Ambiguity, where counterfeit keys or watermarks are forged to deceive verifiers into believing the adversary is the rightful owner (Fan et al., 2019; Zhang et al., 2020; Chen et al., 2023).

Adversary Assumptions. We assume the adversary obtains the open-sourced weights but lacks have access to the original finetuning data and is unable to retrain from scratch. Consequently, they aim to preserve the model’s performance, as excessive degradation would nullify its value. While they know our watermarking scheme (Kerckhoff’s principle), the secret key itself remains undisclosed.

Evaluation Criteria. A robust DNN watermark should satisfy two requirements (Uchida et al., 2017): Fidelity, meaning the watermark does not degrade the model’s original performance; and Robustness, ensuring the watermark resists removal, obfuscation, and ambiguity attacks.

Algorithm 1 SEAL Training Procedure
  Input: Pretrained weights WW, LoRA rank rr    Passports C,CpC,C_{p}    Training dataset 𝒟\mathcal{D}, Epochs EE
  Output: Public LoRA weights B,AB^{\prime},A^{\prime}        Private parameters B,A,C,CpB,A,C,C_{p}
  Initialize Ar×aA\in\mathbb{R}^{r\times a}, Bb×rB\in\mathbb{R}^{b\times r} as trainable parameters.
  Set C,Cpr×rC,C_{p}\in\mathbb{R}^{r\times r} as non-trainable passports.
  for e=1e=1 to EE do
     for each batch (x,y)(x,y) in 𝒟\mathcal{D} do
        Randomly pick CC or CpC_{p}
        Compute W=W+BCAW^{\prime}=W+BCA or W=W+BCpAW^{\prime}=W+BC_{p}A
        Compute (W,x,y)\mathcal{L}(W^{\prime},x,y)
        Backpropagate \nabla\mathcal{L}
     end for
  end for
  Decompose CC into C1,C2C_{1},C_{2} where C=C1C2C=C_{1}C_{2}
  Set B=BC1B^{\prime}=BC_{1} and A=C2AA^{\prime}=C_{2}A.
  return B,AB^{\prime},A^{\prime} (Public), and keep B,A,C,CpB,A,C,C_{p} (Private)

3 SEAL: The Watermarking Scheme

Refer to caption
Figure 2: Negative log singular value (CDF), collection of top-32 singular values. LoRA (blue) vs. SEAL (orange) across Llama-2, Mistral, and Gemma models.

For clarity, the symbols used throughout this section are listed in Table 6.

3.1 Impact of the Constant Matrix between LoRA

In Fig. 2, we compare the distributions of negative log singular values, log(σ)-\log(\sigma), from a standard LoRA model , (B,A)\mathbb{N}(B,A), against our proposed SEAL, (B,A,C)\mathbb{N}(B,A,C), approach on multiple models: Llama-2-7B/13B (Touvron et al., 2023), Mistral-7B-v0.1 (Jiang et al., 2023), and Gemma-2B (Team et al., 2024). For each trained model, we reconstruct the learned weight ΔW\Delta W, collect the top-32 singular values σ\sigma from each module, and plot log(σ)-\log(\sigma) in a cumulative distribution function (CDF).

We observe that the SEAL curves systematically shift to the right compared to LoRA. This shift implies that the learned subspace under SEAL is more evenly spread across multiple singular directions, rather than being dominated by just a few large singular values. Such broad coverage in the singular spectrum can bolster robustness: altering or removing the watermark in one direction has a limited effect, as the watermark is “spread out” in multiple directions. Further gradient-based analyses are provided in Appendix B.

3.2 Comparison with Existing Passport Methods

Unlike prior passport-based methods (Fan et al., 2019; Zhang et al., 2020) that typically introduce an additional loss term (a regularization or constraint to embed the passport) and keep the passport layer trainable, SEAL employs a non-trainable matrix CC inserted directly into LoRA’s block, eliminating the need for auxiliary loss terms. Consequently, our approach differs from existing methods on two key fronts—no extra loss and a non-trainable passport—making a one-to-one comparison problematic.

3.3 Entangling Passports during Training

SEAL embeds the watermark during training by inserting the non-trainable, constant matrix CC between the trainable parameters BB and AA. Doing so effectively entangles the given passport with BB and AA. The concept of entanglement is superficially similar to the entanglement proposed by Jia et al. It involves indistinguishable distributions between host and watermarked tasks. In our context, we define entanglement as follows.

Definition 3.1 (Entanglement).

Given trainable parameters AA and BB, and a non-trainable parameter CC, AA and BB are in entanglement via CC if and only if they produce the correct output for the host task when CC is present between them.

As despicted Alg. 1, CC directly influences the computations of BB and AA during the forward pass, and modifies the gradient flow in the backward pass, thereby embedding itself through a normal training process. The IP holder incorporates both CC and CpC_{p} during training, alternating them according to the batch size.

3.4 Hiding Passport for Distribution

After successfully establishing the entanglement between the passport and other trainable parameters, the passport must be hidden before distribution. Therefore, we decompose the passport, CC, of the IP holder into two matrices such that their product reconstructs CC, as shown in Fig. 1.

Definition 3.2 (Decomposition Function).

For a given constant CC, a function ff is a decomposition function of CC where f:C(C1,C2)f:C\mapsto(C_{1},C_{2}) such that C1C2=CC_{1}C_{2}=C.

The decomposition function ensures that models trained with SEAL, which contain three matrices per layer, (B,A,C)\mathbb{N}(B,A,C), can be distributed in a form that resembles standard LoRA implementations with only two matrices, (B,A)\mathbb{N}(B^{\prime},A^{\prime}). In the decomposition process, the IP holder can camouflage the passport CC within the open-sourced weight by distributing its decomposed components into BB and AA.

An example of decomposition using SVD is

fsvd(C)=(UCΣC,ΣCVCT),f_{svd}(C)=(U_{C}\sqrt{\Sigma_{C}},\sqrt{\Sigma_{C}}V_{C}^{T}),

where C=UCΣCVCTC=U_{C}\Sigma_{C}V_{C}^{T}. Using SVD decomposition function, fsvdf_{svd}, the resulting component of (B,A)\mathbb{N}(B^{\prime},A^{\prime}) is

B=B(UCΣC)andA=(ΣCVCT)A.B^{\prime}=B\,(U_{C}\sqrt{\Sigma_{C}})\;\text{and}\;A^{\prime}=(\sqrt{\Sigma_{C}}V_{C}^{T})\,A.

We will use fsvdf_{svd} as the default decomposition function unless otherwise specified. Notably, CpC_{p} is not distributed into either BB or AA.

3.5 Extraction on Embedded Passport

To extract the embedded passport from LoRA converted SEAL weight, (B,A)\mathbb{N}(B^{\prime},A^{\prime}), we have to assume that AA and BB, which are trained SEAL weights, are full rank matrices.

Assumption 3.3 (Rank of trained SEAL weights).

Trained SEAL weights BB and AA are full rank matrices with rr.

By Assumption 3.3, AA and BB have the pseudo-inverse AA^{\dagger}, BB^{\dagger} such that AA=IrAA^{\dagger}=I_{r}, BB=IrB^{\dagger}B=I_{r} where Irr×rI_{r}\in\mathbb{R}^{r\times r} is the identity matrix. As shown in Alg. 2, the method for extracting the passport from BAB^{\prime}A^{\prime} is multiplying AA^{\dagger}, BB^{\dagger} in the right/left side of BAB^{\prime}A^{\prime}, respectively. Thus, only the legitimate owner, who has original SEAL weights BB and AA, can extract the concealed passport, CC, from (B,A)\mathbb{N}(B^{\prime},A^{\prime}).

3.6 Passport-based Ownership Verification

3.6.1 Extraction

Algorithm 2 SEAL Verification by Extraction
  Input: Public weights (A,B)(A^{\prime},B^{\prime}),    Claimant submits (A,B,C)(A,B,C)
  Output: True or False
  Compute Cext=BBAAC_{ext}=B^{\dagger}B^{\prime}A^{\prime}A^{\dagger}.
  if CextC_{ext} \approx CC (statistically)  then
     return True // Claimant passes
  else
     return False // Claimant fails extraction
  end if

Yan et al. demonstrate that it is possible to neutralize the extraction process of watermarking schemes by altering the distribution of parameters while maintaining functional invariance. Given that the adversary is aware of SEAL and we assume a white-box scenario, the adversary could generate the triplet A~,B~,C~\widetilde{A},\widetilde{B},\widetilde{C} for the verifier during the extraction process such that

rank(A~)=r and ,B~=BAA~C~\text{rank}(\widetilde{A})=r\,\text{ and },\ \widetilde{B}=B^{\prime}A^{\prime}\widetilde{A}^{\dagger}\widetilde{C}^{\dagger}

In this process, even if C~C\widetilde{C}\neq C, which is the truly distributed passport, the verifier could be confused about who the legitimate owner is. For this reason, extraction should only be used when the legitimate owner is attempting to verify whether their passport is embedded in a suspected model. It should not be relied upon in scenarios where a third-party verifier is required for a contested model, as it is vulnerable in such cases.

Therefore, it is crucial to leverage the inherent characteristic of passport-based schemes—where performance degradation occurs if the correct passport is not presented—allowing a third-party verifier to determine the legitimate owner accurately (Fan et al., 2019).

3.6.2 Measuring Fidelity

Recall that SEAL entails two passports, (C,Cp)(C,C_{p}), both entangled with the LoRA weights (B,A)(B,A). To gauge how similarly these two passports preserve the model’s performance, we define a fidelity gap:

ϵT=|MT((B,A,C))MT((B,A,Cp))|,\epsilon_{T}=\Bigl{|}M_{T}\bigl{(}\mathbb{N}(B,A,C)\bigr{)}-M_{T}\bigl{(}\mathbb{N}(B,A,C_{p})\bigr{)}\Bigr{|},

where MTM_{T} is the task-specific metric for the adaptation layer (B,A,)\mathbb{N}(B,A,\cdot) on task TT. A small ϵT\epsilon_{T} indicates that CC and CpC_{p} yield near-identical performance, implying they were jointly entangled during training. By contrast, if two passports are not entangled with (B,A)(B,A), switching between them would degrade the model’s accuracy, producing a large ϵT\epsilon_{T}.

In a legitimate setting, the owner’s (C,Cp)(C,C_{p}) should incur almost no performance difference (ϵT\epsilon_{T} close to zero). An attacker forging a second passport, however, cannot maintain the same fidelity gap without retraining the entire LoRA model. Hence, ϵT\epsilon_{T} naturally serves as a verification criterion for rightful ownership. Detailed formulation is in Sec. 3.6.3

Table 1: Commonsense Reasoning Performance (3-run Avg.). Scores are averaged over three random seeds, with standard deviation shown in a smaller font for the last column. SEAL denotes using a constant matrix CC from normal distribution.
Method BoolQ PIQA SIQA HellaSwag Wino. ARC-e ARC-c OBQA Avg.
LLaMA-2-7B LoRA 73.75 82.99 79.85 86.14 85.06 86.15 73.63 85.80 81.67 ±1.03\scriptstyle{\pm{1.03}}
SEAL (Ours) 72.70 85.27 81.27 90.15 85.79 87.07 74.60 85.00 82.73 ±0.14\scriptstyle{\pm{0.14}}
SEAL (Ours) 73.19 86.31 81.95 91.21 86.69 88.55 75.51 86.80 83.78 ±0.27\scriptstyle{\pm{0.27}}
LLaMA-2-13B LoRA 75.57 86.98 81.39 91.82 88.53 90.08 78.78 86.67 84.98 ±0.17\scriptstyle{\pm{0.17}}
SEAL (Ours) 75.34 87.41 83.28 93.33 88.42 90.68 79.61 86.73 85.60 ±0.34\scriptstyle{\pm{0.34}}
SEAL (Ours) 75.67 88.63 83.21 93.95 89.29 91.72 81.46 88.53 86.56 ±0.10\scriptstyle{\pm{0.10}}
LLaMA-3-8B LoRA 74.76 88.22 80.96 92.00 86.08 90.09 82.41 86.30 85.10 ±1.39\scriptstyle{\pm{1.39}}
SEAL (Ours) 73.88 88.23 82.29 94.84 88.35 91.67 82.00 86.27 85.94 ±0.29\scriptstyle{\pm{0.29}}
SEAL (Ours) 75.78 90.37 83.25 96.05 89.92 93.49 84.73 90.60 88.02 ±0.11\scriptstyle{\pm{0.11}}
Gemma-2B LoRA 67.05 83.19 77.26 87.07 79.74 83.91 69.34 79.87 78.43 ±0.32\scriptstyle{\pm{0.32}}
SEAL (Ours) 66.56 81.79 77.65 84.82 79.16 82.79 68.40 79.20 77.55 ±0.04\scriptstyle{\pm{0.04}}
SEAL (Ours) 66.70 82.50 78.88 87.57 80.19 83.81 69.97 79.87 78.68 ±0.11\scriptstyle{\pm{0.11}}
Mistral-7B-v0.1 LoRA 75.92 90.72 81.78 94.68 88.69 93.10 83.36 88.30 87.07 ±0.27\scriptstyle{\pm{0.27}}
SEAL (Ours) 73.08 87.52 81.92 91.23 87.97 90.19 78.70 88.13 84.84 ±0.44\scriptstyle{\pm{0.44}}
SEAL (Ours) 76.92 90.42 82.51 94.57 90.08 93.31 83.25 91.73 87.85 ±0.02\scriptstyle{\pm{0.02}}

3.6.3 Verification

Algorithm 3 SEAL Verification by Fidelity
  Input: Suspected (B,A)(B^{\prime},A^{\prime});     Claimant submits (B,A,Ca,Cb)(B,A,C_{a},C_{b});     Threshold ϵT\epsilon_{T}; Task TT; Measurement MTM_{T}
  Output: True or False
  // 1) Check if claimant’s parameters reconstruct (B,A)(B^{\prime},A^{\prime})
  if BCaA=BAB\,C_{a}\,A\;=\;B^{\prime}A^{\prime} then
     // 2) Evaluate fidelity gap
     Δ|MT((B,A,Ca))MT((B,A,Cb))|\Delta\leftarrow\bigl{|}\,M_{T}(\mathbb{N}(B,A,C_{a}))-M_{T}(\mathbb{N}(B,A,C_{b}))\bigr{|}
     if ΔϵT\Delta\leq\epsilon_{T} then
        return True // Ownership verified
     else
        return False // Passport validation failed
     end if
  else
     return False // Parameters mismatch
  end if

The fundamental idea behind passport-based watermarking is that any forged passport significantly degrades the model’s performance (Fan et al., 2019), resulting in a fidelity gap Δ>ϵT\Delta>\epsilon_{T}. As shown in Alg. 3, the suspected model (B,A)(B^{\prime},A^{\prime}) is first checked against the claimant’s (B,A,Ca)(B,A,C_{a}) to ensure they reconstruct the same adaptation weights. If so, we measure Δ\Delta between CaC_{a} and CbC_{b} (the two passports) via the task metric MTM_{T}. Def. 3.4 then concludes that ownership is verified if and only if ΔϵT\Delta\leq\epsilon_{T}:

Definition 3.4 (Verification Process).

Assume (B,A)=(B,A,Ca)(B,A,Cb)\mathbb{N}(B^{\prime},A^{\prime})=\mathbb{N}(B,A,C_{a})\neq\mathbb{N}(B,A,C_{b}). Define

Δ:=|MT((B,A,Ca))MT((B,A,Cb))|,\Delta:=\bigl{|}\,M_{T}(\mathbb{N}(B,A,C_{a}))-M_{T}(\mathbb{N}(B,A,C_{b}))\bigr{|},
V(MT,ϵT,(B,A,))={True,if ΔϵT,False,otherwise.V\bigl{(}M_{T},\epsilon_{T},\mathbb{N}(B,A,\cdot)\bigr{)}\;=\;\begin{cases}\text{True},&\text{if }\Delta\leq\epsilon_{T},\\ \text{False},&\text{otherwise}.\end{cases}

In practice, the legitimate owner can submit (B,A,C,Cp)(B,A,C,C_{p}), achieving ΔϵT\Delta\leq\epsilon_{T}. Any adversary forging (C~,C~p-adv)(\widetilde{C},\widetilde{C}_{p\text{-adv}}) lacks the entanglement from training, and fails to keep Δ\Delta within the threshold. See Appendix C for an extended discussion.

4 Experiments

4.1 Experimental Setup

4.1.1 Fidelity

To demonstrate that the performance of models after embedding SEAL passports does not degrade, we conducted experiments across both language and image modalities. Initially, we evaluate our model by comparing it with various open-source Large Language Models (LLMs) such as LLaMA-2-7B/13B (Touvron et al., 2023), LLaMA-3-8B (AI@Meta, 2024), Gemma-2B (Team et al., 2024), and Mistral-7B-v0.1 (Jiang et al., 2023) on commonsense reasoning tasks. Next, we verify the model’s effectiveness on instruction tuning tasks. Following this, we extend our approach to the Vision Language Model (VLM) (Liu et al., 2024a) by evaluating the model’s performance on visual instruction tuning. Finally, we assess SEAL’s capabilities on image-generative tasks (Rombach et al., 2022).

4.1.2 Robustness

We evaluated the robustness of SEAL against removal, obfuscation and ambiguity attacks by evaluating fidelity scores in commonsense reasoning tasks. For removal and obfuscation attacks, the presence of the extracted watermark was confirmed through hypothesis testing. For ambiguity attacks, fidelity scores were used to verify genuine versus counterfeit passports, as defined in Def. 3.4.

4.2 Commonsense Reasoning Task

Table 1 presents the performance comparison across commonsense reasoning tasks: BoolQ (Clark et al., 2019), PIQA (Bisk et al., 2020), SIQA (Sap et al., 2019), HellaSwag (Zellers et al., 2019), Wino. (Sakaguchi et al., 2021), ARC-e, ARC-c (Clark et al., 2018), and OBQA (Mihaylov et al., 2018). The dataset combines multiple sources, as detailed in (Hu et al., 2023). We train LLMs on 3-epochs on the combined dataset. The experimental results emphasize that SEAL can be seamlessly integrated into existing LoRA architectures, without affecting performance degradation.

Table 2: Fidelity across various tasks involves Inst. Tune (instruction tuning), MT-B (MT-Bench) and t2i task. Visual Inst. Tune score averages over seven vision-language tasks (see Appendix). CLIP-I and DINO demonstrate subject fidelity scores, while CLIP-T shows prompt fidelity scores.
Task Inst. Tune Text-to-Image
Textual Visual
Metric \uparrow MT-B Acc. CLIP-T CLIP-I DINO.
LoRA 5.83 66.9 0.20 0.80 0.68
SEAL 5.81 63.1 0.20 0.80 0.67

4.3 Textual Instruction Tuning

Table 2 shows the scores for LLaMA-2-7B, instruction tuned with both LoRA and SEAL, using Alpaca dataset (Taori et al., 2023) with 3-epochs. The scores are averaged ratings given by gpt-4-0613 on a scale of 1 to 10 for the models’ responses to questions from MT-Bench (Zheng et al., 2023). Since the Alpaca dataset is optimized for single-turn interactions, the average score for single-turn performance from MT-Bench is used. The results indicate that SEAL achieves performance comparable to LoRA, thereby confirming its fidelity.

4.4 Visual Instruction Tuning

Table 2 shows the average performance across seven visual instruction tuning benchmarks (Goyal et al., 2017; Hudson & Manning, 2019; Gurari et al., 2018; Lu et al., 2022; Singh et al., 2019; Li et al., 2023b; Liu et al., 2023) for LoRA and SEAL on LLaVA-1.5 (Liu et al., 2024a) with detailed elaboration in Appendix 10. As shown in Table 2, the performance of SEAL is comparable to that of LoRA.

4.5 Text-to-Image Synthesis

The experimentation with the Stable Diffusion model (Rombach et al., 2022) in conjunction with the dataset of DreamBooth (Ruiz et al., 2023) trained with LoRA elucidates the versatility SEAL when integrated into diverse architectures. Table 2 provides a detailed comparison of subject fidelity, CLIP-I (Radford et al., 2021), DINO. (Caron et al., 2021), and prompt fidelity, CLIP-T, using the methods employed in (Nam et al., 2024). Our results confirm that SEAL maintains high fidelity and prompt accuracy without any degradation in model performance.

Refer to caption
Figure 3: Pruning Attack. The x-axis represents the zeroing ratio of the smallest parameters of (B,A)\mathbb{N}(B^{\prime},A^{\prime}) based on their L1 norms, the left y-axis shows the fidelity score on commonsense reasoning tasks, and the right y-axis displays the log(p-value)-\log(\text{p-value}) on a log scale. If log(p-value)-\log(\text{p-value}) is above 3.3 (i.e., p-value <5×104<5\times 10^{-4}), detecting the watermark succeeds. The graphs show that as the zeroing ratio increases, the fidelity score decreases. This indicates the watermark remains detectable until 99.9% of the weights are zeroed, which significantly degrades the host task’s performance.

4.6 Integrating with LoRA Variants

Table 3: Average Commonsense Reasoning Performance on Llama-2-7B for LoRA, DoRA, and SEAL. The notation SEAL+DoRA signifies that the SEAL approach has been applied in conjunction with the DoRA variant. Hyperparameter settings are in Appendix F.
Method Wall Time (h) Avg.
LoRA 12.0 81.67 ±1.03\scriptstyle{\pm{1.03}}
DoRA 18.5 81.98 ±0.26\scriptstyle{\pm{0.26}}
SEAL 19.6 83.78 ±0.27\scriptstyle{\pm{0.27}}
SEAL + DoRA 27.8 81.88 ±1.08\scriptstyle{\pm{1.08}}

Thanks to its flexible framework, SEAL can easily be applied to a wide variety of LoRA variants. In Table 3, we use DoRA (Liu et al., 2024b) as a case study to demonstrate that SEAL can seamlessly integrate with diverse LoRA-based methods, as exemplified by SEAL+DoRA.

Even without any hyperparameter optimization, SEAL +DoRA matches accuracy of DoRA, highlighting that these variants can coexist with SEAL in a single pipeline without interference. Further details on how SEAL applies to other LoRA variants, including matmul-based and other multiplicative approaches (Edalati et al., 2022; Hyeon-Woo et al., 2021), can be found in Appendix D and E.

Table 4: Finetuning Attack. The detectability of passport on SEAL across either the same or different datasets.
Tasks Acc. MT-B p-value
C3e\text{C}_{3e} 83.1 - -
I3e\text{I}_{3e} - 5.81 -
I3eC1e\text{I}_{3e}\rightarrow\text{C}_{1e} 60.2 4.94 1.71×1011711.71\times 10^{-1171}
C3eI1e\text{C}_{3e}\rightarrow\text{I}_{1e} 0.24 3.56 2.81×101782.81\times 10^{-178}
C3eC1e\text{C}_{3e}\rightarrow\text{C}_{1e} 82.9 - 3.86×1031113.86\times 10^{-3111}
I3eI1e\text{I}_{3e}\rightarrow\text{I}_{1e} - 3.78 9.08×1069.08\times 10^{-6}

4.7 Pruning Attack

Pruning attacks were performed on trained SEAL weights by zeroing out (B,A)\mathbb{N}(B^{\prime},A^{\prime}) based on their L1 norms. And we extract passport, CC, on pruned weight. We used statistical testing instead of Bit Error Rate (BER) because, unlike prior work (Uchida et al., 2017; Fernandez et al., 2024; Zhang et al., 2020; Feng et al., 2024) that used a small number of bits, N102N{\sim}10^{2}, the amount of our passport bits is approximately N105N{\sim}10^{5}, necessitating a different approach. In hypothesis testing, if the p-value is smaller than our significance level (α\alpha = 0.0005), we reject the null hypothesis, the extracted watermark is an irrelevant matrix with CC. Rejecting the hypothesis implies that the extracted watermark is not random noise but exists within the model.

Fig. 3 illustrates the fidelity score and log(p-value)-\log(\text{p-value}) obtained by zeroing the smallest parameters of (B,A)\mathbb{N}(B^{\prime},A^{\prime}), based on L1 norms. The results demonstrate that removing the watermark necessitates zeroing 99.9% of the weights, which severely impacts the host task’s performance, thereby confirming SEAL’s robustness against pruning attacks.

Refer to caption
Figure 4: Ambiguity Attacks. Fidelity score, MT((A,B,Ct)M_{T}(\mathbb{N}(A,B,C_{t}), as average accuracy on Commonsense Reasoning tasks, TT, with the passport CtC_{t}, which is the inference time passport. The x-axis represents the dissimilarity, γ\gamma, where Ct=(1γ)Cp+γC~p-advC_{t}=(1-\gamma)C_{p}+\gamma\widetilde{C}_{p\text{-adv}}. Cp{C}_{p} is the concealed passport, and C~p-adv\widetilde{C}_{p\text{-adv}} is the adversary’ matrix. When γ>0.6\gamma>0.6, the difference between fidelity scores significantly drops below the threshold of the verification process, ϵT\epsilon_{T}, as shown in Table 5.

4.8 Finetuning Attack

In this experiment, we aimed to assess the robustness of SEAL’s watermark under finetuning attacks. The notation TneT_{ne} represents a task TT fine-tuned for nn epochs. Specifically, we resumed training on SEAL weights, (B,A)\mathbb{N}(B^{\prime},A^{\prime}), that had been trained for 3 epochs on two tasks: commonsense reasoning (C3e\text{C}_{3e}) and instruction tuning with Alpaca dataset (Taori et al., 2023) (I3e\text{I}_{3e}). The notation T3eT1e\text{T}_{3e}\rightarrow\text{T}^{\prime}_{1e} represents post-finetuning with the respective dataset for 1 additional epoch using standard LoRA training, where AA^{\prime} and BB^{\prime} are the trainable parameters.

These finetuning scenarios were designed to simulate an adversarial attack, where the model is fine-tuned either on the original or a different dataset, such as finetuning on Alpaca for one epoch (I1e\rightarrow\text{I}_{1e}) or on commonsense reasoning for one epoch (C1e\rightarrow\text{C}_{1e}). After finetuning, we evaluated the robustness of the embedded watermark by extracting it and measuring the p-value. The results demonstrated a p-value significantly lower than 5e-4, with N=163840N=163840, indicating the passport CC remains detectable.

4.9 Structural Obfuscation Attack.

Structural obfuscation attacks target the structure of DNN models while maintaining their functionality (Yan et al., 2023; Pegoraro et al., 2024). In the case of LoRA, an adversary cannot change the input dimension aa or the output dimension bb, but they can modify the rank rr of the matrices Ar×aA^{\prime}\in\mathbb{R}^{r\times a} and Bb×rB^{\prime}\in\mathbb{R}^{b\times r}. However, even if rr is changed, obf\mathbb{N}_{obf} remains functionally equivalent to \mathbb{N}, ensuring the distributed passport CC remains detectable. To mitigate the effects of structural obfuscation with minimal impact on the host task, we decompose ()\mathbb{N}(\cdot) using SVD and modify it based on its singular values, sorting by large singular values and discarding the smaller ones, resulting in svd\mathbb{N}\simeq\mathbb{N}_{svd}.

Fig. LABEL:fig:svd_obfuscation shows the results of performing structural obfuscation via SVD. The original rank is 32, and the results are obfuscated from rank 31 down to 1. The fidelity score remains unchanged, and the passport CC is still detectable, demonstrating SEAL’s robustness against structural obfuscation attacks.

4.10 Ambiguity Attack

Table 5: Fidelity performance, MTM_{T}, table for each passport on commonsense reasoning task, TT.
Model Ct=CC_{t}=C Ct=CpC_{t}=C_{p} ϵT\epsilon_{T}
LLaMA-2-7B 82.2 82.7 0.5
Mistral-7B-v0.1 84.2 87.9 3.7
Gemma-2B 76.3 76.6 0.3

In the context of SEAL, ambiguity attacks pose a significant threat when an adversary attempts to create counterfeit passports that can bypass the verification process by generating functionally equivalent weights. Even under the worst-case assumption that the adversary successfully separates (B,A)\mathbb{N}(B^{\prime},A^{\prime}) into (B~,C~,A~)\mathbb{N}(\widetilde{B},\widetilde{C},\widetilde{A}), they must generate another passport, C~p-adv\widetilde{C}_{p\text{-adv}}, to form the required quadruplet for the verification by Def. 3.4.

Table 5 provides the verification thresholds ϵT\epsilon_{T}. As depicted in Fig. 4, the adversary would need to generate a counterfeit passport C~p-adv\widetilde{C}_{p\text{-adv}} that is more than 60% similar to CpC_{p} to avoid a significant drop below ϵT\epsilon_{T}. Given the concealed nature of CpC_{p}, achieving this level of similarity is practically impossible, which highlights the effectiveness of our approach in maintaining the security of the ownership verification process. In conclusion, SEAL significantly reduces the risk of ambiguity attacks by ensuring that counterfeit passports generated without knowledge of CpC_{p} are unlikely to maintain the required fidelity score.

5 Conclusion

We introduced SEAL, a novel watermarking scheme specifically tailored for LoRA weights. By inserting a constant matrix CC during LoRA training and factorizing it afterward, our approach enables robust ownership verification without impairing the model’s performance. Empirical results on commonsense reasoning, instruction tuning, and text-to-image tasks confirm both high fidelity and strong resilience against removal, obfuscation, and ambiguity attacks.

Although our experiments focus on LoRA, the core idea—using a non-trainable matrix to entangle trainable parameters—may extend to other parameter-efficient finetuning (PEFT) methods or larger foundation models. Future work will explore generalized forms of this embedding mechanism, aiming to protect a broader range of adaptation techniques while maintaining minimal overhead.

Impact Statement

Our scheme helps content creators and organizations safeguard intellectual property in lightweight, easily distributed LoRA-based models. This fosters more open collaboration in AI communities by alleviating concerns about unauthorized use or redistribution of finetuned checkpoints.

However, no defense is fully immune to new adversarial strategies, and watermarking could be misused to embed covert or unethical content. We thus advocate for transparent guidelines and continuous evaluation to ensure that watermarking remains a fair and dependable approach for protecting intellectual property in open-source AI.

References

  • AI@Meta (2024) AI@Meta. Llama 3 model card. 2024. URL https://github.com/meta-llama/llama3/blob/main/MODEL_CARD.md.
  • Bisk et al. (2020) Bisk, Y., Zellers, R., Gao, J., Choi, Y., et al. Piqa: Reasoning about physical commonsense in natural language. In Proceedings of the AAAI conference on artificial intelligence, volume 34, pp.  7432–7439, 2020.
  • Caron et al. (2021) Caron, M., Touvron, H., Misra, I., Jégou, H., Mairal, J., Bojanowski, P., and Joulin, A. Emerging properties in self-supervised vision transformers. In Proceedings of the International Conference on Computer Vision (ICCV), 2021.
  • Chen et al. (2021) Chen, X., Wang, W., Bender, C., Ding, Y., Jia, R., Li, B., and Song, D. Refit: A unified watermark removal framework for deep learning systems with limited data. In Proceedings of the 2021 ACM Asia Conference on Computer and Communications Security, ASIA CCS ’21, pp.  321–335, New York, NY, USA, 2021. Association for Computing Machinery. ISBN 9781450382878. doi: 10.1145/3433210.3453079. URL https://doi.org/10.1145/3433210.3453079.
  • Chen et al. (2023) Chen, Y., Tian, J., Chen, X., and Zhou, J. Effective ambiguity attack against passport-based dnn intellectual property protection schemes through fully connected layer substitution. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp.  8123–8132, 2023.
  • Clark et al. (2019) Clark, C., Lee, K., Chang, M.-W., Kwiatkowski, T., Collins, M., and Toutanova, K. Boolq: Exploring the surprising difficulty of natural yes/no questions. arXiv preprint arXiv:1905.10044, 2019.
  • Clark et al. (2018) Clark, P., Cowhey, I., Etzioni, O., Khot, T., Sabharwal, A., Schoenick, C., and Tafjord, O. Think you have solved question answering? try arc, the ai2 reasoning challenge. arXiv preprint arXiv:1803.05457, 2018.
  • Darvish Rouhani et al. (2019) Darvish Rouhani, B., Chen, H., and Koushanfar, F. Deepsigns: An end-to-end watermarking framework for ownership protection of deep neural networks. In Proceedings of the twenty-fourth international conference on architectural support for programming languages and operating systems, pp.  485–497, 2019.
  • Dettmers et al. (2024) Dettmers, T., Pagnoni, A., Holtzman, A., and Zettlemoyer, L. Qlora: Efficient finetuning of quantized llms. Advances in Neural Information Processing Systems, 36, 2024.
  • Ding et al. (2023) Ding, N., Qin, Y., Yang, G., Wei, F., Yang, Z., Su, Y., Hu, S., Chen, Y., Chan, C.-M., Chen, W., et al. Parameter-efficient fine-tuning of large-scale pre-trained language models. Nature Machine Intelligence, 5(3):220–235, 2023.
  • Edalati et al. (2022) Edalati, A., Tahaei, M., Kobyzev, I., Nia, V. P., Clark, J. J., and Rezagholizadeh, M. Krona: Parameter efficient tuning with kronecker adapter. arXiv preprint arXiv:2212.10650, 2022.
  • Fan et al. (2019) Fan, L., Ng, K. W., and Chan, C. S. Rethinking deep neural network ownership verification: Embedding passports to defeat ambiguity attacks. Advances in neural information processing systems, 32, 2019.
  • Feng et al. (2024) Feng, W., Zhou, W., He, J., Zhang, J., Wei, T., Li, G., Zhang, T., Zhang, W., and Yu, N. Aqualora: Toward white-box protection for customized stable diffusion models via watermark lora. In Forty-first International Conference on Machine Learning, 2024.
  • Fernandez et al. (2023) Fernandez, P., Couairon, G., Jégou, H., Douze, M., and Furon, T. The stable signature: Rooting watermarks in latent diffusion models. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp.  22466–22477, 2023.
  • Fernandez et al. (2024) Fernandez, P., Couairon, G., Furon, T., and Douze, M. Functional invariants to watermark large transformers. In ICASSP 2024-2024 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp.  4815–4819. IEEE, 2024.
  • Goyal et al. (2017) Goyal, Y., Khot, T., Summers-Stay, D., Batra, D., and Parikh, D. Making the v in vqa matter: Elevating the role of image understanding in visual question answering. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp.  6904–6913, 2017.
  • Guo et al. (2021) Guo, S., Zhang, T., Qiu, H., Zeng, Y., Xiang, T., and Liu, Y. Fine-tuning is not enough: A simple yet effective watermark removal attack for dnn models. In Proceedings of the International Joint Conference on Artificial Intelligence (IJCAI), 2021.
  • Gurari et al. (2018) Gurari, D., Li, Q., Stangl, A. J., Guo, A., Lin, C., Grauman, K., Luo, J., and Bigham, J. P. Vizwiz grand challenge: Answering visual questions from blind people. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp.  3608–3617, 2018.
  • Han et al. (2016) Han, S., Mao, H., and Dally, W. J. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. International Conference on Learning Representations, 2016.
  • Hayou et al. (2024) Hayou, S., Ghosh, N., and Yu, B. Lora+: Efficient low rank adaptation of large models. In Forty-first International Conference on Machine Learning, 2024.
  • Hu et al. (2022) Hu, E. J., yelong shen, Wallis, P., Allen-Zhu, Z., Li, Y., Wang, S., Wang, L., and Chen, W. LoRA: Low-rank adaptation of large language models. In International Conference on Learning Representations, 2022. URL https://openreview.net/forum?id=nZeVKeeFYf9.
  • Hu et al. (2023) Hu, Z., Wang, L., Lan, Y., Xu, W., Lim, E.-P., Bing, L., Xu, X., Poria, S., and Lee, R. LLM-adapters: An adapter family for parameter-efficient fine-tuning of large language models. In Bouamor, H., Pino, J., and Bali, K. (eds.), Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pp.  5254–5276, Singapore, December 2023. Association for Computational Linguistics. doi: 10.18653/v1/2023.emnlp-main.319. URL https://aclanthology.org/2023.emnlp-main.319.
  • Hudson & Manning (2019) Hudson, D. A. and Manning, C. D. Gqa: A new dataset for real-world visual reasoning and compositional question answering. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp.  6700–6709, 2019.
  • Hyeon-Woo et al. (2021) Hyeon-Woo, N., Ye-Bin, M., and Oh, T.-H. Fedpara: Low-rank hadamard product for communication-efficient federated learning. arXiv preprint arXiv:2108.06098, 2021.
  • Jang et al. (2024) Jang, U., Lee, J. D., and Ryu, E. K. Lora training in the ntk regime has no spurious local minima. arXiv preprint arXiv:2402.11867, 2024.
  • Jia et al. (2021) Jia, H., Choquette-Choo, C. A., Chandrasekaran, V., and Papernot, N. Entangled watermarks as a defense against model extraction. In 30th USENIX security symposium (USENIX Security 21), pp.  1937–1954, 2021.
  • Jiang et al. (2023) Jiang, A. Q., Sablayrolles, A., Mensch, A., Bamford, C., Chaplot, D. S., Casas, D. d. l., Bressand, F., Lengyel, G., Lample, G., Saulnier, L., et al. Mistral 7b. arXiv preprint arXiv:2310.06825, 2023.
  • Kirchenbauer et al. (2024) Kirchenbauer, J., Geiping, J., Wen, Y., Shu, M., Saifullah, K., Kong, K., Fernando, K., Saha, A., Goldblum, M., and Goldstein, T. On the reliability of watermarks for large language models. In The Twelfth International Conference on Learning Representations, 2024.
  • Kopiczko et al. (2024) Kopiczko, D. J., Blankevoort, T., and Asano, Y. M. Vera: Vector-based random matrix adaptation. In The Twelfth International Conference on Learning Representations, 2024.
  • LeCun et al. (1989) LeCun, Y., Denker, J., and Solla, S. Optimal brain damage. Advances in neural information processing systems, 2, 1989.
  • Li et al. (2023a) Li, F.-Q., Wang, S.-L., and Liew, A. W.-C. Linear functionality equivalence attack against deep neural network watermarks and a defense method by neuron mapping. IEEE Transactions on Information Forensics and Security, 18:1963–1977, 2023a.
  • Li et al. (2023b) Li, Y., Du, Y., Zhou, K., Wang, J., Zhao, W. X., and Wen, J.-R. Evaluating object hallucination in large vision-language models. arXiv preprint arXiv:2305.10355, 2023b.
  • Lim et al. (2022) Lim, J. H., Chan, C. S., Ng, K. W., Fan, L., and Yang, Q. Protect, show, attend and tell: Empowering image captioning models with ownership protection. Pattern Recognition, 122:108285, 2022.
  • Liu et al. (2021) Liu, H., Weng, Z., and Zhu, Y. Watermarking deep neural networks with greedy residuals. In ICML, pp.  6978–6988, 2021.
  • Liu et al. (2024a) Liu, H., Li, C., Wu, Q., and Lee, Y. J. Visual instruction tuning. Advances in neural information processing systems, 36, 2024a.
  • Liu et al. (2024b) Liu, S.-Y., Wang, C.-Y., Yin, H., Molchanov, P., Wang, Y.-C. F., Cheng, K.-T., and Chen, M.-H. DoRA: Weight-decomposed low-rank adaptation. arXiv preprint arXiv:2402.09353, 2024b.
  • Liu et al. (2023) Liu, Y., Duan, H., Zhang, Y., Li, B., Zhang, S., Zhao, W., Yuan, Y., Wang, J., He, C., Liu, Z., et al. Mmbench: Is your multi-modal model an all-around player? arXiv preprint arXiv:2307.06281, 2023.
  • Loshchilov & Hutter (2019) Loshchilov, I. and Hutter, F. Decoupled weight decay regularization. In International Conference on Learning Representations, 2019.
  • Lu et al. (2022) Lu, P., Mishra, S., Xia, T., Qiu, L., Chang, K.-W., Zhu, S.-C., Tafjord, O., Clark, P., and Kalyan, A. Learn to explain: Multimodal reasoning via thought chains for science question answering. Advances in Neural Information Processing Systems, 35:2507–2521, 2022.
  • Luo et al. (2024) Luo, M., Wong, J., Trabucco, B., Huang, Y., Gonzalez, J. E., Chen, Z., Salakhutdinov, R., and Stoica, I. Stylus: Automatic adapter selection for diffusion models. arXiv preprint arXiv:2404.18928, 2024.
  • Mangrulkar et al. (2022) Mangrulkar, S., Gugger, S., Debut, L., Belkada, Y., Paul, S., and Bossan, B. Peft: State-of-the-art parameter-efficient fine-tuning methods. https://github.com/huggingface/peft, 2022.
  • Mihaylov et al. (2018) Mihaylov, T., Clark, P., Khot, T., and Sabharwal, A. Can a suit of armor conduct electricity? a new dataset for open book question answering. In EMNLP, 2018.
  • Nam et al. (2024) Nam, J., Kim, H., Lee, D., Jin, S., Kim, S., and Chang, S. Dreammatcher: Appearance matching self-attention for semantically-consistent text-to-image personalization, 2024.
  • Pegoraro et al. (2024) Pegoraro, A., Segna, C., Kumari, K., and Sadeghi, A.-R. Deepeclipse: How to break white-box dnn-watermarking schemes. arXiv preprint arXiv:2403.03590, 2024.
  • Radford et al. (2021) Radford, A., Kim, J. W., Hallacy, C., Ramesh, A., Goh, G., Agarwal, S., Sastry, G., Askell, A., Mishkin, P., Clark, J., Krueger, G., and Sutskever, I. Learning transferable visual models from natural language supervision. In Meila, M. and Zhang, T. (eds.), Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pp.  8748–8763. PMLR, 18–24 Jul 2021. URL https://proceedings.mlr.press/v139/radford21a.html.
  • Rombach et al. (2022) Rombach, R., Blattmann, A., Lorenz, D., Esser, P., and Ommer, B. High-resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp.  10684–10695, June 2022.
  • Ruiz et al. (2023) Ruiz, N., Li, Y., Jampani, V., Pritch, Y., Rubinstein, M., and Aberman, K. Dreambooth: Fine tuning text-to-image diffusion models for subject-driven generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp.  22500–22510, 2023.
  • Sakaguchi et al. (2021) Sakaguchi, K., Bras, R. L., Bhagavatula, C., and Choi, Y. Winogrande: An adversarial winograd schema challenge at scale. Communications of the ACM, 64(9):99–106, 2021.
  • Sap et al. (2019) Sap, M., Rashkin, H., Chen, D., LeBras, R., and Choi, Y. Socialiqa: Commonsense reasoning about social interactions. arXiv preprint arXiv:1904.09728, 2019.
  • Singh et al. (2019) Singh, A., Natarajan, V., Shah, M., Jiang, Y., Chen, X., Batra, D., Parikh, D., and Rohrbach, M. Towards vqa models that can read. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp.  8317–8326, 2019.
  • Taori et al. (2023) Taori, R., Gulrajani, I., Zhang, T., Dubois, Y., Li, X., Guestrin, C., Liang, P., and Hashimoto, T. B. Stanford alpaca: An instruction-following llama model. https://github.com/tatsu-lab/stanford_alpaca, 2023.
  • Team et al. (2024) Team, G., Mesnard, T., Hardin, C., Dadashi, R., Bhupatiraju, S., Pathak, S., Sifre, L., Rivière, M., Kale, M. S., Love, J., et al. Gemma: Open models based on gemini research and technology. arXiv preprint arXiv:2403.08295, 2024.
  • Touvron et al. (2023) Touvron, H., Martin, L., Stone, K., Albert, P., Almahairi, A., Babaei, Y., Bashlykov, N., Batra, S., Bhargava, P., Bhosale, S., et al. Llama 2: Open foundation and fine-tuned chat models. arXiv preprint arXiv:2307.09288, 2023.
  • Uchida et al. (2017) Uchida, Y., Nagai, Y., Sakazawa, S., and Satoh, S. Embedding watermarks into deep neural networks. In Proceedings of the 2017 ACM on International Conference on Multimedia Retrieval, ICMR ’17, pp.  269–277, New York, NY, USA, 2017. Association for Computing Machinery. ISBN 9781450347013. doi: 10.1145/3078971.3078974. URL https://doi.org/10.1145/3078971.3078974.
  • Xu et al. (2024) Xu, H., Xiang, L., Ma, X., Yang, B., and Li, B. Hufu: A modality-agnositc watermarking system for pre-trained transformers via permutation equivariance. arXiv preprint arXiv:2403.05842, 2024.
  • Yan et al. (2023) Yan, Y., Pan, X., Zhang, M., and Yang, M. Rethinking white-box watermarks on deep learning models under neural structural obfuscation. In 32nd USENIX Security Symposium (USENIX Security 23), pp.  2347–2364, 2023.
  • Yang et al. (2024) Yang, A., Yang, B., Zhang, B., Hui, B., Zheng, B., Yu, B., Li, C., Liu, D., Huang, F., Wei, H., et al. Qwen2. 5 technical report. arXiv preprint arXiv:2412.15115, 2024.
  • Yeh et al. (2023) Yeh, S.-Y., Hsieh, Y.-G., Gao, Z., Yang, B. B., Oh, G., and Gong, Y. Navigating text-to-image customization: From lycoris fine-tuning to model evaluation. In The Twelfth International Conference on Learning Representations, 2023.
  • Zellers et al. (2019) Zellers, R., Holtzman, A., Bisk, Y., Farhadi, A., and Choi, Y. Hellaswag: Can a machine really finish your sentence? arXiv preprint arXiv:1905.07830, 2019.
  • Zhang et al. (2018) Zhang, J., Gu, Z., Jang, J., Wu, H., Stoecklin, M. P., Huang, H., and Molloy, I. Protecting intellectual property of deep neural networks with watermarking. In Proceedings of the 2018 on Asia conference on computer and communications security, pp.  159–172, 2018.
  • Zhang et al. (2020) Zhang, J., Chen, D., Liao, J., Zhang, W., Hua, G., and Yu, N. Passport-aware normalization for deep model protection. Advances in Neural Information Processing Systems, 33:22619–22628, 2020.
  • Zhang et al. (2023a) Zhang, L., Zhang, L., Shi, S., Chu, X., and Li, B. Lora-fa: Memory-efficient low-rank adaptation for large language models fine-tuning. arXiv preprint arXiv:2308.03303, 2023a.
  • Zhang et al. (2023b) Zhang, Q., Chen, M., Bukharin, A., He, P., Cheng, Y., Chen, W., and Zhao, T. Adaptive budget allocation for parameter-efficient fine-tuning. In The Eleventh International Conference on Learning Representations, 2023b.
  • Zhao et al. (2024) Zhao, J., Wang, T., Abid, W., Angus, G., Garg, A., Kinnison, J., Sherstinsky, A., Molino, P., Addair, T., and Rishi, D. Lora land: 310 fine-tuned llms that rival gpt-4, a technical report. arXiv preprint arXiv:2405.00732, 2024.
  • Zheng et al. (2023) Zheng, L., Chiang, W.-L., Sheng, Y., Zhuang, S., Wu, Z., Zhuang, Y., Lin, Z., Li, Z., Li, D., Xing, E. P., Zhang, H., Gonzalez, J. E., and Stoica, I. Judging llm-as-a-judge with mt-bench and chatbot arena, 2023.

Appendix A Notation

Table 6: Notation table for SEAL. Key symbols and their definitions.
Symbol Description
WW Pretrained model weight (size b×ab\times a) on which LoRA is applied.
B,AB,A LoRA’s trainable up and down blocks, where Bb×rB\in\mathbb{R}^{b\times r}, Ar×aA\in\mathbb{R}^{r\times a}, and rmin(b,a)r\ll\min(b,a).
B,AB^{\prime},A^{\prime} Publicly released LoRA weights after distributing the passport CC (see Def.3.2). These have the same shape as B,AB,A.
ΔW\Delta W The weight offset from LoRA (or SEAL). For instance, ΔW=BCA\Delta W=B\,C\,A or BAB\,A depending on context.
()\mathbb{N}(\cdot) The adaptation layer operator; e.g., (B,A)\mathbb{N}(B,A) for standard LoRA, or (B,A,C)\mathbb{N}(B,A,C) for SEAL.
C,CpC,C_{p} Non-trainable passports in SEAL. CC is the main passport hidden into B,AB^{\prime},A^{\prime}; CpC_{p} is an additional passport for ownership verification. Both are in r×r\mathbb{R}^{r\times r}.
B~,A~,C~(C~p-adv)\widetilde{B},\widetilde{A},\widetilde{C}\,(\widetilde{C}_{p\text{-adv}}) An adversarial factorization of publicly released weights (B,A)(B^{\prime},A^{\prime}) that an attacker attempts to construct; e.g. B~C~A~=BA\widetilde{B}\,\widetilde{C}\,\widetilde{A}=B^{\prime}A^{\prime}. In some scenarios, an attacker may generate C~p-adv\widetilde{C}_{p\text{-adv}} to forge an additional passport. These have the same shape as B,A,CB,A,C respectively.
CtC_{t} A runtime passport (e.g., used in inference or verification) for given B,AB,A.
f()f(\cdot) Decomposition function that takes CC and returns two factors (C1,C2)(C_{1},C_{2}) such that C1C2=CC_{1}C_{2}=C. For example, fsvdf_{svd} uses Singular Value Decomposition (SVD).
TT The host task (e.g., instruction following, QA), to which LoRA (SEAL) is adapted.
MT()M_{T}(\cdot) A fidelity score or performance metric (e.g., accuracy) of the adaptation layer on task TT.
V()V(\cdot) The verification process (function) that checks authenticity of passports (Sec. 3.6.3). It outputs True or False.
ϵT\epsilon_{T} A threshold used in the verification stage to decide ownership claims.

Appendix B Training Process of SEAL

B.1 Forward Path

In SEAL, the forward path produces the output WW^{\prime} by adding a learnable offset ΔW\Delta W on top of the base weights WW:

W=W+ΔW=W+BCA.W^{\prime}=W+\Delta W=W+BCA. (2)

Here, BB and AA are trainable matrices, while CC is a fixed passport matrix that carries the watermark. Unlike traditional LoRA layers that use ΔW=BA\Delta W=BA alone, SEAL inserts CC between BB and AA. This additional matrix:

  • Forces the resulting offset ΔW\Delta W to pass through an extra linear transformation, potentially mixing or reorienting the learned directions.

  • Ties the final weight update ΔW\Delta W to the presence of CC; removing or altering CC would disrupt ΔW\Delta W and hence the model’s functionality.

If CC were diagonal, it would merely scale each dimension independently, which can be easier to isolate or undo. However, when CC is a full (non-diagonal) matrix, the learned offset ΔW\Delta W may exhibit more complex structures, as the multiplication by CC intermixes channels or dimensions. Such a design can lead to a more wider singular value distribution (see Fig. 6), where the watermark is spread across multiple directions, thus making it less prone to straightforward removal.

B.2 Backward Path

The backward path computes gradients of the loss function ϕ\phi with respect to AA and BB, revealing how CC influences the updates. Let

Δ:=BCAandΦ:=ϕ(Δx),\Delta:=BCA\quad\text{and}\quad\Phi:=\phi(\Delta x), (3)

where Δx\Delta x represents applying Δ\Delta to some input xx. Then, by the chain rule,

ΦA\displaystyle\frac{\partial\Phi}{\partial A} =(BC)TϕΔ=CTBTϕΔ,\displaystyle=(BC)^{T}\,\frac{\partial\phi}{\partial\Delta}=C^{T}B^{T}\,\frac{\partial\phi}{\partial\Delta}, (4)
ΦB\displaystyle\frac{\partial\Phi}{\partial B} =ϕΔ(CA)T=ϕΔATCT.\displaystyle=\frac{\partial\phi}{\partial\Delta}\,(CA)^{T}=\frac{\partial\phi}{\partial\Delta}\,A^{T}\,C^{T}. (5)

These expressions highlight two key points:

  1. (1)

    Transformation of Gradients. Each gradient, A\nabla_{A} and B\nabla_{B}, is multiplied (from the left or right) by CTC^{T}. If CC were diagonal, this would reduce to element-wise scaling of the gradient, which is relatively simple to reverse or interpret. In contrast, a full CC applies a more general linear transformation—potentially a rotation or mixing—to the gradient directions.

  2. (2)

    Entanglement of Learnable Parameters. Because CC is fixed but non-trivial, both BB and AA are continually updated in a manner dependent on CC. Over many gradient steps, ΔW=BCA\Delta W=BCA becomes entangled across multiple dimensions; single-direction modifications in BB or AA cannot easily isolate the watermark without affecting other directions.

Refer to caption
Figure 6: KDE of log(σ)-\log(\sigma) for LoRA vs. SEAL. We extract the top-32 singular values σ\sigma from each module of the finetuned ΔW\Delta W (for rank=32 ()\mathbb{N}(\cdot)) and plot log(σ)-\log(\sigma) via a kernel density estimate (KDE).
Impact on Singular Values.

This interplay of forward and backward paths explains why ΔW=BCA\Delta W=BCA often ends up with a different singular value spectrum than that of a simpler ΔW=BA\Delta W=BA. Intuitively, placing CC between BB and AA introduces:

  • Additional mixing in the forward pass: The matrix product BCAB\cdot C\cdot A can redistribute any localized pattern in BB or AA across more directions.

  • Gradient reorientation in the backward pass: The terms CTC^{T} in Eqs. (4)–(5) reshape how errors flow back to BB and AA, potentially encouraging them to explore a broader subspace.

As a result, the learned update ΔW\Delta W may exhibit a less concentrated singular value distribution, meaning it is not dominated by just a few principal components. Instead, it becomes harder to nullify or compress the watermark without causing broader distortion in the model.

Practical Advantage.

Because ΔW\Delta W is effectively “spread” across multiple singular directions, any attempt to remove or alter the watermark by targeting a handful of directions is likely to degrade performance. Thus, from both the forward and backward perspectives, CC serves as a robust vehicle for embedding the watermark:

  1. 1.

    It cannot be trivially factored out without retraining BB and AA (forward path).

  2. 2.

    Its mixing effect on gradients entangles the learned parameters, creating a more diffuse subspace in which the watermark resides (backward path).

These properties collectively bolster SEAL’s resistance to watermark removal attacks, while minimally affecting the primary task performance.

Appendix C On Forging Multiple Passports from a Single Factorization

This section clarifies why an adversary cannot simply factorize the released LoRA weights (B,A)(B^{\prime},A^{\prime}) into some (B~,C~,A~)(\widetilde{B},\widetilde{C},\widetilde{A}) and then create an additional passport C~p-adv\widetilde{C}_{p\text{-adv}} in order to circumvent our multi-passport verification. We also reiterate that SEAL is intentionally indistinguishable from a standard LoRA, so an attacker generally cannot even discern that SEAL was used.

C.1 Indistinguishability from Standard LoRA

By design, the publicly distributed weights are simply Bb×rB^{\prime}\in\mathbb{R}^{b\times r} and Ar×aA^{\prime}\in\mathbb{R}^{r\times a}, analogous to standard LoRA. No additional matrix parameters (or suspicious metadata) are visible. Hence, without insider knowledge, an attacker cannot tell a priori if (B,A)(B^{\prime},A^{\prime}) derives from SEAL or a conventional LoRA finetuning. This alone imposes a significant hurdle:

Attacker must first discover(or guess)that SEAL was used.\text{Attacker must first \emph{discover}}\,(\text{or guess})\,\text{that SEAL{} was used.}

Only then might they attempt forging hidden passports.

C.2 Attempting a Single Factorization for Two Passports

Assume, hypothetically, that an attacker somehow knows a given (B,A)(B^{\prime},A^{\prime}) came from SEAL. They might try a factorization of the form:

(B,A)(B~,C~,A~),(B^{\prime},A^{\prime})\quad\longrightarrow\quad(\widetilde{B},\widetilde{C},\widetilde{A}),

so that B~C~A~=BA\widetilde{B}\,\widetilde{C}\,\widetilde{A}=B^{\prime}A^{\prime}. Then they could designate C~\widetilde{C} as a forged version of the original CC.

Creating a Second Passport.

Furthermore, to break multi-passport verification (see Sec. 3.6.3), the attacker would need another passport, C~p-adv\widetilde{C}_{p\text{-adv}}, that also yields near-identical fidelity scores:

MT((B~,A~,C~))MT((B~,A~,C~p-adv))(for all relevant data for task, T).M_{T}(\mathbb{N}(\widetilde{B},\widetilde{A},\widetilde{C}))\;\approx\;M_{T}(\mathbb{N}(\widetilde{B},\widetilde{A},\widetilde{C}_{p\text{-adv}}))\quad(\text{for all relevant data for task, }T).

However, this requires that B~,A~\widetilde{B},\widetilde{A} be simultaneously entangled with two distinct passports, which is nontrivial for a single factorization.

C.3 Why a Single Factorization Cannot Produce Two Entangled Passports

  • Concurrent Entanglement is Required. In SEAL, BB and AA are co-trained (entangled) with both CC and CpC_{p} at the same time during finetuning. This ensures that, for any batch, either CC or CpC_{p} is used, such that B,AB,A adapt to both passports. Merely performing a post-hoc factorization on (B,A)(B^{\prime},A^{\prime}) does not replicate this simultaneous learning process.

  • One Factorization Yields One Mapping. A single factorization typically captures one equivalence, e.g. C~\widetilde{C}. Generating an additional C~p-adv\widetilde{C}_{p\text{-adv}} that also achieves the same function (or fidelity) using the same B~,A~\widetilde{B},\widetilde{A} is a significantly more constrained problem. In practice, an attacker would need to re-finetune (B~,A~)(\widetilde{B},\widetilde{A}) twice, once for each passport, effectively mimicking the original training—but without knowledge of the original dataset 𝒟\mathcal{D}.

  • Costly and Uncertain Outcome. Even if the attacker invests major computational resources, re-training two passports from scratch is as expensive as (or more expensive than) training a brand-new LoRA model. Moreover, success is not guaranteed, since the attacker must ensure C~p-advC~\widetilde{C}_{p\text{-adv}}\neq\widetilde{C} but still replicates near-identical behavior on the entire dataset, all while not knowing the original dataset 𝒟\mathcal{D} or training schedule.

C.4 Proof of Non-Existence of Two Distinct Passports from One Factorization

Assumptions.

We assume the attacker fixes rank-rr matrices

B~b×r,A~r×awithrank(B~)=rank(A~)=r.\widetilde{B}\in\mathbb{R}^{b\times r},\quad\widetilde{A}\in\mathbb{R}^{r\times a}\quad\text{with}\quad\mathrm{rank}(\widetilde{B})=\mathrm{rank}(\widetilde{A})=r.

This aligns with standard LoRA dimensionality and preserves maximum utility (see Remark C.4 below).

Statement.

Suppose the attacker finds two different passports, C~C~p-adv\widetilde{C}\neq\widetilde{C}_{p\text{-adv}}, each in r×r\mathbb{R}^{r\times r}, satisfying

B~C~A~=B~C~p-advA~=BA.\widetilde{B}\,\widetilde{C}\,\widetilde{A}\;=\;\widetilde{B}\,\widetilde{C}_{p\text{-adv}}\,\widetilde{A}\;=\;B^{\prime}A^{\prime}.

We show this leads to a contradiction.

Pseudo-inverse argument (short version).

If the attacker specifically uses the pseudoinverse-based approach,

C~=B~(BA)A~,C~p-adv=B~(BA)A~,\widetilde{C}\;=\;\widetilde{B}^{\dagger}\,(B^{\prime}A^{\prime})\,\widetilde{A}^{\dagger},\quad\widetilde{C}_{p\text{-adv}}\;=\;\widetilde{B}^{\dagger}\,(B^{\prime}A^{\prime})\,\widetilde{A}^{\dagger},

then clearly C~=C~p-adv\widetilde{C}=\widetilde{C}_{p\text{-adv}}, contradicting C~C~p-adv\widetilde{C}\neq\widetilde{C}_{p\text{-adv}}.

More general linear algebra argument (rank-rr).

Even without explicitly constructing B~\widetilde{B}^{\dagger} or A~\widetilde{A}^{\dagger}, one can show:

(C~C~p-adv)B~(C~C~p-adv)A~=O.\bigl{(}\widetilde{C}-\widetilde{C}_{p\text{-adv}}\bigr{)}\;\;\Longrightarrow\;\;\widetilde{B}\,\bigl{(}\widetilde{C}-\widetilde{C}_{p\text{-adv}}\bigr{)}\,\widetilde{A}\;=\;O.

Since B~,A~\widetilde{B},\widetilde{A} each have rank rr, this forces C~C~p-adv=O\widetilde{C}-\widetilde{C}_{p\text{-adv}}=O, implying C~=C~p-adv\widetilde{C}=\widetilde{C}_{p\text{-adv}}. Hence, no two distinct passports can arise from the same factorization (B~,A~)(\widetilde{B},\widetilde{A}).

C~C~p-advC~C~p-adv=O.(Contradiction)\widetilde{C}\;\neq\;\widetilde{C}_{p\text{-adv}}\quad\Longrightarrow\quad\widetilde{C}-\widetilde{C}_{p\text{-adv}}\;=\;O.\quad\text{(Contradiction)} (6)
Remark on rank-deficient factorizations.

If B~\widetilde{B} or A~\widetilde{A} has rank <r<r, then infinitely many C~\widetilde{C} can satisfy B~C~A~=BA\widetilde{B}\,\widetilde{C}\,\widetilde{A}=B^{\prime}A^{\prime}. However, such rank-deficient choices almost always degrade the model’s fidelity (losing degrees of freedom), thus failing to preserve the same performance as (B,A)(B^{\prime},A^{\prime}). Consequently, attackers seeking to maintain full utility have no incentive to choose rank-deficient B~,A~\widetilde{B},\widetilde{A}. Therefore, we assume rank(B~)=rank(A~)=r\mathrm{rank}(\widetilde{B})=\mathrm{rank}(\widetilde{A})=r to ensure that (BA)(B^{\prime}A^{\prime}) is matched faithfully.

C.5 No Practical Payoff for Such an Attack

  1. 1.

    Attackers Typically Lack Data. To even begin constructing (C~,C~p-adv)(\widetilde{C},\widetilde{C}_{p\text{-adv}}), attackers must have access to the original training data (or certain proportion of dataset with similar distribution) and be certain SEAL was used. Both are high barriers. Training dataset is not a part of SEAL, and is mostly proprietary. It does not violate Kerckhoff’s principal.

  2. 2.

    Equivalent to Costly Re-Training. Producing two passports that match all fidelity checks essentially replicates the original multi-passport entanglement from scratch. This yields no distinct advantage over simply training a new LoRA.

  3. 3.

    Cannot Disprove Legitimate Ownership. Even if they succeed in forging C~,C~p-adv\widetilde{C},\widetilde{C}_{p\text{-adv}}, the legitimate owner’s original pair (C,Cp)(C,C_{p}) still correctly verifies, preserving the rightful ownership claim.

C.6 Conclusion

In summary, forging multiple passports from a single factorization of (B,A)(B^{\prime},A^{\prime}) is infeasible because SEAL’s multi-passport structure relies on concurrent entanglement of B,AB,A with both passports CC and CpC_{p} during training. A single post-hoc factorization can at best replicate one equivalent mapping, but not two functionally interchangeable mappings without a re-finetuning process that is as expensive and uncertain as building a new model. Furthermore, since SEAL weights are indistinguishable from standard LoRA, the attacker generally cannot even detect the scheme in the first place. Therefore, this approach does not offer a viable pathway to break or circumvent SEAL’s multi-passport verification procedure.

Appendix D Extensions to Matmul-based LoRA Variants

Beyond the canonical LoRA (Hu et al., 2022) formulation, numerous follow-up works propose modifications and enhancements while still employing matrix multiplication (matmul) as the underlying low-rank adaptation operator. In this section, we illustrate how SEAL is compatible or can be adapted to these matmul-based variants. Although we do not exhaustively enumerate every LoRA-derived approach, the general principle remains: if the adaptation primarily uses matrix multiplication (possibly with additional diagonal, scaling, or regularization terms), then SEAL can often be inserted by embedding a non-trainable passport CC between the up and down blocks.

D.1 LoRA-FA (Zhang et al., 2023a)

LoRA-FA (LoRA with frozen down blocks) modifies LoRA by keeping the down block frozen during training, while only the up block is trained. Structurally, however, it does not alter the fundamental matmul operator. Consequently, integrating SEAL follows the same procedure as standard LoRA: one can embed the passport CC into the product BCAB\,C\,A without requiring any special adjustments. The difference in training rules (i.e. freezing AA) does not affect how CC is placed or how it is decomposed into (C1,C2)(C_{1},C_{2}) for final public release.

D.2 LoRA+ (Hayou et al., 2024)

LoRA+ investigates the training dynamics of LoRA’s up (BB) and down (AA) blocks. In particular, it emphasizes the disparity in gradient magnitudes and proposes using different learning rates:

AAηGA,BBληGB,A\;\leftarrow\;A\;-\;\eta\;G_{A},\quad B\;\leftarrow\;B\;-\;\lambda\,\eta\;G_{B},

where λ1\lambda\gg 1 is a scale factor, η\eta is the base learning rate, and GA,GBG_{A},G_{B} are the respective gradients. LoRA+ does not alter the structural operator (still matrix multiplication). Therefore, SEAL can be employed by introducing Cr×rC\in\mathbb{R}^{r\times r} between BB and AA, yielding ΔW=BCA\Delta W=B\,C\,A. The difference in gradient scaling does not impact the usage of a non-trainable passport matrix CC.

D.3 VeRA (Kopiczko et al., 2024)

VeRA introduces two diagonal matrices, Λb\Lambda_{b} and Λd\Lambda_{d}, to scale different parts of the low-rank factors:

ΔW=ΛbBΛdA,\Delta W\;=\;\Lambda_{b}\,B\,\Lambda_{d}\,A,

where B,AB,A may be random, frozen, shared across layers and the diagonal elements in Λb,Λd\Lambda_{b},\Lambda_{d} are trainable. Despite these diagonal scalings, the core operator remains matrix multiplication. Hence, embedding a passport CC is still feasible. By leveraging the commutative property of diagonal matrices and CC (assuming CC commutes with Λd\Lambda_{d} in the sense that one can re-factor CC into C1ΛdC2C_{1}\Lambda_{d}C_{2} or ΛdC\Lambda_{d}C), SEAL can be inserted:

ΔW=Λb(BC1)Λd(C2A),\Delta W\;=\;\Lambda_{b}\,(B\,C_{1})\,\Lambda_{d}\,(C_{2}\,A),

which is functionally identical to ΛbBΛdA\Lambda_{b}\,B\,\Lambda_{d}\,A except for the hidden passport C=C1C2C=C_{1}C_{2}. Implementing SEAL in VeRA may require converting the final trained weights back into a standard (B,A)(B^{\prime},A^{\prime}) form plus a diagonal scaling term, but the fundamental principle is straightforward.

D.4 AdaLoRA (Zhang et al., 2023b)

AdaLoRA applies a dynamic rank-allocating approach inspired by SVD. It factorizes the weight update into:

ΔW=PΛQ,\Delta W\;=\;P\,\Lambda\,Q,

where Λ\Lambda is a diagonal matrix, and P,QP,Q are regularized to maintain near-orthogonality. Since diagonal matrices commute under multiplication (up to a re-factorization), one can embed a passport CC by decomposing it (f(C)(C1,C2)f(C)\rightarrow(C_{1},C_{2})). In essence,

ΔW=PC1ΛC2Q=PΛQ,\Delta W\;=\;P\,C_{1}\,\Lambda\,C_{2}\,Q\;\;=\;\;P^{\prime}\,\Lambda\,Q^{\prime},

where P=PC1P^{\prime}=PC_{1} and Q=C2QQ^{\prime}=C_{2}Q. This preserves the rank-rr structure and does not disrupt AdaLoRA’s optimization logic. Regularization terms that enforce PTPIP^{\prime T}P^{\prime}\approx I and QQTIQ^{\prime}Q^{\prime T}\approx I remain valid, though one may incorporate C1,C2C_{1},C_{2} into the initialization or adapt them carefully so as not to degrade the orthogonality constraints.

D.5 DoRA (Liu et al., 2024b)

DoRA modifies the final LoRA update using a column-wise norm factor:

W=WcW+ΔWc(W+ΔW),W^{\prime}\;=\;\frac{\|W\|_{c}}{\|\,W+\Delta W\,\|_{c}}\,\bigl{(}W+\Delta W\bigr{)},

where c\|\cdot\|_{c} computes column-wise norms and the ratio is (by design) often detached from gradients to reduce memory overhead. Replacing ΔW\Delta W with BCAB\,C\,A in DoRA does not alter the external gradient manipulation logic, since CC is non-trainable. Thus,

W=WcW+BCAc(W+BCA)W^{\prime}\;=\;\frac{\|W\|_{c}}{\|\,W+B\,C\,A\,\|_{c}}\,\bigl{(}W+B\,C\,A\bigr{)}

remains valid. The presence of CC does not interfere with DoRA’s approach to scaling or norm-based constraints.

D.6 Variants with Non-Multiplicative Operations

All of the above variants preserve the core LoRA assumption of a matrix multiplication operator for the rank-rr adaptation. However, certain approaches introduce non-multiplicative adaptations (e.g., Hadamard product, Kronecker product, or other specialized transforms). In the following section, for these cases, which discuss how SEAL can be generalized to any bilinear or multilinear operator \star.

Appendix E Extensions to Generalized Low-Rank Operators

In the main text, we considered a standard LoRA (Hu et al., 2022) that uses a matrix multiplication operator:

ΔW=BCA,\Delta W=B\;C\;A,

where Bb×rB\in\mathbb{R}^{b\times r}, Cr×rC\in\mathbb{R}^{r\times r}, and Ar×aA\in\mathbb{R}^{r\times a}. Recent work has explored alternative low-rank adaptation mechanisms beyond simple matmul, such as Kronecker product-based methods (Edalati et al., 2022; Yeh et al., 2023) or even elementwise (Hadamard) product (Hyeon-Woo et al., 2021) forms. Our approach can be extended in a straightforward manner to these generalized operators, which we denote as \star.

E.1 General Operator \star

Let \star be any bilinear or multilinear operator used for low-rank adaptation.111Here, bilinear means (XY)(X\star Y) is linear in both XX and YY when one is held fixed, e.g. standard matrix multiplication, Kronecker product, or Hadamard product. We can then write the trainable adaptation layer as

ΔW=BCA,\Delta W=B\;\star\;C\;\star\;A,

where B,AB,A are the trainable low-rank parameters, and CC is the non-trainable passport in SEAL. During training, BB and AA are optimized in conjunction with CC held fixed (just as in the matrix multiplication case).

Decomposition Function for Operator \star.

To distribute CC into (B,A)(B,A) after training, we require a decomposition function f:C(C1,C2)f:C\mapsto(C_{1},C_{2}) such that

C=C1C2.C=C_{1}\;\star\;C_{2}.

For example, under the Kronecker product \otimes, one could define f(C)f(C) to split CC into smaller block partitions, or use an SVD-like factorization in an appropriate transformed space. Under the Hadamard product, f(C)f(C) could involve elementwise roots or other transformations.

Once C1C_{1} and C2C_{2} are obtained, we apply:

B=BC1,A=C2A,B^{\prime}\;=\;B\;\star\;C_{1}\quad,\quad A^{\prime}\;=\;C_{2}\;\star\;A,

so that

BA=(BC1)(C2A)=B(C1C2)A=BCA.B^{\prime}\;\star\;A^{\prime}\;=\;(B\;\star\;C_{1})\star(C_{2}\star A)\;=\;B\;\star\;(C_{1}\star C_{2})\;\star\;A\;=\;B\;\star\;C\;\star\;A.

Hence, the final distributed weights (B,A)(B^{\prime},A^{\prime}) for public remain functionally equivalent to using B,A,CB,A,C.

E.2 Implications and Future Directions

  • Broader Applicability. By permitting \star to be any bilinear or multilinear operator (Kronecker, Hadamard, etc.), SEAL naturally extends beyond the canonical matrix multiplication used in most LoRA implementations. This flexibility can be valuable for advanced parameter-efficient tuning methods (Edalati et al., 2022; Hyeon-Woo et al., 2021; Yeh et al., 2023).

  • Same Security Guarantees. The central watermarking principle (embedding a non-trainable passport CC into the adaptation) does not change. An adversary attempting to re-factor BAB^{\prime}\star A^{\prime} to recover CC faces the same challenges described in the main text and Appendix C—non-identifiability, cost of reconstruction, and multi-passport verification barriers.

  • Potential Operator-Specific Designs. Certain operators (e.g., Kronecker product) may admit additional constraints or factorization strategies that could be exploited for improved stealth or efficiency. Investigating these is an interesting direction for future work.

In summary, SEAL can be generalized to other operators \star by treating CC as a non-trainable factor and defining a suitable decomposition function f(C)f(C) such that C=C1C2C=C_{1}\,\star\,C_{2}. This allows us to hide the passport just as in the matrix multiplication case, thereby preserving the main SEAL pipeline for more complex LoRA variants.

Appendix F Training Details

F.1 Commonsense Reasoning Tasks

Table 7: Hyperparameter configurations of SEAL and LoRA for Gemma-2B, Mistral-7B-v0.1, LLaMA2-7B/13B, and LLaMA3-8B on the commonsense reasoning. All experiments are done with 4x A100 80GB (for LLaMA-2-13B) and 4x RTX 3090 (for the other models) with approximately 15 hours.
Models Gemma-2B Mistral-7B-v0.1 LLaMA-2-7B LLaMA-2-13B LLaMA-3-8B
Method LoRA SEAL LoRA SEAL LoRA SEAL LoRA SEAL LoRA SEAL
r 32
alpha 32
Dropout 0.05
LR 2e-4 2e-5 2e-5 2e-5 2e-4 2e-5 2e-4 2e-5 2e-4 2e-5
Optimizer AdamW (Loshchilov & Hutter, 2019)
LR scheduler Linear
Weight Decay 0
Warmup Steps 100
Total Batch size 16
Epoch 3
Target Modules Query Key Value UpProj DownProj

We conduct evaluations on commonsense reasoning tasks using eight distinct sub-tasks: Boolean Questions (BoolQ) (Clark et al., 2019), Physical Interaction QA (PIQA) (Bisk et al., 2020), Social Interaction QA (SIQA) (Sap et al., 2019), Narrative Completion (HellaSwag) (Zellers et al., 2019), Winograd Schema Challenge (Wino) (Sakaguchi et al., 2021), ARC Easy (ARC-e), ARC Challenge (ARC-c) (Clark et al., 2018), and Open Book QA (OBQA) (Mihaylov et al., 2018).

We benchmark SEAL and LoRA against LLaMA-2-7B/13B (Touvron et al., 2023), LLaMA-3-8B (AI@Meta, 2024), Gemma-2B (Team et al., 2024), and Mistral-7B-v0.1 (Jiang et al., 2023) across these commonsense reasoning tasks.

The hyperparameters used for these evaluations are listed in Table 14.

F.2 Textual Instruction Tuning

Table 8: Hyperparameter configurations of SEAL and LoRA for Instruction Tuning. All experiments are done with 1x A100 80GB for approximately 2 hours. All w/o LM HEAD are Query, Key, Value, Out, UpProj, DownProj, GateProj.
Model LLaMA-2-7B
Method LoRA SEAL
r 32
alpha 32
Dropout 0.0
LR 2e-5
LR scheduler Cosine
Optimizer AdamW
Weight Decay 0
Total Batch size 8
Epoch 3
Target Modules All w/o LM HEAD

We conducted textual instruction tuning using Alpaca dataset (Taori et al., 2023) on LLaMA-2-7B (Touvron et al., 2023), trained for 3 epochs. The hyperparameters used for this process are detailed in Table 8.

F.3 Viusal Instruction Tuning

Table 9: Performance comparison of different methods across seven visual instruction tuning benchmarks
Method # Params (%) VQAv2 GQA VisWiz SQA VQAT POPE MMBench Avg
FT 100 78.5 61.9 50.0 66.8 58.2 85.9 64.3 66.5
LoRA 4.61 79.1 62.9 47.8 68.4 58.2 86.4 66.1 66.9
SEAL 4.61 75.4 58.3 41.6 66.9 52.9 86.0 60.5 63.1
Table 10: Hyperparameters for visual instruction tuning. All experiments were performed with 4x A100 80GB with approximately 24 hours
Model LLaVA-1.5-7B
Method LoRA SEAL
r 128
alpha 128
LR 2e-4 2e-5
LR scheduler Linear
Optimizer AdamW
Weight Decay 0
Warmup Ratio 0.03
Total Batch size 64

We compared the fidelity of SEAL, LoRA, and FT on the visual instruction tuning tasks with LLaVA-1.5-7B (Liu et al., 2024a). To ensure a fair comparison, we used the same original model provided by (Liu et al., 2024a) uses the same configuration as the LoRA setup with the same training dataset. We adhere to (Liu et al., 2024a) setting to filter the training data and design the tuning prompt format. The finetuned models are subsequently assessed on seven vision-language benchmarks: VQAv2(Goyal et al., 2017), GQA(Hudson & Manning, 2019), VisWiz(Gurari et al., 2018), SQA(Lu et al., 2022), VQAT(Singh et al., 2019), POPE(Li et al., 2023b), and MMBench(Liu et al., 2023).

F.4 Text-to-Image Synthesis

Table 11: DreamBooth text prompts used for evaluation of inanimate objects and live subjects.
Prompts for Non-Live Objects Prompts for Live Subjects
a {} in the jungle a {} in the jungle
a {} in the snow a {} in the snow
a {} on the beach a {} on the beach
a {} on a cobblestone street a {} on a cobblestone street
a {} on top of pink fabric a {} on top of pink fabric
a {} on top of a wooden floor a {} on top of a wooden floor
a {} with a city in the background a {} with a city in the background
a {} with a mountain in the background a {} with a mountain in the background
a {} with a blue house in the background a {} with a blue house in the background
a {} on top of a purple rug in a forest a {} on top of a purple rug in a forest
a {} with a wheat field in the background a {} wearing a red hat
a {} with a tree and autumn leaves in the background a {} wearing a santa hat
a {} with the Eiffel Tower in the background a {} wearing a rainbow scarf
a {} floating on top of water a {} wearing a black top hat and a monocle
a {} floating in an ocean of milk a {} in a chef outfit
a {} on top of green grass with sunflowers around it a {} in a firefighter outfit
a {} on top of a mirror a {} in a police outfit
a {} on top of the sidewalk in a crowded street a {} wearing pink glasses
a {} on top of a dirt road a {} wearing a yellow shirt
a {} on top of a white rug a {} in a purple wizard outfit
a red {} a red {}
a purple {} a purple {}
a shiny {} a shiny {}
a wet {} a wet {}
a cube shaped {} a cube shaped {}

The DreamBooth dataset (Ruiz et al., 2023) encompasses 30 distinct subjects from 15 different classes, featuring a diverse array of unique objects and live subjects, including items such as backpacks and vases, as well as pets like cats and dogs. Each of the subjects contains 4-6 images. These subjects are categorized into two primary groups: inanimate objects and live subjects/pets. Of the 30 subjects, 21 are dedicated to objects, while the remaining 9 represent live subjects/pets.

For subject fidelity, following (Ruiz et al., 2023), we use CLIP-I, DINO. CLIP-I, an image-text similarity metric, compares the CLIP (Radford et al., 2021) visual features of the generated images with those of the same subject images. DINO (Caron et al., 2021), trained in a self-supervised manner to distinguish different images, is suitable for comparing the visual attributes of the same object generated by models trained with different methods. For prompt fidelity, the image-text similarity metric CLIP-T compares the CLIP features of the generated images and the corresponding text prompts without placeholders, as mentioned in (Ruiz et al., 2023; Nam et al., 2024). For the evaluation, we generated four images for each of the 30 subjects and 25 prompts, resulting in a total of 3,000 images. The prompts used for this evaluation are identical to those originally used in (Ruiz et al., 2023) to ensure consistency and comparability across models. These prompts are designed to evaluate subject fidelity and prompt fidelity across diverse scenarios, as detailed in Table 11

Fig. 7 visually compares LoRA and SEAL on representative subjects from the DreamBooth dataset. The top row shows example reference images for each subject, the middle row shows images generated by LoRA, and the bottom row shows images from our SEAL. Qualitatively, both methods faithfully capture key attributes of each subject (e.g., shape, color, general pose) and produce images of comparable visual quality. That is, SEAL does not degrade or alter the original subject’s appearance relative to LoRA, suggesting that incorporating the constant matrix CC does not introduce noticeable artifacts or reduce fidelity. These results align with the quantitative metrics on subject and prompt fidelity, indicating that SEAL maintains a quality level on par with LoRA while embedding a watermark in the learned parameters.

Figure 7: Comparison of LoRA and SEAL in Text-to-Image Synthesis
Refer to caption
Table 12: Hyperparameter configurations of SEAL and LoRA for Text-to-Image Synthesis. All experiments are done with 4x RTX 4090 with approximately 15 minutes per subject.
Model Stable Diffusion 1.5
Method LoRA SEAL
r 32
alpha 32
Dropout 0.0
LR 5e-5 1e-5
LR scheduler Constant
Optimizer AdamW
Weight Decay 1e-2
Total Batch size 32
Steps 300
Target Modules Q K V Out AddK AddV
Table 13: Hyperparameter configurations of Finetruning Attack on SEAL which trains on 3-epoch. We resume training on (B,A)\mathbb{N}(B^{\prime},A^{\prime}), which passport CC is distributed in B,AB,A via fsvdf_{svd}.
Model LLaMA-2-7B
Method LoRA
r 32
alpha 32
LR 2e-5
Optimizer AdamW
LR scheduler Linear
Weight Decay 0
Warmup Steps 100
Batch size 16
Epoch 1
Target Modules Query Key Value UpProj DownProj
Table 14: Hyperparameter configurations of Integrating with DoRA.
Model LLaMA-2-7B
Method LoRA SEAL DoRA SEAL+DoRA
r 32
alpha 32
Dropout 0.05
LR 2e-4 2e-5 2e-4 2e-5
Optimizer AdamW
LR scheduler Linear
Weight Decay 0
Warmup Steps 100
Total Batch size 16
Epoch 3
Target Modules Query Key Value UpProj DownProj

Appendix G Ablation Study

G.1 Passport Example

In order to provide a concrete illustration of our watermark extraction process, we construct a small 32×\times32 grayscale image as the passport CC (or CpC_{p}). Specifically, we sampled 100 frames from a publicly available YouTube clip, applied center-cropping on each frame, converted them to grayscale, and then downsampled to 32×\times32. From these frames, we selected one representative image (shown in Fig. 3) to embed as the non-trainable matrix CC in our SEAL pipeline Sec. 3.3.

This tiny passport image, while derived from a movie clip, is both unrecognizable at 32×\times32 and used exclusively for educational, non-commercial purposes. Nevertheless, it visually demonstrates how a low-resolution bitmap can be incorporated into the model’s parameter space and later extracted (possibly with minor distortions) to verify ownership.

Refer to caption
Figure 8: Passport Example. Left: A 32×\times32 grayscale bitmap (cropped and downsampled from a YouTube clip333https://www.youtube.com/watch?v=2zHHkSu1br4) serves as our non-trainable passport CC. Right: The passport partially recovered (from 10% zeroed SEAL weight on LLaMA-2-7B).

G.2 Rank Ablation

To evaluate versatility of the proposed SEAL method under varying configurations, we conducted additional experiments focusing on different rank settings (4, 8, 16). The results are summarized in Table 15. We used the Gemma-2B model (Team et al., 2024) on commonsense reasoning tasks, as described previously. For comparison, we included the results of LoRA with r=32r=32 and SEAL with r=32r=32 as mentioned in Table 2.

Table 15: Accuracy across various rank settings on commonsense reasoning tasks. The table includes results for rank configurations (4, 8, 16) of SEAL, as well as LoRA r=32 and SEAL r=32.
Rank BoolQ PIQA SIQA HellaSwag Wino. ARC-c ARC-e OBQA Avg.
4 65.05 78.18 75.64 76.16 73.56 65.02 81.65 74.80 73.76
8 64.83 81.23 77.02 83.92 77.35 68.43 83.00 79.20 76.87
16 66.24 82.32 77.94 86.10 79.24 67.32 83.12 78.60 77.61
32 66.45 82.16 78.20 83.72 79.95 68.09 82.62 79.40 77.57
LoRAr=32\text{LoRA}_{r=32} 65.96 78.62 75.23 79.20 76.64 79.13 62.80 72.40 73.75

G.3 Impact of the Size of Passport CC

To analyze how the magnitude of the passport CC influences the final output, we train the model with ΔW=BCA\Delta W=B\,C\,A, but at inference time remove CC (i.e., (B,A,)\mathbb{N}(B,A,\emptyset)) to observe the resulting images under different standard deviations std of CC. Specifically, we sample C𝒩(0,std2)C\sim\mathcal{N}(0,\texttt{std}^{2}) with std{0.01,0.1,1.0,10.0,100.0}\texttt{std}\in\{0.01,0.1,1.0,10.0,100.0\} and keep BB and AA trainable. Fig. 9 shows that lower std (e.g., 0.010.01) produces markedly different images relative to the vanilla model without CC, while higher std (e.g., 10.010.0 or 100.0100.0) yields outputs closer to the vanilla Stable Diffusion model444https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5. The original weight had been taken down..

Why does std of CC affect (B,A,)\mathbb{N}(B,A,\emptyset)?

Recall that ΔW=BCA\Delta W=B\,C\,A. If std(C)\texttt{std}(C) is very small (e.g., 0.010.01), then during training, the product BCAB\,C\,A must still approximate the desired update ΔW\Delta W. Because CC is tiny, BB and AA tend to have relatively large values to compensate. Consequently, when we remove CC at inference time (use (B,A,)\mathbb{N}(B,A,\emptyset)), these enlarged BB and AA inject strong perturbations, manifesting visually as high-frequency artifacts.

Conversely, if std(C)\texttt{std}(C) is very large (e.g., 10.010.0 or 100.0100.0), then to avoid destabilizing training, BB and AA remain smaller in scale. Hence, removing CC at inference, (B,A,)\mathbb{N}(B,A,\emptyset), introduces only minor differences from the original model, leading to outputs that closely resemble the vanilla Stable Diffusion model.

Figure 9: Effect of passport CC standard deviation (std) on SEAL weight. std = σ\sigma: Outputs are using only SEAL weight without C𝒩(0,σ2)C\sim\mathcal{N}(0,\sigma^{2}), (B,A,)\mathbb{N}(B,A,\emptyset). Vanilla SD 1.5: output from vanila Stable Diffusion 1.5 with same prompt.
Refer to caption
Quantitative Comparison.

In addition to the qualitative results, Table 16 compares Peak Signal-to-Noise Ratio (PSNR) and Structural Similarity (SSIM) between images generated using only trained SEAL weights without CC, (B,A,)\mathbb{N}(B,A,\emptyset), at various passport std values. Lower std (e.g., 0.010.01) shows significantly lower PSNR and SSIM, indicating large deviations (i.e., stronger perturbations) from the vanilla output. As std increases to 10.010.0 or 100.0100.0, the outputs become more aligned with the vanilla model, reflected by higher PSNR/SSIM scores.

Table 16: Comparision of PSNR and SSIM values for images generated without C𝒩(0,σ2)C\sim\mathcal{N}(0,\sigma^{2}), using only (B,A,)\mathbb{N}(B,A,\emptyset), under varying standard deviations of the passport CC, with images generated under vanilla SD 1.5 model. Obj. 1: Cat, Object 2: Backpack dog, Obj. 3: Ducky toy. Object names are same as (Ruiz et al., 2023)
Ref. Metric \uparrow Standard Deviation of CC
0.01 0.1 1.0 10.0 100.0
Obj.1 SSIM 0.104 0.691 0.936 0.987 0.998
PSNR 7.80 19.02 30.87 43.64 53.16
Obj.2 SSIM 0.102 0.652 0.941 0.993 0.998
PSNR 7.91 18.51 33.15 47.24 54.21
Obj.3 SSIM 0.115 0.651 0.959 0.992 0.998
PSNR 8.08 18.39 32.92 45.39 53.58

Appendix H Extending to Multiple Passports and Data-based Mappings

So far, our main exposition has treated the watermark matrices CC and CpC_{p}, constant passports. However, SEAL naturally extends to a setting in which one maintains multiple passports {C1,C2,,Cm}\{C_{1},C_{2},\ldots,C_{m}\} (similarly {D1,D2,Dn\{D_{1},D_{2},\ldots\,D_{n}), each possibly tied to a distinct portion of the training set, or to a distinct sub-task within the same model. Formally, suppose that during mini-batch updates Alg. 1 randomly picks one passport CiC_{i} associated with (x,y)(x,y). Then line 10 of Alg. 1 becomes:

pick Cis.t. (x,y)Ci,WW+BCiA.\text{pick }C_{i}\;\text{s.t.\ }(x,y)\;\mapsto\;C_{i},\quad W^{\prime}\;\leftarrow\;W+B\,C_{i}\,A.

One can store a simple mapping function ϕ:(x,y)i{1,,m}\phi:\,(x,y)\!\mapsto i\in\{1,\ldots,m\} to tie each batch to its specific passport.

Distributed or Output-based Scenarios. Another angle is to use multiple passports not only at training time but also during inference. For instance, given a family {C1,,Cm}\{C_{1},\dots,C_{m}\}, one could selectively load CiC_{i} to induce different behaviors or tasks in an otherwise single LoRA model. In principle, if each CiC_{i} is entangled with (B,A)(B,A), switching passports at inference changes the effective subspace. This may be viewed as a distributed watermark approach: where each CiC_{i} can be interpreted as a unique “key” that enables (or modifies) certain model capabilities, separate from the main training objective. Though we do not explore this direction in detail here, it points to broader usage possibilities beyond simply verifying ownership, such as controlled multi-task inferences and individually licensed feature sets.