对比 Jev 云端 API 与 Laya 本地决策模型的运行原理、部署方式、工单分流效果与 2048 游戏

Jev 与 Laya：结构化决策模型对比

1. 模型

运行原理

Jev 和 Laya 都不是以自由生成文本为目标的通用聊天模型，而是将自然语言或结构化状态转换为预先定义的决策结果。一次调用由 状态（state）、问题协议（questions） 和 结构化输出 三部分组成。

输入状态：传入待处理对象，例如工单正文、邮件内容、表单字段或 JSON 数据。示例中将工单文本包装为 {"body": ticket}，作为模型的判断依据。
问题协议：由程序预先定义每个判断项、说明和候选答案。例如，department 从 billing、technical、sales、other 中选择；urgency 按 0～2 分级；churn_risk 和 is_phishing 输出 0～1 的概率。模型只在这些已定义的输出空间内作答。
模型推断：模型结合输入状态与问题定义，对每个判断项独立计算结果。choice 类型返回类别及各类别概率，score 类型返回分值和概率分布，noul 类型返回“是”的概率；这些概率反映模型在当前协议下的倾向，并不等同于经过业务校准后的真实发生率。
业务执行：应用程序根据类别、分数或阈值决定后续动作，例如将账单问题路由给财务队列、将高紧急度工单提升优先级，或将高风险操作交由人工复核。模型负责判断，权限校验、阈值控制和实际执行仍应由普通业务代码负责。两者的主要区别在部署方式：Jev 在云端通过 API 完成推断，调用方发送 state 与 questions 并获取结果；Laya 在本地加载模型权重后完成同样形式的推断，数据可不离开本机，但需要自行准备模型文件和推理资源。

Jev

Jev 是 Typesafe 提供的托管式决策模型，面向分类、评分、风险判断等结构化任务。调用时需提供待判断状态（state）和明确的问题定义（questions）；模型返回带类型、概率和置信度的结果，可用于工单路由、优先级判定、审核和风控。其优势是延迟低、响应快、调用成本可控；但它不是通用对话模型，不适合开放式问答、长篇生成或复杂推理。

获取 Jev API Key 进入 Typesafe 后，先加入等待列表并填写问卷；审核通过后注册账号，再在控制台创建 API Key。

Laya

Laya 是 Convai Innovations 发布的可本地部署决策模型。它根据输入状态和预定义问题输出类别、分数或二元判断及其概率，适合构建数据不出本机的结构化决策流程。相较于 Jev 的托管 API，Laya 需要自行下载模型并承担本地推理资源开销，但支持离线使用和后续定制。本文使用默认英文检查点；处理中文或其他语言时，用实际业务数据评测或微调。

2. 本地部署 Laya

下载模型

cd /Users/villow/Models/huggingface/convaiinnovations/laya

curl -L --continue-at - \
  --progress-bar \
  --output model.safetensors \
  "https://huggingface.co/convaiinnovations/laya/resolve/main/model.safetensors?download=true"

补齐配置与分词器文件

cd /Users/villow/myProject/Decision-Model-Demo
source .venv/bin/activate

MODEL_DIR="/Users/villow/Models/huggingface/convaiinnovations/laya"

export HTTP_PROXY="http://127.0.0.1:7890"
export HTTPS_PROXY="http://127.0.0.1:7890"
export HF_HUB_DISABLE_XET=1

hf download \
  convaiinnovations/laya \
  --local-dir "$MODEL_DIR" \
  --include "rl_agent_config.json" \
  --include "encoder/*" \
  --include "tokenizer/*" \
  --max-workers 1

3. 工单分流对比 Demo

Demo 以同一份英文工单为输入，同时调用本地 Laya 与 Jev API，并在页面中并列展示部门归属、紧急度、流失风险和诈骗风险。

from __future__ import annotations

import json
import threading
import time
from http import HTTPStatus
from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen

import laya

HOST = "127.0.0.1"
PORT = 8765
PROJECT_DIR = Path(__file__).resolve().parent
# 直接加载已下载的本地检查点，推理时不会访问 Hugging Face
MODEL_DIR = "/Users/villow/Models/huggingface/convaiinnovations/laya"
JEV_ENDPOINT = "https://api.typesafe.ai/v1/systemone"
# Jev API Key
JEV_API_KEY = "apikey_xxxxxx"

