编辑
2026-11-19
实用工具
0

目录

别再拿大模型做工单分类了:33ms 出结果的 Laya,以及如何在 Spring Boot 里本地跑起来
一、一个熟悉的场景
二、Laya 是什么
2.1 它解决什么
2.2 优势在哪
2.3 诚实的边界
三、laya-java:JVM 里的本地推理
四、Spring Boot 实战:对象池 + REST 接口
4.1 一次性准备:构建 SDK 与导出模型
4.2 依赖与配置
4.3 对象池:为什么以及怎么配
4.4 问题定义:一次构建,处处复用
4.5 服务层:borrow → predict → finally return
4.6 接口层与过载语义
4.7 跑起来
五、生产化清单
六、什么时候不该用它
七、小结

别再拿大模型做工单分类了:33ms 出结果的 Laya,以及如何在 Spring Boot 里本地跑起来

一次前向传播,同时回答"这单归哪个部门、有多急、客户是不是要跑路"三个问题,带校准概率, 不生成一个 token。本文介绍 Laya 这个开源决策引擎,并给出 laya-java 在 Spring Boot 中的 完整落地方案——含对象池并发处理,所有代码对照上游源码核实过。

一、一个熟悉的场景

假设你在维护一个客服工单系统,需求很朴素:每条工单进来,判断归属部门、紧急程度、 客户流失风险,然后路由给对应队列。

2026 年的默认解法是调 LLM:写一段 prompt,让模型输出 JSON,解析、校验、重试。 能跑,但你很快会撞上三堵墙:

  1. 延迟。自回归生成几十个 token,哪怕流式输出,一次分类也要几百毫秒到几秒。 工单高峰每秒几百条,LLM 网关先排队。
  2. 成本。分类是个"判断题",你却按"作文题"付费——输入输出 token 双向计费, 一天几十万条工单,账单比模型本身聪明。
  3. 不确定性。JSON 偶尔格式崩坏、选项偶尔 hallucinate 出一个不存在的部门、 置信度全靠模型自报(而它普遍过自信)。你被迫写一堆防御性解析代码。

问题的本质是:分类不需要生成能力。你不需要模型"写"出答案,只需要它在固定选项上 给出一个概率分布。这正是 Laya 的切入点。

二、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 编码—— 三个问题不是三次调用,是一次前向里的三行。

2.1 它解决什么

  • 工单/邮件分流:部门归属、优先级、是否需要人工
  • 意图识别:对话系统的入口路由,几十上百个 intent 标签
  • 内容审核:违规判断 + 置信度门控,低置信自动转人工
  • Agent 工具路由:LangChain/CrewAI 里"该调哪个工具"的判断层
  • 结构化字段抽取:JSON Schema 里的 enum/boolean/有界数值字段,直接映射成三类问题

一句话:所有"从固定选项里挑一个/打个分/判个真假"的场景,它都比生成式 LLM 便宜、快、稳。

2.2 优势在哪

① 快且便宜。 非自回归意味着计算量只跟输入长度有关,跟"答案长度"无关。 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。

2.3 诚实的边界

技术文章不该只唱赞歌,这几条官方自己都写在 README 里:

  • 它不生成。写摘要、写回复、开放问答,仍然找 LLM。它是判断题选手,不是作文选手。
  • shipped checkpoint 过自信,multilingual 尤甚。官方实测出厂平均 ECE: english 0.466、multilingual 0.314,按(问题类型, 选项数)拟合温度后才降到 0.081 / 0.106;而且 multilingual 出厂连拟合温度都没有(english 有)。 本文 demo 用的正是 multilingual——温度要在你自己的数据上拟合验证后, 校准保证才成立。别拿 0.9 的 answerConfidence 直接当"90% 正确率"用。
  • 长文本静默截断。超出预算的部分直接丢掉且不报错,调用方必须主动查 usage.truncated()(下文实战会处理)。
  • java SDK 还很年轻。0.1.0-SNAPSHOT,未发 Maven Central,需要源码构建; HTTP client 模块尚未实现。

三、laya-java:JVM 里的本地推理

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。

四、Spring Boot 实战:对象池 + REST 接口

下面是一个可跑的完整 demo(源码已随本文交付,工程名 laya-springboot-demo): POST /api/triage 接收工单文本,一次前向同时输出部门/紧急度/流失风险。 模型用 multilingual,中文直接可用。

