大语言模型是什么：从语言模型到 LLM

"""bigram 语言模型：用计数和除法算出「哪句话更像人话」。

只用标准库，直接 python3 bigram_lm.py 就能跑。
语料很小，目的是让每一个数字都能用手算复核。
"""
from collections import defaultdict

# 语料：每个句子前后补上 <s> 和 </s>，让「句首第一个词」也有上文可依
CORPUS = [
    "我 想 去 打 篮球",
    "我 想 去 学习",
    "我 喜欢 打 篮球",
    "黑马 程序员 想 去 学习",
    "黑马 程序员 喜欢 学习",
]

BOS, EOS = "<s>", "</s>"


def tokenize(sentence):
    """把一行中文按空格切成词，并补上句首句尾标记。"""
    return [BOS] + sentence.split() + [EOS]


def train(corpus):
    """统计 C(w_{i-1}, w_i) 与 C(w_{i-1})，这就是 bigram 的全部参数。"""
    bigram = defaultdict(int)   # C(前一个词, 当前词)
    unigram = defaultdict(int)  # C(前一个词)
    for sentence in corpus:
        words = tokenize(sentence)
        for prev, cur in zip(words, words[1:]):
            bigram[(prev, cur)] += 1
            unigram[prev] += 1
    return bigram, unigram


def prob(bigram, unigram, prev, cur):
    """P(cur | prev) = C(prev, cur) / C(prev)，即最大似然估计。"""
    if unigram[prev] == 0:
        return 0.0
    return bigram[(prev, cur)] / unigram[prev]


def sentence_prob(bigram, unigram, sentence):
    """链式法则 + 马尔可夫假设：整句概率 = 每一步条件概率连乘。"""
    words = tokenize(sentence)
    total = 1.0
    for prev, cur in zip(words, words[1:]):
        p = prob(bigram, unigram, prev, cur)
        print("    P(%-6s| %-6s) = %.4f" % (cur, prev, p))
        total *= p
    return total


def predict_next(bigram, unigram, prev):
    """给定上文一个词，把所有候选按概率从高到低排出来。"""
    candidates = [(cur, prob(bigram, unigram, prev, cur))
                  for (p, cur) in bigram if p == prev]
    return sorted(candidates, key=lambda x: -x[1])


if __name__ == "__main__":
    bigram, unigram = train(CORPUS)

    print("一、单步条件概率")
    print("  P(想 | 我)   =", round(prob(bigram, unigram, "我", "想"), 4))
    print("  P(喜欢 | 我) =", round(prob(bigram, unigram, "我", "喜欢"), 4))

    print("\n二、整句概率（越大越像人话）")
    for s in ["我 想 去 打 篮球", "我 想 去 学习"]:
        print("  句子:", s)
        p = sentence_prob(bigram, unigram, s)
        print("  => P(S) = %.6f\n" % p)

    print("三、预测下一个词：上文是「打」")
    for word, p in predict_next(bigram, unigram, "打"):
        print("  %-8s %.4f" % (word, p))

    print("\n四、数据稀疏：没见过的组合概率直接归零")
    print("  P(游泳 | 打) =", prob(bigram, unigram, "打", "游泳"))

一、单步条件概率
  P(想 | 我)   = 0.6667
  P(喜欢 | 我) = 0.3333

二、整句概率（越大越像人话）
  句子: 我 想 去 打 篮球
    P(我     | <s>   ) = 0.6000
    P(想     | 我     ) = 0.6667
    P(去     | 想     ) = 1.0000
    P(打     | 去     ) = 0.3333
    P(篮球    | 打     ) = 1.0000
    P(</s>  | 篮球    ) = 1.0000
  => P(S) = 0.133333

  句子: 我 想 去 学习
    P(我     | <s>   ) = 0.6000
    P(想     | 我     ) = 0.6667
    P(去     | 想     ) = 1.0000
    P(学习    | 去     ) = 0.6667
    P(</s>  | 学习    ) = 1.0000
  => P(S) = 0.266667

三、预测下一个词：上文是「打」
  篮球       1.0000

四、数据稀疏：没见过的组合概率直接归零
  P(游泳 | 打) = 0.0

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""加一平滑（Laplace smoothing）——治 bigram 的「没见过就是 0」。

