最近在尝试为开源大语言模型添加水印时，发现相关资料比较零散，要么是复杂的学术论文，要么是难以直接落地的理论框架。本文将围绕OpenStamp这一专为开源大模型设计的水印方法，提供一个从原理到实战的完整指南。无论你是想保护自己微调模型的知识产权，还是希望理解如何在AI生成内容中嵌入可追溯的标记，这篇文章都能带你走通全流程。我们将从核心概念讲起，一步步搭建环境、编写代码，并最终实现一个可运行的示例，同时会深入探讨其背后的技术原理、常见问题以及工程实践中的注意事项。

1. 背景与核心概念：为什么大模型需要水印？

在深入 OpenStamp 之前，我们首先要理解“大模型水印”是什么，以及它要解决什么问题。

1.1 什么是大模型水印？

简单来说，大模型水印（Watermarking for LLMs）是一种在模型生成的文本中嵌入隐蔽、鲁棒且可检测的“标记”的技术。这个标记就像数字世界里的隐形墨水，人类读者难以察觉，但通过特定的检测算法可以准确地识别出来。

它的核心目标不是干扰文本的可读性或质量，而是为了证明一段文本是由某个特定模型（或具有特定密钥的模型）生成的。

1.2 水印要解决的核心问题

随着 ChatGPT、Claude 等闭源模型和 LLaMA、Qwen 等开源模型的普及，AI 生成内容（AIGC）已无处不在。这带来了几个亟待解决的问题：

1. 版权与溯源：我开源了一个精心微调的模型，如何防止他人用其生成内容后声称是“原创”，或用于不当用途而无法追溯？
2. 虚假信息鉴别：如何区分一段新闻或评论是来自真人还是AI，尤其是在涉及舆论、学术诚信的领域？
3. 内容滥用监管：当发现大量由AI生成的垃圾邮件、诈骗信息或恶意内容时，能否追溯到其生成源头（模型或服务提供商）？

传统的哈希、数字签名等方法不适用于概率性的、每次输出都可能变化的文本生成过程。因此，需要一种与生成过程深度融合的水印技术。

1.3 OpenStamp 的定位与特点

OpenStamp 是近年来针对开源大模型（Open-weight LLMs）提出的一种水印方案。这里的“open-weight”指的是模型权重公开可用，如 LLaMA 系列、Mistral、Qwen 等。与为商业API（如GPT-4）设计的水印不同，OpenStamp 需要考虑开源生态的特点：

• 无黑盒访问：我们无法控制模型的服务端，水印必须在本地推理时嵌入。
• 权重可修改：理论上，攻击者可以微调或修改模型权重来尝试移除水印。
• 需要轻量级：方案应易于集成到现有的推理管道中，不引入过高开销。

OpenStamp 的核心思想通常是在语言模型生成下一个词（Token）的采样阶段做文章，通过一个秘密密钥（Secret Key）来轻微地、有偏向性地扰动采样概率分布，使得生成的文本序列带有该密钥的统计特征，从而可以被检测。

2. 环境准备与版本说明

为了复现 OpenStamp 水印的嵌入和检测过程，我们需要搭建一个标准的 Python 深度学习开发环境。以下配置是经过验证的，你可以根据自己的硬件情况进行调整。

2.1 基础环境

• 操作系统：Ubuntu 20.04/22.04 LTS, macOS 12+, 或 Windows 10/11 (建议使用 WSL2)。
• Python：3.8 或 3.9 版本。3.10+ 可能存在某些库的兼容性问题，建议使用 3.9。
• 包管理：使用conda或venv创建独立的虚拟环境，强烈推荐。

2.2 核心依赖库及版本

创建一个requirements.txt文件，内容如下。这些版本是相互兼容的稳定组合。

torch>=1.12.0,<2.0.0 transformers>=4.30.0 accelerate>=0.20.0 sentencepiece>=0.1.99 bitsandbytes>=0.40.0 # 用于4/8-bit量化，非必需但推荐 scipy>=1.10.0 numpy>=1.24.0 tqdm>=4.65.0

版本关键说明：

• transformers：Hugging Face 库，用于加载和运行大模型。4.30+ 版本对新的模型架构支持更好。
• torch：PyTorch 深度学习框架。版本需与你的 CUDA 版本匹配（如果使用GPU）。
• accelerate：简化分布式训练和推理，能更优雅地处理大模型加载。
• bitsandbytes：如果你计划在消费级GPU上运行大模型（如 24GB 显存运行 13B 模型），这个库提供的量化功能至关重要。

