Prompt-Tuning 入门：四范式与提示学习

# -*- coding: utf-8 -*-
"""手搓一遍 Pattern-Verbalizer-Pair：把分类样本变成完形填空样本。

纯标准库可跑。跑完你会看到：所谓 Prompt-Tuning 的「输入构造」，
本质就是字符串拼接 + 一张标签词映射表，没有任何魔法。
"""

# Pattern：带 [MASK] 的短文本，{x} 是原句的占位
PATTERNS = {
    "p1": "{x} 整体感觉是[MASK]的。",
    "p2": "{x} 这是一条[MASK]评。",
    "p3": "评论：{x} 情感：[MASK]。",
}

# Verbalizer：标签词 -> 类别。一个类别可以挂多个标签词
VERBALIZER = {
    "正面": ["好", "棒", "赞"],
    "负面": ["差", "烂", "糟"],
}

SAMPLES = [
    ("这部电影很好看。", "正面"),
    ("剧情拖沓，看了半小时就想走。", "负面"),
    ("演员表演到位，节奏也舒服。", "正面"),
]


def build_input(sentence, pattern_key="p1"):
    """把原句套进 Pattern，得到送进 BERT 的那一串 token 文本。"""
    body = PATTERNS[pattern_key].format(x=sentence)
    return "[CLS] " + body + " [SEP]"


def label_to_words(label):
    """训练时要知道 [MASK] 位置的正确答案是哪些词。"""
    if label not in VERBALIZER:
        raise KeyError("Verbalizer 里没有类别 %r，模型无从学起" % label)
    return VERBALIZER[label]


def word_to_label(word):
    """推理时把 [MASK] 预测出来的词翻译回类别。"""
    for label, words in VERBALIZER.items():
        if word in words:
            return label
    # 落到映射表外面的词，必须显式暴露，不能悄悄当成某一类
    return None


def main():
    print("【一、Pattern 把分类题拼成了填空题】")
    for sent, label in SAMPLES:
        text = build_input(sent, "p1")
        print("  原句 : %s" % sent)
        print("  输入 : %s" % text)
        print("  标签 : %s -> [MASK] 的正确答案可以是 %s" % (label, label_to_words(label)))
        print()

    print("【二、同一句话换三个 Pattern，模型看到的东西完全不同】")
    sent = SAMPLES[0][0]
    for key in PATTERNS:
        print("  %s: %s" % (key, build_input(sent, key)))
    print()

    print("【三、Verbalizer 是双向的】")
    for word in ["好", "棒", "烂", "一般"]:
        label = word_to_label(word)
        shown = label if label else "映射表里没有 -> 必须当作无法判定，而不是硬塞给某一类"
        print("  [MASK] 预测出 %r -> %s" % (word, shown))
    print()

    # 断言：映射表不能有一个词同时指向两个类别，否则推理会自相矛盾
    seen = {}
    for label, words in VERBALIZER.items():
        for w in words:
            assert w not in seen, "标签词 %r 同时属于 %s 和 %s，映射必然出错" % (w, seen[w], label)
            seen[w] = label
    print("映射表自检通过：%d 个标签词，没有一个词跨类别。" % len(seen))


if __name__ == "__main__":
    main()

# -*- coding: utf-8 -*-
"""四种范式的同一件事：都在做「情感二分类」，区别在于谁去迁就谁。

纯标准库，直接 python3 paradigm_compare.py 就能跑，用来把四范式从
「背四句话」变成「看得见的输入长什么样」。
"""

SENT = "这部电影很好看。"

