老周在城南开了家私房菜馆。掌勺二十年后，他炒菜时有一个“怪习惯”：炒几下就停下来，眯着眼尝一小口汤，再决定加盐、加水还是换个火候。学徒问：“师父，您是不是不放心自己的手艺？”老周摇头：“不是不放心，恰恰是太放心。我知道这一勺下去对不对，也知道哪一步自己拿不准。”这个“边做菜边看自己怎么做菜”的本领，就是元认知。 大模型也正在拥有类似的本领。它不只是会“生成下一句话”，还能在生成过程中给自己打分、发现矛盾、承认不知道，并在必要时回头重写。这种对自身推理过程的监控与调节，是它从“能说会道”走向“可靠可用”的关键一跃。本文就用老周的后厨故事，拆解元认知能力从何而来、如何运作，以及为什么它决定了模型的可靠性。

岗位关联

对 AI 从业者而言，元认知能力是模型从“能答”走向“答得靠谱”的分水岭，直接影响评测、训练与产品设计。

目录
  1. 可视化演示
  2. 自我监控：认知之眼
  3. 自信评估：概率温度计
  4. 知识边界：敢说“不知道”
  5. 主动纠错：回勺调味
  6. 思维链支撑：菜谱写步骤
  7. 自我反思：多轮试菜
  8. 训练启示：教厨师尝味
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示系统处理流水线、实时性能指标曲线及多方案对比分析，包含数据流转、吞吐延迟监控与方案评估。

本节配有交互动效（进入视口后自动加载，约 3KB）。

系统可视化 处理流程：输入→处理→模型→输出 性能监控：实时指标 P=L×T

自我监控：认知之眼

刚学厨的小王炒菜时只顾翻锅，直到糊味飘出来才慌了神。老周却不一样：他一边翻炒，一边看火苗、听油声、闻锅气——在“炒菜”这件事之外，还有一双“看着炒菜”的眼睛。这双眼睛，就是元认知里的“自我监控”。它不负责实际下锅，只负责观察：现在做得怎么样？有没有跑偏？需不需要调整？

大模型生成文字时也有类似的双通道。Transformer 的前向传播不仅输出下一个词，还会在隐状态中留下一份“判断依据”：这一段是否合理？是否和自己之前说的话矛盾？要不要继续往下写？这并非模型拥有意识，而是训练数据和反馈信号教会它形成一种可计算的监控回路。

监控回路可以抽象成两个函数：监控器读取当前状态并输出信号，控制器再根据信号决定下一步动作。用公式表示就是：

老周的“厨房之眼”不是一天练成的，而是在无数次试错中沉淀出的直觉。大模型的监控回路也同样来自大量训练：见过太多“说出矛盾话被否定”的例子后，它才学会在生成过程中留一只眼盯住自己。

mt=fmonitor(ht,y<t);at=gcontrol(mt)m_t = f_{\text{monitor}}\left(h_t, y_{<t}\right);\quad a_t = g_{\text{control}}\left(m_t\right)
通俗说：监控器尝一口汤，控制器决定加盐还是继续煮。
  1. 监控输入输入当前隐状态 \(h_t\) 和已经生成的文本 \(y_{<t}\)，让模型看到“自己到目前为止说了什么”。
    ht,y<th_t, y_{<t}
  2. 监控信号监控函数 \(f_{\text{monitor}}\) 把输入转换为一个判断信号 \(m_t\)，相当于“这口汤偏咸”的结论。
    mt=fmonitor(ht,y<t)m_t = f_{\text{monitor}}\left(h_t, y_{<t}\right)
  3. 控制动作控制函数 \(g_{\text{control}}\) 读取 \(m_t\)，决定是继续生成、放慢节奏还是回头修正。
    at=gcontrol(mt)a_t = g_{\text{control}}\left(m_t\right)

自信评估：概率温度计

老周判断一道菜该不该上桌，靠的是舌头。但舌头也有不可靠的时候：熬夜后味觉变钝，吃太辣后神经麻木。所以他不会直接说“我觉得很好吃”，而是会补一句“今天这个判断可能不准”。这种“知道自己判断准不准”的能力，就是自信评估。

