Dans cette deuxième partie, Frédéric vous invite à entraîner le modèle d’IA que vous avez créé précédemment. Ici vous verrez comment créer le modèle local sous Linux
Au sommaire :
Entraînement du modèle IA sous Linux
Pour réaliser l’apprentissage de notre modèle, plusieurs solutions se présentent à nous :
- entraîner le modèle en local, sous linux
- ou en ligne, dans le cloud, sur Google Colab => NON TRAITE DANS CET ARTICLE
Entraînement du modèle sous linux
il ne sera pas possible de réaliser cette étape directement sur un Raspberry PI
En effet, l’entraînement de l’IA nécessite beaucoup de calculs et donc de ressources (mémoire/cpu/gpu),
il est fortement recommandé d’utiliser un PC puissant équipé d’une bonne grosse carte GPU
Cette solution est techniquement très intéressante et mais surtout très chronophage !!! car elle nécessite pas mal de configuration sous Linux pour installer l’ensemble des outils et leurs dépendances !
Mais, fort heureusement HAILO propose des environnements pré-configurés sous forme de conteneur Docker
L’environnement Docker s’installe et s’utilise en quelques lignes :
|
1 2 3 4 5 6 |
git clone https://github.com/hailo-ai/hailo_model_zoo.git cd hailo_model_zoo/training/yolov8 docker build --build-arg timezone=`cat /etc/timezone` -t yolov8:v0 . docker run --name "yolov8" -it --gpus all --ipc=host -v /data_1:/data yolov8:v0 |
Dans le DOCKER YOLOv8
Nous voila dans le conteneur Docker Yolo8 !!!
A noter que le répertoire /data du conteneur est mappé avec le répertoire /data_1 de la machine Linux hôte
–> cela permettra d’extraire les résultats des traitements
Nous pouvons dans, un premier temps, vérifier détection correcte de la carte vidéo et des drivers CUDA
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
$ nvidia-smi Sun Feb 2 15:08:44 2025 +-----------------------------------------------------------------------------------------+ | NVIDIA-SMI 550.120 Driver Version: 550.120 CUDA Version: 12.4 | |-----------------------------------------+------------------------+----------------------+ | GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC | | Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. | | | | MIG M. | |=========================================+========================+======================| | 0 NVIDIA GeForce RTX 4070 ... Off | 00000000:01:00.0 On | N/A | | 0% 42C P2 41W / 285W | 418MiB / 16376MiB | 0% Default | | | | N/A | +-----------------------------------------+------------------------+----------------------+ +-----------------------------------------------------------------------------------------+ | Processes: | | GPU GI CI PID Type Process name GPU Memory | | ID ID Usage | |=========================================================================================| +-----------------------------------------------------------------------------------------+ |
Ensuite , nous allons créer 2 répertoires
- l’un pour le Dataset
- l’autre pour les résultats des traitements
|
1 2 |
mkdir /data/my_dataset mkdir /data/my_yolo8s |
Récupération (téléchargement) de notre Dataset
Comme nous l’avons vu plus haut, il existe plusieurs méthodes pour retrouver son Dataset précédemment créé sur Robotflow
Une des méthodes les plus simples est d’utiliser la commande « curl » :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
apt install curl unzip cd /data/my_dataset curl -L "https://app.roboflow.com/ds/MtF5ewIPDd?key=DtuQjJYrBl" > roboflow.zip; unzip roboflow.zip; rm roboflow.zip root@50b81f5f3e9f:/data/my_dataset# ls -l -rw-r--r-- 1 root root 150 Jan 24 13:16 README.dataset.txt -rw-r--r-- 1 root root 1190 Jan 24 13:16 README.roboflow.txt -rw-r--r-- 1 root root 299 Jan 24 13:16 data.yaml drwxr-xr-x 4 root root 4096 Jan 24 13:16 test drwxr-xr-x 4 root root 4096 Jan 24 13:16 train drwxr-xr-x 4 root root 4096 Jan 24 13:16 valid |
YOLO – Entrainement
VOILA !!! Nous y sommes !!! … nous allons maintenant lancer le traitement d’apprentissage de notre IA
|
1 2 3 |
cd /data/my_yolo8s yolo task=detect mode=train model=yolov8s.pt data=/data/my_dataset/data.yaml epochs=100 batch=8 |
👉 Objectif : Entraîner le modèle YOLOv8 sur notre dataset personnalisé pendant 100 époques avec une taille de batch de 8.
Nous utilisons yolov8s.pt comme modèle de départ pour apprend à détecter les objets.
… et après un certain temps, parfois plusieurs heures ….. ( ici, un peu moins d’une heure)
Notre IA est là !
- les graph des données statistiques sont générés
 |
 |
 |
 |
