大模型原理与训练 / 系统课时

性能压测

性能压测

本课建立一套可重复的 Transformer 推理基准,区分首个可显示文本延迟、解码速度、批量吞吐量和峰值显存。完成后,你可以用统一口径比较不同设备、精度与批大小。

学习目标

  • 正确定义 TTFT、生成速度、吞吐量和显存峰值
  • 编写可运行的本地模型压测脚本
  • 根据指标组合判断预填充、解码或显存瓶颈

统一四类核心指标

首词延迟 TTFT 表示从请求开始到客户端收到首个可显示文本片段的时间,可写为 TTFT=tfirst−trequestTTFT=t_{first}-t_{request}。它主要受输入长度、预填充计算、排队时间和服务开销影响,是交互体验最敏感的指标。

生成速度关注首个片段之后的持续解码能力。输出 token 数为 NoutN_{out} 时,可用 (Nout−1)/(tend−tfirst)(N_{out}-1)/(t_{end}-t_{first}) 近似计算每秒生成 token 数。吞吐量则面向整个测试窗口,统计总输出 token 数除以总墙钟时间。

推理性能指标时间线

显存指标应区分“当前占用”和“峰值占用”。模型加载后已有基础占用,压测期间的峰值还会包含激活、KV Cache、临时张量与批处理开销,因此必须在模型完成预热后重置峰值统计。

固定测试条件

性能数字只有在测试条件一致时才可比较。至少固定模型版本、设备、数据类型、输入长度、输出长度、批大小和生成策略;关闭随机采样可以减少波动,预热则用于排除首次加载算子、缓存和内核初始化的影响。

同一组配置建议重复运行至少 5 次,并报告中位数或 P95,而不是只记录最快一次。GPU 测量前后还要调用同步操作,否则 CPU 计时可能早于异步 CUDA 计算结束,得到偏小的延迟。

实现本地基准脚本

先安装依赖。示例继续使用 distilgpt2,在有 CUDA 时自动使用 GPU,否则在 CPU 上运行。

bash
python -m pip install torch transformers

预期输出

text
Successfully installed <PACKAGES>

将下面代码保存为 benchmark.py。脚本先预热模型,再重复测量单请求 TTFT 与解码速度,并测试批大小为 1、2、4 时的持续 token 吞吐量和峰值显存。

python
import json
import threading
import time
from statistics import median

import torch
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    TextIteratorStreamer,
)

MODEL_NAME = "distilgpt2"
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
PROMPT = "Transformer inference performance depends on"
MAX_NEW_TOKENS = 32
REPEATS = 5

def sync_device() -> None:
    if DEVICE == "cuda":
        torch.cuda.synchronize()

def peak_memory_mb() -> float:
    if DEVICE != "cuda":
        return 0.0
    return torch.cuda.max_memory_allocated() / 1024**2

def reset_peak_memory() -> None:
    if DEVICE == "cuda":
        torch.cuda.reset_peak_memory_stats()

def measure_single(model, tokenizer) -> dict[str, float]:
    inputs = tokenizer(PROMPT, return_tensors="pt").to(DEVICE)
    streamer = TextIteratorStreamer(
        tokenizer,
        skip_prompt=True,
        skip_special_tokens=True,
    )
    result: dict[str, torch.Tensor] = {}

    def worker() -> None:
        with torch.inference_mode():
            result["output_ids"] = model.generate(
                **inputs,
                max_new_tokens=MAX_NEW_TOKENS,
                min_new_tokens=MAX_NEW_TOKENS,
                do_sample=False,
                pad_token_id=tokenizer.pad_token_id,
                streamer=streamer,
            )

    reset_peak_memory()
    sync_device()
    started_at = time.perf_counter()
    thread = threading.Thread(target=worker)
    thread.start()

    first_piece_at = None
    for piece in streamer:
        # Streamer 产生首个非空片段时,记录用户可见首包时间。
        if piece and first_piece_at is None:
            first_piece_at = time.perf_counter()

    thread.join()
    sync_device()
    finished_at = time.perf_counter()

    output_ids = result["output_ids"]
    input_tokens = inputs["input_ids"].shape[1]
    generated_tokens = output_ids.shape[1] - input_tokens
    first_piece_at = first_piece_at or finished_at

    decode_seconds = max(finished_at - first_piece_at, 1e-9)
    decode_tokens = max(generated_tokens - 1, 0)

    return {
        "ttft_ms": (first_piece_at - started_at) * 1000,
        "decode_tokens_per_second": decode_tokens / decode_seconds,
        "peak_allocated_mb": peak_memory_mb(),
    }

