算力需求分析

算力需求分析维度

算力需求分析框架：
├── 训练需求
│   ├── 计算量（FLOPs）
│   ├── 内存容量（显存+内存）
│   ├── 存储容量（数据+检查点）
│   ├── 通信带宽（分布式训练）
│   └── 训练时间预算
├── 推理需求
│   ├── 单次计算量
│   ├── 延迟要求
│   ├── 吞吐量要求
│   └── 内存占用
└── 共同因素
    ├── 模型架构
    ├── 数据规模
    ├── 精度要求
    └── 并行策略

计算量估算公式

训练计算量估算：
┌────────────────────────────────────────┐
│  总计算量 ≈ 6 × N × D                   │
│                                        │
│  N = 模型参数量                         │
│  D = 训练Token数量                      │
│  6 = 前向传播(1) + 反向传播(2) × 参数更新│
└────────────────────────────────────────┘

示例计算：
├── GPT-3 (175B参数, 300B Tokens)
│   └── 计算量 = 6 × 175×10^9 × 300×10^9
│              = 3.15×10^23 FLOPs
│              ≈ 3.15×10^5 PFLOPs-days
│
├── LLaMA-2 (70B参数, 2T Tokens)
│   └── 计算量 = 6 × 70×10^9 × 2×10^12
│              = 8.4×10^23 FLOPs
│              ≈ 8.4×10^5 PFLOPs-days
│
└── GPT-4 (估计1.8T参数, 13T Tokens)
    └── 计算量 ≈ 1.4×10^26 FLOPs
               ≈ 1.4×10^8 PFLOPs-days

主流模型训练计算量对比

内存需求计算

训练内存需求组成：
├── 模型参数
│   └── FP32: 4 bytes/参数
│   └── FP16/BF16: 2 bytes/参数
│
├── 梯度
│   └── 与参数同精度存储
│
├── 优化器状态
│   └── AdamW: 8 bytes/参数 (FP32的m和v)
│   └── SGD: 4 bytes/参数
│
├── 激活值
│   └── 取决于batch size和序列长度
│   └── 可通过gradient checkpointing优化
│
└── 临时缓冲区
    └── 计算中间结果

总内存估算（AdamW优化器）：
┌─────────────────────────────────────────┐
│ FP16训练: 约 20 bytes/参数              │
│   = 2(参数) + 2(梯度) + 8(优化器) +     │
│     4(FP32参数副本) + 4(激活值等)       │
│                                         │
│ FP32训练: 约 16 bytes/参数              │
│   = 4(参数) + 4(梯度) + 8(优化器)       │
└─────────────────────────────────────────┘

示例：LLaMA-2-70B训练
├── 参数内存 (FP16): 140GB
├── 优化器状态: 560GB
├── 激活值 (bs=1, seq=4096): ~30GB
└── 总需求: ~730GB+
    → 需要多卡并行

存储需求组成

推理性能指标

推理性能关键指标：
├── Time to First Token (TTFT)
│   └── 首个Token生成时间
│   └── 影响用户等待体验
│   └── 受预填充阶段计算影响
│
├── Token Generation Latency
│   └── 每个Token生成时间
│   └── 影响响应流畅度
│   └── 受解码阶段计算影响
│
├── Throughput (Tokens/s)
│   └── 每秒生成Token数
│   └── 影响服务容量
│   └── 可通过批处理提升
│
└── Memory Bandwidth Utilization
    └── 内存带宽利用率
    └── 推理主要瓶颈
    └── 受模型大小和精度影响

批处理对推理的影响

批处理策略：
┌──────────────────────────────────────────┐
│ 单请求推理：                              │
│ ├── 延迟最低                             │
│ ├── 吞吐最低                             │
│ └── 内存带宽利用率低                     │
│                                          │
│ 批量推理：                                │
│ ├── 延迟增加（排队+计算）                │
│ ├── 吞吐提升（并行计算）                 │
│ └── 内存带宽利用率高                     │
│                                          │
│ 连续批处理（Continuous Batching）：       │
│ ├── 动态调度请求                         │
│ ├── 最小化空闲时间                       │
│ └── 最优吞吐与延迟平衡                   │
└──────────────────────────────────────────┘

吞吐优化示例：
├── A100 GPU, LLaMA-2-70B
├── Batch=1: ~20 tokens/s
├── Batch=8: ~120 tokens/s
├── Batch=32: ~350 tokens/s
├── Batch=64: ~500 tokens/s
└── Batch=128: ~600 tokens/s (内存限制)

影响算力需求的关键因素

LLaMA-2-70B训练需求分析

LLaMA-2-70B训练需求：
├── 模型规格
│   ├── 参数量: 70B
│   ├── 隐藏维度: 8192
│   ├── 层数: 80
│   └── 注意力头: 64
│
├── 训练配置
│   ├── 训练Token: 2T
│   ├── 序列长度: 4096
│   ├── Batch Size: 4M tokens
│   └── 精度: BF16
│
├── 硬件需求
│   ├── GPU: 2000+ A100-80GB
│   ├── 显存总量: 160TB+
│   ├── 存储: 50TB+
│   └── 网络带宽: 400Gbps
│
├── 时间与成本
│   ├── 训练时长: ~21天
│   ├── GPU小时: ~1,000,000
│   └── 估算成本: $2-3M
│
└── 并行策略
    ├── TP=8 (Tensor Parallelism)
    ├── PP=4 (Pipeline Parallelism)
    └── DP=64 (Data Parallelism)

常用算力评估工具

# 计算量估算工具
# 1. 使用Kapathy的nanoGPT估算

# 模型参数量计算
def estimate_params(vocab_size, d_model, n_layers, n_heads):
    # Embedding
    embed_params = vocab_size * d_model
    
    # Attention per layer
    attn_params = 4 * d_model * d_model  # Q,K,V,O
    
    # FFN per layer
    ffn_params = 8 * d_model * d_model  # assuming 4x expansion
    
    # Layer norm (negligible)
    
    total = embed_params + n_layers * (attn_params + ffn_params)
    return total

# 训练FLOPs估算
def estimate_training_flops(params, tokens):
    # 6 FLOPs per parameter per token
    # (forward: 2, backward: 4)
    return 6 * params * tokens

# 训练时间估算
def estimate_training_time(flops, gpu_count, gpu_flops):
    # gpu_flops: effective FLOPs/s
    # A100 FP16: ~312 TFLOPs theoretical, ~150 TFLOPs effective
    effective_flops = gpu_count * gpu_flops
    seconds = flops / effective_flops
    return seconds / 3600 / 24  # days