大模型的炼金之旅
你正在读的这行字，是一粒「token」。而在它出现在屏幕之前，它已经在硅片上跑了万亿次浮点运算、穿过了几千张显卡组成的集群、在一座几十层深的神经网络里完成了漫长的旅行。周师傅要带小哲，顺着这条「算力 → 参数 → Token」的隧道，一路探到最深处。
一个问题：字是从哪来的
从「会说话」到「为什么能说话」师傅，前两本教程我打通了地牢、走完了软件公司。但有个问题一直堵在我心里：我在对话框里敲一句话，AI 怎么就「哗」地回我一大段？这字到底是从哪冒出来的？
好问题。大多数人都用过 AI，但很少有人知道它背后那条「生产链」。我给你讲个故事——一粒 Token 的诞生。
它要经过九个站点，从最底层说起：① 芯片（算力的原子）→ ② 集群（几千张卡联手）→ ③ 参数（模型的「身体」）→ ④ 训练（把世界装进参数）→ ⑤ 分词（文字变成数字）→ ⑥ 推理（逐字生成）→ ⑦ 采样（概率掷骰子）→ ⑧ 服务（包装成 API）→ ⑨ 最后一公里（字蹦到你屏幕上）。
记住这条链的核心：算力是土，参数是种子，Token 是果实。走，第一站，咱们钻进服务器机房里那块最贵的东西——芯片。
算力基石：芯片
GPU · 显存 · 浮点运算 · TFLOPs大模型的第一性原理：它的一切，都是「海量数字乘法」堆出来的。而干这活最快的，是显卡。
师傅，我明白了，AI 就是「算得快」对吧？那 CPU 不也能算吗，为啥训练大模型非得用显卡？一张显卡好几万块呢！
因为大模型的核心运算，是矩阵乘法——几千亿个「乘加」同时进行。CPU 是「一个大力士」，一次算一件大事；GPU 是「一万个搬砖工」，一次同时算一万件小事。矩阵乘法这种「同样的事重复一万遍」的活，正是 GPU 的主场。
而 AI 用的「显卡」其实叫加速卡：NVIDIA 的 GPU（H100 / A100 / B200）、Google 的 TPU、各家的 ASIC——都是专门为矩阵乘法优化的芯片。
CPU GPU(如 H100)
设计哲学 少数强核，通用 海量小核，并行
核心数 几十个 上万 CUDA 核心
擅长 单线程复杂逻辑 矩阵乘法/并行计算
AI 场景性能 🐢 慢 🚀 快几百倍
典型算力 ~1 TFLOPS ~2000 TFLOPS (FP8)算力侧术语
- GPU / TPU / ASIC：NVIDIA 显卡 / Google 专用芯片 / 定制专用芯片——都是「矩阵乘法加速器」。
- CUDA 核心 / 计算单元：GPU 里的「搬砖工」，上万个小计算单元。
- HBM 显存：AI 加速卡专用的高速内存，紧贴着芯片。显存越大，能装下的模型越大。
- 显存带宽：每秒钟从显存搬多少数据（TB/s 级）——训练 AI 时，带宽经常比算力更先卡脖子。
- FP16 / BF16 / FP8：数字的「精度档位」。AI 用半精度甚至 8 位精度算，够用又省显存还更快——精度和速度的trade-off。
- TFLOPS：每秒多少万亿次浮点运算——算力的「马力」单位。
一张 H100 就好几十万，那训练一个 70B 的大模型，得多少张卡啊？
几百到上万张。一张卡装不下模型，就得让几千张卡手拉手一起干活——下一站，千卡集群。
本站收获：算力的原子是「芯片」。GPU 用「一万个搬砖工」打赢 CPU 的「一个大力士」；显存决定装得下多大的模型，带宽决定喂得饱多快的算力。
千卡集群：互连
NVLink · InfiniBand · 数据/张量/流水线并行一千张卡不是「一千张卡」——如果它们之间传数据像寄快递，那训练一次要等三年。互连，才是集群的灵魂。
一千张卡一起训练……可它们怎么「商量」？总不能每算一步就把结果发邮件给其他卡吧？
哈哈，你猜对了——它们真的在疯狂「发消息」，只是用的是比网线快几个量级的高速通道：
- 卡与卡之间：用 NVLink（NVIDIA 自家的高速互连，带宽 900GB/s 级），8 张卡组成一个 节点（Node）。
- 节点与节点之间：用 InfiniBand 高速网络，把几千张卡连成一张「超级显卡」。
训练时还要把活拆开给不同的卡——这就是并行策略：
【数据并行】每张卡都有一份完整模型，各吃一批数据
卡1: 读样本A 卡2: 读样本B 卡3: 读样本C
→ 每轮算完，把梯度汇总同步（AllReduce）
→ 简单！但模型太大放不下时没用
【张量并行】把一层网络切开，每张卡算一段
Attention/FFN 矩阵切成 N 块 → N 张卡拼起来算一层
→ 层内并行，通信最频繁
【流水线并行】把模型按层切成几段，卡与卡像流水线
卡1算第1-10层 → 卡2算第11-20层 → 卡3算第21-30层
→ 层间并行，像工厂流水线
现实：三者叠加使用（3D 并行）集群侧术语
- NVLink：GPU 之间的超高速直连（卡内互连）。
- InfiniBand：跨服务器的高速网络（跨节点互连），AI 集群的「高速公路」。
- 节点（Node）：一台服务器，通常插 8 张卡。
- 数据并行：每卡一份模型，各吃各的数据，定期同步梯度。
- 张量并行：一层切开分给多卡，合起来算。
- 流水线并行：模型按层切段，卡与卡接力。
- 3D 并行：三种并行叠着用——大模型训练的标配姿势。
- 电力 / 散热：千卡集群的隐藏成本：电费、机房、液冷——训练一次的电费够买一辆车。
集群搭好了，下一步就是把「世界」装进这个集群里。但要装的东西有多重呢？——下一站，秤一下模型的「体重」。
本站收获：集群的本质是「互连」——NVLink 连卡、InfiniBand 连节点，数据/张量/流水线三种并行把大模型拆给千张卡。算力从「一张卡」变成了「一台超级机器」。
模型体重：参数
参数 · 权重 · Transformer · Embedding「70B 大模型」的「70B」，是 700 亿个参数。参数就是模型的「身体」——它有多「博学」，全看这身肉怎么长的。
总听人说「70B 模型」「百亿参数」，参数到底是啥？是一段程序吗？
参数不是程序，是数字——几十亿个「权重」，每个都是一个普通的小数。程序是固定不变的「配方」，而参数是会随训练调整的「调料量」。
打个比方：模型是一台巨大的「文字接龙机」。它的身体（Transformer 神经网络）由很多层组成，每一层都在做同一件事——把输入的 token 向量，经过注意力（Attention）和全连接（FFN）两层加工，再传给下一层。每层里上亿个权重，就是它「看世界的角度」。
70B 参数 × 2 字节(FP16) = 140 GB 权重
一张 H100 显存 80GB → 一张卡装不下！
需要：2 张卡 + 张量并行 / 或量化到 4 位 → 70GB 勉强一张卡
对比人类记忆：人脑约 100 万亿个突触
70B 模型 ≈ 700 亿个权重 —— 大约是人脑的 1/1400
Transformer 的身体结构（一层内部）：
输入 token 向量
↓
[多头自注意力] ← 学「谁和谁有关」：这句话里该看谁
↓
[前馈网络 FFN] ← 学「怎么加工」：把理解变成输出
↓
[层归一化] ← 稳住数值，别让数字爆炸
↓
下一层…… × 几十层模型侧术语
- 参数 / 权重：模型里的几十亿个小数字——「70B」指 700 亿个。
- Transformer：当今大模型的统一架构（2017 年提出），核心是注意力机制。
- 注意力（Attention）：让每个词「看」上下文里其他词，决定该关注谁——「银行」是金融机构还是河岸，靠上下文猜。
- Embedding（词嵌入）：把「苹果」这个词变成一串向量数字，语义相近的词在向量空间里离得近。
- 词表（Vocabulary）：模型认识的「词」集合，通常几万到几十万个 token。
- 层数 / 深度：几十层 Transformer 叠起来，越深越「聪明」，也越贵。
那这 700 亿个数字……是怎么「学会」说话的呢？难道有人一个一个教的？
不是人教的，是它「自己读了几万亿个字」然后一点点调出来的——下一站，训练。
本站收获：参数 = 模型的「身体」。700 亿个小数字 + Transformer 的注意力结构 + 几十层深度 = 一台能「读上下文」的文字接龙机。
训练：把世界装进参数
预训练 · 反向传播 · SFT · RLHF模型是怎么「学会」的？不是抄答案，而是「猜错 → 挨罚 → 微调」循环几万亿次。训练，就是把整个互联网的「规律」压进那 700 亿个数字里。
训练分三步走：预训练、监督微调（SFT）、人类反馈强化学习（RLHF）。咱们一样样看。
预训练是主体：把互联网上几万亿个 token 的文本喂给模型，让它玩一个游戏——看完前半句，猜下一个词。猜对了没奖励，猜错了就「挨罚」：算出一个损失值，用反向传播一路把误差传回去，用梯度下降微调每个权重，让下次猜得更准。
训练样本（来自互联网）：
「今天天气真____」 → 正确答案：好
模型猜测：给出每个词的概率：好(0.6) 差(0.2) 冷(0.1) 贵(0.1)
损失函数：猜错的惩罚 = 0.4（越大错得越离谱）
反向传播：把 0.4 的误差按链式法则传回每一层
梯度下降：每个权重朝着「减小误差」的方向挪一点点（学习率 × 梯度）
→ 训练 1 个批次…… 训练 100 万批……
→ 700 亿个权重被反复微调，直到「好」的概率接近 1
成本账：
70B 模型预训练 ≈ 数万亿 token × 万亿次运算
≈ 几千张 H100 跑 90 天，电费 + 算力 ≈ 上千万美元
（这就是为什么说「算力是土」）预训练完的模型只是「会接词」——你说「你好」，它可能接「吗？我很好谢谢」。但要它变成「会聊天、会写代码、有礼貌」的助手，还得两步精修：
SFT（监督微调）：用「人工写好的问答对」再教它一轮——「用户问 → 优质回答」的样子，学得像样。
RLHF（人类反馈强化学习）：让人类给模型回答打分（好的赞、差的踩），模型学会「人类喜欢什么风格」——这一步让模型从「能说」变成「会说人话」。
训练侧术语
- 预训练（Pretraining）：在超大规模语料上自监督学习，学「世界规律」。
- 反向传播（Backpropagation）：把预测误差逐层传回去，算出每个权重该改多少。
- 梯度下降 / 学习率：沿「误差山坡」往下走的方向调权重；学习率是每步走多大。
- 损失函数：量化「猜得有多错」的尺子。
- Epoch / Batch：整个数据集过一遍 = 一个 epoch；一次喂进去的一批样本 = batch。
- SFT（监督微调）：用人工标注的问答对，把模型调教成「助手」。
- RLHF：人类反馈强化学习——用点赞/差评训练模型「说人话」。
- 微调（Fine-tune）：在成品模型基础上小成本定制（用领域数据再练一小轮）。
明白了！模型是被「喂」大的。那训练完的模型，是怎么回答我的问题的？我把中文打进去，它怎么知道往哪里接？
关键就在这一步——你的中文句子，首先要被切成一块一块的数字，模型才看得懂。下一站，Token 正式登场。
本站收获：训练 = 「猜词游戏 + 挨罚 + 微调」循环几万亿次，把互联网规律压进参数。预训练给知识，SFT 给礼貌，RLHF 给人味——成本是「算力之土」烧出来的。
分词：Token 的诞生
Token · 词表 · BPE · 子词模型不懂「字」，只懂「数字」。文本和数字之间的翻译官，就是分词器——而它切出来的最小单位，就是 Token。
Token 就是模型处理文本的最小单位——可以是一个词、半个词，甚至一个字符。模型不读「字」，它读的是「token 编号」。你的整句话，先被 Tokenizer（分词器）切成一串 token，再查词表变成一串数字。
切分用的是 BPE（字节对编码）算法：先把最常用的词收进词表，生僻词拆成更小的片段，再拆成字符，最后到字节——保证「任何字都能表示」，又尽量少占 token。
输入：「今天天气真好，我们去爬山吧！」
切分（示意，不同模型词表不同）：
[今天] [天气] [真好] [,] [我们] [去] [爬山] [吧] [!]
→ 8 个 token
英文示例（BPE 子词）：
"unbelievable" → [un] [believ] [able] （生僻长词拆小块）
"hello world" → [hello] [ world] （空格常并入前词）
Token 数量 = 计费单位！
API 按 token 收费：1 个汉字 ≈ 1~2 个 token
100 万 token ≈ 一部《三体》的体量
「把话说明白」= 「用最少的 token 表达最多的意思」分词侧术语
- Token：模型处理文本的最小单位——既是「字符块」，也是「计费单位」，还是「上下文窗口的刻度」。
- Tokenizer（分词器）：把文本切成 token 的翻译官。
- 词表（Vocabulary）：token 编号字典，一般 5 万~20 万条。
- BPE（字节对编码）：主流分词算法——高频整词入库，生僻词逐级拆分，永不「查无此字」。
- 上下文窗口（Context Window）：模型一次能「看到」的 token 上限（如 128K）——超过就装不下。
- Token 经济学：输入输出都按 token 计费，优化 token 用量 = 省钱。
所以我的问题变成了 20 个数字……然后呢？模型怎么用这 20 个数字「想」出回答？
然后就是最神奇的一站——推理。注意，模型不是「想好一整段话再说」，而是一个字一个字地往外吐，像挤牙膏。
本站收获：Token 是文本的「原子」——BPE 分词把任何文字都变成词表里的编号。Token 既是单位，也是商品，还是上下文的刻度。
推理：逐字生成
前向传播 · 注意力 · 自回归 · KV Cache你看到 AI「唰唰唰」打字，其实它每蹦一个字，都要把「你的问题 + 已经吐出来的字」从头到尾重读一遍。挤牙膏，也是有讲究的。
推理时，模型跑的是前向传播：你的 token 序列从第一层流到最后一层，每一层用注意力「看」上下文、用 FFN「加工」，最后输出下一个 token 的概率分布。
然后关键来了——自回归（Autoregressive）：把新生成的 token 拼回输入，再跑一遍，再吐下一个……一个词一个词地「挤」出整段回答。
输入: [今天][天气][真好] → 模型算出 → 最可能是 [，]
拼回: [今天][天气][真好][，] → 模型算出 → 最可能是 [我们]
拼回: [今天][天气][真好][，][我们] → 最可能是 [去]
拼回: ……（继续挤）
输出: 「今天天气真好，我们去爬山吧！」
【代价】每挤一个字 = 整段重新算一遍
「挤」到第 100 个字时，前 99 个字全都要重读一遍
→ 幸好有 KV Cache：已算过的注意力结果缓存起来
→ 新字只算「新加的那一段」，速度提升几十倍推理侧术语
- 前向传播（Forward）：输入从第一层流到最后一层，算一遍「预测」。
- 自回归（Autoregressive）：把吐出的词拼回去再算，一个接一个生成。
- 注意力（Attention）：生成每个词时，「回顾」上下文里哪些词跟它相关。
- KV Cache：缓存已算过的 Key/Value，避免每个新词都全量重算——推理速度的关键优化。
- TTFT（首 token 延迟）：从提问到第一个字蹦出来要多久——「响不响应」看它。
- TPOT（每 token 延迟）：后续每个字之间的间隔——「流不流畅」看它。
- 上下文窗口：能塞进注意力的 token 上限，窗口满了就「忘了」最早的对话。
所以 AI 每次回答，都是「算概率 + 选一个词」？那它怎么选的？每次都选概率最大的那个吗？
问到点子上了！如果永远选概率最大的，AI 就变成一台复读机——每次回答一模一样。让它「有点随机」，靠的是下一站：解码采样。
本站收获：推理 = 前向传播 + 自回归：一个字一个字「挤」出来，每挤一个字重读一遍上文；KV Cache 让重读不白费，TTFT/TPOT 决定你体感的快慢。
解码采样：概率的选择
概率分布 · temperature · top-p · 幻觉模型算出的不是「一个答案」，而是一张「每个词的概率表」。从表里挑词，就是解码；怎么挑，决定了 AI 是复读机还是段子手。
模型输出概率分布（示意）：
好 0.61 ████████████
真棒 0.18 ████
不错 0.09 ██
还行 0.07 █
无语 0.05 █
【贪心解码】永远选最大 → 每次都是「好」（复读机模式）
【随机采样】按概率抽签 → 偶尔冒出「真棒」「不错」（有惊喜）
【temperature（温度）】调节「随机度」：
temperature = 0.2 概率更极端 → 保守、稳定
temperature = 0.8 正常 → 日常推荐
temperature = 1.5 概率拉平 → 放飞自我、天马行空（容易跑题）
【top-p / top-k】先砍掉尾巴，再抽签：
top-p=0.9 → 只保留累计概率 90% 的候选（好+真棒+不错）
→ 把「无语」这种小概率胡话直接淘汰采样侧术语
- 概率分布：模型对「下一个词」的完整预测——每个候选词一个概率。
- 贪心解码：永远选最大概率——稳定但死板。
- temperature（温度）：控制随机性——低=稳，高=浪。
- top-k / top-p：限制候选池——只从前 k 个 / 累计概率 p 里抽，防胡话。
- 采样策略：各种「怎么抽签」的配方，决定 AI 的性格。
- 幻觉（Hallucination）：概率采样「自信地编」出不存在的东西——AI 不是撒谎，是「顺着概率瞎接」。RAG、提示词约束都是在给采样「上保险」。
所以同一个问题，你问两次答案不一样——不是它「忘了」，是它在按概率抽签。温度越低，性格越稳定。
好了，模型这一侧的故事讲完了。现在轮到「商业」这一侧——这么多算力、这么多步骤，怎么包装成你手机里那个输入框？下一站，服务化。
本站收获：解码 = 从概率表里挑词。贪心太死板，随机有惊喜；temperature 调性格、top-p 防胡话——AI 的「创作力」和「胡说八道」，其实是同一个旋钮的两端。
服务化：从模型到 API
吞吐 · 批处理 · 量化 · 按 token 计费模型训练完只是「样品」，要变成几千万人同时用的「商品」，还得过服务化这一关：装得快、卖得便宜、扛得住并发。
模型本身不会自己跑——它需要被装进推理服务（如 vLLM 这类推理框架），部署在显卡上，对外提供 API。服务化要解决四个问题：
- 装得下：70B 模型 FP16 要 140GB 显存，一张卡不够 → 量化压到 4 位（INT4），只要 35GB，一张卡搞定。
- 跑得快：一次只服务一个人太浪费 → 连续批处理，把几十个用户的请求拼在一批同时算，吞吐暴涨。
- 记得住：vLLM 的 PagedAttention 像操作系统管内存一样管 KV Cache，显存利用率翻倍。
- 算得清钱：按 token 计费——输入 token 便宜，输出 token 贵（输出是算出来的，成本高）。
POST /v1/chat/completions
{
"model": "deepseek-chat",
"messages": [{"role":"user", "content":"讲个程序员笑话"}],
"temperature": 0.8,
"max_tokens": 200
}
→ 响应：
{
"content": "程序员最怕两件事：别人的代码没注释，自己的代码有 Bug……",
"usage": {
"prompt_tokens": 12, // 输入 12 个 token（便宜）
"completion_tokens": 148, // 输出 148 个 token（贵）
"total_tokens": 160
}
}
计费（示意）：输入 ¥X/百万token + 输出 ¥Y/百万token
→ 你问一个问题，背后是几百张显卡排队给你算 0.5 秒服务化术语
- 推理服务 / 推理框架：vLLM、TensorRT-LLM 等——把模型「运营」起来的引擎。
- 吞吐量（Throughput）：每秒吐多少个 token——决定服务多少并发用户。
- 批处理（Batching）：多个请求拼一批算，摊薄单请求成本。
- 量化（Quantization）：FP16 → INT8 → INT4，用精度换显存和速度——70B 装进一张卡的关键。
- PagedAttention：vLLM 的内存管理黑科技——KV Cache 像操作系统分页，碎片少、利用率高。
- 蒸馏（Distillation）：用大模型教小模型，小模型学个八九成，便宜几十倍。
- 按 token 计费：AI 的「按用量付费」——输入输出分开计价。
- 限流 / 配额：防止被刷爆：每分钟请求上限、额度管理。
所以那个「AI 打字很快」的体验，是服务端每秒吐几千个 token 送过来的？
对！而且不是「一次发完」，是流式地一个字一个字送过来——这就是最后一公里。
本站收获：服务化 = 把模型变成商品：量化装进单卡、批处理拉满吞吐、PagedAttention 省显存、按 token 计费——你花几毛钱，买的其实是几千张卡替你算了半秒钟。
最后一公里：到你手里
流式输出 · RAG · Agent · 缓存token 从服务器出发，穿过光纤、越过 CDN，最后变成一个一个汉字，蹦进你的聊天窗口。最后一公里，决定「体验」二字。
HTTP 连接保持打开，token 一个接一个推送：
data: {"delta": "今天"} ← 0.2 秒
data: {"delta": "天气"}
data: {"delta": "真好"}
data: {"delta": "，"}
...
data: [DONE]
你看到的「AI 边想边打字」，
其实是服务端边算边吐、客户端边收边渲染。到这里，一条 token 的完整旅程就结束了。不过现在的 AI 应用，通常还会在「模型」外面再套几层「外挂」，让它更聪明、更能干活：
- RAG（检索增强）：回答前先查资料库，把相关资料塞进上下文——AI 不再凭记忆瞎编，而是「查了再答」。
- Agent（智能体）：让模型自己规划步骤、调用工具（搜索、算数、操作软件）——从「会聊天」到「会办事」。
- MCP（工具连接协议）：统一给 AI 接工具的「插头标准」——就是你正在用的 Loomy 这种。
- 缓存 / 限流：热门问题直接复用答案，省 token 也省算力。
应用层术语
- 流式输出（SSE / Streaming）：token 逐字推送，打字机效果。
- RAG：检索增强生成——先查资料再回答，防幻觉利器。
- Agent：自主规划 + 工具调用，从问答走向行动。
- MCP：给 Agent 接工具的标准化协议。
- Prompt 工程：把需求「翻译」成模型听得懂的指令——新时代的「与人沟通」技能。
- 缓存 / 命中率：重复问题直接命中缓存，成本下降、速度提升。
师傅……这一路走下来，我鸡皮疙瘩都起来了。原来我屏幕上的每一个字，都是几万张显卡、几百亿参数、几千亿次运算，一起努力「挤」出来的。
是啊。还记得第一句话吗？算力是土，参数是种子，Token 是果实。这条链上每一环都缺一不可：没有芯片就没有算力，没有集群就没有规模，没有训练就没有知识，没有分词就没有入口，没有推理就没有生成，没有采样就没有性格，没有服务就没有商品。
你看到的「AI」，从来不是一块芯片，也不是一个模型——它是一条从硅片一路长到你屏幕上的完整的产业链。
本站收获：最后一公里 = 流式把 token 变成打字机、RAG 给模型装知识库、Agent 让 AI 会办事、MCP 统一工具插头——你的「AI 体验」，是整条链一起表演的结果。
环节 · 术语 · 人话对照表
一句话说清每个环节九站旅程的压缩包：每一环负责什么、关键术语是什么、用一句「人话」怎么理解——遇到陌生名词，按环节对号入座。
| 环节 | 核心术语 | 一句人话 |
|---|---|---|
| 算力基石 | GPU/TPU、HBM 显存、显存带宽、FP16/BF16、TFLOPS | 显卡是「一万个搬砖工」，专门干矩阵乘法 |
| 千卡集群 | NVLink、InfiniBand、数据/张量/流水线并行、3D 并行 | 几千张卡手拉手，变成一台超级机器 |
| 模型体重 | 参数、权重、Transformer、注意力、Embedding、词表 | 700 亿个数字组成的「文字接龙机」 |
| 训练 | 预训练、反向传播、梯度下降、损失、SFT、RLHF | 猜错→挨罚→微调，循环几万亿次把世界装进参数 |
| 分词 | Token、Tokenizer、词表、BPE、上下文窗口 | 把文字切成数字块——最小单位叫 Token |
| 推理 | 前向传播、自回归、注意力、KV Cache、TTFT/TPOT | 一个字一个字「挤」出来，每个字都重读一遍上文 |
| 解码采样 | 概率分布、贪心、temperature、top-p/top-k、幻觉 | 从概率表里抽签——温度决定 AI 的性格 |
| 服务化 | 推理框架、批处理、吞吐、量化、PagedAttention、按 token 计费 | 把模型包装成便宜、扛并发、按用量收费的 API |
| 最后一公里 | 流式输出、RAG、Agent、MCP、Prompt 工程、缓存 | 字一蹦一蹦上屏幕，外挂让它更聪明更能干活 |
都是几万张显卡、几百亿参数、
几千亿次浮点运算，一起努力「挤」出来的。
「AI」从来不是一块芯片，也不是一个模型，
而是一条从硅片一路长到你屏幕上的、完整的产业链。