跳到正文

第 L3 层

系统与基础设施

这一层

这层对应用工程师的边界

L3 讲的是模型跑在什么上面、怎么跑得快、跑一次花多少钱。对以 L4 为主的应用工程师,这层的完成标准是「会讲 + 部署过一次」:能在系统设计题里讲清推理服务的取舍,能把一个开源模型自己跑起来并量出数字;不需要写 CUDA、不需要跑过分布式训练。边界之内的知识点有四个:GPU 入门:为什么是它,瓶颈在哪(硬件为什么是这样)、Serving:自己跑模型(推理服务,本层的重心)、并行训练:为什么一张卡不够(训练为什么要上千卡)、算力经济:训练花在哪,推理怎么收费(钱怎么算);再加一个落地层 Kubernetes:在客户的地方跑,模型和应用最终部到客户环境里的那套词汇。

四个量怎么互相挤

推理服务只有四个量:吞吐、延迟、显存、成本。它们不是四个独立的指标,而是一根杠杆的几个头。解码每走一步都要把全部权重从显存读一遍,所以单条请求几乎用不满卡;把请求合成一批,权重读一次喂多条,吞吐上去了,但每条请求的每 token 间隔被拉长,延迟退了。批次能合多大,取决于 KV cache 还剩多少显存,而 KV cache 随并发数和上下文长度一起涨。成本则是吞吐的倒数:卡的租金固定,一小时跑出多少 token 决定每百万 token 多少钱。于是所有优化都落在三件事上:量化让权重更小(带宽瓶颈直接变快、同样显存装更多并发),分页与前缀缓存让 KV 少浪费,并行让一张卡装不下的模型装得下。讲清这一段,就是本层系统设计题的全部。

两条线

推理侧(本层重心):从 GPU 入门:为什么是它,瓶颈在哪 的「算力还是带宽瓶颈」判断法出发,到 Serving:自己跑模型 的连续 batching、分页 KV、量化与并行,终点是自己部署一次并把四个量量出来,再在 算力经济:训练花在哪,推理怎么收费 里把每百万 token 的成本算成钱。

训练侧(只要求会讲):同一张 GPU 装不下一个大模型的参数、梯度和优化器状态,于是 并行训练:为什么一张卡不够 讲四种切法——数据并行复制模型、ZeRO 分摊状态、张量并行切单层、流水线并行切层段——以及每种切法新增的通信在哪。它解释了为什么训练是上千卡的事,也解释了 算力经济:训练花在哪,推理怎么收费 里训练成本那一栏的来源。

推荐前十

按阅读顺序;每条链到下面的节点。

  1. 1

    What Every Developer Should Know About GPU Computing free

    先知道 GPU 长什么样,才讲得清为什么它吞得下矩阵乘 → GPU 入门:为什么是它,瓶颈在哪

  2. 2

    Making Deep Learning Go Brrrr From First Principles free

    算力、带宽、开销三种瓶颈的判断法,之后所有取舍都靠它 → GPU 入门:为什么是它,瓶颈在哪

  3. 3

    How is LLaMa.cpp possible? free

    把瓶颈判断套在 LLM 解码上算一遍,量化为什么直接换速度 → GPU 入门:为什么是它,瓶颈在哪

  4. 4

    LLM Inference Handbook — Modular free

    推理服务的全景手册,四个量和每个抓手各一节 → Serving:自己跑模型

  5. 5

    Inside vLLM: Anatomy of a High-Throughput LLM Inference System free

    跟着一个请求走完一个真实引擎,系统设计题要画的那张图 → Serving:自己跑模型

  6. 6

    vLLM documentation free

    部署项目用的引擎与测量工具,数字从这里来 → Serving:自己跑模型

  7. 7

    The Ultra-Scale Playbook: Training LLMs on GPU Clusters free

    四种并行逐个引入,各省了什么、各多了什么通信 → 并行训练:为什么一张卡不够

  8. 8

    How to Scale Your Model: A Systems View of LLMs on TPUs free

    用同一把 roofline 尺子推导训练和推理该用多少芯片 → 并行训练:为什么一张卡不够

  9. 9

    DeepSeek-V3/R1 Inference System Overview free

    带真实数字的推理账本,每 token 成本怎么算的一手范例 → 算力经济:训练花在哪,推理怎么收费

  10. 10