只用标准库，直接 python3 smoothing.py 就能跑。
对照组是 bigram_lm.py 的无平滑版本，同一份语料、同一个查询，
把「概率 0」和「概率很小但不是 0」的差别打印出来。
"""
from collections import defaultdict

# 和 bigram_lm.py 完全相同的五句话语料，便于逐行对照
CORPUS = [
    "我 想 学 人工 智能",
    "我 想 学 编程",
    "我 爱 人工 智能",
    "他 想 学 编程",
    "他 爱 编程",
]


def build_counts(corpus):
    """统计 bigram 共现次数与前词次数，并收集词表。"""
    bigram = defaultdict(int)
    unigram = defaultdict(int)
    vocab = set()
    for line in corpus:
        words = ["<s>"] + line.split() + ["</s>"]
        vocab.update(words)
        for i in range(len(words) - 1):
            bigram[(words[i], words[i + 1])] += 1
            unigram[words[i]] += 1
    return bigram, unigram, vocab


def p_mle(bigram, unigram, prev, word):
    """极大似然估计：C(prev, word) / C(prev)，没见过直接是 0。"""
    if unigram[prev] == 0:
        return 0.0
    return bigram[(prev, word)] / unigram[prev]


def p_laplace(bigram, unigram, vocab, prev, word):
    """加一平滑：分子 +1，分母 + |V|。

    分母必须加整个词表大小，不是加 1——
    否则所有候选词的概率加起来不等于 1，就不是概率分布了。
    """
    v = len(vocab)
    return (bigram[(prev, word)] + 1) / (unigram[prev] + v)


def main():
    bigram, unigram, vocab = build_counts(CORPUS)
    v = len(vocab)
    print("语料 %d 句，词表 |V| = %d" % (len(CORPUS), v))
    print("词表:", " ".join(sorted(vocab)))
    print()

    # 三个查询：见过的、没见过的、前词也没见过的
    queries = [
        ("我", "想", "语料里出现过 2 次"),
        ("我", "编程", "两个词都在词表里，但从未相邻"),
        ("爱", "学", "同上，典型的数据稀疏"),
    ]
    print("%-14s %-12s %-12s %s" % ("查询", "无平滑", "加一平滑", "说明"))
    print("-" * 66)
    for prev, word, note in queries:
        a = p_mle(bigram, unigram, prev, word)
        b = p_laplace(bigram, unigram, vocab, prev, word)
        print("P(%s|%s)%s %-12.4f %-12.4f %s"
              % (word, prev, " " * (6 - len(word) - len(prev)), a, b, note))
    print()

    # 验证平滑后仍是合法概率分布：对固定前词，所有候选词概率之和应为 1
    prev = "我"
    total_mle = sum(p_mle(bigram, unigram, prev, w) for w in vocab)
    total_lap = sum(p_laplace(bigram, unigram, vocab, prev, w) for w in vocab)
    print("对前词「%s」，全词表概率求和：" % prev)
    print("  无平滑   = %.6f" % total_mle)
    print("  加一平滑 = %.6f" % total_lap)
    print()

    # 代价：把概率从高频词身上匀给了没见过的词
    print("平滑的代价——高频搭配被稀释：")
    for prev, word in [("我", "想"), ("他", "想")]:
        a = p_mle(bigram, unigram, prev, word)
        b = p_laplace(bigram, unigram, vocab, prev, word)
        drop = (a - b) / a * 100 if a else 0.0
        print("  P(%s|%s): %.4f -> %.4f  下降 %.1f%%" % (word, prev, a, b, drop))
    print()
    print("结论：平滑消灭了 0 概率，代价是牺牲了高频搭配的置信度。")
    print("词表越大，|V| 越大，稀释越狠——所以真实场景用的是 Kneser-Ney 等更精细的方案。")


if __name__ == "__main__":
    main()

语料 5 句，词表 |V| = 10
词表: </s> <s> 人工 他 学 想 我 智能 爱 编程

查询             无平滑          加一平滑         说明
------------------------------------------------------------------
P(想|我)     0.6667       0.2308       语料里出现过 2 次
P(编程|我)    0.0000       0.0769       两个词都在词表里，但从未相邻
P(学|爱)     0.0000       0.0833       同上，典型的数据稀疏

对前词「我」，全词表概率求和：
  无平滑   = 1.000000
  加一平滑 = 1.000000

平滑的代价——高频搭配被稀释：
  P(想|我): 0.6667 -> 0.2308  下降 65.4%
  P(想|他): 0.5000 -> 0.1667  下降 66.7%

结论：平滑消灭了 0 概率，代价是牺牲了高频搭配的置信度。
词表越大，|V| 越大，稀释越狠——所以真实场景用的是 Kneser-Ney 等更精细的方案。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""极简 BPE 分词器——看清楚「一个 token 到底是什么」。

只用标准库，直接 python3 tokenizer_demo.py 就能跑。
真实的 tokenizer（tiktoken、SentencePiece）在工程细节上复杂得多，
但合并规则的核心就是下面这十几行：数相邻对、合并最高频的那一对、重复。
"""
from collections import Counter

