acceptodds
Under review as a conference paper at ICLR 2027

SAME: Semantic Watermark Embedding for Open-Source Large Pretrained Models

Abstract

Open-source large pretrained models (LPMs) have become increasingly valuable assets for model development and downstream applications, but their accessibility also facilitates unauthorised copying and modification. To protect their intellectual property (IP), existing approaches typically embed tailored trigger–response patterns as watermarks for ownership verification. However, such trigger designs need to be tailored to task-specific data that constrain their transferability across downstream tasks, and are not durable under subsequent benign fine-tuning. To address these limitations, we propose SemAntic waterMark Embedding (SAME), which introduces a semantically meaningful private vocabulary that enables flexible composition of adaptive and persistent watermarks. Specifically, SAME introduces a fixed private vocabulary that assigns each native token a private embedding counterpart, while aligning the semantic expressiveness of the two vocabularies within the model’s representation space. This alignment allows private tokens to be flexibly composed into semantic triggers that elicit meaningful responses, enabling adaptive watermarks beyond predefined trigger–response pairs. By grounding the private vocabulary in the model’s native semantics, SAME couples the watermark with its evolving semantic capabilities, allowing this connection to be preserved throughout downstream fine-tuning. Extensive experiments demonstrate that SAME provides reliable and robust watermarks across LPMs of varying scales and architectures, enabling effective ownership verification for IP protection.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Large pre-trained models (LPMs), model watermarking, watermark persistence.

Reviews

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

This paper proposes SAME, a framework for protecting the IP of open-source LLMs even after the LLMs' fine-tuning. The basic idea of SAME is to prepare a randomly-chosen private word embedding matrix, which is used to fine-tune the LLMs. As a result, the LLMs with such private word embedding matrix could behave exactly the same to the original LLMs with same input. This alignment could be used as a evidence for LLM IP verification. Further experiments demonstrate the watermark of SAME could survive further fine-tuning on downstream tasks.

Critical strengths

1.SAME is simple and clear, easy to understand.

Critical weaknesses
  1. How the motivation of SAME induces its design is not well explained

  2. Despite the effectiveness of SAME reported in the paper, the mechanic of SAME and how it works are not discussed: why LLMs could be fine-tuned with randomly chosen word embedding matrix?

  3. For experiments, all baseline methods adopt different watermark dataset from SAME, which makes a unfair comparison. Since the construction of dataset is vital to this backdoor-like watermark injection, using same dataset for fair comparison is necessary.

  4. Why SAME could survive fine-tuning and removal attack are not explained, making it unconvincing.

Questions for authors
  1. What is the social consequence if the LLMs owner choose not to embed watermark into their models? Since open-source model owners all assume that their models might be fine-tuned, why they still want to verify the model's IP after its fine-tuning?
  2. Since word embedding carries important semantic information for NLP tasks, it is hard to believe that LLMs can be trained with randomly chosen word embedding matrix. Why SAME could do that?
  3. What nature of SAME makes it robust to fine-tuning attack and watermark removal attack?
2 comments
AuthorsOpenReview ↗

Response to Reviewer zaWJ (Part 1/2)

We thank the reviewer for raising these important questions.

The motivation of SAME’s design, and a randomly chosen embedding matrix training. (W1/W2/Q1/Q2)

Fixed trigger–response watermarks are tied to a limited set of input patterns and may be overwritten by later adaptation. SAME addresses these issues by assigning every native token a corresponding private embedding. Private queries can then be composed across tasks. During training, native and private inputs pass through the same Transformer and receive the same target responses. This shared supervision links the private codebook to the model’s semantic computation, allowing it to follow knowledge and capabilities acquired during downstream fine-tuning.

The private vectors serve as stable token identities, while the Transformer learns their task-relevant semantic and contextual roles. Prior work supports the learnability of such representations: Transformers can operate with random Gaussian embeddings [1], frozen random input representations [2], hash-based or LSH-generated representations [3, 4], and random non-orthogonal embeddings [5]. Arpit et al. [6] further showed that deep networks tend to learn simple patterns shared across examples before memorizing individual samples. These findings support the use of training to align initially random private vectors with shared semantic computation. The method does not assume that an arbitrary random matrix works without training.

