想象你是一家高档餐厅的老板。后厨新来了一位厨师 AI,厨艺惊人但个性散漫——你让他“做一道牛排”,他可能端上来一份甜品,或是一盘堆满香菜的面条。顾客最怕的,就是你点完菜后,厨师自由发挥、端上来的东西完全不是你要的。 要想让这位“天才厨师”稳定出品,你需要三件法宝:一本写满细规的菜单(告诉厨师必须做什么、不能做什么)、一位严格的品控经理(每道菜上桌前都要对照菜单逐项检查)、一套标准的返工流程(菜不合格就退回后厨重新做,直到合格为止)。这就是 AI 提示工程里最实用的三板斧——输出约束、自动校验、失败重试。 把这三件套装进自动化流水线,AI 就不再是“看心情发挥”的创作型选手,而是“照单上菜”的可靠员工。本文就用餐厅后厨的故事,带你完整掌握这套让 AI 输出稳定可用的组合拳。

岗位关联

输出约束与校验重试是 AI 自动化管线的“安全护栏”。掌握这套方法论,你就能把不可控的大模型输出变成可靠的生产数据——这是提示工程社区公认的进阶必备技能,也是自动化 Pipeline 工程师的核心竞争力之一。

目录
  1. 可视化演示
  2. 输出约束基础
  3. 约束写作技巧
  4. 校验机制实现
  5. 失败重试触发
  6. 重试策略设计
  7. 多轮纠错流程
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

展示AI输出→格式校验→失败重试→成功输出的完整闭环流程,通过环形流程和校验规则面板直观理解Pipeline中的自动纠错机制。

本节配有交互动效(进入视口后自动加载,约 3KB)。

输出约束校验闭环流程 AI生成→格式校验→失败重试→成功输出,四步闭环确保输出可靠性 校验规则涵盖JSON格式/字段类型/值域范围/必填字段 构建AI输出Pipeline的必备校验机制,保障自动化流程稳定运行

输出约束基础

餐厅里,顾客最怕说“随便”,因为“随便”意味着厨师有无限发挥空间。反过来,你给 AI 下的指令越模糊,它输出的“菜”就越五花八门。有一次我让模型“帮我整理一下客户反馈”,结果一次返回 Markdown 表格、一次返回散文、一次直接甩了三个感叹号。这一切的根源,就是输出约束没立住——AI 不知道你要它“长什么样”。

输出约束,本质上是在请求阶段就圈定模型的输出空间。你告诉模型:“你只能做青椒肉丝,不能做鱼香肉丝,更不能做甜点。”模型作为概率生成器,会顺着你给出的轮廓寻找答案。在实际开发中,最常用的限定手段是结构化格式:要求返回 JSON、指定字段名、限定取值范围。

一个典型的约束实例长这样:“请返回 JSON,包含 name(字符串)、amount(数值)、category(只能取 electronics / grocery / clothing 之一)。”这就相当于在菜单上写死:主菜必须装盘、主料必须在清单内、缺任何一项都不许上桌。约束越早、越具体,后续的校验就越轻松。

菜单立住了,后厨就不再自由发挥。但菜单只是第一步——光有约束还不够,因为模型有时会“看错菜单”。

P可用=1−(1−p)n\displaystyle P_{\text{可用}} = 1 - (1-p)^n
公式解读:当单次输出满足要求的概率为 p,重试 n 次后至少一次满足要求的概率。比如 p = 0.7、n = 3 时,可用率能达到 97.3%——这就是约束配合重试的威力所在。
  1. 符号定义这里 p 表示模型单次产出合格结果的概率,n 表示最多尝试次数,它们共同决定整个链路最终能交出合格结果的把握有多大。
    p,  np,\; n
  2. 失效概率单次不合格的概率是 1-p,连续 n 次都不合格的概率要一并乘起来。
    (1−p)n(1-p)^n
  3. 补集求和用 1(全部可能)减去“全部失败”的悲观情形,剩下的就是“至少有一次成功”的可靠保障。
    P可用=1−(1−p)nP_{\text{可用}}=1-(1-p)^n

约束写作技巧

同样一张菜单,写法不同,效果天差地别。你写“牛排七分熟,不要辣”,厨师永远做不错;你写“做点好吃的”,他就开始抽象发挥了。给 AI 写约束,踩的就是这个坑。我见过最失败的约束是“请返回合理的 JSON”——六个字里三个词都是模糊概念。

