Token Lab搜索

AI INFRA / KUBERNETES

Kubernetes 上的完整 AI 流程:从原始语料到 API 生成 token

系统构建数据、训练、检查点、发布与推理流程。含已运行 CPU 实验、可选 GPT-2 训练、Kubernetes 配置及 GPU 部署边界。

来源与版本详情
本文目录

架构与职责边界

原创参考设计,非厂商内部架构。蓝色为离线制品,橙色为私有请求路径,虚线为拒绝与恢复。网关在进入队列前执行身份与预算检查;发布制品通过校验加载进入引擎,不经用户请求。CPU 下载实验通过私有端口转发代替外部网关。
原创参考设计,非厂商内部架构。蓝色为离线制品,橙色为私有请求路径,虚线为拒绝与恢复。网关在进入队列前执行身份与预算检查;发布制品通过校验加载进入引擎,不经用户请求。CPU 下载实验通过私有端口转发代替外部网关。 查看原尺寸架构图
阶段输入 → 输出负责人和失败边界
摄取源记录 → 不可变原始快照数据负责人:拒绝无授权或格式错误记录;隔离并记录,不静默丢弃。
预处理快照 → 划分清单 + 分词器数据工程:模式、近重复簇与泄漏边界;重试保持相同划分。
训练版本数据 + 配置 → 检查点训练负责人:所有 rank 一起恢复;不选择未完成检查点。
发布候选 + 证据 → 不可变批准版本模型负责人:拒绝候选不覆盖在线版本;记录门禁版本。
服务批准权重/分词器 → 就绪副本平台:先校验摘要再加载、预热;失败副本不接流量。
请求授权提示词 + token 预算 → 流式输出网关/引擎:限制队列与 deadline,传播取消;不透明重放已观察输出。

从服务契约开始,而不是堆工具

我们要构建一个私有文本补全服务,其模型来自有版本的语料。离线路径把授权源记录变成数据集、分词器、训练运行、检查点和批准版本;在线路径认证调用者、检查请求预算、分词、调度计算并返回生成 token。Kubernetes 负责调度进程,不自动保证数据质量、模型质量或权限安全,每项都需要明确负责人和制品。

下载包用一个很小、真正经过学习的 bigram 模型跑通生命周期:本地训练、精确续训、发布校验、HTTP 和流式返回均已运行。另提供两层 GPT-2 训练实现与 vLLM 参考,展示如何迁移到 Transformer,但未在这里执行。当前环境没有 Docker、集群或 GPU。文章区分可搭建的 CPU 实验与生产 GPU 平台额外需要的工作;小模型都不是实用助手。

跟随一条记录:文档 d17 进入原始快照 R1,清洗版本 C2 生成数据集 D3,分词器 T1 将文字转成整数,训练 J4 生成检查点 K400 和导出 M1。发布 R7 绑定 M1、T1、服务镜像摘要和生成限制。请求 q9 只在开始时把公开模型别名解析为 R7,并记录该身份。控制面改变期望版本与策略,数据面搬运字节并计算。注册库保存引用和证据,不是运行中的 GPU 进程;Service 路由到副本,不是路由到训练检查点。别名更新不等于部署已完成。

先修知识要能解释故障

容器镜像打包代码与用户态库,不包含一个自动兼容的宿主 GPU 驱动。Pod 是调度与重启单元,Job 跟踪任务完成,Deployment 维持服务副本,Service 选择后端,PVC 请求持久存储,其访问模式与拓扑会影响调度。理解这些差别才能判断“重启”是不是“恢复”:没有数据游标或优化器状态,重启可能重复读数据或丢失学习进度。

模型侧需要理解:token 是特定分词器下的整数,logits 是未归一化的下一 token 分数,softmax 将其转成概率,交叉熵是训练损失。优化器更新权重,推理使用固定权重。可续训检查点包含的状态多于推理导出。存储一致性、HTTP 超时、TLS、身份和指标同样关键,因为它们决定正确模型是否服务正确调用者。

kubectl 提交 Job 后,API server 认证调用者并检查授权,准入控制检查对象,再持久化已接受的期望状态。控制器创建 Pod;调度器根据资源请求、约束与卷拓扑选择可行节点。kubelet 让容器运行时启动镜像并汇报状态;设备插件公布 GPU 资源,CSI 驱动创建和挂载卷。这些组件都不替容器执行优化器。Pod 已 Running 时模型可能仍在加载,就绪探针才是普通 Service 端点可用性的独立信号。startup probe 避免初始化期间被存活探针过早重启;readiness 失败通常取消接流量资格,本身不触发容器重启。

摄取:先有不可变记录,再有训练窗口

每份来源要有 ID、权限或许可、获取时间、内容哈希和保留规则。保存不可变原始快照,再记录清洗变换及代码版本。表格、代码与文档边界应有意识地解析,随意删除空白也可能改变含义。精确去重与近似去重要分开处理;先按来源、用户或时间划分,再生成重叠窗口,否则验证集会泄漏近乎相同的段落。哈希划分可重复,却不保证相关文档一定在同一侧。

实验包接受原创 CC0 合成 JSONL,归一化空白、精确去重并按内容哈希划分,清单保存源数据与处理后数据哈希。生产还需要隐私与同意管理、恶意文档隔离、语言来源平衡,以及传播到派生分片的删除标记。版本工具与对象存储目录负责血缘,不决定训练是否合法。删除数据可能需要停用数据集并重新训练;删除一个对象不会让权重自动遗忘。

生产摄取 worker 应在不可变对象及清单条目按明确协议持久提交后,才确认来源 offset。重试可以重复写同一个内容寻址对象;变换代码版本变化则必须产生不同派生身份。内容哈希只检测字节相等,不证明语义相似、同意或质量。相关文档必须同侧时,应先聚近重复簇再按簇划分。教学示例规定 hash 模 5 为零进验证集,其期望比例是 20%,有限语料不保证恰好 20%。100 GB 原始快照加 60 GB 派生数据,存储至少 160 GB,尚未计副本、检查点和旧版本。流式分片限制 worker 内存,但压缩、分片大小与访问顺序共同决定 CPU 开销及读放大。

分词器、打包与训练契约

模型发布必须包含精确词表、归一化规则、特殊 token ID,以及聊天模型的消息模板。训练与服务使用不同分词器,可能悄悄改变全部输入 ID。Transformer 路径只用训练集学习字节级 BPE,每条记录以 EOS 结束,填充位置不计入损失。把多条记录打包到一个序列能提高利用率,但必须明确注意力是否允许跨记录边界。

批量 B、长度 T 时,输入 ID 和标签形状为 B×T,logits 为 B×T×V。因果语言建模预测的是下一个 token,不是当前 token。提供的 Hugging Face 模型内部移动标签,所以标签最初与输入 ID 相同,填充处设为 −100,数据加载器不能再移一次。验证也必须使用同一分词与掩码契约,按有效 token 加权统计损失,不要对不同长度批次简单平均。

算例:假设教学分词器将“AI helps”编码为 [17,42],EOS 为 1。输入 [17,42,1] 产生两个监督转移:17→42,以及 [17,42]→1。这些 ID 是讲解用的假设值,不是下载包真实词表。批量 4、长度 128、词表 512 时 logits 含 262,144 个标量,FP32 占 1 MiB,未计梯度。embedding 查表将整数变成 B×T×d 向量,位置信息表达顺序。两文档打包到一行时,必须明确第二篇能否关注第一篇:EOS 是学习到的边界 token,不是自动的注意力防火墙。损失中屏蔽 padding 和注意力中屏蔽 padding 也是不同操作。