# 进程内只保留一个 Laya 实例，避免每次请求重新加载 804 MiB 权重
LAYA_AGENT = None
LAYA_LOCK = threading.Lock()

# 当前仅下载了仓库根目录的默认英文检查点，因此页面示例和对比输入使用英文工单。
# 仓库另有 multilingual 多语种检查点，可用于中文文本；投入具体业务前仍应结合领域数据微调或充分评测。
# QUESTIONS 是两边模型共用的测试协议：每个键是页面展示的一个判断项，值定义该判断如何执行。
# - department：choice 类型，从 billing、technical、sales、other 四个预设部门中选一个，返回类别、各项概率和置信度。
# - urgency：score 类型，按 0 至 2 的三级标准评分，0 是不紧急，1 是需要尽快响应，2 是有明确截止时间或业务受阻。
# - churn_risk：noul 类型，输出 0 至 1，表示用户是否威胁取消订阅或转向竞争对手的概率。
# - is_phishing：noul 类型，输出 0 至 1，表示消息是否疑似钓鱼或诈骗的概率。
# criteria 是每个类别或评分档位的英文业务定义；模型据此对输入工单进行独立判断。
# 两个模型接收完全相同的 QUESTIONS 与工单文本，页面结果才可以横向比较。
QUESTIONS = {
    "department": {
        "type": "choice",
        "instructions": "Which department should handle this support ticket?",
        "criteria": {
            "billing": "invoices, payments, duplicate charges, refunds",
            "technical": "bugs, outages, account access, integrations",
            "sales": "pricing, contracts, demos, upgrades",
            "other": "everything else",
        },
    },
    "urgency": {
        "type": "score",
        "instructions": "How urgent is this customer request?",
        "criteria": [
            "not urgent",
            "needs a response soon",
            "critical deadline or blocking issue",
        ],
    },
    "churn_risk": {
        "type": "noul",
        "instructions": "Does the customer threaten to cancel or switch to a competitor?",
    },
    "is_phishing": {
        "type": "noul",
        "instructions": "Is this message a phishing or scam attempt?",
    },
}


# 所有模型结果都使用同一层响应壳，前端可按 provider、ok、latency_ms、result 统一渲染
def success(provider: str, started: float, result: dict) -> dict:
    return {
        "provider": provider,
        "ok": True,
        "latency_ms": round((time.perf_counter() - started) * 1000),
        "result": result,
    }


def failure(provider: str, error: str, configured: bool = True) -> dict:
    """将未配置和网络失败统一转换为前端可显示的结果。"""
    return {"provider": provider, "ok": False, "configured": configured, "error": error}


def get_laya_agent():
    """首次请求时加载 Laya，并避免多个浏览器请求重复初始化。"""
    global LAYA_AGENT
    with LAYA_LOCK:
        if LAYA_AGENT is None:
            LAYA_AGENT = laya.load(MODEL_DIR)
        return LAYA_AGENT


def call_laya(ticket: str) -> dict:
    # 将同一段文本包装为 Laya 的结构化 state，与 Jev 的输入保持一致
    started = time.perf_counter()
    result = get_laya_agent().predict({"body": ticket}, QUESTIONS)
    return success("Laya", started, result)


def call_jev(ticket: str) -> dict:
    # 密钥直接配置在本文件；浏览器只访问本地服务，密钥仍不会发送到前端
    # Jev 使用 JSON HTTP API
    request = Request(
        JEV_ENDPOINT,
        data=json.dumps({"model": "jev-latest", "state": ticket, "questions": QUESTIONS}).encode(),
        headers={"Authorization": f"Bearer {JEV_API_KEY}", "Content-Type": "application/json"},
        method="POST",
    )
    started = time.perf_counter()
    try:
        with urlopen(request, timeout=45) as response:
            return success("Jev", started, json.loads(response.read()))
    except HTTPError as error:
        body = error.read().decode("utf-8", errors="replace")
        return failure("Jev", f"HTTP {error.code}: {body}")
    except URLError as error:
        return failure("Jev", str(error.reason))


