4.8 Frameworks de pipeline de vision en temps réel

Pourquoi c'est important

Un modèle précis à lui seul ne crée pas un système de vision en temps réel.

Un système fonctionnel a également besoin de :

  • entrée depuis des caméras ou des fichiers
  • décodage et transport des images
  • inférence et post-traitement
  • affichage, stockage ou communication en aval

Toute cette chaîne s'appelle un pipeline.

Cette section présente la réflexion en termes de framework nécessaire pour comprendre les systèmes de vision en temps réel avant de passer à DeepStream et aux services spécifiques à Jetson.

Objectifs d'apprentissage

À la fin de cette section, vous devriez être capable de :

  • expliquer les principales étapes d'un pipeline de vision en temps réel
  • comparer des pipelines applicatifs simples avec des pipelines basés sur un framework
  • comprendre le rôle d'OpenCV et de GStreamer
  • écrire de petits exemples pour lire et traiter de la vidéo en direct
  • penser en termes de flux système de bout en bout plutôt qu'en appels de modèle isolés

Concepts clés / Théorie

Un pipeline en temps réel comporte des étapes

Un pipeline visuel en temps réel typique comprend :

  1. l'entrée source
  2. le décodage et l'acquisition d'images
  3. le prétraitement
  4. l'inférence du modèle
  5. le post-traitement
  6. le rendu, le stockage ou la transmission

Pourquoi les pipelines sont importants

Si une étape est instable ou trop lente, l'ensemble du système en pâtit.

Par exemple :

  • un flux RTSP de mauvaise qualité peut entraîner des pertes d'images
  • un prétraitement lent peut augmenter la latence
  • une surcharge d'affichage inutile peut limiter le débit

OpenCV vs GStreamer

OpenCV est pratique pour l'apprentissage et la logique applicative.

GStreamer est plus puissant lorsque vous avez besoin de pipelines média robustes, de streaming et de flux de données en temps réel.

Les deux sont utiles, mais remplissent des rôles différents.

Termes clés

  • Source : d'où viennent les images
  • Decode : conversion d'une vidéo compressée en images
  • Preprocessing : préparation des images pour l'inférence
  • Post-processing : transformation des prédictions brutes en sortie utile
  • Latency : délai de bout en bout à travers le pipeline
  • Throughput : volume total d'images ou de flux traités

Exemple travaillé / Exemple de code

Pipeline OpenCV en direct simple

python
import cv2
import time

cap = cv2.VideoCapture(0)
prev_time = time.time()

while True:
    ok, frame = cap.read()
    if not ok:
        break

    current_time = time.time()
    fps = 1.0 / (current_time - prev_time)
    prev_time = current_time

    cv2.putText(frame, f"FPS: {fps:.2f}", (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
    cv2.imshow("OpenCV Live Pipeline", frame)

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
cv2.destroyAllWindows()

Exemple GStreamer

bash
gst-launch-1.0 videotestsrc ! videoconvert ! autovideosink

Exemple d'entrée RTSP

bash
gst-launch-1.0 rtspsrc location=rtsp://<camera-ip>/<path> latency=200 ! \
  rtph264depay ! h264parse ! avdec_h264 ! videoconvert ! autovideosink

Idées reçues fréquentes

  • « Le modèle est le pipeline. »
    • Le modèle n'est qu'une étape à l'intérieur du pipeline.
  • « Si j'obtiens 30 FPS sur le benchmark du modèle, tout le système tourne à 30 FPS. »
    • Les performances de bout en bout dépendent de l'ensemble du pipeline.
  • « OpenCV et GStreamer font la même chose. »
    • Ils se chevauchent dans certains domaines, mais ne sont pas le même outil.

Exercices / Réflexion

  1. Dessinez un pipeline en temps réel à cinq étapes pour un détecteur webcam.
  2. Exécutez l'exemple OpenCV et mesurez les FPS approximatifs sur votre machine.
  3. Comparez une entrée fichier vidéo et une entrée caméra en direct. Quelles différences pratiques observez-vous ?
  4. Expliquez pourquoi la latence de bout en bout est souvent plus importante que le seul temps d'inférence du modèle.

Résumé

La vision par ordinateur en temps réel dépend de la conception du pipeline, pas seulement des modèles. Comprendre l'entrée, le décodage, le prétraitement, l'inférence, le post-traitement et la sortie prépare l'apprenant à des frameworks edge plus avancés tels que DeepStream.

Étape suivante suggérée

Poursuivez avec 4.9 DeepStream et Jetson.

Références