指令明确是第一要义。与其说“返回 JSON”,不如说“只返回 JSON 对象,键为 status 与 message,不要 Markdown 代码块包裹”。对,连“不要用代码块包裹”都要写出来,因为模型真的会包。其次是示例引导:给一个正确的成品样例,就像给厨师一张实拍菜品图,他照着摆盘就赢了一半。最后是边界框定,主动告诉模型什么不能做:“不要解释、不要寒暄、不要输出无关内容。”

写约束的本质是在做可复现的限定:约束的空间越小、边界越清楚,模型越没有自由发挥的余地。它就像 GPS 终点:精确到门牌号、不能跨省,导航就有极高的把握。

菜单写得越精细,顾客就越满意。但这还只解决了一半问题——因为就算你写清了,AI 偶尔还是会“上错菜”。

max⁡θ  P(y∈S约束  ∣  x)\displaystyle \max_{\theta} \; P\bigl(y \in S_{\text{约束}} \;\big|\; x\bigr)
公式解读:模型参数在约束集合 S 内的概率最大化——提醒我们,约束不是附加题,而是主线题,它可以直接改变模型采样的方向。
  1. 目标函数我们要让模型输出 y 落在约束集合 S 里,概率越大越好,这就是约束写作的优化目标。
    max⁡θ P(y∈S约束  ∣  x)\max_{\theta}\,P\bigl(y \in S_{\text{约束}}\;\big|\;x\bigr)
  2. 条件含义竖线右侧的 x 是输入提示词,它承载了约束描述与示例引导。
    ∣  x\big|\;x
  3. 集合落点y ∈ S 表示模型输出必须命中预设的约束范围,这也是校验环节要验证的核心命题。
    y∈S约束y \in S_{\text{约束}}

校验机制实现

有了菜单,还得有品控。后厨把菜端出来,你总不能闭眼就端给顾客——得先对照菜单检查一遍。AI 流水线同样如此:模型的输出,必须先经过程序化校验,合格才允许进入下游。校验的粒度,可以分为三层,就像品控人员从上到下扫视整道菜。

第一层是结构检查:用 JSON Schema 或字段存在性检查,逐级比对“有没有这些键、嵌套层级对不对”。第二层是类型检查:quantity 就应该是整数,price 就应该是浮点数,字符串混进数字区直接亮红灯。第三层是内容审查:枚举值在不在允许列表里?数值在不在合理区间?情感标签是不是真的只有 positive / negative / neutral 三种?这三层合起来,就是一道完整的“验菜关卡”。

我在项目里通常会封装一个 validate_order() 函数,传入模型输出,返回 ok 与 errors 两个字段。这样上游出错,下游只 “收到一个明确的警报”,而不会被脏数据带崩。

品控把不合格的菜扣下来,接下来就要打发回后厨——这叫“退菜返工”。

Validator(y)=⋀i=1k  checki(y)\displaystyle \text{Validator}\bigl(y\bigr) = \bigwedge_{i=1}^{k}\; \text{check}_i\bigl(y\bigr)
公式解读:校验器是多个检查条件同时成立的“且”关系——任何一个坑没踩住,校验就会失败,结果就被打回重做。
  1. 总校验器Validator(y) 是一个复合函数,对模型输出 y 做整体验收。
    Validator(y)\text{Validator}(y)
  2. 逐项检查check_i 代表第 i 项检查,比如是否存在键、类型对不对、枚举值有没有越界。
    checki(y)\text{check}_i(y)
  3. 与关系大写的 Λ 是逻辑“且”,所有小项全部成立,校验才通过——这就是品控的铁面无私。
    ⋀i=1k  checki(y)\bigwedge_{i=1}^{k}\;\text{check}_i(y)

失败重试触发

品控扣下菜,总不能把菜倒掉就完事——得送回后厨,告诉厨师“哪道工序出了问题,重新做”。。失败重试的触发逻辑与此完全一致:校验器发现输出不合格,立刻把“不合格原因”打包,连同修正提示一起返回给模型,让它重新生成。

触发重试的前提是错误信息要具体。如果校验器只返回“解析失败”,模型还是一脸懵;如果返回“第二行缺少 order_id 字段,且 total 必须是数值”,模型就能精准修正。我在项目里常把错误字符串直接拼进下一次请求的 prompt 末尾,让“退菜理由”清晰可见。