# 训练语料：故意让 low/lower/newest/widest 共享后缀，看 BPE 怎么把后缀学出来
CORPUS = {
    "low": 5,
    "lower": 2,
    "newest": 6,
    "widest": 3,
}

NUM_MERGES = 10


def init_vocab(corpus):
    """把每个词切成字符序列，词尾加 </w> 标记，避免跨词合并。"""
    vocab = {}
    for word, freq in corpus.items():
        vocab[" ".join(list(word)) + " </w>"] = freq
    return vocab


def count_pairs(vocab):
    """统计所有相邻符号对的出现频次（按词频加权）。"""
    pairs = Counter()
    for word, freq in vocab.items():
        symbols = word.split()
        for i in range(len(symbols) - 1):
            pairs[(symbols[i], symbols[i + 1])] += freq
    return pairs


def merge_pair(pair, vocab):
    """把选中的符号对合并成一个新符号。"""
    merged = "".join(pair)
    old = " ".join(pair)
    out = {}
    for word, freq in vocab.items():
        # 用空格做边界，确保只替换完整的符号对，不会切断更长的符号
        out[(" " + word + " ").replace(" " + old + " ", " " + merged + " ").strip()] = freq
    return out


def train(corpus, num_merges):
    """跑 BPE 训练，返回合并规则表和最终词表。"""
    vocab = init_vocab(corpus)
    merges = []
    print("初始状态（每个字符都是一个 token）：")
    for word, freq in vocab.items():
        print("   %-24s x%d" % (word, freq))
    print()
    for step in range(1, num_merges + 1):
        pairs = count_pairs(vocab)
        if not pairs:
            print("没有可合并的对了，提前停止。")
            break
        best, freq = pairs.most_common(1)[0]
        if freq < 2:
            print("第 %d 步：最高频对只出现 %d 次，停止合并。" % (step, freq))
            break
        vocab = merge_pair(best, vocab)
        merges.append(best)
        print("第 %2d 步：合并 %-12s 频次 %d  ->  新 token 「%s」"
              % (step, str(best), freq, "".join(best)))
    return merges, vocab


def encode(word, merges):
    """用学到的合并规则给新词分词，顺序必须和训练时一致。"""
    symbols = list(word) + ["</w>"]
    for pair in merges:
        i = 0
        while i < len(symbols) - 1:
            if (symbols[i], symbols[i + 1]) == pair:
                symbols[i:i + 2] = ["".join(pair)]
            else:
                i += 1
    return symbols


def main():
    merges, vocab = train(CORPUS, NUM_MERGES)
    print()
    print("最终切分结果：")
    for word, freq in vocab.items():
        print("   %-24s x%d" % (word, freq))
    print()

    print("拿学到的规则去切新词（训练时没见过的）：")
    for word in ["lowest", "newer", "wide", "slow"]:
        toks = encode(word, merges)
        print("   %-8s -> %-30s 共 %d 个 token" % (word, str(toks), len(toks)))
    print()

    print("同一句话，不同语言的 token 数差别：")
    samples = [
        ("英文", "hello world"),
        ("中文", "你好世界"),
    ]
    for lang, text in samples:
        # 这里只按最朴素的规则估算：英文按空格切词再按字符兜底，中文按字
        rough = len(text.split()) if lang == "英文" else len(text)
        print("   %s「%s」字符数 %d，朴素切分约 %d 个单位"
              % (lang, text, len(text), rough))
    print()
    print("要记住的三件事：")
    print("  1. token 不是词也不是字，是 BPE 按频次合并出来的片段；")
    print("  2. 高频片段会变成一个 token，生僻词会被拆成好几个；")
    print("  3. 计费和上下文长度都按 token 算，所以换个 tokenizer，同一句话的成本就变了。")


