ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Huấn luyện & Alignment

AI Researcher

Đánh dấu nội dung AI

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Kỹ thuật nhúng dấu hiệu thống kê ẩn vào nội dung do AI tạo ra để xác minh nguồn gốc và phát hiện văn bản tổng hợp.

lesson98 minHuấn luyện & AlignmentAI Researcher

Dự đoán

Giáo viên có thể phát hiện bài do AI viết bằng cách nào mà không cần đọc nội dung?

AI Watermarking nhúng dấu hiệu thống kê ẩn vào văn bản: LLM ưu tiên chọn từ từ 'danh sách xanh' bí mật sinh ra từ hash(token trước). Văn bản đọc bình thường, nhưng khi phân tích tỷ lệ từ xanh cao BẤT THƯỜNG so với mức kỳ vọng 50% ngẫu nhiên → chứng tỏ do AI viết. Giống chữ ký ẩn trong bức tranh mà chỉ kính lúp mới thấy!

Khoảnh khắc A-ha

Watermark AI giống tiền giả với dải bảo mật nhúng UV — mắt thường đọc văn bản bình thường, nhưng phân tích thống kê dưới 'đèn UV' phát hiện pattern ẩn. Với tokens và tỷ lệ green % thay vì 50% ngẫu nhiên, xác suất xảy ra tự nhiên là . Nếu z-score vượt ngưỡng , ta gần như chắc chắn văn bản do AI sinh ra — và không cần đọc một chữ nào!

Thử thách nhanh

Sinh viên paraphrase 30% câu của bài do AI viết có watermark. Watermark còn phát hiện được không?

Paraphrase phá huỷ watermark trong câu bị viết lại (chuỗi token mới không còn tuân hash cũ), nhưng 70% còn lại vẫn mang dấu hiệu. Với đoạn văn >200 tokens và delta = 2.0, z-score thường vẫn vượt 3 — đủ báo động. Đây là điểm yếu rõ của watermark statistical: khắc phục bằng semantic watermark (nhúng vào nghĩa, không token).

Văn bản chỉ có 20 token, trong đó 15 token thuộc green list (75%). Có kết luận chắc chắn là AI viết không?

Với T=20, gamma=0.5, kỳ vọng green = 10, SD = sqrt(5) ≈ 2.24. Z = (15-10)/2.24 ≈ 2.24 → p ≈ 0.013. Đáng chú ý nhưng CHƯA đủ an toàn để tuyên bố watermark (thường yêu cầu p < 3×10⁻⁵, tức z > 4). Người viết bình thường có thể tình cờ đạt 75% trong một đoạn ngắn. Luôn cần đoạn ≥ 100-200 tokens để đạt confidence đáng tin.

Cách hoạt động

AI Watermarking là kỹ thuật nhúng dấu hiệu ẩn vào nội dung AI, cho phép phát hiện nguồn gốc mà không ảnh hưởng đáng kể đến chất lượng. Đây là tuyến phòng thủ quan trọng bổ trợ cho phát hiện deepfake, và đối phó với tấn công đối kháng nhằm xoá dấu nguồn gốc. Trong bối cảnh EU AI Act và quản trị AI tại Việt Nam, watermark đang trở thành yêu cầu bắt buộc đối với nội dung tổng hợp.

Công thức z-score phát hiện watermark:

z=∣g∣−γTγ(1−γ)T(∣g∣ = soˆˊ green tokens, T = tổng tokens, γ = tỷ lệ green list)z = \frac{|g| - \gamma T}{\sqrt{\gamma (1-\gamma) T}} \quad \text{(} |g| \text{ = số green tokens, } T \text{ = tổng tokens, } \gamma \text{ = tỷ lệ green list)}

Dưới giả thuyết H0 (văn bản không có watermark), số green tokens tuân theo phân phối nhị thức Binomial(T, gamma). Với T đủ lớn, z-score xấp xỉ phân phối chuẩn N(0, 1). Nếu z>4z > 4, p-value < 3×10⁻⁵ → bác bỏ H0.

Seed, hash và PRF

Trong paper gốc của Kirchenbauer, seed của RNG được sinh từ hash(last_token_id). Điều này có nghĩa: hai văn bản khác nhau cùng chứa token "the" ở vị trí i sẽ có green list giống nhau ở vị trí i+1 (với giả định cùng tokenizer và cùng khoá).

Đây là trade-off: dùng context dài hơn (hash của k token trước) giúp watermark khó đoán hơn nhưng làm tăng "biến thiên" trong green list giữa các đoạn văn, nhiều khi giảm độ tin cậy phát hiện.

