Token Lab搜索

SDE → AI ENGINEERING

写给 SDE 的 AI 调用底层原理:从 HTTP 到 Token 生成

沿一次请求系统解释分词、prefill、decode、KV Cache、流式输出与工具执行,讲清故障边界、性能预算,并提供可运行的本地代码。

HTTP / SSETransformerKV CacheAI InfraAgents

来源与版本详情
本文目录

一次 AI 调用是分布式程序,而非远程大脑

以 SRE 助手为例:用户询问一次部署为何处于 Pending。应用读取 Kubernetes 快照、选择运行手册、把相关证据发给模型,最后展示诊断。如果需要修复,必须由独立执行器授权。本文沿这一请求,从应用代码一直追踪到生成文本。这是参考设计,不是对任何厂商内部基础设施的还原。

先修知识就是常见后端工程:HTTP 承载请求,TLS 保护传输,认证识别调用者,队列分离接入与执行,超时只是某个参与方的观察。再加三个机器学习概念:token 是词表 ID,权重是学习得到的参数,推理是利用参数计算条件输出分布。训练改变权重,普通推理不改变权重。

HTTP 成功状态既不证明事实正确,也不证明业务已完成。应把契约拆成三个独立结果:传输完成、模型响应完成、业务结果验收通过。没有证据的流畅诊断可能满足前两项却不满足第三项。语言理解与归纳可以交给模型,授权、精确算术、状态转换和不变量应由确定性代码负责。

在模型边界,运算是 pθ(y₁…yₙ | x),可分解为逐 token 条件概率之积。θ 表示固定权重,x 是实际组装的上下文,不是应用掌握的全部信息。答案来自这个分布的采样或解码决策,并非查询权威故障记录的数据库事务。要让“GPU 不足”有依据,必须给答案关联快照 ID、采集时间和确切的调度事件。

必须明确状态归属:应用持有身份、会话与任务状态,引擎持有临时序列/KV 状态,执行器持有持久化操作结果。模型服务重启可以丢失 KV,却不删除会话历史;操作后进程崩溃可以丢失响应,但已提交操作仍存在。因此恢复时应查询状态的权威持有方,而不是让模型回忆发生了什么。

从 SDK 到被接纳的请求

SDK 把消息和设置序列化,附加认证,通过 HTTPS 发送,再把响应事件转换成对象。它通常不会在笔记本上运行大模型。参考服务链路包含入口、认证与配额检查、模型路由、准入控制和引擎队列;具体顺序与实现因服务而异。服务商密钥应保留在后端,浏览器调用你自己的认证接口。

为每个逻辑诊断设置 request ID、截止时间、输出上限与模型配置;为每次网络尝试另设 attempt ID。有界并发信号量防止流量尖峰变成无限在途请求;无法在期限内完成的工作应在准入阶段拒绝。每分钟请求数与 token 数约束不同资源:少量长提示就可能先耗尽 token 配额。

服务端会话对象可能保存历史,但 Transformer 仍只处理本次推理组装出的上下文。不要假定遗漏的事实会被自动记住、上传过的文件会自动加入,或模型别名变化后行为保持不变。应用应保存权威会话记录与证据版本;API 暴露具体模型版本时也应记录。

连接池复用已建立连接,在适用情况下减少重复 DNS/TCP/TLS 建连开销。HTTP/2 可复用多条流,但不会消除服务端排队或模型配额。连接超时、响应空闲超时和整体操作期限应分别配置;耗时使用单调时钟,下游超时从剩余预算推导,不能每一跳都重置完整超时。

重试可能隐性相乘:SDK 最多尝试三次,外层 worker 也最多三次,一个逻辑请求就可能变成九次上游尝试。应指定单一重试责任方或协调两层,并把每次尝试纳入预算。20 秒期限已用掉 8 秒,退避加下次尝试最多剩 12 秒,而不是再给 20 秒。POST 的载荷相同并不天然意味着可以安全重试。 [12]

参考架构:推理与动作执行跨越不同边界,不允许模型绕过宿主直达执行器。
参考架构:推理与动作执行跨越不同边界,不允许模型绕过宿主直达执行器。
层次输入 → 输出故障责任
应用问题 + 证据 → 请求身份、隐私、预算
推理服务Token ID → 得分 → ID队列、显存、生成
传输事件字节 → 完整项分帧、部分输出、取消
执行器已授权动作 → 回执权限、幂等、审计