4.1 一次性准备:构建 SDK 与导出模型

laya-java 未发 Central,先本地构建(仓库自带 Gradle wrapper,无需预装 Gradle):

bash
git 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+,仅这一步需要):

bash
cd 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 文件会得到一个空壳。

4.2 依赖与配置

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 本身。 池上限不是随便调的吞吐旋钮,是内存预算的直接表达。

4.3 对象池:为什么以及怎么配

并发模型有两种选择:

  • 单 Agent + ONNX 多线程:官方说"除非 ORT 配置允许",且线程数要在 open 时定死, 推理内部并行与请求级并发叠加会互相抢核;
  • 多 Agent + 每个单线程(本文方案):Agent.open(..., threads=1), 并发完全交给池和 Tomcat 请求线程。每个请求独占一个 Agent,隔离干净, 池上限即背压阈值。

工厂实现,注意 create 时的快速失败校验和 destroy 时的本地内存释放:

java
public 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 是进程内对象,不会像网络连接那样悄悄断掉, 借出校验纯属浪费。

4.4 问题定义:一次构建,处处复用

java
private 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",写清楚每个选项覆盖什么,准确率立竿见影。

4.5 服务层:borrow → predict → finally return

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 就是什么类型。

4.6 接口层与过载语义

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("推理并发已满,请稍后重试"); } }

4.7 跑起来

bash
export 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
bash
curl -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 到生产还差这几步,按优先级:

  1. 校准阈值。multilingual 出厂不带拟合温度,这步是必做不是可选:拿几百条 自己业务的标注数据,用 Python 侧 laya/calibrate.py 的 fit_temperature_map 按(问题类型, 选项数)分桶拟合温度并持久化(java 侧加载时读 checkpoint 里的 温度表),再定门控线。注意别用成 vegaml 的 fit()——那是另一条路线的工具。 简单起步:用 ConfidenceGate.apply(answers, threshold) 对低置信答案标记 ABSTAINED 转人工,阈值从保守值开始灰度。
  2. 启动预热。min-idle 拉满 + eviction 线程预建,把数十秒的图加载从首请求挪到启动期, 配合 readiness probe 挡流量。
  3. 监控。SDK 自带 hooks(onPredictStart/End),埋 elapsedMs、usage.inputTokens、 池的 active/idle/borrowWait 指标;截断率单独告警——它是静默的。
  4. 长文本。超 1024 token 用 predictLong(滑窗扫描,noul 取窗口最大 P(true), choice 取最自信窗口),注意其概率是"决策窗口的"而非全文校准值。
  5. 内存不够。优先降 max-total 换排队。INT8 是最后手段:--quantize 在 scripts/export_onnx.py 上(prepare_checkpoint.py 没有这个参数,需单独跑 导出脚本),产物 laya.int8.onnx 仅 CPU 可用,体积小 1.4~2.8 倍、比 fp32 ONNX 快约 1.8 倍,但官方明确警告这是拿真实精度换的(multilingual 与 fp32 的决策一致率仅 83%),凡是在意校准概率/置信度的场景不要用——而本文 主打的恰恰是校准概率。
  6. 批量场景。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 万条合成多语工单), 结果顺序不变。

六、什么时候不该用它

  • 需要生成文本(摘要、回复、翻译)——找 LLM;
  • 选项集开放且频繁变化到无法枚举——它是封闭选项集选手(虽有 Shortlist 缓解大标签集);
  • 需要多步推理链的复杂判断——System 1 的直觉解不了 System 2 的题;
  • 团队没有能力维护一条"导出 ONNX + 本地构建 SNAPSHOT"的供应链——目前 java SDK 的分发成熟度确实不如 pip 生态,这是真实成本。

合理的架构往往是分层:Laya 做高频、低延迟的第一道判断(覆盖 80%+ 的确定性流量), 低置信/弃答的少数流量升级给 LLM 或人工。判断题交给判断题选手,作文题才交给作文选手。

七、小结

Laya 的价值不是"又一个模型",而是把"决策"从"生成"里拆出来单独定价: 单次前向、结构化输出、校准概率、进程内推理。laya-java 让这套能力以纯 JVM 依赖的形态 进入 Spring Boot——一个 commons-pool2 池解决它唯一的并发约束,剩下的就是普通的 Bean 和 Controller。


*项目地址:github.com/NandhaKishorM/laya(Apache-2.0)。

本文作者:Weee

本文链接:

版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!