class DemoHandler(SimpleHTTPRequestHandler):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, directory=str(PROJECT_DIR), **kwargs)

    def log_message(self, format, *args):
        print(f"[{self.log_date_time_string()}] {format % args}")

    def ticket(self) -> str:
        """读取 JSON 中的 ticket，并在模型调用前限制输入长度。"""
        payload = json.loads(self.rfile.read(int(self.headers.get("Content-Length", "0"))))
        ticket = payload.get("ticket", "").strip()
        if not ticket:
            raise ValueError("Ticket text is required.")
        if len(ticket) > 4000:
            raise ValueError("Ticket text must be 4,000 characters or fewer.")
        return ticket

    def do_POST(self):
        # 仅开放这个本地 JSON 接口；静态页面由父类的 GET 处理
        if self.path != "/api/compare":
            self.send_error(HTTPStatus.NOT_FOUND)
            return

        try:
            ticket = self.ticket()
            # Laya 在本地执行；Jev 使用本文件中配置的 API Key 调用
            self.send_json(HTTPStatus.OK, {"laya": call_laya(ticket), "jev": call_jev(ticket)})
        except (ValueError, json.JSONDecodeError) as error:
            self.send_json(HTTPStatus.BAD_REQUEST, {"error": str(error)})
        except Exception as error:
            self.send_json(HTTPStatus.INTERNAL_SERVER_ERROR, {"error": f"Laya request failed: {error}"})

    def send_json(self, status: HTTPStatus, body: dict):
        encoded = json.dumps(body, ensure_ascii=False).encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Content-Length", str(len(encoded)))
        self.end_headers()
        self.wfile.write(encoded)


if __name__ == "__main__":
    # 仅绑定回环地址，局域网其他设备无法访问该页面
    print(f"Laya local model: {MODEL_DIR}")
    print("Jev live API: enabled")
    print(f"Open http://{HOST}:{PORT}")
    ThreadingHTTPServer((HOST, PORT), DemoHandler).serve_forever()

测试工单 为确保横向对比有效，Laya 和 Jev 使用相同的工单文本与 QUESTIONS 决策协议。内置了以下三类英文工单：

重复扣费：要求在周五前退还重复付款，否则取消账户。
登录故障：重置密码后无法登录，团队工作受阻。
合同咨询：咨询企业版报价及年度合同选项。

html

