Deep-Thinking Tokens：用"预测不稳定Token"衡量LLM真实推理努力 · 干货攻略

链接:https://x.com/omarsar0/status/2025239354327924833
分类:x-tips
来源:X @omarsar0
作者:Jay
更新:2026-07-23

这是什么

这篇来自弗吉尼亚大学与 Google 的研究（arXiv:2602.13517，ICML 2026 录用）提出了一个核心问题：模型生成的 token 数量，真的能衡量它的推理努力吗？

答案是否定的。研究者发现，输出 token 数与准确率之间存在平均负相关（r = −0.544）——token 越多，反而可能越差。这被称为"过度思考"（overthinking）：模型陷入循环、放大错误、或对无关细节反复纠缠。

为此，论文提出 Deep-Thinking Ratio（DTR）——通过观察模型内部层间预测的变化，找出"真正在深度思考"的 token，并以此作为推理努力的新度量。

为什么值得关注

@omarsar0 分享这篇工作时指出了一个工程价值：判断"模型是否真的在想"有直接参考意义。具体而言：

评估层面：不再只看 token 数或 logprob，可以参考 DTR 判断模型是否在做有效推理
推理优化层面：DTR 可在生成 50 个 token 的前缀后就被估算出来，从而提前终止明显无望的生成路径，省下大量算力
训练信号层面：DTR 可作为奖励信号，引导模型在真正需要深度思考的地方多投入，而非单纯堆 token 长度

这项工作被 @omarsar0 标注为"对推理评估方法论有颠覆性"，不是夸张。

核验过程

官方来源

arXiv 摘要页（2602.13517）：确认论文全称为 Think Deep, Not Just Long: Measuring LLM Reasoning Effort via Deep-Thinking Tokens，作者团队以弗吉尼亚大学 Wei-Lin Chen 为首、联合作者包括 Google 研究员，v2 版本更新于 2026-07-06，发表于 ICML 2026。
arXiv HTML 全文页（2602.13517v2）：提取了关键数据——DTR 在 AIME 2024/2025、HMMT 2025、GPQA-Diamond 上与准确率的相关系数（r = 0.828 平均值，各子 benchmark 分别为 r = 0.862、0.715、0.941、0.795）；Token 数相关系数为 r = −0.544（各子 benchmark 分别为 −0.407、−0.704、−0.783、−0.284）。Think@n 在 AIME 2025 上达到 94.7% 准确率，均摊 token 消耗 155.4k，对比标准 Cons@n 为 92.7% / 307.6k。
arXiv PDF：确认了 DTR 的计算方法——对每个中间层 hidden state h_t^l 通过 unembedding matrix W_U 投影到词表空间得到分布 p_{t,l}，计算与最终层分布 p_{t,L} 之间的 Jensen-Shannon Divergence D_{t,l}，取 depth fraction ρ = 0.85（即 token 最终在最后 15% 层才稳定）。测试模型包括 GPT-OSS（20B / 120B 变体）、DeepSeek-R1-70B、Qwen3-30B-Thinking。

交叉验证

MarkTechPost 报道（2026-02-21）：独立描述了相同方法，复现了核心数字（AIME 2025 Think@n 94.7% vs 92.7%，成本减半），报道与论文官方数字一致。
YouTube 视频摘要（AI Paper Slop 频道）：提供了对论文结构的逐章解读，确认 DTR 的机制（late regime）、Think@n 早停逻辑（50 prefix tokens 后估算 DTR）在科普层面无错误传达。
X 推文转发链（@fly51fly 等多个科研账号）：多个独立信源引用了相同的 r = 0.828 平均相关系数和 AIME 2025 数字，交叉验证成立。

原帖与官方文档的一致性

原帖链接指向的推文（@omarsar0）核心主张为：Google 新工作，用"预测不稳定 Token"替代 token 数衡量推理努力。该主张与论文摘要高度一致，未发现冲突。