Our experiments provide direct evidence in the SAME setting. Fig. 2 shows improved private-path loss and held-out response quality. Fig. 3 shows that learned private vectors outperform random controls, confirming that the semantic behavior comes from the learned private–model pairing. Fig. 4 shows persistent alignment between native and private hidden representations across layers and adaptation. Together, these results support the claim that the private codebook learns a reusable semantic pathway. The owner can independently sample and keep this codebook private, making watermark creation reproducible while keeping independently sampled codebooks highly unlikely to collide.

[1] Kumar et al., “From Fully Trained to Fully Random Embeddings: Improving Neural Machine Translation with Compact Word Embedding Tables,” AAAI 2022.

[2] Bochkov, “Emergent Semantics Beyond Token Embeddings: Transformer LMs with Frozen Visual Unicode Representations,” TMLR 2025.

[3] Xue et al., “HashFormers: Towards Vocabulary-independent Pre-trained Transformers,” EMNLP 2022.

[4] Sankar et al., “ProFormer: Towards On-Device LSH Projection Based Transformers,” EACL 2021.

[5] Vural et al., “Learning to Recall with Transformers Beyond Orthogonal Embeddings,” ICLR 2026.

[6] Arpit et al., “A Closer Look at Memorization in Deep Networks,” ICML 2017.


Fair comparison with baselines using different watermark datasets. (W3)

The comparison is fair with respect to the downstream evaluation. As described in Section 4.1, all methods use the same Qwen3-8B base model and are implemented in a unified codebase. For each benchmark, Vanilla, SAME, and all baselines are evaluated on the same downstream dataset, using the same downstream fine-tuning protocol and the same utility and verification metrics. The results are therefore directly comparable under the downstream adaptation setting.

The watermark-injection data are intentionally different because the comparison targets a specific practical property. SAME is injected once on general Alpaca data and then reused across all downstream tasks. Each baseline is injected using the corresponding task-specific dataset. This is not an uncontrolled change in the downstream evaluation. It is the experimental distinction that tests whether SAME can support one-time injection and cross-task reuse, while the baselines require task-specific watermark injection. The tables therefore compare all methods under the same base model, downstream data, adaptation procedure, and evaluation protocol.

AuthorsOpenReview ↗

Response to Reviewer zaWJ (Part 2/2)

What makes SAME robust to downstream fine-tuning and watermark removal? (W4Q3)

SAME persists because its native and private pathways are trained through shared semantic computation. During watermark injection, both pathways receive the same semantic supervision, linking the private codebook to the model’s semantic capabilities. During downstream adaptation, native-only fine-tuning updates the model’s semantic computation while the private codebook remains fixed. If the model retains its semantic capabilities, the private pathway can follow newly learned knowledge and task capabilities.

Our experiments support this functional coupling. Fig. 3 shows that the learned private vocabulary remains stronger than random controls after adaptation. Fig. 4 shows persistent native–private alignment, Fig. 5 evaluates repeated heterogeneous fine-tuning, and Fig. 6 shows coupled degradation and recovery under MEraser. Prior work on entangled watermarking, semantic sharing, multi-view representation learning, and watermark learnability provides related motivation [1–5]. These works support the intuition behind our design, but do not establish a theory or guarantee for SAME.

Existing watermark removal methods mainly target specific trigger–response patterns. SAME is coupled to the model’s shared semantic computation, so removing its private pathway may require damaging the model’s original semantic output capability. We evaluate this trade-off under the removal methods considered in the paper. Designing attacks that selectively remove SAME while preserving native utility remains an open problem, as discussed in Appendix F.

[1] Jia et al., “Entangled Watermarks as a Defense against Model Extraction,” USENIX Security Symposium 2021.

[2] Yang et al., “Rethinking Label-Wise Cross-Modal Retrieval from A Semantic Sharing Perspective,” IJCAI 2021.

[3] Hwang et al., “Multi-View Representation Learning via Total Correlation Objective,” NeurIPS 2021.

[4] Masrani et al., “Task-Agnostic Language Model Watermarking via High Entropy Passthrough Layers,” AAAI 2025.

[5] Gu et al., “On the Learnability of Watermarks for Language Models,” ICLR 2024.


Why embed a watermark and verify ownership after fine-tuning? (Q4)

Hugging Face’s Model Card specification provides a base_model field for fine-tuned, adapter, merged, and quantized models. The upstream license may also require attribution or modification notices. Documenting model provenance supports reproducibility and transparent release. SAME adds a functional ownership signal that remains verifiable after downstream fine-tuning.

Open-weight models can be fine-tuned, distilled, or merged and redistributed under new names, which can obscure the original developer’s contribution. Recent cases involving Cursor’s Composer 2 and Rio 3.5 show the practical importance of identifying upstream models [1, 2].