<!doctype html>
<html lang="zh-CN">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Laya / Jev 决策对比</title>
  <style>
    :root { --ink:#111111; --muted:#666666; --line:#d5d5d5; --surface:#ffffff; --page:#f2f2f2; --laya:#111111; --jev:#5a5a5a; --warning:#555555; --error:#111111; }
    * { box-sizing:border-box; }
    body { margin:0; color:var(--ink); background:var(--page); font:14px/1.5 Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
    button, textarea { font:inherit; }
    header { background:#111111; color:#fff; border-bottom:3px solid #111111; }
    .shell { width:min(1180px, calc(100% - 40px)); margin:0 auto; }
    .top { min-height:58px; display:flex; align-items:center; }
    .brand { display:flex; align-items:baseline; }
    h1 { font-size:17px; line-height:1; margin:0; font-weight:720; letter-spacing:0; }
    main { padding:20px 0 32px; }
    .input-zone { display:grid; grid-template-columns:minmax(0, 1fr) 184px; gap:12px; align-items:end; padding-bottom:16px; }
    label { display:none; }
    textarea { width:100%; min-height:100px; resize:vertical; padding:12px; color:var(--ink); background:#fff; border:1px solid #bdbdbd; border-radius:2px; outline:none; }
    textarea:focus { border-color:#111111; box-shadow:0 0 0 3px rgba(17,17,17,.12); }
    .actions { display:flex; flex-direction:column; gap:10px; }
    button { min-height:40px; border:0; border-radius:2px; cursor:pointer; font-weight:680; color:#fff; background:#111111; }
    button:hover { background:#3f3f3f; }
    button:disabled { opacity:.62; cursor:wait; }
    .examples { display:flex; gap:7px; flex-wrap:wrap; }
    .examples button { min-height:30px; padding:0 10px; color:#333333; background:#e7e7e7; font-size:12px; font-weight:600; }
    .examples button:hover { background:#d5d5d5; }
    .comparison { display:grid; grid-template-columns:repeat(2, minmax(0,1fr)); gap:12px; }
    .panel { background:var(--surface); border:1px solid var(--line); border-radius:2px; overflow:hidden; }
    .panel-head { display:flex; justify-content:space-between; align-items:center; padding:13px 14px; border-bottom:1px solid var(--line); }
    .name { display:flex; align-items:center; gap:10px; font-size:17px; font-weight:740; }
    .mark { width:11px; height:11px; border-radius:2px; }
    .laya .mark, .jev .mark { background:#111111; }
    .jev .mark { background:#5a5a5a; transform:rotate(45deg); }
    .meta { font-size:12px; color:var(--muted); }
    .decisions { padding:7px 19px 15px; }
    .decision { padding:14px 0; border-bottom:1px solid #ededed; }
    .decision:last-child { border:0; }
    .decision-top { display:flex; justify-content:space-between; gap:12px; align-items:baseline; }
    .decision-title { color:var(--muted); font-size:12px; }
    .answer { font-size:15px; font-weight:720; text-transform:capitalize; }
    .score { font-size:13px; color:var(--muted); }
    .bar { height:6px; margin-top:10px; background:#e6e6e6; overflow:hidden; border-radius:2px; }
    .bar > i { display:block; height:100%; background:#111111; }.jev .bar > i { background:#5a5a5a; }
    .probabilities { color:var(--muted); font-size:11px; margin-top:7px; overflow-wrap:anywhere; }
    .empty { min-height:250px; display:grid; place-items:center; }
    .loader { width:14px; height:14px; border:2px solid #d5d5d5; border-top-color:#111111; border-radius:50%; animation:spin .7s linear infinite; }
    @keyframes spin { to { transform:rotate(360deg); } }
    .error { color:#111111; background:#eeeeee; border-left:3px solid #111111; padding:12px; font-size:12px; }
    details { margin:0 19px 18px; border-top:1px solid var(--line); padding-top:12px; }
    summary { cursor:pointer; color:var(--muted); font-size:12px; }
    pre { max-height:260px; overflow:auto; margin:10px 0 0; padding:12px; border:1px solid var(--line); background:#f8f8f8; font:11px/1.45 ui-monospace, SFMono-Regular, Menlo, monospace; white-space:pre-wrap; overflow-wrap:anywhere; }
    .footnote { margin-top:18px; color:var(--muted); font-size:12px; }
    @media (max-width:760px) { .shell { width:min(100% - 28px, 1180px); }.top { min-height:72px; }.brand { display:block; }.brand span { display:block; margin-top:7px; }.connection { display:none; }.input-zone,.comparison { grid-template-columns:1fr; }.actions { flex-direction:row; align-items:end; flex-wrap:wrap; }.actions > button { flex:1; }.examples { width:100%; } }
  </style>
</head>
<body>
<header><div class="shell top"><div class="brand"><h1>Laya / Jev</h1></div></div></header>
<main class="shell">
  <section class="input-zone" aria-label="工单输入">
    <div><label for="ticket">工单内容</label><textarea id="ticket">I was charged twice for my March subscription. Please refund the duplicate payment by Friday or I will cancel my account.</textarea></div>
    <div class="actions"><button id="run" type="button">运行对比</button><div class="examples"><button data-example="billing" type="button">重复扣费</button><button data-example="technical" type="button">登录故障</button><button data-example="sales" type="button">合同咨询</button></div></div>
  </section>
  <section class="comparison">
    <article class="panel laya"><div class="panel-head"><div class="name"><i class="mark"></i>Laya</div><div id="laya-latency" class="meta"></div></div><div id="laya-body" class="empty"></div></article>
    <article class="panel jev"><div class="panel-head"><div class="name"><i class="mark"></i>Jev</div><div id="jev-latency" class="meta"></div></div><div id="jev-body" class="empty"></div></article>
  </section>
</main>
<script>
  // 预置英文工单：当前本地 Laya 检查点主要面向英文文本。
  const examples = {
    billing: 'I was charged twice for my March subscription. Please refund the duplicate payment by Friday or I will cancel my account.',
    technical: 'I cannot sign in after resetting my password. The verification email never arrives and our team is blocked from using the dashboard.',
    sales: 'We are evaluating your enterprise plan. Can you send a quote and explain the annual contract options for fifty users?'
  };
  const labels = {department:'归属部门', urgency:'紧急度', churn_risk:'流失风险', is_phishing:'诈骗风险'};
  const ticket = document.querySelector('#ticket'); const run = document.querySelector('#run');
  document.querySelectorAll('[data-example]').forEach(button => button.addEventListener('click', () => { ticket.value = examples[button.dataset.example]; }));
  const percent = value => `${Math.round(Number(value || 0) * 100)}%`;
  function content(response) {
    // 将不同提供方的类型化结果渲染为同一套决策行，便于横向比较。
    if (!response.ok) return `<div class="empty"><div class="error">${escapeHtml(response.error || '请求失败')}</div></div>`;
    const answers = response.result.answers || {};
    const rows = Object.entries(answers).map(([key, value]) => {
      let answer = '', score = 0, detail = '';
      if (value.type === 'choice') { answer = value.choice; score = value.confidence ?? Math.max(...Object.values(value.probabilities || {x:0})); detail = Object.entries(value.probabilities || {}).map(([k,v]) => `${k} ${percent(v)}`).join(' · '); }
      if (value.type === 'score') { answer = `${Number(value.score).toFixed(2)} / 2`; score = value.confidence ?? Number(value.score) / 2; detail = Object.entries(value.probabilities || {}).map(([k,v]) => `${k}: ${percent(v)}`).join(' · '); }
      if (value.type === 'noul') { answer = percent(value.noul); score = value.noul; detail = `判断为“是”的概率 ${percent(value.noul)}`; }
      return `<div class="decision"><div class="decision-top"><span class="decision-title">${labels[key] || key}</span><strong class="answer">${escapeHtml(answer)}</strong></div><div class="bar"><i style="width:${Math.max(0, Math.min(100, Number(score)*100))}%"></i></div><div class="probabilities">${escapeHtml(detail)}</div></div>`;
    }).join('');
    return `<div class="decisions">${rows}</div><details><summary>查看原始 JSON</summary><pre>${escapeHtml(JSON.stringify(response.result, null, 2))}</pre></details>`;
  }
  function escapeHtml(text) { const div = document.createElement('div'); div.textContent = String(text); return div.innerHTML; }
  async function compare() {
    // 单次请求同时执行本地 Laya 与已配置的 Jev API。
    if (!ticket.value.trim()) return; run.disabled = true;
    ['laya','jev'].forEach(id => { document.querySelector(`#${id}-body`).innerHTML = '<div class="empty"><span class="loader" aria-label="运行中"></span></div>'; document.querySelector(`#${id}-latency`).textContent = ''; });
    try {
      const res = await fetch('/api/compare', {method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify({ticket:ticket.value})});
      const data = await res.json(); if (!res.ok) throw new Error(data.error || '请求失败');
      for (const id of ['laya','jev']) { document.querySelector(`#${id}-body`).innerHTML = content(data[id]); document.querySelector(`#${id}-latency`).textContent = data[id].ok ? `${data[id].latency_ms} ms` : '不可用'; }
    } catch (error) { ['laya','jev'].forEach(id => { document.querySelector(`#${id}-body`).innerHTML = `<div class="empty"><div class="error">${escapeHtml(error.message)}</div></div>`; }); }
    finally { run.disabled = false; }
  }
  run.addEventListener('click', compare);
</script>
</body>
</html>

4. 测试结果

工单分流结果

Jev 在三次测试中均给出了接近或等于 100% 的部门概率；Laya 的概率分布更分散，能够更直观地反映其不确定性。

测试工单	Laya	Jev	观察
重复扣费，周五前退款，否则取消	`billing` 93.65%，紧急度 `1.4052`，流失风险 `85.45%`	`billing` 100%，紧急度 `1.81`，流失风险 `98%`	两者都识别为账单问题、高流失风险；Jev 判定更激进。
团队无法登录，发布前受阻	`technical` 62.56%，紧急度 `1.5884`，流失风险 `0.69%`	`technical` 100%，紧急度 `2.0`，流失风险 `6%`	分类一致。Jev 认为是明确最高紧急度；Laya 有明显不确定性。
120 人企业版报价、合规资料、合同	`sales` 38.75%，紧急度 `1.0227`，流失风险 `0.01%`	`sales` 100%，紧急度 `0.9`，流失风险 `3%`	分类一致。Laya 的销售判断置信度很低，说明该工单同时包含合同、合规、采购等混合信号。

2048 游戏

除了工单分流，我们还让 Jev 和本地 Laya 尝试玩 2048，并在输入中补充了游戏规则、操作技巧和决策提示，观察它们在连续决策任务中的表现。

尽管补充了规则和技巧，两者的总体得分仍然较低，未表现出稳定的全局布局与多步规划能力。2048 的每一步都会改变后续可用空间和合并机会，因此，单次动作能够快速给出，并不意味着连续决策就能取得高分。

对于需要长期规划的任务，仅靠逐步调用决策模型可能还不够，可以进一步结合状态评估、向前搜索或专门的游戏策略。当前结果也不足以单独判定表现受限的原因，提示设计和决策流程仍有改进空间。

Jev 与 Laya 的 2048 游戏实验界面

5. 适用场景

Laya 和 Jev 适合处理“程序已规定可选答案，模型只负责快速判断”的任务。输入通常是文本、邮件、工单、表单或 JSON 状态；输出是类别、评分或是/否概率，而非自然语言回复。

适用场景

场景	模型判断什么	程序接下来做什么
客服工单分流	应归哪个部门、是否紧急、是否要转人工	入不同队列、提升优先级、触发人工处理
邮件处理	是否垃圾邮件、钓鱼邮件、退款请求、销售咨询	过滤、标记、路由、创建工单
Agent 工具选择	搜索资料、查数据库、调用账单接口、要求澄清，哪个动作合适	在允许工具中选择并执行
Agent 风险控制	是否涉及付款、删除、权限变更、敏感数据	要求确认、转人工或阻止自动执行
模型路由	请求简单还是复杂，应该用小模型还是强模型	选择模型，控制成本和延迟
销售线索筛选	是否有采购意图、客户规模、成交紧迫度	分派销售、调整跟进优先级
内容审核	是否广告、诈骗、辱骂、违法风险	通过、折叠、限流或送人工审核
RAG 检索控制	候选文档是否相关、资料是否足够回答	重排、继续搜索、要求补充信息
数据清洗	两条记录是否重复、字段是否矛盾、是否有效	合并、标记、过滤或进入人工审核

不适合场景

场景	为什么不适合	更合适的方法
写邮件、文章、报告	它们不生成自然语言	GPT、Claude、Qwen、Llama 等生成式 LLM
代码编写、调试、重构	需要长上下文、推理、生成和工具循环	编程 Agent / 通用推理模型
长链路规划	任务需要拆解、反思、搜索、反复修正	Agent + 推理模型 + 工作流引擎
开放式问答	答案不是有限选项，无法预先定义输出空间	RAG + 生成式 LLM
数学证明、复杂计算	不是直觉型的单次判断	Python、SQL、符号计算或推理模型
实时控制游戏或机器人	当前实测约数百毫秒到 1 秒级，不适合高频控制	传统控制算法、规则引擎、专用策略模型
贪吃蛇最优求解、路径规划	BFS、A*、动态规划有确定答案且更可靠	图搜索、路径规划算法
可用固定规则完成的判断	例如金额大于 1000、退出码非零，不需要模型	普通 `if/else`、SQL、规则引擎
高风险自动执行	概率高也不代表有授权或绝对正确	权限系统、人工审批、二次确认

总结

Laya：适合本地、私有数据、可接受本机模型部署的场景。当前默认模型更适合英文；需要中文时应下载多语种检查点，并用真实业务样本做评测或微调。
Jev：适合希望快速接入云端 API、不想自行部署权重的场景。其输出在这次测试中更果断，但仍应依据自己的标注数据验证概率是否真的校准。
两者都不应单独授权高风险操作：退款、删除数据、付款、权限修改等，应由业务代码加金额阈值、权限验证、人工审批或二次确认。