训练到底计算什么

前向传播嵌入 token、执行因果层并输出 logits;损失惩罚目标下一 token 概率过低;反向传播计算导数;AdamW 维护一阶和二阶移动矩并更新权重。梯度累积把有效批量分散到多个微批次,但损失缩放必须一致。例如微批量2×累积8×数据并行4=每次更新64条序列,长度不同时不代表 token 数相同。

实测基线是一张 V×V 可学习 logit 表,只有上一个字符影响下一个字符;它是真正经过优化的自回归模型,但没有注意力与长上下文。可选 GPT-2 有2个因果层、4个头、宽度128,展示模型与分词器制品流程,不代表高质量语言能力。大规模系统还应区分预训练、监督微调、偏好优化与 RL rollout:数据、奖励、参考模型状态和资源模式不同,rollout 服务不是优化器 Job。

损失式中 b 是序列索引,t 是下一 token 预测位置,m 对有效目标取 1、padding 取 0,N_valid 是 m 的总和。有效批量式中 B_micro 是每副本序列数,A 是累积步数,D 是数据并行副本数。只有有效 token 数相同时,等权平均微批次损失才等于逐 token 平均。

一个因果注意力头从形状 T×d_model 的 X 计算 _Q、_K、_V。QKᵀ 为 T×T;在逐行 softmax 前,把未来位置分数设成负无穷,再乘 V 得到 T×d_h。输出投影与残差维持模型宽度;前馈块逐位置变换,而注意力在位置间混合信息。反向传播对这些运算逐层应用链式法则。,0]、目标类别为1时,概率=[0.5,0.5],损失 ,logit梯度=[0.5,−0.5]。学习率0.1的SGD将可学习logits更新为[−0.05,0.05],目标损失降至约0.6444。AdamW则保存梯度一阶、二阶矩并校正初始偏差,另做解耦权重衰减;只恢复权重会改变下一次更新。

公式中 M 为因果遮罩(允许位置0,其余−∞),d_h 为头宽度,z_j 为第j个logit,y为目标ID。AdamW中g_t为梯度、β₁/β₂为矩系数、η为学习率、λ_w为权重衰减系数、ε为数值稳定项;平方和矩均按元素计算。该式描述带偏差校正、不含AMSGrad的常见AdamW,具体实现和有限精度会影响数值。

扩展训练:并行算法不等于调度

数据并行复制模型并同步梯度;张量并行拆层内运算;流水线并行拆层;状态分片拆参数、梯度或优化器状态,解决的问题不同。一种常见混合精度 Adam 实现把权重、梯度、主副本和两个矩合计约为每参数16字节,另有激活、缓冲与碎片。因此7B算例在激活之前就约112GB,并非 BF16 推理权重的14GB;这是预算示例,不是所有框架的固定分配。

多节点运行需要各 rank 一致的 world size、集合通信顺序与 rendezvous。GPU 拓扑和互联决定同步是否成为瓶颈。Kueue 一类准入系统管理配额与队列,gang 调度减少只占到一半 worker 后一直等待的情况,但都不改变梯度算法。rank 失败会卡住集合通信,应明确超时、协同终止和从完整检查点恢复。给 Deployment 增副本不会自动得到分布式训练器。

本地批量相同时,D个副本各算梯度g_r;all-reduce求和后除D,得到合并批次的梯度。有效token数不同时不能等权平均副本,要按全局有效token数归一化。理想ring all-reduce对G字节梯度每rank约传2(D−1)G/D字节,忽略时延和计算重叠。、时每rank传12GB;有效带宽25GB/s时仅带宽下界就0.48秒。张量并行更频繁通信层内中间结果,宜用高速本地互联。ZeRO各阶段逐渐分片优化器状态、梯度、参数,用通信换复制内存。流水线并行还会产生空泡,更多stage不保证更快。

ring估算统一使用十进制字节:G为每副本梯度字节数,D为rank数,B_net为有效字节/秒。这是下界模型,不是端到端耗时预测。

Kubernetes 资源要匹配两条生命周期

有界的数据准备与训练使用 Job,持续推理使用 Deployment,内部稳定名称用 Service。CPU 准备、GPU 训练和低延迟推理应有不同资源池与优先级。除了 GPU,还要请求 CPU 和 RAM;缺少解析 CPU 或网络带宽会浪费加速器。驱动、容器运行时集成与设备插件让 GPU 成为可分配资源,调度器不能像普通内存想象那样超卖一个扩展资源限制来凭空得到显存。

CPU 实验使用一个命名空间、一个动态 RWO 卷、一个训练 Job 和一个服务 Deployment。服务只读挂载并检查制品哈希,防止部分或被篡改的版本就绪。这里有意使用 Recreate,因为共享卷小实验不是零停机架构。生产应从对象存储把不可变批准制品暂存到各 Pod 独立缓存,完整加载后才就绪;同时考虑拓扑,一个可用区的卷不能自动跟随任意 GPU 去另一可用区。

配置为训练请求1个CPU,调度器按该保留量放置;2CPU limit通过运行时/cgroup限制运行消耗。内存request用于放置,超过memory limit可能导致OOM kill。GPU扩展资源计设备数,不计剩余显存字节。Pod Pending要区分设备不足、node affinity不匹配和卷未绑定/拓扑不兼容。容器已启动却CUDA失败,应查驱动、运行时和设备权限,不只查调度器。RWO表示可在单节点读写挂载,不等于只能有一个Pod,也不是跨节点共享文件系统。实验用小卷上的单写者和读者,不是分布式数据服务。

检查点、候选模型与发布版本是不同对象

可续训检查点包括权重、优化器与调度器状态、步数、随机数生成器、数据版本和采样位置,只保存权重会从不同优化状态重新开始。先写暂存位置,等必要分片与元数据齐全并校验后,再发布完成标记。对象存储不能把多对象写入变成原子事务;读取者只选择已完成清单,失败上传留下待清理垃圾,不应成为半有效检查点。

推理导出移除训练专用状态,但保留架构、分词器、adapter、精度、权重、校验值与许可血缘。模型注册库是不可变制品及其批准证据的目录,起步时不一定需要另买商业服务。发布版本指向特定候选、服务镜像与配置,每个环境使用独立指针。回滚应选择上一套兼容组合,而不是只改模型名,留下不兼容分词器或量化内核。

对象存储检查点写者先写唯一名称的分片,再计算哈希,再写列出全部分片及大小/哈希的清单。确认完整后,才用条件写或等效并发控制更新“最新完整版本”小指针。读者取一份清单并验证全部引用,不通过列出碰巧存在的文件猜发布版本。清单前崩溃留下待回收垃圾,而非批准检查点。本地实验用临时文件加rename,避免暴露写了一半的文件;断电持久性还取决于文件系统和目录同步语义。导出与准入分离:文件有效,模型仍可能很差。回滚将路由指向旧的完整组合,无法撤回已经发送的token。

从模型文件到首 token 与后续 token