消息如何变成 token、embedding 与张量

聊天模板在消息内容周围加入角色分隔符与特殊 token;tokenizer 按模型特定词表和编码算法映射为整数 ID。token 不等于单词、字符或网络包。中文、代码、空白的切分不同;条件允许时应使用正确 tokenizer 对实际模板化输入计数。服务端附加指令与媒体处理可能让用量超出可见文本。 [1]

教学用 decoder 的输入 ID 形状为 [B,T],在 [V,d] 的 embedding 矩阵 E 中查表得到 [B,T,d] 的 X。B 为批大小,T 为序列长度,V 为词表大小,d 为隐藏宽度。查表并非搜索网页,每行是学习得到的向量。位置表示让网络区分顺序;推理随后对向量进行注意力、归一化、残差与前馈运算。

图片和音频通常不是靠把 Base64 字符当成普通文字阅读来理解。服务栈解码传输载荷,再使用模型特定的图像 patch、音频特征或 token 序列。Base64 在 JSON 开销之外把字节数扩大到约 4/3,但这不是视觉 token 的计费规则。媒体类型、尺寸、时长与载荷上限应独立于文字 token 预算校验。

看一个教学用 BPE:初始符号为 a,b,a,b,如果优先合并规则是 (a,b)→ab,序列变成 [ab,ab];另一个词表可能仍保留四个 ID。真实编码器使用训练出的合并优先级或其他算法,并有附加规则。因此 token 数字 ID 只有结合 tokenizer 词表与版本才有意义,不能像通用字符编码一样跨模型比较。

取 、、,embedding 输出含 64 个浮点元素; 时查表矩阵含 8000 个参数。词表查表只是选取行,不会为每次请求创建新 embedding 模型。聊天角色标记必须匹配训练模板:重复添加序列开始标记,或缺少 assistant 生成标记,都会改变模型输入,即使界面上文字看起来一样。Padding 也必须被 mask,不能让补齐位置变成证据。

Prefill:先读取提示,再开始生成

一个因果注意力头构造形状 [T,d_h] 的 Q、K、V。QKᵀ 为 [T,T],因果 mask 阻止读取未来位置。在分量独立的简化假设下,除以 √d_h 用于控制点积方差随维度增长。softmax 沿 key 位置计算,乘 V 后恢复为 [T,d_h]。多个头拼接再投影;现代架构可能使用分组 KV 头与不同归一化方式。 [2]

Prefill 在每层内并行计算已知的提示位置,mask 保持因果性;提示末尾位置产生第一个输出 token 的 logits。稠密全上下文 prefill 的注意力计算量随 T 二次增长,投影与 MLP 还有额外开销。高效 kernel 可以避免完整保存得分矩阵,但不等于消除了全部二次注意力计算。因此,即使答案很短,长提示也可能推迟首个输出。

故障案例中,选择相关时间段、调度事件及带引用的运行手册段落,通常比发送十万行日志更合理。检索并不会扩大模型实际上下文上限。要为输出和工具观察留空间:假设预算 16,000 token,指令 2,000、对话 4,000、输出预留 2,000,则证据可用 8,000。这些是合成算例,不是某个模型的规格。

最小数值头可以直接看懂机制:令 =,0],[0,1]],d_。位置 0 只能看自己,输出 [1,0];位置 1 的得分为 [0,1/√2],softmax 约为 [0.3302,0.6698],输出就是两个 value 向量按该权重的混合。注意力选择的是可见位置上的分布,不是在作出“某句话为真”的布尔判断。

稠密层中,Q/K/V 与输出投影约随 T d² 增长,两次注意力乘法约随 T² d 增长,前馈层还包含中间宽度相关项。因此“注意力是二次复杂度”不是完整延迟模型。矩阵分块在快速片上内存重用数据,减少昂贵的显存访问;kernel 融合减少中间张量写回。这些优化改变数据搬运与常数,实际速度取决于形状、精度、硬件和 batch。

Decode、采样与 KV Cache

