Dans cette seconde partie, le Raspberry Pi 5 passe à l’action avec la vidéo temps réel accélérée par Hailo-10H. Détection de personnes, cadrage dynamique, pose squelette et reconnaissance des mains : on enchaîne les modèles concrets. L’objectif est d’évaluer les performances réelles, les limites, et les bons compromis en situation réelle. Ici, pas de cloud ni de GPU : uniquement du calcul embarqué, optimisé et mesurable.

Raspberry Pi AI HAT+ 2 : vision par ordinateur en vidéo avec Hailo-10H

On part donc d’une base saine : le Raspberry Pi 5 est opérationnel, la Raspberry Pi AI HAT+ 2 (Hailo-10H) est correctement reconnue, les pilotes sont installés et les outils Hailo fonctionnent. Bref, le matériel répond présent et la chaîne logicielle est en place. Dans la partie précédente, nous avons déjà validé un premier usage concret de l’accélérateur avec un LLM local : un texte a été traduit de l’anglais vers le français à l’aide de Qwen, ce qui a permis de vérifier que l’environnement était fonctionnel et que le Hailo-10H pouvait être exploité dans un cas réel.

Dans cette partie 2, on change complètement d’échelle et de nature de calcul. On passe du texte à la vidéo temps réel, avec tout ce que cela implique : flux continus, latence,  performances, et enchaînement de modèles d’IA. L’objectif est simple : reprendre des types de démos déjà explorées avec le Hailo-8 (détection, pose, etc.), telles qu’elles étaient présentées dans l’article https://www.framboise314.fr/module-ai-hailo-8l-pour-le-raspberry-pi-5/ et observer ce que change réellement le Hailo-10H.

Les vidéos utilisées ne seront pas forcément les mêmes, mais ce n’est pas l’essentiel. Le but est avant tout de vérifier comment le Hailo-10H traite la vidéo, comment les pipelines sont organisés, et ce que cela permet en termes de fluidité, de complexité des modèles, et de nouvelles possibilités : détection de personnes, pose squelette, mains, et gestion des ROI.

Comprendre le pipeline vidéo Hailo : entrée → inférence → sortie

Avant de lancer la moindre démo, il est utile de comprendre comment “passe” une vidéo dans une chaîne Hailo. Le principe est toujours le même : on prend un flux (caméra ou fichier), on le prépare (décodage / redimensionnement), on envoie les images au moteur d’inférence sur l’AI HAT+ 2 (Hailo-10H), puis on récupère les résultats pour les afficher (boîtes, squelette, mains…) ou les exploiter autrement.

Sur Raspberry Pi, ces démos s’appuient très souvent sur un pipeline GStreamer : c’est lui qui “colle” les briques entre elles en temps réel, sans que vous ayez à réinventer un lecteur vidéo, un convertisseur d’images et un afficheur.

Le point important : Hailo accélère l’inférence (le “gros calcul” du réseau neuronal), mais il reste toujours un peu de travail côté CPU pour préparer les images et exploiter les résultats. C’est précisément là que l’on va regarder ce qu’apporte le Hailo-10H : fluidité, latence, et possibilité d’enchaîner des modèles (détection → ROI → mains, par exemple) sans que tout s’écroule.

Choix de la source vidéo pour les démos

Pour cette série de tests, l’objectif n’est pas de comparer des vidéos “pixel à pixel” avec celles utilisées dans l’article sur le Hailo-8, mais de valider le comportement du Hailo-10H face à un flux vidéo, quelle qu’en soit la provenance.

Les démos Hailo acceptent plusieurs types de sources :

• Caméra USB (UVC) : simple à mettre en œuvre, idéale pour tester le temps réel.
• Caméra Raspberry Pi (CSI) : intéressante pour mesurer la latence et l’intégration libcamera.
• Fichier vidéo (MP4, MKV…) : pratique pour des tests reproductibles, sans dépendre de l’éclairage ou du mouvement.

Dans la pratique, les pipelines Hailo sont conçus pour être indépendants de la source : que l’image provienne d’une caméra ou d’un fichier, le traitement IA reste identique. C’est un point important, car cela permet de valider les modèles et les performances avant de passer à un usage réellement embarqué.

Pour la suite des tests, nous utiliserons principalement des vidéos de test, puis une caméra, afin d’observer le comportement du Hailo-10H en lecture continue et en conditions proches du temps réel.

Pourquoi on ne peut pas (encore) à lancer une démo vidéo depuis hailo_model_zoo ?

On a bien une base saine (Pi 5 + AI HAT+ 2 / Hailo-10H OK), mais il faut distinguer deux mondes :

