Inference Latency

Độ trễ suy luận là thời gian một model machine learning đã huấn luyện cần để chuyển một đầu vào, chẳng hạn khung hình từ camera hoặc prompt văn bản, thành dự đoán. Độ trễ thường được tính bằng mili giây (ms) và quyết định tốc độ phản hồi của hệ thống: camera chạy ở 30 khung hình/giây tạo khung hình mới sau mỗi 33,3 ms, nên detector cần nhiều thời gian hơn sẽ bị tụt lại so với luồng và không còn đáp ứng được suy luận thời gian thực. Độ trễ được báo cáo riêng cho lượt truyền xuôi hoặc tính từ đầu đến cuối, từ đầu vào thô đến đầu ra có thể sử dụng; hệ thống production theo dõi các phân vị như trung vị (p50) và phân vị thứ 99 (p99), vì một số phản hồi chậm có thể quan trọng không kém giá trị trung bình.

Những yếu tố làm tăng độ trễ suy luận#

Một dự đoán đơn lẻ đi qua nhiều giai đoạn. Tiền xử lý giải mã, thay đổi kích thước và chuẩn hóa đầu vào. Lượt truyền xuôi chạy mạng; chi phí tăng theo FLOPs của model, độ phân giải đầu vào và độ chính xác số, còn tốc độ phụ thuộc vào bộ xử lý — CPU, GPU hay bộ xử lý thần kinh (NPU). Hậu xử lý chuyển đầu ra thô thành kết quả; với detector, quá trình này giải mã box và chạy loại bỏ phi cực đại (NMS). API đám mây làm tăng thời gian khứ hồi mạng và thời gian yêu cầu phải chờ trong hàng đợi; đó là lý do AI biên chạy model ngay trên thiết bị thu thập dữ liệu. Lần gọi đầu tiên cũng chậm hơn những lần sau vì framework cấp phát bộ nhớ, nạp weight vào cache và chọn kernel trong lần sử dụng đầu.

Phần cứng và runtime có thể làm thời gian forward pass thay đổi hơn một bậc độ lớn: Ultralytics YOLO26 nano đạt trung bình 38,9 ms cho mỗi ảnh COCO 640 pixel với ONNX trên CPU và 1,7 ms với TensorRT trên GPU NVIDIA T4. Ultralytics YOLO ghi lại thời gian từng giai đoạn của mỗi dự đoán trong thuộc tính speed của kết quả; chế độ benchmark lặp lại phép đo cho từng định dạng export:

from ultralytics import YOLO

# Load the smallest YOLO26 detection model
model = YOLO("yolo26n.pt")

# Predict on one image
results = model("https://ultralytics.com/images/bus.jpg")
result = results[0]

# Per-image time in milliseconds for each stage of the pipeline
for stage, ms in result.speed.items():
    print(f"{stage}: {ms:.1f} ms")

Vòng lặp in thời gian tiền xử lý, suy luận và hậu xử lý; tổng của các giá trị này là độ trễ của model cho ảnh đó trên thiết bị hiện tại.

Đo độ trễ chính xác#

Chỉ có thể so sánh các con số độ trễ khi chúng được đo theo cùng một cách. Phép đo đáng tin cậy loại bỏ một số lượt chạy khởi động, đo nhiều lượt và báo cáo trung vị cùng một phân vị đuôi thay vì chỉ một lượt. Trên GPU, bộ định giờ phải chờ thiết bị, chẳng hạn bằng torch.cuda.synchronize(), vì kernel được khởi chạy bất đồng bộ và đọc đồng hồ quá sớm sẽ kết thúc trước khi công việc hoàn tất. Kích thước đầu vào, batch size, độ chính xác và thiết bị phải khớp với môi trường triển khai, vì độ trễ của model trên GPU trung tâm dữ liệu không nói lên nhiều về độ trễ trên điện thoại. FLOPs ước tính chi phí mà không phụ thuộc phần cứng, nhưng các model có cùng FLOPs vẫn có thể chạy nhanh chậm khác nhau rõ rệt trên cùng thiết bị.

Độ trễ suy luận và thông lượng#

Thông lượng là số đầu vào mà hệ thống xử lý trong một đơn vị thời gian, chẳng hạn số ảnh/giây hoặc token/giây; thông lượng thường biến thiên ngược chiều với độ trễ. Batch lớn hơn giúp phần cứng hoạt động hiệu quả hơn, làm tăng thông lượng, nhưng mọi đầu vào trong batch phải chờ cả batch xử lý xong, nên thời gian phản hồi cho từng yêu cầu cũng tăng:

import time

import torch
import torchvision

# A ResNet-18 image classifier in inference mode on the CPU
model = torchvision.models.resnet18().eval()

for batch in [1, 2, 4, 8]:
    x = torch.randn(batch, 3, 224, 224)
    with torch.inference_mode():
        model(x)  # warmup run, not timed
        times = []
        for _ in range(20):
            start = time.perf_counter()
            model(x)
            times.append(time.perf_counter() - start)
    latency = sorted(times)[len(times) // 2]  # median seconds per batch
    print(f"batch {batch}: {latency * 1e3:5.1f} ms per batch, {batch / latency:4.0f} images/s")

Trên CPU laptop, tăng batch từ 1 lên 8 nâng thông lượng từ 168 lên 220 ảnh/giây, trong khi thời gian trả về một batch tăng từ 6 ms lên 36 ms. Vì vậy, các hệ thống tương tác như hỗ trợ lái xe và trợ lý giọng nói chạy với batch size 1, còn các tác vụ ngoại tuyến như lập chỉ mục kho lưu trữ video thì gom batch mạnh hơn. Máy chủ LLM sử dụng batching liên tục, thêm và loại bỏ yêu cầu khỏi batch đang chạy để duy trì thông lượng cao mà không bắt từng người dùng phải chờ cả batch hoàn tất.

Giảm độ trễ suy luận#

Mức cải thiện lớn nhất thường đến từ việc giảm lượng tính toán: dùng biến thể model nhỏ hơn, giảm độ phân giải đầu vào hoặc giảm số weight bằng cắt tỉa model. Lượng tử hóa model xuống FP16 hoặc INT8 giúp mỗi phép toán còn lại tốn ít chi phí hơn trên phần cứng có đơn vị xử lý độ chính xác thấp tốc độ cao. Export sang inference engine được tối ưu như TensorRT, OpenVINO hoặc ONNX Runtime sẽ hợp nhất các layer và chọn kernel nhanh nhất cho thiết bị. Chạy model ngay trên thiết bị loại bỏ thời gian khứ hồi mạng, vốn thường tốn hàng chục mili giây qua kết nối di động.

Các trường hợp độ trễ có ý nghĩa#

• Large language model (LLM): Dịch vụ chat theo dõi thời gian đến token đầu tiên, yếu tố người dùng cảm nhận là độ phản hồi, và thời gian cho mỗi token đầu ra, yếu tố quyết định tốc độ streaming. Giải mã suy đoán giảm thời gian thứ hai bằng cách xác minh nhiều token được soạn trước trong một lần forward pass.
• Kiểm tra công nghiệp: Camera đặt phía trên băng chuyền phải phân loại từng linh kiện trước khi linh kiện đến cổng loại bỏ, vì vậy độ trễ quyết định tốc độ tối đa của dây chuyền.
• Xe tự hành: Nhận thức, lập kế hoạch và điều khiển cùng sử dụng một ngân sách thời gian rất chặt; ở tốc độ 100 km/h, xe đi được 2,8 mét trong mỗi 100 ms trễ.