2.3 安装命令

在终端中执行以下步骤：

# 1. 创建并激活虚拟环境 (以 conda 为例) conda create -n openstamp python=3.9 -y conda activate openstamp # 2. 安装 PyTorch (请根据 CUDA 版本去官网选择命令) # 例如，对于 CUDA 11.8 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 3. 安装其他依赖 pip install -r requirements.txt

2.4 模型准备

我们将以Meta 的 LLaMA-2-7B-Chat模型为例。你需要从 Hugging Face Model Hub 获取访问权限并下载模型。

1. 访问 LLaMA-2 页面 ，同意许可协议。
2. 使用 Hugging Face CLI 登录：

   huggingface-cli login

   输入你的 Access Token。
3. 模型会在代码首次运行时自动下载，但为了网络稳定，也可以预先下载：

   python -c “from transformers import AutoModelForCausalLM; AutoModelForCausalLM.from_pretrained(‘meta-llama/Llama-2-7b-chat-hf’)”

3. OpenStamp 核心原理拆解

OpenStamp 并非一个单一的算法，而是一类方法的代表。其核心通常基于“绿色列表（Green-list）”水印思想。我们来深入拆解其工作原理。

3.1 水印嵌入：如何“悄无声息”地影响生成？

假设我们有一个语言模型，在生成每个新 token 时，它会输出一个覆盖整个词表的概率分布 ( P )。标准采样（如核采样、温度采样）会从这个分布中选取下一个 token。

OpenStamp 水印嵌入过程如下：

1. 密钥生成：使用一个固定的秘密密钥（如一个字符串或随机数种子）初始化一个哈希函数或伪随机数生成器（PRNG）。这个密钥是水印的灵魂，必须保密。
2. 上下文哈希：对于当前要生成的 token，将已有的生成文本（或部分上下文）与秘密密钥一起，通过哈希函数计算出一个哈希值。
3. 划分词表：利用这个哈希值，将整个词表（Vocabulary）伪随机地划分为两个子集：“绿色列表（Green-list）”和“红色列表（Red-list）”。划分规则是确定性的，即相同的（上下文+密钥）总是产生相同的划分。
4. 偏置采样：在采样前，我们人为地提升绿色列表中所有 token 的 logit（未归一化的概率分数），增加一个固定的偏置值 ( \delta )（例如，δ=2.0）。 [ \text{logits}{\text{green}} = \text{logits}{\text{green}} + \delta ]
5. 重新归一化与采样：对偏置后的 logits 进行 softmax 重新计算概率分布，然后进行采样。这样，绿色列表中的 token 被选中的概率就显著提高了。

关键点：偏置 ( \delta ) 很小，不会让生成文本变得不通顺，但会引入一个可检测的统计信号——在带水印的文本中，绿色列表 token 的出现频率会高于其原本的概率预期。

3.2 水印检测：如何判断一段文本“带水印”？

检测端不需要原始模型，只需要相同的秘密密钥和偏置值 δ。

1. 模拟划分：对于待检测文本中的每一个 token（除了第一个），使用相同的密钥和该 token 之前的上下文，模拟出生成它时应该存在的“绿色列表”。
2. 统计检验：检查这个 token 是否落在了它对应的“绿色列表”中。统计整段文本中，落在绿色列表的 token 比例（称为z-score或绿色比例）。
3. 假设检验：
   • 零假设（H0）：文本是自然生成的（无水印），绿色列表 token 的比例应接近 50%（因为划分是随机的）。
   • 备择假设（H1）：文本带水印，绿色比例应显著高于 50%。
4. 计算 p 值：根据二项分布或正态近似，计算观测到的绿色比例（或更高）在零假设下发生的概率（p-value）。
5. 做出判断：如果 p 值小于一个显著性水平（如 0.01），我们就拒绝零假设，认为文本很可能带有该密钥的水印。

3.3 与其它水印方案的对比

• KGW 水印：由 Kirchenbauer 等人提出，是绿色列表方法的开创性工作。OpenStamp 可视为其在开源模型场景下的具体实现和优化。
• API 水印：如 GPT 系列可能使用的水印，依赖于服务端的黑盒控制，用户不可知也不可控。
• 密码学水印：在输出中直接插入特殊字符或不可见字符，容易被过滤或破坏，鲁棒性差。

