---
tags: [AI, 成本, 服务]
阶段: 08-Agent与工程化
难度: ★★★
created: 2026-10-18
related: "[[模型推理优化]], [[分布式训练与部署]], [[模型评估矩阵]], [[Agent工作流与编排]]"
---

# 成本-延迟-质量权衡

## 定义

**成本-延迟-质量权衡**指在质量下限与延迟上限的约束下，为每类请求选择模型、上下文长度、缓存策略与重试策略，使单位请求的期望货币成本最小；三者不是可以同时优化的独立指标，而是在固定技术与硬件下互相挤压的三个坐标。

本文使用的量定义如下，符号全文一致。

| 符号 | 含义 | 单位 |
|---|---|---|
| $n_{\text{in}},n_{\text{out}}$ | 单请求的输入与输出 token 数 | 个 |
| $p_{\text{in}},p_{\text{out}}$ | 每百万输入与输出 token 的价格 | 货币/百万 token |
| $C$ | 单请求期望成本 | 货币 |
| $L$ | 单请求端到端延迟 | 秒 |
| $P_{50},P_{95}$ | 延迟的 50 与 95 分位 | 秒 |
| $Q$ | 质量指标，取任务成功率 | 无量纲，0 至 1 |
| $h$ | 缓存命中率 | 无量纲 |
| $\tau$ | 路由阈值，低于此置信度则升级到大模型 | 无量纲 |
| $a(\tau)$ | 小模型承接比例，$a=1-\text{升级率}$ | 无量纲 |
| $C_{s},C_{l}$ | 小模型与大模型的单请求成本 | 货币 |
| $L_{s},L_{l}$ | 小模型与大模型的单请求延迟 | 秒 |

术语按首次出现处定义。**单请求成本**是一次请求消耗的全部计费资源，包括输入 token、输出 token、缓存查找与被重试放大的部分；**首 token 延迟**（TTFT）是请求到达到第一个 token 返回的时间；**每输出 token 时间**（TPOT）是解码阶段相邻 token 的平均间隔；**任务成功率**是在预先定义的判定规则下回答正确的请求比例；**模型路由**（routing）是按请求特征选择模型档位的策略；**级联**（cascade）是先由小模型尝试、失败或低置信时升级到大模型的特定路由；**语义缓存**（semantic cache）以嵌入向量的相似度而非精确匹配判定命中；**服务等级目标**（service level objective，SLO）是对某个可测指标的目标区间，**错误预算**（error budget）是 $1-\text{SLO}$ 允许的违约总量。

## 为什么重要

推理成本随请求数线性增长，且随上下文长度超线性增长。设一次请求的输入为 $n_{\text{in}}$、输出为 $n_{\text{out}}$，成本为

$$
C=\frac{n_{\text{in}}p_{\text{in}}+n_{\text{out}}p_{\text{out}}}{10^{6}} .
$$

单看每百万 token 的单价无法判断哪条链路更贵，因为不同任务的输入输出比例相差两个数量级：分类任务的输入可能是 200 token、输出 10 token，长文问答的输入可能是 30000 token、输出 400 token，按上式计算后者的成本是前者的 130 倍以上，而单价完全相同。

延迟的约束方式与成本不同。用户感知的是尾部而非均值：交互式场景中 P50 为 0.5 秒、P95 为 0.6 秒的服务，一旦把升级率提到 5% 以上，P95 会直接跳到升级路径的延迟，均值几乎不变。因此"平均延迟达标"不能作为验收条件。

质量与业务指标之间存在映射损耗。离线基准的分数提高 2 个百分点，不一定带来任务成功率的同幅提升，而任务成功率的提升也不一定转化为业务指标；把三者混为一谈会导致优化方向错误：为了基准分数选最大模型，成本上升一个数量级而业务指标不变。

没有显式权衡会产生三类后果。第一类是成本失控：所有请求都走最大模型，占多数的简单请求为少数困难请求支付了同等单价。第二类是延迟违约：为了省钱把困难请求也压在小模型上，重试率上升，P95 反而高于直接走大模型。第三类是评估失真：只统计成功响应的成本与延迟，忽略重试与超时，得出比实际低 30% 以上的结论。

