Ajuste de costes y latencia

Mide primero todo el pipeline#

Cada objeto Results divide su propio tiempo en 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

Aquí la inferencia representa el 95 % del tiempo del modelo, así que las palancas relacionadas con el modelo serán útiles. Mide también la decodificación y tus propios procesos de envío de resultados de la misma manera (con time.perf_counter() alrededor de cada uno) y, después, aplica la regla correspondiente a lo que encuentres:

Clasificación de palancas#

Empieza por arriba y detente cuando alcances el presupuesto:

Las cifras proceden de las tablas de pruebas de rendimiento de YOLO26, TensorRT y OpenVINO, así como de las mediciones de abajo; tus resultados serán distintos, así que mide.

Modelo más pequeño#

La tabla de pruebas de rendimiento de YOLO26 en COCO:

En CPU, cada paso hacia un modelo más pequeño es entre 2,2 y 2,5 veces más rápido. La diferencia de precisión en COCO representa el peor caso: un detector de almacén con 3 clases y objetos grandes suele perder mucho menos al pasar de m a n que un detector general de 80 clases, así que siempre merece la pena probar el modelo más pequeño con tu propio conjunto de validación.

Entrada más pequeña#

El cálculo escala aproximadamente con el número de píxeles, así que imgsz=480 requiere alrededor del 56 % del trabajo que requiere 640. Medición en la CPU del portátil de pruebas con ONNX Runtime y lote 1 (mediana de 25 ejecuciones en bus.jpg):

Criterio de decisión: si el objeto importante más pequeño sigue ocupando unos 10 píxeles o más con el nuevo tamaño, pruébalo; si los objetos son pequeños o lejanos (drones, estanterías alejadas de la cámara), conserva la resolución y reduce el tamaño del modelo.

Menos fotogramas#

Si la inferencia limita tu frecuencia de fotogramas y la escena se mueve despacio, ejecuta la detección en uno de cada N fotogramas con vid_stride=N y deja que el rastreador cubra los intervalos:

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

Procesar la mitad de los fotogramas cuesta aproximadamente la mitad de tiempo, y el rastreador mantuvo 30 de las 32 identidades. Con vid_stride=3 perdió 4, lo que indica que debes detenerte en esta escena a ritmo de paseo.

Reduce los costes en la nube#

El coste equivale a las horas de instancia divididas entre el trabajo útil. Una tarjeta como esta muestra las dos cifras que necesitas: cuánto cuesta una hora (0,17 $ por 1 vCPU y 4 GiB en este caso) y cuánto trabajo realiza (59 solicitudes en 24 horas, con una latencia P95 de 226 ms; el endpoint está inactivo la mayor parte del tiempo). A continuación:

• Aumenta la utilización. Una GPU con una utilización del 30 % desperdicia el 70 % de lo que pagas. Agrupa los flujos (lecciones anteriores) o sirve el modelo mediante Triton Inference Server.
• Ajusta el tamaño. Compara el rendimiento en una GPU más pequeña o en una CPU con OpenVINO antes de dar por hecho que necesitas una GPU grande.
• Usa capacidad bajo demanda o interrumpible para trabajos por lotes. El reprocesamiento de vídeo archivado tolera las interrupciones; los flujos en directo, no.

Errores habituales#