# 每种范式：模型怎么拿到输入、谁的参数在动、需要多少标注数据
PARADIGMS = [
    {
        "no": "第一范式",
        "name": "传统机器学习",
        "stack": "TF-IDF 特征 + 朴素贝叶斯",
        "model_input": "['电影', '好看'] 这类稀疏特征向量",
        "trainable": "分类器全部参数（模型很小）",
        "data": "大量标注（几千到几万条）",
        "pain": "特征全靠人工设计，换个任务要重做特征工程",
    },
    {
        "no": "第二范式",
        "name": "深度学习",
        "stack": "word2vec + LSTM",
        "model_input": "词向量序列 [768 维 × 句长]",
        "trainable": "整个网络（随机初始化）",
        "data": "大量标注（上万条）",
        "pain": "特征工程少了，但网络从零学起，数据还是要得多",
    },
    {
        "no": "第三范式",
        "name": "预训练 + Fine-Tuning",
        "stack": "BERT + 新增分类头",
        "model_input": "[CLS] 这部电影很好看。[SEP]",
        "trainable": "BERT 全部参数 + 新分类头",
        "data": "中等标注（几百到几千条）",
        "pain": "预训练学的是完形填空，下游学的是分类，两个目标对不上",
    },
    {
        "no": "第四范式",
        "name": "预训练 + Prompt + 预测",
        "stack": "BERT + Pattern + Verbalizer",
        "model_input": "[CLS] 这部电影很好看。[SEP] 整体感觉是[MASK]的。[SEP]",
        "trainable": "复用预训练的 MLM 头，不新增分类层",
        "data": "少量标注，甚至零样本",
        "pain": "模板和标签词怎么选，成了新的难题",
    },
]


def show():
    for p in PARADIGMS:
        print("=" * 68)
        print("%s · %s" % (p["no"], p["name"]))
        print("  技术栈      : %s" % p["stack"])
        print("  模型看到的  : %s" % p["model_input"])
        print("  在动的参数  : %s" % p["trainable"])
        print("  标注数据    : %s" % p["data"])
        print("  代价        : %s" % p["pain"])
    print("=" * 68)


def check():
    """第三、第四范式的关键差别：输入里有没有 [MASK]。"""
    third = PARADIGMS[2]["model_input"]
    fourth = PARADIGMS[3]["model_input"]
    assert "[MASK]" not in third, "第三范式靠分类头，输入里不该有 [MASK]"
    assert "[MASK]" in fourth, "第四范式靠完形填空，输入里必须有 [MASK]"
    # 第四范式的输入 = 第三范式的输入 + 一段模板
    assert fourth.startswith(third), "第四范式只是在原输入后面又拼了一段模板"
    extra = fourth[len(third):]
    print("第四范式比第三范式多出来的那一段模板：%r" % extra)
    print("它没有改动原句一个字，只是把「分类」改写成了「填空」。")


if __name__ == "__main__":
    print("待处理的句子：%s\n" % SENT)
    show()
    print()
    check()

# -*- coding: utf-8 -*-
"""从 [MASK] 的词表分布，到最终类别：Verbalizer 那一步到底算了什么。

纯标准库（只用 math），可以直接跑。这里的 logits 是写死的演示值，
目的是让「MLM 头输出 -> 类别概率」这条路径每一步都能手算核对。
"""
import math

# 模型在 [MASK] 位置对整个词表打的分（只列出我们关心的几个词）
MASK_LOGITS = {
    "好": 6.2,
    "棒": 5.1,
    "赞": 3.4,
    "差": 1.8,
    "烂": 1.2,
    "糟": 0.9,
    "的": 5.9,   # 高频虚词，分数很高，但它不在标签词里
    "很": 4.7,
}

VERBALIZER = {
    "正面": ["好", "棒", "赞"],
    "负面": ["差", "烂", "糟"],
}


def softmax(scores):
    m = max(scores.values())
    exp = {k: math.exp(v - m) for k, v in scores.items()}
    total = sum(exp.values())
    return {k: v / total for k, v in exp.items()}


def label_scores(logits, verbalizer, mode="max"):
    """把标签词的分数汇总成类别分数。

    mode='max' 取该类别下最高的标签词分数；
    mode='sum' 把该类别下所有标签词的概率加起来。
    两种都常见，但必须全程用同一种，混用会得到不可比的数字。
    """
    if mode == "max":
        return {lab: max(logits[w] for w in words if w in logits)
                for lab, words in verbalizer.items()}
    probs = softmax(logits)
    return {lab: sum(probs[w] for w in words if w in probs)
            for lab, words in verbalizer.items()}


