第一章：GPU 架构——为什么 GPU 是 AI 推理的最优硬件

在理解 AI 推理优化之前，必须理解 GPU 的工作原理。不懂硬件的工程师，优化推理就像不懂发动机的赛车手——只能靠直觉，无法真正突破瓶颈。

一、CPU 和 GPU 的根本差异

CPU：为串行任务优化

CPU 的设计哲学：尽可能快地完成单个任务

结构：
- 少量核心（8-64 个）
- 每个核心：超强的单线程性能
- 大量的控制逻辑（分支预测、乱序执行）
- 大容量缓存（L1/L2/L3 Cache，MB 级别）

适合任务：
- 操作系统调度
- 数据库查询
- 网络请求处理
- 任何需要复杂控制流的任务

GPU：为并行任务优化

GPU 的设计哲学：同时执行数千个简单任务

结构：
- 大量核心（NVIDIA H100：18,432 个 CUDA Cores）
- 每个核心：简单，低单线程性能
- 最少的控制逻辑
- 高带宽内存（HBM，TB/s 级别）

适合任务：
- 矩阵乘法（神经网络的核心运算）
- 图像处理
- 物理模拟
- 任何"对大量数据做相同操作"的任务

为什么神经网络天然适合 GPU

# Transformer 的核心运算：矩阵乘法
# 推理时，每一层都在做类似的计算：
output = input_matrix @ weight_matrix  # 矩阵乘法

# 对于 BERT-base（768 维，512 tokens）：
# 每次前向传播需要 ~ 10^9 次浮点运算（1 GFLOPS）
# CPU（单线程，100 GFLOPS）：~10ms
# GPU（H100，4000 TFLOPS）：~0.25μs（理论值）

# 实际差距：GPU 推理比 CPU 快 100-1000 倍

二、CUDA 并行计算模型

CUDA 是 NVIDIA 的并行计算平台，理解它是理解所有 GPU 加速框架的基础。

层次结构

GPU 硬件层次：
  GPU
  └── SM (Streaming Multiprocessor)  ← 72个（H100 SXM）
      ├── CUDA Cores（执行 FP32 运算）
      ├── Tensor Cores（执行矩阵乘法，AI专用）
      └── 共享内存（SRAM，高速）

CUDA 软件层次（对应硬件）：
  Grid
  └── Block（映射到 SM）
      └── Thread（映射到 CUDA Core）

# 简单的 CUDA 内核示例（理解概念，实际 AI 框架屏蔽了这层）
# Python 中用 cupy 库体验 CUDA 并行

import cupy as cp

# 在 GPU 上执行的函数
vector_add_kernel = cp.RawKernel(r'''
extern "C" __global__ void vector_add(float* a, float* b, float* c, int n) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) {
        c[idx] = a[idx] + b[idx];  // 每个线程处理一个元素
    }
}
''', 'vector_add')

n = 1_000_000
a = cp.random.rand(n, dtype=cp.float32)
b = cp.random.rand(n, dtype=cp.float32)
c = cp.zeros(n, dtype=cp.float32)

# 启动 1000 个 Block，每个 Block 1024 个 Thread
# 总共 1,024,000 个线程并行执行
vector_add_kernel((1000,), (1024,), (a, b, c, n))

Tensor Cores——AI 加速的秘密武器

传统 CUDA Core：执行标量运算（一次处理 1 个数）
Tensor Core：专门执行矩阵乘法（一次处理 4x4 矩阵）

性能对比（A100 SXM4）：
  FP32（CUDA Core）：19.5 TFLOPS
  TF32（Tensor Core）：312 TFLOPS  ← 16x 提升！
  FP16（Tensor Core）：312 TFLOPS
  INT8（Tensor Core）：624 TOPS   ← 量化后 32x 提升！

这就是为什么：
1. PyTorch 默认用 FP32，但推理用 FP16 快很多
2. INT8 量化不只节省显存，还显著提升速度
3. H100 比 A100 快，主要因为更多/更强的 Tensor Core

三、显存（VRAM）——推理的第一瓶颈

为什么显存是关键

# 模型参数的显存占用计算
def calc_model_vram(params_billion: float, dtype: str) -> float:
    bytes_per_param = {
        "fp32": 4,
        "fp16": 2,
        "bf16": 2,
        "int8": 1,
        "int4": 0.5  # 实际用 GPTQ/AWQ 量化
    }
    bytes_per = bytes_per_param[dtype]
    vram_gb = params_billion * 1e9 * bytes_per / (1024**3)
    return vram_gb

# 常见模型的显存需求
models = {
    "Llama-3-8B": 8,
    "Llama-3-70B": 70,
    "Llama-3-405B": 405,
    "GPT-3": 175,
}

print("模型显存需求（GiB）：")
print(f"{'模型':25} {'FP16':>8} {'INT8':>8} {'INT4':>8}")
for name, params in models.items():
    fp16 = calc_model_vram(params, "fp16")
    int8 = calc_model_vram(params, "int8")
    int4 = calc_model_vram(params, "int4")
    print(f"{name:25} {fp16:>7.1f}G {int8:>7.1f}G {int4:>7.1f}G")