上手步骤

理解 DTR 的直观含义

对于一个给定 token，模型会经过 L 层 transformer：

浅层 token（如功能词 "and"、"is"）：预测在第 5 层左右就稳定了，后续层变化极小——模型几乎没"想"。
深度思考 token（如数学符号、关键推理词）：预测在第 30 层（以 36 层模型为例）左右才稳定——模型在这些 token 上投入了大量层间计算。

DTR = 序列中深度思考 token 的比例。比例越高，模型整体越在"认真推理"。

计算 DTR（伪代码）

import torch
from transformers import AutoModel
import torch.nn.functional as F

def compute_jsd(p, q):
    """Jensen-Shannon Divergence between two distributions."""
    m = 0.5 * (p + q)
    return 0.5 * F.kl_div(p.log(), m, reduction='batchmean') + \
           0.5 * F.kl_div(q.log(), m, reduction='batchmean')

def deep_thinking_ratio(model, input_ids, rho=0.85):
    """
    Compute DTR for a generated sequence.

    Args:
        model: Transformer model with hidden states accessible via output_hidden_states=True
        input_ids: Token IDs of the generated sequence (including prompt)
        rho: Depth fraction threshold (default 0.85 means token stabilizes in final 15% layers)

    Returns:
        DTR score (float)
    """
    num_layers = model.config.num_hidden_layers
    cutoff_depth = int(num_layers * rho)  # e.g., 36 * 0.85 = 30.6 → layer 31+

    with torch.no_grad():
        outputs = model(input_ids, output_hidden_states=True)
        hidden_states = outputs.hidden_states  # tuple of (num_layers + 1,) tensors

        deep_tokens = 0
        total_tokens = 0

        W_U = model.get_output_embeddings().weight  # unembedding matrix

        final_layer_states = hidden_states[-1][0]  # (seq_len, hidden_dim)
        final_layer_logits = final_layer_states @ W_U.T
        final_layer_dist = F.softmax(final_layer_logits, dim=-1)

        for tok_idx in range(1, input_ids.shape[1]):  # skip first token ( BOS)
            for layer_idx in range(1, num_layers + 1):
                layer_states = hidden_states[layer_idx][0, tok_idx]  # (hidden_dim,)
                layer_logits = layer_states @ W_U.T
                layer_dist = F.softmax(layer_logits, dim=-1)

                jsd = compute_jsd(layer_dist, final_layer_dist)

                # Check if this layer is already converged (below a small threshold)
                if jsd < 1e-4:  # converged
                    if layer_idx < cutoff_depth:
                        # Token converged early → NOT a deep-thinking token
                        break
                    else:
                        # Token only converged in late regime → deep-thinking token
                        deep_tokens += 1
                        total_tokens += 1
                        break
            else:
                # Never fully converged → treat as deep-thinking
                deep_tokens += 1
                total_tokens += 1

        return deep_tokens / total_tokens if total_tokens > 0 else 0.0

Think@n 推理策略（概念实现）

def think_at_n(model, prompt, n_candidates=48, n_select=8, prefix_len=50):
    """
    Think@n: select top-n candidates by DTR prefix, reject rest early.

    1. Sample N candidate completions from model
    2. After PREFIX_LEN tokens, compute DTR for each
    3. Keep only top-N_SELECT by DTR, abandon rest
    4. Complete remaining candidates and majority-vote
    """
    candidates_dtr = []

    for _ in range(n_candidates):
        # Generate up to prefix_len tokens
        partial_ids = model.generate(
            prompt,
            max_new_tokens=prefix_len,
            do_sample=True,
            return_dict_in_generate=True,
            output_hidden_states=True
        )

        # Compute DTR on the prefix (reuse compute_deep_thinking_ratio above)
        dtr = deep_thinking_ratio_from_ids(model, partial_ids.sequences[0])

        if dtr >= 0.5:  # threshold: keep promising candidates
            # Full generation continues in the final pass
            candidates_dtr.append((partial_ids.sequences[0], dtr))
        # else: early-stop this candidate

    # Sort by DTR descending and take top n_select
    candidates_dtr.sort(key=lambda x: x[1], reverse=True)
    selected = candidates_dtr[:n_select]

    # Complete selected candidates and majority vote
    answers = []
    for seq_ids, _ in selected:
        full_output = model.generate(seq_ids.unsqueeze(0), ...)
        answers.append(decode(full_output))

    return majority_vote(answers)

