为什么 LLM 要用 GPU？从游戏显卡到 AI 引擎

一个反直觉的事实

训练 ChatGPT 用了 上万块 NVIDIA A100 GPU。

GPU——Graphics Processing Unit——图形处理单元。一块为了让游戏画面更流畅而设计的芯片，怎么就成了 AI 革命的引擎？

语言理解和游戏画面，看起来毫无关系。但如果你拆开它们的底层，你会发现——它们在做完全一样的数学运算。

这篇文章要回答一个问题：

GPU 不知道自己在画画还是在思考，它只知道自己在做矩阵乘法。

第一章：GPU 的老本行——把三角形变成画面

3D 画面是怎么生成的

你在游戏里看到的一切——角色、建筑、爆炸特效——都是由无数个三角形拼出来的。

🎮 3D 渲染流水线
建模→顶点变换→光栅化→着色→屏幕顶点坐标 → 矩阵变换 → 像素填充 → 颜色计算 → 显示

关键数字：

场景	三角形数量	顶点数量
一个立方体	12 个	8 个
一个游戏角色	~100,000 个	~50,000 个
一帧完整画面	数百万个	数百万个
每秒 60 帧	→	每秒处理上亿个顶点

每个顶点都要经过坐标变换——旋转、缩放、透视投影——才能从 3D 空间映射到你的 2D 屏幕上。

而每一次坐标变换，就是一次矩阵乘法。

旋转一个点 = 一次矩阵乘法

这是 3D 图形学里最基础的操作：把一个点绕原点旋转 θ 度。

2D旋转就是矩阵乘法——点(1,0)绕原点旋转一圈，每一帧的新位置都是旋转矩阵乘以原坐标算出来的

看上面的动画：蓝色点 (1, 0) 经过旋转矩阵变换后，变成了橙色点。右侧实时显示矩阵计算过程——每一帧的新位置，都是矩阵 × 旧坐标算出来的。

2D 旋转公式：
┌ x' ┐   ┌ cosθ  -sinθ ┐   ┌ x ┐
│   │ = │            │ × │   │
└ y' ┘   └ sinθ   cosθ ┘   └ y ┘

在真正的 3D 游戏中也一样。下面的动画展示一个线框立方体（8 个顶点、12 条边）绕 Y 轴旋转，右侧实时显示每个顶点坐标的变化：

3D立方体绕Y轴旋转——8个顶点的每一帧新位置都是旋转矩阵乘以原坐标算出来的

游戏里物体的旋转，每一帧都是 8 次矩阵乘法。 一个游戏角色有 5 万个顶点，那就是 5 万次。

每个顶点要经历一连串矩阵乘法：

最终位置 = 投影矩阵 × 视图矩阵 × 模型矩阵 × 顶点坐标
             4×4         4×4         4×4         4×1
            (透视)      (摄像机)    (物体位置)   (原始坐标)

那一帧完整的游戏画面有多少三角形呢？

球面三角形网格——从4个三角形到数百个，三角形越多形状越光滑，计算量也越大

上面的动画展示了一个球面从粗糙到光滑的过程——三角形越多，形状越光滑，但每个三角形的顶点都要做矩阵乘法。现代游戏一帧有数百万个三角形。

关键洞察：每个顶点的变换公式完全一样，只是输入坐标不同。

一百万个顶点，同一道数学题，只是数据不同——这就是 GPU 存在的理由。

CPU vs GPU：教授 vs 全班同学

先看一个直观的对比动画——256 个计算任务，CPU 逐个处理 vs GPU 整行同时处理：

CPU串行处理vs GPU并行处理——256个方块代表计算任务，CPU一个一个点亮，GPU整行同时点亮

GPU 快不是因为单个核心更快，而是因为同时做。 一万个简单核心同时工作，碾压一个超强核心。

🧑‍🏫 CPU 方式（串行）

⬜ 顶点 1 → [变换] → ✅
⬜ 顶点 2 → [变换] → ✅
⬜ 顶点 3 → [变换中...] ⏳
⬜ 顶点 4 → [等待...]
⬜ 顶点 5 → [等待...]
⬜ ... × 100万