Decode 反复计算下一个 token 的分布、选择 token 并追加。KV Cache 保留过去位置的 key/value 张量,新 token 只需计算自己的 Q/K/V,再读取历史 K/V,而非重新计算全部历史位置。缓存是数值执行状态,不是事实数据库,也不是应用的长期记忆;其有效性取决于模型、前缀、位置与相关配置。 [3]

常规全注意力缓存字节数约为 2 L B T H_kv d_h s:L 是层数,B 是等长活跃序列数,T 是缓存位置数,H_kv 是 KV 头数,s 是每元素字节数。取 、、、H_、d_、,得到 1 GiB。这里不含权重、激活、分配器开销与复制;变长序列应对各序列 T 求和,滑动窗口、压缩和特殊架构会改变公式。

Logits 是未归一化得分,temperature 在 softmax 前缩放得分,top-p 保留累计概率较高的候选集合再归一化。它们都不是“真实性旋钮”。,1,0]、 时,稳定 softmax 约为 [0.6652,0.2447,0.0900]。贪心选择最大项也不保证正确或跨硬件复现。停止 token、输出上限与工具调用结果都可能终止生成;被长度上限截断的 JSON 不是成功的结构化结果。

缓存 decode 的第 t 步,全注意力头有 q_t [1,d_h]、K_cache [t,d_h]、V_cache [t,d_h],得分形状为 [1,t]。追加 token 让缓存增长,不必重算旧 key;但新 query 仍要读取可见历史 K/V,因此单步注意力成本随可见上下文增长。缓存消除的是重复计算,不是全部历史依赖。 [13]

块表把序列位置映射到存储:假设每块 16 token,位置 35 在逻辑块 2、偏移 3。若块表为 [7,2,9],它位于物理块 9。这是地址映射算例,不是固定的 vLLM kernel 布局。物理张量可重排以支持向量化与合并读取。共享前缀块需要引用计数及后续写入保护;缓存键不能允许租户读取其他租户的私有提示状态。

GPU 调度:吞吐量与延迟为何冲突

引擎通过批处理摊薄权重读取成本并提高 GPU 利用率。连续批处理允许在迭代之间加入和移除序列,而非等待整个静态 batch 完成。长提示、长输出与不均匀到达的请求争夺计算和 KV 容量。总 tokens/s 提高可以与单用户延迟恶化同时发生。准入限制应考虑 token 和显存预算,而非只看 CPU 或请求数。

PagedAttention 把逻辑 KV 块映射到物理内存块,减少碎片并支持高效共享,但不会让显存无限。前缀缓存重用兼容的已计算提示状态,主要节省重复 prefill;它不是答案缓存,也不会消除新答案的 decode 工作。精确缓存键、淘汰、租户隔离与模型兼容仍是正确性要求。 [4] [5]

低 decode batch 时,读取权重与 KV 可能比算术更主导,因此显存带宽很重要;batch 增大后瓶颈可能转向计算。张量并行分摊工作但增加通信,prefill/decode 分离匹配不同资源特征但需要搬运 KV。量化减少表示体积,却涉及质量和 kernel 取舍。推测解码成组验证候选 token,收益取决于接受率与验证成本。没有明确工作负载,就不能承诺通用加速。

可用 roofline 思路估计下界:kernel 时间至少受 FLOPs/可达算力与搬运字节/可达带宽两项中较大者约束。合成例中,80 亿参数、每权重 2 字节共 16 GB;以 1 TB/s 读取一遍已经需要 16 ms,尚未加 KV、算术和通信。这是简化带宽下界,不是模型实测速度;重用、缓存、量化与分片会改变流量。

一次调度迭代分配 token 工作与 KV 容量、启动 kernel、收集采样 ID,再移除完成序列。大型 prefill 可能占据整个步骤并拖慢正在 decode 的请求;分块 prefill 将工作切小以改善交错,但也引入调度取舍。自动扩容时,队列等待、活跃/缓存 token 数、decode 延迟可能比单独的 GPU 利用率更有信息。扩容还需加载权重与预热执行路径,不会瞬时生效。

流式输出是字节之上的应用协议