在本库中的位置是决策层。[[模型推理优化]] 给出单请求的字节数与延迟构成，[[分布式训练与部署]] 给出单位卡时与部署形态，[[模型评估矩阵]] 给出质量指标的构造方法；本篇把这三组量放进同一个约束优化问题，[[Agent工作流与编排]] 则是在多步流程上重复本框架。对应学习目标中的"会评估"：能算出单任务成本，能判断一次优化是降低了成本还是只转移了成本。

## 原理与推导

### 1 三个目标的量化

成本按计费口径直接相加。多轮对话中每轮都要重发历史，第 $k$ 轮的输入为 $k\cdot n_{\text{turn}}$，$T$ 轮的总输入为

$$
n_{\text{in}}^{\text{total}}=n_{\text{turn}}\cdot\frac{T(T+1)}{2},
$$

即单轮输入的 $T(T+1)/2$ 倍。取 $T=10$、$n_{\text{turn}}=800$，总输入为 44000 token，是单轮的 55 倍；若按单轮成本乘以轮数估算，会低估 $(T+1)/2=5.5$ 倍。

延迟可分解为四项：

$$
L=L_{\text{queue}}+\text{TTFT}+(n_{\text{out}}-1)\cdot\text{TPOT}+L_{\text{net}},
$$

其中 $L_{\text{queue}}$ 为排队时间，$L_{\text{net}}$ 为网络与序列化开销。TTFT 由预填充决定，与 $n_{\text{in}}$ 近似线性、与 $n_{\text{in}}^{2}$ 的注意力项相关；TPOT 由解码步决定，主要由模型字节数与批大小决定。P95 不能由各分量均值相加得到，必须由端到端分布统计。

质量指标必须可判定。取判定函数 $r(x,\hat{y})\in\{0,1\}$，任务成功率为

$$
Q=\frac{1}{N}\sum_{i=1}^{N}r\left(x_{i},\hat{y}_{i}\right).
$$

判定可以是精确匹配、单元测试通过、或按评分规则判定的阈值。不可判定的"满意度"不能作为优化目标，只能作为辅助监控。

### 2 成本分解

单请求成本由四项构成：模型调用、重试放大、缓存查找、工具与检索。模型调用为 $C_{0}$。设单次成功率为 $q$、最多重试 $k$ 次（共 $k+1$ 次尝试），则尝试次数 $N$ 满足 $P(N\ge i)=q^{i-1}$，于是

$$
\mathbb{E}[N]=\sum_{i=1}^{k+1}P(N\ge i)=\sum_{i=0}^{k}q^{i}=\frac{1-q^{k+1}}{1-q},
$$

当 $k\to\infty$ 时趋于 $1/q$。因此重试把成本放大约 $1/q$ 倍。若 $q=0.9$，成本放大 11%；若 $q=0.7$，放大 43%，这时更便宜的做法是直接换更强的模型而不是重试。

缓存查找的成本是嵌入计算与向量检索，通常比一次生成低两个数量级，可近似为零。于是有效成本为

$$
C\approx(1-h)\,C_{\text{miss}}+h\,C_{\text{hit}}\approx(1-h)\,C_{\text{miss}} .
$$

### 3 延迟与排队

服务端在利用率 $\rho$ 下的排队时间决定 P95 的量级。单服务台、到达率 $\lambda$、服务率 $\mu$ 的 M/M/1 系统中

$$
\mathbb{E}[W_{q}]=\frac{\rho}{\mu(1-\rho)},\qquad \rho=\frac{\lambda}{\mu}.
$$

取 $\mu=20$ 请求/秒：$\rho=0.8$ 时平均排队 0.2 秒，$\rho=0.9$ 时 0.45 秒，$\rho=0.95$ 时 0.95 秒。P95 的放大比均值更陡，因为排队时间的分布是重尾的。