启动时获取批准制品、校验哈希、加载兼容权重、分配缓冲区、初始化内核,并用代表性形状预热后才就绪。prefill 处理提示 token 并生成缓存的 key/value;decode 自回归追加 token,复用缓存。连续批处理在旧序列结束时接纳新序列,提高利用率,也增加公平与取消管理的复杂度。即便内核很快,分词、排队与网络缓冲仍会影响首 token 延迟。

普通注意力可用2×层数×KV头数×头维度×每数值字节×驻留token数估算 KV。合成算例:32层、8个KV头、128头维度、BF16,每token为131,072字节,8,192个驻留token为1GiB,尚未含元数据和分配开销。GQA 改变KV头数,不一定改变查询头数。权重放得下,长提示仍可能挤爆缓存;权重量化与KV量化也有不同质量与内核要求。

内存式中 L 为层数,H_KV 为每层 KV 头数,d_h 为头宽度,b 为每缓存标量的字节数,T_i 为序列 i 的驻留 token 数。因子 2 对应 key 和 value。该普通注意力估算不包含分配开销,不能直接套到潜在注意力或压缩缓存架构。

长度T的提示先prefill,计算表示并保存各层K、V。decode新增一个query,关注缓存keys,避免重算旧K/V,但仍要读取不断增长的缓存。普通密集注意力的提示交互工作量约随T平方增长,单步decode随上下文线性增长,尚未计投影和前馈。分页KV将逻辑token块映射到物理块,不必一次连续分配最大长度。块大小16、两个序列长度17与31时,占64个token槽,其中16个空闲;若每条预留128,则占256槽。这只是分配算术,不是吞吐实测。共享前缀复用要求模型、分词器、位置和相关执行设置一致;引用计数必须防止释放仍被其他请求使用的块。

分配式中P为每物理块token数、T_i为序列长度,向上取整把每条序列扩到整块。算例不包含跨序列前缀共享和块元数据。

分页 KV:逻辑长度与物理容量. 4 块 × 16 = 64 槽;已用 48,未用 16. 分配与生命周期示意,不是性能实测。
分页 KV:逻辑长度与物理容量. 4 块 × 16 = 64 槽;已用 48,未用 16. 分配与生命周期示意,不是性能实测。 查看原尺寸架构图

API 路径是受控状态机

生产路径是客户端→TLS网关→身份与租户策略→配额准入→模型路由→私有推理服务→流式响应。占用GPU之前检查请求体大小、模型权限、匹配分词器的输入长度和输出预留token。request ID连接网关与引擎事件,模型别名在一次请求内解析到不可变发布版本,不能在已有流中途更换权重。

流式返回是增量事件,不是连接结束才得到的一个JSON。关闭不必要的代理缓冲,并匹配空闲超时。字节已经送达后,透明重试可能重复文本或重复计费;只在未披露前按明确规则重试,或定义可恢复协议。断连与取消必须传给引擎,释放KV及准入槽位。生成文字里的工具调用只是提议,不等于付款或修改操作的执行许可。

网关应验证凭据,不能信任调用者自填tenant字段。将凭据主体映射到允许模型和租户预算,用所选模型的分词器计数,要求输入token加预留输出token不超过上下文窗口。预留保护稀缺服务容量,结束后按实际生成量结算。SSE每个事件以空行结束,一个事件可能跨多次TCP读取,所以客户端必须缓冲到完整事件。HTTP成功响应头之后生成仍可能失败,应同时记录传输状态与生成终止原因。停止条件包含EOS、输出上限、deadline、取消。temperature在采样前缩放logits;低温使分布更尖锐,不证明事实正确。

请求生命周期:分配、输出与取消. 容量只释放一次. 分配与生命周期示意,不是性能实测。
请求生命周期:分配、输出与取消. 容量只释放一次. 分配与生命周期示意,不是性能实测。 查看原尺寸架构图

容量、自动扩缩容与发布成本

按工作负载扩容,不能只盯GPU利用率。记录队列长度与年龄、运行序列、输入输出token、缓存占用、首token与token间延迟。饱和GPU可能是健康离线批任务,也可能是过载交互服务。稳态 Little 定律把在途请求数联系到到达率×平均停留时间,但不能预测接近饱和时的尾延迟。每秒10请求、各停留2秒,平均20在途;实际显存仍取决于上下文与输出上限。

冷启动包括调度、拉镜像、下载制品、加载与预热,HPA不能消除这些延迟,需要预留余量、预热热门模型并限制排队。新版本先小流量canary,保持可比较的输入输出分布再扩大。PDB约束自愿驱逐,不防所有GPU故障;优雅排空应停止准入并让有界流完成。单GPU Recreate实验没有零停机备用容量,核算每个成功请求成本要包含闲置、失败与发布冗余。

把首token时间拆为接入、认证/分词、排队、prefill和首token传输。合成预算20+10+80+150+10毫秒合计270毫秒。prefill省30毫秒,解决不了过载后增加数秒的队列。token间延迟描述首token之后的间隔;批处理可能提高总体吞吐,却让某位用户等更久。教学M/M/1队列到达率λ、服务率μ时,平均停留1/(μ−λ);λ、μ为0.5秒,λ则2秒。真实token服务不满足指数单服务台假设,此例只解释余量减少为何放大延迟。扩容要估队列工作量和启动时间,不能把长短请求当等量计数。

安全与可观测性贯穿每个阶段

分开摄取身份、训练身份、注册库发布权和服务身份。服务Pod只应读取批准制品,不能改训练数据或自行提升权重。使用工作负载身份与短期凭证,避免镜像或日志含秘密,限制出网并审计发布变更。NetworkPolicy只有在CNI执行时限制可达性,不认证API用户;不调用Kubernetes API的Pod也无需挂服务账号token。

元数据串起数据哈希、run ID、检查点、模型版本、服务镜像与request ID。观测数据拒绝、训练吞吐与损失、检查点时长、GPU错误、排队、token时序、取消和拒绝。不能把任意prompt或request ID当指标标签,避免高基数与隐私风险;细节trace进入受控、采样和有保留期的存储。缺少遥测不等于没有故障,可用性SLO也不同于正确性与安全评估。

权限和数据要分别追踪:训练身份只能读D3、写自己的run前缀;发布控制器才可批准候选;服务身份只能读已批准组合。namespace标签不是租户认证。NetworkPolicy限制连接,IAM策略授权对象操作;外部存储通常两者都需要。可观测性沿同一链路记录queue、prefill、decode span,准入/拒绝counter,延迟histogram,驻留容量gauge。trace ID放采样trace或exemplar,不放无界指标标签。每次完成响应记录模型版本,才能归因延迟或质量回归。缺span可能是采样、遥测丢失、工作未完成,不能据此证明操作从未发生。

按控制点与未解决约束选技术栈

托管云提供节点、存储与身份集成,平台团队仍拥有数据契约和模型验收责任。NVIDIA GPU软件靠近设备供给与执行,PyTorch靠近训练,Kubernetes靠近工作负载调谐,vLLM靠近服务与KV调度。MLflow类注册库记录实验与版本,对象存储保存字节,网关管理外部身份和准入;这些层有重叠却不能互换。不要买了几个仪表盘,却没有明确发布权和回滚负责人。