Fine-tuning can substantially change model parameters and behavior, so model names and external metadata may not be enough to verify provenance. SAME embeds a private watermark into the model’s learned computation, enabling ownership verification after downstream adaptation while preserving legitimate model reuse.

References

[1] TechCrunch, “Cursor Admits Its New Coding Model Was Built on Top of Moonshot AI’s Kimi,” 2026; Cursor, “A Technical Report on Composer 2,” 2026.

[2] Decrypt, “Rio de Janeiro Built an AI Model That Beat DeepSeek—But Was Based on Someone Else’s Work,” 2026.

Reviewer_usYbOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

SAME is a watermarking method for verifying ownership of LLMs. It introduces a fixed private embedding matrix and fine-tunes the model on both native and privately encoded inputs using the same target responses. Ownership is verified through either predefined watermark responses or meaningful answers to unseen private queries. Experiments examine watermark persistence under downstream fine-tuning and removal attacks, while assessing normal task performance across several models and datasets.

Critical strengths

The paper’s main strength is its interesting approach to teaching a model to interpret two sets of embeddings. However, the limited training and evaluation details make it difficult to fully assess the method’s effectiveness.

Critical weaknesses
  1. The paper does not report the training token count, which is critical for evaluating the method.
  2. There is no intermediate supervision to ensure that the model’s original internal representations do not change too much.
  3. Metrics such as BERTScore, rather than accuracy, are insufficient to prove that the watermarking method preserves model performance, especially in math and coding. The benchmark selection is also not representative enough. Qwen3 has reported results on AIME, LiveCodeBench, and other benchmarks that could be used here.
  4. For watermark detection, the paper does not report ROC curves, which are important for evaluating detection reliability.
Questions for authors
  1. What is the difference between this method and other question-based watermarking methods?
  2. Why do we need to teach the model to understand a new embedding matrix instead of simply training it to answer special questions with <SAME>? The experiments do not sufficiently demonstrate why learning an entire private embedding matrix is necessary. What would the detection results look like if the model were trained only on the 20 watermark questions?
  3. Could the authors evaluate more backdoor-removal methods? These would be important attacks to test against this approach.
  4. The abstract refers to large pretrained models, but the main experiments use Qwen3-8B-Instruct, which has already undergone post-training. This wording is confusing.
3 comments
AuthorsOpenReview ↗

Response to Reviewer usYb (Part 1/2)

We thank the reviewer for raising these important questions.

Training token count. (W1)

We use the Alpaca instruction–response dataset with its original system prompt and no additional prompt modifications, tokenized with the Qwen3-8B-Instruct tokenizer. After reserving 500 examples, 51,500 examples are trained for 10 epochs. Accounting for both native and private pathways, the training volume is approximately 309M processed tokens.


No intermediate supervision to constrain representation drift. (W2)

Our objective is to preserve semantic output quality and align the private pathway with the model’s semantic capabilities. As discussed in our response to Reviewer TRmy (Q3), SAME relies on the private-codebook to semantics mapping, not a particular tensor layout or unchanged internal representation. Representation drift is therefore not itself a concern, provided that semantic alignment and output quality are maintained. We assess these directly through downstream evaluations, without intermediate supervision.


Are BERTScore and the selected benchmarks sufficient to show that watermarking preserves performance, especially in math and coding? (W3)

BERTScore is appropriate for our primary evaluation goal: measuring whether the private pathway preserves the semantic quality of the model’s responses and remains aligned with the native pathway. SAME does not create new task-solving capabilities. Its performance is naturally bounded by the underlying model’s semantic capabilities. Therefore, lower scores on a difficult mathematical or coding task can reflect Qwen3’s own capability and do not necessarily indicate degradation caused by watermarking.

Our current evaluation compares both native and private outputs with the corresponding golden outputs. For math and coding tasks, we will add a conditional accuracy metric in the revised version: among the instances answered correctly through the native pathway, we will measure how often the private pathway also produces a correct answer. This tests whether the private pathway follows the model’s semantic capabilities as they appear in the native pathway.


ROC curves, FPR (W4)

We will compare SAME with fixed trigger–response methods under the same downstream fine-tuning setting using ROC curves, FPR, and related verification metrics.


Difference between SAME and other question-based watermarking methods? (Q1)

