知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 性能与成本优化 > 导读:本文从"Agent 终于能跑通业务流程了,但账单涨得比业务快,单次响应还要等十几秒"这个具体痛点出发,把成本构成、缓存策略、并行执行、Token 优化、预算控制这五件事讲透,最后给出工程实践与踩坑。适合正在为 Agent 做性能调优、或需要回答"Agent 成本怎么降、延迟怎么降"的同学。 ## 一、先建立全局认知 ### Q:Agent 的钱主要花在哪? A:结论先行——主要花在 LLM 的 Token 上,而 Token 的构成里"随轮次增长的对话历史"和"每步变化的外部内容(检索文档、工具返回)"通常占大头。也就是说,**成本不是均匀分布的,而是集中在少数几个环节**。 ```text 每次任务的 Token 消耗构成: 系统 Prompt(固定) + 工具描述(固定) + 对话历史(随轮次增长) + 检索到的文档(每步变化) + LLM 输出(每步变化) 一个多步任务的示意性拆解(数值仅为示意,须以实测为准): 系统 Prompt:固定量级 工具描述(10 个工具):固定量级 对话历史(10 轮):随轮次线性增长 检索文档(每步):每步都可观 LLM 输出(每步):与输出长度相关 ``` 关键点解读:注意其中最关键的规律——**固定部分(系统提示、工具描述)是"每次调用都要付一次"的税,变动部分(历史、检索)是"越跑越贵"的税。** 前者靠精简描述与减少调用次数来降,后者靠上下文管理与缓存来降。此外要记住一个结构性事实:**输入与输出通常分别计价,且输出的单价往往显著高于输入**。具体价目会随时间变动,请务必以你自己使用的定价与实测账单为准,不要照搬任何示例数字。 ### Q:为什么必须"先测量,再优化"? A:结论先行——因为 Agent 的成本与耗时分布高度偏斜,"凭感觉优化"极易优化到不重要的地方,甚至把成本转移到别处。没有基线数据,你无法判断改动是净收益还是净损失。 ```text 没有测量的三种典型误判: 1. 以为瓶颈在模型推理 → 实际在重复的工具调用 2. 以为缓存能省钱 → 实际缓存键不规范,命中率近乎为零 3. 以为并行能提速 → 实际关键路径由最慢子任务决定,没变 必须建立的基线(按任务统计): 输入 Token / 输出 Token / 工具调用次数 / 端到端耗时 / 步骤数 ``` 关键点解读:这三条误判都指向同一个方法论——**优化必须作用在"被测量证实的瓶颈"上**。第 3 条尤其常见:很多人一看到"多步任务"就上并行,结果发现耗时由最长的那一步决定,并行的收益被"聚合环节"的串行开销吃掉。所以基线数据不是"锦上添花",它是"优化"这个动作的定义前提。 ### Q:性能(延迟)和成本是一回事吗? A:结论先行——不是,但它们经常同源。降低上下文长度会同时降成本与降延迟;而上并行只降延迟不降成本(甚至略微升成本)。所以要区分目标,避免用一个手段去解两个不同的问题。 | 目标 | 主要手段 | 副作用 | |---|---|---| | 降成本 | 缓存、精简上下文、模型路由 | 可能降低质量或引入脏读风险 | | 降延迟 | 并行、缓存、更小的模型 | 并行提高并发压力;小模型可能降质 | | 两者兼顾 | 上下文优化、缓存 | 需要正确的失效与规范化设计 | 关键点解读:这张表最实用的提醒是"**模型路由是一把双刃剑**"——把简单任务路由到更小/更便宜的模型可以同时降成本与降延迟,但如果路由判据不准,把复杂任务也路由过去了,就会以"质量下降"的形式付出代价,且这类问题很隐蔽(因为它不报错)。所以路由必须配合质量抽检。 ## 二、缓存策略 ### Q:为什么说语义缓存是"最有效"的一招? A:结论先行——因为 Agent 场景里存在大量"表述不同但语义相同"的请求(如"北京今天天气"与"北京今日天气如何"),精确匹配的缓存命中率很低,而语义缓存(Semantic Cache)能把它们归到同一个缓存条目,命中率显著提升。 ```python from langchain.cache import RedisSemanticCache from langchain_openai import OpenAIEmbeddings import langchain # 设置语义缓存:相似的问题命中同一个缓存 langchain.llm_cache = RedisSemanticCache( redis_url="redis://localhost:6379", embedding=OpenAIEmbeddings(), score_threshold=0.95 # 相似度阈值,越高越严格 ) # 之后所有 LLM 调用自动使用缓存 # "北京今天天气" 和 "北京今日天气如何" 会命中同一个缓存 ``` 关键点解读:`score_threshold` 是这里唯一需要认真调参的地方,而它的调法体现了典型的"**召回与准确**"取舍——阈值设高(更严格),命中率低但几乎不会错;阈值设低,命中率高但可能把"相似但不同"的问题当成同一个,返回错误答案。**在 Agent 场景里,语义缓存的风险比普通问答更高**,因为 LLM 的输出会被后续步骤消费,一个错误的缓存命中可能污染整条推理链。所以建议:先设高阈值跑一段时间,用命中率与抽查准确率来决定是否下探。另外注意缓存的是"模型输出",若你的 Prompt 包含时效性内容,必须把时效因素纳入缓存键或禁用缓存。 ### Q:工具结果缓存怎么按不同时效分层? A:结论先行——按"数据变化速度"给每个工具配不同的 TTL,并对确定性工具(纯计算)做永久缓存。 ```python class SmartToolCache: """智能工具缓存:根据工具类型设置不同的 TTL""" TTL_CONFIG = { "search_web": 300, # 搜索结果缓存 5 分钟 "get_weather": 1800, # 天气缓存 30 分钟 "query_database": 60, # 数据库查询缓存 1 分钟 "get_stock_price": 10, # 股价缓存 10 秒 "read_file": 3600, # 文件内容缓存 1 小时 "calculate": None, # 计算结果永久缓存(确定性结果) } async def get_or_execute(self, tool_name: str, args: dict, tool_func): ttl = self.TTL_CONFIG.get(tool_name, 300) # 确定性工具(计算等)永久缓存 if ttl is None: cache_key = self._make_key(tool_name, args) cached = await self.cache.get(cache_key) if cached: return cached result = await tool_func(**args) await self.cache.set(cache_key, result) return result # 有时效性的工具 cache_key = self._make_key(tool_name, args) cached = await self.cache.get(cache_key) if cached: return cached result = await tool_func(**args) await self.cache.setex(cache_key, ttl, result) return result ``` 关键点解读:这段代码的设计精华是"**用配置表达的时效模型**"——把 TTL 从代码里抽出来做成一张表,就变成了一份"数据新鲜度契约",可以被评审、被调整、被监控。`calculate: None` 表示永久缓存,这个特例揭示了一个重要分类:**确定性函数的输出可以永久缓存,因为它不会变**;而一切依赖外部状态的输出都必须有 TTL。注意表中的 TTL 数值均为示意,必须按业务的数据变化周期与"读错代价"实测确定。另外 `_make_key` 必须做参数规范化(排序键),否则缓存命中率会趋近于零。 ### Q:缓存的价值和风险各是什么? A:结论先行——价值是同时降成本与降延迟,且对重复模式的任务收益极大;风险是脏读、击穿、以及"让 Agent 行为变得难以复现"。 ```text 收益: 同一子问题反复出现 → 直接复用,省一次调用与一次等待 确定性计算 → 永久复用,零边际成本 风险: 脏读:数据已变、缓存未过期 → 返回过期结果 击穿:热点键过期的瞬间大量并发回源 不可复现:同一任务的两次执行走了不同的缓存路径 → 排查时"本地怎么也复现不出来" ``` 关键点解读:最后一条风险在 Agent 场景里被放大——**因为缓存影响的是"模型的输入",而模型输入的变化会导致完全不同的输出路径**。所以缓存命中/未命中必须被记录进追踪(第 05 篇)。一条实用的原则是:**在开发与调试环境关闭缓存**,只在生产开启,或者提供一个强制回源的开关,用于复现问题。 ## 三、并行执行优化 ### Q:怎么识别哪些步骤可以并行? A:结论先行——把计划建成依赖图,每一轮把所有"依赖已满足"的步骤一起并发执行,直到全部完成或检测到无法推进(防止死锁)。 ```python class ParallelExecutor: """识别并行机会,自动并行执行独立步骤""" async def execute_plan(self, plan: list[dict]) -> list: """分析计划,找出可以并行的步骤""" # 构建依赖图 dependency_graph = self._build_dependency_graph(plan) results = {} executed = set() while len(executed) < len(plan): # 找出所有依赖已满足的步骤 ready_steps = [ step for step in plan if step["id"] not in executed and all(dep in executed for dep in step.get("depends_on", [])) ] if not ready_steps: break # 防止死锁 # 并行执行所有就绪的步骤 step_results = await asyncio.gather(*[ self._execute_step(step, results) for step in ready_steps ], return_exceptions=True) for step, result in zip(ready_steps, step_results): results[step["id"]] = result executed.add(step["id"]) return results # 示例:分析报告任务 plan = [ {"id": "search_market", "task": "搜索市场数据", "depends_on": []}, {"id": "search_competitor", "task": "搜索竞争对手", "depends_on": []}, {"id": "analyze", "task": "综合分析", "depends_on": ["search_market", "search_competitor"]}, {"id": "write_report", "task": "撰写报告", "depends_on": ["analyze"]}, ] # search_market 和 search_competitor 会并行执行 ``` 关键点解读:这是一个"**按层推进**"的拓扑执行模型——每一轮挑出所有可执行的节点,一起跑,再进入下一轮。三个细节值得注意。第一,`if not ready_steps: break` 是防死锁的保险:若依赖图有环或依赖了不存在的 id,循环会永远找不到就绪步骤,这一步把它变成"安全退出"而不是"死循环"。第二,`return_exceptions=True` 让单个步骤失败不拖垮整轮(与第 06 篇并行 Agent 的处理一致)。第三,这个模型的效率上限由"层数 × 每层最慢节点"决定——**如果某一步特别慢,它就会成为关键路径,其他并行都白搭**。所以先看耗时分布,再决定是否值得引入并行,这又回到了"先测量"。 ### Q:并行有什么代价? A:结论先行——三条:瞬时并发压力上升(可能触发限流)、依赖关系必须显式且正确、失败与重试的组合复杂度上升。 ```text 并行的三种代价: 1. 压力:N 个步骤同时打向同一个下游 → 更容易限流 → 缓解:并发上限(信号量)、按下游分别限流 2. 契约:depends_on 写错会导致"读到了还没产出的结果" → 缓解:启动时先做一次依赖图校验(无环、无悬空 id) 3. 复杂度:多个并行分支同时失败时的重试与降级组合爆炸 → 缓解:每个分支独立重试;整轮失败走统一降级 ``` 关键点解读:第 2 条是最隐蔽的——**依赖少写一条,程序不会报错,但会读到 `None` 或不完整的结果**,模型基于残缺信息继续推理,最终产出错误结论。所以"启动时校验依赖图"应该是强制执行的一步,而不是可选优化。第 1 条提醒我们并行度要可控:不加限制的并行在压测里看着很快,在线上限流后反而更慢。 ### Q:工具调用为什么强调"批量"? A:结论先行——因为每多一次"模型往返",就多一轮完整的上下文重发(历史 + 工具描述全部再计费一次)。把多个独立调用合并成一批,等于把若干轮压缩成一轮。  *图:串行多轮与批量调用:上下文发送次数与并行度* ```text 串行多轮的代价(示意): 第 1 轮:发全部上下文 → 模型返回调用 A 第 2 轮:再发全部上下文 → 模型返回调用 B 第 3 轮:再发全部上下文 → 模型返回调用 C → 上下文被重复发送 3 次 批量调用的收益: 若 A、B、C 相互独立 → 让模型一次返回三个调用 → 只发送一轮上下文,并行执行三个工具 → 轮次减少,成本与延迟同时下降 前提条件: 三个调用确实相互独立(无先后依赖) 工具本身允许并行(下游能承受并发) ``` 关键点解读:这里的核心洞察是——**Token 成本主要由"轮次 × 每轮上下文大小"决定,而不仅是"总调用次数"**。所以"减少轮次"往往比"减少单次调用"更有效。批量化的前提是独立性,判断方法与并行优化完全一致(看 `depends_on` 是否为空)。注意批量的上限:一次塞太多工具调用会让模型的选择准确率下降(回到第 01 篇的决策负担问题),所以"批量"与"分批粒度"之间也要权衡。 ## 四、Token 优化 ### Q:工具描述精简真的有用吗? A:结论先行——有用,且收益是"每次调用都省一次"。因为工具描述几乎出现在每一次 LLM 调用里,它的精简是"乘以调用次数"的收益。 ```python # 完整描述(浪费 Token) VERBOSE_TOOL_DESC = """ search_web: 这个工具用于在互联网上搜索信息。你可以使用它来查找最新的新闻、 技术文档、产品信息等。当你需要了解某个话题的最新动态时,这个工具非常有用。 参数:query(字符串,搜索关键词) 返回:搜索结果的摘要列表 """ # 精简描述(节省 Token) CONCISE_TOOL_DESC = """ search_web(query): 搜索互联网。用于获取最新信息。 """ ``` 关键点解读:这段对比的架构含义是——**固定开销要用"乘法视角"去看**。系统提示与工具描述是"每次调用都付"的成本,所以在多步任务里它们会被重复计费多次。反过来说,也正因为它们每次都在,**精简时要格外小心不要删掉关键语义**(如"何时不用"的信息,见第 03 篇),否则省下的 Token 会以"选错工具"的形式加倍还回去。原文给出的"节省约 80% Token、效果几乎一样"是一个经验性观察,请在自行对比评测后采用,不要直接当作结论。 ### Q:上下文怎么动态裁剪才不伤质量? A:结论先行——保留三类内容:系统消息、最近若干条消息、以及预算允许范围内从新到旧填充的中间历史;超预算就停止填充。 ```python def optimize_context(messages: list, max_tokens: int = 8000) -> list: """动态裁剪上下文,保留最重要的信息""" total_tokens = 0 optimized = [] # 始终保留系统消息 system_msgs = [m for m in messages if m["role"] == "system"] for msg in system_msgs: total_tokens += estimate_tokens(msg) optimized.append(msg) # 始终保留最后 3 条消息(最近的上下文) recent_msgs = [m for m in messages if m["role"] != "system"][-3:] recent_tokens = sum(estimate_tokens(m) for m in recent_msgs) # 在剩余空间内,从最新到最旧填充历史消息 remaining_budget = max_tokens - total_tokens - recent_tokens middle_msgs = [] for msg in reversed([m for m in messages if m["role"] != "system"][:-3]): msg_tokens = estimate_tokens(msg) if remaining_budget - msg_tokens < 0: break middle_msgs.insert(0, msg) remaining_budget -= msg_tokens return optimized + middle_msgs + recent_msgs ``` 关键点解读:这段裁剪的逻辑与第 02 篇的滑动窗口同源,但多了一层"**先给必留项预留预算**"的工程化处理:先扣掉系统消息与最近消息,再用剩余预算尽力多塞一些中间历史。这个"预留"思路很重要——它保证了**无论预算多紧,最关键的两类内容都不会被挤掉**。注意 `max_tokens = 8000` 是示意值,应与你的模型窗口、输出预留空间一起确定。另外要留意 `optimize_context` 与 `trim_messages` 若同时存在,应保证两者使用同一个 token 估算函数,否则预算会算不准。 ### Q:模型路由怎么用才安全? A:结论先行——按任务复杂度把请求分给不同档位的模型,用规则或轻量分类做判据;关键是配套质量抽检,否则"省下的钱"会以"变差的答案"偿付。 ```python class ModelRouter: """根据任务复杂度选择合适的模型""" MODELS = { "simple": "gpt-4o-mini", # 轻量档,简单任务 "standard": "gpt-4o", # 标准档,常规任务 "complex": "o1-preview", # 重推理档,复杂任务 } async def route(self, task: str, context: dict) -> str: """判断任务复杂度,返回合适的模型""" # 简单规则判断 if self._is_simple_task(task): return self.MODELS["simple"] elif self._needs_deep_reasoning(task): return self.MODELS["complex"] else: return self.MODELS["standard"] def _is_simple_task(self, task: str) -> bool: simple_patterns = [ "总结", "翻译", "格式化", "提取", "summarize", "translate", "format" ] return any(p in task.lower() for p in simple_patterns) def _needs_deep_reasoning(self, task: str) -> bool: complex_patterns = [ "证明", "推导", "分析原因", "制定策略", "prove", "derive", "analyze why", "strategy" ] return any(p in task.lower() for p in complex_patterns) ``` 关键点解读:这份实现的取舍非常明确——**用关键词规则而不是再起一个 LLM 来判复杂度**。理由是判复杂度本身若也要一次 LLM 调用,就等于"为了省钱先花钱",而且引入一层不确定性。规则路由的代价是覆盖不全(遇到规则未覆盖的任务会落到默认档),但因为默认档是"标准档",最坏情况也只是"没有省到钱",而不是"降了质量"。这个"**兜底落到安全档**"的设计思路与第 04 篇的降级链一致。注意这里的模型名只是示例,请以你实际可用的模型清单与定价为准。同时务必强调:**任何"用模型路由省钱"的结论都必须经过质量抽检与成本实测**,不能只看账单下降。 ## 五、成本监控与预算控制 ### Q:预算控制应该怎么做? A:结论先行——设"日预算 + 阈值告警 + 硬拦截"三层:接近阈值先告警,达到上限直接拦截并让任务降级或排队,而不是静默超支。 ```python class BudgetController: """成本预算控制器""" def __init__(self, daily_budget_usd: float, alert_threshold: float = 0.8): self.daily_budget = daily_budget_usd self.alert_threshold = alert_threshold self.today_spent = 0.0 async def check_budget(self, estimated_cost: float) -> bool: """检查是否有足够预算""" if self.today_spent + estimated_cost > self.daily_budget: raise BudgetExceededError( f"预算不足:今日已花费 ${self.today_spent:.2f}," f"预算上限 ${self.daily_budget:.2f}" ) if (self.today_spent + estimated_cost) / self.daily_budget > self.alert_threshold: await self.send_alert( f"预算使用率超过 {self.alert_threshold*100}%," f"今日已花费 ${self.today_spent:.2f}" ) return True def record_cost(self, cost: float, task_id: str): self.today_spent += cost # 记录到数据库用于分析 ``` 关键点解读:三层设计的核心是"**告警与拦截分开**"。只告警不拦截,会出现"告警天天响、没人管、月底超支";只拦截不告警,会在毫无预警的情况下突然断服。所以 80% 告警、100% 拦截是合理的默认组合(阈值可按业务调整)。另外注意 `estimated_cost` 是"预估"——**预估算不准会让预算形同虚设**,所以要用实际 usage 回流校准预估值。还要考虑一个边界:拦截至上之后,正在执行的任务怎么处理?建议是"让当前任务走完,只拦截新任务",避免把用户的任务打断在中间。 ### Q:性能优化有没有一份可以照着执行的检查清单? A:结论先行——有,按四类展开:Token、缓存、并行、成本控制。 ```text Token 优化: □ 工具描述精简(每个工具描述尽量短) □ 系统 Prompt 精简(去掉冗余说明) □ 对话历史有上限(按条数或 Token) □ 中间结果存状态,不放消息 □ 根据任务复杂度选择合适的模型 缓存优化: □ LLM 调用语义缓存(阈值从严开始) □ 工具结果按 TTL 缓存(按数据变化速度分档) □ 确定性工具结果永久缓存 并行优化: □ 识别独立步骤并行执行(先校验依赖图无环) □ 工具调用批量处理 □ 异步执行,不阻塞 成本控制: □ 设置每日预算上限 □ 监控每任务成本 □ 异常成本告警 ``` 关键点解读:清单里有一个隐含的执行顺序——**先做"加法"(测量基线、加缓存与并行),再做"减法"(精简描述、裁剪上下文、路由小模型)**。顺序反了会出问题:在没测量的情况下先精简描述,可能删掉了关键语义;在没校验依赖的情况下先并行,可能引入静默的错误读取。清单本身只是条目,顺序才是不踩坑的关键。 ### Q:成本该怎么归因?为什么必须按"单位任务"看? A:结论先行——归因要落到"单位任务",并进一步拆到"按环节(工具 / 步骤位置 / 是否为重试)",否则你只能看到总额上涨,却不知道是谁在烧钱。 ```text 三级归因: L1 总量:每日 / 每小时总消耗 L2 单位:单任务平均消耗、P50 / P99 L3 环节:按工具、按步骤位置、按是否重试、按命中缓存与否 为什么要到 L3: 总量上涨可能是"任务量上涨"而不是"单任务变贵" 单任务变贵可能只集中在少数"长尾任务"上 长尾变贵往往是因为某一步开始把全文反复塞进上下文 ``` 关键点解读:L1 与 L2 的区别是"规模效应"与"效率变化"的分界——**任务量翻倍导致总额翻倍是正常的,单任务成本翻倍才是问题**。L3 的价值在于定位:如果成本集中在"第 1~2 步"和"检索类工具",那优化方向就是上下文裁剪与工具结果外置;如果集中在"重试相关的调用",那要回头查可靠性配置(第 04 篇)。三个层级缺一层,归因链就断在那里。所有金额数字都应以你自己的实测口径为准。 ## 六、工程实践与踩坑 ### Q:性能与成本优化中最常见的坑有哪些? A:结论先行——五类:没基线就优化、缓存键不规范、并行度不限、模型路由无抽检、只看总成本不看分布。 ```text 坑 1:没有基线就动手 后果:无法判断改动是净收益还是把成本挪了个地方 修法:先按任务建立 Token/耗时/步骤数基线 坑 2:缓存键未规范化 后果:命中率趋近于零,缓存形同虚设 修法:键包含工具名 + 排序后的规范化参数 坑 3:并行度不加限制 后果:瞬时压力触发限流,线上反而更慢 修法:并发信号量;按下游分别限流 坑 4:模型路由不抽检 后果:成本降了,质量隐性地降了,且不报错 修法:定期抽样对比不同档位模型的质量 坑 5:只看总成本 后果:看不出钱花在哪个环节,优化无方向 修法:按任务、按工具、按步骤位置拆解成本 ``` 关键点解读:坑 4 是本文最需要强调的一条——**"降本"最容易以"降质"的形式偷偷发生**,而 Agent 的降质通常不会抛异常,只会让成功率或用户满意度缓慢下滑。所以凡是涉及质量敏感的手段(小模型、短上下文、激进缓存),都必须配套"质量抽检"这道闸门。坑 5 则回到了开篇的方法论:成本优化的前提是"知道钱花在哪"。 ### Q:怎么验证优化真的有效? A:结论先行——用同一批固定任务做 A/B 对照,同时看成本、延迟、质量三组指标;只有当"成本/延迟下降且质量不降"时,才认为优化成立。 ```text 验收对照(同一任务集,优化前 vs 优化后): 成本:单任务 Token 数、折算成本 延迟:端到端耗时 P50 / P99 质量:任务成功率、抽检质量评分 副作用:缓存命中率、限流次数、重试次数 判定规则: 成本降 + 延迟降 + 质量持平 → 采纳 成本降 + 质量降 → 需权衡,并显式记录代价 成本不降 + 延迟降 → 说明优化点选错了 ``` 关键点解读:最后一行给出的判据很实用——**如果只有延迟改善、成本毫无变化,那说明你优化的不是成本瓶颈**(例如把串行改并行,时间短了但 Token 数没变)。反过来也一样:如果只有成本下降、延迟没变,说明省的是"边角料"。用这四行做判定,可以避免"看起来做了很多优化、实际没什么效果"的情况。 ## 小结 - 一句话:**性能优化 = 缓存(减少重复调用)+ 并行(减少等待时间)+ Token 优化(减少每次调用的成本)+ 模型路由(用合适的模型做合适的事)。先测量,再优化。** - 成本集中在少数环节:固定开销(系统提示、工具描述)是"每次调用都付的税",变动开销(历史、检索)是"越跑越贵的税"。 - 语义缓存命中率最高但风险也最高,阈值应从严起步;工具缓存按数据变化速度分档,确定性结果永久缓存。 - 并行按依赖图分层推进,必须有防死锁退出、失败隔离与并发上限;依赖图上线前要校验。 - Token 优化的两类入手点:精简"每次都在"的固定内容;裁剪"越跑越长"的动态内容。 - 模型路由要用"兜底落到安全档"的策略,并强制配套质量抽检。 - 预算控制三层:阈值告警 + 上限拦截 + 任务级成本拆分。 - 一切成本与性能结论都必须以自身实测为准;单价的绝对值会变动,不要照搬示例。 ## 思考题 1. 语义缓存的阈值设低能提升命中率,但可能返回错误答案并污染后续推理链。请设计一套"分层阈值"方案(例如按任务风险分级),并说明如何监控它的准确率。 2. 并行执行的效率上限由"关键路径"决定。请给出一套方法,在计划阶段就估计出关键路径的耗时,从而判断并行是否值得。 3. 模型路由用关键词规则实现,那么"规则未覆盖"的任务会落到标准档。你会如何设计规则的迭代机制,让它随真实流量持续改进? 4. 预算"达到上限后拦截新任务、让当前任务走完"是一种策略。请分析它在用户体验与成本控制之间是否合理,并提出你认为更优的替代方案。 5. 如果成本降了 30% 但任务成功率从 92% 掉到 88%,你会如何定价这笔交易?请给出一套可以量化"质量损失"的评估方法。
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入