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 :

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.