大模型给出答案时，也会给每个候选词打一个分数。Softmax 函数把这些分数转成概率，其中最大的那个概率，可以视为模型对“下一个词该是什么”的自信程度。如果最大概率接近 1，说明它比较笃定；如果最大概率只有 0.3，说明它在几个选项中犹豫。

不过，原始 softmax 概率经常“过度自信”，就像熬夜后的老周觉得所有菜都偏淡。这时需要温度参数 \(T\) 来校准：

老周后来每天清晨先喝一口白水，确认舌头没“失灵”再开始调盐。模型也一样：训练时把温度校准好，它报出的“90% 确定”才真的有九成把握。否则，一个盲目自信的模型，比一个敢于犹豫的模型危险得多。

pi=ezi/T∑j=1Vezj/Tp_i = \frac{e^{z_i / T}}{\sum_{j=1}^{V} e^{z_j / T}}
温度高，分布更平；温度低，分布更尖。好的温度校准，能让模型的“自信”和“正确率”对得上。
  1. 原始得分 \(z_i\)模型为词表中第 \(i\) 个词打出的逻辑分数，可以理解为“炒这勺菜的力度”。
    ziz_i
  2. 温度参数 \(T\)一个缩放因子。\(T\) 越大，所有指数之间的差距被稀释，概率分布越平坦。
    ezi/Te^{z_i / T}
  3. 归一化分母把词表中所有 \(V\) 个词的指数项加总，保证所有概率之和为 1。
    ∑j=1Vezj/T\sum_{j=1}^{V} e^{z_j / T}
  4. 最终概率 \(p_i\)第 \(i\) 个词被选中的概率，也是模型“自信度”的一个候选度量。
    pi=ezi/T∑j=1Vezj/Tp_i = \frac{e^{z_i / T}}{\sum_{j=1}^{V} e^{z_j / T}}

知识边界：敢说“不知道”

老周厨房墙上贴着一句话：“不知道就不知道，别糊弄客人。”有一次客人问一道川菜的地道做法，老周是粤菜师傅，他坦然说：“这道菜我不拿手，怕做坏了您的期待。”客人反而更信任他。认识自己的知识边界，不是示弱，而是专业。

大模型也会遇到同样问题：被问到训练数据里没有答案的问题时，它可能强行编造一个看似合理的回答，这就是“幻觉”。拥有元认知能力的大模型，则会输出“我不确定”或主动转交人工。问题在于：它怎么知道“自己不不知道”？答案是校准不确定性。

常用的评估指标是期望校准误差（ECE），它衡量模型的置信度和真实准确率之间的差距：

老周说“这道菜不拿手”，不是因为手艺差，而是因为对边界足够诚实。模型学会表达“我不确定”，反而能在医疗、金融等高危场景中守住底线，把不知道的问题交给人类或更专业的模型。

ECE=∑m=1M∣Bm∣N∣acc(Bm)−conf(Bm)∣\mathrm{ECE} = \sum_{m=1}^{M} \frac{|B_m|}{N} \left| \mathrm{acc}(B_m) - \mathrm{conf}(B_m) \right|
ECE 越低，说明模型给出“80% 自信”的回答时，真的有大约 80% 概率正确，知识边界也就越清楚。
  1. 置信度分箱 \(B_m\)把所有样本按模型给出的置信度分成 \(M\) 箱，比如 0~0.1、0.1~0.2、……每箱对应一个区间。
    Bm,m=1,…,MB_m, \quad m=1,\dots,M
  2. 每个箱子的准确率\(\mathrm{acc}(B_m)\) 表示第 \(m\) 箱中，有多少比例的回答确实正确，相当于“客人说好喝的比例”。
    acc(Bm)\mathrm{acc}(B_m)
  3. 每个箱子的平均置信度\(\mathrm{conf}(B_m)\) 表示模型对自己给出回答的平均自信值，相当于“厨师自己打的分”。
    conf(Bm)\mathrm{conf}(B_m)
  4. 加权平均差距用 \(\frac{|B_m|}{N}\) 给每个箱子加权，再对所有箱子求平均，得到整体校准误差。
    ∑m=1M∣Bm∣N∣acc(Bm)−conf(Bm)∣\sum_{m=1}^{M} \frac{|B_m|}{N} \left| \mathrm{acc}(B_m) - \mathrm{conf}(B_m) \right|

