========================= PARTIE 1 =========================

Fredéric avait déjà présenté des articles sur le Blog, dont le « Raspberry Pi sur la planète Mars« . Membre de l’association de robotique Caliban Fred utilise l’IA pour agrémenter le fonctionnement des ses robots et il a fait un énorme travail sur la création de modules d’IA avec Hailo pour le Raspberry Pi 5, et il m’a proposé de partager sa documentation sur le blog. Vous retrouverez en fin d’article les liens vers le Github qui contient la totalité des travaux de Fred.

Au sommaire :

1 Créer et Entraîner son propre IA pour le module AI HAILO du Raspberry PI5
2 Conclusion de ce premier article
3 Sources
4 Entraînement du modèle IA
5 Conversion du modèle pour le module HAILO
- 5.1 Installation de DFC
- 5.2 Dans le DOCKER HAILO
  - 5.2.1 Compilation
  - 5.2.2 Résultats
6 Sources
7 Déploiement et tests d’un modèle d’IA
- 7.1 Pré-requis
- 7.2 Exécution
8 Vidéo
9 Conclusion

Créer et Entraîner son propre IA pour le module AI HAILO du Raspberry PI5

L’objectif est ici de :

créer une IA de reconnaissance de formes simples
sur la base de ses propres photos ( ou vidéos )
et qui puisse exploiter la puissance d’un module IA d’un Raspberry PI5

Nous pouvons distinguer 4 grandes étapes décrites plus bas :

la création de son jeu de données : le dataset
l’entraînement du modèle IA avec YOLOv8
la conversion, ou compilation, du modèle pour le module HAILO
le déploiement et les tests sur le Raspberry PI

Création de son jeu de donnée

Pour la création du Dataset, différentes méthodes se présentent à nous :

Tout réaliser en local à l’aide d’outils spécifiques et/ou scripts Python
Utiliser une plateforme spécialisée, en ligne, dans le cloud

J’ai commencé, dans un premier temps, par réaliser mon jeu de donnée en local, pour ensuite réaliser des versions plus complexes et certainement plus efficaces sur Roboflow, une plateforme particulière intéressante pour créer et stocker des Dataset.

Je vais donc décrire ces deux approches.

La création du dataset consiste à créer une collection d’images représentatives des objets que l’on souhaite détecter.
Ces images devront être annotés avec l’emplacement et le nom de l’objet visible.

Mais il y a quelques éléments à prendre en considération :

le format du dataset : YOLOv8

YOLOv8 (You Only Look Once v8) est une version avancée de la célèbre famille de modèles YOLO utilisée pour la détection d’objets, la segmentation d’images et la classification.

YOLOv8 est principalement un modèle d’IA de détection d’objets qui utilise un format spécifique pour les datasets.
Ce modèle d’IA est particulièrement adapté et préconisé pour le module HAILO du Raspberry PI.

Autres éléments importants :

YOLOv8, comme ses prédécesseurs, fonctionne mieux avec des images carrées.
la dimension des images de 640×640 pixels (par défaut pour YOLOv8) –> Un bon compromis entre précision et performance.
l’arborescence des répertoires
le format des fichiers d’annotation
le nombre de classes
le nommage des classes ( ex: « carré vert », « rond rouge », triangle « jaune », …. )

Voici un exemple d’organisation du dataset au format YOLOv8 :

	Mon_Dataset/
	├── data.yaml
	├── test
	│   ├── images
	│   └── labels
	├── train
	│   ├── images
	│   └── labels
	└── valid
		├── images
		└── labels

Mon_Dataset/

├── data.yaml

├── test

│ ├── images

│ └── labels

├── train

│ ├── images

│ └── labels

└── valid

├── images

└── labels

On y trouve :

le fichier « data.yaml » qui contient la liste des sous répertoires, le nombre et le nom des classes
3 répertoires : « train », « valid », « test »
contenant chacun 2 sous répertoires : « images » et « labels »