前沿方案拆分prefill/decode、跨机器传KV、按前缀局部性路由并卸载缓存,可能改善资源匹配,也增加网络、一致性与取消路径。多租户adapter服务增加版本隔离,量化增加校准与内核约束,推测解码增加草稿计算与接受算法,没有免费的吞吐。先建立守住不变量的单机服务,测出瓶颈再逐个改变边界。持续难题包括性能可移植性、公平调度、可审计数据删除、长上下文质量与大集群高效恢复。

按“把哪种资源开销搬到哪里”选优化。量化降低权重存储或运算精度,但依赖校准和内核支持,不一定缩小未量化KV。前缀缓存只对兼容的相同前缀节省prefill,不是语义相近文本都能复用。prefill/decode分离把计算放到不同池,却引入KV传输:1GiB缓存通过有效10GiB/s链路,协议及争用前下界就是0.1秒。推测解码先提出多个草稿token再由目标模型验证,收益取决于接受率和验证成本,不能只看草稿速度。每项技术都增加状态负责人或兼容约束。设计评审要说出原瓶颈、转移工作、新失败路径,以及简单方案更好的条件。

实践与验证

下载完整源码包

1. 运行完整 CPU 生命周期

使用 Python 3.11 与独立环境,解压后进入目录。包内是 100 条原创 CC0 合成记录,用于验证流水线,不是实用语言语料。预处理先规范化、去重,再按稳定哈希划分训练/验证集,之后才生成 token 对。种子为 42。训练用 SGD 最小化下一字符交叉熵,不包含 Attention。发布门禁检查制品哈希及此数据的验证 NLL 小于 4,不代表安全或实际质量。

python3.11 -m venv .venv
. .venv/bin/activate
pip install -r requirements.txt
python pipeline.py prepare --source corpus.jsonl --root ./run
python pipeline.py train --root ./run --steps 400
python pipeline.py promote --root ./run
python serve.py --root ./run --port 8000
# In another terminal
curl -s http://127.0.0.1:8000/health
curl -s http://127.0.0.1:8000/v1/completions -H 'Content-Type: application/json' \
  -d '{"prompt":"A model","max_tokens":16}'
curl -N http://127.0.0.1:8000/v1/completions -H 'Content-Type: application/json' \
  -d '{"prompt":"A model","max_tokens":16,"stream":true}'

2. 构建并调度 CPU 版本

前提:Docker、连接自己集群的 kubectl、支持 fsGroup 的默认 StorageClass、能执行 NetworkPolicy 的 CNI。kind 可加载本地镜像;其他集群需推送仓库并修改两处 image。命名空间 restricted,容器 UID 10001,不挂载 API token,Service 私有。单 RWO 卷和 Recreate 策略为简单性牺牲可用性。初次发布尚未生成时服务重启属预期;生产环境应审批完成后再部署。不要将此未认证实验暴露到公网。

docker build -t tokenlab-ai:local .
# For kind only; otherwise push image to your registry and edit YAML
kind load docker-image tokenlab-ai:local
kubectl apply -f kubernetes.yaml
kubectl -n tokenlab-ai wait --for=condition=complete job/train-v1 --timeout=600s
kubectl -n tokenlab-ai rollout status deployment/model-v1 --timeout=300s
kubectl -n tokenlab-ai port-forward service/model-api 8000:8000
# Then run the curl commands above; Ctrl-C stops the local tunnel.

3. 替换为真正的 Transformer 训练

可选路径只用训练集训练 byte-BPE 分词器,并从随机初始化训练两层 GPT-2:4 头、隐藏宽度 128、上下文 128、AdamW 学习率 3e-4。padding 标签为 -100,GPT-2 内部移位标签,不要重复移位。保存优化器与 RNG 状态,导出 safetensors、分词器和配置;计算按 token 加权的验证 NLL 后才创建 approved/。固定门禁只是合成验收示例,拒绝覆盖已批准版本。这套依赖与执行路径未在此运行,请使用下方完整脚本。

# Separate environment recommended; optional path not executed here
pip install -r requirements-transformer.txt
python transformer.py --root ./run --steps 200
python transformer.py --root ./run --steps 400 --resume
python approve_transformer.py --root ./run --max-nll 4.0
# Optional training Job (existing namespace/PVC required)
docker build -f Dockerfile.transformer -t tokenlab-transformer:lab .
kind load docker-image tokenlab-transformer:lab
kubectl -n tokenlab-ai scale deployment model-v1 --replicas=0
kubectl apply -f transformer-job.yaml
kubectl -n tokenlab-ai wait --for=condition=complete job/transformer-train --timeout=7200s

4. GPU 推理:需要单独验证的集成

可选训练 Job 使用同一个 artifacts PVC,先停止 CPU Deployment,避免跨节点 RWO 挂载冲突。vLLM 参考挂载已批准导出并创建私有 Service;vLLM 0.14.0 文档列出 GPT2LMHeadModel,但本次导出尚未做兼容性实测。应用前需将镜像 UID、可写缓存及安全上下文适配 restricted 策略,不能降低命名空间策略。配置兼容 NVIDIA 驱动、device plugin、GPU 与可挂载存储。README 列出剩余验证项,这不是即用的生产 GPU 发行包。

实测结果、失败用例与公平对照

本 CPU 数据上初始训练 NLL 为 3.73767 nat/token,400 步后为 1.70074,验证 NLL 为 1.70306。这是 bigram 损失,不是 Transformer benchmark。验证脚本逐字节比较连续训练与 200+200 步续训,检查 HTTP、SSE 结束,拒绝非法 token 预算并检测制品篡改。请在自己的机器复现,不要用这些数字比较厂商。

python verify.py
python mechanism_math.py
# PASS: loss descent, exact resume, artifact integrity, HTTP generation, SSE, invalid input

集群验收应覆盖:检查点后终止训练、篡改候选但不改变当前版本、未知字符、并发耗尽、SSE 客户端断开、新副本不就绪。在所选部署策略允许时验证旧服务连续性。公平对照固定数据、分词器、精度、输入/输出长度、到达流量与硬件,同时报告排队、TTFT、token 间延迟、失败、成本与质量。更快的失败不是提升。单副本教学部署无法证明零停机切换。

原创模拟面试题 · 非公司真实面试题

1. 为什么恢复权重后续训仍会偏离?

提示 1

考虑 Adam 状态和下一个 batch。

提示 2

RNG、优化器动量、调度器、数据游标与并行拓扑影响下一步。

答案与分析

推理导出不等于可续训检查点。恢复数据指纹、优化器与 RNG,明确要求逐位一致还是统计等价。跨硬件 GPU 不保证逐位相等。以固定连续运行对照中断运行,成功加载并不证明相同。

评分:1 分说出组件;2 分解释状态;3 分追踪故障;4 分给出正确恢复及边界;5 分设计公平反例并论证取舍。

2. 14 GB 模型为什么会在 24 GB GPU 上失败?

提示 1

权重只是内存的一部分。

提示 2

还要计算 KV cache、激活工作区、运行时预留和碎片。

答案与分析

32 层、8 个 KV 头、头维 128、BF16 时每 token KV 为 128 KiB。8 条 8192-token 序列仅 KV 就需 8 GiB,再加 14 十进制 GB 权重,标称 24 GB 显卡安全余量很小。限制准入 token 预算并测峰值。权重量化不自动意味着 KV 量化。

评分:1 分说出组件;2 分解释状态;3 分追踪故障;4 分给出正确恢复及边界;5 分设计公平反例并论证取舍。

