Ajuste de custos e latência

Mede primeiro o pipeline completo#

Cada objeto Results divide o seu próprio tempo por etapas:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
video = "https://github.com/ultralytics/assets/releases/download/v0.0.0/solutions_ci_demo.mp4"
totals = {"preprocess": 0.0, "inference": 0.0, "postprocess": 0.0}
for n, r in enumerate(model.predict(video, stream=True, verbose=False), 1):
    for stage in totals:
        totals[stage] += r.speed[stage]
print({stage: round(ms / n, 1) for stage, ms in totals.items()}, "ms per frame")

{'preprocess': 0.7, 'inference': 36.1, 'postprocess': 0.7} ms per frame

Neste caso, a inferência representa 95% do tempo do modelo, por isso as alavancas relacionadas com o modelo vão ajudar. Mede também a descodificação e os teus próprios destinos da mesma forma (time.perf_counter() à volta de cada um) e, depois, aplica a regra correspondente ao que encontrares:

Classificação das alavancas#

Experimenta pela ordem indicada e para quando atingires o limite:

Os números provêm das tabelas de benchmarks do YOLO26, TensorRT e OpenVINO, bem como das medições abaixo; os teus serão diferentes, por isso mede.

Modelo menor#

A tabela de benchmarks do YOLO26 no COCO:

Na CPU, cada redução de tamanho é 2,2–2,5× mais rápida. A diferença de precisão no COCO representa o pior caso: um detetor de armazém com 3 classes e objetos grandes costuma perder muito menos ao passar de m para n do que um detetor geral com 80 classes. Por isso, vale sempre a pena testar o modelo menor no teu próprio conjunto de validação.

Entrada menor#

O cálculo escala aproximadamente com o número de píxeis, por isso imgsz=480 requer cerca de 56% do trabalho da resolução 640. Medido na CPU do portátil de teste, com ONNX Runtime no lote 1 (mediana de 25 execuções em bus.jpg):

Regra de decisão: se o teu objeto importante mais pequeno ainda ocupar cerca de 10 píxeis ou mais na nova resolução, experimenta; se os objetos forem pequenos ou distantes (drones, prateleiras longe da câmera), mantém a resolução e reduz o modelo.

Menos fotogramas#

Se a inferência limitar a tua frequência de fotogramas e a cena se mover lentamente, executa a deteção em cada N-ésimo fotograma com vid_stride=N e deixa o rastreador preencher as lacunas:

import time

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
video = "https://github.com/ultralytics/assets/releases/download/v0.0.0/solutions_ci_demo.mp4"
model.predict(video, vid_stride=30, verbose=False)  # warm up so the first timing is fair

for stride in (1, 2, 3):
    start, ids, frames = time.perf_counter(), set(), 0
    for r in model.track(video, stream=True, vid_stride=stride, tracker="bytetrack.yaml", classes=[0], verbose=False):
        frames += 1
        if r.boxes.is_track:
            ids.update(r.boxes.id.int().tolist())
    print(f"vid_stride={stride}: {frames} frames in {time.perf_counter() - start:.2f} s, {len(ids)} person IDs")

vid_stride=1: 62 frames in 2.66 s, 32 person IDs
vid_stride=2: 31 frames in 1.19 s, 30 person IDs
vid_stride=3: 20 frames in 0.95 s, 28 person IDs

Processar metade dos fotogramas demora cerca de metade do tempo, e o rastreador manteve 30 das 32 identidades. Em vid_stride=3 perdeu 4, o que indica que deves parar neste caso de movimento a passo de caminhada.

Reduz os custos na nuvem#

O custo corresponde às horas de instância divididas pelo trabalho útil. Um cartão como este apresenta os dois números de que precisas: o custo por hora (0,17 $ por 1 vCPU e 4 GiB neste caso) e o trabalho realizado (59 pedidos em 24 horas com latência P95 de 226 ms, num endpoint praticamente inativo). Depois:

• Aumenta a utilização. Uma GPU com 30% de utilização desperdiça 70% do que pagas. Agrupa os fluxos (lições anteriores) ou disponibiliza-os através do Triton Inference Server.
• Ajusta o tamanho dos recursos. Compara o desempenho numa GPU menor ou numa CPU com OpenVINO antes de presumires que precisas de uma GPU grande.
• Usa capacidade spot ou preemptível para trabalhos em lote. O reprocessamento de vídeos arquivados tolera interrupções; os fluxos em direto, não.

Armadilhas#