def main():
    print("【一、词表上的完整分布（含无关词）】")
    full = softmax(MASK_LOGITS)
    for w, p in sorted(full.items(), key=lambda kv: -kv[1]):
        mark = "  <- 标签词" if any(w in ws for ws in VERBALIZER.values()) else ""
        print("  %-3s logit=%.1f  p=%.4f%s" % (w, MASK_LOGITS[w], p, mark))
    print("  注意：概率最高的是「的」，它根本不是标签词。")
    print("  所以不能直接取 argmax，必须先把范围收缩到标签词上。\n")

    print("【二、只在标签词之间比较（max 汇总）】")
    ls = label_scores(MASK_LOGITS, VERBALIZER, "max")
    for lab, s in ls.items():
        print("  %s : 最高标签词 logit = %.1f" % (lab, s))
    picked = max(ls, key=ls.get)
    print("  判定结果 -> %s\n" % picked)

    print("【三、换成 sum 汇总，结论是否一样】")
    ls2 = label_scores(MASK_LOGITS, VERBALIZER, "sum")
    for lab, s in ls2.items():
        print("  %s : 标签词概率之和 = %.4f" % (lab, s))
    picked2 = max(ls2, key=ls2.get)
    print("  判定结果 -> %s" % picked2)

    assert picked == picked2 == "正面", "两种汇总方式在本例中应给出相同结论"
    print("\n两种汇总方式结论一致，但数值不可互相比较——报指标时要说明用了哪一种。")

    # 这一步才是 Prompt-Tuning 训练时算 loss 的地方
    pos_p = ls2["正面"] / (ls2["正面"] + ls2["负面"])
    print("归一化到两类之后，正面的概率 = %.4f" % pos_p)
    print("交叉熵损失（真实标签为正面）= %.6f" % (-math.log(pos_p)))


if __name__ == "__main__":
    main()

# -*- coding: utf-8 -*-
"""模板敏感性：同一个任务，六种写法，模型给的答案可能完全不同。

这是 Hard Prompt 最大的软肋，也是后面 Soft Prompt 出现的直接原因。
本脚本不联网、不调模型，它做的是另一件更有用的事：
把六个模板的结构差异量化出来，让你看清「差异到底出在哪」。
"""

SENT = "剧情拖沓，看了半小时就想走。"

TEMPLATES = [
    ("T1", "{x} 整体感觉是[MASK]的。", ["好", "差"]),
    ("T2", "{x} 这是一条[MASK]评。", ["好", "差"]),
    ("T3", "{x} 我的评价：[MASK]。", ["正面", "负面"]),
    ("T4", "[MASK]。{x}", ["好", "差"]),
    ("T5", "{x} It was [MASK].", ["good", "bad"]),
    ("T6", "{x}[MASK]", ["好", "差"]),
]


def render(tpl, sent):
    return tpl.format(x=sent)


def template_gap(tpl):
    """模板自己在 {x} 与 [MASK] 之间插了什么。

    只看渲染后的文本会被原句自带的句号干扰，所以要在模板层面判。
    若 [MASK] 在 {x} 前面（如 T4），返回 None 表示不适用。
    """
    xi, mi = tpl.find("{x}"), tpl.find("[MASK]")
    if xi < 0 or mi < 0 or mi < xi:
        return None
    return tpl[xi + len("{x}"):mi]


def describe(name, tpl, sent, words):
    text = render(tpl, sent)
    pos = text.index("[MASK]")
    gap = template_gap(tpl)
    return {
        "name": name,
        "tpl": tpl,
        "text": text,
        "len": len(text),
        "mask_at": pos,
        "mask_ratio": pos / len(text),
        "words": words,
        "word_lang": "英文" if any(w.isascii() for w in words) else "中文",
        "gap": gap,
        "gap_desc": "[MASK] 在句首" if gap is None else (repr(gap) if gap else "紧贴（空）"),
    }