3. 网关发出第一个 token 后应该重试吗?

提示 1

客户端是否已经观察到输出?

提示 2

重新生成可能重复或改变文本及计费。

答案与分析

不要透明重放已被观察的流。标为中断,由客户端明确发新请求;除非设计了能重放同一缓冲事件序列的续传协议。输出前也只能在总 deadline 内有限重试符合条件的失败。断开时取消引擎工作、释放 KV。请求 ID 关联证据,不自动赋予生成幂等性。

评分:1 分说出组件;2 分解释状态;3 分追踪故障;4 分给出正确恢复及边界;5 分设计公平反例并论证取舍。

完整实现文件(共享英文代码注释)

mechanism_math.py

mechanism_math.py

"""Deterministic checks for the article's synthetic arithmetic. Standard library only.
No cluster, model benchmark, GPU, network or stochastic experiment.
"""
import math
p0=0.5
loss0=-math.log(p0)
loss1=math.log(math.exp(-0.05)+math.exp(0.05))-0.05
assert abs(loss0-0.69314718056)<1e-10
assert abs(loss1-0.64439666007)<1e-10 and loss1<loss0
# First AdamW moment correction with a scalar gradient.
g=0.5;beta1=0.9;beta2=0.999
m=(1-beta1)*g;v=(1-beta2)*g*g
assert math.isclose(m/(1-beta1),g)
assert math.isclose(v/(1-beta2),g*g)
assert 4*128*512*4==1024**2
assert 2*(4-1)*8/4/25==0.48
slots=16*sum(math.ceil(t/16) for t in [17,31])
assert slots==64 and slots-17-31==16
assert 2*32*8*128*2*8192==1024**3
assert sum([20,10,80,150,10])==270
assert 1/(10-8)==0.5 and 1/(10-9.5)==2
print('PASS: gradient step, AdamW bias correction, logits bytes, ring budget, KV blocks, TTFT and queue arithmetic')
pipeline.py

pipeline.py

"""Transparent language-model lifecycle. Python 3.11 + numpy 2.3.5.
The model is a learned bigram softmax, not a Transformer or general assistant.
"""
import argparse, hashlib, json, os, tempfile
from pathlib import Path
import numpy as np

def digest(b): return hashlib.sha256(b).hexdigest()
def atomic(path, data):
    path=Path(path); path.parent.mkdir(parents=True,exist_ok=True)
    fd,tmp=tempfile.mkstemp(dir=path.parent)
    with os.fdopen(fd,'wb') as f: f.write(data); f.flush(); os.fsync(f.fileno())
    os.replace(tmp,path)
def prepare(source,out):
    records=[json.loads(x) for x in Path(source).read_text().splitlines() if x.strip()]
    seen=set(); groups={'train':[],'validation':[]}
    for r in records:
        if r.get('license')!='CC0' or not isinstance(r.get('text'),str): raise ValueError('unsupported rights/schema')
        text=' '.join(r['text'].split())
        if not text: raise ValueError('empty text')
        h=digest(text.encode())
        if h in seen: continue
        seen.add(h)
        # Split before windows; one source record never crosses splits.
        groups['validation' if int(h[:8],16)%5==0 else 'train'].append({'id':r['id'],'text':text,'sha256':h})
    if not all(groups.values()): raise ValueError('both splits required')
    payload=json.dumps(groups,sort_keys=True).encode()
    atomic(Path(out)/'dataset.json',payload)
    atomic(Path(out)/'data-manifest.json',json.dumps({'sha256':digest(payload),'source_sha256':digest(Path(source).read_bytes()),'split':'content-hash modulo 5','counts':{k:len(v) for k,v in groups.items()}},indent=2).encode())
    return groups

def pairs(records,vocab):
    lookup={c:i+2 for i,c in enumerate(vocab)}; xs=[];ys=[]
    for r in records:
        ids=[0]+[lookup[c] for c in r['text']]+[1]
        xs.extend(ids[:-1]);ys.extend(ids[1:])
    return np.array(xs),np.array(ys)
def loss(w,x,y):
    z=w[x]; z=z-z.max(axis=1,keepdims=True)
    return float(np.mean(np.log(np.exp(z).sum(axis=1))-z[np.arange(len(x)),y]))
def train(root,steps=400,resume=False):
    root=Path(root); raw=(root/'dataset.json').read_bytes();ds=json.loads(raw)
    # Vocabulary belongs to training data. Fixture is ASCII; production needs UNK policy.
    vocab=sorted(set(''.join(r['text'] for r in ds['train'])))
    if any(c not in vocab for r in ds['validation'] for c in r['text']): raise ValueError('validation has unknown characters')
    x,y=pairs(ds['train'],vocab); vx,vy=pairs(ds['validation'],vocab)
    rng=np.random.default_rng(42);w=np.zeros((len(vocab)+2,)*2);start=0
    cp=root/'checkpoint.npz'
    if resume and cp.exists():
        with np.load(cp,allow_pickle=False) as c:
            if str(c['data_hash'])!=digest(raw): raise ValueError('dataset changed during resume')
            w=c['weights'];start=int(c['step']);rng.bit_generator.state=json.loads(str(c['rng']))
    initial=loss(w,x,y)
    for step in range(start,steps):
        ix=rng.integers(0,len(x),size=128); xx=x[ix];yy=y[ix]
        z=w[xx];z-=z.max(axis=1,keepdims=True);p=np.exp(z);p/=p.sum(axis=1,keepdims=True)
        p[np.arange(len(xx)),yy]-=1;g=np.zeros_like(w);np.add.at(g,xx,p/len(xx));w-=3*g
        if (step+1)%50==0 or step+1==steps:
            import io
            buf=io.BytesIO();np.savez(buf,weights=w,step=step+1,rng=json.dumps(rng.bit_generator.state),data_hash=digest(raw));atomic(cp,buf.getvalue())
    model={'architecture':'bigram-softmax-v1','vocab':vocab,'weights':w.tolist(),'data_sha256':digest(raw),'steps':steps,'seed':42}
    modelraw=json.dumps(model,separators=(',',':')).encode();atomic(root/'model.json',modelraw)
    metrics={'initial_train_nll':initial,'train_nll':loss(w,x,y),'validation_nll':loss(w,vx,vy),'model_sha256':digest(modelraw),'steps':steps}
    atomic(root/'metrics.json',json.dumps(metrics,indent=2).encode());print(json.dumps(metrics));return metrics

def promote(root):
    root=Path(root);m=json.loads((root/'metrics.json').read_text()); raw=(root/'model.json').read_bytes()
    if digest(raw)!=m['model_sha256'] or not np.isfinite(m['validation_nll']) or m['validation_nll']>=4: raise ValueError('release gate failed')
    # This threshold only validates the declared teaching fixture, not language quality.
    atomic(root/'release.json',json.dumps({'model_sha256':digest(raw),'data_sha256':digest((root/'dataset.json').read_bytes()),'artifact':'model.json','gate':'fixture validation NLL < 4; not a safety evaluation'},indent=2).encode())

if __name__=='__main__':
    p=argparse.ArgumentParser();p.add_argument('action',choices=['prepare','train','promote']);p.add_argument('--root',default='/work');p.add_argument('--source',default='corpus.jsonl');p.add_argument('--steps',type=int,default=400);p.add_argument('--resume',action='store_true');a=p.parse_args()
    if a.action=='prepare': prepare(a.source,a.root)
    elif a.action=='train': train(a.root,a.steps,a.resume)
    else: promote(a.root)