节点

GPU 入门:为什么是它,瓶颈在哪

半衰期: 快变

ml-mathgpu-basicscompute-economicsparallel-trainingserving

深度学习的主体是矩阵乘,GPU 用上千个简单核心并行做同一种算术,正好对上。要讲清三个量:算力(FLOPs/s,由核心数和张量核决定)、显存容量(装得下多大的权重和 KV cache)、显存带宽(每秒能搬多少字节进计算单元)。估算方法只有两条:一次前向大约每参数两次浮点运算,所以 7B 模型每 token 约 14 GFLOPs;解码时每生成一个 token 都要把全部权重读一遍,所以速度上限 ≈ 带宽 ÷ 权重字节数。把这两条和芯片参数一比,就知道当前是算力瓶颈还是带宽瓶颈,量化和 batching 各救哪一头。本层的边界:会算、会判断,不写 CUDA。

先修
数学:用到时再补
之后
算力经济:训练花在哪,推理怎么收费 · 并行训练:为什么一张卡不够 · Serving:自己跑模型
  • What Every Developer Should Know About GPU Computing free

    article · 40 分钟 — 一篇把 GPU 的硬件形状(SM、warp、寄存器与显存的层级)讲到应用工程师够用的入门,读完能说清 GPU 为什么吞得下矩阵乘、为什么数据搬运才是瓶颈。

  • Making Deep Learning Go Brrrr From First Principles free

    article · 45 分钟 — 三种瓶颈(算力、带宽、开销)的判断法,连带算术强度与 FLOPs 估算:面试里被问「这个模型跑慢了卡在哪」,答案的框架就是这篇。

  • How is LLaMa.cpp possible? free

    article · 30 分钟 — 把前两篇的原理套到 LLM 解码上算一遍:权重字节数 ÷ 带宽 = 每 token 的下限,于是量化为什么直接换来速度、一台笔记本为什么跑得动 7B,数字都自己算得出来。

落选 (4)
  • GPU MODE(原 CUDA MODE)讲座系列 — 面向写 kernel 的人,深度超过本层「会讲不必会写」的边界;GitHub 6,819 star(2026-10-08 取)留作想往下挖时的入口。
  • Transformer Inference Arithmetic(kipply,2022) — 内容与 finbarr 一文重叠,HN 两次上榜都不到 100 分。
  • How to Scale Your Model 第 1 章(rooflines)与第 12 章(GPUs) — 同一本书已在 并行训练:为什么一张卡不够 精选,不重复占位。
  • AI Engineering 第 9 章(Chip Huyen) — 推理优化讲得好,但同一本书已在 LLM:模型怎么工作 节点作付费精选,且内容被 Serving:自己跑模型 的 handbook 覆盖。

Serving:自己跑模型

半衰期: 快变谁在招

请求batchGPU输出 tokenbatch 越大:每秒总共产出的 token 越多,每个请求等第一个 token 的时间也越长

托管 API 替你跑模型;自己跑一个开源模型,这件事就变成了 GPU 时间:把许多请求批在一起、缓存重复的部分、在延迟(第一个 token 多久到)和吞吐(所有人加起来每秒多少 token)之间取舍。vLLM、SGLang 这类推理引擎把大部分活都干了,serving 的功夫在于知道该改它们的哪个设置,并在真实负载下测。目标不是会写 CUDA,而是能在系统设计题里讲清吞吐、延迟、显存、成本这四个量怎么互相挤。