if __name__ == "__main__":
    main()

初始状态（每个字符都是一个 token）：
   l o w </w>               x5
   l o w e r </w>           x2
   n e w e s t </w>         x6
   w i d e s t </w>         x3

第  1 步：合并 ('e', 's')   频次 9  ->  新 token 「es」
第  2 步：合并 ('es', 't')  频次 9  ->  新 token 「est」
第  3 步：合并 ('est', '</w>') 频次 9  ->  新 token 「est</w>」
第  4 步：合并 ('l', 'o')   频次 7  ->  新 token 「lo」
第  5 步：合并 ('lo', 'w')  频次 7  ->  新 token 「low」
第  6 步：合并 ('n', 'e')   频次 6  ->  新 token 「ne」
第  7 步：合并 ('ne', 'w')  频次 6  ->  新 token 「new」
第  8 步：合并 ('new', 'est</w>') 频次 6  ->  新 token 「newest</w>」
第  9 步：合并 ('low', '</w>') 频次 5  ->  新 token 「low</w>」
第 10 步：合并 ('w', 'i')   频次 3  ->  新 token 「wi」

最终切分结果：
   low</w>                  x5
   low e r </w>             x2
   newest</w>               x6
   wi d est</w>             x3

拿学到的规则去切新词（训练时没见过的）：
   lowest   -> ['low', 'est</w>']             共 2 个 token
   newer    -> ['new', 'e', 'r', '</w>']      共 4 个 token
   wide     -> ['wi', 'd', 'e', '</w>']       共 4 个 token
   slow     -> ['s', 'low</w>']               共 2 个 token

同一句话，不同语言的 token 数差别：
   英文「hello world」字符数 11，朴素切分约 2 个单位
   中文「你好世界」字符数 4，朴素切分约 4 个单位

要记住的三件事：
  1. token 不是词也不是字，是 BPE 按频次合并出来的片段；
  2. 高频片段会变成一个 token，生僻词会被拆成好几个；
  3. 计费和上下文长度都按 token 算，所以换个 tokenizer，同一句话的成本就变了。

"""BLEU / ROUGE-N / PPL 三个指标的纯标准库实现。

不装 nltk、不装 rouge，把公式一行行写出来，
这样每个中间量都能打印、能跟手算对上。
直接 python3 eval_metrics.py 运行。
"""
import math
from collections import Counter


# --------------------------------------------------------------------------
# 公共工具
# --------------------------------------------------------------------------
def ngrams(tokens, n):
    """把 token 序列切成 n-gram 列表；长度不够时返回空列表。"""
    return [tuple(tokens[i:i + n]) for i in range(len(tokens) - n + 1)]


# --------------------------------------------------------------------------
# BLEU：看准确率——候选句里的 n-gram 有多少能在参考句里找到
# --------------------------------------------------------------------------
def modified_precision(candidate, references, n):
    """截断精确率：候选的每个 n-gram 最多只能按参考里出现的最大次数计数。

    这一步专门治「the the the the」刷分：
    分子被参考句里 the 的真实出现次数封顶。
    """
    cand_counts = Counter(ngrams(candidate, n))
    if not cand_counts:
        return 0.0, 0, 0

    # 同一个 n-gram 在多条参考里取最大出现次数作为上限
    max_ref_counts = Counter()
    for ref in references:
        ref_counts = Counter(ngrams(ref, n))
        for gram, cnt in ref_counts.items():
            max_ref_counts[gram] = max(max_ref_counts[gram], cnt)

    clipped = sum(min(cnt, max_ref_counts[gram])
                  for gram, cnt in cand_counts.items())
    total = sum(cand_counts.values())
    return clipped / total, clipped, total


def brevity_penalty(candidate, references):
    """长度惩罚：候选句比参考句短就扣分，防止只输出最有把握的几个词。"""
    c = len(candidate)
    if c == 0:
        return 0.0
    # 取长度最接近候选句的那条参考作为有效长度 r
    r = min((abs(len(ref) - c), len(ref)) for ref in references)[1]
    if c > r:
        return 1.0
    return math.exp(1 - r / c)