OpenStamp/KGW 水印的优势在于其统计不可见性和白盒可验证性（只要知道密钥）。

4. 完整实战：为 LLaMA2 实现 OpenStamp 水印

现在，我们将理论付诸实践。我们将创建一个OpenStampWatermark类，实现水印的嵌入和检测，并用 LLaMA-2-7B-Chat 模型进行演示。

4.1 项目结构

创建如下目录和文件：

openstamp_demo/ ├── watermark.py # 水印核心逻辑类 ├── demo_generate.py # 带水印文本生成演示 ├── demo_detect.py # 水印检测演示 ├── requirements.txt # 依赖文件 └── README.md

4.2 实现水印逻辑 (watermark.py)

这是最核心的文件，包含了水印嵌入器和检测器。

# watermark.py import torch import hashlib from scipy import stats from typing import List, Optional import numpy as np class OpenStampWatermark: """ OpenStamp 水印实现 (基于绿色列表方法)。 """ def __init__(self, vocab_size: int, gamma: float = 0.5, delta: float = 2.0, seeding_scheme: str = “self_hash”): """ 初始化水印器。 参数: vocab_size: 模型词表大小。 gamma: 绿色列表占词表的比例 (默认0.5)。 delta: 添加到绿色列表token的logit偏置值 (默认2.0)。 seeding_scheme: 生成随机种子的方案。“self_hash”使用上下文哈希。 """ self.vocab_size = vocab_size self.gamma = gamma # 绿色列表比例 self.delta = delta # 偏置强度 self.seeding_scheme = seeding_scheme self.green_list_size = int(vocab_size * gamma) self.red_list_size = vocab_size - self.green_list_size def _get_green_list_ids(self, input_ids: torch.LongTensor, secret_key: int) -> torch.LongTensor: """ 根据当前上下文和密钥，确定绿色列表的token id。 参数: input_ids: 当前已生成的token id序列 (形状: [seq_len])。 secret_key: 整数形式的秘密密钥。 返回: green_list_ids: 绿色列表的token id张量。 """ # 将上下文和密钥组合成一个字符串用于哈希 if self.seeding_scheme == “self_hash”: # 使用最后一个token和密钥生成种子 (简化版，实际可更复杂) seed = int(hashlib.sha256( f“{input_ids[-1].item() if len(input_ids) > 0 else 0}_{secret_key}”.encode() ).hexdigest(), 16) % (2**32) else: seed = secret_key # 使用种子初始化一个随机状态，用于划分词表 rng = np.random.RandomState(seed) all_indices = np.arange(self.vocab_size) rng.shuffle(all_indices) # 取前 green_list_size 个作为绿色列表 green_indices = all_indices[:self.green_list_size] return torch.from_numpy(green_indices.copy()).to(input_ids.device) def apply_watermark(self, logits: torch.FloatTensor, input_ids: torch.LongTensor, secret_key: int) -> torch.FloatTensor: """ 将水印应用于模型输出的logits上。 参数: logits: 模型输出的原始logits (形状: [batch_size, vocab_size])。 input_ids: 当前已生成的token id序列 (形状: [batch_size, seq_len])。 secret_key: 秘密密钥。 返回: watermarked_logits: 应用了绿色列表偏置后的logits。 """ # 我们假设 batch_size = 1 以简化处理 assert logits.shape[0] == 1, “目前仅支持 batch_size=1” current_input_ids = input_ids[0] # [seq_len] green_list_ids = self._get_green_list_ids(current_input_ids, secret_key) # [green_list_size] # 创建绿色列表掩码 green_mask = torch.zeros(self.vocab_size, dtype=torch.bool, device=logits.device) green_mask[green_list_ids] = True # 将偏置 delta 加到绿色列表的logits上 watermarked_logits = logits.clone() # watermarked_logits[0, green_mask] += self.delta # 更安全的索引方式 watermarked_logits = watermarked_logits.clone() watermarked_logits[:, green_mask] += self.delta return watermarked_logits def detect_watermark(self, text_ids: torch.LongTensor, secret_key: int) -> dict: """ 检测给定token id序列是否包含水印。 参数: text_ids: 待检测的token id序列 (形状: [seq_len])。 secret_key: 用于检测的秘密密钥 (必须与嵌入时相同)。 返回: result: 包含检测统计信息的字典。 """ seq_len = len(text_ids) if seq_len < 2: return {“score”: 0.0, “p_value”: 1.0, “is_watermarked”: False, “msg”: “序列太短”} green_count = 0 # 遍历每个位置（除了第一个，因为它没有“前文”上下文） for i in range(1, seq_len): prefix_ids = text_ids[:i] # 当前token的前文 green_list_ids = self._get_green_list_ids(prefix_ids, secret_key) if text_ids[i] in green_list_ids: green_count += 1 green_fraction = green_count / (seq_len - 1) # 假设检验：在零假设（无水印）下，每个token落入绿色列表的概率是 gamma # 计算 z-score 和 p-value (使用正态近似) expected_green = self.gamma std_dev = np.sqrt(expected_green * (1 - expected_green) / (seq_len - 1)) if std_dev > 0: z_score = (green_fraction - expected_green) / std_dev # 单边检验（绿色比例是否显著大于预期） p_value = 1 - stats.norm.cdf(z_score) else: z_score = 0.0 p_value = 1.0 # 通常 p_value < 0.01 认为检测到水印 is_watermarked = p_value < 0.01 return { “green_fraction”: green_fraction, “expected_fraction”: expected_green, “z_score”: z_score, “p_value”: p_value, “is_watermarked”: is_watermarked, “green_count”: green_count, “total_tested”: seq_len - 1 }