# 输出：
# Llama-3-8B          14.9G     7.5G     3.7G
# Llama-3-70B        130.4G    65.2G    32.6G
# Llama-3-405B       754.0G   377.0G   188.5G

显存不足时会发生什么

场景：A100（80GB）运行 Llama-3-70B（FP16，需要 130GB）

结果：
1. OOM（Out of Memory）错误：最常见，直接崩溃
2. Offloading 到 CPU RAM：速度下降 10-50x
3. Offloading 到 NVMe SSD：速度下降 100x+

解决方案：
- 量化（INT4）：130GB → 32GB，A100 单卡可以运行
- 张量并行：两张 A100（160GB 总显存），每张存一半参数

HBM（高带宽内存）

HBM（High Bandwidth Memory）是 GPU 显存使用的内存类型。

带宽对比：
  DDR5（CPU 内存）：~100 GB/s
  GDDR6X（GeForce）：~1 TB/s
  HBM2e（A100）：~2 TB/s
  HBM3（H100）：~3.35 TB/s

为什么带宽重要：
  矩阵乘法的速度瓶颈有时不是计算，而是数据从显存加载到寄存器的速度（内存带宽瓶颈）
  HBM 比 GDDR 高 2-3 倍的带宽，是 A100 > RTX 3090 用于 AI 推理的重要原因之一

四、NVIDIA GPU 产品线解析

数据中心 GPU（推理首选）

GPU	显存	带宽	FP16 TFLOPS	TDP	2024年租用价格/小时
A10G	24GB GDDR6	600 GB/s	31.2	150W	$0.76 (Spot)
A100 40GB	40GB HBM2e	1,555 GB/s	77.6	400W	$1.1 (Spot)
A100 80GB	80GB HBM2e	2,000 GB/s	77.6	400W	$1.8 (Spot)
H100 SXM	80GB HBM3	3,350 GB/s	989	700W	$3.0 (Spot)
H100 NVL	94GB HBM3	3,930 GB/s	1,979	700W	$3.5 (Spot)

消费级 GPU（开发/低成本推理）

GPU	显存	FP16 TFLOPS	购买价格	适合模型大小
RTX 3090	24GB GDDR6X	35.6	~$800 二手	7B (FP16) / 13B (INT4)
RTX 4090	24GB GDDR6X	82.6	~$1,600	7B (FP16) / 13B (INT4)
RTX 4090 × 2	48GB	165	~$3,200	34B (INT4)

Apple Silicon——统一内存的革命

# Apple M2 Ultra 的特殊优势
apple_m2_ultra = {
    "unified_memory": "192GB",    # CPU 和 GPU 共享同一块内存！
    "memory_bandwidth": "800 GB/s",  # 远超消费 GPU
    "max_model_size": "~110B (INT4)",  # 单机可以运行巨型模型
    "price": "$3,999 (Mac Studio 基础款)",
    
    # 关键优势：不存在"显存不足"问题
    # 模型参数、KV Cache、系统内存全部共享 192GB
    # 比 24GB RTX 4090 可以运行大得多的模型
    
    "limitation": "GPU 算力远低于 NVIDIA（约等于 RTX 3070）",
    "best_for": "运行大型量化模型（30B-110B），延迟中等，成本低"
}

五、选择推理硬件的决策框架

def choose_inference_hardware(
    model_size_b: float,  # 模型参数量（十亿）
    precision: str,       # "fp16" / "int8" / "int4"
    latency_req_ms: float,  # 延迟要求（毫秒，P95）
    throughput_rps: float,  # 吞吐量（请求/秒）
    budget_per_month: float # 预算（美元/月）
) -> dict:
    
    vram_needed = model_size_b * {"fp16": 2, "int8": 1, "int4": 0.5}[precision]
    
    recommendations = []
    
    if vram_needed <= 24 and latency_req_ms < 200:
        recommendations.append({
            "option": "RTX 4090 (本地)",
            "cost": "$300-500/月（电费 + 折旧）",
            "best_for": "开发环境、低流量生产"
        })
    
    if vram_needed <= 80 and throughput_rps > 10:
        recommendations.append({
            "option": "A100 80GB (云端)",
            "cost": "$1.8/小时 Spot = $648/月",
            "best_for": "中等流量生产环境"
        })
    
    if throughput_rps > 100:
        recommendations.append({
            "option": "H100 集群",
            "cost": "$3-5/小时/卡",
            "best_for": "高流量 AI 服务"
        })
    
    return recommendations

关键认知

理解 GPU 架构的实际收益：

知道为什么 INT4 量化既省显存又提速（Tensor Core 的 INT4 算力 = FP16 的 2x，同时显存减少 4x）
知道什么是内存带宽瓶颈（大 batch 时计算瓶颈，小 batch 时内存带宽瓶颈）
知道为什么 H100 比 A100 值 3 倍价格（Tensor Core 性能提升 3x，带宽提升 2x）
知道 Apple Silicon 的适用场景（大型量化模型，成本敏感，不要求极低延迟）

GPU 是 AI 时代的"石油"。理解 GPU 的人，能用更少的资源做更多的事。这在 AI 产品的成本结构中，直接决定了能否盈利。