重试不可能是无限的。必须设次数上限,否则模型一直失败,你的 API 账单就一路走高、服务也卡死不动。设定 max_retries,一旦达到上限,就返回最后一次错误信息,交给人工兜底。这就像餐厅有个规矩:一道菜返工三次还没做好,就换主厨或干脆退钱。

退菜返工很重要,但返工也要讲策略——不是让你疯狂乱试,而是有节奏地重来。

E[T]=∑i=1R(ti+wi)⋅pfaili−1\displaystyle E[T] = \sum_{i=1}^{R} \bigl(t_i + w_i\bigr) \cdot p_{\text{fail}}^{i-1}
公式解读:期望总耗时,是把每一轮“生成时间 + 等待时间”按“前面一直失败的概率”加权求和——直观看到重试次数对延迟的影响。
  1. 单轮耗时第 i 轮包含生成时间 t_i 和等待时间 w_i(如指数退避间隔)。
    ti+wit_i + w_i
  2. 到达概率第 i 轮能被执行,说明前 i-1 轮全失败了,概率是 p_fail 的连乘。
    pfail i−1p_{\text{fail}}^{\,i-1}
  3. 期望求和把每一轮的耗时乘上它被执行的权重再累加,就是整体流程的期望时长。
    ∑i=1R  (ti+wi)⋅pfail i−1\sum_{i=1}^{R}\;(t_i+w_i)\cdot p_{\text{fail}}^{\,i-1}

重试策略设计

重试不是“再来一次”这么简单。回想后厨返工时:如果厨师因为系统过载才做错菜,你立刻催他重做,多半还是做错——得让他喘口气。指数退避就是给 AI 的“喘息时间”:第 1 次失败等 1 秒、第 2 次等 2 秒、第 3 次等 4 秒……间隔指数翻倍,有效避开高峰期,也给服务端恢复的时间。

除了等待,重试时还要带上修正指令。把校验器返回的错误消息拼进 prompt,明确告诉模型“上一次错在哪”。这也叫“少样本纠错”——每次失败都在给模型补课。比如:“上次生成的 JSON 缺少 price 字段,请补充后再输出。”这种带反馈的重试,成功率远高于盲目重发。

此外必须设置成本上限:最大轮数、最长等待时间、最大 token 消耗。这三个“封顶值”就像一个保险丝,保证系统在极端情况下不会失控。退一步说,重试的成本曲线是线性甚至指数上升的,不封顶的项目十有八九要被账单教做人。

等到了第 N 轮,后厨已经形成一套完整的返工节奏——这就是闭环的多轮纠错。

di=d0×2 i−1,i=1,…,R\displaystyle d_i = d_0 \times 2^{\,i-1}, \quad i = 1,\dots, R
公式解读:指数退避公式——第 i 次重试前的等待时间 d_i 是基准值 d_0 的 2^(i-1) 倍,让每次重试都更克制。
  1. 基准间隔d_0 是第一次失败后的基础等待时间,比如 1 秒。
    d0d_0
  2. 指数翻倍每多失败一次,指数 i-1 加一,等待时间整体翻倍。
    2  i−12^{\;i-1}
  3. 逐轮退避d_i 就是第 i 轮重试前的实际等待时长,式子简洁但直接决定了系统的温柔程度。
    di=d0×2i−1d_i=d_0\times2^{i-1}

多轮纠错流程

把约束、校验、反馈、重试串成一个闭环,就得到了多轮纠错流程。在一个成熟的上菜流水线里,一道菜在品控与后厨之间可能来回好几个回合,每一回合都在逼近最终标准。

多轮纠错的第一步是错误分类:把校验失败的原因分成“语法错误”(JSON 都解析不了)、“结构错误”(缺 key)、“语义错误”(值不在枚举内)。分类后就可以针对性修复——语法错误就强调格式;结构错误就给出模板;语义错误就把合法值列表再贴一次。这就像品控大声报告:“不是菜咸了,是盘子裂了,换个盘子!”

每一轮循环,都是“生成 — 校验 — 反馈 — 再生成”的迭代,直到通过校验或达到终止条件。终止条件像一个总指挥,看三样东西:是否通过校验、是否达到最大轮数、是否超出预算。三个条件任何一个命中,循环立即收工。我在代码里经常写 for attempt in range(max_rounds):,然后配合 break,逻辑清晰又安全。