4.3 带水印的文本生成 (demo_generate.py)

这个脚本演示如何加载模型，并在生成时应用我们实现的水印。

# demo_generate.py import torch from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline from watermark import OpenStampWatermark # 1. 加载模型和分词器 model_name = “meta-llama/Llama-2-7b-chat-hf” print(f“正在加载模型和分词器: {model_name}...”) tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.float16, # 半精度节省显存 device_map=“auto”, # 自动分配模型层到GPU/CPU load_in_8bit=True, # 使用8-bit量化 (需要bitsandbytes) ) print(“模型加载完成。”) # 2. 初始化水印器 vocab_size = tokenizer.vocab_size watermarker = OpenStampWatermark(vocab_size=vocab_size, gamma=0.5, delta=2.0) # 3. 定义生成参数和水印密钥 SECRET_KEY = 12345 # 这是你的秘密密钥，必须保管好！ generation_config = { “max_new_tokens”: 150, “do_sample”: True, “temperature”: 0.7, “top_p”: 0.9, } # 4. 自定义生成函数，在每一步干预logits def generate_with_watermark(prompt, watermarker, secret_key): inputs = tokenizer(prompt, return_tensors=“pt”).to(model.device) input_ids = inputs[“input_ids”] attention_mask = inputs[“attention_mask”] generated_ids = input_ids.clone() past_key_values = None print(“正在生成带水印的文本...”) for _ in range(generation_config[“max_new_tokens”]): with torch.no_grad(): outputs = model( input_ids=generated_ids if past_key_values is None else None, attention_mask=torch.ones_like(generated_ids) if past_key_values is None else None, past_key_values=past_key_values, use_cache=True ) next_token_logits = outputs.logits[:, -1, :] # [batch_size, vocab_size] past_key_values = outputs.past_key_values # === 关键步骤：应用水印 === watermarked_logits = watermarker.apply_watermark( next_token_logits.unsqueeze(0), # 保持batch维度 generated_ids, secret_key ) watermarked_logits = watermarked_logits.squeeze(0) # [vocab_size] # 应用温度采样和top-p过滤 if generation_config[“temperature”] != 1.0: watermarked_logits = watermarked_logits / generation_config[“temperature”] if generation_config[“top_p”] < 1.0: sorted_logits, sorted_indices = torch.sort(watermarked_logits, descending=True) cumulative_probs = torch.cumsum(torch.softmax(sorted_logits, dim=-1), dim=-1) sorted_indices_to_remove = cumulative_probs > generation_config[“top_p”] sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone() sorted_indices_to_remove[..., 0] = 0 indices_to_remove = sorted_indices[sorted_indices_to_remove] watermarked_logits[indices_to_remove] = -float(“Inf”) # 从处理后的分布中采样下一个token probs = torch.softmax(watermarked_logits, dim=-1) next_token_id = torch.multinomial(probs, num_samples=1) # 将新token添加到序列中 generated_ids = torch.cat([generated_ids, next_token_id], dim=-1) # 如果生成了结束符，则停止 if next_token_id.item() == tokenizer.eos_token_id: break generated_text = tokenizer.decode(generated_ids[0], skip_special_tokens=True) return generated_text # 5. 运行生成 prompt = “““### Human: 请用中文解释一下什么是机器学习？ ### Assistant: ””” watermarked_text = generate_with_watermark(prompt, watermarker, SECRET_KEY) print(“\n” + “=”*50) print(“【带水印的生成结果】”) print(“=”*50) print(f“输入提示: {prompt}”) print(f“生成文本: {watermarked_text}”) print(“=”*50) # 6. 保存生成结果（可选） with open(“watermarked_output.txt”, “w”, encoding=“utf-8”) as f: f.write(watermarked_text) print(“结果已保存到 watermarked_output.txt”)