一个天才，一次做一道题
完成 100万个顶点需要 N 步

🏭 GPU 方式（并行）

⬜ 顶点 1 → [核心 0001] → ✅
⬜ 顶点 2 → [核心 0002] → ✅
⬜ 顶点 3 → [核心 0003] → ✅
⬜ 顶点 4 → [核心 0004] → ✅
⬜ 顶点 5 → [核心 0005] → ✅
⬜ ... × 16384 核心同时工作

一万个小学生，同时做同一道题
完成 100万个顶点只需 ~1 步

比喻：CPU 是一个数学天才，什么难题都能解，但一次只做一道。GPU 是一万个小学生，只会做乘法和加法，但同时做。当你的任务是"一百万道加法题"时，一万个小学生完胜。

第二章：GPU 的架构——为并行而生

芯片级对比

CPU 和 GPU 在设计哲学上是完全不同的物种：

CPU — 少数精英

核心 1
超强单核

核心 2
超强单核

核心 3
超强单核

核心 4
超强单核

大缓存 + 复杂控制逻辑
分支预测、乱序执行、虚拟化...

4~24 核，每核都很强大
擅长：复杂逻辑、分支判断

GPU — 大规模军团

超高带宽显存 (HBM/GDDR6)
简单控制，海量算力

数千~万核，每核都很简单
擅长：相同运算 × 海量数据

关键数字对比

指标	CPU (i9-14900K)	GPU (RTX 4090)	倍数
核心数	24	16,384	~680×
时钟频率	6.0 GHz	2.5 GHz	0.4×
内存带宽	90 GB/s	1,008 GB/s	11×
FP32 算力	~1 TFLOPS	83 TFLOPS	83×
功耗	253W	450W	1.8×

注意：GPU 的时钟频率反而更低。它不靠单核速度取胜，而是靠数量碾压。

每瓦性能在矩阵运算上，GPU 完胜。

CUDA：让 GPU 不只画画

2006 年，NVIDIA 做了一个改变历史的决定：发布 CUDA（Compute Unified Device Architecture）。

在此之前，GPU 只能通过图形 API（OpenGL、DirectX）来编程——你只能告诉它"画一个三角形"，不能让它做任意数学计算。

CUDA 打破了这个限制。它让程序员可以用类 C 语言直接在 GPU 上运行任意代码。GPU 从"只能画图的专用芯片"变成了"通用并行计算引擎"。

2006 年的 CUDA，是 AI 革命的基础设施转折点。 没有它，就没有后来 AlexNet 的突破，就没有深度学习的爆发，就没有 ChatGPT。

第三章：LLM 里全是矩阵乘法

GPU 这么擅长矩阵运算，那 LLM 里有多少矩阵运算呢？

答案是：几乎全是。

第一步：Embedding——把词变成向量

在进入 Transformer 之前，每个词（token）首先要通过 Embedding 查表，变成向量空间中的一个点：

Embedding向量空间——King、Queen、Man、Woman四个词在2D空间中的位置，展示向量关系 King-Man+Woman≈Queen

上面的动画展示了经典的词向量类比关系：King - Man + Woman ≈ Queen。这不是巧合，而是因为 Embedding 矩阵在训练中学到了语义关系。Embedding 本质上就是一次矩阵查表——用 token ID 去索引一个巨大的矩阵。

Transformer 一层的计算流程

一个 Transformer Block（无论 GPT、Claude 还是 DeepSeek 都在用）的内部，是这样的：

Transformer 一层 = 8 次矩阵乘法

输入 X [seq_len × d_model]
  │
  ├→ X × WQ = Q  矩阵乘法 ①
  ├→ X × WK = K  矩阵乘法 ②
  ├→ X × WV = V  矩阵乘法 ③
  │
  ├→ Q × KT = Scores  矩阵乘法 ④
  ├→ softmax(Scores) × V = Attn  矩阵乘法 ⑤
  │
  ├→ Attn × WO = Output  矩阵乘法 ⑥
  │
  ├→ X × W1 → GELU  矩阵乘法 ⑦
  └→       × W2 = FFN out  矩阵乘法 ⑧
  │