Beyond fixed verification, SAME tests whether private-codebook queries can still produce meaningful semantic responses. The private vocabulary allows semantic components to be freely composed into new verification queries across tasks. Conventional question-based methods bind verification to a finite set of injected instruction–response pairs, while SAME trains a reusable private vocabulary that can encode new queries across tasks. Appendix A provides examples of this free semantic composition, while Tables 1 and 2 show private-path evaluation on multiple downstream classification and generation tasks. The transfer quality depends on the task and the model’s capabilities.

The fixed <SAME> protocol is included for direct comparison with trigger–response methods and is not the main contribution. Instructional Fingerprinting is the closest prior work for this protocol. Its fixed triggers may survive downstream fine-tuning, but they do not automatically produce new semantic verification queries for newly learned tasks. SAME extends this setting with a reusable private semantic channel, supported by the held-out results in Fig. 2, random-vocabulary controls in Fig. 3, and unseen-query examples in Appendix A.

Why train the full private embedding matrix when only 20 watermark questions are used? (Q2)

We include the 20 fixed queries and the private <SAME> token to compare with existing trigger–response watermarking methods. SAME aims to let the model understand new queries expressed through the private codebook, including queries about tasks learned during downstream fine-tuning.

The 20 examples are optional for this goal. Training only on them may teach the model those specific responses, but does not teach it to understand queries using the rest of the private vocabulary. This is why we train the full codebook and evaluate it on held-out queries, downstream tasks, and random-codebook controls.

AuthorsOpenReview ↗

Response to Reviewer usYb (Part 2/2)

Evaluate more backdoor-removal methods (Q3)

The manuscript already evaluates robustness against targeted watermark-removal attacks through three complementary mechanisms. BEEAR perturbs intermediate representations, and MEraser uses mismatched responses to erase learned trigger associations. These are directly relevant removal attacks because they attempt to disrupt the model behavior associated with a watermark while preserving normal utility. SAME is specifically designed to make this selective removal difficult. Its watermark is not an isolated trigger–response pattern or a distributional output statistic. It is a semantic alignment between the private codebook and the model’s shared semantic computation. Removing it therefore requires damaging this semantic capability, which is precisely the trade-off examined by the BEEAR and MEraser experiments.

We also evaluate DPO alignment because reinforcement-learning-based post-training is a common transformation applied to instruction-tuned models. This tests whether ordinary RL post-training weakens the private semantic pathway. Finally, the FGSM experiment applies adversarial perturbations at the input level and tests whether the private pathway can be reproduced or removed through local embedding perturbations. Together, these experiments cover targeted representation-level removal, response-based erasure, common RL post-training, and input-level adversarial perturbation. They directly test the threat model relevant to SAME. Additional attacks designed for isolated trigger patterns or output-distribution statistics would not test the mechanism that SAME actually uses.

Why say “pretrained models” when using Qwen3-8B-Instruct? (Q4)

Yes. The principal experiments use an instruction-tuned open-weight checkpoint, not a purely pretrained base model. We will revise the wording to “open-weight language models, including instruction-tuned checkpoints.” The cross-model experiments include LLaMA3.2, Qwen3, Mistral, GPT-OSS, and Qwen3-VL, but these results still do not constitute a systematic study of purely pretrained checkpoints. We will align the abstract and claims with the actual experimental scope.

Thank you for the response and clarifications. The additional training details are helpful, but key empirical concerns remain unresolved, including task-level accuracy comparisons before and after watermarking, the 20-question-only ablation, and ROC/FPR results for watermark detection. I will therefore maintain my original score.

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

The paper tackles ownership verification for open-weight LLMs that third parties run and modify themselves. SAME adds a fixed, randomly initialised private vocabulary mapped one-to-one onto the native token IDs. It then trains the model so that native and private inputs give the same outputs. Verification works in two ways: 1. Check whether 20 implanted examples output <SAME>. 2. Compare private and native responses using BERTScore. The authors say the watermark survives fine-tuning (independent and sequential), BEEAR/MEraser, DPO and FGSM, and that it works across several model families.

Critical strengths
  • Instead of a single trigger -> response backdoor, the watermark is tied to a whole parallel input channel. Removing it should therefore hurt the model's general ability.
  • It's injected once on Alpaca (baselines are injected per task) and still gets 100% fixed detection after native-only fine-tuning.