def measure_batch(model, tokenizer, batch_size: int) -> dict[str, float]:
    prompts = [PROMPT] * batch_size
    inputs = tokenizer(
        prompts,
        return_tensors="pt",
        padding=True,
        truncation=True,
        max_length=512,
    ).to(DEVICE)

    reset_peak_memory()
    sync_device()
    started_at = time.perf_counter()
    with torch.inference_mode():
        output_ids = model.generate(
            **inputs,
            max_new_tokens=MAX_NEW_TOKENS,
            min_new_tokens=MAX_NEW_TOKENS,
            do_sample=False,
            pad_token_id=tokenizer.pad_token_id,
        )
    sync_device()
    elapsed = time.perf_counter() - started_at

    generated_per_sequence = (
        output_ids.shape[1] - inputs["input_ids"].shape[1]
    )
    total_generated = output_ids.shape[0] * generated_per_sequence

    return {
        "throughput_tokens_per_second": total_generated / elapsed,
        "peak_allocated_mb": peak_memory_mb(),
    }

def main() -> None:
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
    tokenizer.padding_side = "left"
    if tokenizer.pad_token_id is None:
        tokenizer.pad_token = tokenizer.eos_token

    model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
    model.to(DEVICE)
    model.eval()

    # 预热不计入正式结果,避免首次执行开销污染数据。
    warmup = tokenizer("warmup", return_tensors="pt").to(DEVICE)
    with torch.inference_mode():
        model.generate(
            **warmup,
            max_new_tokens=8,
            do_sample=False,
            pad_token_id=tokenizer.pad_token_id,
        )
    sync_device()

    single_runs = [
        measure_single(model, tokenizer) for _ in range(REPEATS)
    ]

    batch_results = []
    for batch_size in (1, 2, 4):
        runs = [
            measure_batch(model, tokenizer, batch_size)
            for _ in range(REPEATS)
        ]
        batch_results.append(
            {
                "batch_size": batch_size,
                "throughput_tokens_per_second_p50": round(
                    median(
                        run["throughput_tokens_per_second"]
                        for run in runs
                    ),
                    2,
                ),
                "peak_allocated_mb_max": round(
                    max(run["peak_allocated_mb"] for run in runs),
                    2,
                ),
            }
        )

    report = {
        "model": MODEL_NAME,
        "device": DEVICE,
        "single_request": {
            "ttft_ms_p50": round(
                median(run["ttft_ms"] for run in single_runs),
                2,
            ),
            "decode_tokens_per_second_p50": round(
                median(
                    run["decode_tokens_per_second"]
                    for run in single_runs
                ),
                2,
            ),
            "peak_allocated_mb_max": round(
                max(run["peak_allocated_mb"] for run in single_runs),
                2,
            ),
        },
        "batch_results": batch_results,
    }
    print(json.dumps(report, indent=2))

if __name__ == "__main__":
    main()

预期结果

text
脚本输出一个 JSON 报告,包含 model、device、single_request 和 batch_results;具体延迟、吞吐量与显存数值取决于实际硬件和运行环境。

运行基准测试。首次执行还会下载模型文件,正式比较时应在模型已缓存后重新运行。

bash
python benchmark.py

预期输出

text
{
  "model": "distilgpt2",
  "device": "<cpu|cuda>",
  "single_request": {
    "ttft_ms_p50": <TTFT_MS>,
    "decode_tokens_per_second_p50": <DECODE_TPS>,
    "peak_allocated_mb_max": <PEAK_MB>
  },
  "batch_results": [
    {
      "batch_size": 1,
      "throughput_tokens_per_second_p50": <THROUGHPUT_TPS>,
      "peak_allocated_mb_max": <PEAK_MB>
    }
  ]
}

解读指标组合

TTFT 高而解码速度正常,通常说明输入较长、预填充计算重、请求排队或服务层开销较大。TTFT 正常但解码速度低,更可能是显存带宽、量化实现、设备性能或单 token 调度效率限制。

批大小增加后吞吐量上升而单请求延迟变差,属于常见权衡;若吞吐量几乎不升但显存快速增长,说明当前模型、精度或执行后端没有从批处理获益。峰值显存接近设备上限时,还要留出框架缓存和突发请求余量,不能把压测峰值直接当作安全容量。

TextIteratorStreamer 记录的是首个非空可显示片段,而不是底层严格意义上的单 token 完成时刻。这个口径更接近用户看到首字的体验;比较不同实现时必须保持同一 streamer 和解码策略。

形成可复现的压测结论

最终报告应同时写明硬件型号、驱动与框架版本、模型提交版本、精度、输入 token 数、输出 token 数、批大小、并发度、预热次数和重复次数。缺少这些条件,单独给出“每秒多少 token”没有可比性。

模型侧基准用于判断计算上限,服务上线前还应在 HTTP 层补测排队时间、序列化开销、P50/P95/P99 延迟、错误率和请求吞吐量。两层数据相减,才能区分模型瓶颈与服务框架瓶颈。

本课总结

  • TTFT、解码速度、吞吐量和峰值显存描述的是不同阶段,不能相互替代
  • 压测必须固定输入输出长度、批大小、精度与生成策略,并经过预热和重复运行
  • 指标要组合解读:延迟定位交互瓶颈,吞吐量评估容量,显存峰值决定安全并发边界

下一课预告

下一课将把接口与压测结果用于部署决策,进一步讨论批处理、量化、缓存和多实例扩缩容等工程优化方法。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

性能压测

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通