一次前向传播,同时回答"这单归哪个部门、有多急、客户是不是要跑路"三个问题,带校准概率, 不生成一个 token。本文介绍 Laya 这个开源决策引擎,并给出 laya-java 在 Spring Boot 中的 完整落地方案——含对象池并发处理,所有代码对照上游源码核实过。
假设你在维护一个客服工单系统,需求很朴素:每条工单进来,判断归属部门、紧急程度、 客户流失风险,然后路由给对应队列。
2026 年的默认解法是调 LLM:写一段 prompt,让模型输出 JSON,解析、校验、重试。 能跑,但你很快会撞上三堵墙:
问题的本质是:分类不需要生成能力。你不需要模型"写"出答案,只需要它在固定选项上 给出一个概率分布。这正是 Laya 的切入点。
Laya(Apache-2.0,35k+ star)把自己定位为 非自回归的 System 1 决策引擎——借用卡尼曼的术语:不做慢思考的推理链, 只做快思考的直觉判断。
技术上它是一个双向编码器(ModernBERT / mmBERT 家族,150M~421M 参数)加一个类型化决策头, 对任意文本 + 一组问题定义,单次前向传播输出三类答案:
| 类型 | 语义 | 输出 |
|---|---|---|
choice | 多选一 | 选中的标签 + 每个选项的概率 |
score | 等级打分 | 各等级的期望分 + 概率分布 |
noul | 是/否判断 | 命题成立的概率 |
官方口径:english checkpoint 在 T4 上单次决策约 33ms(multilingual 的 T4 参考值为 32.8ms/问题)。同一个 state 的多个问题合并成一个 batch 编码—— 三个问题不是三次调用,是一次前向里的三行。
一句话:所有"从固定选项里挑一个/打个分/判个真假"的场景,它都比生成式 LLM 便宜、快、稳。
① 快且便宜。 非自回归意味着计算量只跟输入长度有关,跟"答案长度"无关。 encoder 一次过,没有 KV cache、没有逐 token 采样。322M~421M 的模型 CPU 都能跑, 不需要 GPU 集群,更没有按 token 计费的 API 账单。
② 输出天然结构化。 答案就是标签 + 概率分布,不存在 JSON 解析失败、 不存在编造选项——概率只分布在你定义的选项上,这是架构保证而不是 prompt 约束。
③ 校准与保守预测。 这是它跟"随便训个分类器"最大的区别。Laya 用
RLCD(针对 strictly proper scoring rule 的强化学习)训练,输出经过温度校准;
vega 路线还带 conformal prediction set(保覆盖的候选集)、abstain(弃答)、
OOD 标记,最终汇成一个 route: auto/review 字段——该转人工它自己会说,
而不是给个虚高的置信度让你踩坑。
④ 多语言。 multilingual checkpoint(mmBERT-base,322M)覆盖 100+ 语言,
出厂默认 1024 token 上下文——编码器本身支持 8192,Python 侧传 max_len=8192
就能读长文;java 侧跟 checkpoint 配置走,长文用 predictLong(见第五节)。
注意一个坑:english checkpoint 对非英文不是"变差"而是"崩溃"——
官方实测 20 选项印地语意图分类准确率 0.100,随机猜是 0.050,而且置信度照样很高。
中文业务必须用 multilingual,这条没有商量余地。
⑤ 少量标注就能提效(vegaml 路线)。 Agent(vegaml=True) 的 fit() 冻结底座,
只在特征上训一个 logistic head + 温度校准,几秒完成、不遗忘任何其他问题;
head 打不过 zero-shot 底座就不上线。官方示例:40 行标注把路由准确率从 0.60 提到 0.90。
注意这是 vegaml(0.8B reader)路线的能力;本文 demo 用的 laya checkpoint
走的是另一条路——梯度微调(官方 RLCD notebook)加温度拟合(laya/calibrate.py),
两条路线的工具别混用。
⑥ 多语言 SDK。 Python 为主,另有 Java/Go/Rust/TS/C++/.NET 六个移植, Java 版走 ONNX Runtime,JVM 进程内推理,不需要 Python sidecar。
技术文章不该只唱赞歌,这几条官方自己都写在 README 里:
usage.truncated()(下文实战会处理)。laya-java 的设计很克制:JDK 17+,唯一运行时依赖 com.microsoft.onnxruntime。
tokenizer、序列构建、语言检测、答案解码全部纯 Java 实现,与 Python 参考实现做
fixture 级 parity 测试(20 万随机 logit 行里四位小数概率仅 88 行有浮点末位差异)。
架构上你需要理解两个目录:
checkpoint 目录 graph 目录 ├── rl_agent_config.json ├── laya.onnx (图结构, ~2.8MB) ├── tokenizer/ └── laya.onnx.data (外部权重, 1.29GB) └── encoder/config.json
Agent.open(checkpointDir, graphDir) 把两者组装成一个可推理的 Agent。
SDK 自己不下载任何东西——模型准备是部署前的一次性离线步骤(下文第四节)。
三个必须记住的 API 约束,全是踩坑点:
① Agent 非线程安全。 官方 README 原话:一个 Agent 不能并发 predict, 要么每 worker 一个,要么串行化。这直接决定了 Spring Boot 集成的形态——对象池。
② 选项顺序 = logit 顺序。 choice 的第 N 个选项对应第 N 个 logit。
用 HashMap 装选项,迭代顺序一变,probabilities().get("refund") 读到的就是
别的选项的概率。SDK 干脆拒绝 HashMap/Map.of,只收 LinkedHashMap 或
Question.choiceOf(...)。这是我见过的最"防御性"的 API 设计之一,点赞。
③ 两种置信度不是一个东西。 answerConfidence() = max(p),是温度校准的对象;
confidence() 对 choice/score 是归一化熵、对 noul 是 max(p, 1-p)。
量纲不同,不能共用一个阈值。 门控请用 answerConfidence。
下面是一个可跑的完整 demo(源码已随本文交付,工程名 laya-springboot-demo):
POST /api/triage 接收工单文本,一次前向同时输出部门/紧急度/流失风险。
模型用 multilingual,中文直接可用。
laya-java 未发 Central,先本地构建(仓库自带 Gradle wrapper,无需预装 Gradle):
bashgit clone --depth 1 https://github.com/NandhaKishorM/laya.git
cd laya/laya-java
./gradlew publishToMavenLocal -x test
# 产物: ~/.m2/repository/com/convaiinnovations/laya-java/0.1.0-SNAPSHOT/
模型准备用官方脚本一步完成下载 + ONNX 导出(需要 Python 3.10+,仅这一步需要):
bashcd laya
python3 -m venv .venv
.venv/bin/python -m pip install "laya[onnx]"
# 国内网络走 HF 镜像(社区镜像,已验证覆盖 laya 仓库)
# PowerShell 用 $env:HF_ENDPOINT="https://hf-mirror.com",同样每个终端执行一次
export HF_ENDPOINT=https://hf-mirror.com
.venv/bin/python laya-java/scripts/prepare_checkpoint.py --checkpoint multilingual
# 产物:
# laya-java/.work/checkpoints/multilingual/ <- checkpoint 目录
# laya-java/.work/onnx/multilingual/ <- 图目录 (laya.onnx + laya.onnx.data)
磁盘预算约 4GB(checkpoint ~850MB + 图 1.29GB + torch 依赖)。脚本幂等,
断网重跑即可续传。注意 laya.onnx 和 laya.onnx.data 必须同目录——
权重在后者里,只拷 .onnx 文件会得到一个空壳。
xml<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.4.5</version>
</parent>
<properties>
<java.version>17</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.convaiinnovations</groupId>
<artifactId>laya-java</artifactId>
<version>0.1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.12.1</version>
</dependency>
</dependencies>
yaml# application.yml
laya:
checkpoint-dir: ${LAYA_CHECKPOINT_DIR:./models/checkpoints/multilingual}
graph-dir: ${LAYA_GRAPH_DIR:./models/onnx/multilingual}
pool:
max-total: 2 # 池上限 = 最大并发推理数,见下文内存账
max-idle: 2
min-idle: 0
max-wait: 10s # 借用超时 -> 503
ort-threads: 1 # 每个 Agent 的 ONNX intra-op 线程数
内存账先算清楚:每个 Agent 独占一份图权重,multilingual 融合图 1.29GB,
运行时按每 Agent ~1.5GB 预算。max-total=2 ≈ 3GB + JVM 本身。
池上限不是随便调的吞吐旋钮,是内存预算的直接表达。
并发模型有两种选择:
Agent.open(..., threads=1),
并发完全交给池和 Tomcat 请求线程。每个请求独占一个 Agent,隔离干净,
池上限即背压阈值。工厂实现,注意 create 时的快速失败校验和 destroy 时的本地内存释放:
javapublic class LayaAgentFactory extends BasePooledObjectFactory<Agent> {
private final Path checkpointDir;
private final Path graphDir;
private final int ortThreads;
public LayaAgentFactory(Path checkpointDir, Path graphDir, int ortThreads) {
this.checkpointDir = checkpointDir;
this.graphDir = graphDir;
this.ortThreads = ortThreads;
}
@Override
public Agent create() throws IOException {
// 路径错了在创建时就报可操作的错,而不是等首个请求 NPE
if (!Files.isRegularFile(checkpointDir.resolve("rl_agent_config.json"))) {
throw new IOException("checkpoint 目录缺少 rl_agent_config.json: " + checkpointDir);
}
if (!Files.isRegularFile(graphDir.resolve("laya.onnx"))) {
throw new IOException("图目录缺少 laya.onnx: " + graphDir);
}
return Agent.open(checkpointDir, graphDir, ortThreads);
}
@Override
public PooledObject<Agent> wrap(Agent agent) {
return new DefaultPooledObject<>(agent);
}
@Override
public void destroyObject(PooledObject<Agent> p) {
p.getObject().close(); // 幂等,释放 ONNX session 本地内存
}
}
池 Bean,destroyMethod = "close" 让应用停机时逐个释放 Agent:
java@Configuration
public class LayaPoolConfig {
@Bean(destroyMethod = "close")
public GenericObjectPool<Agent> layaAgentPool(LayaProperties props) {
LayaProperties.Pool p = props.pool();
GenericObjectPoolConfig<Agent> config = new GenericObjectPoolConfig<>();
config.setMaxTotal(p.maxTotal());
config.setMaxIdle(p.maxIdle());
config.setMinIdle(p.minIdle());
config.setMaxWait(p.maxWait());
config.setBlockWhenExhausted(true); // 过载时有限排队,不无限建 Agent
config.setJmxEnabled(false);
return new GenericObjectPool<>(
new LayaAgentFactory(Path.of(props.checkpointDir()),
Path.of(props.graphDir()), p.ortThreads()),
config);
}
}
三个参数值得展开:
blockWhenExhausted=true + maxWait=10s:并发超过池上限时排队而不是报错,
但最多等 10 秒——超时抛 NoSuchElementException,上层转 503。
有限排队 + 明确拒绝,比无限堆请求或立刻失败都体面。min-idle=0:lazy 加载,首个请求才建 Agent(加载 1.29GB 图要数十秒)。
在意首请求延迟的话,把 min-idle 拉满并配 eviction 线程做启动预热。testOnBorrow=false:Agent 是进程内对象,不会像网络连接那样悄悄断掉,
借出校验纯属浪费。javaprivate static Map<String, Question> buildQuestions() {
Map<String, Question> qs = new LinkedHashMap<>();
qs.put("department", Question.choiceOf(
"Which department should handle this message?",
Map.entry("billing", "invoices, payments, refunds, duplicate charges"),
Map.entry("technical", "bugs, outages, errors, integration problems"),
Map.entry("hr", "jobs, payroll, leave, company policy"),
Map.entry("other", "everything else")));
qs.put("urgency", Question.score("How soon does this need a reply?",
List.of("can wait", "this week", "today")));
qs.put("churn_risk", Question.noul("The customer threatens to cancel or leave."));
return Collections.unmodifiableMap(qs);
}
细节:choiceOf 用可变参数 Entry 保证顺序,绕开 Map 类型陷阱;
问题集构建一次存成只读——选项渲染有开销,且顺序绝不能在不同请求间漂移。
criteria 的描述文本就是"零样本 prompt",写清楚每个选项覆盖什么,准确率立竿见影。
java@Service
public class TriageService {
private final GenericObjectPool<Agent> pool;
private final Map<String, Question> questions = buildQuestions();
public TriageService(GenericObjectPool<Agent> pool) {
this.pool = pool;
}
public TriageResponse triage(String text) {
Agent agent = borrow();
try {
// 三个问题,一次批量前向。语言传 null:单 multilingual 模型不需要语言温度 override
Prediction p = agent.predict(text, questions, null);
Answer.Choice dept = (Answer.Choice) p.answer("department");
Answer.Score urgency = (Answer.Score) p.answer("urgency");
Answer.Noul churn = (Answer.Noul) p.answer("churn_risk");
if (p.usage().truncated()) { // 静默截断必须显式暴露
log.warn("state 被截断: dropped={} tokens", p.usage().stateTokensDropped());
}
return new TriageResponse(
dept.choice(), dept.probabilities(), dept.answerConfidence(),
urgency.score(), urgency.legend(), churn.noul(),
new TriageResponse.UsageInfo(p.usage().inputTokens(),
p.usage().stateTokens(), p.usage().truncated()));
} finally {
pool.returnObject(agent); // 异常也要归还,池不泄漏
}
}
private Agent borrow() {
try {
return pool.borrowObject();
} catch (NoSuchElementException e) {
throw e; // 池耗尽 -> Controller 转 503
} catch (Exception e) {
throw new IllegalStateException("借用 laya Agent 失败", e);
}
}
}
Answer 是 sealed interface(Choice/Score/Noul 三个 record),JDK 21 上可以用
穷尽 switch,17 上用 instanceof pattern 即可。取答案的强转在问题类型固定时是安全的——
question 定义是什么类型,answer 就是什么类型。
java@RestController
public class TriageController {
public record TriageRequest(String text) {}
private final TriageService triageService;
public TriageController(TriageService triageService) {
this.triageService = triageService;
}
@PostMapping("/api/triage")
public TriageResponse triage(@RequestBody TriageRequest request) {
if (request == null || request.text() == null || request.text().isBlank()) {
throw new IllegalArgumentException("text 不能为空");
}
return triageService.triage(request.text());
}
@ExceptionHandler(NoSuchElementException.class)
public ResponseEntity<String> overloaded(NoSuchElementException e) {
return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
.body("推理并发已满,请稍后重试");
}
}
bashexport JAVA_HOME=$(/usr/libexec/java_home -v 17) # JDK 17+,8 会 UnsupportedClassVersionError
export LAYA_CHECKPOINT_DIR=/path/to/laya/laya-java/.work/checkpoints/multilingual
export LAYA_GRAPH_DIR=/path/to/laya/laya-java/.work/onnx/multilingual
mvn package -DskipTests
java -jar target/laya-springboot-demo-0.1.0.jar
bashcurl -s http://localhost:8080/api/triage -X POST \
-H 'Content-Type: application/json' \
-d '{"text":"我们三月份被重复扣款了,请今天之内退还多扣的一笔,否则我们就退订。"}'
期望返回(数值以实际为准):
json{
"department": "billing",
"departmentProbabilities": {"billing": 0.91, "technical": 0.04, "hr": 0.01, "other": 0.04},
"departmentAnswerConfidence": 0.91,
"urgencyScore": 1.8,
"urgencyLegend": {"0": "can wait", "1": "this week", "2": "today"},
"churnRiskProbability": 0.87,
"usage": {"inputTokens": 210, "stateTokens": 35, "truncated": false}
}
三个判断、一套概率、一次前向,没有 JSON 解析重试,没有 prompt 工程,没有 token 账单。
demo 到生产还差这几步,按优先级:
laya/calibrate.py 的 fit_temperature_map
按(问题类型, 选项数)分桶拟合温度并持久化(java 侧加载时读 checkpoint 里的
温度表),再定门控线。注意别用成 vegaml 的 fit()——那是另一条路线的工具。
简单起步:用 ConfidenceGate.apply(answers, threshold) 对低置信答案标记
ABSTAINED 转人工,阈值从保守值开始灰度。elapsedMs、usage.inputTokens、
池的 active/idle/borrowWait 指标;截断率单独告警——它是静默的。predictLong(滑窗扫描,noul 取窗口最大 P(true),
choice 取最自信窗口),注意其概率是"决策窗口的"而非全文校准值。--quantize 在
scripts/export_onnx.py 上(prepare_checkpoint.py 没有这个参数,需单独跑
导出脚本),产物 laya.int8.onnx 仅 CPU 可用,体积小 1.4~2.8 倍、比 fp32
ONNX 快约 1.8 倍,但官方明确警告这是拿真实精度换的(multilingual 与 fp32
的决策一致率仅 83%),凡是在意校准概率/置信度的场景不要用——而本文
主打的恰恰是校准概率。predictBatch(states, questions, lang, batchSize, true)——
批量本身对逐条循环就有收益(官方 CLI 实测 20 条工单 2.6 倍);sortByLength
再按长度分组减 padding,官方实测 1.42 倍(128 条 Yelp,Apple silicon)、
java 侧约 1.48 倍(M1,80 条长短交替)、研究侧 2.15 倍(1 万条合成多语工单),
结果顺序不变。合理的架构往往是分层:Laya 做高频、低延迟的第一道判断(覆盖 80%+ 的确定性流量), 低置信/弃答的少数流量升级给 LLM 或人工。判断题交给判断题选手,作文题才交给作文选手。
Laya 的价值不是"又一个模型",而是把"决策"从"生成"里拆出来单独定价: 单次前向、结构化输出、校准概率、进程内推理。laya-java 让这套能力以纯 JVM 依赖的形态 进入 Spring Boot——一个 commons-pool2 池解决它唯一的并发约束,剩下的就是普通的 Bean 和 Controller。
*项目地址:github.com/NandhaKishorM/laya(Apache-2.0)。
本文作者:Weee
本文链接:
版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!