批处理提高吞吐但抬高单请求延迟。设批的成形速率为 $r_{\text{batch}}$（批/秒），一条请求平均要先等半批的时间，即 $(B-1)/(2r_{\text{batch}})$ 秒，且整批的完成时间由最长输出决定。因此批处理适合离线任务与高吞吐场景，不适合交互式首屏。

### 4 模型路由

两档级联是最常见的路由形式：小模型先试，置信度低于阈值 $\tau$ 时升级。设小模型输出置信度 $c(x)$，承接比例 $a(\tau)=P(c\ge\tau)$，则

$$
C(\tau)=C_{s}+(1-a(\tau))\,C_{l},
$$

$$
L(\tau)=L_{s}+(1-a(\tau))\,L_{l},
$$

$$
Q(\tau)=a(\tau)\,q_{s}(\tau)+(1-a(\tau))\,q_{l},
$$

其中 $q_{s}(\tau)$ 是在承接部分上的小模型成功率，它随 $\tau$ 上升而上升，因为被承接的请求更容易。三式给出边际关系：升级率每提高 1 个百分点，成本增加 $0.01(C_{l}-C_{s})$，延迟增加 $0.01(L_{l}-L_{s})$ 的对应份额，质量增加 $0.01(q_{l}-q_{s}(\tau))$。

路由有效的前提是置信度经过校准。若置信度与正确率不对应，阈值就没有意义，表现为高置信度区间内的错误率与小置信度区间相当。校准的检验方法是把置信度分桶，比较每桶的平均置信度与实际正确率，两者之差即校准误差；工程上要求最大偏差不超过 0.05。

### 5 缓存

精确缓存以请求的规范化哈希为键，命中即返回，风险来自键未覆盖的隐变量：模型版本、温度、系统提示、工具权限。键必须包含这些字段，否则一次模型升级会让旧答案继续返回。

语义缓存以嵌入向量的余弦相似度判定，阈值常取 0.95 以上。其风险是假阳性：两条语义相近但意图不同的请求被判为命中，返回错误答案且不触发任何重试。设假阳性率为 $f$、缓存答案在假阳性样本上的正确率为 0，则质量损失为

$$
\Delta Q=f\cdot Q_{\text{miss}} .
$$

$f=2\%$ 时质量下降约 0.02 的绝对值，看似可接受，但在高风险场景中这 2% 的错误分散在长尾，难以被平均值发现。缓解手段包括：按领域分库并各自设阈值、对高相似度但实体不同的请求强制绕过缓存、缓存写入只接受已验证的输出。

缓存污染是另一类风险：不可信输入写入缓存后，后续相同请求会返回被注入的内容。防护要求写入路径与读取路径的信任级别一致，并对写入内容做来源标记。

### 6 上下文的二次与线性项

上下文长度对三个目标的影响不同。成本随 $n_{\text{in}}$ 线性增长；预填充时间由

$$
F_{\text{prefill}}=2Pn_{\text{in}}+4Ln_{\text{in}}^{2}h
$$

决定，第二项使 TTFT 随长度超线性增长；KV 缓存字节数随长度线性增长，因而并发数按 $1/n_{\text{in}}$ 下降。对 7B 模型取 $n_{\text{in}}$ 从 2048 增到 32768：token 数为 16 倍，预填充 FLOP 从 $3.1\times10^{13}$ 增到 $1.0\times10^{15}$，约 33 倍；单请求 KV 从 1 GiB 增到 16 GiB，80 GB 卡上的并发从 64 降到 4。三个量的放大倍数不同，说明"上下文翻倍成本翻倍"只在计费口径成立，在容量与延迟口径都不成立。

### 7 蒸馏与量化的影响

两种手段都改变模型本身，因此对三个目标的影响是结构性的，而不是调度层面的。

| 手段 | 成本 | 延迟 | 质量 | 主要风险 |
|---|---|---|---|---|
| 蒸馏到 1/10 参数 | 约降至 1/10 | 约降至 1/10 | 下降，幅度取决于数据覆盖 | 长尾能力先丢失 |
| 4 bit 量化 | 约降至 1/2 | 小幅下降 | 小幅下降 | 特定输入类型的截断 |
| 缓存 | 降至 $1-h$ | 命中时降至毫秒级 | 可能下降 | 假阳性与污染 |
| 路由 | 取决于升级率 | 混合 | 受阈值控制 | 置信度未校准 |