Le fichier label, au format texte (.txt) est donc stocké dans un répertoire différent de l’image correspondante,
mais le lien entre ces deux fichiers est fait par leur nom ( mon_image_12345.jpg –> mon_image_12345.txt )

Enfin, les données doivent être répartis selon un certain ratio :

70 % pour le training –> répertoire « train »
15 % pour la validation –> répertoire « valid »
15 % pour les tests –> répertoire « test »

Nous pourrions également envisager un répartition de 70/20/10 , ou 75/15/10 …. à tester …

Création du Dataset en local

J’ai réalisé de nombreux tests de création de dataset, avec 12 objets différents (12 classes), différents fonds, plusieurs types d’éclairage … mais ça commençait à se compliquer un peu … surtout quand le résultat attendu n’était pas vraiment au rendez vous ….

J’ai donc réduit la voilure avec un Dataset composé de 2 classes : « carré vert » & « carré rouge »

Les fichiers sources, de mes derniers tests, son disponibles dans mon repo GitHub :
https://github.com/FredJ21/RPI5_AI_Hailo_tests

git clone https://github.com/FredJ21/RPI5_AI_Hailo_tests
cd RPI5_AI_Hailo_tests

ls -al Dataset/Fred_Dataset/images_HD_2

git clone https://github.com/FredJ21/RPI5_AI_Hailo_tests

cd RPI5_AI_Hailo_tests

ls -al Dataset/Fred_Dataset/images_HD_2

Les photos

J’ai donc fait plein de photos de mes pièces en veillant, bien évidemment, à réaliser autant de photos pour chacune d’entre elle :

75 photos pour le training dans le répertoire « train » (*)
15 photos pour la validation dans le répertoire « valid » (*)
15 photos pour les tests dans le répertoire « test » (*)

*( pour chaque classe d’objet !!! )

Pour réaliser ces photos, c’est très simple ! il suffit d’utiliser la caméra du Raspberry PI !
Avec la commande suivante :

rpicam-jpeg  --camera ${CAMERA} --output ${FILE} --timeout ${TIMEOUT} --autofocus-mode manual --lens-position 0.0

1	rpicam-jpeg --camera ${CAMERA} --output ${FILE} --timeout ${TIMEOUT} --autofocus-mode manual --lens-position 0.0

Cela produit une image haute définition de 4608×2592 pixels et d’environ 3,3 Mo.

Le script « prendre_une_photo.sh » ( dans le répertoire [GIT]Scripts/bin ) permet d’automatiser la séance !
en prenant une photo toutes les 2 secondes et en répartissant les clichés dans les répertoires : train, valid, et test.
Le nom des fichiers correspond à un horodatage de type timestamp.