流通过响应体传输事件,常使用 text/event-stream。TCP 读取、HTTP chunk、SSE 事件、JSON delta、模型 token 与界面字符是不同的边界。一次读取可能停在中文多字节字符中间,也可能包含多个事件。客户端应增量解码 UTF-8、缓存不完整行和事件,只解析完整载荷。浏览器原生 EventSource 不能直接替代任意带认证 JSON POST,通常应使用 fetch 流或服务商 SDK。 [6]

把生成当成状态机:等待 → 流式传输 → 完成、失败或取消。HTTP 200 后仍可能收到错误事件;如果缺少协议要求的完成标记,即使 socket 正常关闭,也可能只是未完成响应。部分文本必须保持“部分”状态,不能静默升级为成功。工具参数也可能是分段 JSON,必须等调用项完整、解析并授权后才能执行。各服务事件名和停止语义不同,下方实验使用明确标注的自定义协议。 [7]

反向代理缓存输出,会让正常工作的模型看起来没有流式响应。浏览器读取慢时,如果后端没有背压或有界缓冲,队列可能无限增长。支持时应把取消传播到上游,但客户端断开并不证明计费或 GPU 工作已停止。取消传播、最大缓冲字节数、空闲超时与总截止时间必须分别定义。

解析器有三层缓冲:未完成 UTF-8 码点、未完成行、一个事件的 data 字段。即使 CR 与 LF 分两次到达,CRLF 也只能算一次换行。空行分发 SSE 事件,多个 data 字段以换行连接,此后才交给 JSON 解码器。应用还需按 response/item ID 分别累积 delta,因为一条流可能包含文本与多个工具项。

传输层流控不会限制所有应用队列。如果输出先被复制进无界 Python list 再送给浏览器,TCP 背压可能来得太晚,无法保护内存。应限制排队字节与总响应大小,定义慢消费者策略,在支持时暂停读取或取消上游。教学解析器只限制单个事件;生产实现还需要总响应、生命周期上限及服务商特定的终止处理。

工具调用如何把推理变成 Agent 循环

对于客户端执行的工具,模型返回建议的名称与参数,宿主验证并执行,再把观察发回模型进行下一次推理。服务商托管工具的执行边界不同。模型说“我已重启服务”不构成重启证据;业务动作应关联执行回执、资源版本与审计记录。这里可借用 Anthropic 对 workflow/agent 的区分:步骤顺序可以由代码决定,也可由模型建议下一项工具。 [8]

在 SRE 案例中,read_snapshot 与 search_runbook 是带租户范围的白名单只读操作;restart_deployment 是独立能力,要求资源级授权,并按配置获得批准。运行手册内容是数据,不是授予权限的指令。结构化输出验证只能保证形状,不保证安全与真实性。未知工具及额外字段应被拒绝,不能为了方便回退为直接运行模型生成的 shell。

限制模型轮次、工具次数、耗时与费用。如果写操作超时,应先查询持久化操作状态再重试:丢失的响应可能掩盖已经完成的变更。应用级幂等需要请求指纹和冲突检测,不能只重复使用 UUID。HTTP 重试和服务商 request ID 都不能保证 Kubernetes 变更恰好执行一次。

使用显式操作生命周期:已提议、已校验、已授权、执行中、成功/失败/未知。重启授权应绑定主体、namespace、deployment、动作和资源版本。写入前重新检查相关状态,降低检查与使用之间的竞态。如果资源在诊断后改变,应重新决策,不能把旧批准直接套用到新对象。

在副作用前持久化操作意图,但不能称其与 Kubernetes 构成原子事务。外部变更完成与回执写入之间仍可能崩溃;恢复需要操作标识,以及查询外部资源或安全识别重复执行的方法。事务 outbox 解决本地数据库的可靠投递,本身不保证任意远端系统中的副作用恰好一次。

延迟、费用与故障责任如何拆分

分别测量首 token 时间 TTFT、输出 token 间隔、总完成时间和业务验收成功率。TTFT 包括连接开销、排队、prefill 与传输,不是纯 GPU 时间。假设输出 N 个 token、固定间隔 Δ,总耗时约为 TTFT+(N−1)Δ; 秒、、 秒时为 2.6 秒。流式输出改善感知响应,不一定减少总完成时间。