serve.py

serve.py

"""Local/private teaching API; no public ingress, TLS or identity provider."""
import argparse, hashlib, json, threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
import numpy as np

def load(root):
    root=Path(root);release=json.loads((root/'release.json').read_text());raw=(root/'model.json').read_bytes()
    if hashlib.sha256(raw).hexdigest()!=release['model_sha256']: raise ValueError('artifact integrity mismatch')
    return json.loads(raw),release['model_sha256']
def application(model,revision):
    w=np.array(model['weights']);vocab=model['vocab'];lookup={c:i+2 for i,c in enumerate(vocab)};slots=threading.BoundedSemaphore(2)
    class Handler(BaseHTTPRequestHandler):
        def log_message(self,*args): pass # No prompts in request logs.
        def respond(self,status,obj):
            raw=json.dumps(obj).encode();self.send_response(status);self.send_header('Content-Type','application/json');self.send_header('Content-Length',str(len(raw)));self.end_headers();self.wfile.write(raw)
        def do_GET(self):
            self.respond(200 if self.path=='/health' else 404,{'model_revision':revision})
        def do_POST(self):
            if self.path!='/v1/completions': return self.respond(404,{'error':'not found'})
            self.connection.settimeout(10)
            try:
                size=int(self.headers.get('Content-Length','0'))
                if not 0<size<=8192: return self.respond(413,{'error':'body limit'})
                body=json.loads(self.rfile.read(size))
                if not isinstance(body,dict): raise ValueError('object required')
                prompt=body.get('prompt','');limit=body.get('max_tokens',32)
                if not isinstance(prompt,str) or len(prompt)>512 or type(limit)!=int or not 1<=limit<=128: raise ValueError('invalid prompt or token limit')
                if any(c not in lookup for c in prompt): raise ValueError('unknown character')
                if type(body.get('stream',False))!=bool: raise ValueError('stream must be boolean')
            except (ValueError,TypeError,TimeoutError): return self.respond(400,{'error':'invalid request'})
            if not slots.acquire(blocking=False): return self.respond(429,{'error':'capacity'})
            try:
                token=lookup[prompt[-1]] if prompt else 0;rng=np.random.default_rng(42);out=[]
                if body.get('stream'):
                    self.send_response(200);self.send_header('Content-Type','text/event-stream');self.send_header('Cache-Control','no-cache');self.send_header('Connection','close');self.end_headers();self.close_connection=True
                for _ in range(limit):
                    z=w[token].copy();z[0]=-np.inf;p=np.exp(z-np.max(z));p/=p.sum();token=int(rng.choice(len(p),p=p))
                    if token==1: break
                    out.append(vocab[token-2])
                    if body.get('stream'):
                        self.wfile.write(('data: '+json.dumps({'token':out[-1],'model_revision':revision})+'\n\n').encode());self.wfile.flush()
                if body.get('stream'): self.wfile.write(b'data: [DONE]\n\n');self.wfile.flush()
                else: self.respond(200,{'text':''.join(out),'completion_tokens':len(out),'model_revision':revision})
            except (BrokenPipeError,ConnectionResetError,TimeoutError): pass
            finally: slots.release()
    return Handler
if __name__=='__main__':
    p=argparse.ArgumentParser();p.add_argument('--root',default='/work');p.add_argument('--host',default='127.0.0.1');p.add_argument('--port',type=int,default=8000);a=p.parse_args()
    model,rev=load(a.root);ThreadingHTTPServer((a.host,a.port),application(model,rev)).serve_forever()
transformer.py

transformer.py

"""Optional real GPT-2 architecture training path; not run by Token Lab.
Python 3.11, torch 2.6.0, transformers 4.51.3, tokenizers 0.21.1.
Reads the SAME prepared dataset.json; trains its own byte BPE tokenizer.
A tiny random model demonstrates mechanics, not useful assistant capability.
"""
import argparse,json,os,random
from pathlib import Path
import torch
from tokenizers import ByteLevelBPETokenizer
from transformers import GPT2Config,GPT2LMHeadModel,PreTrainedTokenizerFast
p=argparse.ArgumentParser();p.add_argument('--root',default='/work');p.add_argument('--steps',type=int,default=200);p.add_argument('--resume',action='store_true');a=p.parse_args()
root=Path(a.root);ds=json.loads((root/'dataset.json').read_text());torch.manual_seed(42);random.seed(42)
# CPU default for broad compatibility; set DEVICE=cuda for a provisioned GPU.
device=os.environ.get('DEVICE','cpu');tokenizer=ByteLevelBPETokenizer()
tokenizer.train_from_iterator((r['text'] for r in ds['train']),vocab_size=512,min_frequency=2,special_tokens=['<bos>','<eos>','<pad>'])
tok=PreTrainedTokenizerFast(tokenizer_object=tokenizer._tokenizer,bos_token='<bos>',eos_token='<eos>',pad_token='<pad>')
config=GPT2Config(vocab_size=len(tok),n_positions=128,n_ctx=128,n_embd=128,n_layer=2,n_head=4,bos_token_id=tok.bos_token_id,eos_token_id=tok.eos_token_id,pad_token_id=tok.pad_token_id)
model=GPT2LMHeadModel(config).to(device);optimizer=torch.optim.AdamW(model.parameters(),lr=3e-4)
rows=[tok(r['text'],max_length=126,truncation=True)['input_ids']+[tok.eos_token_id] for r in ds['train']]
import hashlib
fingerprint=hashlib.sha256((root/'dataset.json').read_bytes()).hexdigest();cp=root/'transformer-checkpoint.pt';start=0
if a.resume and cp.exists():
    state=torch.load(cp,map_location='cpu',weights_only=True)
    if state['data_hash']!=fingerprint: raise ValueError('dataset mismatch')
    model.load_state_dict(state['model']);optimizer.load_state_dict(state['optimizer']);start=state['step'];torch.set_rng_state(state['cpu_rng']);random.setstate(state['python_rng'])
    if device.startswith('cuda'): torch.cuda.set_rng_state_all(state['cuda_rng'])
model.train()
for step in range(start,a.steps):
    chosen=random.choices(rows,k=4);width=max(map(len,chosen));ids=torch.full((4,width),tok.pad_token_id,dtype=torch.long,device=device);mask=torch.zeros_like(ids)
    for i,row in enumerate(chosen): ids[i,:len(row)]=torch.tensor(row,device=device);mask[i,:len(row)]=1
    labels=ids.clone();labels[mask==0]=-100
    optimizer.zero_grad(set_to_none=True);loss=model(input_ids=ids,attention_mask=mask,labels=labels).loss
    loss.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),1);optimizer.step()
    if (step+1)%50==0 or step+1==a.steps:
        state={'model':model.state_dict(),'optimizer':optimizer.state_dict(),'step':step+1,'cpu_rng':torch.get_rng_state(),'python_rng':random.getstate(),'cuda_rng':torch.cuda.get_rng_state_all() if device.startswith('cuda') else [],'data_hash':fingerprint}
        tmp=root/'checkpoint.tmp';torch.save(state,tmp);os.replace(tmp,cp)
        print(json.dumps({'step':step+1,'training_loss':float(loss.detach())}))
