Exécuter l'inférence sur une vidéo

Exemple pratique : effectuer une prédiction sur un fichier vidéo#

Les vidéos utilisent le même mode Predict que les images. Cet extrait de 62 images montre des personnes traversant un atrium :

yolo predict model=yolo26n.pt source=https://github.com/ultralytics/assets/releases/download/v0.0.0/solutions_ci_demo.mp4

video 1/1 (frame 1/62) solutions_ci_demo.mp4: 384x640 22 persons, 27.3ms
...
video 1/1 (frame 62/62) solutions_ci_demo.mp4: 384x640 22 persons, 54.8ms
Results saved to runs/detect/predict

• frame 1/62 : Ultralytics décode la vidéo et traite chaque image comme une image fixe.
• 22 persons : détections dans cette image. Les mêmes passants sont comptés à nouveau dans chaque image.
• 27.3ms ... 54.8ms : le temps par image varie selon les autres tâches effectuées par la machine.

La vidéo annotée est runs/detect/predict/solutions_ci_demo.mp4. Ton propre modèle fonctionne de la même manière : remplace yolo26n.pt par runs/detect/pills_v1/weights/best.pt.

Diffuser des flux longs et en direct#

Pour exécuter du code sur les détections, parcours un flux en boucle. Chaque itération génère le Results d'une image, puis le supprime :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
source = "https://github.com/ultralytics/assets/releases/download/v0.0.0/solutions_ci_demo.mp4"

frames, people = 0, 0
for result in model(source, stream=True, classes=[0], verbose=False):  # one Results object per frame
    frames += 1
    people += len(result.boxes)
print(f"{frames} frames, {people / frames:.1f} people per frame")

62 frames, 22.2 people per frame

La même boucle accepte l'index d'une webcam (source=0) ou une URL de caméra telle que rtsp://camera.local/stream, et s'exécute jusqu'à la fin du flux ou jusqu'à ce que tu l'arrêtes. Ajoute vid_stride=2 pour traiter une image sur deux. Pour créer une interface Web autour de cette boucle, le guide Inférence en direct avec Streamlit l'intègre dans une application.

Exemple pratique : compter chaque personne une seule fois#

« 22 personnes par image » n'est pas le nombre que l'on cherche ; on veut savoir « combien de personnes sont passées ». Le suivi multi-objets relie les boîtes d'une image à l'autre, et le mode Track attribue à chaque objet un ID dans boxes.id :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
source = "https://github.com/ultralytics/assets/releases/download/v0.0.0/solutions_ci_demo.mp4"

seen = set()
for result in model.track(source, stream=True, persist=True, classes=[0], tracker="bytetrack.yaml", verbose=False):
    if result.boxes.is_track:
        seen.update(result.boxes.id.int().tolist())
print(f"{len(seen)} unique people tracked")

32 unique people tracked

is_track correspond à False dans les images précédant la confirmation d'une piste, lorsque boxes.id vaut None. Utilise les ID pour compter, tracer des trajectoires ou appliquer une logique du type « cet objet est ici depuis 3 secondes ».

Si tu omets tracker, Ultralytics utilise tracktrack.yaml, la valeur par défaut actuelle ; le mode Track propose aussi ocsort.yaml, deepocsort.yaml et fasttrack.yaml. Le choix et le réglage des suiveurs, ainsi que la création de comptages d'objets, de cartes thermiques et d'estimations de vitesse à partir de ces suiveurs, sont abordés dans Suivre des objets avec ByteTrack, BoT-SORT et TrackTrack.

Exemple pratique : créer ta propre boucle de caméra#

Les applications réelles lisent souvent elles-mêmes les images — pour les redimensionner, les recadrer, les horodater ou partager une caméra avec d'autres codes — puis les transmettent au modèle. Dans ce cas, persist=True permet au suiveur de rester actif entre les appels :

import cv2

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
cap = cv2.VideoCapture("solutions_ci_demo.mp4")  # saved locally by the commands above; or 0, or an rtsp:// URL

seen = set()
while cap.isOpened():
    ok, frame = cap.read()
    if not ok:
        break
    result = model.track(frame, persist=True, classes=[0], tracker="bytetrack.yaml", verbose=False)[0]
    if result.boxes.is_track:
        seen.update(result.boxes.id.int().tolist())
cap.release()
print(f"{len(seen)} unique people, highest ID {max(seen)}")

32 unique people, highest ID 67

Même 32 personnes que dans track.py. Note que l'ID le plus élevé est 67, et non 32 : le suiveur attribue aussi des ID à des pistes provisoires qui ne sont jamais confirmées, d'où les discontinuités dans les ID.

Suivre la cadence de la source#

Une caméra à 30 FPS fournit une image toutes les 33 ms, et la cadence effective correspond à la plus lente des étapes de décodage, d'inférence et d'écriture. Sur le CPU de notre ordinateur portable, yolo26n a pris entre 26 et 46 ms par image de 384×640 au fil des exécutions, selon les autres tâches effectuées par la machine : le temps atteint ou dépasse le budget, sans aucune marge. Si ton système ne suit pas la cadence, essaie ces leviers dans l'ordre :

L'utilisation simultanée de plusieurs caméras et le multithreading associé sont abordés dans Inférence mult flux.

Éviter ces erreurs#