四个量由什么决定

  • 吞吐(每秒产出 token)主要靠 batching:解码阶段每一步都要把全部权重读一遍,一次服务一条请求时显存带宽几乎白跑,把几十条请求合成一批,权重读一次喂多条,吞吐近似线性上涨,直到算力或 KV 显存先见顶。连续 batching 让新请求随时插进正在跑的批次,不等整批结束。
  • 延迟分两段:首 token 延迟由 prefill(一次性算完提示词)决定,和提示长度、排队深度成正比;之后每 token 的间隔由解码一步的耗时决定。batch 越大吞吐越高,但每条请求的每 token 间隔也被拉长——吞吐和延迟是同一根杠杆的两头。
  • 显存装两样东西:权重和 KV cache。权重是定数,KV cache 随并发数 × 上下文长度增长,装不下就得缩 batch,吞吐跟着掉。分页管理(PagedAttention)减少浪费,前缀缓存让共享的系统提示不重复占位。
  • 成本是吞吐的倒数:卡的小时租金固定,每百万 token 的价格只取决于这一小时跑出了多少 token。所以降成本的抓手就是前三条:加大 batch、省 KV 显存、量化让权重更小(带宽瓶颈直接变快、同样显存装更多并发)、并行让一张卡装不下的模型装得下或把算力叠起来。张量并行在节点内分摊单层、降延迟;流水线并行跨节点、换吞吐;两者都增加通信。

动手部署的规格

只写规格,不执行;执行时的数字填进下面的表。

部什么。 两档各一个候选,同一家族以便对比:7B 级选 Qwen3-8B(Hugging Face 上有官方 GGUF、AWQ 和社区 MLX 4-bit 版本,三条路都不用自己转换),小模型选 Qwen3-1.7B。执行时若同家族有更新的 7–9B 稠密权重,换成新的即可,规格不变。

在哪里跑,两条路:

路 工具 适用
本机 Apple Silicon llama.cpp(llama-bench 测吞吐,llama-server 提供接口)或 MLX(mlx_lm.generate 直接打印 prompt / generation tokens/s 和峰值内存) 零成本、反复试;量化对速度和显存的影响在这里最直观;并发测试到 8 为止,统一内存上没有「显存不够」只有「变慢」
租一小时云 GPU 一张 24–80 GB 卡,vllm serve 起服务,vllm bench serve 打负载 要看真实的 batching 曲线、分页 KV 的显存占用和每百万 token 的租金成本;1 / 8 / 32 并发在一小时内全部跑完

量什么,每个配置都记:

  1. 吞吐:输出 tokens/s(整机),以及单请求 tokens/s。
  2. 首 token 延迟(TTFT)p50 / p90;每 token 间隔(TPOT)p50 / p90。vLLM 的 bench 默认给中位数和 P99,p90 从原始结果里算或用百分位参数指定;本机路用同一份负载脚本自己计时。
  3. 显存占用:权重部分 + KV cache 部分(vLLM 启动日志给 KV 预留量,nvidia-smi 给总数;本机看峰值内存)。
  4. 每百万 token 成本:云 GPU = 小时租金 ÷(输出 tokens/s × 3600)× 10⁶;本机记为 0 并注明电费未计。

变量矩阵: 模型(8B / 1.7B)× 精度(bf16 或 fp16 / 4-bit 量化)× 并发(1 / 8 / 32)× 路(本机 / 云),固定提示长度(如 512 输入、128 输出)。本机路 32 并发可跳过。

产出。 一页对比表:一行一个配置,列是上面四组数字;表下三句结论——量化换来了多少速度、并发从 1 到 32 吞吐涨了几倍而 TPOT 退了多少、云上每百万 token 多少钱并和一家托管 API 的标价放在一起。

先修
LLM:模型怎么工作 · GPU 入门:为什么是它,瓶颈在哪 · 解码与推理
之后
算力经济:训练花在哪,推理怎么收费 · Kubernetes:在客户的地方跑
  • LLM Inference Handbook — Modular free

    docs — Latency, throughput and cost of serving a model — batching, KV cache, quantization, which engine when — as one practical handbook rather than twenty blog posts.

  • Inside vLLM: Anatomy of a High-Throughput LLM Inference System free

    article · 90 min — One request followed through the scheduler, paged KV cache, continuous batching, prefix caching and speculative decoding, ending on the latency-against-throughput curve a design answer needs.

  • vLLM documentation free

    docs — The engine the cloud-GPU route runs on: the docs explain the trade-off behind each setting, and the bundled vllm bench serve prints TTFT, TPOT and throughput — the deployment project's numbers.