def bleu(candidate, references, max_n=4, verbose=False):
    """BLEU = BP × exp(Σ w_n · log p_n)，权重取均匀的 1/max_n。"""
    weights = [1 / max_n] * max_n
    log_sum = 0.0
    for n in range(1, max_n + 1):
        p_n, clipped, total = modified_precision(candidate, references, n)
        if verbose:
            print("  %d-gram 匹配 %d/%d = %.4f" % (n, clipped, total, p_n))
        if p_n == 0:
            # 任意一阶为 0，整体连乘就是 0；这也是短句 BLEU 常年偏低的原因
            return 0.0
        log_sum += weights[n - 1] * math.log(p_n)
    bp = brevity_penalty(candidate, references)
    if verbose:
        print("  长度惩罚 BP = %.4f" % bp)
    return bp * math.exp(log_sum)


# --------------------------------------------------------------------------
# ROUGE-N：看召回率——参考句里的 n-gram 有多少被候选句覆盖到
# --------------------------------------------------------------------------
def rouge_n(candidate, reference, n=1):
    """返回 (precision, recall, f1)。ROUGE 的主指标是 recall。"""
    cand_counts = Counter(ngrams(candidate, n))
    ref_counts = Counter(ngrams(reference, n))
    overlap = sum(min(cnt, cand_counts[gram]) for gram, cnt in ref_counts.items())

    cand_total = sum(cand_counts.values())
    ref_total = sum(ref_counts.values())
    precision = overlap / cand_total if cand_total else 0.0
    recall = overlap / ref_total if ref_total else 0.0
    if precision + recall == 0:
        return precision, recall, 0.0
    f1 = 2 * precision * recall / (precision + recall)
    return precision, recall, f1