le réseau de neurones que nous allons exploiter est dans fichier best.pt
|
1 2 3 4 |
root@50b81f5f3e9f:/data/my_yolo8s# ls -l /workspace/ultralytics/runs/detect/train/weights/ total 43968 -rw-r--r-- 1 root root 22510584 Feb 2 15:52 best.pt -rw-r--r-- 1 root root 22510584 Feb 2 15:52 last.pt |
YOLO – Validation
|
1 |
yolo task=detect mode=val model=/workspace/ultralytics/runs/detect/train/weights/best.pt data=/data/my_dataset/data.yaml |
👉 Objectif : Tester la performance du modèle best.pt sur les images de validation définies dans data.yaml.
cette étape génère des métriques (mAP, précision, rappel) pour évaluer la qualité du modèle.
résultat :
|
1 2 3 4 5 6 7 8 9 10 11 |
Ultralytics YOLOv8.0.55 🚀 Python-3.8.5 torch-2.0.0+cu117 CUDA:0 (NVIDIA GeForce RTX 4070 Ti SUPER, 16069MiB) Model summary (fused): 168 layers, 11127132 parameters, 0 gradients, 28.4 GFLOPs val: Scanning /data/my_dataset/valid/labels.cache... 80 images, 0 backgrounds, 0 corrupt: 100%|██████████| 80/80 [00:00<?, ?it/s] Class Images Instances Box(P R mAP50 mAP50-95): 100%|██████████| 5/5 [00:01<00:00, 3.80it/s] all 80 80 0.978 0.98 0.989 0.921 hexagon 80 21 0.979 0.952 0.99 0.916 round 80 19 0.939 1 0.974 0.901 square 80 20 1 0.967 0.995 0.965 triangle 80 20 0.994 1 0.995 0.899 Speed: 1.8ms preprocess, 2.8ms inference, 0.0ms loss, 0.9ms postprocess per image Results saved to /workspace/ultralytics/runs/detect/val |
YOLO – Test d’inférence
|
1 |
yolo task=detect mode=predict model=/workspace/ultralytics/runs/detect/train/weights/best.pt conf=0.25 source=/data/my_dataset/test/images save=True |
👉 Objectif : Exécuter le modèle entraîné (best.pt) sur des nouvelles images avec une confiance minimale de 0.25.
Cette étape sauvegarde les résultats sous forme d’images (images annotées avec les prédictions).
résultat :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Ultralytics YOLOv8.0.55 🚀 Python-3.8.5 torch-2.0.0+cu117 CUDA:0 (NVIDIA GeForce RTX 4070 Ti SUPER, 16069MiB) Model summary (fused): 168 layers, 11127132 parameters, 0 gradients, 28.4 GFLOPs image 1/40 ../../hexagon_mp4-0003_jpg.rf.c293d0bda8579255c22e0bb3adec7517.jpg: 640x640 1 hexagon, 6.0ms image 2/40 ../../hexagon_mp4-0004_jpg.rf.cc7bd017125af4dbd404019b3770f394.jpg: 640x640 1 hexagon, 4.6ms image 3/40 ../../hexagon_mp4-0008_jpg.rf.4fd6e77433c04562e72f935866ce0f6f.jpg: 640x640 1 hexagon, 4.5ms image 4/40 ../../hexagon_mp4-0019_jpg.rf.7d1cf963c7a1ec1475e9835eb22823fe.jpg: 640x640 1 hexagon, 4.4ms ../.. image 18/40 ../../round_mp4-0072_jpg.rf.a7b124ffd4ac510cb800640b2662692c.jpg: 640x640 1 round, 5.2ms image 19/40 ../../round_mp4-0073_jpg.rf.17cc51715ce2f318fbe54c4cf027eb25.jpg: 640x640 1 round, 4.4ms image 20/40 ../../round_mp4-0079_jpg.rf.726d39195525a9379b7a0d027cc95fa2.jpg: 640x640 1 round, 5.3ms image 21/40 ../../square_mp4-0008_jpg.rf.2de6b97777c35ad77243686b52db8fdd.jpg: 640x640 1 square, 4.3ms image 22/40 ../../square_mp4-0031_jpg.rf.51e2987542775d7b404283d2555c1e89.jpg: 640x640 1 square, 4.4ms ../.. image 38/40 ../../triange_mp4-0093_jpg.rf.a5e21f5433c42886dfa68207bf33bcf4.jpg: 640x640 1 triangle, 4.3ms image 39/40 ../../triange_mp4-0094_jpg.rf.ca41d949218064b2667407a288294d54.jpg: 640x640 1 triangle, 4.5ms image 40/40 ../../triange_mp4-0097_jpg.rf.42740df0f5c5443d917efcfb888b12b6.jpg: 640x640 1 triangle, 4.4ms Speed: 0.4ms preprocess, 4.9ms inference, 1.3ms postprocess per image at shape (1, 3, 640, 640) Results saved to /workspace/ultralytics/runs/detect/predict |
 |
 |