蒸馏的收益与模型规模近似成正比，因为解码受带宽限制，而带宽需求与参数量成正比；其质量损失集中在训练数据未覆盖的长尾，表现为平均指标下降不多而特定子集骤降。量化的收益来自字节数减半，对解码延迟的影响是直接的，对预填充延迟的影响较小，因为预填充受算力限制。

### 8 形式化与求解

把选择写成约束优化：

$$
\min_{\pi}\ \mathbb{E}_{x}\left[C\left(\pi(x)\right)\right]
\quad\text{s.t.}\quad
P\left(L\left(\pi(x)\right)>L_{\max}\right)\le\epsilon,\quad
\mathbb{E}\left[Q\left(\pi(x)\right)\right]\ge Q_{\min},
$$

其中 $\pi$ 是从请求到处置方案的映射，$\epsilon$ 是允许的尾部违约比例。对两档级联，$\pi$ 只由一个标量 $\tau$ 参数化，问题退化为一维搜索，可直接枚举 $\tau$ 并检查约束。

若约束集为空，说明在当前技术栈下三个目标不可同时满足。判断方法是对每个 $\tau$ 计算三元组 $(C,P_{95},Q)$，观察可行域；若不存在同时满足 $P_{95}\le L_{\max}$ 与 $Q\ge Q_{\min}$ 的 $\tau$，则必须放宽其中一个约束，或改变技术栈（换更快的模型、加缓存、减上下文）。这一结论本身是分析结果，不应通过调参掩盖。

拉格朗日形式给出边际替代率：

$$
\mathcal{L}=C+\lambda\left(P_{95}-L_{\max}\right)+\mu\left(Q_{\min}-Q\right),
$$

$\lambda$ 是"延迟每超标 1 秒"的影子成本，$\mu$ 是"质量每差 1 个单位"的影子成本。两者的比值决定在预算内向哪个方向倾斜。

### 9 成本核算表

以 $p_{\text{in}}=1$、$p_{\text{out}}=4$ 的相对价格为例，五种典型任务的计算结果如下。实际价格需按服务商公开的定价页填入，表中只保留比例关系。

| 任务 | 输入 token | 输出 token | 相对成本 | 主导项 |
|---|---|---|---|---|
| 短文本分类 | 200 | 10 | 0.00024 | 输入 |
| 客服问答 | 800 | 300 | 0.0020 | 输出 |
| 文档摘要 | 4000 | 500 | 0.0060 | 输入 |
| 代码生成 | 1500 | 2000 | 0.0095 | 输出 |
| 长文问答 | 30000 | 400 | 0.0316 | 输入 |

表的用法是定位优化方向：输入主导的任务应压缩上下文、做前缀缓存；输出主导的任务应限制最大输出长度、用小模型先出草稿。若不看主导项而统一优化，投入会落在收益较小的一侧。

### 10 A/B 与在线决策

离线评估无法覆盖真实流量的分布，上线前需要在线实验。两组比例指标的最小样本量近似为

$$
n\approx\frac{16\,\sigma^{2}}{\delta^{2}},
$$

其中 $\sigma^{2}=p(1-p)$ 为指标的方差，$\delta$ 为要检测的绝对差异，系数 16 对应显著性 0.05、检验力 0.8。取 $p=0.5$、$\delta=0.02$，每组需要 10000 个样本。

三类错误需要避免。第一是提前停止：在观察到显著差异时立刻停止会抬高第一类错误率，正确做法是固定样本量或使用序贯检验的 $\alpha$ 消耗函数。第二是只测主指标：路由降低了成本，但重试率上升导致的任务失败没有被计入，需要在同一实验中收集成本、延迟与质量三个指标。第三是忽略分流一致性：同一用户在不同请求间被分到不同组时，体验抖动会污染指标。

在线决策的另一种形式是多臂老虎机：把每个模型档位视为臂，按观测到的成本与质量更新选择概率，使探索成本随样本累积而下降。其代价是可解释性下降，且不适合需要稳定行为的产品。

