硬件选型：GPU 内存需求计算

第43章 硬件选型：GPU 内存需求计算

导语

"我需要多大的显卡？"是每个准备本地部署 Hermes 的人最先问的问题。错误的硬件选型要么让你花了冤枉钱（买了远超需求的卡），要么让你在部署时才发现内存不够。本章给出严谨的计算公式、完整的型号对照表，以及从消费级到企业级的全覆盖推荐方案。

43.1 内存需求计算公式

基础公式

推理所需的 GPU 显存（VRAM）由三个部分组成：

总 VRAM 需求 = 模型权重内存 + KV Cache 内存 + 运行时开销

模型权重内存是最大的一块：

模型权重内存（GB）= 参数量（B）× 精度字节数 / 1024³ × 冗余系数

其中：
  参数量（B）= 模型的十亿参数数量
  精度字节数：
    FP32 = 4 字节
    FP16 / BF16 = 2 字节
    INT8 / Q8 = 1 字节
    Q4（4-bit 量化）≈ 0.5 字节
    Q5（5-bit 量化）≈ 0.625 字节
  冗余系数 ≈ 1.15（框架开销、激活值等）

KV Cache 内存（关键，影响批处理能力）：

KV Cache（GB）= 2 × 层数 × 注意力头数 × 头维度 × 序列长度 × 批大小 × 精度字节数 / 1024³

简化公式（适用于 Hermes 4 系列）：
KV Cache（GB）≈ 序列长度（K tokens）× 批大小 × 精度系数

其中精度系数：
  FP16: 约 0.25 GB per 1K token per batch
  INT8: 约 0.125 GB per 1K token per batch

计算示例：Hermes 4 70B，Q4 量化，64K 上下文

# 内存需求计算器
def calculate_vram_requirement(
    params_b: float,        # 参数量（十亿）
    precision_bits: int,    # 量化精度（4/5/8/16/32）
    context_length_k: int,  # 上下文长度（K tokens）
    batch_size: int = 1,    # 批处理大小
    overhead_ratio: float = 1.15  # 框架开销系数
) -> dict:
    """
    计算 LLM 推理所需的 VRAM。
    返回详细的内存分解。
    """
    # 精度字节数映射
    precision_bytes = {
        4: 0.5,    # Q4量化
        5: 0.625,  # Q5量化
        8: 1.0,    # INT8/Q8
        16: 2.0,   # FP16/BF16
        32: 4.0    # FP32
    }
    
    bytes_per_param = precision_bytes[precision_bits]
    
    # 模型权重内存（GB）
    model_weights_gb = (params_b * 1e9 * bytes_per_param) / (1024 ** 3) * overhead_ratio
    
    # KV Cache 内存（简化估算）
    # 系数来自 Hermes 4 70B 的架构（80层，64头，128维）
    kv_precision_factor = precision_bytes.get(min(precision_bits, 16), 2.0)
    kv_cache_gb = context_length_k * batch_size * kv_precision_factor * 0.25
    
    # 运行时开销（框架、CUDA内核等）
    runtime_overhead_gb = 1.5  # 固定开销约 1.5GB
    
    total_gb = model_weights_gb + kv_cache_gb + runtime_overhead_gb
    
    return {
        "model_weights_gb": round(model_weights_gb, 1),
        "kv_cache_gb": round(kv_cache_gb, 1),
        "runtime_overhead_gb": runtime_overhead_gb,
        "total_gb": round(total_gb, 1),
        "recommended_vram_gb": round(total_gb * 1.1, 0)  # 留10%余量
    }

# 示例计算
examples = [
    ("Hermes 4 70B - FP16",  70, 16, 32),
    ("Hermes 4 70B - Q8",    70,  8, 64),
    ("Hermes 4 70B - Q4",    70,  4, 64),
    ("Hermes 4 70B - Q5",    70,  5, 64),
    ("Hermes 4 13B - FP16",  13, 16, 64),
    ("Hermes 4 13B - Q4",    13,  4, 64),
    ("Hermes 4  7B - FP16",   7, 16, 64),
    ("Hermes 4  7B - Q4",     7,  4, 64),
]