输出 [seq_len × d_model]

一层 Transformer = 8 次大矩阵乘法。

其中矩阵乘法 ⑦⑧ 就是 MLP 层——Transformer 的"思考肌肉"。下面的动画展示了 MLP 的核心过程：

MLP升维降维过程——4维向量经W1矩阵升到16维，GELU激活筛选后，再经W2矩阵降回4维

MLP 就是：升维 → 筛选 → 降维，核心是两次矩阵乘法。 升维让模型有更大的空间去"思考"，GELU 激活函数筛掉不重要的特征，降维把结果压缩回原来的维度。

那 GPT-3 有 96 层，所以：

模型	层数	每次推理矩阵乘法次数
GPT-2 small	12	96
GPT-2 large	36	288
GPT-3	96	768
GPT-4 (估算)	~120	~960

生成每一个 token，都要把这几百次矩阵乘法从头跑一遍。

一次矩阵乘法有多少计算？

以 GPT-2 的一个全连接层为例：

输入 × 权重 = 输出
[512×768] × [768×768] = [512×768]

这一次乘法包含：
  512 × 768 × 768 = 301,989,888 次乘法
                   ≈ 3 亿次浮点运算

而这只是一层里 8 个矩阵乘法中的一个！

实际数字：GPT-3 生成一个 token 的计算量

GPT-3 (175B 参数) 生成 1 个 token

~350 GFLOP

每个 token 的计算量
(3500 亿次浮点运算)

~1.1 ms

A100 GPU 耗时
(312 TFLOPS 算力)

~350 秒

CPU 耗时
(~1 TFLOPS 算力)

生成一段 500 token 的回复：
GPU ≈ 0.6 秒 | CPU ≈ 48 小时

如果用 CPU 来跑 GPT-3，你问它一个问题，要等两天才能收到回复。

这就是为什么 LLM 必须用 GPU。

第四章：游戏画面 vs LLM——同一个本质

现在我们可以把两件事放在一起看了：

🎮 3D 游戏

📐 百万个顶点
🔢 每个做 4×4 矩阵乘法
🔄 所有顶点同一个公式
🕐 每秒 60 帧
🖼️ 结果 = 一帧画面

✅ 大规模并行
✅ 相同操作重复
✅ 计算密集
✅ 矩阵运算为主

🤖 LLM 推理

🧮 百万个参数
🔢 每层做 d×d 矩阵乘法
🔄 所有 token 同一个公式
🕐 每秒数十个 token
💬 结果 = 下一个词

✅ 大规模并行
✅ 相同操作重复
✅ 计算密集
✅ 矩阵运算为主

同一种数学 → 同一种硬件 → 不同的奇迹

GPU 不知道它在渲染一个爆炸场景还是在回答"量子力学是什么"。对它来说，这两件事在硅片上的操作是一样的：从显存读取矩阵 → 做大量乘加运算 → 写回结果。

这就是为什么一块"游戏显卡"能成为 AI 引擎的原因——不是偶然的跨界，而是数学本质的一致性。

第五章：从 AlexNet 到 H100——GPU 如何成为 AI 的心脏

GPU 成为 AI 核心硬件不是一夜之间发生的，而是一条跨越 20 年的路：

2006 — CUDA 发布

NVIDIA 让 GPU 可以做通用计算。当时几乎没人关注。

2012 — AlexNet 震惊世界

用 2 块 GTX 580 GPU 训练的神经网络，碾压所有传统方法赢得 ImageNet 竞赛。
深度学习 + GPU 的组合第一次证明了自己。

2017 — Transformer 诞生

Google 发表 "Attention Is All You Need"。Transformer 的核心操作——
矩阵乘法——完美匹配 GPU 架构。

2018 — V100 + Tensor Core

NVIDIA 推出专为矩阵乘法设计的硬件单元 Tensor Core。GPU 从"也能做 AI"变成"专门做 AI"。