复现项目: Serve a small open model and measure it — Serve a small open model with vLLM, then measure time to first token and tokens per second at 1, 8 and 32 concurrent requests, with and without quantization.

落选 (6)
  • SGLang 文档 — 第二个主流引擎,概念与 vLLM 同构(RadixAttention 即前缀缓存),一次部署选一个就够;GitHub 36,861 star(2026-10-08 取)。
  • TensorRT — LLM 文档 — 只在 NVIDIA 栈上追极限性能时才值得,部署门槛高于本层。
  • llama.cpp、MLX — 本机路直接用的工具,在部署规格里出现,不占精选位;两者当天都有提交。
  • Life of an inference request (vLLM V1)(Ubicloud,2025 — 06,HN 175 分)— 与 Gordić 一文覆盖同一条链路而更短,二选一取更全的。
  • Nano — vLLM(2025–2026)— 读源码学引擎的好路,但超出「会讲 + 部署过一次」的边界。
  • AI Engineering 第 9 章(Chip Huyen) — 同一本书已在 LLM:模型怎么工作 节点作付费精选,推理优化内容与 handbook 重叠。

并行训练:为什么一张卡不够

半衰期: 快变

gpu-basicstransformerparallel-training

一个 70B 模型的参数、梯度和优化器状态用混合精度就要上 TB,一张卡的显存不到 200 GB,所以训练首先是一道「切开放哪里」的题。数据并行每卡一份完整模型、各算各的批次再同步梯度;ZeRO 把优化器状态、梯度、参数依次切片分摊,不再按卡数复制内存;张量并行把一层的矩阵切给几张卡、每层都要通信,所以只在节点内用;流水线并行按层分段传激活,代价是气泡。上千卡是几种并行相乘的结果,工程难点在把通信藏到计算后面。本层只要求讲清每种并行切的是什么、通信在哪,不要求跑过。

先修
GPU 入门:为什么是它,瓶颈在哪 · Transformer
  • The Ultra-Scale Playbook: Training LLMs on GPU Clusters free

    book · 一个周末 — 从单卡显存算起,一步步引入数据并行、ZeRO、张量并行、流水线并行、上下文并行与专家并行,每一步都说明它省了什么、新增了哪种通信;读完能解释为什么训练要上千卡。

  • How to Scale Your Model: A Systems View of LLMs on TPUs free

    book · 一个周末 — 用 roofline 一把尺子贯穿训练与推理:每种并行策略的通信量和计算量都写成公式,让你能在白板上推导某个模型用多少芯片、什么切法最划算;第 12 章把同一套方法搬到 GPU。

  • CS336: Language Modeling from Scratch free

    course · 系统部分 4 讲约 6 小时 — 想听课而不是读书的那条路:第 5 讲 GPU、第 7–8 讲并行、第 10 讲推理,由一线研究者讲清系统设计的取舍,正好覆盖本层四个节点;讲座视频在 YouTube 播放列表里。

落选 (3)
  • picotron / nanotron(Hugging Face) — 读 playbook 的配套实现,可跑,但本层停在「会讲」,不要求动手训练。
  • Megatron — LM、DeepSpeed 官方文档 — 实现文档,前提是已经要用它们;概念层面 playbook 讲得更清楚。
  • GPU MODE 的 NCCL / 集合通信讲座 — 对本层过深,列在 GPU 入门:为什么是它,瓶颈在哪 落选里的同一个系列。

算力经济:训练花在哪,推理怎么收费

半衰期: 快变

gpu-basicsservingcompute-economics