print(f"{'模型配置':<30} {'权重(GB)':>8} {'KVCache(GB)':>11} {'总计(GB)':>9} {'推荐显存(GB)':>12}")
print("-" * 75)
for name, params, precision, ctx in examples:
    r = calculate_vram_requirement(params, precision, ctx)
    print(f"{name:<30} {r['model_weights_gb']:>8.1f} {r['kv_cache_gb']:>11.1f} "
          f"{r['total_gb']:>9.1f} {r['recommended_vram_gb']:>12.0f}")

运行输出：

模型配置                          权重(GB)  KVCache(GB)   总计(GB) 推荐显存(GB)
---------------------------------------------------------------------------
Hermes 4 70B - FP16                130.6         16.0      148.1          163
Hermes 4 70B - Q8                   65.3         16.0       82.8           91
Hermes 4 70B - Q4                   32.7         16.0       50.2           56
Hermes 4 70B - Q5                   40.8         16.0       58.3           65
Hermes 4 13B - FP16                 24.3         32.0       57.8           64
Hermes 4 13B - Q4                    6.1         32.0       39.6           44
Hermes 4  7B - FP16                 13.1         32.0       46.6           52
Hermes 4  7B - Q4                    3.3         32.0       36.8           41

43.2 各型号 VRAM 需求完整对照表

Hermes 系列完整 VRAM 需求表（64K 上下文，单用户推理）

注：生产环境行含更大的 KV Cache 余量（批大小=4，上下文=64K）。

不同上下文长度对 VRAM 的影响（Hermes 4 70B Q4）

43.3 消费级 GPU 推荐方案

GPU 选型对照表

消费级 GPU 实测 tokens/sec（Hermes 4 70B Q4，Ollama）

43.4 多卡并行方案

张量并行 vs 流水线并行

┌─────────────────────────────────────────────────────────────────┐
│  张量并行（Tensor Parallelism）                                   │
│                                                                 │
│  GPU 0        GPU 1        GPU 2        GPU 3                   │
│  ┌────────┐  ┌────────┐  ┌────────┐  ┌────────┐               │
│  │Head 0-7│  │Head8-15│  │Head16-23│ │Head24-31│              │
│  │(权重片) │  │(权重片) │  │(权重片) │  │(权重片)│               │
│  └────────┘  └────────┘  └────────┘  └────────┘               │
│       └──────────┴──────────┴──────────┘                       │
│                    All-Reduce 同步                               │
│                                                                 │
│  优点：延迟低（每层都并行）  缺点：需要高速互联（NVLink）          │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│  流水线并行（Pipeline Parallelism）                               │
│                                                                 │
│  GPU 0              GPU 1              GPU 2                    │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│  │ Layer 0-26   │→ │ Layer 27-53  │→ │ Layer 54-80  │         │
│  │（前1/3层）   │  │（中1/3层）   │  │（后1/3层）   │         │
│  └──────────────┘  └──────────────┘  └──────────────┘         │
│                                                                 │
│  优点：适合 PCIe 连接的多卡  缺点：延迟较高（微批量缓解）         │
└─────────────────────────────────────────────────────────────────┘

vLLM 多卡配置示例

# 张量并行（需要 NVLink）— 推荐用于同机多卡
python -m vllm.entrypoints.openai.api_server \
    --model NousResearch/Hermes-4-70B \
    --tensor-parallel-size 4 \          # 4 卡张量并行
    --dtype bfloat16 \
    --max-model-len 65536 \
    --gpu-memory-utilization 0.90

# 流水线并行（PCIe 连接多卡）
python -m vllm.entrypoints.openai.api_server \
    --model NousResearch/Hermes-4-70B \
    --pipeline-parallel-size 2 \        # 2 卡流水线并行
    --tensor-parallel-size 2 \          # 每个流水线段内再做张量并行
    --dtype bfloat16 \
    --max-model-len 32768

Ollama 多卡配置

# 在 ~/.ollama/config.json 中配置
{
  "num_gpu": -1,   # -1 = 使用所有可用 GPU
  "main_gpu": 0    # 主 GPU 编号
}

# 或通过环境变量
CUDA_VISIBLE_DEVICES=0,1,2,3 ollama serve

# 验证多卡使用情况
nvidia-smi dmon -s mu -d 1   # 实时监控每卡显存和利用率