2020 — GPT-3 发布

OpenAI 用上万块 V100 训练 1750 亿参数模型。GPU 集群成为 AI 实验室的标配。

2022 — ChatGPT 引爆 AI 革命

NVIDIA 股价起飞。A100/H100 一卡难求，黑市价翻倍。

2023 — NVIDIA 市值破万亿

一家"显卡公司"成为全球最值钱的公司之一。Jensen Huang 从"卖游戏显卡的"变成了"AI 教父"。

2024-2025 — Blackwell 架构

B200/GB200 专为大模型设计：FP4 精度、NVLink 互联、单卡 20 PFLOPS AI 算力。

第六章：动手验证——在 VM 上跑矩阵乘法

以下 Demo 在本文作者的 AI Lab VM（8 核 CPU, 无 GPU）上实测。

实验 1：纯 Python vs PyTorch 矩阵乘法

纯 Python 64×64 矩阵乘法: 25.5 ms
  → 如果算 4096×4096: 预估 ≈ 112 分钟!

PyTorch CPU (BLAS 优化):
   矩阵大小         耗时      加速比
   64×64         0.01ms    2,378×
   256×256       0.11ms   14,306×
   1024×1024     4.75ms   21,995×
   4096×4096   287.15ms   23,305× 🚀

同样是 CPU，用了优化的线性代数库（BLAS）后，快了 2 万倍。 GPU 还会在此基础上再快几十到上百倍。

实验 2：模拟 Transformer 一层的运算

模拟 GPT-2 small 配置（d_model=768, seq_len=512）：

  操作                   矩阵形状                        耗时
  Q = X × W_Q          [512×768]×[768×768]              1.40ms
  K = X × W_K          [512×768]×[768×768]              1.42ms
  V = X × W_V          [512×768]×[768×768]              1.31ms
  Scores = Q × Kᵀ      [512×768]×[768×512]              7.63ms
  Attn = Scores × V    [512×512]×[512×768]              0.80ms
  Out = Attn × W_O     [512×768]×[768×768]              1.37ms
  FFN_up = X × W₁      [512×768]×[768×3072]             4.66ms
  FFN_down = h × W₂    [512×3072]×[3072×768]            4.93ms
  ─────────────────────────────────────────────────────────────
  合计 (一层)                                           23.52ms

  GPT-2 有 12 层 → 总计 ≈ 282ms
  GPT-3 有 96 层, d=12288 → 计算量是这个的 ~24,000 倍

8 个矩阵乘法，占了 Transformer 一层几乎全部的计算量。其他操作（LayerNorm、softmax、GELU）相比之下微不足道。

实验 3：矩阵乘法的可并行度

1024×1024 矩阵:
  矩阵乘法 (A @ B):   4.35ms   (493 GFLOPS)
  逐元素乘 (A * B):   2.30ms   (0.46 GFLOPS)

矩阵乘法的运算量是逐元素乘的 1024×
但耗时只多了 1.9×

运算量多了 1024 倍，耗时只多了 2 倍。 这就是矩阵乘法的可并行优化能力——每一个乘加操作都是独立的，可以同时做。这正是 GPU 的天赐之粮。

Demo 脚本: ~/demo_gpu_matmul.py，可在 VM 上直接运行复现以上数据。

第七章：不只是快——GPU 生态为何不可替代

GPU 成为 AI 的标准计算平台，不仅因为硬件快，更因为十几年积累的软件生态：

层次	代表	作用
硬件	Tensor Core	专门做矩阵乘法的硬件单元，比通用 CUDA 核心再快数倍
数学库	cuBLAS	针对 NVIDIA GPU 深度优化的线性代数库
深度学习库	cuDNN	卷积、Attention 等操作的 GPU 加速实现
推理优化	TensorRT	模型部署时的图优化、量化、内核融合
框架层	PyTorch CUDA	一行 `.cuda()` 就把计算从 CPU 搬到 GPU
通信	NCCL / NVLink	多卡训练时 GPU 之间的高速互联

