机器学习与深度学习 / 系统课时

批量与并发推理

批量与并发推理

本课解决在线推理中“请求很多但设备吃不满”与“批次变大却延迟升高”的矛盾。你将实现一个带等待窗口、队列上限和单工作线程的动态批处理器,并学会用延迟、吞吐量和资源占用共同验收配置。

学习目标

  • 解释请求并发、模型执行并发与批量推理的区别
  • 使用队列和时间窗口把多个请求合并为动态批次
  • 根据 p95/p99 延迟、吞吐量和队列状态调整并发参数

为什么不能只增加线程

接口可以同时接收很多请求,但模型设备不一定适合被同样数量的线程直接调用。尤其在单张 GPU 上,多个线程争抢同一模型,可能增加上下文切换、显存峰值和尾延迟,却没有形成足够大的矩阵计算。

动态批处理的做法是:请求线程只负责入队,由固定的推理工作线程在短时间窗内收集请求,合并张量后执行一次前向传播,再把结果拆回各自的 Future。这样把“网络并发”与“模型执行”解耦。

动态批处理请求链路

动态批处理的三个参数

max_batch_size 决定一次前向传播最多合并多少个样本。值过小,设备利用率不足;值过大,单次计算和显存占用上升。

max_wait_ms 决定第一个请求最多等待多久来凑批。它直接影响低流量时的额外排队延迟,因此不能只追求满批率。

max_queue_size 是过载保护。队列达到上限后应快速失败、限流或降级,而不是无限堆积,避免请求超时后仍继续消耗计算资源。

调参时必须成对观察批次大小与等待窗口:先确定可接受的延迟目标,再在目标内提高平均批次和吞吐量。

实现动态批处理器

下面示例要求 Python 3.10 及以上并已安装 PyTorch。请求线程并发提交数据,后台线程统一调用模型;示例模型把输入乘以 2,便于验证请求与结果是否正确对应。

python
import queue
import threading
import time
from concurrent.futures import Future, ThreadPoolExecutor
from dataclasses import dataclass

import torch
from torch import nn

class Doubler(nn.Module):
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return x * 2

@dataclass
class Request:
    tensor: torch.Tensor
    future: Future

class DynamicBatcher:
    def __init__(
        self,
        model: nn.Module,
        max_batch_size: int = 4,
        max_wait_ms: int = 20,
        max_queue_size: int = 16,
    ) -> None:
        self.model = model.eval()
        self.max_batch_size = max_batch_size
        self.max_wait_seconds = max_wait_ms / 1000
        self.requests: queue.Queue[Request | None] = queue.Queue(max_queue_size)
        self.worker = threading.Thread(target=self._run, daemon=True)
        self.worker.start()

    def submit(self, tensor: torch.Tensor) -> Future:
        future: Future = Future()
        request = Request(tensor=tensor, future=future)
        try:
            # 队列满时快速失败,避免无界排队拖垮服务。
            self.requests.put(request, timeout=0.1)
        except queue.Full as exc:
            raise RuntimeError("推理队列已满,请稍后重试") from exc
        return future

    def _run(self) -> None:
        while True:
            first = self.requests.get()
            if first is None:
                return

            batch = [first]
            deadline = time.perf_counter() + self.max_wait_seconds

            # 满批或等待窗口结束后立即执行,不固定等待完整时长。
            while len(batch) < self.max_batch_size:
                remaining = deadline - time.perf_counter()
                if remaining <= 0:
                    break
                try:
                    item = self.requests.get(timeout=remaining)
                except queue.Empty:
                    break
                if item is None:
                    self.requests.put(None)
                    break
                batch.append(item)

            inputs = torch.stack([item.tensor for item in batch])
            with torch.inference_mode():
                outputs = self.model(inputs)

            # 按批内顺序把输出写回对应请求。
            for item, output in zip(batch, outputs):
                item.future.set_result(output)

    def close(self) -> None:
        self.requests.put(None)
        self.worker.join()

def main() -> None:
    service = DynamicBatcher(Doubler(), max_batch_size=4, max_wait_ms=20)

    with ThreadPoolExecutor(max_workers=8) as pool:
        submit_tasks = [
            pool.submit(service.submit, torch.tensor([float(i)]))
            for i in range(8)
        ]
        inference_futures = [task.result() for task in submit_tasks]
        results = [
            (request_id, future.result().item())
            for request_id, future in enumerate(inference_futures)
        ]

    service.close()

    for request_id, value in results:
        print(f"request {request_id} -> {value:.1f}")

if __name__ == "__main__":
    main()

预期输出

text
request 0 -> 0.0
request 1 -> 2.0
request 2 -> 4.0
request 3 -> 6.0
request 4 -> 8.0
request 5 -> 10.0
request 6 -> 12.0
request 7 -> 14.0

model.eval() 切换推理行为,torch.inference_mode() 关闭该工作线程中的梯度记录。请求线程只操作队列和 Future,因此模型前向传播始终由一个位置统一控制;实际部署到 GPU 时,还要把批量输入移动到同一设备。

用指标决定是否扩容

不要只看平均延迟。平均值可能掩盖队列拥塞,至少应同时记录 p50、p95、p99 延迟、每秒请求数、平均批次大小、队列等待时间、队列拒绝数以及 CPU、GPU 和显存占用。

现象 常见原因 优先调整
GPU 利用率低且队列短 批次太小或请求稀疏 适度增大等待窗口或合并相近尺寸请求
p99 很高且队列持续增长 到达速率超过处理能力 限流、增加实例或降低单次计算成本
吞吐量上升但显存溢出 最大批次过大 减小批次并检查输入尺寸
队列经常满但设备不忙 前后处理或数据搬运阻塞 分离预处理、使用固定形状或并行 I/O

生产压测应逐级增加并发,找到延迟目标首次被突破的位置。达到上限后,优先扩展独立模型实例,而不是让单实例继续无限排队。

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

目录与阅读设置

阅读设置

17

记录一个想法

批量与并发推理

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

登录哪都通