def main():
    rows = [describe(n, t, SENT, w) for n, t, w in TEMPLATES]

    print("句子：%s\n" % SENT)
    print("%-4s %-6s %-10s %-6s %-14s %s"
          % ("模板", "总长", "[MASK]位置", "语言", "模板插入的间隔", "拼出来的输入"))
    for r in rows:
        print("%-4s %-6d %-10d %-6s %-14s %s"
              % (r["name"], r["len"], r["mask_at"], r["word_lang"],
                 r["gap_desc"], r["text"]))

    print("\n【差异出在哪】")
    print("· T4 把 [MASK] 放到了句首，模型还没读到评论就要作答，位置信息完全变了。")
    print("· T5 换成英文模板配英文标签词，中文预训练模型在这条路上几乎学不到东西。")
    print("· T6 没有任何分隔符，[MASK] 直接粘在句号后面，切词结果会变。")

    # 把可量化的部分做成断言，避免嘴上说说
    t1 = next(r for r in rows if r["name"] == "T1")
    t4 = next(r for r in rows if r["name"] == "T4")
    assert t1["mask_at"] > t4["mask_at"], "T4 的 [MASK] 必须比 T1 更靠前"
    t6 = next(r for r in rows if r["name"] == "T6")
    assert t6["gap"] == "", "T6 的模板在 {x} 与 [MASK] 之间不应插入任何字符"
    assert t1["gap"].startswith(" "), "T1 的模板靠一个空格把原句和模板隔开"
    assert t4["gap"] is None, "T4 的 [MASK] 在原句之前，间隔不适用"

    print("\n【结论】")
    print("六个模板表达的是同一个意思，但送进模型的 token 序列长度、")
    print("[MASK] 的位置、标签词所在语言全都不同——效果自然会差出一截。")
    print("人工挑模板成本高、方差大，这正是 Soft Prompt 要解决的问题。")


if __name__ == "__main__":
    main()

# -*- coding: utf-8 -*-
"""Hard Prompt 与 Soft Prompt 在「送进模型之前」到底差在哪一步。

结论先摆出来：差别不在模型，在 embedding 这一层之前还是之后。
Hard Prompt 是先有文字再查表；Soft Prompt 直接就是表里查不到的向量。
纯标准库可跑，用小维度把形状算清楚。
"""

HIDDEN = 8          # 真实模型是 768/4096，这里缩小成 8 方便打印
VOCAB = {"[CLS]": 0, "[SEP]": 1, "[MASK]": 2, "这": 3, "部": 4,
         "电": 5, "影": 6, "很": 7, "好": 8, "看": 9, "。": 10,
         "整": 11, "体": 12, "感": 13, "觉": 14, "是": 15, "的": 16}


def fake_embedding(token_id):
    """假装这是 embedding table 的一行，真实值由预训练得到。"""
    return [round((token_id * 0.37 + i * 0.11) % 1.0, 3) for i in range(HIDDEN)]


def tokenize(text):
    """按字切，未登录字一律记为 [UNK]（这里用 -1 表示）。"""
    ids = []
    i = 0
    while i < len(text):
        for special in ("[CLS]", "[SEP]", "[MASK]"):
            if text.startswith(special, i):
                ids.append(VOCAB[special])
                i += len(special)
                break
        else:
            ch = text[i]
            ids.append(VOCAB.get(ch, -1))
            i += 1
    return ids


def hard_prompt_path(sentence):
    """Hard Prompt：模板是真实文字，和原句一起过 tokenizer、一起查 embedding。"""
    text = "[CLS]" + sentence + "整体感觉是[MASK]的。[SEP]"
    ids = tokenize(text)
    vectors = [fake_embedding(i) if i >= 0 else [0.0] * HIDDEN for i in ids]
    return text, ids, vectors