• hailo_model_zoo : c’est surtout un dépôt “modèles + outils” (configs, post-processing, utilitaires). Il peut fournir des modèles (ONNX/TF) et des HEF (binaire exécutable Hailo), mais ce n’est pas le dépôt “démos vidéo prêtes à lancer” sur Raspberry Pi.
• Les démos vidéo Raspberry Pi : elles sont regroupées dans le dépôt hailo-rpi5-examples, avec des pipelines orientés flux (GStreamer) et des scripts Python comme basic_pipelines/detection.py.

Dans notre cas, la vérification est simple : dans ~/hailo_model_zoo on ne trouve pas de script de démo type basic_pipelines/detection.py, et la commande hailomz n’existe pas non plus (donc le paquet n’a pas été installé). Bref : le Model Zoo est présent sur le disque, mais les exemples “vidéo” ne sont pas installés.

Installer les exemples vidéo Hailo “Raspberry Pi 5” (ceux qu’on va utiliser pour Videos/foule.mp4)

Par “exemples vidéo Hailo pour Raspberry Pi 5”, il faut entendre des programmes de démonstration capables de lire un flux vidéo (caméra ou fichier MP4), d’exécuter l’inférence sur le Hailo-10H et d’afficher le résultat à l’écran. Il ne s’agit pas de vidéos fournies par Hailo, mais bien d’outils logiciels auxquels on envoie nos propres fichiers vidéo en entrée.

Hailo indique d’ailleurs que, pour le Raspberry Pi 5, il faut passer par le dépôt Hailo Raspberry Pi 5 Examples (plutôt que TAPPAS directement). :contentReference[oaicite:1]{index=1}

1. Cloner le dépôt des exemples :
   
   cd ~ git clone https://github.com/hailo-ai/hailo-rpi5-examples.git

   1 2	cd ~ git clone https://github.com/hailo-ai/hailo-rpi5-examples.git

   
   
2. Vérifier qu’on a bien la démo “detection vidéo” (zéro supposition, on contrôle) :
   
   ls -la ~/hailo-rpi5-examples/basic_pipelines

   1	ls -la ~/hailo-rpi5-examples/basic_pipelines

   
   Le fichier attendu est basic_pipelines/detection.py.
   Les programmes sont bien installés.
3. Repérer le mode d’exécution prévu par le dépôt (script d’environnement, Docker, etc.) :
   
   ls -la ~/hailo-rpi5-examples

   1	ls -la ~/hailo-rpi5-examples

   
    

Cette étape permet de vérifier que tous les éléments nécessaires sont bien en place : les programmes de démonstration, la documentation associée et les scripts fournis par Hailo. On peut ainsi poursuivre les tests dans de bonnes conditions.

L’idée ici est d’identifier ce que le dépôt fournit réellement (script de setup, doc d’install),
avant de lancer la moindre commande “magique”.

Une fois ces exemples en place, on pourra attaquer la suite (la première exécution sur ~/Videos/foule.mp4)
avec le bon script, dans le bon environnement — et mesurer la fluidité (FPS/latence) en scène chargée.

Détection d’objets sur une vidéo de foule

On commence volontairement par un test simple et parlant : une vidéo de foule. L’objectif n’est pas encore de faire de la pose ou du comptage, mais de vérifier deux points essentiels :

• le Hailo-10H est-il capable de traiter correctement un fichier vidéo, et pas uniquement un flux caméra ?
• le traitement reste-t-il fluide (FPS, latence) lorsque la scène devient dense ?

Étape 1 : Préparer la vidéo de test

Copiez votre fichier vidéo (au format MP4 de préférence) dans le dossier Videos de votre Raspberry Pi. Par exemple :

La vidéo doit être encodée en H.264, sans piste audio (ou avec une piste ignorée). Le contenu exact de la vidéo importe peu à ce stade : l’important est qu’elle contienne plusieurs personnes en mouvement afin de solliciter réellement le pipeline.

Étape 2 : Mettre en place l’environnement des exemples Hailo (RPi5)

Pour les tests vidéo (détection, pose, segmentation…), nous n’allons pas utiliser le Model Zoo directement. Les démos “prêtes à lancer” sont fournies dans le dépôt hailo-rpi5-examples, qui s’appuie sur un virtualenv afin d’isoler les dépendances Python du système.
Cette étape se fait une seule fois : on installe, puis on vérifie que l’environnement est bien opérationnel.

Se placer dans le dépôt

Lancer l’installation

Cette étape est relativement longue : plusieurs dépendances Python et composants Hailo sont installés. Vous pouvez aller vous faire un café ☕. À la fin, le script doit avoir créé (ou réutilisé) le virtualenv venv_hailo_rpi_examples.

Création de l’arborescence attendue par les exemples

Les scripts des pipelines Hailo s’attendent à trouver les modèles et certaines bibliothèques dans le répertoire /usr/local/hailo. Ce répertoire n’existe pas par défaut sur Raspberry Pi OS : il faut donc le créer.

Lien vers les modèles Hailo (.hef)