4.4 水印检测 (demo_detect.py)

这个脚本演示如何检测一段文本是否包含特定密钥的水印。

# demo_detect.py from transformers import AutoTokenizer from watermark import OpenStampWatermark # 1. 加载相同的分词器 model_name = “meta-llama/Llama-2-7b-chat-hf” tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True) # 2. 初始化水印检测器 (参数必须与生成时一致!) vocab_size = tokenizer.vocab_size watermark_detector = OpenStampWatermark(vocab_size=vocab_size, gamma=0.5, delta=2.0) # 3. 定义密钥 (必须与生成时相同!) SECRET_KEY = 12345 # 4. 待检测的文本 (这里读取刚才生成的文件，你也可以直接粘贴文本) try: with open(“watermarked_output.txt”, “r”, encoding=“utf-8”) as f: text_to_check = f.read().strip() except FileNotFoundError: # 如果文件不存在，使用一个示例文本 text_to_check = “机器学习是人工智能的一个分支，它使计算机系统能够从数据中学习和改进，而无需进行明确的编程。它主要依赖于算法和统计模型来识别模式、做出预测或决策。” print(“未找到生成文件，使用示例文本进行检测。”) print(f“待检测文本: {text_to_check[:100]}...”) # 打印前100字符 # 5. 将文本转换为token ids input_ids = tokenizer.encode(text_to_check, return_tensors=“pt”).squeeze(0) # [seq_len] # 6. 执行检测 detection_result = watermark_detector.detect_watermark(input_ids, SECRET_KEY) # 7. 打印检测报告 print(“\n” + “=”*50) print(“【水印检测报告】”) print(“=”*50) print(f“检测文本长度 (token数): {len(input_ids)}”) print(f“绿色列表token计数: {detection_result[‘green_count’]} / {detection_result[‘total_tested’]}”) print(f“绿色比例: {detection_result[‘green_fraction’]:.4f} (预期: {detection_result[‘expected_fraction’]:.4f})”) print(f“Z-score: {detection_result[‘z_score’]:.4f}”) print(f“P-value: {detection_result[‘p_value’]:.10f}”) print(f“是否检测到水印 (p<0.01)?: {detection_result[‘is_watermarked’]}”) print(“=”*50) # 8. 解释结果 if detection_result[‘is_watermarked’]: print(“✅ 结论：在该文本中检测到了与密钥匹配的水印信号。”) else: if detection_result[‘p_value’] < 0.05: print(“⚠️ 提示：存在统计异常，但未达到强置信度 (p<0.01)。可能水印强度较弱，或密钥错误。”) else: print(“❌ 结论：未在该文本中检测到与密钥匹配的水印信号。文本可能为自然生成，或使用了不同的密钥。”)

4.5 运行与结果说明

1. 运行生成脚本：

   python demo_generate.py

   首次运行会下载模型，需要较长时间和足够磁盘空间。生成完成后，你会看到一段关于机器学习的解释文本，并被保存到watermarked_output.txt。

2. 运行检测脚本：

   python demo_detect.py

   你会看到一份详细的检测报告。如果一切正常，is_watermarked字段应为True，并且 p-value 会非常小（例如< 1e-10）。

3. 验证水印特异性： 修改demo_detect.py中的SECRET_KEY（例如改为54321），再次运行检测。你会发现is_watermarked变为False，p-value 会变大（接近0.5），这说明水印检测是密钥依赖的，只有知道正确密钥的人才能验证。