def soft_prompt_path(sentence, prompt_len=5):
    """Soft Prompt：伪标记没有文字，也不查 embedding table，直接是可训练参数。"""
    text = "[CLS]" + sentence + "[SEP]"
    ids = tokenize(text)
    sent_vecs = [fake_embedding(i) if i >= 0 else [0.0] * HIDDEN for i in ids]
    # 伪标记向量：训练开始时随机初始化，之后被梯度一路更新
    pseudo = [[round(0.01 * (k + 1) + 0.002 * j, 4) for j in range(HIDDEN)]
              for k in range(prompt_len)]
    return text, pseudo + sent_vecs, pseudo


def main():
    sent = "这部电影很好看。"

    print("【Hard Prompt 这条路】")
    text, ids, vecs = hard_prompt_path(sent)
    print("  拼出来的文字 : %s" % text)
    print("  token id     : %s" % ids)
    print("  向量矩阵形状 : (%d, %d)   <- 每一行都来自 embedding table" % (len(vecs), HIDDEN))
    print("  第一行向量   : %s\n" % vecs[0])

    print("【Soft Prompt 这条路】")
    p_len = 5
    text2, all_vecs, pseudo = soft_prompt_path(sent, p_len)
    print("  拼出来的文字 : %s   <- 模板一个字都没有" % text2)
    print("  伪标记个数   : %d" % p_len)
    print("  向量矩阵形状 : (%d, %d) = (%d 伪标记 + %d 原句 token, hidden)"
          % (len(all_vecs), HIDDEN, p_len, len(all_vecs) - p_len))
    print("  伪标记第一行 : %s" % pseudo[0])
    print("  这 %d 行在词表里查不到任何对应的汉字。\n" % p_len)

    print("【形状对账】")
    n_sent = len(tokenize("[CLS]" + sent + "[SEP]"))
    assert len(all_vecs) == p_len + n_sent, "拼接后长度必须是 p + n"
    print("  (p + n) × e = (%d + %d) × %d = %d 个数" % (p_len, n_sent, HIDDEN, len(all_vecs) * HIDDEN))
    print("  其中只有 %d × %d = %d 个数是可训练的，其余全部冻结。"
          % (p_len, HIDDEN, p_len * HIDDEN))

    print("\n【一句话记住】")
    print("Hard Prompt 改的是 tokenizer 之前的字符串；")
    print("Soft Prompt 改的是 embedding 之后的那几行向量。")


if __name__ == "__main__":
    main()

# -*- coding: utf-8 -*-
"""参数账：全参微调、加分类头、只训 Soft Prompt，各自要动多少参数。

纯标准库可跑。数字全部由公式算出，不是抄来的经验值——
你可以把 hidden、layers 换成自己的模型再算一遍。
"""

# BERT-base 的常见配置
CFG = {
    "vocab": 21128,      # 中文 BERT 词表大小
    "hidden": 768,       # d_model
    "layers": 12,
    "ff": 3072,          # FFN 中间层
    "max_pos": 512,
    "num_labels": 2,     # 下游二分类
    "prompt_len": 20,    # Soft Prompt 的伪标记个数
}


def encoder_params(cfg):
    """粗算 encoder 主体参数量：embedding + N 层 transformer。"""
    h = cfg["hidden"]
    emb = cfg["vocab"] * h + cfg["max_pos"] * h + 2 * h      # 词/位置/段
    attn = 4 * (h * h + h)                                    # Q K V O
    ffn = (h * cfg["ff"] + cfg["ff"]) + (cfg["ff"] * h + h)   # 两个线性层
    ln = 4 * h                                                # 两个 LayerNorm
    per_layer = attn + ffn + ln
    return emb + cfg["layers"] * per_layer


def head_params(cfg):
    """第三范式新增的分类头：hidden -> num_labels。"""
    return cfg["hidden"] * cfg["num_labels"] + cfg["num_labels"]


def soft_prompt_params(cfg):
    """第四范式里 Soft Prompt 的可训参数：prompt_len 个 hidden 维向量。"""
    return cfg["prompt_len"] * cfg["hidden"]


def pct(part, whole):
    return 100.0 * part / whole