使用费用账本,而非按字符猜测。假设每百万输入/输出 token 分别为 2/8 美元,2,000 输入加 500 输出的单次请求为 0.008 美元,尚未计缓存、工具费和重试。这是算术示例,不是服务商报价;内部推理或媒体 token 可能采用不同核算方式。产品指标应是每个验收任务成本:总付费尝试成本除以验收任务数,纳入失败尝试及适用的人工审核成本。

429 应遵循服务文档的重试提示,采用有界指数退避和抖动,不可无限重试。schema 无效应修复请求;5xx 或断连仅在逻辑截止时间和预算内重试,并保留部分结果状态。记录服务商 request ID、attempt ID、模型、用量、时间、结束原因和脱敏工具回执,默认不要记录客户原始提示或密钥。TTFT 高应检查队列与 prefill;生成平稳却成批到达应检查缓冲;传输正常但事实错误需要评估证据与模型。

Little 定律可做稳定条件下的容量核对:平均在途请求 L=到达率 λ×平均停留时间 W。5 请求/秒、平均停留 4 秒,对应 20 个在途请求。这不是 p99 保证或安全最大值,波动与过载仍需余量。队列停留和处理时间要分开,测量边界必须一致,否则公式比较的是不同请求集合。

Trace 应为父任务 → 模型尝试 → 工具操作,而不是一个笼统的“AI latency”span。可观测时记录队列等待;不可观测时就标注客户端 TTFT,不能编造服务端分段耗时。p50/p95/p99 应在匹配输入长度、输出长度、模型与缓存状态的分组内比较。因为答案变短或拒绝任务变多导致平均延迟下降,并不自动代表基础设施改善。

合成延迟预算:首 token 0.6 秒,随后 100 个间隔 × 0.02 秒,总计 2.6 秒。面积不表示 GPU 利用率。
合成延迟预算:首 token 0.6 秒,随后 100 个间隔 × 0.02 秒,总计 2.6 秒。面积不表示 GPU 利用率。

这个模型能解释什么,不能解释什么

本文针对 API 背后的自回归 decoder 式文本生成。Embedding 接口返回向量,没有自回归文本循环;reranker 返回相关性分数;扩散模型与实时语音系统可能有不同执行和流式语义。接口外观兼容聊天,并不意味着 tokenizer、工具行为、缓存隔离或停止原因相同。必须验收实际部署的契约。

前沿问题是联合优化:公平调度混合 prefill/decode、搬运或压缩 KV 时不抵消收益、高效验证推测输出、降低精度时保持质量。应用层更困难的未解决问题包括长任务可靠性、证据新鲜度、提示注入韧性和模型变化下的可复现评测。token 单价降低不会解决授权,更长上下文也不会自动建立事实依据。

托管 API 将运维工作委托出去,但隐藏调度器、kernel 与缓存细节;自托管开放这些调节能力,同时把容量、补丁和安全责任交给团队。应根据数据约束、负载可预测性、运维能力和验收任务总成本选择,而非只比较 token 单价。保留小而明确的服务商适配层,统一事件时不能抹去拒绝、未完成和工具调用语义。

这篇教程最终要建立一套排障方法:谁持有能够回答问题的状态,哪个测量能区分竞争解释,哪些操作可以安全重复。缺少证据时保留不确定性。文末实践检查的是小而可证伪的不变量;没有真实负载 trace 与受控部署证据,不能据此宣称生产可靠性。

实践与验证

运行完整本地实验

保存 lab.py,使用 Python 3.11+ 执行 python3 lab.py,仅需标准库;输入全部确定,不涉及随机种子。这是协议与算术实验,不是神经网络,也不是完整生产级 SSE 库。程序按每种字节分片大小输入合成 UTF-8 响应,检查三种换行方式,并拒绝截断、格式错误及失败流。delta/done/error 是本站教学协议,不宣称兼容某家 API。

下载 Python 实验
"""Original teaching protocol, not a provider SDK. Python 3.11+, stdlib only.
No network, keys, GPU, or randomness. Feed arbitrary byte fragments.
Supports LF, CRLF and CR lines, UTF-8 BOM, comments and multiline data.
Does not implement EventSource reconnect, retry or Last-Event-ID semantics.
"""
import codecs
import json
import math