Phiên bản cryptographic thay hash đơn giản bằng PRF (pseudorandom function) hoặc HMAC với khoá bí mật. Không có khoá, kẻ tấn công không thể:

  • Biết token nào là green (để thay bằng từ đồng nghĩa)
  • Huấn luyện mô hình remove watermark
  • Giả mạo văn bản "mang watermark" mà mình không sở hữu

Ví dụ: SynthID-Text của Google DeepMind dùng "tournament sampling" — mỗi token được chọn qua một cây đấu loại nhiều vòng, mỗi vòng đánh giá bằng PRF. Phân bố đầu ra gần LLM gốc (distortion-free), nhưng tín hiệu watermark đủ mạnh để phát hiện.

Các tấn công xoá watermark

1. Paraphrase attack: Viết lại từng câu bằng mô hình paraphrase (ví dụ PEGASUS hoặc GPT-4) → phá cấu trúc token. Hiệu quả 80-95% với delta nhỏ; giảm khi delta tăng.

2. Token substitution: Thay ngẫu nhiên một tỷ lệ p tokens bằng từ đồng nghĩa. Cần p > 25-30% mới phá được watermark mạnh.

3. Back-translation: Dịch sang ngôn ngữ khác rồi dịch ngược. Phá watermark rất hiệu quả nhưng giảm chất lượng.

4. Adversarial perturbation: Tìm các token perturbation nhỏ nhất giữ nguyên nghĩa nhưng lật nhiều token từ green sang red. Yêu cầu truy cập chi tiết đến watermark algorithm.

5. Editing attack: Chỉnh sửa thủ công, thêm câu, xoá câu. Nếu đủ nhiều, z-score giảm đáng kể.

Đây là cuộc chạy đua giữa watermark và paraphrase — mỗi bước tiến của bên này kéo theo bước tiến của bên kia. Giải pháp lâu dài là semantic watermark (nhúng vào embedding space) và content provenance (C2PA chuẩn).

Code mẫu và triển khai

watermark_detect.py

"""
Phát hiện watermark Kirchenbauer bằng z-score.
Yêu cầu: tokenizer của mô hình gốc, gamma đã biết.
"""
import hashlib
import numpy as np
from typing import List, Dict

def _green_list_for_context(
    prev_token_id: int,
    vocab_size: int,
    gamma: float = 0.5,
    secret_key: bytes = b"vi-edu-demo-key",
) -> set[int]:
    """Sinh green list từ hash(khoá + prev_token).
    Trả về tập các token id thuộc green list.
    """
    payload = secret_key + prev_token_id.to_bytes(8, "little")
    seed_bytes = hashlib.sha256(payload).digest()[:8]
    seed = int.from_bytes(seed_bytes, "little")
    rng = np.random.default_rng(seed)

    green_size = int(vocab_size * gamma)
    green_ids = rng.choice(vocab_size, size=green_size, replace=False)
    return set(int(x) for x in green_ids)


def detect_watermark(
    token_ids: List[int],
    vocab_size: int,
    gamma: float = 0.5,
    secret_key: bytes = b"vi-edu-demo-key",
    z_threshold: float = 4.0,
) -> Dict[str, float | bool | str]:
    """Phát hiện watermark trong một chuỗi token."""
    if len(token_ids) < 2:
        raise ValueError("Cần ít nhất 2 token để phát hiện watermark.")

    green_count = 0
    total = len(token_ids) - 1  # Bỏ token đầu (không có prev)

    for i in range(1, len(token_ids)):
        prev = token_ids[i - 1]
        green_list = _green_list_for_context(
            prev, vocab_size, gamma, secret_key,
        )
        if token_ids[i] in green_list:
            green_count += 1

    # z-score test
    expected = total * gamma
    variance = total * gamma * (1 - gamma)
    z = (green_count - expected) / np.sqrt(variance)

    # p-value xấp xỉ (1-tail)
    from scipy.stats import norm
    p_value = 1.0 - norm.cdf(z)

    confidence = (
        "cao" if z > 6.0
        else "vừa" if z > z_threshold
        else "thấp"
    )

    return {
        "z_score": float(z),
        "p_value": float(p_value),
        "green_ratio": green_count / total,
        "is_ai": bool(z > z_threshold),
        "confidence": confidence,
        "total_tokens": total,
    }


# ─────────────────────────────────────────────────────────
# Ví dụ sử dụng với tokenizer thực tế
# ─────────────────────────────────────────────────────────
if __name__ == "__main__":
    from transformers import AutoTokenizer

    tok = AutoTokenizer.from_pretrained("vinai/PhoGPT-7B5")
    text = open("suspicious_essay.txt", encoding="utf-8").read()
    ids = tok.encode(text)

    result = detect_watermark(
        token_ids=ids,
        vocab_size=tok.vocab_size,
        gamma=0.5,
    )

    print(f"Tổng tokens:     {result['total_tokens']}")
    print(f"Tỷ lệ green:     {result['green_ratio']:.3f}")
    print(f"z-score:         {result['z_score']:.2f}")
    print(f"p-value:         {result['p_value']:.2e}")
    print(f"Phán đoán:       {'AI' if result['is_ai'] else 'Người/mơ hồ'}")
    print(f"Độ tin cậy:      {result['confidence']}")