注意：上述为概念伪代码。实际实现需考虑 GPU 内存管理（hidden states 会显著增加显存占用）、JSD 计算的数值稳定性，以及针对具体模型的层数 L 和 ρ 超参调优。ρ = 0.85 是论文默认值，不同模型架构可能需要调整。

在现有 RAG/Agent 流水线中集成 DTR

如果你的系统已经在用 self-consistency（采样 → 投票）做答案筛选，可以将 DTR 作为额外过滤维度叠加：

# 在候选答案生成后、投票前，按 DTR 过滤
candidates = generate_n_candidates(prompt, n=48)
scored = []
for cand in candidates:
    dtr = compute_dtr(model, cand.input_ids)
    if dtr > threshold:  # 丢弃 DTR 过低的（模型在"瞎编"）
        scored.append((cand, dtr))

top_k = sorted(scored, key=lambda x: x[1], reverse=True)[:8]
final_answer = majority_vote([c.text for c, _ in top_k])

坑与适用边界

适用条件：

模型必须支持访问中间层 hidden states（大多数开源模型如 GPT-OSS、DeepSeek-R1、Qwen3 支持；部分商业闭源模型不开放）
DTR 计算需要在生成过程中做额外 forward pass，显存占用会比纯推理高约 20-30%（取决于层数）
深度思考 token 的判定依赖 ρ 参数，论文以 ρ = 0.85 为默认值，但模型深度不同最优值可能不同（如 70B 模型 vs 8B 模型）

已知的局限：

论文测试模型均为推理优化模型（thinking models / reasoning-focused models），在纯对话模型（如 instruction-tuned 但非 CoT 原生）上的相关性未知
DTR 衡量的是"内部计算量"，不是"答案正确性"——两者高度相关但不等价
50 token prefix 估算 DTR 的准确率（在完整序列上的估算相关性）与完整序列 DTR 的相关性为 r = 0.683（论文 Table 3，原帖引述）——意味着早停信号有约 17% 的误差，敏感场景需注意

未核验处：

论文声称 Think@n 可将推理成本降低 50%，该数字基于 AIME 2025 benchmark，在其他任务类型（代码生成、开放域问答）上的成本收益尚未被独立验证
ρ = 0.85 作为统一的 depth fraction threshold 是否适用于所有模型家族，论文未做全面的超参消融

一句话结论

DTR 用模型内部层间预测是否"晚期才稳定"来量化真正的推理努力，在 AIME/GPQA 等困难数学基准上相关系数达 r = 0.828（远超 token 数的 −0.544），可驱动 Think@n 实现推理精度提升兼成本腰斩，是判断模型是否"真的在想"的最优信号。

核验来源

arXiv 摘要页（2602.13517）— 论文标题、作者、ICML 2026 录用状态、DTR 定义、核心相关系数
arXiv HTML 全文页（2602.13517v2）— 各 benchmark 分项相关系数、Think@n 数字、DTR 计算细节
arXiv PDF（2602.13517）— GPT-OSS/DeepSeek-R1/Qwen3 模型族测试范围、ρ = 0.85 参数设置
MarkTechPost 报道（2026-02-21）— Think@n AIME 2025 准确率 94.7% vs 92.7%，成本 155.4k vs 307.6k tokens
YouTube 视频 / 多账号 X 转发链 — 交叉验证核心数字无异