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

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

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 :

 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

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

$ 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

mkdir /data/my_dataset
mkdir /data/my_yolo8s

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 » :

 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

VOILA !!! Nous y sommes !!!

… nous allons maintenant lancer le traitement d’apprentissage de notre IA

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

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

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 :

	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

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 :

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

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.).

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 :

	ONNX: export success ✅ 0.7s, saved as /workspace/ultralytics/runs/detect/train/weights/best.onnx (42.7 MB)

Il est temps maintenant, de copier tous ces résultats en dehors du conteneur Docker dans lequel nous sommes :

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

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

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	

… 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

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

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

Les articles de cette trilogie :

Partie 1Partie 2Partie 3

 

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/