--- title: Vision temps réel légère : comment une petite puce « voit » en direct source: https://synapx.fr/blog/vision-temps-reel-edge/ date: 2026-06-26 category: IA site: SynapxLab --- # Vision temps réel légère : comment une petite puce « voit » en direct Comment un module d'edge AI à quelques dizaines d'euros — comme le **TFL-1** ukrainien, mais aussi un robot agricole, une caméra de comptage ou un drone d'inspection — arrive-t-il à **détecter et suivre une cible en temps réel**, sans cloud, sans liaison radio ? Non pas avec un système à 5 000 €, mais avec une **chaîne de traitement bien pensée** et un **petit modèle spécialisé**. Cet article décortique le **pipeline complet** et donne le plan pour le reconstruire avec du matériel civil. > Le secret n'est pas la puissance brute : c'est la **spécialisation**. Un modèle distillé qui ne sait faire qu'**une** chose, mais très vite et localement, bat un mastodonte cloud sur le terrain. ## La chaîne complète (le pipeline) Tout part de la caméra, tout finit en une décision. Entre les deux, **5 étages** qui s'enchaînent à chaque image : ``` Caméra ──► Prétraitement ──► Détection ──► Tracking ──► Décision 30 FPS resize/norm "où ?" "la même ?" "j'agis" ``` | Étage | Rôle | Techno typique | |---|---|---| | **1. Capture** | Flux vidéo brut (souvent 30 FPS) | OpenCV, GStreamer, libcamera | | **2. Prétraitement** | Redimensionner, normaliser, recadrer | OpenCV, NumPy (sur GPU/NPU si possible) | | **3. Détection** | « Y a-t-il un objet, et **où** ? » | YOLO, SSD, NanoDet | | **4. Tracking** | « Est-ce **le même** objet qu'à l'image d'avant ? » | ByteTrack, SORT, KCF, flux optique | | **5. Décision** | Verrouillage, alerte, commande moteur | Logique métier + filtre de Kalman | Le tout doit boucler **avant l'image suivante**. À 30 FPS, cela laisse **~33 ms par tour**. Telle est la contrainte centrale. ## L'étage clé : la détection C'est lui qui « voit ». La famille de référence en edge est **YOLO** (*You Only Look Once*) : un seul passage du réseau donne, d'un coup, **les boîtes englobantes + les classes** de tous les objets de l'image. - **YOLO** (Ultralytics, versions *nano*/`n`) — la référence, du plus léger au plus puissant. - **NanoDet / NanoDet-Plus** — ultra-léger, pensé mobile/embarqué. - **SSD-MobileNet** — un classique encore très utilisé sur Coral / microcontrôleurs. > ⚖️ **Le compromis fondamental** : un gros modèle voit *tout*, mais lentement. Un petit modèle ne voit que ce pour quoi on l'a entraîné — mais à **60+ FPS sur une puce à 30 €**. Pour de l'embarqué, on choisit **toujours** le petit, et on l'entraîne sur **un jeu de données restreint et ciblé**. ## Comment on rend le modèle léger ? Un YOLO « brut » est trop lourd pour une petite puce. Trois leviers le compressent **sans trop perdre** en précision : | Technique | Principe | Gain | |---|---|---| | **Quantification** | Passer les poids de 32 bits flottants à **8 bits entiers (INT8)** | ÷4 mémoire, ×2–4 vitesse | | **Distillation** | Un gros modèle « professeur » entraîne un petit « élève » | Petit modèle, précision quasi préservée | | **Pruning (élagage)** | Supprimer les connexions inutiles du réseau | Réseau plus maigre, plus rapide | > La **quantification INT8** est le levier n°1 en edge : c'est ce qui permet à un Jetson ou un NPU de tenir le temps réel. La perte de précision est souvent **négligeable** pour une tâche spécialisée. ## L'étage qu'on oublie : le tracking Détecter, c'est bien. Mais à chaque image, le détecteur **repart de zéro** — il ne sait pas que la boîte d'aujourd'hui est le même objet qu'hier. Le **tracking** fait ce lien : - **SORT / ByteTrack** — associent les détections d'une image à l'autre via un **filtre de Kalman** (prédiction de trajectoire) + association. Rapides, robustes, standard. - **KCF / CSRT** (OpenCV) — trackers « visuels » qui suivent une zone sans redétecter à chaque frame → **très peu de calcul**. - **Flux optique** (Lucas-Kanade) — suit le **mouvement des pixels** entre deux images, utile pour combler les trous. > 🎯 **L'astuce temps réel** : on ne lance pas le détecteur (coûteux) à **chaque** image. On détecte **1 image sur 5**, et entre deux, un tracker léger (KCF, flux optique) maintient le verrouillage **quasi gratuitement**. C'est ce qui débloque les hauts FPS sur petite puce. ## Tourner en temps réel : le matériel Le modèle léger ne suffit pas — il faut le **bon accélérateur**. Voici ce qui fait tourner ce pipeline, du moins onéreux au plus puissant : | Matériel | Accélérateur | Pour quoi | Prix ~ | |---|---|---|---| | **ESP32-S3** | mini-NPU | Détection binaire (présence/absence) | 3–8 € | | **Google Coral USB** | Edge TPU | Booste un Raspberry Pi (INT8) | 60–80 € | | **Raspberry Pi 5 + Hailo-8L** | NPU 13 TOPS | Vision temps réel polyvalente | ~140 € | | **NVIDIA Jetson Orin Nano** | GPU CUDA | Modèles plus lourds, multi-flux | 250–400 € | > Sur NVIDIA, le compilateur **TensorRT** optimise le modèle pour le GPU exact de la carte (fusion de couches, INT8) → souvent **×2 à ×5** de débit. Sur Hailo/Coral, c'est leur SDK (HailoRT / Edge TPU compiler) qui fait ce travail. ## La robustesse : pourquoi traiter la vision en local C'est tout l'intérêt de faire la vision **sur la puce**, et pas dans le cloud : - **Pas de réseau requis** → insensible à la perte de signal, au brouillage, à la latence. - **Décision locale** → la boucle perception→action tient en **millisecondes**, pas en allers-retours cloud. - **Confidentialité** → aucune image ne sort de l'appareil (RGPD-friendly par construction). C'est exactement le principe du *« fire and forget »* du TFL-1 : une fois la cible accrochée, **plus besoin de personne** — le calculateur embarqué tient seul. Le même principe sert un **robot agricole** qui suit un rang de vigne hors couverture réseau, ou une **caméra de comptage** dans un tunnel. ## Le plan de montage (côté code) Le squelette d'un pipeline temps réel tient en quelques lignes — ici en Python avec OpenCV + Ultralytics : ```python import cv2 from ultralytics import YOLO model = YOLO("yolo11n.pt") # modèle "nano", léger cap = cv2.VideoCapture(0) # flux caméra frame_id = 0 while True: ok, frame = cap.read() if not ok: break # Détection + tracking intégré (ByteTrack) en un appel results = model.track( frame, persist=True, # garde les IDs entre les images tracker="bytetrack.yaml", imgsz=320, # petite résolution = plus de FPS verbose=False, ) # results[0].boxes contient boîtes + classes + ID de tracking annotated = results[0].plot() cv2.imshow("edge vision", annotated) if cv2.waitKey(1) == 27: # Échap break frame_id += 1 cap.release() cv2.destroyAllWindows() ``` > Pour passer en **production embarquée** : exporter le modèle (`model.export(format="engine")` pour TensorRT, ou `format="hef"` pour Hailo), réduire `imgsz`, quantifier en **INT8**, et ne détecter qu'**1 frame sur N** en s'appuyant sur le tracker pour le reste. ## La recette, en une phrase **Petit modèle spécialisé** (YOLO-nano distillé) + **quantification INT8** + **tracking léger** entre deux détections + **NPU à 30–140 €** = vision temps réel **locale, souveraine et robuste**. La perf ne vient pas du prix du matériel — elle vient de l'**architecture du pipeline** et de la **spécialisation du modèle**. ## ❓ FAQ **Faut-il un GPU à 1 500 € pour faire de la vision temps réel ?** Non. Un Raspberry Pi 5 + accélérateur Hailo-8L (~140 €) ou un Jetson Orin Nano (~300 €) suffisent largement pour détecter et suivre des objets à 30+ FPS, à condition d'utiliser un modèle léger quantifié. **Quelle différence entre détection et tracking ?** La détection répond à « où est l'objet sur cette image ? » (elle repart de zéro à chaque frame). Le tracking répond à « est-ce le même objet que sur l'image précédente ? » en lui attribuant un ID stable. On combine les deux : détecter de temps en temps, tracker entre-temps. **Comment tenir le temps réel sur une petite puce ?** Trois leviers : un modèle léger (YOLO-nano, NanoDet), la quantification INT8 (÷4 mémoire), et ne pas redétecter à chaque image — un tracker léger (KCF, flux optique, ByteTrack) comble les images intermédiaires presque gratuitement. **Pourquoi faire la vision en local plutôt que dans le cloud ?** Pour la latence (décision en millisecondes), la robustesse (fonctionne sans réseau, insensible au brouillage) et la confidentialité (aucune image ne sort de l'appareil). C'est le cœur de l'edge AI souverain. --- > La vision temps réel embarquée n'est plus un sujet de laboratoire. Avec un modèle ouvert, un peu d'optimisation et une puce à quelques dizaines d'euros, on reconstruit **chez soi** ce qui, hier encore, demandait une station de travail — sans cloud, sans abonnement, sans fuite de données.