ls -al Dataset/Fred_Dataset/images_HD_2/test/*jpg

-rw-r--r-- 1 pi pi 2994083 15 déc.  00:47 Dataset/Fred_Dataset/images_HD_2/test/1734220016.jpg
-rw-r--r-- 1 pi pi 3009538 15 déc.  00:47 Dataset/Fred_Dataset/images_HD_2/test/1734220032.jpg
-rw-r--r-- 1 pi pi 3367522 15 déc.  00:47 Dataset/Fred_Dataset/images_HD_2/test/1734220038.jpg
-rw-r--r-- 1 pi pi 3281630 15 déc.  00:47 Dataset/Fred_Dataset/images_HD_2/test/1734220046.jpg
-rw-r--r-- 1 pi pi 3273484 15 déc.  00:47 Dataset/Fred_Dataset/images_HD_2/test/1734220051.jpg
../..

ls -al Dataset/Fred_Dataset/images_HD_2/test/*jpg

-rw-r--r-- 1 pi pi 2994083 15 déc. 00:47 Dataset/Fred_Dataset/images_HD_2/test/1734220016.jpg

-rw-r--r-- 1 pi pi 3009538 15 déc. 00:47 Dataset/Fred_Dataset/images_HD_2/test/1734220032.jpg

-rw-r--r-- 1 pi pi 3367522 15 déc. 00:47 Dataset/Fred_Dataset/images_HD_2/test/1734220038.jpg

-rw-r--r-- 1 pi pi 3281630 15 déc. 00:47 Dataset/Fred_Dataset/images_HD_2/test/1734220046.jpg

-rw-r--r-- 1 pi pi 3273484 15 déc. 00:47 Dataset/Fred_Dataset/images_HD_2/test/1734220051.jpg

../..

Les labels

Il est temps maintenant d’annoter les images.

Cette opération d’étiquetage consiste à dessiner un cadre de délimitation autour des objets présents sur les photos, tout en précisant sa classe ( « carré vert » ou « carré rouge » ) ?

Cette opération nécessite une certaine précision et un peu de patience !!!
Le cadres doit être serré mais pas trop proche.
Il ne doit pas y avoir de sur ajustement dans le cas ou plusieurs objets sont présents sur la même photo.
( mais par soucis de simplification, mes images ne comportent qu’un seul objet )

Dans mon cas, j’ai choisi de réaliser des photos distinctes par type d’objet. J’ai donc qu’un seul objet par photo.

Je souhaitais également réaliser cette opération complètement en local, sur mon Raspberry PI5, à l’aide d’un utilitaire très léger.
J’ai utilisé « YOLO-Label » que l’on peut trouver ici : https://github.com/developer0hye/Yolo_Label

« YOLO-Label » est également disponible dans une version pré-compilé pour le Raspberry PI 64bits (version Debian/PiOS 12 bookworm) sur mon GIT :

cd RPI5_AI_Hailo_tests//Scripts/bin/Yolo_Label/
chmod +x YoloLabel
./YoloLabel

cd RPI5_AI_Hailo_tests//Scripts/bin/Yolo_Label/

chmod +x YoloLabel

./YoloLabel

(animation d’exemple du site officiel)

L’utilisation est très simple et doit être réalisé sur l’ensemble des photos de DataSet.

on sélectionne le répertoire de travail qui contient les images
on sélectionne la liste des classes ( labels_list.txt )
on choisit une classe
on dessine en carré pour délimiter notre pièce
next …

Tous les fichiers jpeg sont maintenant accompagnés par un fichier texte du même nom mais avec l’extension .txt .

1734219226.jpg	--&gt;  1734219226.txt
1734220832.jpg  --&gt;  1734220832.txt
1734220572.jpg  --&gt;  1734220572.txt
1734219623.jpg  --&gt;  1734219623.txt

1734219226.jpg --> 1734219226.txt

1734220832.jpg --> 1734220832.txt

1734220572.jpg --> 1734220572.txt

1734219623.jpg --> 1734219623.txt

Ces fichiers contiennent 5 valeurs numériques :

$ cat train/1734219226.txt 

1 0.637242 0.526384 0.053579 0.094291

$ cat train/1734219226.txt

1 0.637242 0.526384 0.053579 0.094291

l’index de la classe d’objet (0->carré route, 1->carré vert)
la position en X du centre de l’objet
la position en Y du centre de l’objet
la largeur de l’objet
la hauteur de l’objet

Les coordonnées sont normalisées de 0 à 1 sur la largeur et la hauteur de l’image.

Augmentation du nombre d’image

Nous avons donc, pour l’ensemble de nos objets :

150 photos d’entraînement,
30 photos de validation,
30 photos de test,
les photos sont au format .jpg et d’une dimension de 4608×2592 pixels,
chaque photo est accompagné de son fichier label au format .txt

Il maintenant nécessaire de redimensionner les photos au format 640×640 pixels (pour YOLOv8),
de plus, il est intéressant d’augmenter artificiellement le nombre de photos !!
En effet l’entraînement de l’IA sur un plus grand nombre de photos permettra d’obtenir de meilleurs résultats

Plusieurs solutions permettent d’augmenter le nombre de photos :

recadrer l’image par rapport à l’objet en positionnant l’objet plus ou moins sur la droite ou plus ou moins sur la gauche
–> cette opération permet de passer d’un format de 4608×2592 pixels à un format carré de 640×640 pixels
réaliser une ou plusieurs rotation d’image
ajouter artificiellement du bruit ( des points blancs ou noirs )
réaliser plusieurs itérations par image source

J’ai développé un script Python pour réaliser cela :

cd RPI5_AI_Hailo_tests/Scripts/

python3 -m venv --system-site-packages venv
source venv/bin/activate
pip install -r requirements.txt

cd bin

cat dataset_HD_to_640x640.conf

	{
		"REP_IN"  : "../../Dataset/Fred_Dataset/images_HD_2",
		"REP_OUT" : "/home/pi/My_Dataset/",
		"IMG_FILE_EXT"   : ".jpg",
		"LABEL_FILE_EXT" : ".txt",
		"Nb_Iteration_par_image" : 15,
		"Add_Noise" : 1,
		"Retournement" : 3
	}

cd RPI5_AI_Hailo_tests/Scripts/

python3 -m venv --system-site-packages venv

source venv/bin/activate

pip install -r requirements.txt

cd bin

cat dataset_HD_to_640x640.conf

{

"REP_IN" : "../../Dataset/Fred_Dataset/images_HD_2",

"REP_OUT" : "/home/pi/My_Dataset/",

"IMG_FILE_EXT" : ".jpg",

"LABEL_FILE_EXT" : ".txt",

"Nb_Iteration_par_image" : 15,

"Add_Noise" : 1,

"Retournement" : 3

}

Le fichier de configuration défini les répertoires source et destination, le nombre de bruit, le nombre de retournement d’image
Le script se chargera également de recalculer la nouvelle position, en x et y, de l’objet et ses dimensions afin de produire un nouveau fichier label.

Le répertoire cible (REP_OUT) peut ne pas exister, le script se chargera de créer toute l’arborescence de répertoires.

Go !!!

python dataset_HD_to_640x640.py

1	python dataset_HD_to_640x640.py

Puisque nous avons réalisé 15 itérations, pour lesquels nous avons une version avec et une version sans bruit, et nous avons réalisé 3 retournements en plus de la position de départ … notre Dataset est maintenant plus volumineux :

150 * 15 * 2 * 4 –> 18000 photos le répertoire « train »
30 * 15 * 2 * 4 –> 3600 photos dans le répertoire « valid »
30 * 15 * 2 * 4 –> 3600 photos dans le répertoire « test »

ce qui donne un total de 25200 photos accompagnées de leurs annotations !
en effet :

find /home/pi/My_Dataset -name *jpg | wc -l

	25200

find /home/pi/My_Dataset -name *jpg | wc -l

25200

Notre Dataset est prêt à être utilisé pour l’apprentissage !!!

… mais il est également possible de créer son jeu de données en ligue, dans le cloud

Création du Dataset sur Roboflow

Une autre solution pour réaliser son dataset et l’annotation de ses images, est d’utiliser un outil en ligne.

Roboflow ( https://roboflow.com/ ) est une plateforme tout-en-un qui facilite la gestion, l’annotation, l’augmentation et l’exportation de datasets pour l’entraînement de modèles de vision par ordinateur. Elle est particulièrement utile pour des modèles comme YOLOv8, Faster R-CNN, SSD, et d’autres.

On peut identifier plusieurs fonctionnalités très intéressantes :

Annotation d’images : Interface web collaborative pour annoter rapidement les objets.
Augmentation des données : Ajout automatique de variations (rotation, flou, contraste, etc.) pour améliorer la robustesse du modèle.
Conversion de formats : Compatible avec YOLO, COCO, Pascal VOC, et d’autres standards.
Hébergement & API : Stocke et gère les datasets, avec accès via API pour automatiser les workflows.
Entraînement et déploiement : Intégration avec des frameworks d’IA (PyTorch, TensorFlow) et déploiement dans le cloud ou en edge computing.

Une dès première fonctionnalité très intéressante que j’ai exploitée :

Roboflow permet d’extraire une série de photos depuis une vidéo !!!

Mon nouveau Dataset :

Cette fois ci, pour ce nouveau Dataset, j’ai choisi un nouvel énoncé de départ :

un Dataset avec 4 classes : round, square, triangle, hexagon
les 4 objets sont de couleur identique ( vert )
les images sont extraites de 4 vidéos distinctes
chaque vidéo dure exactement de 20 secondes

Pour réaliser les vidéos, c’est très simple ! il suffit d’utiliser la caméra du Raspberry PI !
Avec la commande suivante :

rpicam-vid --camera 0 -t20000 --autofocus-range normal --autofocus-speed fast -o square.mp4

1	rpicam-vid --camera 0 -t20000 --autofocus-range normal --autofocus-speed fast -o square.mp4

Nous pouvons bien évidemment ajuster les paramètres d’autofocus et autres …

Ces vidéos de départ sont dans le répertoire : Dataset/210125_4_shapes_TEST.sources du dépôt Git :

ls -al Dataset/210125_4_shapes_TEST.sources/

	-rw-rw-r-- 1 fredj21 fredj21 4881188 janv. 29 13:37 hexagon.mp4
	-rw-rw-r-- 1 fredj21 fredj21 4985373 janv. 29 13:37 round.mp4
	-rw-rw-r-- 1 fredj21 fredj21 4848499 janv. 29 13:37 square.mp4
	-rw-rw-r-- 1 fredj21 fredj21 5261945 janv. 29 13:37 triange.mp4

ls -al Dataset/210125_4_shapes_TEST.sources/

-rw-rw-r-- 1 fredj21 fredj21 4881188 janv. 29 13:37 hexagon.mp4

-rw-rw-r-- 1 fredj21 fredj21 4985373 janv. 29 13:37 round.mp4

-rw-rw-r-- 1 fredj21 fredj21 4848499 janv. 29 13:37 square.mp4

-rw-rw-r-- 1 fredj21 fredj21 5261945 janv. 29 13:37 triange.mp4

Direction donc –> http://www.roboflow.com/

Après s’être identifié,
on crée un nouveau projet public de type « Object Detection » avec le nom des différentes classes

Maintenant, dans la section « Upload Data », nous importons chaque vidéo, l’une après l’autre
avec une fréquence d’échantillonnage de 5 images par seconde (choix arbitraire à adapter à ses besoins)

On crée des tâches de type « Manual Labeling », que l’on assigne à soi même.

En effet, la plateforme est collaborative, et permet d’assigner des taches à différentes personnes
Dans la section « Annotate », nous pouvons visualiser les différentes taches restants, la personne en charge de cette tâche, le taux de réalisation

Pas de difficulté lors du labeling, il faut juste veiller à sélectionner la bonne classe …. et avoir un peu de patience !!!

Après avoir annoté l’ensemble des images, nous allons ajouter ces images à notre Dataset en utilisant la méthode « Split Images Between Train/Valid/Test » qui permettra de répartir aléatoirement nos photos pour les besoins de training, validation et test.

Enfin, il nous reste à générer une nouvelle version de notre Dataset en appliquant des opérations de rotation, ajout de bruit, passage de certaines photos en niveau de gris, ….
Le but étant, ici, d’augmenter artificiellement le nombre de photos de notre Dataset

Dans la section « Dataset » –> « Generate Version »

Pour résumer cette création de son jeu de données sur Roboflow:

Nous sommes parti sur la base de :

4 vidéos de 20 secondes
un échantillonnage de 5 images par seconde
ce qui donne : 99 images par classe

Après l »opération de « split », nous obtenons :

70 % Train –> 69 images
20 % Validation –> 20 images
10 % Test –> 10 images

Un total donc, pour l’ensemble des classes de :

276 image de training
80 images de Validation
40 image de Test

Ensuite, la création d’une version du Dataset ( augmentation du nombre d’image)

rotation horizontal et vertical
gris 15% des images
bruit 1.96%

Lors de cet augmentation, nous sommes limité, dans la version gratuite de Roboflow, à 1500 images !
Nous avons donc maintenant :

1380 image de training
80 images de Validation
40 image de Test

Téléchargement du jeu de données

Nous pouvons maintenant télécharger notre Dataset dans de nombreux formats
–> particulièrement au format YOLOv8 pour la suite de notre projet !

l’ensemble des fichiers se trouve dans le répertoire : Dataset/210125_4_shapes_TEST.v2i.yolov8/ du dépôt Git :

ls -l Dataset/210125_4_shapes_TEST.v2i.yolov8

	-rw-rw-r-- 1 fredj21 fredj21  299 févr.  2 08:08 data.yaml
	-rw-rw-r-- 1 fredj21 fredj21  150 févr.  2 08:08 README.dataset.txt
	-rw-rw-r-- 1 fredj21 fredj21 1190 févr.  2 08:08 README.roboflow.txt
	drwxrwxr-x 4 fredj21 fredj21 4096 févr.  2 08:08 test
	drwxrwxr-x 4 fredj21 fredj21 4096 févr.  2 08:08 train
	drwxrwxr-x 4 fredj21 fredj21 4096 févr.  2 08:08 valid


tree Dataset/210125_4_shapes_TEST.v2i.yolov8 -d

	Dataset/210125_4_shapes_TEST.v2i.yolov8
	├── test
	│   ├── images
	│   └── labels
	├── train
	│   ├── images
	│   └── labels
	└── valid
		├── images
		└── labels

ls -l Dataset/210125_4_shapes_TEST.v2i.yolov8

-rw-rw-r-- 1 fredj21 fredj21 299 févr. 2 08:08 data.yaml

-rw-rw-r-- 1 fredj21 fredj21 150 févr. 2 08:08 README.dataset.txt

-rw-rw-r-- 1 fredj21 fredj21 1190 févr. 2 08:08 README.roboflow.txt

drwxrwxr-x 4 fredj21 fredj21 4096 févr. 2 08:08 test

drwxrwxr-x 4 fredj21 fredj21 4096 févr. 2 08:08 train

drwxrwxr-x 4 fredj21 fredj21 4096 févr. 2 08:08 valid

tree Dataset/210125_4_shapes_TEST.v2i.yolov8 -d

Dataset/210125_4_shapes_TEST.v2i.yolov8

├── test

│ ├── images

│ └── labels

├── train

│ ├── images

│ └── labels

└── valid

├── images

└── labels

Prêt à coder !!!

Robotflow propose également, dans la section « Download », plusieurs méthodes d’accès au Dataset.
et plus particulièrement une librairie Python pour automatiser le téléchargement de son Dataset

pip install roboflow

python

	from roboflow import Roboflow
	rf = Roboflow(api_key="xxxxxxxxxxxxxxxxxxx")
	project = rf.workspace("fred-robotic").project("210125_4_shapes_test")
	version = project.version(2)
	dataset = version.download("yolov8")

pip install roboflow

python

from roboflow import Roboflow

rf = Roboflow(api_key="xxxxxxxxxxxxxxxxxxx")

project = rf.workspace("fred-robotic").project("210125_4_shapes_test")

version = project.version(2)

dataset = version.download("yolov8")

Prêt à entrainer notre modèle !!!

Ce sera l’objet du prochain article que vous pouvez lire ici.

Conclusion de ce premier article

Frédéric remercie particulièrement Kubii pour la fourniture du matériel qui a servi à réaliser toutes ces expériences, et en particulier pour le module d’Intelligence artificielle Hailo, indispensable dans ce développement.

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

========================= PARTIE 2 ==========================
Dans cette deuxième partie, Frédéric vous invite à entraîner le modèle d’IA que vous avez créé précédemment. Deux solutions sont proposées, soit dans le modèle local sous Linux, soit dans le Cloud sur Google Colab.

Entraînement du modèle IA

Pour réaliser l’apprentissage de notre modèle, plus solutions se présente à nous :

entraîner le modèle en local, sous linux
ou en ligne, dans le cloud, sur Google Colab

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 :

 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

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

$ 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      |
|=========================================================================================|
+-----------------------------------------------------------------------------------------+

$ 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

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

 apt install curl unzip

cd /data/my_dataset
curl -L "https://app.roboflow.com/ds/MtF5ewIPDd?key=DtuQjJYrBl" &gt; 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

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

cd /data/my_yolo8s

yolo task=detect mode=train model=yolov8s.pt data=/data/my_dataset/data.yaml  epochs=100 batch=8

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

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

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 :

	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&lt;?, ?it/s]
					Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100%|██████████| 5/5 [00:01&lt;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

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

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 :

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

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

yolo export model=/workspace/ultralytics/runs/detect/train/weights/best.pt imgsz=640 format=onnx opset=11

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 :

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

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 :

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

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

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 :

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

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

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 [==================================================&gt;]  976.4MB/976.4MB
	c361101a082c: Loading layer [==================================================&gt;]   83.5MB/83.5MB
	593a1325c5ed: Loading layer [==================================================&gt;]  12.99MB/12.99MB
	69b082334a83: Loading layer [==================================================&gt;]  9.197MB/9.197MB
	b2e1817da5c2: Loading layer [==================================================&gt;]    384MB/384MB
	71cf924c7ef0: Loading layer [==================================================&gt;]  18.03MB/18.03MB
	21f476235018: Loading layer [==================================================&gt;]  3.072kB/3.072kB
	11c4c6ec7d5d: Loading layer [==================================================&gt;]  3.072kB/3.072kB
	4b7ec45684e6: Loading layer [==================================================&gt;]  3.072kB/3.072kB
	9661444da425: Loading layer [==================================================&gt;]  194.9MB/194.9MB
	bba85803bb3e: Loading layer [==================================================&gt;]  3.284GB/3.284GB
	64951b6189b1: Loading layer [==================================================&gt;]  485.1MB/485.1MB
	92b2d02a49ee: Loading layer [==================================================&gt;]  2.184GB/2.184GB
	88eb41c2be66: Loading layer [==================================================&gt;]  5.324GB/5.324GB
	b3d3a14740d8: Loading layer [==================================================&gt;]  895.5kB/895.5kB
	2053f733bc05: Loading layer [==================================================&gt;]  192.6MB/192.6MB
	5f70bf18a086: Loading layer [==================================================&gt;]  1.024kB/1.024kB
	Loaded image: hailo_ai_sw_suite_2025-01:1

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

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

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

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

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

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

exit

Sources

Documentation de la suite Hailo :
https://hailo.ai/developer-zone/documentation/hailo-sw-suite-2025-01/

========================= PARTIE 3 ============================
Après la création d’un modéle auquel on a appris à exécuter une tâche (reconnaître des formes géométriques), Frédéric nous propose de déployer ce modèle sur le module d’IA Hailo, sur un Raspberry Pi 5. Cet article décrit cette dernière phase.

Déploiement et tests d’un modèle d’IA

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 :
https://github.com/FredJ21/RPI5_AI_Hailo_tests/blob/main/Doc/2_config_et_tests.md

Installer les exemples proposés par HAILO

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

./install.sh

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"
		]
	}

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

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

1	./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 !

Vidéo

Conclusion

Merci à Frédéric pour cette série d’articles qui permettront à ceux qui sont intéressés de développer leur propre modèle d’IA pour le module Hailo sur un Raspberry Pi 5.

Si vous vous lancez dans l’aventure, n’hésitez pas à faire des retours dans les commentaires ci dessous et si vous réalisez une vidéo de démo, mettez un lien vers la vidéo ou envoyez là pour qu’elle soit ajoutée à l’article.

Merci à Kubii qui a fourni une grande partie du matériel utilisé à l’occasion de cette réalisation, et en particulier le module Hailo.