### 11 SLO 设计

SLO 由指标、目标与窗口三部分组成。交互式服务的典型组合是：TTFT 的 P95 小于 1.5 秒、TPOT 的 P95 小于 80 毫秒、请求成功率高于 99.5%，统计窗口为 28 天。

错误预算为 $1-\text{SLO}$，消耗速率用燃烧率衡量：

$$
\text{burn rate}=\frac{\text{窗口内违约比例}}{1-\text{SLO}} .
$$

燃烧率 14.4 持续 1 小时会消耗 2% 的 28 天预算，适合作为快速告警阈值；燃烧率 6 持续 6 小时消耗 5%，适合慢速告警。多窗口组合可以在避免误报的同时保证发现速度。

SLO 的选取必须与成本联动。把 P95 目标从 2 秒收紧到 1 秒，通常需要把利用率从 90% 降到 70%，副本数增加约 30%；这一换算关系应在制定 SLO 时显式给出，否则目标会变成无法兑现的承诺。

## 关键直觉

> [!tip] 三个目标由同一组物理量决定：token 数决定成本，字节数与批大小决定延迟，模型能力决定质量。因此权衡不是在三者之间做主观取舍，而是先算出每条链路的 $(C,P_{95},Q)$ 三元组，再在约束下取成本最小者。级联之所以有效，是因为请求难度分布不均匀：多数请求落在小模型的能力范围内，用阈值把少数困难请求挑出来，只为它们支付高价。当约束集为空时，结论是当前技术栈不可行，而不是某个参数还没调好。

## 例子与代码

下面的模拟构造 20000 条请求，难度服从 Beta 分布，小模型的正确率随难度下降，置信度是难度的带噪函数。路由器按阈值 $\tau$ 决定走小模型还是升级到大模型，输出成本、延迟分位与质量三元组。

```python
import numpy as np

rng = np.random.default_rng(0)
N = 20000

C_S, C_L = 1.0, 12.0            # 单请求成本（相对单位）
L_S, L_L = 0.35, 1.50           # 服务时间中位数（秒）
O_S, O_L = 0.10, 0.25           # 排队与网络开销（秒）

difficulty = rng.beta(2.0, 3.0, N)
conf = 1.0 / (1.0 + np.exp(-(2.5 * (1.0 - difficulty) + rng.normal(0, 0.8, N))))
ok_small = rng.random(N) < (0.99 - 0.30 * difficulty)
ok_large = rng.random(N) < (0.995 - 0.01 * difficulty)
lat_small = L_S + O_S + rng.exponential(0.05, N)
lat_large = L_L + O_L + rng.exponential(0.08, N)

u_retry = rng.random(N)          # 固定掩码，便于改变重试率时对比

def evaluate(tau, retries=0.0):
    small = conf >= tau
    base = np.where(small, lat_small, lat_large)
    retried = u_retry < retries
    cost = np.where(small, C_S, C_L) * (1.0 + retries)
    lat = base + retried * base  # 重试一次：成本与延迟都叠加一次完整服务
    quality = np.where(small, ok_small, ok_large)
    return (cost.mean(), np.percentile(lat, 50), np.percentile(lat, 95),
            quality.mean(), small.mean())
```

打印阈值扫描表与两个基准。

```python
print(" tau   成本     P50     P95    质量   小模型占比")
for tau in [0.0, 0.3, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 1.01]:
    c, p50, p95, q, share = evaluate(tau)
    print(f"{tau:5.2f} {c:6.3f} {p50:7.3f} {p95:7.3f} {q:7.4f} {share:10.3f}")

print()
for name, tau in [("全小模型", 0.0), ("全大模型", 1.01)]:
    c, p50, p95, q, share = evaluate(tau)
    print(f"{name} 成本={c:6.3f} P50={p50:.3f} P95={p95:.3f} 质量={q:.4f}")
```