class Stream:
    def __init__(self, max_event=65536):
        self.decoder = codecs.getincrementaldecoder('utf-8-sig')('strict')
        self.line = ''
        self.data = []
        self.event = ''
        self.cr = False
        self.size = 0
        self.max_event = max_event
        self.text = ''
        self.state = 'waiting'

    def feed(self, chunk):
        self.consume(self.decoder.decode(chunk))

    def consume(self, text):
        for c in text:
            if c == '\n' and self.cr:
                self.cr = False
                continue
            self.cr = False
            if c in '\r\n':
                self.on_line(self.line)
                self.line = ''
                self.cr = c == '\r'
            else:
                self.line += c
                if len(self.line.encode('utf-8')) > self.max_event:
                    raise ValueError('line too large')

    def on_line(self, line):
        if not line:
            self.dispatch()
            self.data, self.event, self.size = [], '', 0
            return
        if line.startswith(':'):
            return
        field, _, value = line.partition(':')
        if value.startswith(' '):
            value = value[1:]
        if field == 'event':
            self.event = value
        elif field == 'data':
            self.size += len(value.encode('utf-8')) + 1
            if self.size > self.max_event:
                raise ValueError('event too large')
            self.data.append(value)

    def dispatch(self):
        if not self.data:
            return
        if self.state in {'completed', 'failed'}:
            raise ValueError('data after terminal state')
        payload = json.loads('\n'.join(self.data))
        if not isinstance(payload, dict):
            raise ValueError('payload must be object')
        if self.event == 'delta':
            if not isinstance(payload.get('text'), str):
                raise ValueError('delta.text must be string')
            self.text += payload['text']
            self.state = 'streaming'
        elif self.event == 'done':
            if payload.get('reason') != 'stop':
                raise ValueError('not an accepted completion')
            self.state = 'completed'
        elif self.event == 'error':
            self.state = 'failed'
        else:
            raise ValueError('unknown teaching event')

    def finish(self):
        self.consume(self.decoder.decode(b'', final=True))
        if self.line or self.data or self.event:
            raise ValueError('unfinished event')
        if self.state != 'completed':
            raise ValueError('no successful completion')
        return self.text


def softmax(logits):
    if not logits or not all(math.isfinite(x) for x in logits):
        raise ValueError('finite nonempty logits required')
    m = max(logits)
    values = [math.exp(x - m) for x in logits]
    return [v / sum(values) for v in values]


def decode(raw, width):
    s = Stream()
    for start in range(0, len(raw), width):
        s.feed(raw[start:start+width])
    return s.finish()


def must_fail(raw):
    try:
        decode(raw, 1)
    except (ValueError, UnicodeDecodeError):
        return
    raise AssertionError('invalid stream accepted')


if __name__ == '__main__':
    text = 'Pending:GPU 不足'
    wire = (': heartbeat\n\nevent: delta\ndata: ' +
            json.dumps({'text': text}, ensure_ascii=False) +
            '\n\nevent: done\ndata: {"reason":"stop"}\n\n')
    raw = wire.encode()
    for newline in ['\n', '\r\n', '\r']:
        variant = b'\xef\xbb\xbf' + wire.replace('\n', newline).encode()
        for width in range(1, len(variant)+1):
            assert decode(variant, width) == text
    must_fail(raw.split(b'event: done')[0])
    must_fail(raw[:-1])
    must_fail(b'event: error\ndata: {"error":"overloaded"}\n\n')
    must_fail(b'event: delta\ndata: {bad}\n\n')
    must_fail(b'event: delta\ndata: {"text":3}\n\n')
    must_fail(b'\xff')
    must_fail(raw + b'event: delta\ndata: {"text":"late"}\n\n')
    try:
        Stream(max_event=4).feed(b'data: oversized')
    except ValueError:
        pass
    else:
        raise AssertionError('size limit failed')
    p = softmax([2,1,0])
    assert abs(sum(p)-1) < 1e-12
    assert all(abs(a-b)<1e-12 for a,b in zip(p,softmax([1002,1001,1000])))
    kv = 2*32*1*8192*8*128*2
    assert kv == 1024**3
    cost = (2000*2+500*8)/1e6
    assert abs(cost-0.008) < 1e-12
    print(text)
    print('softmax:', ', '.join(f'{x:.4f}' for x in p))
    print(f'KV: {kv/1024**3:.1f} GiB; hypothetical cost: ${cost:.3f}')
    print('PASS: byte fragmentation, newline variants, truncation, errors, bounds and arithmetic')