从菜单、品控到返工,这家“AI 餐厅”终于运转得井井有条。你再也不用担心厨师端上来一盘邪门料理——因为门被焊死了。

outcome={y∗,Validator(y∗)=真error,round≥R\displaystyle \text{outcome} =\begin{cases}y^{*}, & \text{Validator}(y^{*}) = \text{真} \\[4pt]\text{error}, & \text{round} \geq R\end{cases}
公式解读:多轮纠错的最终结果——要么交出通过校验的合格输出,要么在轮数用尽时如实报告失败。简单,但可靠。
  1. 成功分支当某一轮的输出 y* 通过了校验器,整个循环立刻终止并返回它。
    Validator(y∗)=真\text{Validator}(y^{*})=\text{真}
  2. 失败分支当轮数达到上限 R,不再退让,返回 error 让更上层接管。
    round≥R\text{round} \geq R
  3. 分段选择这个花括号结构表达“两种情况只取其一”,非常清晰,正是多轮纠错的决策骨架。
    outcome={y∗,⋯error,⋯\text{outcome} = \begin{cases}y^{*}, & \cdots \\ \text{error}, & \cdots \end{cases}

AI 应用场景

智能客服工单自动分类流水线

阶段:自动化 Pipeline 构建

解决的问题:传统客服工单分类靠人工阅读与标注,一天几千条工单要累垮三班倒的客服组长。AI 自动分类看似美好,但模型自由发挥的输出(乱起标签、字段不全、偶尔还输出解释文字)会让下游系统直接崩溃。

具体案例:某电商公司构建工单自动分类系统:先通过输出约束限定模型必须返回 JSON,包含 category(枚举:退款/物流/售后/其他)与 priority(枚举:高/中/低);再用校验器检查 JSON 是否可解析、枚举值是否合法;若失败,把错误信息回传给模型重试,最多 3 次,显著将分类准确率从 72% 提升到 95%。

财报数据抽取与录入

阶段:结构化数据抽取

解决的问题:从 PDF 财报中抽数字,最怕模型把金额抽成带逗号的字符串或漏掉关键字段,进而污染数据库。

具体案例:内部投研工具每天从 200 份财报中抽取 revenue、net_income、date 三个字段,用 JSON Schema 校验类型与范围;校验失败时自动携带错误信息重试,重试上限 5 次。自上线以来,数据入库的格式错误率从 11% 降到了 1% 以下。

自动化批量内容生成

阶段:内容生产管线

解决的问题:批量生成商品描述时,模型偶尔输出 Markdown 或带 emoji 的废话,破坏排版线。

具体案例:用约束强制“只返回纯文本 JSON”,再用校验器拦截包含 #、* 的脏输出;命中错误自动重试两次,从源头保证了生成内容的纯净度,让渲染层再也不用写清理脚本。

Python 演示

python73 行
# -*- coding: utf-8 -*-"""模拟 LLM 输出约束 + 校验 + 重试的迷你流水线。"""import jsonimport timefrom random import random, randint, choice CONSTRAINT_PROMPT = """你是工单分类器。只输出 JSON,不要输出任何解释。JSON 必须包含三个字段:- order_id: 字符串- category: 只能是退款|物流|售后|其他- priority: 只能是高|中|低示例: {"order_id": "A001", "category": "物流", "priority": "中"}""" def fake_llm_generate(order_id, error_hint=""):    """模拟大模型生成结果,30% 概率产生某种缺陷。"""    roll = random()    if roll < 0.30:        return '{"order_id": ' + order_id + ', "category": "未知", "priority": "超高"}'    if roll < 0.10:        return "抱歉,我无法解析该工单。"    if error_hint:        print("      携带纠错信息:", error_hint)    return json.dumps({        "order_id": order_id,        "category": choice(["退款", "物流", "售后", "其他"]),        "priority": choice(["高", "中", "低"])    }, ensure_ascii=False) def validate_order(text):    """三层校验: 解析、类型、枚举范围。返回 (ok, errors)。"""    errors = []    try:        data = json.loads(text)    except json.JSONDecodeError as exc:        return False, ["JSON解析失败: " + str(exc)]    if not isinstance(data, dict):        return False, ["最外层必须是对象"]    if data.get("order_id") is None:        errors.append("缺少 order_id")    if not isinstance(data.get("category"), str):        errors.append("category 必须是字符串")    elif data.get("category") not in ["退款", "物流", "售后", "其他"]:        errors.append("category 不在合法枚举内")    if data.get("priority") not in ["高", "中", "低"]:        errors.append("priority 取值越界")    return (not errors), errors def try_place_order(order_id, max_retries=3):    """带重试的生成入口,内部完成约束+校验+反馈循环。"""    hint = ""    for attempt in range(1, max_retries + 1):        print("第 %d 次生成..." % attempt)        text = fake_llm_generate(order_id, hint)        ok, errors = validate_order(text)        if ok:            print("  校验通过, 结果:", text)            return True, text        hint = "; ".join(errors)        print("  校验失败, 误差:", hint)        time.sleep(0.5)    return False, "达到最大重试次数" if __name__ == "__main__":    ids = ["A001", "B002", "C003"]    success = 0    for order_id in ids:        ok, result = try_place_order(order_id)        if ok:            success += 1        print("---")    print("流水线成功率: %d/%d = %.0f%%" % (success, len(ids), 100.0 * success / len(ids)))
目的:演示一个完整可运行的迷你流水线——用约束 Prompt 圈定输出格式、用校验器做三层检查、失败时携带错误信息重试。直接 python 运行即可看到“生成→校验→反馈→重试”的完整闭环。
  1. CONSTRAINT_PROMPT输出约束菜单:明确要求 JSON 结构、枚举值和示例,相当于给后厨立规矩。
  2. fake_llm_generate()模拟大模型生成:用概率注入 JSON 解析失败和枚举越界等缺陷,模拟真实模型的不可控。
  3. validate_order()三层校验器:先 json.loads 验证语法,再检查字段类型和枚举范围,输出 (ok, errors)。
  4. try_place_order()重试主控:最多 max_retries=3 轮,超限即回退失败,避免死循环。

常见误区

误区提示词里只要把格式和字段写清楚,模型就一定会遵守。我的约束已经很长很详细了,输出应该不可能出错。

正解约束只能大幅提高成功率,不能保证 100%。LLM 是概率模型,偶尔会解析错误、输出幻觉或擅自加料;校验器是最后一道安全闸,没有校验的管线就像没有品控的餐厅,迟早向顾客端出错菜。

为何常见:人们习惯把“我讲清楚了”等同于“对方照做了”,忽略了模型输出的概率本质。

误区失败就重试,程序反复调同一条 API,总有一次能成功。三秒不行就十秒,十次不行就一百次。

正解无脑重发同样请求,等于把同一份错误答案反复提交。有效的重试必须携带错误反馈——把校验器的错误信息拼回提示词,让模型知道“哪里错、怎么改”。同时要设上限与退避,否则既烧钱又拖垮服务。

为何常见:直觉上认为“多试几次总有一次好运气”,却忽略了缺少反馈的重试几乎是在浪费时间。

误区把所有可能的输出都枚举出来,模型就绝对安全。比如规定每个字符、每层嵌套都必须写死。

正解约束过死会严重压缩模型的理解空间,迫使其生成“字面上合法但语义糟糕”的垃圾输出;校验失败率反而更高。好的约束是给出目标格式 + 合理枚举 + 明确边界,而不是用枷锁绑死模型。

为何常见:希望用“确定性手段”消灭概率世界的不确定性,忽略了模型自身的推理能力。

误区第一轮返回错误就认定模型不行,立即切换模型或让用户重新输入,导致极差的体验。

正解单次失败可能是偶发的采样波动,多轮纠错机制正是为此设计——分类错误原因、回传反馈、逐轮逼近。直接放弃等于白白浪费前面的 prompt 设计成本,也让重试策略失去了存在价值。

为何常见:把单次失败解读为能力不足,而不是概率事件;缺乏对重试的设计耐心。

面试题

Q1. 输出约束的核心作用是什么?

单选题 · easy

  • A.提升模型的推理速度
  • B.让输出更符合预期格式← 正确答案
  • C.降低训练数据标注成本
  • D.扩大模型的词表容量

答案:B。输出约束的核心是圈定模型输出空间,使其格式、字段、取值范围符合预期,相当于给后厨一张明确的菜单。选项 A(推理速度)、C(训练成本)、D(词表)都与生成环节的格式限定无关,故排除。

Q2. 以下哪项属于输出约束的典型写法?

单选题 · easy

  • A.请返回 JSON 对象并限定字段← 正确答案
  • B.请自由发挥写一段散文
  • C.请尽量详细地解释你的思路
  • D.请用幽默风趣的语气回答

答案:A。输出约束强调结构化与确定性,明确要求“JSON 对象 + 限定字段”符合约束精神。其余选项追求开放、创意或语气,属于开放式指令,无法限制输出形态。

Q3. 校验器发现 JSON 无法解析时,最为合理的下一步是?

单选题 · easy

  • A.直接丢弃结果并静默失败
  • B.修改提示词强制要求 JSON
  • C.把解析错误回传给模型重试← 正确答案
  • D.让用户手动检查全部输出

答案:C。错误反馈式重试是标准解法——把解析错误信息回传给模型,让它知道自己错在哪。静默失败会掩盖问题,只改提示词不解决当次输出,人工检查在自动化管线中成本过高。

Q4. 在重试策略中,指数退避的主要目的是什么?

单选题 · mid

  • A.等模型冷却下来再请求
  • B.避免击穿下游服务限流← 正确答案
  • C.让错误信息传播得更快
  • D.增加 API 调用的成功率

答案:B。指数退避让失败后的等待时间逐轮翻倍,核心目的是降低对后端服务的瞬时压力,躲避限流与雪崩。选项 A 只描述了现象,C 与 D 不是退避的直接目的。

Q5. 多轮纠错流程的终止条件不包括以下哪项?

单选题 · mid

  • A.输出通过校验器
  • B.重试轮数达到上限
  • C.累计 API 费用超预算
  • D.提示词长度超过 1000 字← 正确答案

答案:D。终止条件看“是否通过、轮数、预算”三件事,与提示词长度无关。提示词超长可以截断或压缩,但它不是纠错循环的收尾判据。

Q6. 当校验器返回“category 取值越界”,应如何设计重试消息?

单选题 · mid

  • A.原样再发一次相同请求
  • B.附上合法枚举值列表并重发← 正确答案
  • C.将返回结果截断后重发
  • D.把校验器逻辑换为宽松模式

答案:B。重试要带着有效反馈,附上合法枚举值列表,等于告诉厨师“只能用这四种酱料”。原样重发等于空转;截断与宽松校验会引入新问题。

Q7. 输出约束在什么时候价值最大?

单选题 · mid

  • A.模型进行自由创作时
  • B.输出要直接进入下游程序时← 正确答案
  • C.模型进行预训练数据清洗
  • D.用户进行本地模型微调

答案:B。当 AI 输出要被下游程序直接消费(JSON 入库、字段赋值、路由分发)时,约束与校验价值最大,保证了端到端自动化不崩。创作场景反感约束,预训练与微调不涉及在线输出格式。

Q8. 输出校验通常包含哪些层面的检查?

多选题 · mid

  • A.JSON 结构能否正确解析← 正确答案
  • B.字段类型是否符合预期← 正确答案
  • C.输出文本字数是否足够多
  • D.枚举值是否在允许集合内← 正确答案

答案:ABD。三层校验是结构、类型、内容审查(枚举范围),对应 A、B、D。C“字数多”不是校验目标,语义质量不属于格式校验的默认环节,故排除。

Q9. 重试机制里,哪些做法能提升二次生成成功率?

多选题 · hard

  • A.把校验错误详情拼入提示词← 正确答案
  • B.给出正确输出的示例模板← 正确答案
  • C.保持上下文与上次完全一致
  • D.设置合理的最大重试次数← 正确答案

答案:ABD。错误详情与示例模板是有效反馈,最大重试次数是流程保障,三者协同。C 保持上下文不变等于重发相同请求,不会给模型任何新信息,故不选。

Q10. 以下哪些方式能让 AI 输出更稳定可靠?

多选题 · hard

  • A.用结构化约束表达输出格式← 正确答案
  • B.在管线中加自动校验与反馈← 正确答案
  • C.彻底禁止模型输出任何内容
  • D.失败时携带错误信息重试← 正确答案

答案:ABD。约束、校验、反馈重试是可靠性三件套。C 彻底禁止输出属于因噎废食,直接让任务无法完成,故排除。