def main():
    total = encoder_params(CFG)
    head = head_params(CFG)
    soft = soft_prompt_params(CFG)

    print("模型主体参数量（BERT-base 量级）: %s" % "{:,}".format(total))
    print()

    rows = [
        ("全参 Fine-Tuning", total + head, "主体 + 分类头全部更新"),
        ("只训分类头", head, "主体冻结，只动最后那层线性"),
        ("Soft Prompt（prompt_len=%d）" % CFG["prompt_len"], soft, "主体冻结，只动伪标记向量"),
    ]
    print("%-28s %14s %10s  %s" % ("方案", "可训参数", "占比", "说明"))
    for name, n, note in rows:
        print("%-28s %14s %9.4f%%  %s" % (name, "{:,}".format(n), pct(n, total + head), note))

    print()
    print("【一句话读懂这张表】")
    print("Soft Prompt 只有 %s 个可训参数，是全参微调的 1/%d。"
          % ("{:,}".format(soft), round((total + head) / soft)))
    print("每多一个下游任务，全参微调要另存一整份模型，Soft Prompt 只多存一小段向量。")

    # 换算成磁盘占用（fp32，每参数 4 字节）
    print()
    print("按 fp32 存盘：全参微调一份 %.0f MB，Soft Prompt 一份 %.1f KB。"
          % ((total + head) * 4 / 1024 / 1024, soft * 4 / 1024))

    assert soft < head * 100, "Soft Prompt 的参数量应当与分类头同一量级，而非模型量级"
    assert pct(soft, total) < 0.1, "Soft Prompt 占比应当远低于 0.1%"
    print("\n自检通过：Soft Prompt 的开销确实停留在「小配件」量级。")


if __name__ == "__main__":
    main()

# -*- coding: utf-8 -*-
"""PVP 骨架：把任意文本分类任务改写成完形填空任务。

复制后只改五处 TODO 就能用在自己的数据上。纯标准库，先在本地把
「输入长什么样、标签词映射对不对」验证通过，再接真实模型。

用法：
    python3 pvp_skeleton.py            # 跑自检 + 打印样例
    from pvp_skeleton import PVP       # 当成模块导入
"""