训练成本是一次性的:卡数 × 小时数 × 单价,加上失败重跑和数据、人力;推理成本是持续的,决定产品毛利。每百万 token 的成本只有一个公式:GPU 每小时租金 ÷ 这一小时实际产出的 token 数,所以吞吐就是成本的倒数,而吞吐由 batch 大小、KV cache 命中、量化和并行决定——这正是 Serving:自己跑模型 四个量里的最后一个。供给侧看三样:芯片(算力和 HBM 各占多少钱、产能在谁手里)、电力与机房、租赁市场的小时价。读这一节的目的是在系统设计题里把「这个功能一个月要烧多少钱」算出来,并能说出降成本的四个抓手。

先修
GPU 入门:为什么是它,瓶颈在哪 · Serving:自己跑模型
  • DeepSeek-V3/R1 Inference System Overview free

    article · 30 分钟 — 一家模型公司亲手公开的推理账本:多少节点、每天处理多少 token、每天的 GPU 成本和按标价算出的收入,是「每 token 成本怎么算」唯一带真实数字的一手范例,连带解释了为什么大 batch 和专家并行能把成本压下去。

  • Memory has grown to nearly two-thirds of AI chip component costs free

    article · 15 分钟 — 供给侧的一个关键事实:一块 AI 芯片的成本大头已经是 HBM 而不是逻辑芯片,由此能解释为什么显存带宽贵、为什么算力扩张卡在内存供应而不只是晶圆。

落选 (4)
  • How AI Labs Are Solving the Power Crisis(SemiAnalysis,2025 — 12)— 电力这条供给线讲得最细,但成本分析在付费墙后,HN 167 分;需要时作付费补充。
  • Inference Economics of Language Models(Epoch AI,2025 — 06)— 模型化推理成本的好文,但没有独立背书(HN 4 分),留作延伸。
  • LLM Inference Economics from First Principles(Tensor Economics,2025 — 05)— 同上,推导细致而缺背书。
  • AI's $600B Question(Sequoia,2024) — 讲的是投资回报而不是单位经济,离本层的完成标准远。

Kubernetes:在客户的地方跑

半衰期: 快变谁在招

FDE 的活常常落在客户的云里、一个你不拥有的集群上。以前发布过服务的人,这里的大部分已经会了:部署、配置与密钥、资源限制、滚动更新、看日志和指标;不需要会运维集群本身。你在 k3s 上做过的一切都算数。

先修
Serving:自己跑模型
  • Learn Kubernetes Basics — Kubernetes documentation free

    docs — The project's own six-module tutorial: create a cluster, deploy, expose, scale and roll out an app — the vocabulary every customer's environment is written in, in an afternoon.

  • Troubleshooting Applications — Kubernetes documentation free

    docs — Pods, services and running containers debugged with what you get on a cluster you do not own — describe, logs, events, a shell — the job when a customer's deployment misbehaves.

复现项目: Deploy your agent where a customer would run it — Package the agent as a container, deploy it to a local cluster with its secrets, a health probe and resource limits, then kill a node and watch what happens.

完成标准自测

  • 给一张卡的算力和带宽、一个模型的参数量和精度,能口算它解码的 tokens/s 上限,并说出当前是算力还是带宽瓶颈。
  • 能解释并发从 1 到 32 时吞吐、TTFT、TPOT、KV 显存各怎么变,以及量化动了其中哪几项。
  • 给一个产品的日 token 量和一张卡的租金,能算出每百万 token 的成本和月账单,并说出四个降成本抓手。
  • 能讲清数据并行、ZeRO、张量并行、流水线并行各切什么、通信在哪,以及为什么训练要上千卡。
  • 自己部署过一个开源模型,交出一页带数字的对比表。

复现项目在本机(llama.cpp / MLX)或一小时云 GPU(vLLM)上跑 Qwen3-8B 和 Qwen3-1.7B,在 1 / 8 / 32 并发、有无量化下量出吞吐、TTFT 与 TPOT 的 p50 / p90、显存占用和每百万 token 成本,产出一页对比表——规格在 Serving:自己跑模型「动手部署的规格」。

作者的笔记原稿。