Jev爆火：不生成文字，直接输出概率的决策模型

文章目录

• • 前言
  • [1. Jev 到底是干嘛的](#1. Jev 到底是干嘛的)
  • • [1.1 输入长什么样](#1.1 输入长什么样)
    • [1.2 输出（和一条让人感动的约束）](#1.2 输出（和一条让人感动的约束）)
  • [2. 为什么 Jev 突然就火了](#2. 为什么 Jev 突然就火了)
  • [3. 怎么理解它](#3. 怎么理解它)
  • • [3.1 如果你是 LLM 老手](#3.1 如果你是 LLM 老手)
    • [3.2 如果你是 BERT 时代老兵](#3.2 如果你是 BERT 时代老兵)
  • [4. 从两个开源项目还原 Jev 的技术路线](#4. 从两个开源项目还原 Jev 的技术路线)
  • • [4.1 Laya：BERT 复古，但复古得很精妙](#4.1 Laya：BERT 复古，但复古得很精妙)
    • • [4.1.1 输入是怎么拼的](#4.1.1 输入是怎么拼的)
      • [4.1.2 Forward 之后，概率怎么读出来](#4.1.2 Forward 之后，概率怎么读出来)
      • [4.1.3 多题并发怎么做](#4.1.3 多题并发怎么做)
    • [4.2 Kev：解码器变身并行决策机](#4.2 Kev：解码器变身并行决策机)
    • • [4.2.1 输入是怎么拼的](#4.2.1 输入是怎么拼的)
      • [4.2.2 问题隔离：Block-Causal Mask](#4.2.2 问题隔离：Block-Causal Mask)
      • [4.2.3 概率怎么读出来：Pointer Head](#4.2.3 概率怎么读出来：Pointer Head)
  • [5. 训练：决策模型要解决哪些问题](#5. 训练：决策模型要解决哪些问题)
  • • [5.1 概率校准（Calibration）](#5.1 概率校准（Calibration）)
    • [5.2 选项顺序无关（Permutation）](#5.2 选项顺序无关（Permutation）)
    • [5.3 有序打分的训练（RPS）](#5.3 有序打分的训练（RPS）)
    • [5.4 选项数量（Option Count）](#5.4 选项数量（Option Count）)
    • [5.5 没有正确选项怎么办](#5.5 没有正确选项怎么办)
  • [6. Jev 在 Harness 里能怎么用](#6. Jev 在 Harness 里能怎么用)
  • • [6.1 选择类：Skill Search](#6.1 选择类：Skill Search)
    • [6.2 围栏类：LLM Guardrail](#6.2 围栏类：LLM Guardrail)
    • [6.3 校验类：Reference Verify](#6.3 校验类：Reference Verify)

P.S. 推荐一个大神的教程给想要了解或者学习人工智能知识的读者，这个教程里内容讲解通俗易懂且风趣幽默，对我帮助很大。我想与大家分享这个宝藏教程，请点击下方链接查看，传送门https://blog.csdn.net/qq_74013365

前言

先聊个严肃的话题：为什么一个连字都不愿意多吐的模型，最近能火成这样？

因为它叫 Jev。名字听着像个说唱歌手的艺名，干的事却特别朴素------把"状态"变成"概率"。你给它一段描述，再扔几个问题，它直接还你每个选项的概率分布，全程不生成一个文字。

注意，是全程不吐一个字。省下来的算力，够我这种打工人多刷两部剧。

1. Jev 到底是干嘛的

一句话：它是一台"把状态变成概率"的机器。给它一个 state（字符串、JSON 都行），再给它几个 typed questions，它直接还你概率分布------一个字符都不生成。

1.1 输入长什么样

一个共享的 state，加上一堆运行时定义的问题。问题分三种型：

• choice：多项选择，候选集合上的分布；
• score：有序等级上的分布 / 期望；
• noul：yes 的概率。

1.2 输出（和一条让人感动的约束）

每个选项直接返回概率分布。关键约束：0 个输出 token 被 decode，所有结果一次 forward pass 全部拿到。

翻译成人话：别人是打字机，它是盖章机。咔一下，全出。

2. 为什么 Jev 突然就火了

一句话：它同时做到了三件之前互相矛盾的事------快、懂、可信。

	BERT 时代分类器	大模型	Jev
速度 / 并发	✅ 极快	❌ 慢	✅ 极快
复杂上下文理解	❌ 弱	✅ 强	✅ 强
概率输出可信	❌ 不可信	❌ 不可信	✅ 接近真实

什么叫"概率输出可信"？BERT 时代做分类，softmax 经常输出 0.9999 vs 0.9998。你盯着这两个数看半小时，也看不出它俩谁更接近正确答案，只能手动调阈值------本质上退化成排序器。

翻译：模型自己心里也没底，全靠你瞎调。

Jev 的目标是：模型说"60%"，现实中这件事就真的发生约 60% 的时间。这叫概率校准。有了它，下游决策直接拿概率值用，不再需要玄学调阈值。

3. 怎么理解它

3.1 如果你是 LLM 老手

你的第一反应大概率是：这不就是个 JSON 分类器？

......对，任务范式上确实如此。但类比一下：汽车也不过是"带引擎的马车"，但你不会说它俩一样------除非你刚考完科目二。

关键差异：LLM 是逐字生成，像挤牙膏；Jev 是一步读数，像看体检报告。没有 token-by-token 的自回归循环，hidden state 直接映射成概率------速度和并发差了一个数量级，延迟毫秒级。

另一个差异：LLM 输出的"概率"其实是 next-token 的条件概率，和"这件事发生的真实概率"没有直接关系。Jev 专门被训练来对齐这两者。

翻译：LLM 说"我 90% 确定"的时候，它只是在猜下一个字。跟你朋友说"我 90% 会到"，结果你等到凌晨三点他还在床上，是同一个道理。

3.2 如果你是 BERT 时代老兵

你的第一反应可能是：NLI 任务卷土重来？

也有道理，当年 BERT + NLI 那套确实干过类似的事。但有两个本质升级。

升级一：底座更强。ModernBERT-large（421M）和 Qwen3 级别的解码器，长上下文、复杂语义的理解远超当年。属于是开着超跑去送外卖。

升级二：概率校准。当年 BERT 分类器的 softmax 概率是"伪概率"，训练目标把它往 0 和 1 推，你拿到的数字没有概率意义。Jev 专门解决了这个问题------后面训练章节详细讲。

4. 从两个开源项目还原 Jev 的技术路线

Jev 本身不开源，但社区有两个有代表性的复现：Laya（编码器路线，ModernBERT 底座，比 Jev 还早）和 Kev（解码器路线，Qwen 底座，已被阿里云采用上线）。

我们从零开始讲：输入怎么拼 → 模型怎么跑 → 概率怎么读出来 → 多题怎么并发。架构和推理先讲，训练最后说。

4.1 Laya：BERT 复古，但复古得很精妙

一句话概述：BERT 基座，每个选项前面插一个 [MASK]，最后去这些 [MASK] 的隐藏向量上打分。

4.1.1 输入是怎么拼的

模板长这样：

[CLS] <type> question: <instructions> [SEP]  [MASK] opt0 [MASK] opt1 ... [SEP] <state> [SEP]

举个例子。客户说被扣了两次款，要退款不然退订：

state = "Hi, we were billed twice for March. Please refund the duplicate today or we will cancel our plan."
questions = {
    "department": {"type": "choice", "instructions": "Which department should handle this?",
                   "criteria": {"billing": "invoices, payments, refunds",
                                "technical": "bugs, outages, system errors",
                                "other": "everything else"}}
}

拼进模型的序列就是：

[CLS] choice question: Which department should handle this? [SEP]
[MASK] billing: invoices, payments, refunds
[MASK] technical: bugs, outages, system errors
[MASK] other: everything else
[SEP] Hi, we were billed twice for March. Please refund the duplicate today or we will cancel our plan. [SEP]

每个选项前面顶着一个 [MASK]。不知道的以为是给选项戴了口罩，其实是为了让它们能偷看全场。

妙就妙在：MASK 的位置在 Encoder 里能双向 attend 所有 token------它同时看到了问题、自己的选项描述、别人的选项描述、还有完整的 state。所以 MASK 位置的 hidden state，天然就是"当前语境下这个选项的综合表示"。

比开屏广告还能看。

4.1.2 Forward 之后，概率怎么读出来

四步走。第一步，Encoder 编码：

h = encoder(input).last_hidden_state  # shape: [Batch, Length, Hidden]

第二步，注入题型信息：

h = h + type_embedding(question_type)  # choice/score/noul 语义注入

第三步，决策头：再过一个 2 层的 transformer，从 Encoder 的通用表示里蒸馏出决策信号。

第四步，只读 MASK 位置，按不同题型归一化：

mask_hiddens = h[:, mask_positions, :]  # 只取 MASK 位置
logits = scorer(mask_hiddens)           # hidden → scalar

# 按题型分别处理
if type == "choice":
    logits_scaled = logits / t_scale    # t_scale 按题型×选项数分桶取温度
    probs = softmax(logits_scaled)
elif type == "score":
    probs = softmax(logits / t_scale)
    expected_score = sum(i * p_i for i, p_i in enumerate(probs))
elif type == "noul":
    probs = softmax(logits / t_scale)
    yes_prob = probs[1]                 # 直接取"是"的概率

注意那个 t_scale------按题型 × 选项数分桶的温度系数。这是 Laya 概率校准的关键手段，后面训练章节详细展开。

另外，Laya 还会从 [CLS] 的 hidden state + 4 个概率统计指标（熵、最大概率等）预测一个置信度分数，用来判断"这道题 AI 有没有把握，要不要转人工"。

翻译：模型自己心里也没底的时候，至少知道把锅甩给人类。

4.1.3 多题并发怎么做

一个 state 有 N 个问题时，Laya 用 Batch 推理：N 个问题各自构建一条序列，state 在每条序列里完整复制一份，然后一起打包进模型。

显存换速度，架构本身不支持 state 的 KV cache 共享。

翻译：复制粘贴 × N，钞能力换并发。

4.2 Kev：解码器变身并行决策机

一句话概述：把因果 LM 改造成并行决策机，关键是 block-causal 隔离 + pointer head。

4.2.1 输入是怎么拼的

Kev 基于 Qwen，是因果解码器，序列是线性的：

[ state tokens ]  [ <q> instr1 <opt> A </opt> <opt> B </opt> <opt> C </opt> <decide> ]
[ <q> instr2 <opt> X </opt> <opt> Y </opt> <decide> ]

State 在前面，各道题依次排列，每道题以 <decide> 结尾。

除了 token id，Kev 还维护几个并行数组，记录序列里每个 token 的"身份信息"：

数组名	含义	例子（5 个 state token + 1 道选择题 ABC）
ids	token id 序列	[s0,s1,s2,s3,s4, <q>,i0,i1, <opt>,A,</opt>, <opt>,B,</opt>, <opt>,C,</opt>, <decide>]
seg	每个 token 属于哪道题（0=state）	[0,0,0,0,0, 1,1,1, 1,1,1, 1,1,1, 1,1,1, 1]
pos	position id	state: [0..4]；每个问题都重置，重新从 5 开始
opt	属于该题的第几个选项（OPT_NONE/0/1/2/OPT_DECIDE）	[-, -, -, ..., NONE, NONE, 0, 0, 0, 1, 1, 1, 2, 2, 2, DECIDE]
decide_idx	<decide> 在 ids 中的位置	[17]
opt_idx	每个 </opt> 的位置	[[10, 13, 16]]（对应 A/B/C 的边界）

这些数组在 Forward 之后用来精准定位"去哪个位置读概率"。

4.2.2 问题隔离：Block-Causal Mask

Decoder 默认是因果掩码------每个 token 只能看到自己前面的 token。这会导致：第二道题的 <decide> 能看到第一道题的所有选项，两道题的概率互相污染。

比大学宿舍串味儿还严重。

Kev 的解法是 Block-Causal Mask：

题目1内部：完整因果注意力（可以看 state + 题目1自己的 token）
题目2内部：完整因果注意力（可以看 state + 题目2自己的 token）
题目1 → 题目2：完全屏蔽（attention mask = -inf）

效果类似滑动窗口注意力，每道题只在自己的"小世界"里做注意力，题目之间完全隔离。

Kev 还提供了更激进的 Option Isolation：题目内部各个选项之间也互相屏蔽，每个选项独立 attend state 和问题指令，选项之间完全不知道彼此的存在。

像极了办公室里互相甩锅的同事。

注意：Option Isolation 有适用限制。如果选项里有"其他"这类相对性选项，选项之间需要"知道彼此"才能正确理解语义------"其他"得先知道别的选项都说了啥，才知道自己算老几。

就像"我不是针对谁"这句话，得先知道全场的谁都在，才成立。

4.2.3 概率怎么读出来：Pointer Head

Forward 完成后，每个 token 都有一个 hidden state。Kev 用 Pointer Head 把这些向量变成概率：

# <decide> 位置的 hidden → 决策 query（"我想选哪个"）
q = proj_q(hidden[decide_idx])          # shape: [D]

# 每个 </opt> 位置的 hidden → 选项 key（"我是第 k 个选项"）
k = proj_k(hidden[opt_idx])             # shape: [num_options, D]

# 点积打分 → softmax → 概率
logits = (q @ k.T)                       # shape: [num_options]
probs = softmax(logits / temperature)

为什么用 <decide> 而不是其他位置？因果解码器里，只有序列中"最后一个能看到所有选项"的 token 才能做全局比较。<decide> 被设计在每道题的最末尾，正是这个角色------它 attend 完该题的完整选项列表，再综合判断。

翻译：全场最终解释权归 <decide>。

Pointer Head 对选项数天然友好：普通 joint softmax 选项越多分母越大，概率被稀释；Pointer Head 每个 logit 是 <decide> 和 </opt> 的点积，选项数不影响 logit 的绝对量级，最后才做 softmax。这比 Laya 的联合 softmax 对选项数变化更鲁棒。

翻译：别人是聚餐 AA，人越多每人越少；它是分餐制，加菜不影响我这份。

5. 训练：决策模型要解决哪些问题

把推理层搭好只是第一步。让模型真正输出"有意义的概率"，训练阶段要专门解决五个问题。

5.1 概率校准（Calibration）

猜测方案：合成数据 + soft labels 蒸馏 + soft cross-entropy 训练 + 后验温度系数。

问题根源：Cross-entropy 的理论最优解确实是真实概率分布。但理论归理论，实践中神经网络在 loss 降得很低时，logit 被推得越来越大，softmax 越来越尖------argmax 很对，但概率的刻度已经失真。

最典型症状：模型对一道 60/40 开的问题，输出 0.9999, 0.0001。方向对了，但概率值骗人。

翻译：就像你问朋友"你到底来不来"，他说"99.99% 来"，结果你等到凌晨三点，他还在床上。

解法①：Soft Label + Soft Cross-Entropy

根本矛盾是标签不诚实。解法是换掉标签：

# 硬标签（过度自信的根源）
hard_label = [0, 1, 0]

# Soft Label（更接近真实世界）
soft_label = [0.1, 0.8, 0.1]

# Soft Cross-Entropy
loss = -sum(soft_label[i] * log(pred[i]) for i in range(K))

Soft Label 从哪来？最可能的路线：用大模型或多个模型对同一个样本重复采样，统计各选项被选的频率，作为该样本的 soft label。本质上是对真实分布的蒙特卡罗估计。

翻译：多问几个 AI，取个平均数，跟居委会做民意调查似的。

解法②：后验温度缩放

光靠训练还不够。Kev 和 Laya 都在训练完成后，用验证集拟合一个温度系数 T：

# T > 1：概率分布变软（修正过度自信）
# T < 1：概率分布变尖（修正过度保守）
calibrated_probs = softmax(logits / T)

T 不是全局值，而是按题型 × 选项数分桶拟合。"3 个选项的 choice"和"5 个选项的 choice"用不同的 T。

效果有多狠？Laya 校准前 ECE 高达 0.466，分桶拟合后降到 0.081------几乎全部校准效果来自这一步。从"满嘴跑火车"到"基本靠谱"，全靠一个旋钮。

5.2 选项顺序无关（Permutation）

引入 Permutation KL（置换一致性）：把同一道题的选项随机打乱，要求输出分布（对应到选项）不变。

perm_logits = model(permuted_input)
perm_kl = KL(softmax(logits[original_order]) || softmax(perm_logits[inv_perm]))

并且训练时对选项顺序做 shuffle，推理时让所有选项的位置编码一致，不引入偏差。

翻译：防止模型记住"选项 B 永远是对的"这种职场潜规则。

5.3 有序打分的训练（RPS）

Score 题（1-5 分）如果当普通分类训练，损失函数对所有错误一视同仁------预测 2 分而真实是 3 分，和预测 5 分而真实是 3 分，loss 一样大。但显然后者错得更离谱。

就像你问同事几点开会，他说"下午"，跟你问他明天开，离谱程度能一样吗？

解法：RPS（Ranked Probability Score），用累积分布函数（CDF）的平方差作为损失：

rps = sum((CDF_pred[j] - CDF_target[j])**2 for j in range(K-1))

这个损失的本质：惩罚"分布形状"的错误，而不只是"峰值位置"的错误。预测集中在 2-3 分的模型，比预测集中在 1 分的模型，RPS 更小------即使两者的 argmax 都是"错的"。

翻译：不只看你猜没猜对，还看你偏得有多离谱。像极了查户口：不只看你有没有房，还看你有几套。

5.4 选项数量（Option Count）

这个问题的本质是 softmax 的归一化耦合：所有选项共享一个归一化分母，选项数越多，单个选项的概率天然被稀释。

这不是 bug，是数学的物理规律------就像人越多，AA 聚餐每人就越少。

Kev 的架构受影响较小，因为每个选项和 <decide> 独立计算 logit 之后再归一化。

残余问题靠分桶温度补救：温度系数按选项数分桶，2 选题和 10 选题用不同的 T，在后验层面对齐不同选项数下的概率刻度。

但要接受：选项数的影响是天然存在的，跨选项数直接比较两道题的概率，语义上本来就不合适，不是能完全修好的 bug。

你非拿 2 选 1 的"60%"和 10 选 1 的"60%"比，就像非拿篮球 60 分和考试 60 分比------都是 60，但不是一个世界。

5.5 没有正确选项怎么办

比较朴素的：Kev 默认在训练和推理中都加入 "None-of-Above" 选项：

options_augmented = options + ["[NONE_OF_ABOVE]"]

翻译：以上都不对。这招跟某些调查问卷学坏了。

Laya 的方案是同时输出选项概率和置信度分数（基于 [CLS] hidden state + 熵等统计指标）。当置信度低于阈值时，直接拒绝所有概率输出，标记为"无可信答案"。

翻译：模型承认"这题我搞不定，转人工"，比某些客服机器人诚实多了。

6. Jev 在 Harness 里能怎么用

最后看看在 Harness 框架搭建中，有哪些可以利用 Jev 进行优化、提速的点。

这里抛砖引玉，给出几个方向。部分场景还没验证------毕竟 AI 写代码太快，验证场景又太复杂。

6.1 选择类：Skill Search

用用户 query 和 agent 所有候选技能作为输入，判断解决用户问题是否需要使用技能；如果需要，用哪个技能。

本质是给 agent 装了个"用什么工具"的导航。类似的思路还能用在 MCP search、effort routing、memory search 等等。

不过 model routing 在我的使用场景里往往效率提升不明显、质量下降很明显------因为对场景复杂度的评估需要更全面的上文。实现很简单，效果很难评。

翻译：省了 1 秒，错了一道题，亏到姥姥家。

6.2 围栏类：LLM Guardrail

拦截用户的各类风险输入和 prompt 注入。这里提供了 9 种基础的风险类型，每种风险可以给不同的处置方案：block、review 等。

翻译：给 LLM 装了个门卫大爷，还带分级安检的那种。

类似的思路也能用于模型输出检查、tool call 检查等。

6.3 校验类：Reference Verify

适用于 inline 引用：提供模型推理段落 + inline 推理 + 对应 reference 正文，判断搜索上文能否支持推理输出。

翻译：AI 学术版"查重"，连引用都给你验明正身。

类似的思路也可以用于 tool result 校验、agent 结果校验，用在 loop 里检查 task completed 等等。

总之，Jev 这波火的不是玄学，是把"快、懂、可信"三个原本互相打架的需求，用一套决策模型焊死了。至于它能不能成为你 harness 里的常驻员工------反正它不吐字、不占带宽，还不用发工资。

P.S. 推荐一个大神的教程给想要了解或者学习人工智能知识的读者，这个教程里内容讲解通俗易懂且风趣幽默，对我帮助很大。我想与大家分享这个宝藏教程，请点击下方链接查看，传送门https://blog.csdn.net/qq_74013365