def lcs_length(a, b):
    """最长公共子序列长度，ROUGE-L 用它衡量「顺序上的重合」。"""
    dp = [[0] * (len(b) + 1) for _ in range(len(a) + 1)]
    for i in range(1, len(a) + 1):
        for j in range(1, len(b) + 1):
            if a[i - 1] == b[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
    return dp[len(a)][len(b)]


def rouge_l(candidate, reference):
    """ROUGE-L：不要求连续，只要求词序一致，比 ROUGE-N 宽松。"""
    lcs = lcs_length(candidate, reference)
    precision = lcs / len(candidate) if candidate else 0.0
    recall = lcs / len(reference) if reference else 0.0
    if precision + recall == 0:
        return precision, recall, 0.0
    f1 = 2 * precision * recall / (precision + recall)
    return precision, recall, f1


# --------------------------------------------------------------------------
# PPL：困惑度——模型面对真实句子时平均「纠结」在多少个候选词之间
# --------------------------------------------------------------------------
def perplexity(sentence, unigram):
    """PPL = 2^(-1/N · Σ log2 P(w))，等价于几何平均概率的倒数。"""
    log_prob = 0.0
    for word in sentence:
        p = unigram.get(word, 0.0)
        if p <= 0:
            # 概率为 0 时 log 无定义，真实工程里靠平滑兜底
            return float("inf")
        log_prob += math.log(p, 2)
    avg_neg_log = -log_prob / len(sentence)
    return 2 ** avg_neg_log


if __name__ == "__main__":
    cand = "It is a nice day today".lower().split()
    ref = "today is a nice day".lower().split()

    print("一、BLEU（准确率视角）")
    score = bleu(cand, [ref], max_n=4, verbose=True)
    print("  BLEU-4 = %.4f\n" % score)

    print("二、截断精确率治刷分")
    spam = "the the the the".split()
    spam_ref = "The cat is standing on the ground".lower().split()
    p1, clipped, total = modified_precision(spam, [spam_ref], 1)
    print("  候选 'the the the the' 的 1-gram 截断精确率 = %d/%d = %.4f\n"
          % (clipped, total, p1))

    print("三、ROUGE（召回率视角）")
    for n in (1, 2):
        p, r, f = rouge_n(cand, ref, n)
        print("  ROUGE-%d  P=%.4f  R=%.4f  F1=%.4f" % (n, p, r, f))
    p, r, f = rouge_l(cand, ref)
    print("  ROUGE-L  P=%.4f  R=%.4f  F1=%.4f\n" % (p, r, f))

    print("四、PPL（困惑度）")
    unigram = {"i": 1 / 12, "have": 1 / 12, "a": 3 / 12, "pen": 1 / 12,
               "he": 1 / 12, "has": 2 / 12, "book": 1 / 12,
               "she": 1 / 12, "cat": 1 / 12}
    corpus = [["i", "have", "a", "pen"],
              ["he", "has", "a", "book"],
              ["she", "has", "a", "cat"]]
    total = 0.0
    for s in corpus:
        ppl = perplexity(s, unigram)
        print("  %-22s PPL = %.4f" % (" ".join(s), ppl))
        total += ppl
    print("  平均 PPL = %.4f" % (total / len(corpus)))

一、BLEU（准确率视角）
  1-gram 匹配 5/6 = 0.8333
  2-gram 匹配 3/5 = 0.6000
  3-gram 匹配 2/4 = 0.5000
  4-gram 匹配 1/3 = 0.3333
  长度惩罚 BP = 1.0000
  BLEU-4 = 0.5373

二、截断精确率治刷分
  候选 'the the the the' 的 1-gram 截断精确率 = 2/4 = 0.5000

三、ROUGE（召回率视角）
  ROUGE-1  P=0.8333  R=1.0000  F1=0.9091
  ROUGE-2  P=0.6000  R=0.7500  F1=0.6667
  ROUGE-L  P=0.6667  R=0.8000  F1=0.7273

四、PPL（困惑度）
  i have a pen           PPL = 9.1180
  he has a book          PPL = 7.6673
  she has a cat          PPL = 7.6673
  平均 PPL = 8.1509

"""评估脚本骨架：把一批生成结果按 BLEU / ROUGE / PPL 打分并出报表。

复制后只改 5 处 TODO 即可用在自己的任务上。
依赖：只用标准库 + 同目录的 eval_metrics.py。
"""
import json
import os

from eval_metrics import bleu, rouge_n, rouge_l, perplexity

# TODO 1：换成你自己的数据文件。每行一个 JSON 对象，形如
#   {"prompt": "...", "prediction": "模型输出", "reference": "人工标准答案"}
DATA_PATH = os.environ.get("EVAL_DATA", "samples.jsonl")

# TODO 2：换成你的分词方式。中文建议用 jieba，英文按空格即可。
def tokenize(text):
    return text.lower().split()


# TODO 3：按任务类型挑指标。翻译看 BLEU，摘要看 ROUGE，语言模型看 PPL。
METRICS = ("bleu4", "rouge1_r", "rouge2_r", "rougeL_f")


def load(path):
    """读 jsonl；文件不存在时退回内置样例，保证脚本永远能跑起来。"""
    if not os.path.exists(path):
        return [
            {"prediction": "It is a nice day today", "reference": "today is a nice day"},
            {"prediction": "the the the the", "reference": "the cat is on the ground"},
        ]
    rows = []
    with open(path, encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if line:
                rows.append(json.loads(line))
    return rows


def score_one(prediction, reference):
    """对单条样本算出全部指标，返回字典。"""
    cand, ref = tokenize(prediction), tokenize(reference)
    r1_p, r1_r, r1_f = rouge_n(cand, ref, 1)
    r2_p, r2_r, r2_f = rouge_n(cand, ref, 2)
    rl_p, rl_r, rl_f = rouge_l(cand, ref)
    return {
        "bleu4": bleu(cand, [ref], max_n=4),
        "rouge1_r": r1_r,
        "rouge2_r": r2_r,
        "rougeL_f": rl_f,
    }


def main():
    rows = load(DATA_PATH)
    totals = dict.fromkeys(METRICS, 0.0)

    print("%-34s %s" % ("样本", "  ".join("%-9s" % m for m in METRICS)))
    print("-" * 80)
    for row in rows:
        scores = score_one(row["prediction"], row["reference"])
        for m in METRICS:
            totals[m] += scores[m]
        preview = row["prediction"][:30]
        print("%-34s %s" % (preview,
                            "  ".join("%-9.4f" % scores[m] for m in METRICS)))

    print("-" * 80)
    n = len(rows) or 1
    print("%-34s %s" % ("平均（共 %d 条）" % len(rows),
                        "  ".join("%-9.4f" % (totals[m] / n) for m in METRICS)))

    # TODO 4：需要 PPL 时，换成你自己的词表概率分布（真实项目里由模型给出）
    # print(perplexity(tokenize("i have a pen"), {"i": 1/12, ...}))

    # TODO 5：把结果落盘，接进 CI 做回归对比
    # json.dump(totals, open("eval_report.json", "w"), ensure_ascii=False, indent=2)


if __name__ == "__main__":
    main()