计算机底层概念速查（零基础版）
这份文档不预设你会写代码。你只需要知道"计算机能存东西、能算东西"，其他一切从零讲起。
你的目标是看懂 AI 学习文档里出现的 FP16、BF16、量化、显存……这些词到底在说什么。
碰不懂的词 Ctrl+F 搜。
目录
- 计算机到底是什么
- 比特：计算机只认识 0 和 1
- 字节：8 个比特捆在一起
- 整数在计算机里怎么存
- 浮点数：怎么存小数
- FP32 vs FP16 vs BF16：三种精度
- 内存（RAM）和显存（VRAM）
- 量化：用低精度省空间
- 为什么精度越低越省资源
- 附录：概念速查表
计算机到底是什么
在往下看之前先统一一个画面：
计算机 = 硬件（能摸到的铁盒子、芯片、电路板）+ 软件（你看不到但屏幕上看得到的那些东西——浏览器、游戏、微信，它们本质上是一串指令，告诉硬件"做什么"）。
你双击一个软件图标，硬盘里存着的一长串指令就被搬到内存里，CPU 开始逐条执行。AI 模型也不例外——它本质上就是一个特别大的"数据文件"（比如 100 GB），被一个叫"推理引擎"的软件加载到显存里，然后你问它问题，它给你回答。
本文只讲硬件层面的事——计算机怎么存数字、为什么存数字还有"精度"的区别。
比特：计算机只认识 0 和 1
一根电线，两个状态
计算机内部是一大堆电路。一根电线的电压要么是高（比如 3V），要么是低（比如 0V）。高电压代表 1，低电压代表 0。
这就是"二进制"的物理本质——不是计算机"喜欢"二进制，而是电路只分得清"有电/没电"两种状态。
一个 0 或 1 叫一个 比特（bit），信息的最小单位。
为什么不用十进制？
如果你想让一根电线表示 0 到 9 十种状态，你需要精确区分 10 档电压（0V、0.3V、0.6V……3V）。电流稍微波动一下就分不清 4 还是 5 了。只区分"有"和"没有"，抗干扰能力极强。
比特组合表示更多东西
1 个比特 → 2 种可能：0 1 2 个比特 → 4 种可能：00 01 10 11 3 个比特 → 8 种可能：000 001 010 011 100 101 110 111
每多一个比特，可能性翻倍。8 个比特有 256 种组合，32 个比特有约 43 亿种组合。
字节：8 个比特捆在一起
为什么是 8 个？
历史原因——早期计算机要存英文字符。26 个大写 + 26 个小写 + 10 个数字 + 标点符号 ≈ 100 个字符，刚好可以用 7 位表示（2^7 = 128 种组合，这叫 ASCII 码）。再加一位校验位，凑成 8 位，就是 1 字节（byte）。
1 字节 = 8 比特。这个约定沿用至今。
常用单位换算（用生活中的东西感受一下大小）
1 字节 (B) = 8 比特 → 存一个英文字母（比如 'A'）
1 KB = 1024 字节 → 一篇短文
1 MB = 1024 KB → 一张手机拍的照片
1 GB = 1024 MB → 一部高清电影
1 TB = 1024 GB → 一块移动硬盘的容量为什么是 1024 而不是 1000？因为 1024 = 2^10，计算机里的计数天生按 2 的幂走。硬盘厂商有时用 1000，所以买的"1TB 移动硬盘"插上显示 ~931GB——没被坑，只是计数标准不同。
这和 AI 有什么关系
一个 671B 参数的 AI 模型（比如 DeepSeek V4），如果每个参数用 2 字节（BF16 精度）存：
671 × 10^9 × 2 字节 = 1342 GB ≈ 1.3 TB
光是"存下"这个模型，就能塞满一块移动硬盘。训练时还要额外存梯度（帮助模型进步的信息）和优化器状态（记录每个参数最近怎么调的），实际空间需求再翻几倍。所以训练大模型需要几百 GB 甚至上 TB 的显存，一张显卡根本装不下——这就是第三阶段讲"分布式训练"的原因。
整数在计算机里怎么存
二进制转十进制（感受一下即可）
二进制每一位代表 2 的幂次方。从右往左：第 0 位是 1，第 1 位是 2，第 2 位是 4，第 3 位是 8……
1 0 1 1 0
│ │ │ │ └─ 第 0 位: 0 × 1 = 0
│ │ │ └─── 第 1 位: 1 × 2 = 2
│ │ └───── 第 2 位: 1 × 4 = 4
│ └─────── 第 3 位: 0 × 8 = 0
└───────── 第 4 位: 1 × 16 = 16
总和 = 0 + 2 + 4 + 0 + 16 = 2210110（二进制）= 22（日常数字）。不要求手算——知道"每位是 2 的幂"就够了。
几种整数类型
用更多位就能存更大的数：
| 类型 | 位数 | 能表示的范围 | 类比 |
|---|---|---|---|
| INT8 | 8 位 | -128 ~ 127 | 一个字节就能装的数 |
| INT16 | 16 位 | -32,768 ~ 32,767 | 够存屏幕分辨率（1920×1080） |
| INT32 | 32 位 | -21 亿 ~ 21 亿 | 够存地球人口 |
| INT64 | 64 位 | ±9.2 × 10^18 | 什么整数都够 |
AI 在回答用户问题时（推理），常用 INT8 甚至 INT4（只有 4 位！）存储模型参数——本来 FP16 每个参数占 2 字节，压到 INT4 只占 0.5 字节，模型瘦身到 1/4，回答质量几乎不变。
浮点数：怎么存小数
类比：科学计数法
计算器上见过这种写法：6.02 × 10²³。它由三部分构成：
- 符号：正数还是负数
- 有效数字：6.02
- 指数：23（决定小数点位置）
浮点数用完全一样的思路，只不过底数不是 10 而是 2。
FP32 的"内部结构"
一个 32 位浮点数（FP32）占 4 个字节，布局如下：
- 符号位（1 位）：0 = 正，1 = 负
- 指数（8 位）：决定"小数点往哪移"
- 尾数（23 位）：有效数字，决定有多精确
数值 = (-1)^符号 × 1.尾数 × 2^指数
走一个具体例子：存数字 6.5
6.5 写成二进制是 110.1（6 = 110，0.5 = 0.1）。
写成科学计数法：1.101 × 2²（小数点左移两位，所以指数 = 2）。
然后填入 FP32：
- 符号 = 0（正数）
- 指数 = 129（实际存储时加了一个固定偏移 127，2+127=129）
- 尾数 = 101 后面补 20 个零
拼起来就是 32 个 0 和 1：01000000110100000000000000000000
不要求手算。只需要记住一件事：位数是有限的，所以精度也是有限的。就像十进制 1/3 = 0.3333... 永远写不完，二进制里很多小数也写不完，只能存个近似值。
为什么 0.1 + 0.2 有时候不等于 0.3？
在任何一台计算机上算 0.1 + 0.2，结果可能是 0.30000000000000004，不是精确的 0.3。
这不是 bug。原因很简单：0.1 和 0.2 在二进制里都是无限循环小数（就像十进制的 1/3 写不完），FP32 只能存 23 位尾数，后面截断。两个近似值加起来，误差就更明显了。
日常生活用计算器你感觉不到，因为计算器会四舍五入显示。但 AI 训练涉及几千亿次运算，累积误差就不能完全忽视——这也是训练时用高精度（FP32/BF16），而回答问题时允许降精度（INT8）的原因之一。
FP32 vs FP16 vs BF16：三种精度
三者对比
| 类型 | 总位数 | 指数位 | 尾数位 | 能表示的范围 | 有多精确 |
|---|---|---|---|---|---|
| FP32 | 32 位 | 8 位 | 23 位 | 超大~超小 | 高（约 7 位有效数字） |
| FP16 | 16 位 | 5 位 | 10 位 | 最大才 65504 | 一般 |
| BF16 | 16 位 | 8 位 | 7 位 | 和 FP32一样大 | 还行（约 2 位有效数字） |
FP16 的问题：装不下大数
FP16 的指数只有 5 位，能表示的最大值才 65504。AI 训练过程中，很多中间计算结果（梯度）远超这个数。指数装不下 → 数值变成"无穷大"（NaN）→ 训练崩掉。这就是第三阶段文档里"损失尖峰"的常见原因。
BF16 的妙处
BF16 做了一个聪明的取舍：砍尾数（精度），保指数（范围）。
结果：
- 数值范围和 FP32 一样大（不会突然溢出崩掉）
- 精度比 FP16 稍低一点，但训练完全够用
- 占 2 字节，比 FP32 省一半空间
打个比方：π 的值是 3.1415926535... BF16 只存"3.14"（精度低但大小对），FP16 想把 π × 10¹⁰⁰ 这个巨大的数装进只能装到 65504 的口袋——直接撑破。
效果：BF16 训出来的模型和 FP32 几乎一样好，但省一半显存，速度更快。 2026 年主流 GPU（H100 等）都有专门的 BF16 硬件加速，不用 BF16 反而是浪费。
内存（RAM）和显存（VRAM）
内存（RAM）
你打开一个软件（比如浏览器），它就从硬盘被"搬"到了内存。内存是电脑正在做事时的临时工作台——关机就清空。
CPU 直接读写内存。普通笔记本 16-32 GB，AI 训练服务器 1-2 TB。
显存（VRAM）
显卡（GPU）自带专用内存，比普通内存快得多，但容量更小。GPU 只能直接读写自己的显存，不能直接用系统内存。
一张 H100 显卡有 80 GB 显存。前面算了，一个 671B 模型光存参数就要 ~1.3 TB——一张卡根本放不下。所以必须拆开分散到多张卡、多台机器上。
内存层次一览
关键瓶颈在中间那道红线——CPU 内存 ↔ GPU 显存走的是 PCIe 通道，速度 ~64 GB/s，比 GPU 内部（3.35 TB/s）慢 50 倍，比 GPU 之间互联（NVLink 900 GB/s）慢 14 倍。
所以 AI 训练时数据必须尽量待在显存里，来回搬运就是自废武功。
量化：用低精度省空间
一句话
量化 = 用低精度格式存数字，用一点点精度换巨大的空间和速度。
类比：照片压缩
原始照片（RAW，50 MB）→ JPEG 压缩（2 MB）。你看起来几乎一样，但文件小了 25 倍。
量化就是给 AI 模型参数做"JPEG 压缩"：FP32（每参数 4 字节）→ INT8（1 字节）→ INT4（0.5 字节），体积骤降，回答质量几乎不变（尤其是大模型）。
4-bit 只能表示 16 个数，怎么存小数？
INT4 只有 4 个比特，一共 16 种组合，能表示 -8 到 7 的整数。怎么用它表示原来 FP16 里 -3.0 到 3.0 之间各种小数？
做法：按比例缩放。
FP16 原始范围: -3.0 ··········· 0 ··········· 3.0
↕ ↕ ↕
INT4 档位: -8 ··· 0 ··· 7找一个缩放因子（比如 3.0 ÷ 7 ≈ 0.429），那么：
- INT4 的 3 → 代表 FP16 的 3 × 0.429 ≈ 1.29
- INT4 的 -8 → 代表 FP16 的 -8 × 0.429 ≈ -3.43
存的只是 INT4 的 4 位数据 + 一个缩放因子（FP16 数，很小）。用的时候把 INT4 值乘回缩放因子，就还原出近似的原始值。
QLoRA 用的 NF4 更聪明
普通 INT4 均匀分段（每个区间一样宽）。但 AI 模型的参数通常集中在 0 附近，很大或很小的参数极少。
NF4（NormalFloat 4-bit）把分段做成了"不均匀"——0 附近分得特别密，越远越稀疏。这样珍贵的 16 个档位更多地分配给"常住区域"，精度损失更小。
QLoRA 正是靠 NF4 把模型压到 4-bit，再加 LoRA 微调，做到了一张 48GB 显卡微调 650 亿参数模型。
量化实际效果
| 精度 | 每参数大小 | 70B 模型占用空间 | 回答质量 |
|---|---|---|---|
| FP32 | 4 字节 | ~280 GB | 基准 |
| FP16/BF16 | 2 字节 | ~140 GB | 几乎不变 |
| INT8 | 1 字节 | ~70 GB | 轻微下降 |
| INT4 | 0.5 字节 | ~35 GB | 有点下降（大模型几乎感觉不到） |
模型越大，量化越不伤质量。 因为大模型参数本来就有很多冗余，精度损失被大量参数分摊了。
为什么精度越低越省资源
省的不只是空间
| 方面 | FP32 | INT4 | 效果 |
|---|---|---|---|
| 空间 | 1× | ~1/8× | 更大模型装进更小显存 |
| 速度 | 1× | ~2-4× | 同一时间算更多东西 |
| 搬运成本 | 1× | ~1/8× | 数据进出更省时间 |
为什么低精度算得快？
GPU 芯片上有专门的"计算单元"。一个 FP32 乘法器占的芯片面积，能塞好几个 INT4 乘法器。同一块芯片、同一秒钟，低精度能并行算更多次——物理规律决定的。
H100 显卡的实际算力：
- FP32：~60 TFLOPS（万亿次运算/秒）
- FP16/BF16（专用加速单元）：~990 TFLOPS
- INT8：~1980 TFLOPS
差了 30 多倍。
实际怎么选
- 训练（让 AI 学习）：BF16 是 2026 年主流。又快又稳。
- 推理（你问 AI 问题，它回答）：INT8/INT4 是标配。省显存、快响应。
- 微调（给训练好的模型补点知识）：QLoRA 的 NF4 方案让普通人用一张游戏显卡就能做。
为什么 GPU 比 CPU 擅长 AI 计算
前面说了 H100 的 INT8 算力是 FP32 的 30 多倍，但还没回答一个更基本的问题：为什么 GPU 一开始就比 CPU 快？
1. 并行度：几千个核心 vs 几个核心
CPU（比如 Intel i9）有 8-24 个"大核"，每个都极度聪明——能乱序执行、分支预测、虚拟内存管理。设计目标是"单线程跑得快"。
GPU（比如 H100）有几千个"小核"（CUDA Core），每个单独拿出来比 CPU 核心弱很多，但胜在数量多。设计目标是"几千个任务同时做"。
类比：CPU = 8 个教授解 8 道复杂数学题。GPU = 2000 个小学生每人算一道 2+3。如果你需要算 2000 道 2+3，小学生们瞬间搞定，教授们得排队。
AI 的核心运算是矩阵乘法——把一个 4096×4096 的矩阵和另一个 4096×4096 的矩阵相乘。这一下就产生了几百万个独立的乘法和加法——刚好是 GPU 最喜欢的"大量简单任务同时做"场景。
2. Tensor Core：一个时钟周期算完一个矩阵小块
普通 GPU 核心（CUDA Core）一次只能算一个乘法和一个加法。Tensor Core 是 NVIDIA 从 Volta 架构（2017）开始加的专用硬件，一次能算完一个 4×4 小矩阵的乘加运算。一个时钟周期完成 64 次乘加——这就是上面数据里 FP16 算力是 FP32 的 16 倍的原因。不是"FP32 算得慢"，是 Tensor Core 专门为 FP16/INT8 加速了。
3. 内存带宽：喂数据的速度决定实际算多快
AI 计算有一个反直觉的事实：瓶颈通常不是计算，是喂数据。 一个矩阵乘法本身只需要几微秒，但把两个 4096×4096 矩阵从显存搬到计算单元的时间可能是计算的 10 倍以上。
GPU 显存带宽（H100：3.35 TB/s）是 CPU 内存带宽（DDR5：~50 GB/s）的 ~70 倍。所以即使 CPU 有同样的计算能力，数据来不及喂也是白搭。
一句话总结：GPU = 几千个小核心 + 矩阵专用加速器 + 超高带宽显存，三个因素叠加，让它做 AI 计算比 CPU 快几十到几百倍。
附录：概念速查表
| 你看到的 | 中文名 | 一句话 | 出现在哪 |
|---|---|---|---|
| 比特 bit | 位 | 0 或 1，信息最小单位 | 本文 |
| 字节 byte | 字节 | 8 个比特，存一个字母 | 本文 |
| KB / MB / GB / TB | 存储单位 | 每级翻 1024 倍 | 第三阶段·显存计算 |
| 二进制 | 二进制 | 用 0 和 1 计数 | 本文 |
| FP32 | 32 位浮点数 | 4 字节，训练基准精度 | 第三阶段·训练精度 |
| FP16 | 16 位浮点数 | 2 字节，范围小易溢出 | 第三阶段·损失尖峰 |
| BF16 | Brain Float 16 | 2 字节，范围=FP32，训练主流 | 第三阶段·训练精度 |
| INT8 / INT4 | 8 位/4 位整数 | 量化后的低精度格式 | 第三阶段·QLoRA |
| 量化 | Quantization | 高精度压到低精度，省空间 | 第三阶段·QLoRA |
| NF4 | 正态分布 4 位量化 | 0 附近分得更密 | 第三阶段·QLoRA |
| RAM | 内存 | CPU 临时工作台，关机清空 | 第三阶段·训练硬件 |
| VRAM | 显存 | GPU 临时工作台，快但贵 | 第三阶段·训练硬件 |
| H100 | NVIDIA 显卡 | 2026 年 AI 训练标配 | 第三阶段·GPU 集群 |
| NVLink | GPU 间高速互联 | 机器内 GPU 通信，900 GB/s | 第三阶段·GPU 集群 |
| InfiniBand | 服务器间高速网络 | 机器间通信，400 GB/s | 第三阶段·GPU 集群 |
| FLOPS | 每秒浮点运算次数 | 算力的度量单位 | 第三阶段·训练成本 |
| CUDA Core | GPU 通用计算核心 | 一次算一个乘加，几千个同时工作 | 本文·GPU vs CPU |
| Tensor Core | GPU 矩阵专用核心 | 一个周期算完 4×4 矩阵乘加 | 本文·GPU vs CPU |
| 内存带宽 | Memory Bandwidth | 每秒能读写多少数据，通常比计算更瓶颈 | 本文·GPU vs CPU |
| 推理 | Inference | 你问 AI，它回答 | 第三阶段 |
| 训练 | Training | 让 AI 学习数据的过程 | 第三阶段 |
参考文献与图片来源
- IEEE 754-2019 — IEEE Standard for Floating-Point Arithmetic, 2019. https://ieeexplore.ieee.org/document/8766229
- N. Burgess et al., "Bfloat16: The secret to high performance on Cloud TPUs", Google Cloud Blog, 2019. https://cloud.google.com/blog/products/ai-machine-learning/bfloat16-the-secret-to-high-performance-on-cloud-tpus
- T. Dettmers et al., "QLoRA: Efficient Finetuning of Quantized Language Models", NeurIPS 2023. https://arxiv.org/abs/2305.14314
- T. Dettmers et al., "8-bit Optimizers via Block-wise Quantization", ICLR 2022. https://arxiv.org/abs/2110.02861
- NVIDIA H100 Tensor Core GPU Architecture, 2022. https://resources.nvidia.com/en-us-tensor-core/gtc22-whitepaper-hopper