Les modèles Hailo sont installés par le paquet hailo-models dans /usr/share/hailo-models, alors que les exemples les recherchent dans /usr/local/hailo/resources/models.
On crée donc un lien symbolique pour rendre les modèles visibles au bon endroit.

Lien vers les bibliothèques de post-traitement (TAPPAS)

Les bibliothèques de post-traitement Hailo (YOLO, cropper, overlay, etc.) sont fournies par hailo-tappas-core et installées dans /usr/lib/aarch64-linux-gnu/hailo/tappas/post_processes.
Là encore, les exemples les attendent dans /usr/local/hailo/resources/so. On crée donc le lien symbolique correspondant.

Vérification de l’environnement

À ce stade :

• l’environnement Python est actif,
• les modèles Hailo sont accessibles,
• les bibliothèques de post-traitement sont correctement référencées.

Les scripts du dossier basic_pipelines/ sont maintenant prêts à être utilisés
pour analyser une vidéo locale avec l’accélérateur Hailo.

Activer l’environnement de travail

Le prompt doit maintenant indiquer que l’environnement venv_hailo_rpi_examples est actif. Il faudra réactiver cet environnement à chaque fois que vous lancerez le terminal.

Création du fichier de configuration (.env)

Sur Raspberry Pi 5 avec AI HAT+ 2, le script d’installation ne remplit pas automatiquement le fichier .env. Il est donc nécessaire de le créer manuellement.

Y coller exactement le contenu suivant :

Enregistrer et quitter (Ctrl+O, Entrée, Ctrl+X).
Nota : Certaines versions de la documentation Hailo mentionnent un serveur de téléchargement . Sur Raspberry Pi 5 avec AI HAT+ 2, ce téléchargement n’est pas requis, car les modèles et composants sont fournis par les paquets système.

Étape 3 : Vérifier les modèles Hailo installés localement (AI HAT+ 2)

Sur Raspberry Pi 5 équipé de l’AI HAT+ 2 (Hailo-10H), les modèles d’inférence ne sont pas téléchargés depuis Internet lors de l’installation des exemples. Ils sont fournis directement par les paquets Debian officiels Hailo installés sur le système.
Avant de lancer une démo de détection, il est donc indispensable de vérifier que les fichiers .hef (modèles compilés pour le NPU Hailo) sont bien présents localement.

Emplacement des modèles Hailo

Les modèles sont installés automatiquement dans le dossier système suivant :

Depuis un terminal, listez le contenu de ce dossier :

Vous devez obtenir une liste de fichiers .hef, par exemple :

La présence de fichiers contenant _h10 confirme que les modèles sont bien adaptés au NPU Hailo-10H de l’AI HAT+ 2.

Modèle utilisé pour la détection d’objets

Les scripts de détection fournis dans le dossier basic_pipelines/ s’appuient sur des modèles YOLO optimisés pour Hailo. Pour l’AI HAT+ 2, la démo de détection de personnes utilise le modèle suivant :

Aucune copie manuelle ni téléchargement supplémentaire n’est nécessaire : le script accède directement à ce modèle installé par le système.

Vérification rapide (optionnelle)

Pour vérifier explicitement que le modèle requis est bien présent :

Si le fichier existe, l’environnement est correctement configuré et prêt pour exécuter une première détection sur une vidéo locale.
Nous pouvons maintenant passer à l’étape suivante : lancer une démo complète de détection d’objets sur une vidéo avec la chaîne Hailo.

Étape 4 : Lancer une première détection de personnes sur la vidéo

La vidéo de test est déjà en place (Étape 1) et l’environnement Hailo est correctement configuré (Étapes 2 et 3). Nous pouvons maintenant lancer une première démo complète de détection de personnes sur un fichier vidéo local.

Activer l’environnement Hailo

Rappel : À chaque nouvelle ouverture de terminal, l’environnement de travail doit être activé :

Le prompt doit maintenant indiquer que l’environnement venv_hailo_rpi_examples est actif.

Lancer la détection vidéo

Depuis le dossier hailo-rpi5-examples, exécutez la commande suivante :

Une fenêtre vidéo s’ouvre alors automatiquement. Les personnes détectées sont entourées de boîtes, et un indicateur de performance (FPS) est affiché à l’écran.

Résultat attendu

• La vidéo est correctement lue
• Les personnes sont détectées et encadrées
• Le traitement reste fluide, même sur une scène chargée

À ce stade, la chaîne complète est validée : lecture du fichier vidéo, inférence sur le NPU Hailo-10H, post-traitement TAPPAS et affichage en temps réel.

 

Détection d’objets en direct avec une caméra USB sur Raspberry Pi 5 + AI HAT+ 2 (Hailo-10H)