export=root/'transformer-candidate';export.mkdir(exist_ok=True)
model.save_pretrained(export,safe_serialization=True);tok.save_pretrained(export)
# Candidate only: no release pointer is changed. Evaluate before promotion.
(export/'lineage.json').write_text(json.dumps({'data_sha256':fingerprint,'seed':42,'steps':a.steps,'status':'candidate-not-approved'}))
approve_transformer.py

approve_transformer.py

"""Held-out next-token NLL gate for this synthetic fixture only. Not a safety gate.
Unexecuted optional Transformer path. Uses CPU; no paid APIs or uploaded data.
"""
import argparse,hashlib,json,math,os,shutil
from pathlib import Path
import torch
from transformers import AutoTokenizer, GPT2LMHeadModel
p=argparse.ArgumentParser();p.add_argument('--root',default='/work');p.add_argument('--max-nll',type=float,required=True);a=p.parse_args()
r=Path(a.root);src=r/'transformer-candidate';dst=r/'approved'
if dst.exists(): raise ValueError('use a fresh release directory; never overwrite a served artifact')
data=json.loads((r/'dataset.json').read_text());lineage=json.loads((src/'lineage.json').read_text())
assert lineage['data_sha256']==hashlib.sha256((r/'dataset.json').read_bytes()).hexdigest()
tok=AutoTokenizer.from_pretrained(src,local_files_only=True);model=GPT2LMHeadModel.from_pretrained(src,local_files_only=True).eval()
total=0.;n=0
with torch.no_grad():
    for row in data['validation']:
        ids=tok(row['text'],max_length=126,truncation=True)['input_ids']+[tok.eos_token_id]
        x=torch.tensor([ids]);loss=model(input_ids=x,labels=x).loss.item()
        total+=loss*(len(ids)-1);n+=len(ids)-1
nll=total/n
print(json.dumps({'validation_nll':nll,'tokens':n,'threshold':a.max_nll}))
if not math.isfinite(nll) or nll>=a.max_nll: raise ValueError('candidate rejected; approved version unchanged')
files={f.name:hashlib.sha256(f.read_bytes()).hexdigest() for f in src.iterdir() if f.is_file()}
staging=r/'approval-staging'
if staging.exists(): shutil.rmtree(staging)
shutil.copytree(src,staging)
(staging/'release-manifest.json').write_text(json.dumps({'files':files,'validation_nll':nll,'gate':'synthetic fixture only','data_sha256':lineage['data_sha256']},indent=2))
os.replace(staging,dst) # Atomic directory rename on this one filesystem, not object-store transaction.
verify.py

verify.py

"""Actual local training/resume/integrity/API checks; no cluster required."""
import importlib.util,json,tempfile,threading,urllib.request,urllib.error
from pathlib import Path
from http.server import ThreadingHTTPServer
import numpy as np
from pipeline import prepare,train,promote
from serve import load,application
here=Path(__file__).parent
with tempfile.TemporaryDirectory() as t:
    a=Path(t)/'a';b=Path(t)/'b'
    for root in (a,b):prepare(here/'corpus.jsonl',root)
    metrics=train(a);train(b,200);train(b,400,True)
    assert (a/'model.json').read_bytes()==(b/'model.json').read_bytes(),'resume differs'
    assert metrics['train_nll']<metrics['initial_train_nll'];promote(a)
    model,revision=load(a);server=ThreadingHTTPServer(('127.0.0.1',0),application(model,revision))
    thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start()
    url=f'http://127.0.0.1:{server.server_port}'
    def post(body):
        request=urllib.request.Request(url+'/v1/completions',data=json.dumps(body).encode(),headers={'Content-Type':'application/json'})
        return urllib.request.urlopen(request,timeout=5).read()
    assert json.loads(urllib.request.urlopen(url+'/health').read())['model_revision']==revision
    result=json.loads(post({'prompt':'Data ','max_tokens':16}));assert result['completion_tokens']<=16 and result['model_revision']==revision
    stream=post({'prompt':'Data ','max_tokens':16,'stream':True});assert stream.endswith(b'data: [DONE]\n\n')
    try:post({'prompt':'Data ','max_tokens':0});raise AssertionError('invalid request accepted')
    except urllib.error.HTTPError as e:assert e.code==400
    server.shutdown();server.server_close()
    (a/'model.json').write_text('{}')
    try:load(a);raise AssertionError('tamper accepted')
    except ValueError:pass
print('PASS: loss descent, exact resume, artifact integrity, HTTP generation, SSE, invalid input')
kubernetes.yaml

kubernetes.yaml

apiVersion: v1
kind: Namespace
metadata:
  name: tokenlab-ai
  labels:
    pod-security.kubernetes.io/enforce: restricted
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata: {name: artifacts, namespace: tokenlab-ai}
spec:
  accessModes: [ReadWriteOnce]
  resources:
    requests: {storage: 1Gi}
---
apiVersion: batch/v1
kind: Job
metadata: {name: train-v1, namespace: tokenlab-ai}
spec:
  backoffLimit: 1
  activeDeadlineSeconds: 600
  template:
    metadata:
      labels: {app: trainer}
    spec:
      restartPolicy: Never
      automountServiceAccountToken: false
      securityContext: {runAsNonRoot: true, runAsUser: 10001, runAsGroup: 10001, fsGroup: 10001, seccompProfile: {type: RuntimeDefault}}
      containers:
      - name: train
        image: tokenlab-ai:local
        imagePullPolicy: IfNotPresent
        command: [sh, -ec]
        args:
        - python pipeline.py prepare --source corpus.jsonl --root /work && python pipeline.py train --root /work --resume && python pipeline.py promote --root /work
        resources:
          requests: {cpu: '1', memory: 256Mi}
          limits: {cpu: '2', memory: 512Mi}
        securityContext: {allowPrivilegeEscalation: false, readOnlyRootFilesystem: true, capabilities: {drop: [ALL]}}
        volumeMounts:
        - {name: artifacts, mountPath: /work}
      volumes:
      - name: artifacts
        persistentVolumeClaim: {claimName: artifacts}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: model-v1, namespace: tokenlab-ai}
spec:
  replicas: 1
  strategy: {type: Recreate}
  selector:
    matchLabels: {app: model-v1}
  template:
    metadata:
      labels: {app: model-v1}
    spec:
      automountServiceAccountToken: false
      securityContext: {runAsNonRoot: true, runAsUser: 10001, runAsGroup: 10001, fsGroup: 10001, seccompProfile: {type: RuntimeDefault}}
      containers:
      - name: server
        image: tokenlab-ai:local
        imagePullPolicy: IfNotPresent
        resources:
          requests: {cpu: '250m', memory: 128Mi}
          limits: {cpu: '1', memory: 256Mi}
        ports: [{containerPort: 8000}]
        startupProbe:
          httpGet: {path: /health, port: 8000}
          failureThreshold: 30
          periodSeconds: 2
        readinessProbe:
          httpGet: {path: /health, port: 8000}
          periodSeconds: 5
        livenessProbe:
          httpGet: {path: /health, port: 8000}
          periodSeconds: 15
        securityContext: {allowPrivilegeEscalation: false, readOnlyRootFilesystem: true, capabilities: {drop: [ALL]}}
        volumeMounts:
        - {name: artifacts, mountPath: /work, readOnly: true}
      volumes:
      - name: artifacts
        persistentVolumeClaim: {claimName: artifacts}