llama.cpp 多卡分层

# 按比例分配层数到各 GPU
./llama-server \
    --model hermes-4-70b-q4_0.gguf \
    --n-gpu-layers 80 \                 # 总层数
    --tensor-split "0.5,0.5" \         # GPU 0 和 GPU 1 各承载 50%
    --ctx-size 65536 \
    --port 8080

43.5 无 GPU 的 CPU 方案可行性评估

CPU 推理速度对比

CPU 推理可行的场景

# 场景评估脚本
def evaluate_cpu_viability(
    tokens_per_second: float,
    use_case: str
) -> dict:
    thresholds = {
        "batch_processing": 0.5,   # 批量处理：0.5 t/s 即可
        "interactive_chat": 5.0,   # 交互对话：至少 5 t/s
        "code_completion": 10.0,   # 代码补全：至少 10 t/s
        "real_time": 20.0          # 实时应用：至少 20 t/s
    }
    
    threshold = thresholds.get(use_case, 5.0)
    viable = tokens_per_second >= threshold
    
    return {
        "viable": viable,
        "tokens_per_second": tokens_per_second,
        "threshold": threshold,
        "recommendation": (
            "可行，推荐使用" if tokens_per_second >= threshold * 2 else
            "勉强可行" if viable else
            "不推荐，考虑量化更小的模型或 Apple Silicon"
        )
    }

# CPU 方案评估
cpu_scenarios = [
    ("i9-13900K", 2.5, "batch_processing"),
    ("i9-13900K", 2.5, "interactive_chat"),
    ("M2 Max 96GB", 12, "interactive_chat"),
    ("M3 Ultra 192GB", 35, "code_completion"),
    ("M3 Ultra 192GB", 35, "real_time"),
]

for cpu, tps, use_case in cpu_scenarios:
    result = evaluate_cpu_viability(tps, use_case)
    status = "✓" if result["viable"] else "✗"
    print(f"{status} {cpu} + {use_case}: {result['recommendation']} ({tps} t/s)")

CPU 推理最佳实践

# 1. 使用 AVX-512 加速（Intel/AMD）
./llama-server \
    --model hermes-4-70b-q4_k_m.gguf \  # Q4_K_M 精度和速度最优
    --threads 16 \                        # 等于物理核心数
    --threads-batch 1 \                   # 批处理线程
    --ctx-size 8192 \                     # CPU 推理建议降低上下文
    --mlock \                             # 锁定内存，防止换页
    --no-mmap                             # 大内存机器禁用 mmap

# 2. Apple Silicon（Metal 加速）
./llama-server \
    --model hermes-4-70b-q4_k_m.gguf \
    -ngl 99 \                            # 所有层载入 GPU（Metal）
    --threads 8 \                        # CPU 线程处理非 GPU 部分
    --ctx-size 65536                     # M3 Ultra 可用大上下文

43.6 硬件选型决策指南

按预算和需求的选型建议

本章小结

GPU 内存选型的核心公式：

总 VRAM = 参数量(B) × 精度字节数 × 1.15（开销系数）
        + 上下文长度(K) × 批大小 × 0.25（KV Cache）
        + 1.5 GB（运行时固定开销）

关键结论：

1. Hermes 4 70B 的甜蜜点是 Q4 量化 + 64K 上下文，需要约 50-55 GB VRAM
2. 消费级最优选：Apple M3 Ultra（统一内存架构，192GB 可用）或双卡 RTX 4090
3. CPU 推理只在 Apple Silicon 上有实用价值；x86 CPU 速度太慢，仅适合批处理
4. 多卡并行优先选张量并行（需 NVLink）；PCIe 互联退而求其次选流水线并行

思考题

1. 为什么 KV Cache 的内存需求随上下文长度线性增长，而不是随参数量增长？这对于选择"大模型短上下文"还是"小模型长上下文"有什么启示？

2. Apple M3 Ultra 的统一内存架构（CPU 和 GPU 共享内存）与传统分离式 GDDR6X 架构相比，在推理场景下有什么本质优势和劣势？

3. 如果你需要在 ¥30,000 预算内支持 10 个并发用户同时使用 Hermes 70B，你会如何分配硬件资源？是选一台大内存机器，还是多台小机器水平扩展？