Réglage des coûts et de la latence

Commencer par mesurer l’ensemble du pipeline#

Chaque objet Results répartit son propre temps en plusieurs étapes :

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

Ici, l’inférence représente 95 % du temps du modèle ; les leviers liés au modèle seront donc utiles. Mesure de la même façon le décodage et tes propres opérations de sortie (ajoute time.perf_counter() autour de chacune), puis applique la règle correspondant à ton observation :

Classement des leviers#

Essaie les leviers en commençant par le premier et arrête-toi lorsque tu atteins le budget :

Les chiffres proviennent des tableaux de référence YOLO26, TensorRT et OpenVINO, ainsi que des mesures ci-dessous ; les tiens seront différents, alors mesure.

Modèle plus petit#

Le tableau de référence YOLO26 sur COCO :

Sur CPU, chaque réduction d’un niveau accélère le traitement de 2,2 à 2,5×. L’écart de précision sur COCO représente le pire des cas : un détecteur d’entrepôt à 3 classes avec de grands objets perd généralement beaucoup moins en passant de m à n qu’un détecteur généraliste à 80 classes. Le modèle plus petit mérite donc toujours d’être testé sur ton propre jeu de validation.

Entrée plus petite#

La charge de calcul évolue approximativement avec le nombre de pixels ; imgsz=480 nécessite donc environ 56 % du travail requis en 640. Mesures effectuées sur le CPU de l’ordinateur portable de test, avec ONNX Runtime et une taille de lot de 1 (médiane de 25 exécutions sur bus.jpg) :

Règle de décision : si ton plus petit objet important couvre encore environ 10 pixels ou plus à la nouvelle taille, essaie-la ; si les objets sont petits ou éloignés (drones, étagères éloignées de la caméra), conserve la résolution et réduis plutôt la taille du modèle.

Moins d’images#

Si l’inférence limite ta fréquence d’images et que la scène évolue lentement, effectue une détection toutes les N images avec vid_stride=N et laisse le suivi combler les intervalles :

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

Traiter la moitié des images prend environ deux fois moins de temps, et le suivi a conservé 30 des 32 identités. À vid_stride=3, il en a perdu 4 : c’est le signal qu’il faut s’arrêter pour cette scène à allure de marche.

Réduire les coûts du cloud#

Le coût correspond aux heures d’instance divisées par le travail utile. Une fiche comme celle-ci contient les deux chiffres dont tu as besoin : le coût horaire (0,17 $ pour 1 vCPU et 4 Gio ici) et la quantité de travail effectuée (59 requêtes en 24 heures à une latence P95 de 226 ms ; le point de terminaison est donc presque inactif). Ensuite :

• Augmente le taux d’utilisation. Un GPU utilisé à 30 % gaspille 70 % de ta facture. Regroupe les flux en lots (voir les leçons précédentes) ou sers-les avec Triton Inference Server.
• Choisis une taille adaptée. Évalue les performances sur un GPU plus petit ou sur un CPU avec OpenVINO avant de supposer qu’il t’en faut un grand.
• Utilise une capacité préemptible ou à la demande pour les traitements par lots. Le retraitement de vidéos archivées tolère les interruptions ; les flux en direct, non.

Pièges#