Critical weaknesses
  • There's no threshold, no hypothesis test and no ROC/AUC. The only negative control is a single unwatermarked Qwen3-8B. Ownership claims need actual error rates, especially on other fine-tunes of the same base or models sharing the tokenizer.
  • Verification needs embedding-level (white-box) access. In that setting, the natural comparisons are fingerprinting methods like HuRef, REEF or Instructional Fingerprinting, not backdoor attacks (BadNet, VPI, etc.). API-only suspects, which are probably the more common case, aren't discussed at all.
Questions for authors

I have the following questions:

  • What threshold and test decide ownership? Please report FPR/TPR or AUC over a pool of independent models.
  • Why is semantic accuracy near chance on MMLU and BoolQ? Would you limit the semantic-verification claim to generation tasks?
  • Does SAME survive embedding normalisation or clipping, or fine-tuning on random high-norm inputs? Does a smaller epsilon that matches native norms still work?
  • What is Vanilla? Were the baselines evaluated after the same downstream fine-tuning? What is the watermarked model's general utility before downstream adaptation?
  • Is the proposed method still reusable once the verification procedure is exposed to the adversary?
2 comments
AuthorsOpenReview ↗

Response to Reviewer TRmy (Part 1/2)

We sincerely appreciate your time and effort in reviewing our manuscript. Below are our responses to your valuable comments.


Ownership threshold, error rates, and negative models (W1/Q1)

SAME uses two complementary verification signals. Conventional text watermarks detect statistical signatures in generated outputs, so they are naturally evaluated with thresholds, FPR, TPR, and detection power.

SAME semantic verification asks whether a query encoded by the private codebook still produces meaningful semantic content. The model has native and private input pathways, and BERTScore or ROUGE-L measures the semantic quality or consistency of the private response, even when wording differs. This is a different verification object from an output-distribution signature.

For direct comparison with trigger–response methods, SAME also retains <SAME> and 20 fixed queries. Tables 1 and 2 show a 100% fixed verification rate across all evaluated downstream tasks. In the revised manuscript, we will add the negative-trigger rate, operating threshold, FPR/TPR or an equivalent statistical test, and appropriate negative-baseline comparisons for this fixed protocol. We will report and compare these metrics for SAME and the different baselines under the same downstream fine-tuning protocol.


Comparison of SAME with HuRef, REEF, and Instructional Fingerprinting (W2)

These methods differ mainly in what they use as the verification carrier. HuRef relies on parameter-space properties and is therefore tied to the inspected model structure and parameters. REEF compares representation-level features for the same outputs, but representation similarity across different architectures does not by itself guarantee model-specific separation in a high-dimensional space. SAME relies on the model’s output semantics and does not depend on a particular parameter or representation pattern. Instructional Fingerprinting is the closest baseline to SAME’s fixed protocol, since both use secret instruction–response triggers. However, its verification behavior is tied to the injected instruction pairs and does not automatically inherit newly learned downstream instruction capabilities. SAME uses a private codebook to align with the model’s semantic computation and evaluate newly composed queries.

This comparison is most direct for SAME’s fixed protocol, which uses the <SAME> token and 20 fixed queries. SAME’s semantic protocol further evaluates newly composed private queries. Since SAME requires access to the suspect model’s input-embedding interface, we will include Instructional Fingerprinting as the closest comparison in the revised manuscript, together with a concise clarification of the different access assumptions and verification signals.


Low semantic accuracy on MMLU and BoolQ, limitation on task generalization (Q2)

As discussed in Q1/W1, semantic verification depends on both the model’s task capability and the private codebook’s alignment with the adapted model. This explains the lower private-path accuracies on MMLU and BoolQ, 28.02% and 56.20%, respectively. It reflects task-dependent semantic transfer, not a watermark limited to the Alpaca injection task. The random-vocabulary controls in Fig. 3 and Fig. 13 further show that this capability depends on the learned private–model pairing.

Table 2 provides stronger evidence on generation tasks. Private-path BERTScore-F1 reaches 85.61 on Dolly, 81.62 on Math, and 88.57 on CodeAlpaca, remaining close to native Utility. Thus, SAME supports task-adaptive semantic verification, although its quality depends on the task and model capability. The separate fixed protocol remains robust, achieving 100% verification across Tables 1 and 2.


Robustness to tensor operations and epsilon scale (Q3)

SAME is agnostic to any particular architecture, tensor layout, or tensor statistic. It learns a mapping between the fixed private codebook and the model’s semantic computation, so internal tensor changes do not automatically invalidate the watermark. Section 4.3 supports this across dense model families and scales. MoE models show greater variation and sensitivity to capacity and initialization, while the multimodal result demonstrates compatibility with feature fusion and alignment. These results do not imply immunity to destructive operations that disrupt the private-codebook to semantics mapping.