这套生态经过 十几年积累，形成了 NVIDIA 的护城河。

竞争者在追赶

平台	厂商	现状
ROCm	AMD	硬件不差，但软件生态远不如 CUDA
TPU	Google	Transformer 推理极快，但只在 Google Cloud 上可用
昇腾	华为	国产替代方案，在国内快速推进
Trainium/Inferentia	AWS	亚马逊自研，生态刚起步
Apple Silicon	Apple	统一内存很有潜力，训练生态待完善

目前的现实是：如果你要训练或部署大模型，NVIDIA GPU 仍然是最稳妥的选择。

一个常被忽视的瓶颈：显存带宽

很多人以为 GPU 快是因为算力大。但在大模型推理中，真正的瓶颈往往不是算力，而是内存带宽。

推理时的数据流：
  显存 → GPU 核心 → 计算 → 写回显存
         ↑
    这一步才是瓶颈！
    (memory-bound，而非 compute-bound)

GPT-3 的 175B 参数 = 350GB (FP16)
每生成一个 token，要把这 350GB 参数全读一遍

A100 显存带宽: 2 TB/s → 理论上 175ms/token
H100 显存带宽: 3.35 TB/s → 理论上 104ms/token
CPU 内存带宽: 0.09 TB/s → 理论上 3,889ms/token

GPU 的显存带宽是 CPU 的 20~40 倍，这是大模型推理速度差异的另一个关键来源。

总结：一句话回答标题

GPU 本来是为了每秒把百万个三角形顶点做矩阵变换、渲染成游戏画面而设计的。
LLM 恰好也需要每秒对百万个参数做矩阵乘法、推算出下一个词。
同一种数学，同一种硬件，不同的奇迹。

全文逻辑链

3D 游戏需要
大量顶点变换 → 顶点变换
= 矩阵乘法 → GPU 为
并行矩阵乘而生 → LLM 也全是
矩阵乘法 → 所以 LLM
用 GPU

参考文献

NVIDIA, CUDA C Programming Guide, docs.nvidia.com/cuda
Vaswani et al., “Attention Is All You Need”, NeurIPS 2017, arXiv:1706.03762
Krizhevsky et al., “ImageNet Classification with Deep Convolutional Neural Networks” (AlexNet), NeurIPS 2012
Brown et al., “Language Models are Few-Shot Learners” (GPT-3), NeurIPS 2020, arXiv:2005.14165
Andrej Karpathy, “Let’s build GPT: from scratch, in code, spelled out”, YouTube, 2023
Horace He, “Making Deep Learning Go Brrrr From First Principles”, 2022, horace.io
Tim Dettmers, “Which GPU for Deep Learning?”, 2023, timdettmers.com
NVIDIA, “How GPU Computing Works”, GTC 2021

本文 Demo 脚本可在 AI Lab VM 上直接运行：python3 ~/demo_gpu_matmul.py

一个反直觉的事实#

第一章：GPU 的老本行——把三角形变成画面#

3D 画面是怎么生成的#

旋转一个点 = 一次矩阵乘法#

CPU vs GPU：教授 vs 全班同学#

第二章：GPU 的架构——为并行而生#

芯片级对比#

关键数字对比#

CUDA：让 GPU 不只画画#

第三章：LLM 里全是矩阵乘法#

第一步：Embedding——把词变成向量#

Transformer 一层的计算流程#

一次矩阵乘法有多少计算？#

实际数字：GPT-3 生成一个 token 的计算量#

第四章：游戏画面 vs LLM——同一个本质#

第五章：从 AlexNet 到 H100——GPU 如何成为 AI 的心脏#

第六章：动手验证——在 VM 上跑矩阵乘法#

实验 1：纯 Python vs PyTorch 矩阵乘法#

实验 2：模拟 Transformer 一层的运算#

实验 3：矩阵乘法的可并行度#

第七章：不只是快——GPU 生态为何不可替代#

竞争者在追赶#

一个常被忽视的瓶颈：显存带宽#

总结：一句话回答标题#

参考文献#