|
 |
||
YOLO – Export du modèle au formant ONNX
ONNX (Open Neural Network Exchange) est un format standardisé pour représenter des modèles d’IA compatibles avec plusieurs frameworks (PyTorch, TensorFlow, Hailo, OpenVINO, etc.).
|
1 |
yolo export model=/workspace/ultralytics/runs/detect/train/weights/best.pt imgsz=640 format=onnx opset=11 |
👉 Objectif : Convertir le modèle best.pt en ONNX (format optimisé pour l’inférence sur des accélérateurs comme Hailo).
On spécifie une taille d’image de 640×640 et l’opset=11 (compatibilité avec certains moteurs d’inférence).
opset (Operator Set) définit un ensemble d’opérations que le modèle peut utiliser (par exemple : convolutions, normalisations, activations…).
‘opset=11’ est une version stable qui assure une compatibilité large avec la plupart des moteurs d’inférence comme Hailo
résultat :
|
1 |
ONNX: export success ✅ 0.7s, saved as /workspace/ultralytics/runs/detect/train/weights/best.onnx (42.7 MB) |
YOLO – Sauvegarde
Il est temps maintenant, de copier tous ces résultats en dehors du conteneur Docker dans lequel nous sommes :
|
1 2 3 4 5 6 7 8 9 |
cp -rv /workspace/ultralytics/runs/detect/* /data/my_yolo8s ls -l /data/my_yolo8s drwxr-xr-x 2 root root 4096 Feb 2 16:26 predict drwxr-xr-x 3 root root 4096 Feb 2 16:26 train drwxr-xr-x 2 root root 4096 Feb 2 16:26 val -rw------- 1 root root 6534387 Feb 2 15:23 yolov8n.pt -rw------- 1 root root 22573363 Feb 2 15:23 yolov8s.pt |
Nous pouvons maintenant sortir de notre conteneur Docker YOLOv8
|
1 |
exit |
Conversion du modèle pour le module HAILO
FC (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 :
|
1 2 3 4 5 |
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 »:
|
1 2 3 4 5 6 7 8 |
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 :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
./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.
|
1 2 3 4 |
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
|
1 2 3 4 5 6 |
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 )
|
1 2 3 4 5 6 7 |
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
|
1 2 3 |
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
|
1 2 3 4 5 |
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
|
1 |
exit |
Les articles de cette trilogie :
Sources
Vous pouvez retrouver les images et vidéos sources, ainsi que certains résultats des test et quelques scripts sur le dépôt GitHub suivant :
https://github.com/FredJ21/RPI5_AI_Hailo_tests
Documentation de la suite Hailo :
https://hailo.ai/developer-zone/documentation/hailo-sw-suite-2025-01/