The epsilon ablation is separate. Appendix B and Fig. 8 evaluate ϵ∈{0.1,0.5,2.0}\epsilon\in\{0.1,0.5,2.0\}. With d=4096d=4096, the expected private-vector norms are 5.23, 26.13, and 104.51, compared with a native mean norm of 1.38. Thus, ϵ=0.1\epsilon=0.1 is not norm-matched. This experiment measures initialization-scale sensitivity, not robustness to arbitrary post-injection tensor operations.

AuthorsOpenReview ↗

Response to Reviewer TRmy (Part 2/2)

“Vanilla” definition, matched fine-tuning and baseline comparison, and pre-adaptation utility (Q4)

“Vanilla” denotes the original model without watermark injection or downstream fine-tuning. It serves as the reference model in Tables 1–2. SAME and the other watermarking baselines are first injected using their respective watermarking procedures. All watermarked models are then fine-tuned on the same downstream dataset using the same downstream adaptation protocol. The only difference is the watermark-injection stage: SAME is injected once on Alpaca, whereas the other baselines are injected using their task-specific watermark datasets. Thus, all watermarked methods undergo the same downstream fine-tuning and evaluation protocol, making the comparison fair.

Regarding utility before downstream adaptation, the Alpaca row in Table 2 evaluates both pathways on the Alpaca test set. Utility is the native-path BERTScore-F1, while the semantic trigger score is the private-path BERTScore-F1. The strong scores in both pathways show that the watermarked model can still produce meaningful semantic responses from public and private embeddings. This indicates that watermark injection does not prevent the model from learning useful semantic representations. BERTScore does not replace answer-level or execution-based metrics for mathematical and coding correctness.


Reuse after verification exposure (Q5)

Knowing that a model uses SAME does not reveal the private codebook. The private verification input is constructed from the secret matrix EPE_P, which is independently initialized and is never exposed through the public tokenizer or native embedding matrix. Without the codebook, an adversary cannot reconstruct the private inputs used for verification, even if the existence and general design of the watermark are known.

The codebook is also highly specific. In Appendix C, corrupting 100, 200, and 500 of its 4096 dimensions reduces private-path BERTScore-F1 from about 88.6 to 86.9, 82.7, and 76.1, respectively. Corrupting only 12.2% of the dimensions therefore makes the remaining codebook insufficient for reliable verification. Partial recovery cannot replace the exact codebook. Our threat model assumes that the owner keeps EPE_P private; we do not claim security after complete codebook leakage. Knowledge of SAME’s design or the fixed verification token does not reveal the private inputs without access to EPE_P.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

Dear Reviewers,

We sincerely thank all reviewers for their careful and constructive feedback. Your comments helped us clarify the verification protocol, the role of the private codebook, the scope of our experiments, and the relationship between SAME and existing watermarking methods.

SAME aligns the semantic expressiveness of a private codebook with the model’s semantic capabilities. Fixed trigger–response watermarks verify a limited set of predefined queries. SAME assigns a private embedding to each native token and trains the private and native pathways with shared target responses. This enables private queries to be composed across tasks and allows the private pathway to follow the model’s capabilities after downstream fine-tuning. When the underlying model has strong capabilities and the private codebook is well aligned, semantic components can be freely combined to construct new verification queries beyond a fixed test set. Our results support this design through held-out queries, random-codebook controls, downstream classification and generation tasks, cross-model experiments, and robustness evaluations.

The reviews also raised questions about verification thresholds, negative controls, benchmark metrics, baseline fairness, representation changes, codebook privacy, and watermark removal. We clarify that SAME has two complementary protocols: semantic verification evaluates the quality and consistency of private outputs, while the fixed <SAME> protocol enables direct comparison with trigger–response methods. We also explain why semantic output quality and native–private alignment are the relevant functional goals, why task performance is bounded by the underlying model, and why removing a semantically coupled watermark may affect the model’s original semantic capability.

In the revised version, we will clarify the experimental scope, add ROC/FPR and negative-baseline analyses for the fixed protocol, report conditional accuracy for mathematical and coding tasks, include the closest fixed-trigger baseline, and improve the documentation of model provenance and evaluation settings. We thank the reviewers again for helping us improve the clarity and presentation of SAME.

Best regards,
Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.