watermark_generate.py

"""
Sinh văn bản có watermark bằng logit processor.
Tương thích với Hugging Face Transformers.
"""
import torch
from transformers import LogitsProcessor


class WatermarkLogitsProcessor(LogitsProcessor):
    """Cộng delta vào logits của green tokens trước softmax.

    Triển khai theo Kirchenbauer et al., 2023.
    """

    def __init__(
        self,
        vocab_size: int,
        gamma: float = 0.5,
        delta: float = 2.0,
        secret_key: bytes = b"vi-edu-demo-key",
    ):
        self.vocab_size = vocab_size
        self.gamma = gamma
        self.delta = delta
        self.secret_key = secret_key
        self._cache: dict[int, torch.Tensor] = {}

    def _green_mask(self, prev_token: int, device: torch.device) -> torch.Tensor:
        """Trả về mask nhị phân (vocab_size,) — 1 cho green, 0 cho red."""
        if prev_token in self._cache:
            return self._cache[prev_token].to(device)

        import hashlib, numpy as np
        payload = self.secret_key + int(prev_token).to_bytes(8, "little")
        seed = int.from_bytes(
            hashlib.sha256(payload).digest()[:8], "little",
        )
        rng = np.random.default_rng(seed)
        size = int(self.vocab_size * self.gamma)
        green = rng.choice(self.vocab_size, size=size, replace=False)

        mask = torch.zeros(self.vocab_size)
        mask[green] = 1.0
        self._cache[prev_token] = mask
        return mask.to(device)

    def __call__(
        self,
        input_ids: torch.LongTensor,
        scores: torch.FloatTensor,
    ) -> torch.FloatTensor:
        # input_ids: (batch, seq_len) — seq_len có thể khác nhau giữa batch
        # scores: (batch, vocab_size) — logits cho token tiếp theo
        for i in range(input_ids.shape[0]):
            prev = int(input_ids[i, -1].item())
            mask = self._green_mask(prev, scores.device)
            scores[i] = scores[i] + self.delta * mask
        return scores


# ─────────────────────────────────────────────────────────
# Ví dụ: watermark hoá PhoGPT tiếng Việt
# ─────────────────────────────────────────────────────────
if __name__ == "__main__":
    from transformers import AutoModelForCausalLM, AutoTokenizer

    name = "vinai/PhoGPT-7B5-Instruct"
    tok = AutoTokenizer.from_pretrained(name)
    model = AutoModelForCausalLM.from_pretrained(name, torch_dtype=torch.float16)

    processor = WatermarkLogitsProcessor(
        vocab_size=tok.vocab_size, gamma=0.5, delta=2.0,
    )

    inputs = tok("Giới thiệu về vịnh Hạ Long:", return_tensors="pt")
    out = model.generate(
        **inputs,
        max_new_tokens=200,
        logits_processor=[processor],
        do_sample=True,
        top_p=0.9,
    )
    print(tok.decode(out[0], skip_special_tokens=True))

Ứng dụng

Tóm tắt

  • Watermark văn bản chia từ vựng thành green/red list sinh từ hash(token trước), cộng bias delta vào logits green khi sinh. Văn bản có watermark có tỷ lệ green cao bất thường.
  • Phát hiện bằng z-score one-proportion test: z = (|g| - γT) / √(γ(1-γ)T). z > 4 ⇔ p < 3×10⁻⁵ — gần như chắc chắn có watermark.
  • Paraphrase là tấn công hiệu quả nhất: viết lại 30-40% câu có thể giảm z-score đáng kể. Giải pháp lâu dài là semantic watermark và content provenance (C2PA).
  • Tiếng Việt bị BPE fragment → effective vocab nhỏ → cần đoạn dài hơn (200-300 tokens) và chịu watermark yếu hơn tương đối so với tiếng Anh.
  • Watermark cryptographic (SynthID-Text, Aaronson) dùng PRF với khoá bí mật, cho phép distortion-free và chống tấn công mạnh hơn, nhưng cần quản lý khoá.
  • Ứng dụng: phát hiện bài AI trong giáo dục, ghi nhãn tin tức chống tin giả, tuân thủ EU AI Act và khung pháp lý nội dung số của Việt Nam.

Continue the module

Lesson 9 of 11