---
apiVersion: v1
kind: Service
metadata: {name: model-api, namespace: tokenlab-ai}
spec:
  selector: {app: model-v1}
  ports: [{port: 8000, targetPort: 8000}]
  type: ClusterIP
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: private-model, namespace: tokenlab-ai}
spec:
  podSelector: {}
  policyTypes: [Ingress, Egress]
  ingress:
  - from:
    - podSelector:
        matchLabels: {role: authorized-client}
    ports: [{protocol: TCP, port: 8000}]
  egress: []
transformer-job.yaml

transformer-job.yaml

# Optional, not executed here. First create namespace/PVC from kubernetes.yaml.
apiVersion: batch/v1
kind: Job
metadata:
  name: transformer-train
  namespace: tokenlab-ai
spec:
  backoffLimit: 1
  activeDeadlineSeconds: 7200
  template:
    metadata:
      labels:
        app: trainer
    spec:
      restartPolicy: Never
      automountServiceAccountToken: false
      securityContext:
        runAsNonRoot: true
        runAsUser: 10001
        runAsGroup: 10001
        fsGroup: 10001
        seccompProfile:
          type: RuntimeDefault
      containers:
      - name: train
        image: tokenlab-transformer:lab
        imagePullPolicy: IfNotPresent
        command:
        - sh
        - -c
        args:
        - python pipeline.py prepare --source corpus.jsonl --root /work && python transformer.py
          --root /work --steps 200 --resume && python approve_transformer.py --root
          /work --max-nll 4.0
        resources:
          requests:
            cpu: '2'
            memory: 2Gi
          limits:
            cpu: '4'
            memory: 4Gi
        securityContext:
          allowPrivilegeEscalation: false
          readOnlyRootFilesystem: true
          capabilities:
            drop:
            - ALL
        volumeMounts:
        - name: artifacts
          mountPath: /work
      volumes:
      - name: artifacts
        persistentVolumeClaim:
          claimName: artifacts
gpu-serving.yaml

gpu-serving.yaml

# Optional unexecuted serving reference. Populate /models/approved first.
# Replace the image tag with a verified digest in your registry before production.
apiVersion: apps/v1
kind: Deployment
metadata: {name: transformer-v1, namespace: tokenlab-ai}
spec:
  replicas: 1
  strategy: {type: Recreate}
  selector:
    matchLabels: {app: transformer-v1}
  template:
    metadata:
      labels: {app: transformer-v1}
    spec:
      automountServiceAccountToken: false
      containers:
      - name: vllm
        image: vllm/vllm-openai:v0.14.0
        args: [--model, /models/approved, --served-model-name, tokenlab-transformer, --max-model-len, '128', --dtype, float32, --gpu-memory-utilization, '0.5', --max-num-seqs, '8']
        resources:
          requests: {cpu: '2', memory: 4Gi}
          limits: {cpu: '4', memory: 8Gi, nvidia.com/gpu: '1'}
        ports: [{containerPort: 8000}]
        startupProbe:
          httpGet: {path: /health, port: 8000}
          failureThreshold: 180
          periodSeconds: 10
        readinessProbe:
          httpGet: {path: /health, port: 8000}
        volumeMounts:
        - {name: models, mountPath: /models, readOnly: true}
        - {name: shm, mountPath: /dev/shm}
      volumes:
      - name: models
        persistentVolumeClaim: {claimName: artifacts}
      - name: shm
        emptyDir: {medium: Memory, sizeLimit: 1Gi}
# Integrate into a separately hardened GPU namespace: the public image's UID,
# writable cache locations, device access and driver/CUDA matrix must be checked.
# Do not apply blindly to the restricted CPU namespace above. See README.

---
apiVersion: v1
kind: Service
metadata: {name: transformer-api, namespace: tokenlab-ai}
spec:
  selector: {app: transformer-v1}
  ports: [{port: 8000, targetPort: 8000}]
Dockerfile

Dockerfile

FROM python:3.11.14-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY pipeline.py serve.py corpus.jsonl ./
USER 10001:10001
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1
CMD ["python", "serve.py", "--host", "0.0.0.0"]
Dockerfile.transformer

Dockerfile.transformer

FROM python:3.11.14-slim
WORKDIR /app
COPY requirements-transformer.txt .
RUN pip install --no-cache-dir -r requirements-transformer.txt
COPY pipeline.py transformer.py approve_transformer.py corpus.jsonl ./
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 TOKENIZERS_PARALLELISM=false
USER 10001:10001
CMD ["python", "transformer.py", "--root", "/work"]
把基础真正讲清楚

回顾本方法依赖的共同基础,再通过算例与检查定位理解上的缺口。

自回归解码每次根据已有 token 生成一个新 token。在因果 Transformer 中,前缀和模型不变时,之前的 Key、Value 无需重新计算。KV 缓存保存的是内部张量,不是完整答案。估算容量之前,应先数清层数、batch、缓存位置数、KV 头数、头维度和每个数字的字节数。

先独立推理,再看答案

2 层、、缓存 4 个 token、2 个 KV 头、头维度 3、每个数字 2 字节,同时保存 K 和 V 需要多少字节?

逐步解析

2×2×1×4×2×3×2=192 字节。第一个 2 表示 K、V 两份。它不包含权重、注意力临时缓冲、分配器开销和 padding。固定其他维度时,上下文翻倍会让这部分翻倍,不表示总显存也翻倍。

为什么在应用中重要

GQA 用少于 Query 的 KV 头减少该项存储。这是架构选择,不代表可以随意删除已有模型的缓存张量。前缀复用还要求 token、位置、模型和相关执行设置一致。

怎样证明自己理解了

同一前缀比较有无缓存的输出,在数值容差内应一致;改变前缀后验证失效处理。区分有效张量字节与分配内存,分别报告 prefill 和 decode 延迟。浏览器容量计算器不是硬件吞吐基准。

运行完整 Python 算例

Python 3.10+ · 仅标准库 · 确定性计算,无需随机种子 · 不联网。保存文件后执行下方命令。这些是教学检查,不是模型基准。

下载 Python · kv.py
python3 kv.py
# Python 3.10+; standard library; deterministic; no network.
def kv_bytes(layers, batch, tokens, kv_heads, head_dim, bytes_per_value):
    dimensions = [layers, batch, tokens, kv_heads, head_dim, bytes_per_value]
    if any(not isinstance(x, int) or x < 0 for x in dimensions):
        raise ValueError("nonnegative integer dimensions required")
    size = 2  # K and V
    for dimension in dimensions:
        size *= dimension
    return size

assert kv_bytes(2, 1, 4, 2, 3, 2) == 192
assert kv_bytes(2, 1, 8, 2, 3, 2) == 384
assert kv_bytes(2, 1, 0, 2, 3, 2) == 0
print("KV payload=192 bytes; doubled context=384 bytes")

预期输出

KV payload=192 bytes; doubled context=384 bytes

补齐先修知识 →

基础讲解更新:

下一步学什么

阅读版本固定的论文,复现小机制,运行负对照,说明哪些尚未被证明。

实现与验收 → · 继续学习路线 →

预测、检验与证据记录

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

打开记录/导出/清除 →

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