（二十一）32天GPU测试从入门到精通-LLaMA 系列模型测试day19
目录
引言
LLaMA 系列是最具影响力的开源大语言模型，从 LLaMA 到 LLaMA 3，推动了整个开源 AI 社区的发展。2023 年 2 月，Meta 发布了第一代 LLaMA，虽然仅限研究许可，但其出色的性能引发了开源社区的广泛关注。随后，LLaMA 2 于 2023 年 7 月发布，开放了商业使用许可，真正开启了开源 LLM 的黄金时代。2024 年 2 月，LLaMA 3 发布，带来了架构升级和性能飞跃，成为当时开源最强模型。
掌握 LLaMA 系列模型测试是 LLM 评估的基础。无论你是在选择生产部署的模型，还是在研究不同模型的特性，LLaMA 系列都是必须了解的基准。它的广泛采用意味着丰富的工具链、完善的文档、以及活跃的社区支持。
- LLaMA 2 和 LLaMA 3 有什么区别？ 架构改进、性能提升
- 7B/13B/70B 如何选择？ 精度与资源的权衡
- 哪些推理引擎支持最好？ vLLM/TensorRT-LLM/llama.cpp
- 实际性能如何？ 延迟、吞吐量实测数据
- 如何选择最适合的模型？ 场景需求决定
这些问题都指向一个核心主题：LLaMA 系列模型测试。
LLaMA 系列演进
┌─────────────────────────────────────────────────────────────────────┐
│ LLaMA 系列演进史 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 2023.02: LLaMA (第一代) │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 模型：7B/13B/33B/65B │ │
│ │ 特点：开创性开源，性能接近 GPT-3 │ │
│ │ 限制：研究许可，非商业用途 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ 2023.07: LLaMA 2 (第二代) │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 模型：7B/13B/70B │ │
│ │ 特点：商业可用，RLHF 对齐，上下文 4K │ │
│ │ 改进：+40% 训练数据，更好的对话能力 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ 2024.02: LLaMA 3 (第三代) │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 模型：8B/70B/405B │ │
│ │ 特点：架构升级，上下文 8K，代码能力增强 │ │
│ │ 改进：GQA 注意力，更高效的推理 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ 2024.07: LLaMA 3.1 (优化版) │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 模型：8B/70B/405B │ │
│ │ 特点：上下文 128K，工具调用，多语言 │ │
│ │ 改进：更好的指令遵循，降低幻觉 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘
LLaMA 模型介绍
理解了 LLaMA 系列的发展历程后，让我们深入了解 LLaMA 3 的架构特性。LLaMA 3 相比 LLaMA 2 有多项重要改进，这些改进直接影响了推理性能和部署方式。
LLaMA 3 架构
LLaMA 3 的基础架构采用 Transformer Decoder-only 设计，这是当前 LLM 的标准架构。GQA（Grouped Query Attention）是 LLaMA 3 的关键改进之一，相比 LLaMA 2 的 MHA（Multi-Head Attention），GQA 将 query 头分组共享 key/value 头，显著降低了 KV Cache 的显存占用，提升了推理速度。
词表方面，LLaMA 3 使用了 128k token 词表，相比 LLaMA 2 的 32k 扩大了 4 倍。这使得 LLaMA 3 能更好地支持多语言和代码生成。上下文长度方面，LLaMA 3 支持 8192 tokens，LLaMA 3.1 更是扩展到 131072 tokens（128K），可以处理长文档和长对话。
训练数据方面，LLaMA 3 使用了超过 15T tokens 的训练数据，是 LLaMA 2 的 7.5 倍。更多的训练数据直接带来了性能提升。数据截止到 2023 年，确保了知识的时效性。
模型规格对比表显示了 LLaMA 3 系列的完整阵容。8B 模型适合轻量级应用，70B 模型是标准选择，405B 模型则是超大模型，需要多卡部署。LLaMA 3.1 系列在保持相同参数量的情况下，将上下文扩展到 128K，适合长文本应用。
├─────────────────────────────────────────────────┤
│ │
│ 基础架构: │
│ ├── Transformer Decoder-only │
│ ├── GQA (Grouped Query Attention) │
│ ├── SwiGLU 激活函数 │
│ └── RoPE 位置编码 │
│ │
│ 词表: │
│ ├── 128k token 词表 │
│ ├── 支持多语言 │
│ └── 更好的代码 token 化 │
│ │
│ 上下文: │
│ ├── LLaMA 3: 8192 tokens │
│ ├── LLaMA 3.1: 131072 tokens (128K) │
│ └── 使用 RoPE 插值扩展 │
│ │
│ 训练数据: │
│ ├── LLaMA 3: >15T tokens │
│ ├── LLaMA 3.1: >15T tokens │
│ └── 截止 2023 年数据 │
│ │
└─────────────────────────────────────────────────┘
模型规格对比
┌────────────────────────────────────────────────────────────────────┐
│ LLaMA 3 系列模型规格 │
├──────────────┬─────────────┬─────────────┬─────────────┬──────────┤
│ 模型 │ 参数量 │ 激活参数 │ 上下文 │ 用途 │
│ │ (B) │ (B) │ (tokens) │ │
├──────────────┼─────────────┼─────────────┼─────────────┼──────────┤
│ LLaMA-3-8B │ 8 │ 8 │ 8K │ 轻量 │
│ LLaMA-3-70B │ 70 │ 70 │ 8K │ 标准 │
│ LLaMA-3-405B │ 405 │ 405 │ 8K │ 超大 │
│ LLaMA-3.1-8B │ 8 │ 8 │ 128K │ 长文本 │
│ LLaMA-3.1-70B│ 70 │ 70 │ 128K │ 长文本 │
│ LLaMA-3.1-405B│ 405 │ 405 │ 128K │ 超长 │
└──────────────┴─────────────┴─────────────┴─────────────┴──────────┘
注：LLaMA 3 采用 GQA，推理效率高于 LLaMA 2 的 MHA
LLaMA 2 vs LLaMA 3
LLaMA 3 相比 LLaMA 2 有显著提升，理解这些差异有助于你选择合适的模型版本。虽然 LLaMA 2 仍然是一个不错的选择，但在大多数场景下，LLaMA 3 提供了更好的性能和功能。
架构差异
注意力机制是 LLaMA 3 的核心改进之一。LLaMA 2 使用 MHA（Multi-Head Attention），每个 query 头都有独立的 key 和 value 头。LLaMA 3 使用 GQA（Grouped Query Attention），多个 query 头共享一组 key/value 头。这种设计将 KV Cache 的显存占用减少了 40-50%，推理速度提升了约 30%。
词表大小从 32k 扩展到 128k，使得 LLaMA 3 能更好地支持多语言和代码生成。上下文长度从 4K 扩展到 8K（LLaMA 3.1 扩展到 128K），可以处理更长的输入。训练数据从 2T tokens 增加到 15T tokens，7.5 倍的增长直接带来了性能提升。对齐优化方面，LLaMA 3 使用了改进的 RLHF 和 DPO 技术，指令遵循能力更好，幻觉更少。
性能对比数据显示，LLaMA 3 在各基准测试上均有显著提升。MMLU（综合知识）从 45.8% 提升到 68.4%，提升 22.6%。GSM8K（数学）从 27.5% 提升到 52.0%，提升 24.5%。HumanEval（代码）从 14.6% 提升到 62.2%，提升 47.6%，这是最显著的改进。ARC-C（科学）和 TruthfulQA（真实性）也有显著提升。
├─────────────────────────────────────────────────┤
│ │
│ 注意力机制: │
│ ├── LLaMA 2: MHA (Multi-Head Attention) │
│ ├── LLaMA 3: GQA (Grouped Query Attention) │
│ └── 效果：GQA 显存减少 40-50%，速度提升 30% │
│ │
│ 词表大小: │
│ ├── LLaMA 2: 32k tokens │
│ ├── LLaMA 3: 128k tokens │
│ └── 效果：更好的多语言和代码支持 │
│ │
│ 上下文长度: │
│ ├── LLaMA 2: 4096 tokens │
│ ├── LLaMA 3: 8192 tokens │
│ └── LLaMA 3.1: 131072 tokens (128K) │
│ │
│ 训练数据: │
│ ├── LLaMA 2: ~2T tokens │
│ ├── LLaMA 3: ~15T tokens │
│ └── 效果：7.5x 更多训练数据 │
│ │
│ 对齐优化: │
│ ├── LLaMA 2: RLHF │
│ ├── LLaMA 3: 改进的 RLHF + DPO │
│ └── 效果：更好的指令遵循，更少幻觉 │
│ │
└─────────────────────────────────────────────────┘
性能对比
┌────────────────────────────────────────────────────────────────────┐
│ LLaMA 2 vs LLaMA 3 性能对比 │
├──────────────────┬─────────────┬─────────────┬─────────────────────┤
│ Benchmark │ LLaMA-2-7B│ LLaMA-3-8B│ 提升 │
├──────────────────┼─────────────┼─────────────┼─────────────────────┤
│ MMLU │ 45.8% │ 68.4% │ +22.6% │
│ GSM8K (数学) │ 27.5% │ 52.0% │ +24.5% │
│ HumanEval (代码)│ 14.6% │ 62.2% │ +47.6% │
│ ARC-C │ 39.2% │ 60.0% │ +20.8% │
│ TruthfulQA │ 33.5% │ 50.0% │ +16.5% │
└──────────────────┴─────────────┴─────────────┴─────────────────────┘
注：LLaMA 3 在各基准测试上均有显著提升，尤其是代码和数学能力
不同参数量对比
选择合适参数量的模型是部署决策的关键。参数量越大，模型能力越强，但资源需求也越高。理解不同参数量模型的特点，可以帮助你做出合适的选择。
7B/8B vs 13B vs 70B
8B 模型（轻量级）适合资源受限场景。显存需求：FP16 约 16GB，INT4 约 6GB。推理速度：100-150 tok/s（A100）。适用场景包括个人使用、开发测试、简单问答、文本生成、资源受限环境。优势是速度快、成本低。
13B 模型（中量级，LLaMA 2）在质量和成本之间取得平衡。显存需求：FP16 约 26GB，INT4 约 10GB。推理速度：60-90 tok/s（A100）。适用场景包括企业应用、中等复杂度任务、内容创作、代码辅助、需要更好质量的场景。
70B 模型（重量级）提供最佳质量。显存需求：FP16 约 140GB，INT4 约 48GB。推理速度：20-40 tok/s（单卡 H100），需要多卡并行。适用场景包括复杂推理、专业领域、高质量内容生成、生产环境关键应用。优势是最佳质量，接近 GPT-4 水平。
405B 模型（超大，LLaMA 3）是开源最强性能。显存需求：FP16 约 810GB，INT4 约 240GB，需要多卡并行。适用场景包括最复杂任务、研究与前沿应用、需要 SOTA 性能的场景。
显存需求计算脚本可以帮助你估算不同配置的显存需求。通过指定模型参数量、量化类型、上下文长度，脚本会计算权重显存、KV Cache 显存、激活显存、以及总显存。这对于容量规划很有帮助。
├─────────────────────────────────────────────────┤
│ │
│ 8B 模型 (轻量级): │
│ ├── 显存需求：FP16 ~16GB, INT4 ~6GB │
│ ├── 推理速度：100-150 tok/s (A100) │
│ ├── 适用场景： │
│ │ ├── 个人使用/开发测试 │
│ │ ├── 简单问答/文本生成 │
│ │ └── 资源受限环境 │
│ └── 优势：速度快，成本低 │
│ │
│ 13B 模型 (中量级 - LLaMA 2): │
│ ├── 显存需求：FP16 ~26GB, INT4 ~10GB │
│ ├── 推理速度：60-90 tok/s (A100) │
│ ├── 适用场景： │
│ │ ├── 企业应用/中等复杂度任务 │
│ │ ├── 内容创作/代码辅助 │
│ │ └── 需要更好质量的场景 │
│ └── 优势：质量与成本平衡 │
│ │
│ 70B 模型 (重量级): │
│ ├── 显存需求：FP16 ~140GB, INT4 ~48GB │
│ ├── 推理速度：20-40 tok/s (单卡 H100) │
│ ├── 适用场景： │
│ │ ├── 复杂推理/专业领域 │
│ │ ├── 高质量内容生成 │
│ │ └── 生产环境关键应用 │
│ └── 优势：最佳质量，接近 GPT-4 │
│ │
│ 405B 模型 (超大 - LLaMA 3): │
│ ├── 显存需求：FP16 ~810GB, INT4 ~240GB │
│ ├── 推理速度：需多卡并行 │
│ ├── 适用场景： │
│ │ ├── 最复杂任务 │
│ │ ├── 研究与前沿应用 │
│ │ └── 需要 SOTA 性能的场景 │
│ └── 优势：开源最强性能 │
│ │
└─────────────────────────────────────────────────┘
显存需求计算
#!/usr/bin/env python3
# calculate_memory_requirement.py - 显存需求计算
def calculate_vram(model_size_b: int, quantization: str, context: int = 4096):
"""
计算显存需求
参数:
model_size_b: 模型参数量 (B)
quantization: 量化类型 (fp16/int8/int4)
context: 上下文长度
"""
# 权重显存
if quantization == 'fp16':
bytes_per_param = 2
elif quantization == 'int8':
bytes_per_param = 1
elif quantization == 'int4':
bytes_per_param = 0.5
else:
raise ValueError(f"未知量化类型：{quantization}")
weight_memory = model_size_b * 1e9 * bytes_per_param / 1e9 # GB
# KV Cache 显存 (估算)
# 假设：hidden_size = 4096, num_layers = 32
kv_cache_per_token = 4 * 4096 * 32 * 2 / 1e9 # GB per token per batch
kv_cache_memory = kv_cache_per_token * context * 1 # batch=1
# 激活显存 (估算)
activation_memory = weight_memory * 0.2 # 约 20%
# 总显存
total_memory = weight_memory + kv_cache_memory + activation_memory
return {
'weight_gb': round(weight_memory, 1),
'kv_cache_gb': round(kv_cache_memory, 1),
'activation_gb': round(activation_memory, 1),
'total_gb': round(total_memory, 1)
}
def main():
print("="*70)
print("LLaMA 模型显存需求计算")
print("="*70)
models = [
(8, 'LLaMA-3-8B'),
(70, 'LLaMA-3-70B'),
(405, 'LLaMA-3-405B'),
]
quants = ['fp16', 'int8', 'int4']
for size, name in models:
print(f"\n{name}:")
print("-"*70)
print(f"{'量化':<10} {'权重':<10} {'KV Cache':<12} {'激活':<10} {'总计':<10}")
print("-"*70)
for quant in quants:
result = calculate_vram(size, quant)
print(f"{quant:<10} {result['weight_gb']:<10.1f} "
f"{result['kv_cache_gb']:<12.1f} {result['activation_gb']:<10.1f} "
f"{result['total_gb']:<10.1f}")
if __name__ == "__main__":
main()
推理引擎适配
LLaMA 系列作为最流行的开源模型，得到了所有主流推理引擎的完善支持。选择合适的推理引擎可以显著提升性能和易用性。
各引擎支持情况
各引擎对 LLaMA 的支持情况如下：vLLM 对 LLaMA 2/3/3.1 都有完善支持，是推荐选择。TensorRT-LLM 对 LLaMA 2/3 有完善支持，对 LLaMA 3.1 支持中，提供高性能。SGLang 对 LLaMA 2/3/3.1 都有支持，适合结构化生成场景。llama.cpp 对 LLaMA 2/3/3.1 都有完善支持，适合 CPU 推理。TGI 对 LLaMA 2/3/3.1 都有支持，是 HuggingFace 官方方案。
vLLM 部署 LLaMA 3 的脚本展示了如何使用 vLLM 启动 LLaMA 3 服务。配置包括模型名称、端口、张量并行数、最大序列长度、显存利用率、以及分块预填充。启动后，服务提供 OpenAI API 兼容接口。
llama.cpp 部署 LLaMA 3 的脚本展示了如何在 CPU 或混合模式下运行 LLaMA 3。配置包括 GGUF 模型路径、端口、GPU 层数、上下文大小、批处理大小。这使得 LLaMA 3 可以在无 GPU 或有限 GPU 的设备上运行。
├──────────────┬─────────────┬─────────────┬─────────────┬──────────┤
│ 引擎 │ LLaMA 2 │ LLaMA 3 │ LLaMA 3.1 │ 备注 │
├──────────────┼─────────────┼─────────────┼─────────────┼──────────┤
│ vLLM │ ✓ 完善 │ ✓ 完善 │ ✓ 完善 │ 推荐 │
├──────────────┼─────────────┼─────────────┼─────────────┼──────────┤
│ TensorRT │ ✓ 完善 │ ✓ 完善 │ ✓ 支持 │ 高性能 │
│ -LLM │ │ │ │ │
├──────────────┼─────────────┼─────────────┼─────────────┼──────────┤
│ SGLang │ ✓ 支持 │ ✓ 支持 │ ✓ 支持 │ 结构化 │
├──────────────┼─────────────┼─────────────┼─────────────┼──────────┤
│ llama.cpp │ ✓ 完善 │ ✓ 完善 │ ✓ 完善 │ CPU │
├──────────────┼─────────────┼─────────────┼─────────────┼──────────┤
│ TGI │ ✓ 支持 │ ✓ 支持 │ ✓ 支持 │ HF 官方 │
└──────────────┴─────────────┴─────────────┴─────────────┴──────────┘
vLLM 部署 LLaMA 3
#!/bin/bash
# deploy_llama3_vllm.sh - vLLM 部署 LLaMA 3
echo "=========================================="
echo " vLLM 部署 LLaMA 3"
echo "=========================================="
# 配置
MODEL=${MODEL:-"meta-llama/Meta-Llama-3-8B-Instruct"}
PORT=${PORT:-8000}
TP_SIZE=${TP_SIZE:-1}
echo ""
echo "部署配置:"
echo " 模型：$MODEL"
echo " 端口：$PORT"
echo " 张量并行：$TP_SIZE"
echo ""
# 启动服务
python3 -m vllm.entrypoints.openai.api_server \
--model $MODEL \
--host 0.0.0.0 \
--port $PORT \
--tensor-parallel-size $TP_SIZE \
--max-model-len 8192 \
--gpu-memory-utilization 0.9 \
--enable-chunked-prefill \
--served-model-name llama-3
echo ""
echo "=========================================="
echo " LLaMA 3 服务已启动"
echo "=========================================="
echo ""
echo "API 端点：http://localhost:$PORT/v1"
echo "测试：curl http://localhost:$PORT/v1/models"
llama.cpp 部署 LLaMA 3
#!/bin/bash
# deploy_llama3_llamacpp.sh - llama.cpp 部署 LLaMA 3
echo "=========================================="
echo " llama.cpp 部署 LLaMA 3"
echo "=========================================="
# 配置
MODEL=${MODEL:-"~/.cache/llama.cpp/models/Meta-Llama-3-8B-Instruct-Q4_K_M.gguf"}
PORT=${PORT:-8080}
N_GPU=${N_GPU:-35}
echo ""
echo "部署配置:"
echo " 模型：$MODEL"
echo " 端口：$PORT"
echo " GPU 层数：$N_GPU"
echo ""
# 启动服务
cd /opt/llama.cpp
./server \
-m $MODEL \
--host 0.0.0.0 \
--port $PORT \
-ngl $N_GPU \
-c 8192 \
--batch-size 512
echo ""
echo "=========================================="
echo " LLaMA 3 服务已启动"
echo "=========================================="
性能实测
部署好 LLaMA 模型后，需要进行性能测试以验证配置是否正确，以及性能是否达到预期。性能测试包括吞吐量测试和延迟测试。
吞吐量测试
吞吐量测试脚本通过发送多个请求到 vLLM 服务，测量平均延迟、P95 延迟、总 token 数、以及吞吐量（tokens/s）。测试结果可以与官方参考值对比，如果性能明显低于预期，可能存在配置问题或硬件瓶颈。
性能参考表提供了不同配置下的预期性能。LLaMA-3-8B 在 FP16、batch=1 时吞吐量约 140-160 tokens/s，延迟 35-45ms。INT4 量化后，吞吐量提升到 200-240 tokens/s，延迟降低到 25-35ms。batch=32 时，吞吐量可达 2800-3200 tokens/s。
LLaMA-3-70B 需要多卡部署。FP16、8 卡 TP 时吞吐量约 80-100 tokens/s，延迟 80-120ms。INT4、4 卡 TP 时吞吐量约 120-150 tokens/s，延迟 60-90ms。INT4、8 卡 TP 时吞吐量约 200-250 tokens/s，延迟 50-70ms。
LLaMA-3.1-70B 在 INT4、8 卡 TP 时吞吐量约 180-220 tokens/s，延迟 60-80ms。启用 128K 上下文后，吞吐量略降到 150-180 tokens/s，延迟略增到 80-100ms。
import time
import requests
import statistics
def test_throughput(base_url: str, model: str, num_requests: int = 100):
"""吞吐量测试"""
print("="*70)
print(f"LLaMA 3 吞吐量测试 ({model})")
print("="*70)
prompt = "请介绍一下人工智能的基本概念。"
latencies = []
tokens_generated = []
for i in range(num_requests):
start = time.perf_counter()
response = requests.post(
f"{base_url}/v1/chat/completions",
json={
"model": model,
"messages": [{"role": "user", "content": prompt}],
"max_tokens": 100,
"temperature": 0.7
}
)
elapsed = time.perf_counter() - start
if response.status_code == 200:
data = response.json()
content = data['choices'][0]['message']['content']
tokens = len(content.split())
latencies.append(elapsed * 1000)
tokens_generated.append(tokens)
if (i + 1) % 10 == 0:
print(f" 完成 {i+1}/{num_requests} 请求")
else:
print(f" 请求失败：{response.status_code}")
# 统计
avg_latency = statistics.mean(latencies)
p95_latency = sorted(latencies)[int(len(latencies) * 0.95)]
total_tokens = sum(tokens_generated)
total_time = sum(latencies) / 1000
tokens_per_sec = total_tokens / total_time
print()
print("="*70)
print("测试结果:")
print(f" 平均延迟：{avg_latency:.1f} ms")
print(f" P95 延迟：{p95_latency:.1f} ms")
print(f" 总 Tokens: {total_tokens}")
print(f" 吞吐量：{tokens_per_sec:.1f} tokens/s")
print("="*70)
if __name__ == "__main__":
test_throughput("http://localhost:8000", "llama-3")
性能参考值
┌────────────────────────────────────────────────────────────────────┐
│ LLaMA 3 推理性能参考 (A100 80GB) │
├──────────────────┬─────────────┬─────────────┬─────────────────────┤
│ 配置 │ 吞吐量 │ 延迟 │ 显存占用 │
│ │ (tok/s) │ (ms) │ (GB) │
├──────────────────┼─────────────┼─────────────┼─────────────────────┤
│ LLaMA-3-8B │ │ │ │
│ FP16, batch=1 │ 140-160 │ 35-45 │ 16-18 │
│ INT4, batch=1 │ 200-240 │ 25-35 │ 8-10 │
│ INT4, batch=32 │ 2800-3200 │ 150-200 │ 12-14 │
├──────────────────┼─────────────┼─────────────┼─────────────────────┤
│ LLaMA-3-70B │ │ │ │
│ FP16, 8xTP │ 80-100 │ 80-120 │ 140-160 │
│ INT4, 4xTP │ 120-150 │ 60-90 │ 60-80 │
│ INT4, 8xTP │ 200-250 │ 50-70 │ 60-80 │
├──────────────────┼─────────────┼─────────────┼─────────────────────┤
│ LLaMA-3.1-70B │ │ │ │
│ INT4, 8xTP │ 180-220 │ 60-80 │ 70-90 │
│ INT4, 8xTP,128K│ 150-180 │ 80-100 │ 90-110 │
└──────────────────┴─────────────┴─────────────┴─────────────────────┘
注：测试条件 vLLM/TensorRT-LLM，实际性能受配置影响
实战部署案例
理解了 LLaMA 模型的特性和性能后，让我们看看实际部署案例。根据模型大小和硬件条件，部署方案有所不同。
单卡 8B 部署
单卡 8B 部署是最简单的场景。Docker Compose 配置包括：vLLM 镜像、GPU 资源配置、端口映射、模型缓存卷、以及启动命令。启动命令指定模型名称、张量并行数（1）、最大序列长度（8192）、显存利用率（0.9）、最大并发请求数（256）。健康检查确保服务可用。
多卡 70B 部署需要 8 卡并行。配置类似，但 GPU 数量改为 8，张量并行数也改为 8。这需要数据中心级的硬件，如 8 卡 A100 或 H100 服务器。
本地 CPU 部署（8B INT4）适合无 GPU 场景。脚本首先下载预量化的 GGUF 模型，然后使用 llama.cpp 启动服务。配置包括模型路径、主机地址、端口、上下文大小、线程数。预期速度 30-50 tokens/s（16 核 CPU），对于个人使用已经足够。
version: '3.8'
services:
llama3-8b:
image: vllm/vllm-openai:latest
runtime: nvidia
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: 1
capabilities: [gpu]
ports:
- "8000:8000"
volumes:
- ~/.cache/huggingface:/root/.cache/huggingface
command: >
--model meta-llama/Meta-Llama-3-8B-Instruct
--tensor-parallel-size 1
--max-model-len 8192
--gpu-memory-utilization 0.9
--max-num-seqs 256
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
interval: 30s
timeout: 10s
retries: 3
restart: unless-stopped
多卡 70B 部署
# docker-compose.llama3-70b.yaml
version: '3.8'
services:
llama3-70b:
image: vllm/vllm-openai:latest
runtime: nvidia
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: 8
capabilities: [gpu]
ports:
- "8000:8000"
volumes:
- ~/.cache/huggingface:/root/.cache/huggingface
command: >
--model meta-llama/Meta-Llama-3-70B-Instruct
--tensor-parallel-size 8
--max-model-len 8192
--gpu-memory-utilization 0.9
--max-num-seqs 256
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
interval: 30s
timeout: 10s
retries: 3
restart: unless-stopped
本地 CPU 部署 (8B INT4)
#!/bin/bash
# deploy_llama3_cpu.sh - CPU 部署 LLaMA 3 8B
echo "=========================================="
echo " CPU 部署 LLaMA 3 8B (INT4)"
echo "=========================================="
# 下载模型
huggingface-cli download bartowski/Meta-Llama-3-8B-Instruct-GGUF \
Meta-Llama-3-8B-Instruct-Q4_K_M.gguf \
--local-dir ~/.cache/llama.cpp/models
# 启动服务
cd /opt/llama.cpp
./server \
-m ~/.cache/llama.cpp/models/Meta-Llama-3-8B-Instruct-Q4_K_M.gguf \
--host 0.0.0.0 \
--port 8080 \
-c 4096 \
-t 16
echo ""
echo "=========================================="
echo " LLaMA 3 8B CPU 服务已启动"
echo "=========================================="
echo ""
echo "API 端点：http://localhost:8080"
echo "预期速度：30-50 tokens/s (16 核 CPU)"
选型建议
选择合适的 LLaMA 模型需要考虑场景需求、硬件条件、以及预算限制。下面的选型建议可以帮助你做出合适的选择。
场景推荐
个人使用/开发测试场景推荐 LLaMA-3-8B（INT4）。显存需求 6-8GB，硬件要求单卡 RTX 3060/4060。用途包括学习、原型开发、简单应用。
中小企业应用场景推荐 LLaMA-3-8B（FP16）或 LLaMA-3-70B。显存需求 16GB 或 48-80GB。硬件要求单卡 A10 或多卡 A100。用途包括客服系统、内容生成、知识问答。
大型企业应用推荐 LLaMA-3-70B（INT4/FP16）。显存需求 80-160GB。硬件要求 4-8 卡 A100/H100。用途包括核心业务、复杂推理、高质量生成。
研究与 SOTA 推荐 LLaMA-3.1-405B。显存需求 240-810GB。硬件要求 16-64 卡 H100。用途包括前沿研究、最复杂任务。
边缘/本地部署推荐 LLaMA-3-8B（INT4，llama.cpp）。显存需求 6GB 或 CPU。硬件要求笔记本/台式机 CPU。用途包括隐私敏感、离线场景、个人助手。
成本估算表显示了不同配置的硬件成本、云成本、以及电费（自建）。8B 单卡（RTX4090）硬件成本约1,600，云成本1,600，云成本300-500/月，电费50−80/月。70B8卡（A100）硬件成本约50−80/月。70B8卡（A100）硬件成本约80,000，云成本8,000−12,000/月，电费8,000−12,000/月，电费800-1,200/月。70B 8 卡（H100）硬件成本约240,000，云成本240,000，云成本20,000-30,000/月，电费$1,500-2,000/月。
├─────────────────────────────────────────────────┤
│ │
│ 个人使用/开发测试: │
│ ├── 推荐：LLaMA-3-8B (INT4) │
│ ├── 显存：6-8GB │
│ ├── 硬件：单卡 RTX 3060/4060 │
│ └── 用途：学习、原型开发、简单应用 │
│ │
│ 中小企业应用: │
│ ├── 推荐：LLaMA-3-8B (FP16) 或 LLaMA-3-70B │
│ ├── 显存：16GB 或 48-80GB │
│ ├── 硬件：单卡 A10 或 多卡 A100 │
│ └── 用途：客服系统、内容生成、知识问答 │
│ │
│ 大型企业应用: │
│ ├── 推荐：LLaMA-3-70B (INT4/FP16) │
│ ├── 显存：80-160GB │
│ ├── 硬件：4-8 卡 A100/H100 │
│ └── 用途：核心业务、复杂推理、高质量生成 │
│ │
│ 研究与 SOTA: │
│ ├── 推荐：LLaMA-3.1-405B │
│ ├── 显存：240-810GB │
│ ├── 硬件：16-64 卡 H100 │
│ └── 用途：前沿研究、最复杂任务 │
│ │
│ 边缘/本地部署: │
│ ├── 推荐：LLaMA-3-8B (INT4, llama.cpp) │
│ ├── 显存：6GB 或 CPU │
│ ├── 硬件：笔记本/台式机 CPU │
│ └── 用途：隐私敏感、离线场景、个人助手 │
│ │
└─────────────────────────────────────────────────┘
成本估算
┌────────────────────────────────────────────────────────────────────┐
│ LLaMA 部署成本估算 (月) │
├──────────────────┬─────────────┬─────────────┬─────────────────────┤
│ 配置 │ 硬件成本 │ 云成本 │ 电费 (自建) │
│ │ (一次性) │ (月租) │ (月) │
├──────────────────┼─────────────┼─────────────┼─────────────────────┤
│ 8B 单卡 (RTX4090)│ $1,600 │ $300-500 │ $50-80 │
│ 8B 单卡 (A10) │ $4,000 │ $600-900 │ $80-120 │
│ 70B 8 卡 (A100) │ $80,000 │ $8000-12K │ $800-1200 │
│ 70B 8 卡 (H100) │ $240,000 │ $20K-30K │ $1500-2000 │
└──────────────────┴─────────────┴─────────────┴─────────────────────┘
注：云成本参考 AWS/Azure/GCP，电费按$0.1/kWh 计算
总结
今天学到的内容
- ✅ LLaMA 模型介绍：架构演进、LLaMA 3 特性
- ✅ LLaMA 2 vs LLaMA 3：架构差异、性能对比
- ✅ 不同参数量对比：8B/70B/405B 选择指南
- ✅ 推理引擎适配：vLLM/TensorRT-LLM/llama.cpp
- ✅ 性能实测：吞吐量、延迟参考值
- ✅ 实战部署案例：单卡/多卡/CPU 部署
- ✅ 选型建议：场景推荐、成本估算
下一步
明天我们将学习 Day 20 - DeepSeek 模型测试，深入了解：
- DeepSeek 模型特点
- 推理性能测试
- 中文场景优化
- 与其他模型对比
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
5
0- 0
已为社区贡献13条内容
所有评论(0)