```text
 tau   成本     P50     P95    质量   小模型占比
 0.00  1.000   0.485   0.600  0.8707      1.000
 0.30  1.072   0.485   0.606  0.8720      0.993
 0.50  1.633   0.488   1.760  0.8817      0.942
 0.60  2.378   0.492   1.822  0.8924      0.875
 0.70  3.740   0.504   1.877  0.9115      0.751
 0.80  5.919   0.568   1.921  0.9371      0.553
 0.90  9.444   1.784   1.967  0.9722      0.232
 0.95 11.355   1.801   1.982  0.9863      0.059
 1.01 12.000   1.805   1.986  0.9908      0.000

全小模型 成本= 1.000 P50=0.485 P95=0.600 质量=0.8707
全大模型 成本=12.000 P50=1.805 P95=1.986 质量=0.9908
```

表中 $\tau=0$ 表示不升级，$\tau=1.01$ 表示全部升级。三个现象值得注意。第一，$\tau$ 从 0 增到 0.3 时成本只涨 7%，质量只涨 0.0013，说明置信度最低的那批请求恰好也是小模型最不擅长的，但数量太少，收益有限。第二，$\tau$ 从 0.5 起 P95 从 0.606 跳到 1.76：升级率超过 5% 后，95 分位落进升级路径，P95 直接等于大模型延迟。第三，$\tau=0.9$ 时成本是大模型的 79%，质量只低 0.019，这是级联的甜点区；再往下压成本，质量下降速度超过成本下降速度。

接下来求约束下的最优点，并显式处理不可行情形。

```python
def best_under(q_min, p95_max):
    best = None
    for tau in np.linspace(0.0, 1.0, 401):
        c, p50, p95, q, share = evaluate(tau)
        if q >= q_min and p95 <= p95_max and (best is None or c < best[0]):
            best = (c, tau, p50, p95, q, share)
    return best

for q_min, p95_max in [(0.96, 2.0), (0.96, 1.2), (0.95, 1.2), (0.99, 2.0)]:
    b = best_under(q_min, p95_max)
    if b is None:
        print(f"质量>={q_min}, P95<={p95_max}s: 无可行 tau")
    else:
        print(f"质量>={q_min}, P95<={p95_max}s: tau={b[1]:.3f} 成本={b[0]:.3f} "
              f"P50={b[2]:.3f} P95={b[3]:.3f} 质量={b[4]:.4f} 升级率={1 - b[5]:.3f}")

for r in (0.0, 0.1, 0.2):
    c, p50, p95, q, share = evaluate(0.8, retries=r)
    print(f"重试率 {r:.0%}: 成本={c:6.3f} P95={p95:.3f} 质量={q:.4f}")
```

```text
质量>=0.96, P95<=2.0s: tau=0.865 成本=8.071 P50=1.769 P95=1.951 质量=0.9601 升级率=0.643
质量>=0.96, P95<=1.2s: 无可行 tau
质量>=0.95, P95<=1.2s: 无可行 tau
质量>=0.99, P95<=2.0s: tau=0.973 成本=11.864 P50=1.804 P95=1.985 质量=0.9900 升级率=0.988
重试率 0%: 成本= 5.919 P95=1.921 质量=0.9371
重试率 10%: 成本= 6.511 P95=2.100 质量=0.9371
重试率 20%: 成本= 7.102 P95=3.595 质量=0.9371
```

第一行是可行域的边界：要质量 0.96 必须升级 64.3% 的请求，成本升到 8.07，相对全大模型只省 33%。第二、三行显示约束集为空：P95 上限 1.2 秒小于大模型单次服务时间 1.75 秒，而任何超过 5% 的升级都会把 P95 推到该值，因此不存在可行解。这不是参数没调好，而是三个目标在该技术栈下互斥，只能放宽延迟或换更快的模型。

最后三行验证重试的影响。重试率 10% 时成本上升 10%，P95 从 1.921 升到 2.100 秒；20% 时 P95 达到 3.595 秒，接近翻倍，因为重试的请求恰好落在尾部。这说明重试成本不是线性的，它在尾部的放大远超其在均值上的表现。

## 易错点

