5ème et dernière partie : compilation, déploiement, et tests du réseau de neurones
Je vous propose de partager mon retour d’expérience sur la mise en œuvre d’une intelligence artificielle avec le nouveau module HAILO 8 (ou HAILO 8L) intégré dans un Raspberry PI5, capable de reconnaître et différencier divers objets personnels.
Le principe repose sur l’entraînement automatique d’un réseau de neurones, en utilisant les outils YOLO et le compilateur HAILO, à partir d’un ensemble de données constitué d’un certain nombre d’images (le « DataSet »).
Ce réseau de neurones sera ensuite capable d’identifier, avec un taux de certitude donné, les objets pour lesquels il a été entraîné, que ce soit sur des images statiques ou sur un flux vidéo.
Cet article, consacrée à la mise en œuvre d’une intelligence artificielle embarquée sur un Raspberry Pi 5, est composé de 5 grands chapitre :
- Partie 1 : Introduction
- Partie 2 : Config & Tests
- Partie 3 : Créer son jeu de données
- Partie 4 : Entraînement du modèle IA
- Partie 5 : Conversion et Déploiement du modèle
Partie 5.1 : Conversion du modèle
DFC (Dataflow Compiler) est un outil clé du Hailo SDK utilisé pour compiler et optimiser des modèles d’intelligence artificielle (IA) pour les exécuter efficacement sur les accélérateurs Hailo-8.
DFC prend en entrée un modèle d’IA, tel que notre modèle YOLOv8 au format ONNX, et le transforme en un fichier HEF (Hailo Executable Format), qui est un format binaire optimisé pour l’inférence sur les puces HAILO.
Étapes principales du traitement par le compilateur DFC :
- Parsing → Charge le modèle ONNX.
- Quantization → Convertit les poids du modèle en entiers 8 bits (INT8) pour accélérer l’inférence.
- Optimization → Réorganise le modèle pour minimiser la latence et la consommation mémoire.
- Compilation en HEF → Génère un fichier .hef pouvant être exécuté directement sur le module HAILO 8.
Comme pour l’apprentissage, la conversion du modèle est réalisé sur un « Gros » PC sous Linux !
car cette conversion, ou compilation, demande également beaucoup de ressource Cpu, Gpu, Mémoire
Installation de DFC
Le Dataflow Compiler (DFC) fait partie de la suite logiciel proposée par Hailo
Cette suite inclut les outils nécessaires pour compiler, optimiser et exécuter des modèles sur l’accélérateur Hailo-8.
Hailo propose cette suite sous la forme d’un conteneur Docker, ce qui va nous faciliter grandement la tâche !!
Donc, direction : https://hailo.ai/developer-zone/software-downloads/
et téléchargement de l’image Docker
Décompression du fichier :
unzip hailo_ai_sw_suite_2025-01_docker.zip
Archive: hailo_ai_sw_suite_2025-01_docker.zip
inflating: hailo_ai_sw_suite_2025-01.tar.gz
inflating: hailo_ai_sw_suite_docker_run.sh
Nous voici avec un script Shell pour la création et le lancement de l’image Docker
Petit problème :
Ce script crée un répertoire partagé entre l’image Docker et l’hôte Linux dans le répertoire de l’utilisateur courant.
Je préfère travailler sur mon disque /data_1
J’ai donc réalisé quelques modifications pour que l’image Docker « monte » mon disque « /data_1 » :
vi hailo_ai_sw_suite_docker_run.sh
ligne 226 - modification
avant : -v $(pwd)/${SHARED_DIR}/:/local/${SHARED_DIR}:rw \
après : -v /data_1/:/local/${SHARED_DIR}:rw \
ligne 352 - mise en commentaire (ajout de #)
# create_shared_dir
Il suffit maintenant de lancer le script :
./hailo_ai_sw_suite_docker_run.sh
Loading Docker image: /home/fredj21/FRED/hailo_ai_sw_suite_2025-01.tar.gz
INFO: Checking system requirements...
INFO: System requirements check finished successfully.
5baeb41057c7: Loading layer [==================================================>] 976.4MB/976.4MB
c361101a082c: Loading layer [==================================================>] 83.5MB/83.5MB
593a1325c5ed: Loading layer [==================================================>] 12.99MB/12.99MB
69b082334a83: Loading layer [==================================================>] 9.197MB/9.197MB
b2e1817da5c2: Loading layer [==================================================>] 384MB/384MB
71cf924c7ef0: Loading layer [==================================================>] 18.03MB/18.03MB
21f476235018: Loading layer [==================================================>] 3.072kB/3.072kB
11c4c6ec7d5d: Loading layer [==================================================>] 3.072kB/3.072kB
4b7ec45684e6: Loading layer [==================================================>] 3.072kB/3.072kB
9661444da425: Loading layer [==================================================>] 194.9MB/194.9MB
bba85803bb3e: Loading layer [==================================================>] 3.284GB/3.284GB
64951b6189b1: Loading layer [==================================================>] 485.1MB/485.1MB
92b2d02a49ee: Loading layer [==================================================>] 2.184GB/2.184GB
88eb41c2be66: Loading layer [==================================================>] 5.324GB/5.324GB
b3d3a14740d8: Loading layer [==================================================>] 895.5kB/895.5kB
2053f733bc05: Loading layer [==================================================>] 192.6MB/192.6MB
5f70bf18a086: Loading layer [==================================================>] 1.024kB/1.024kB
Loaded image: hailo_ai_sw_suite_2025-01:1
Dans le DOCKER HAILO
… après le télécharge de plusieurs Giga de dépendances …. nous voici dans le Docker HAILO
le répertoire « /local/shared_with_docker » est bien mappé avec le répertoire de l’hôte Linux « /data_1 »
Ce qui permet d’avoir accès au Dataset, au modèle que nous avons entraîné, et à la documentation Hailo.
ls -l /local/shared_with_docker/
drwxrwxrwx 2 hailo ht 4096 Feb 2 22:33 doc
drwxr-xr-x 5 1000 1000 4096 Feb 2 16:21 my_dataset
drwxrwxrwx 8 1000 1000 4096 Feb 3 10:59 my_yolo8s
Nous pouvons également vérifier la présence et de la version des modules Python/Hailo préinstallés
pip list | grep hailo
hailo-dataflow-compiler 3.30.0
hailo-model-zoo 2.14.0 /local/workspace/hailo_model_zoo
hailo-tappas-dot-visualizer 3.31.0 /local/workspace/tappas/tools/trace_analyzer/dot_visualizer
hailo-tappas-run-apps 3.31.0 /local/workspace/tappas/tools/run_app
hailort 4.20.0
Compilation
Il temps maintenant de lancer la compilation de notre fichier ONNX en fichier HEF
A noter :
- l’architecture cible est dépendante du type de carte HAILO que nous possédons : hailo8l ou hailo8
- la calibration peut être réalisée sur les images de test, validation, ou training ( à tester )
cd /local/shared_with_docker/
hailomz compile yolov8s \
--ckpt=my_yolo8s/train/weights/best.onnx \
--hw-arch hailo8 \
--calib-path my_dataset/test/images/ \
--classes 4 --performance
Après quelques heures de patience …
nous obtenons LE fichier HEF compatible avec le module HAILO 8 du notre Raspberry PI
ls *hef
yolov8s.hef
Résultats
Vous pouvez retrouver l’ensemble des résultats de cette compilation, log et fichier Hef, sur mon dépôt GitHub :
https://github.com/FredJ21/RPI5_AI_Hailo_tests
ls -l Results/20250203_result_from_210125_4_shapes_test_v2/hail_result_1
ls -l Results/20250203_result_from_210125_4_shapes_test_v2/hail_result_2
ls -l Results/20250203_result_from_210125_4_shapes_test_v2/hail_result_3
Nous pouvons maintenant sortir de notre conteneur Docker HAILO
exit
Documentation de la suite Hailo :
https://hailo.ai/developer-zone/documentation/hailo-sw-suite-2025-01/
Partie 5.2 : Déploiement du modèle & tests
Dernière étape !! le test final !!
Pré-requis
Pré-requis pour tester son IA fraîchement compilée :
- Installation et configuration du Raspberry PI5 : Assurez-vous que votre Raspberry PI5 est correctement installé et configuré.
- Installation des exemples proposés par HAILO : Ces exemples permettent de récupérer les dépendances nécessaires ainsi que l’environnement d’exécution.
- Création d’un fichier de configuration JSON : Ce fichier définira les paramètres requis par votre application.
- Utilisation du fichier .hef préalablement copié sur le Raspberry PI pour l’utiliser lors de l’exécution.
Installer et configurer correctement son Raspberry PI5
Documentation officielle :
https://www.raspberrypi.com/documentation/accessories/ai-hat-plus.html
https://www.raspberrypi.com/documentation/computers/ai.html
Un bref résumé ici :
Module AI HAILO Raspberry PI5 – Partie 2 : Config & Tests
Installer les exemples proposés par HAILO
git clone https://github.com/hailo-ai/hailo-rpi5-examples.git
cd hailo-rpi5-examples
./install.sh
Le fichier de configuration
Le fichier de configuration JSON est utilisé pour paramétrer le modèle de détection d’objets.
3 paramètres :
- detection_threshold : 0.5 → Seulement les objets avec une confiance ≥ 50% seront détectés.
- max_boxes : 200 → Limite le nombre d’objets détectés à 200 par image.
- labels → Liste des classes d’objets que le modèle peut détecter
Nous devons créer ce fichier :
vi my_labels.json
{
"detection_threshold": 0.5,
"max_boxes":200,
"labels": [
"unlabeled",
"hexagon",
"round",
"square",
"triangle"
]
}
Exécution
Afin de faciliter l’exécution, j’ai créé un petit script Shell sur mon dépôt GitHub :
https://github.com/FredJ21/RPI5_AI_Hailo_tests
Dans le répertoire « Scripts »
vi test_my_IA.sh
# chemin du projet
MY_REP=/home/pi/FRED/RPI5_AI_Hailo_tests/Results/20250203_result_from_210125_4_shapes_test_v2
# nom du fichier de configuration
MY_LAB=my_labels.json
# chemin vers le fichier .hef
MY_HEF=hailo_result_1/yolov8s_with_test_img.hef
# chargement de l’environnement
cd /home/pi/FRED/hailo-rpi5-examples
source setup_env.sh
# lancement de la caméra et de la détection
python3 basic_pipelines/detection.py \
--hef-path ${MY_REP}/${MY_HEF} \
--labels-json ${MY_REP}/${MY_LAB} \
--input rpi
Let’s GO !!!
./test_my_IA.sh
Test final réussi !
La puce HAILO8 exécute le modèle d’IA avec une très bonne précision. La reconnaissance des objets s’effectue en temps réel, démontrant la puissance et l’efficacité du système.
Tous les paramètres et configurations se sont révélés corrects, ce qui confirme la fiabilité de notre pipeline de déploiement et l’optimisation du fichier .hef.
C’est une validation concrète de notre travail de compilation et d’intégration sur le Raspberry PI5 !
En vidéo
Conclusion
Nous avons donc décrit les grandes étapes de la mise en oeuvre d’une intelligence artificielle de traitement vidéo pour la reconnaissance d’objet par Rasberry PI5
- création du Dataset,
- entraînement avec Yolo,
- conversion avec le compilateur Hailo
- déploiement sur le Raspberry
Il est vrai que ce travail est assez fastidieux et plutôt chronophage. Le processus d’apprentissage de l’IA peut être perturbé par de nombreuses raisons et ne pas donner le résultat escompté. Certains biais peuvent rapidement parvenir selon le choix et/ou la qualité des images de son Dataset. Les erreurs seront alors visibles uniquement lors des tests finaux. Il faudra alors reprendre son travail dès le départ.
De plus, ces traitements demandent de posséder une grosse machine équipée d’un CPU et d’un GPU puissants pour réaliser les calculs, même si certaines solutions restent possibles dans le cloud.
Mais l’arrivée des modules IA pour le Raspberry PI est une vraie révolution ! La puce Hailo est conçue pour accélérer l’exécution des réseaux de neurones en prenant en charge les calculs d’inférence, ce qui permet d’analyser rapidement des vidéos ou des images en temps réel. Cela se traduit par une faible consommation d’énergie et une réduction de la charge sur le processeur principal du Raspberry Pi, rendant ainsi le dispositif plus efficace pour des applications d’intelligence artificielle embarquée.
… et toujours au format carte de crédit !
Sources
https://www.raspberrypi.com/documentation/accessories/ai-hat-plus.html
https://www.raspberrypi.com/documentation/computers/ai.html
https://github.com/hailo-ai/hailo-rpi5-examples
https://github.com/hailo-ai/hailo_model_zoo
https://hailo.ai
https://hailo.ai/developer-zone/software-downloads
https://hailo.ai/developer-zone/documentation/hailo-sw-suite-2025-01
et sur mon GitHub :
https://github.com/FredJ21/RPI5_AI_Hailo_tests
https://github.com/FredJ21/RPI5_AI_Hailo_tests/tree/main/Doc