主动纠错：回勺调味

老周最得意的一道招牌汤，有一次被徒弟做咸了。他没有直接上桌，而是马上加水、加配菜，重新吊了一遍味。客人尝不出任何破绽。这种“发现问题立刻回勺”的动作，在厨房里叫补救，在模型里叫主动纠错。

大模型生成回答时，监控器一旦发现当前片段自信度过低，或者和上文逻辑矛盾，控制器就可以执行一个回溯动作：删除最近生成的几个词，换一个方向重新生成。这就好像老周发现汤头偏咸，不是硬着头皮继续炖，而是立刻调整配方。

用数学语言描述，就是根据当前自信度 \(c_t\) 和阈值 \(\tau\) 做决策：

老周常对徒弟说：“回勺不丢人，端上桌的菜砸了招牌才丢人。”模型也一样：一次自我纠错会多花几毫秒，但换来的是一段极大概率更正确的回答。主动纠错，是元认知从“监而不控”走向“监而能控”的关键一步。

at={继续生成,ct≥τ回溯重写,ct<τa_t =\begin{cases}\text{继续生成}, & c_t \ge \tau \\\text{回溯重写}, & c_t < \tau\end{cases}
一勺错了不要紧，怕的是错了还不知道。模型在低置信处停下重来，才能避免错误一路滚雪球。
  1. 当前自信度 \(c_t\)模型对已生成内容的整体信心，来自 token 概率和内部监控信号。
    ctc_t
  2. 判断阈值 \(\tau\)一个经验上设定的“及格线”。高于它，模型认为目前方向可信；低于它，模型认为可能已经跑偏。
    τ\tau
  3. 继续生成分支当自信度足够高时，模型保持当前轨迹，继续写下去。
    ct≥τ⇒继续生成c_t \ge \tau \Rightarrow \text{继续生成}
  4. 回溯重写分支当自信度不足时，模型回退到更早的位置，重新选择更合理的路径。
    ct<τ⇒回溯重写c_t < \tau \Rightarrow \text{回溯重写}

思维链支撑：菜谱写步骤

老周教徒弟做佛跳墙，从不让徒弟把食材一股脑丢进锅里。他会先写一张分步菜谱：泡发、焯水、煸炒、焖煮、调味。每一步做完，徒弟都可以对照菜谱检查这一锅的状态。步骤写下来了，检查才有抓手。

大模型也是这样。Chain-of-Thought（思维链）让模型在给出最终答案前，先把推理过程逐行写出来。这既给了监控器更多“可检查的节点”，也让每个中间步骤可以单独验证。逻辑链条中一旦有一步出问题，后续就很容易被抓住并修正。

思维链生成的概率可以看作每一步条件概率的连乘：

老周写菜谱不是为了让客人看，而是为了让徒弟每一步都有依据可查。思维链的价值也不在“多写几个字”，而在于把不可见的推理变成可见的文字，让自我监控和自我纠错真正有处下手。

P(y∣x)≈∏i=1NPθ(si∣x,s<i)P(y \mid x) \approx \prod_{i=1}^{N} P_\theta\left(s_i \mid x, s_{<i}\right)
把推理过程摊开成多步，等于把“凭感觉炒一道菜”变成“按菜谱走一步查一步”。
  1. 问题文本 \(x\)模型的输入，相当于客人点的菜名。
    xx
  2. 第 \(i\) 步推理 \(s_i\)思维链中的某一个中间步骤，比如“先把食材焯水”。
    sis_i
  3. 历史步骤 \(s_{<i}\)第 \(i\) 步之前已经写出的所有推理内容，是当前步的上下文。
    s<is_{<i}
  4. 条件概率连乘整个推理路径的概率由每一步 \(P_\theta(s_i \mid x, s_{<i})\) 相乘得到。
    ∏i=1NPθ(si∣x,s<i)\prod_{i=1}^{N} P_\theta\left(s_i \mid x, s_{<i}\right)

自我反思：多轮试菜

招牌菜出锅前，老周会把菜端到二灶师傅面前，两个人各自尝一口，然后互相说问题。“是不是淡了？”“木耳是不是发过了？”说完再回锅调整，再尝，再调。几轮之后，两人才点头上菜。这不是不自信，而是把“反思”做成了流程。

大模型中的 Self-Reflection 范式也是这样：首轮生成一个答案，然后让模型或另一个模块扮演批评者，找出答案的漏洞；接着根据批评意见修改，生成新答案；再批评，再修改。如此循环，直到不再发现新的主要问题。

一次完整反思迭代可以写成：

老周和二灶师傅的“两人试菜”，有点费时间，却把出错率降到最低。模型的自我反思也一样：多一次审视就多一分可靠，尤其是面对代码、数学和逻辑推理任务时，这轮“回锅”往往能明显提升输出质量。

y^(r+1)=Refine(p,y^(r),Critique(p,y^(r)))\hat{y}^{(r+1)} = \mathrm{Refine}\left(p, \hat{y}^{(r)}, \mathrm{Critique}\left(p, \hat{y}^{(r)}\right)\right)
第一版答案只是“毛坯菜”，自我反思是让主厨和评审一起尝、一起改，直到能上桌。
  1. 当前答案 \(\hat{y}^{(r)}\)第 \(r\) 轮反思时的答案版本，首轮记为 \(\hat{y}^{(0)}\)。
    y^(r)\hat{y}^{(r)}
  2. 批评函数 \(\mathrm{Critique}\)对该版本进行挑刺，指出其中的矛盾、缺失或可疑之处。
    Critique(p,y^(r))\mathrm{Critique}\left(p, \hat{y}^{(r)}\right)
  3. 精修函数 \(\mathrm{Refine}\)把原始提示词、当前答案和批评意见放在一起，生成一个更完善的版本。
    Refine(p,y^(r),Critique(p,y^(r)))\mathrm{Refine}\left(p, \hat{y}^{(r)}, \mathrm{Critique}\left(p, \hat{y}^{(r)}\right)\right)
  4. 迭代与收敛把 \((r)\) 替换成 \((r+1)\)，进入下一轮；通常几轮之后，修改幅度会明显变小。
    y^(r+1)=Refine(p,y^(r),Critique(p,y^(r)))\hat{y}^{(r+1)} = \mathrm{Refine}\left(p, \hat{y}^{(r)}, \mathrm{Critique}\left(p, \hat{y}^{(r)}\right)\right)

训练启示：教厨师尝味

老周带徒弟有个规矩：从第一天起，每炒完一道菜必须先自己尝一口，然后当着老师傅的面说出“哪里好、哪里不好”。天天这么练，徒弟们慢慢就练出了对味道的敏感。尝味不是做菜之外的负担，而是训练体系里的一部分。

大模型要获得元认知，也不能靠“边推理边自学成才”，而是要靠训练阶段有意识地把监控、评估、纠错编进目标函数。比如在训练时加入置信度校准的惩罚项，或者用 RLHF 让模型更倾向于“能自我反省的答案”。

RLHF 的目标一般可以写成“期望奖励最大”和“不要偏离参考模型太多”的平衡：

训练时的“尝味练习”会沉淀成部署时的元认知能力：模型知道自己哪些题会答错，就可以把低置信问题自动升级给更强模型或人工；知道自己哪些领域不熟，就主动拒答。这种“知道何时该求助”的能力，正是资源分配和系统设计中最值钱的那块拼图。

---

J(θ)=Ey∼Pθ[R(y)]−β KL(Pθ ∥ Pref)J(\theta) = \mathbb{E}_{y \sim P_\theta}\left[ R(y) \right] - \beta \, \mathrm{KL}\left(P_\theta \, \| \, P_{\mathrm{ref}}\right)
训练阶段教会模型“先尝后出菜”，部署阶段才能放心让它独立上灶。
  1. 期望奖励从当前策略 \(P_\theta\) 采样回答 \(y\)，计算奖励 \(R(y)\)，再对所有可能回答求期望。
    Ey∼Pθ[R(y)]\mathbb{E}_{y \sim P_\theta}\left[ R(y) \right]
  2. 奖励 \(R(y)\)一个回答有多好，可以来自人工偏好、工具校验或规则打分。
    R(y)R(y)
  3. KL 惩罚\(\mathrm{KL}\) 衡量当前策略和参考模型 \(P_{\mathrm{ref}}\) 的分布距离，用来防止模型跑偏。
    KL(Pθ ∥ Pref)\mathrm{KL}\left(P_\theta \, \| \, P_{\mathrm{ref}}\right)
  4. 平衡系数 \(\beta\)控制“追求奖励”和“保持稳定”之间的比例，\(\beta\) 越大，模型越不敢偏离参考行为。
    β KL(Pθ ∥ Pref)\beta \, \mathrm{KL}\left(P_\theta \, \| \, P_{\mathrm{ref}}\right)

AI 应用场景

智能客服与人工转接

阶段：模型推理与决策

解决的问题：传统客服机器人经常对疑难问题强行作答，给用户错误承诺，导致投诉升级。具备元认知能力的模型会在低置信或知识边界附近主动触发转人工流程，而不是硬编。

具体案例：某银行智能助手被问到“房贷提前还款违约金是否支持减免”时，模型内部监控发现该政策依赖城市分行的最新文件，自己在训练数据中见过多个冲突版本。它输出“这个问题我需要专员确认”，并自动创建人工工单，准确率和用户满意度同时提升。

大模型评测与资源调度

阶段：模型评测与训练后优化

解决的问题：传统评测只看最终正确率，无法发现“模型哪些地方过度自信”。引入置信度校准指标后，可识别出大量低质量样本，并指导资源分配。

具体案例：一家 AI 公司为 10 万条测试问答计算 ECE，发现模型在“多跳推理”类题目上的自信度显著高于实际准确率。于是团队把这类问题从自研小模型路由到更大的模型，既控制成本又保住准确率。

代码生成助手自我审查

阶段：推理时对齐与反馈

解决的问题：代码助手一次生成的代码可能有隐藏 bug，传统方案依赖人工 code review。利用自我反思范式，模型先生成代码，再扮演审查者检查边界条件，最后根据审查意见重写。

具体案例：某开发助手在生成一个“批量文件重命名”函数时，首版遗漏了文件重名冲突处理。模型自我批判后发现了这个风险，第二版补充了冲突检测逻辑，并附带测试用例，开发者直接采用，减少了 30% 的返工。

Python 演示

python47 行
class MetaCognitiveAgent:    def __init__(self, target=821):        self.target = target     def draft_answer(self, seed):        # 模拟大模型首轮输出：返回答案文本和模型给出的自信度        if seed % 5 == 0:            return ("I am not sure", 0.22)        if seed % 5 == 1:            return (f"Answer is {self.target - 1}", 0.71)        if seed % 5 == 2:            return (f"Answer is {self.target}", 0.56)        if seed % 5 == 3:            return (f"Answer is {self.target}, because 800+20+1", 0.88)        return (f"Answer is {self.target}", 0.97)     def verify(self, answer):        # 外部工具校验：相当于“试菜”        return str(self.target) in answer and str(self.target - 1) not in answer     def reflect(self, answer, confidence):        # 内部监控：自信不足或答案不自洽时，给出反馈        if confidence < 0.5:            return "low_confidence"        if not self.verify(answer):            return "self_contradiction"        return "ok"     def solve_with_metacognition(self, seed, max_rounds=3):        answer, confidence = self.draft_answer(seed)        for round_i in range(1, max_rounds + 1):            feedback = self.reflect(answer, confidence)            if feedback == "ok":                return answer, confidence, round_i - 1, feedback            if feedback == "low_confidence":                return answer, confidence, round_i, feedback            # 模拟回溯修正：重新生成一个更完整的答案            answer = f"Answer is {self.target}, because 800+20+1"            confidence = 0.94        return answer, confidence, max_rounds, "max_reflection"  if __name__ == "__main__":    agent = MetaCognitiveAgent(target=821)    for seed in range(5):        ans, conf, rounds, fb = agent.solve_with_metacognition(seed)        print(f"seed={seed}, answer={ans}, confidence={conf:.2f}, rounds={rounds}, feedback={fb}")
目的：演示“首轮生成 → 自我评估 → 判断边界 → 回溯修正 → 收敛输出”的元认知工作流，方便迁移到真实 LLM 的多轮自审提示设计中。
  1. def draft_answer(self, seed)模拟模型首轮输出，返回答案和自信度，相当于菜刚出锅时的第一口试味。
  2. if seed % 5 == 0: return ("I am not sure", 0.22)模拟模型识别到知识边界，主动表达不确定。
  3. def verify(self, answer)外部规则校验，相当于请老周或试菜工具确认答案是否真的对。
  4. if confidence < 0.5: return "low_confidence"内部监控发现“舌头不可靠”，就不再强行作答。
  5. if not self.verify(answer): return "self_contradiction"发现答案与事实矛盾，触发纠错回路。
  6. for round_i in range(1, max_rounds + 1)多轮反思循环，每轮都可能修正一次，直到通过校验。
  7. answer = f"Answer is {self.target}, because 800+20+1"模拟回溯修正后的新答案，置信度也随之提升。
  8. if __name__ == "__main__":提供可执行入口，用 5 个不同 seed 展示模型在不同初始状态下的表现。

常见误区

误区大模型能说出“我不确定”，说明它像人一样有自我意识，会诚实反省自己的想法。

正解模型没有主观意识。“我不确定”只是一种被训练出来的文本模式，背后由 token 概率、置信度分数和内部监控信号共同触发。它就像老周根据舌头反馈判断咸淡，并不意味着舌头有自己的“想法”。

为何常见：因为语言模型用第一人称说话，人们很容易把文本中的“我”和真实心智绑定，产生拟人化错觉。

误区模型说“有 95% 把握”，那它答对的概率就一定是 95%。

正解只有经过校准的置信度才接近准确率。原始 softmax 概率常常过度自信，尤其在分布外数据上。ECE 就是为了衡量这个偏差而设计的；一个模型可能输出 95% 自信，实际正确率只有 70%。

为何常见：软概率看起来像统计学里的概率，但它是从神经网络分数变换来的，不是真实世界频率，容易被人误读。

误区只要让模型多批判自己几轮，答案就一定会变正确。

正解自我反思的效果依赖批评质量。如果模型本身缺乏相关知识，批评者也可能“瞎批评”，甚至把原本正确的答案改错。反思不是万能的“神仙回锅”，有时还需要外部工具、检索结果或人类反馈做锚点。

为何常见：实验室论文里常展示反思后变好的案例，失败的案例很少被传播，容易让人误以为反思=提升。

误区模型经常说“不知道”，说明它训练得不好，知识不够多。

正解恰当地识别知识边界并拒绝作答，恰恰是元认知能力强的表现。一个模型如果对所有问题都“自信满满”，会在医疗、法律等高危场景中制造严重幻觉。老周承认“川菜不拿手”，反而让客人更放心。

为何常见：人们默认 AI 应该“无所不知”，但真实可靠的产品更需要在不确定时停住脚步。

误区模型参数多了，自然就会自我评估和自我纠错。

正解元认知能力需要数据、奖励信号和训练策略共同“喂养”。比如在训练目标中加入校准项，用 RLHF 鼓励自我反思，或者构建批判—修正的数据对。单靠堆参数，可能只得到更流畅的幻觉。

为何常见：模型规模扩大后确实会出现一些结构性改善，但“有监控能力”和“懂得用监控结果”之间还有一条需要训练铺设的通道。

面试题

Q1. 元认知能力最像以下哪一个场景？

单选题 · easy

  • A.厨师只顾放调料
  • B.厨师边做边尝味← 正确答案
  • C.服务员只知上菜
  • D.顾客大口吃菜

答案：B。元认知的核心是“对生成过程的监控与调节”。边做边尝味既是观察又是调整，对应模型的自我监控和主动纠错；其他选项都只是“做”“传”“吃”的单一动作。

Q2. 模型输出的 softmax 最大概率主要用于表示？

单选题 · easy

  • A.生成下一个词的概率← 正确答案
  • B.人类对答案的偏好
  • C.训练数据的大小
  • D.推理速度的快慢

答案：A。Softmax 把模型的 logits 转成词表上的概率分布，取最大值就是对下一个候选词的自信程度。它不代表人类偏好，也不表示数据量或速度。

Q3. 温度参数 T 在 softmax 中的作用是？

单选题 · mid

  • A.平滑或锐化概率分布← 正确答案
  • B.加快梯度下降速度
  • C.增加训练样本数量
  • D.修改词汇表大小

答案：A。T 越大，指数项差异被稀释，分布更平坦；T 越小，高 logits 项被放大，分布更尖锐。它只改变概率分布的“锐度”，不影响梯度和词表。

Q4. ECE 越小说明什么？

单选题 · mid

  • A.模型参数越少
  • B.置信度贴近准确率← 正确答案
  • C.生成速度越来越快
  • D.训练数据更加均匀

答案：B。ECE 衡量每个置信度区间内“模型自信平均分”和“真实正确率”的差距。ECE 越小，说明模型说 80% 确定时，确实约有 80% 答对，即校准越好。

Q5. 模型识别知识边界的主要价值是？

单选题 · mid

  • A.避免生成错误信息← 正确答案
  • B.增加模型参数量
  • C.提升文本生成速度
  • D.减少显卡显存占用

答案：A。识别知识边界让模型能在不确定时拒答或转交，从而减少幻觉和错误信息传播。参数量、速度、显存都与“是否知道自己不知道”没有直接关系。

Q6. Chain-of-Thought 让模型变准的核心原因是？

单选题 · hard

  • A.写出中间推理步骤← 正确答案
  • B.使用更大的显卡
  • C.增加训练轮次数
  • D.降低输出长度限制

答案：A。思维链通过把推理过程分解成可检查的中间步骤，让模型逐步推理并让监控器能定位矛盾。显卡、训练轮次和输出长度限制并非其准确率提升的本质。

Q7. 自我反思范式一般包含哪些环节？

多选题 · hard

  • A.首轮生成答案← 正确答案
  • B.对答案进行批判← 正确答案
  • C.根据批评精修← 正确答案
  • D.扩大训练语料

答案：ABC。自我反思的典型流程是“先生成，再批评，再修改”，循环迭代。“扩大训练语料”是训练阶段的事，不属于推理时反思循环。

Q8. 哪些方法可以帮助模型拥有更好的元认知？

多选题 · mid

  • A.置信度校准训练← 正确答案
  • B.自批判数据微调← 正确答案
  • C.多轮反思提示← 正确答案
  • D.固定随机种子

答案：ABC。校准、自批判微调和反思提示都能提升模型对自身输出的监控能力。固定随机种子只影响采样结果，无法带来元认知能力。

Q9. 关于 RLHF 中 KL 惩罚项的作用，正确的是？

多选题 · extreme

  • A.防止模型偏离参考模型← 正确答案
  • B.让策略更新更稳健← 正确答案
  • C.降低奖励模型误差风险← 正确答案
  • D.直接提高训练集大小

答案：ABC。KL 惩罚将当前策略限制在参考模型附近，避免只顾奖励最大化而失去语言能力，因此能提升稳定性和抗奖励攻击能力，但它并不会直接增加训练数据。

Q10. 模型主动说“我不确定”说明它？

单选题 · easy

  • A.正在识别知识边界← 正确答案
  • B.推理速度较慢
  • C.训练数据较少
  • D.随机数种子问题

答案：A。主动表达不确定，是元认知中“知识边界识别”的表现。它和速度、数据量、采样种子没有必然因果，更多来自模型对自身置信度的判断。