Après les tests sur fichier vidéo, place au temps réel avec une caméra USB. L’objectif est double : vérifier que la webcam est bien reconnue par le Raspberry Pi, puis lancer la détection  d’objets en live via le pipeline Hailo (overlay + FPS).

Vérifier que la caméra USB est détectée

Branchez la caméra, puis listez les périphériques vidéo et l’identification V4L2 :

Vous devez voir une entrée de type USB Live camera avec au moins un /dev/videoX (dans mon cas /dev/video0 et /dev/video1). Cela confirme que la caméra est bien visible côté système.

Tester la caméra sous Raspberry Pi OS (sans IA)

Avant d’introduire l’IA, il est important de vérifier que la caméra fonctionne correctement en affichage direct. Cela permet d’écarter tout problème matériel ou de pilote.

Lancez simplement l’affichage du flux vidéo brut :

Une fenêtre doit s’ouvrir avec l’image de la caméra.

Une légère latence (environ une demi-seconde) est normale à ce stade, car l’affichage se fait en logiciel, sans accélération particulière.

Lancer la détection en direct (caméra USB)

On se place dans le dépôt des exemples, on active l’environnement, puis on lance la démo en mode USB (détection + affichage du FPS) :

Une fenêtre s’ouvre avec l’image de la caméra et les boîtes de détection (overlay). Sur une scène de bureau, la démo détecte non seulement une personne, mais aussi des objets courants (clavier, souris, etc.). La latence observée est d’environ 0,5 s, ce qui reste très exploitable pour de la démonstration et des tests.

Estimation de pose (squelette) en temps réel : état actuel sur Raspberry Pi 5 + AI HAT+ 2

Après la détection d’objets, l’étape suivante logique consiste à tester l’estimation de pose (pose humaine), c’est-à-dire l’identification des articulations du corps (tête, épaules, coudes, hanches, genoux, etc.) et l’affichage d’un squelette en surimpression sur le flux vidéo.

Sur le papier, tout est réuni pour que cette démonstration fonctionne : le modèle yolov8m_pose_h10.hef est bien présent sur le système, fourni par les paquets Debian officiels (/usr/share/hailo-models), et le script basic_pipelines/pose_estimation.py est inclus dans le dépôt hailo-rpi5-examples.

Dans la pratique, sur Raspberry Pi 5 équipé de l’AI HAT+ 2 (Hailo-10H), le lancement de la démo de pose échoue systématiquement avec l’erreur suivante :

Cette erreur indique que le module de post-traitement utilisé pour la pose (libyolov8pose_postprocess.so) appelle une fonction (filter_letterbox) qui n’est pas résolue dans la version actuelle des bibliothèques TAPPAS fournies pour le Raspberry Pi 5. Les vérifications effectuées montrent que ce symbole n’est pas exporté par libgsthailotools.so dans la version hailo-tappas-core 5.1.0 disponible sur Raspberry Pi OS.

Il est important de souligner que ce problème ne provient ni de la configuration de l’utilisateur, ni du fichier vidéo, ni de la caméra USB. La détection d’objets fonctionne correctement dans le même environnement, ce qui confirme que le NPU Hailo-10H et la chaîne GStreamer sont opérationnels. Il s’agit ici d’une incompatibilité logicielle spécifique au pipeline d’estimation de pose dans l’état actuel des paquets fournis pour le Raspberry Pi 5.

Cet état de fait correspond à la situation au moment de la rédaction de cet article. L’AI HAT+ 2 étant encore en phase de lancement, il est très probable que les bibliothèques TAPPAS et les pipelines associés évoluent dans les prochaines semaines. Une mise à jour logicielle lors de la sortie officielle du produit, ou peu après, pourrait corriger cette limitation et rendre l’estimation de pose pleinement fonctionnelle sur Raspberry Pi 5.

Cette partie sera donc réévaluée et mise à jour dès qu’une version corrigée des paquets Hailo sera disponible.

Sources

https://www.raspberrypi.com/products/ai-hat-plus-2/

https://pip-assets.raspberrypi.com/categories/1319-raspberry-pi-ai-hat-2/documents/RP-009655-MM-3-raspberry-pi-ai-hat-plus-2-product-brief.pdf

https://www.raspberrypi.com/documentation/accessories/ai-hat-plus.html

https://hailo.ai/products/hailo-software/model-explorer/generative-ai/devices/hailo-10h/
https://hailo.ai/products/ai-accelerators/hailo-10h-m-2-ai-acceleration-module

Docker : qu’est-ce que c’est et comment l’utiliser ?

 

Les articles sur Framboise314 :

Raspberry Pi AI HAT+ 2 : présentation matérielle et installation sur Raspberry Pi 5

Raspberry Pi AI HAT+ 2 : installer Hailo-10H et lancer un LLM local (Partie 1)

Raspberry Pi AI HAT+ 2 : vision par ordinateur en vidéo avec Hailo-10H (Partie 2)