class PVP(object):
    """Pattern-Verbalizer-Pair：一个任务一份实例。"""

    # TODO 1：换成你的任务模板。{x} 是原文占位，[MASK] 是答案落点。
    #         写 2~3 个备选，后面用 pick_pattern() 在验证集上选。
    PATTERNS = {
        "p1": "{x} 整体感觉是[MASK]的。",
        "p2": "{x} 这是一条[MASK]评。",
    }

    # TODO 2：换成你的类别与标签词。要求：
    #   · 标签词必须在预训练词表里存在，优先选单字；
    #   · 同一个词不能挂在两个类别下；
    #   · 各类别的标签词个数尽量持平，否则 sum 汇总会偏。
    VERBALIZER = {
        "正面": ["好", "棒", "赞"],
        "负面": ["差", "烂", "糟"],
    }

    # TODO 3：按你使用的模型改特殊标记（BERT 系用 [CLS]/[SEP]/[MASK]）
    CLS, SEP, MASK = "[CLS]", "[SEP]", "[MASK]"

    def __init__(self, pattern_key="p1"):
        if pattern_key not in self.PATTERNS:
            raise KeyError("没有模板 %r，可选：%s"
                           % (pattern_key, list(self.PATTERNS)))
        self.pattern_key = pattern_key
        self._check_verbalizer()

    # ---------------- 构造输入 ----------------
    def build(self, text):
        """原文 -> 送进模型的字符串，以及 [MASK] 在字符串里的下标。

        真实实现里要把下标换成 token 下标（tokenize 之后再定位），
        这里先用字符下标把流程跑通。
        """
        body = self.PATTERNS[self.pattern_key].format(x=text)
        full = "%s %s %s" % (self.CLS, body, self.SEP)
        return full, full.index(self.MASK)

    # ---------------- 标签双向映射 ----------------
    def label_words(self, label):
        """训练时：类别 -> 该类别下所有标签词。"""
        if label not in self.VERBALIZER:
            raise KeyError("Verbalizer 里没有类别 %r" % label)
        return self.VERBALIZER[label]

    def word_label(self, word):
        """推理时：标签词 -> 类别。表外的词返回 None，不要默认归类。"""
        for label, words in self.VERBALIZER.items():
            if word in words:
                return label
        return None

    # ---------------- 解码 ----------------
    def decode(self, mask_scores, mode="max"):
        """把 [MASK] 位置的词表分数汇总成类别分数。

        mask_scores: dict[词] = 分数（真实场景是 logits 张量取对应词 id）
        mode: 'max' 取类别下最高分；'sum' 把该类别所有标签词的分数相加。
        两种都常见，但必须全程用同一种：数值不可互相比较。
        用 'sum' 时各类别的标签词个数要持平，否则词多的一类天然占便宜。
        返回 (类别, 类别分数字典)。全程只在标签词集合内比较。
        """
        if mode not in ("max", "sum"):
            raise ValueError("mode 只能是 max 或 sum")
        scores = {}
        for label, words in self.VERBALIZER.items():
            hit = [mask_scores[w] for w in words if w in mask_scores]
            if not hit:
                # 该类别一个标签词都没命中：必须暴露，不能当成 0 分默默参与比较
                raise ValueError("类别 %r 的标签词都不在打分结果里" % label)
            scores[label] = max(hit) if mode == "max" else sum(hit)
        best = max(scores, key=scores.get)
        return best, scores

    # ---------------- 自检 ----------------
    def _check_verbalizer(self):
        seen = {}
        for label, words in self.VERBALIZER.items():
            if not words:
                raise ValueError("类别 %r 没有标签词" % label)
            for w in words:
                if w in seen:
                    raise ValueError("标签词 %r 同时属于 %s 和 %s"
                                     % (w, seen[w], label))
                seen[w] = label


def pick_pattern(samples, score_fn):
    """在验证集上挑模板。

    samples: [(文本, 真实类别), ...]
    score_fn: 接收 (拼好的输入, mask_idx) 返回 dict[词]=分数 的函数，
              真实场景里就是「调模型拿 [MASK] 位置 logits」。
    TODO 4：接上你的模型推理函数，然后用这个函数选模板，别靠手感。
    """
    result = {}
    for key in PVP.PATTERNS:
        pvp = PVP(key)
        right = 0
        for text, gold in samples:
            full, idx = pvp.build(text)
            pred, _ = pvp.decode(score_fn(full, idx))
            right += int(pred == gold)
        result[key] = right / float(len(samples))
    return result


def _demo():
    pvp = PVP("p1")

    print("【一、输入构造】")
    for text in ["这部电影很好看。", "剧情拖沓，看了半小时就想走。"]:
        full, idx = pvp.build(text)
        print("  原文 : %s" % text)
        print("  输入 : %s" % full)
        print("  [MASK] 字符下标 : %d\n" % idx)

    print("【二、解码】")
    # TODO 5：换成真实模型在 [MASK] 位置的输出分数
    fake_scores = {"好": 6.2, "棒": 5.1, "赞": 3.4,
                   "差": 1.8, "烂": 1.2, "糟": 0.9,
                   "的": 5.9}
    for mode in ("max", "sum"):
        label, detail = pvp.decode(fake_scores, mode)
        print("  mode=%-4s -> %s   %s" % (mode, label, detail))
    print("  注意「的」分数 5.9 很高，但它不是标签词，不参与比较。")

    print("\n【三、映射表自检】")
    try:
        bad = type("Bad", (PVP,), {"VERBALIZER": {"A": ["好"], "B": ["好"]}})
        bad()
    except ValueError as e:
        print("  按预期拦下交叉标签词：%s" % e)

    assert pvp.word_label("棒") == "正面"
    assert pvp.word_label("一般") is None, "表外词必须返回 None"
    print("  双向映射自检通过。")


if __name__ == "__main__":
    _demo()