4. 测试自然文本： 找一段人类写的文本（例如从新闻网站复制一段），用检测脚本跑一下。大概率会得到“未检测到水印”的结果，因为其绿色token比例不会显著偏离50%。

5. 常见问题与排查思路

在实际部署和测试 OpenStamp 水印时，你可能会遇到以下问题。

6. 最佳实践与工程建议

将 OpenStamp 水印集成到实际项目中时，需要考虑以下工程化问题。

6.1 密钥管理

• 保密性：水印的安全完全依赖于密钥的保密。切勿将密钥硬编码在客户端代码或公开仓库中。
• 密钥派生：可以使用一个主密钥，结合模型ID、用户ID或时间戳等信息，通过密钥派生函数（KDF）生成每次生成或每个用户独有的子密钥，增强追踪能力。
• 轮换策略：定期轮换密钥，但需注意，旧密钥生成的水印需要用旧密钥检测。

6.2 参数调优

• delta(强度)：在文本质量和检测鲁棒性之间权衡。建议从 1.0 开始，在目标模型上生成一些文本，人工评估可读性，然后进行检测威力测试。
• gamma(绿色比例)：0.5 是理论最优值（检测信号最强）。除非有特殊理由，否则不要改动。
• 上下文哈希：我们示例中使用最后一个token的简化方案。生产环境应使用更健壮的哈希方案，例如将前k个token与密钥一起哈希，以防止某些攻击。

6.3 集成到生产推理管道

示例中的逐token生成是为了清晰，但效率低。正确做法是集成到 Transformers 库的generation流程中：

from transformers import LogitsProcessor class WatermarkLogitsProcessor(LogitsProcessor): def __init__(self, watermarker, secret_key): self.watermarker = watermarker self.secret_key = secret_key self.generated_sequence = [] def __call__(self, input_ids, scores): # 注意：这里需要处理batch维度，并维护生成历史 # 简化逻辑：将当前input_ids传递给watermarker.apply_watermark # ... return watermarked_scores # 在调用 model.generate() 时使用 from transformers import GenerationConfig generation_config = GenerationConfig( max_new_tokens=150, do_sample=True, temperature=0.7, logits_processor=[WatermarkLogitsProcessor(watermarker, SECRET_KEY)] ) outputs = model.generate(inputs[“input_ids”], generation_config=generation_config)

6.4 鲁棒性考量与攻击防御

水印可能面临多种攻击：

1. ** paraphrasing (重述)**：攻击者使用另一个模型（或人工）对带水印文本进行重写。OpenStamp 对此类攻击的鲁棒性有限，因为重写会破坏基于原始 token 序列的统计特征。
   • 缓解：增加水印强度delta，或研究更高级的、对语义保持不变的扰动方法。
2. 编辑攻击：随机插入、删除、替换少量词语。
   • 测试：我们的检测方法对少量编辑有一定鲁棒性，因为大部分 token 及其上下文得以保留。可以进行压力测试，模拟不同编辑比例下的检测率。
3. 多模型混合：攻击者从多个带水印的生成结果中拼接文本。
   • 检测：可以尝试对文本分段进行检测。
4. 密钥猜测/泄露：如果密钥空间小，可能被暴力破解。
   • 防御：使用足够长且随机的密钥（如256位加密密钥）。

6.5 性能与可扩展性

• 计算开销：水印嵌入和检测的主要开销在于为每个 token 计算哈希和划分词表。对于万级别词表，这是轻量级的操作，对生成速度影响很小（通常 < 5%）。
• 批量处理：确保你的水印逻辑支持批量生成，这对高并发服务至关重要。
• 检测服务：可以将检测功能封装为 REST API 服务，供其他系统调用，用于内容审核或溯源。

6.6 伦理与合规

• 透明度：如果对用户生成的内容添加水印，应考虑在服务条款中明确告知。
• 用途：将水印技术用于版权保护、内容溯源等正当目的。避免用于不道德的监控或审查。
• 不可否认性：水印提供了“这段文本来自这个模型/密钥”的证据，但并非绝对法律证据，需结合其他日志信息。

通过以上步骤，你不仅能够运行一个 OpenStamp 水印的演示，更能理解其内在机制，并知道如何将其适配到自己的开源大模型项目中。水印技术是AIGC治理工具箱中的重要一环，合理使用能在促进开源共享的同时，保护开发者的权益。