python3 lab.py
# Pending:GPU 不足
# softmax: 0.6652, 0.2447, 0.0900
# KV: 1.0 GiB; hypothetical cost: $0.008
# PASS: byte fragmentation, newline variants, truncation, errors, bounds and arithmetic

公平对照应固定响应字节,只改变分片方式:把每次读取直接当 JSON 的简单解析器会在模型未变化时失败。另一个对照固定 logits 的相对差值,整体加常数,稳定 softmax 应保持不变。移除 done 事件后,部分文本不能变成成功。它们隔离验证协议和数值正确性,不评估事实答案或模型质量。

原创模拟面试与评分

1. 为什么 HTTP 200 后任务仍会失败?

提示:三种契约。传输接纳、流完成与业务验收不同。检测终止/错误事件,保留部分状态,再基于证据验证结果。

2. 上下文变长为何降低服务容量?

提示:KV 字节与 prefill。计算每个活跃请求缓存,预留权重和激活,再考虑队列与计算。T 翻倍使此简化 KV 估算翻倍,不代表总延迟必然翻倍。

3. 重启超时后能直接安全重试吗?

提示:副作用状态未知。查询执行器操作账本,比对指纹与资源版本。重放已记录结果,拒绝冲突复用;再次变更前先核对未知结果。

4. 前缀缓存会消除输出生成成本吗?

提示:区分三种缓存。KV 保存执行状态,前缀缓存重用兼容 prefill,答案缓存返回旧答案。只有最后一种命中时可避免生成,但必须核验租户、时效和请求兼容性。

每题 1–5 分:指出组件;准确定义契约;解释机制;处理反例和失败;设计可观测、公平且说明边界的验证。这些为原创练习,并非公司真实面试题。

参考资料与后续教程

  1. Chat templates — Hugging Face Transformers (main documentation, checked 2026-11-11)https://huggingface.co/docs/transformers/main/en/chat_templating
  2. Attention Is All You Need — Vaswani et al., first submitted 2017-06-12; arXiv v7 2023-08-02https://arxiv.org/abs/1706.03762v7
  3. KV cache strategies — Hugging Face Transformers (main documentation)https://huggingface.co/docs/transformers/main/en/kv_cache
  4. PagedAttention — Kwon et al., arXiv v1 2023-09-12https://arxiv.org/abs/2309.06180v1
  5. Automatic prefix caching — vLLM documentationhttps://docs.vllm.ai/en/latest/features/automatic_prefix_caching/
  6. Server-sent events — WHATWG HTML standardhttps://html.spec.whatwg.org/multipage/server-sent-events.html
  7. Streaming messages — Claude Platform documentationhttps://platform.claude.com/docs/en/build-with-claude/streaming
  8. Building effective agents — Anthropic, 2024-12-19https://www.anthropic.com/research/building-effective-agents
  9. Attention Is All You Need — PDF v7https://arxiv.org/pdf/1706.03762v7
  10. PagedAttention — PDF v1https://arxiv.org/pdf/2309.06180v1
  11. vLLM — source codehttps://github.com/vllm-project/vllm
  12. HTTP Semantics — RFC 9110, June 2022https://www.rfc-editor.org/rfc/rfc9110.html
  13. Caching — Hugging Face Transformers (main documentation)https://huggingface.co/docs/transformers/main/en/cache_explanation
学习指南与本课目录学习目标与验收

理解 → 实现 → 研究

目标:解释本课机制、复现一个例子、测试一个失败案例。读完不自动代表掌握。

预测、检验与证据记录

展开答案前先预测一个结果;练习后记录差异和迁移测试。记录仅存本地,在不同语言版本间共用。

打开记录/导出/清除 →

数学复核范围逐篇记录,不代表完成论文实证复现;可在笔记中记录疑似错误。 复核范围