> [!warning] 以下五条均可在账单或监控中直接检验。
> 1. 只看单价不看 token 数。相同单价的两次调用，输入 200 token 与输入 30000 token 的成本差 150 倍。常见错误是用"每百万 token 价格"比较模型，却忽略输出 token 的价格通常是输入的 3 至 4 倍，导致输出主导型任务被误判为便宜。
> 2. 忽略重试与失败成本。按首次调用计价会低估 $1/q$ 倍，而重试还会把延迟尾部拉长。若重试的请求集中在困难样本上，P95 的恶化幅度远大于重试率本身：上例中 20% 的重试率使 P95 翻倍。
> 3. 缓存污染。语义缓存的键不含模型版本与系统提示，升级后仍返回旧答案；阈值设得过低导致近似但意图不同的请求命中；不可信输入写入缓存造成注入内容被反复返回。检验方法是按领域分桶统计命中样本的人工判定正确率。
> 4. 质量指标与业务指标脱节。用离线基准分数代替任务成功率，会出现分数上升而业务指标不变的情况；用平均分代替分位数，会掩盖某个子集的整体失效。质量指标必须可判定、可按业务切片。
> 5. 用吞吐改善推断延迟下降。批处理提高 tokens/s 但抬高 TPOT，路由降低成本但可能抬高 P95 尾部。任何优化都必须同时报告成本、P50、P95 与质量四项，缺一项就可能把成本转移而非消除。

## 关联笔记

- 前置 [[模型推理优化]]：TTFT 与 TPOT 的物理构成、KV 缓存字节数在该篇推导，本篇把它们换算成货币成本与 SLO。
- 前置 [[分布式训练与部署]]：单位卡时、部署形态与副本数决定固定成本，本篇在其上叠加按 token 计费的变动成本。
- 前置 [[模型评估矩阵]]：任务成功率、分桶评估与基准选择在该篇给出，本篇的质量约束直接引用其指标定义。
- 后续 [[Agent工作流与编排]]：多步流程的成本是单步成本的累加，且每步的重试概率相乘，权衡框架在该篇扩展到轨迹级别。
- 对照 [[Agent记忆与上下文]]：上下文裁剪既降低 token 数也改变质量，是本篇约束在记忆层的一个具体应用。

## 达标检测

- [ ] 写出单请求成本公式，并用输入 800、输出 300、$p_{\text{out}}=4p_{\text{in}}$ 计算相对成本。
- [ ] 计算 10 轮对话在每轮重发历史下的总输入 token，并与按单轮乘轮数的估算比较误差倍数。
- [ ] 用 M/M/1 公式算出 $\rho=0.8$、$0.9$、$0.95$ 三档的排队时间，并说明为何 P95 的恶化更快。
- [ ] 推导两档级联的 $C(\tau)$、$L(\tau)$、$Q(\tau)$，指出升级率每增加 1 个百分点时成本增量的表达式。
- [ ] 运行本篇代码，找出使质量不低于 0.95 且成本最低的 $\tau$，并解释为何 P95 约束 1.2 秒时无解。
- [ ] 给定 $p=0.5$、$\delta=0.02$，计算 A/B 实验每组所需样本量，并说明提前停止为何不可取。
- [ ] 说明语义缓存假阳性率 2% 对质量的影响，并给出两条降低该风险的工程措施。

## 参考来源

- Chip Huyen, *Designing Machine Learning Systems*, O'Reilly, 2022, 第 7、8 章 —— 对应第 9 节的成本核算与第 11 节的 SLO 设计。
- Kwon et al., "Efficient Memory Management for Large Language Model Serving with PagedAttention", 2023, arXiv:2309.06180 —— 对应第 3 节的批处理延迟与第 6 节的上下文容量约束。
- OpenAI API 定价文档（Pricing 页面） —— 对应第 1 节与第 9 节的输入、输出 token 计费口径，具体价格按页面为准。
- Anthropic API 定价文档（Pricing 页面） —— 对应第 2 节的重试成本与第 9 节的相对价格结构，具体价格按页面为准。
- 张奇等，《大规模语言模型：从理论到实践》，2023 —— 对应第 7 节的蒸馏与量化对推理成本的影响。
