détection/reconnaissance d’objets dans une image

[thierryvalk]

Voici un poste consacré à la détection/reconnaissance d’objets dans une image.

Ce n’est pas un tuto détaillé, mais un rassemblement de données pour découvrir ce monde de l’IA de l’image sans trop de connaissances.

Niveau hardware, c’est Raspberry pi V5 avec une caméra. Ne pas oublier le système de refroidissement du RPI par ventilateur.
Le RPI5 a de bonnes performances pour ce genre de travail et peut donc se passer d’accélérateurs dédiés pour des tâches qui ne demandent pas trop de vitesse.

On utilisera pour l’imagerie YoloV8, il y en d’autres mais il est complet et simple.
Je précise que je ne suis pas du tout expert avec dans le monde du RPI et Linux.


On commence par prendre une carte SD et l’application Raspberry pour créer une Image du système.
On y sélectionne RPI5, OS 64bit, sa carte et dans les options l’on active le SSH.
Le SSH permet par la suite d’accéder à son RPI sans devoir lui coller clavier et écran dédié.
Tout se fait via son PC.

Une fois la carte flashée, on la place dans le RPI et PowerOn.
Le but étant d’utiliser VNC Viewer qui aura été installé sur le PC pour avoir l’écran du RPI sur l’écran du PC, il faut l’activer dans le RPI. (il y a peut-être moyen de la faire lors du flashage, mais connais pas).
Pour l’activer on branche un écran et clavier sur le RPI pour accéder à la configuration et activer VNC ou l’on utilise PuTTY sur son PC pour accéder au terminal du RPI et activer VNC.
sudo raspi-config
Interface option puis Enable VNC.
Et reboot.


Ce n’est pas bien compliqué au final.
Via VNC Viewer on peut maintenant accéder au RPI et ouvrir son Terminal.
On va mettre à jour le système :
sudo apt-get update
sudo apt-get upgrade

Nous avons donc maintenant un tout beau RPI en ordre de marche.

Pour la suite, on va y créer un environnement virtuel.
Cela permet de faire n’importe quoi sans bousiller l’environnement du RPI.
C’est que certaines versions sont trop récentes, d’autres trop vielles ….
Pour cela :
cd ~
mkdir /home/pi/.venv

pi est l’user name par défaut, si vous avez choisi un autre, il faut change pi par celui-ci.

python3 -m venv --system-site-packages /home/pi/.venv
Pour avoir une copie de l’environnement du rpi dans le dossier/environnement .venv
Petite remarque le . avant le nom venv va en faire un dossier caché.

source /home/pi/.venv/bin/activate

Pour l’activer, maintenant le terminal va commencer sa ligne par (.venv)
Par la suite, pour le désactiver :
deactivate
On va directement installer notre logiciel et tout ce qu’il faut pour l’imagerie par :
pip3 install ultralytics

Le vrai bonheur, une seule commande pour tout installer.
Voilà pour le RPI prêt, on va le laisser tranquille pour le moment.

[thierryvalk]

On peut faire différentes tâches :

Détection pour détecter par exemple différents objets dans une image.
Classification : l’image sera recoupée aux dimensions de l’élément que l’on veut classifier ; par exemple un oiseux et connaître son espèce.
La pose comme j’utilise pour avoir un squelette simplifié d’une personne ou d’un animal donné.
Et la segmentation pour détacher de l’image la forme d’un objet détecté.

Pour cela, il faudra apprendre à reconnaitre des objets en ayant une grande quantité d’images de l’objet en question sous différents angles, éclairages, variantes … ce sera le dataset.
Et le résultat de l’apprentissage le modèle.

Un dataset se compose d’images, et pour chaque image un petit fichier texte avec un descriptif. Un fichier data.yaml qui va indiquer les dossiers et ce que l’on cherche.
Pour cela, on peut s’aider de Google ou trouver des datasets tout faits.
Il y a kaggle.com et universe.roboflow.com qui regorgent de datasets.
Il suffit de s’inscrire, faire une recherche et télécharger un .zip

Le dossier va contenir le fichier data.yaml
Un dossier train qui va servir à créer le modèle. Il contient un dossier images avec les images et un dossier labels avec les fichiers textes
Un dossier valid de même structure pour la validation du modèle.
Et éventuellement un dossier test.

[thierryvalk]

Créer un modèle va demander énormément de calculs, le RPI peut le faire mais ce sera très très long.

Un PC classique peut le faire mais ce sera long. L’idéal est d’avoir un PC avec carte graphique NVidia : le GPU.
Il faut un environnement Linux avec Python.

J’ai réussi au boulot à le faire en utilisant Visual Studio 2022 et pytorch pour avoir accès aux ressources de ma GPU.
Mais à mon privé, impossible de le reproduire.

Si l’on ne veut pas s’embêter avec Linux sur son PC, il y a Google.
Colab research Google donne latéralement accès à une machine linux tout équipée sans frais. (Attention qu’il existe des solutions payantes si l’on veut plus que ce qui est gratuit).

C’est relativement simple, on va lier son Google Drive qui contient le dataset (les images et descriptifs)

Et lancer l’application « train ».
C’est tout simple vu qu’il existe des exemples tout faits où il suffit de changer les dossiers.
Le paramètre qui va le plus influencer la durée du traitement c’est le paramètre « epochs ».
Pour chaque « epoch » il va réanalyser toutes les images et ensuite lui donner une note la note la plus grande est conservée dans best.pt Les données mAP50 et mAP50-65 donnent une évaluation de cette notte.
Tout va dépendre de la complexité de l’objet ce paramètre semble être compris entre 100 et 300.

On n’oublie pas à la fin de sauvegarder le modèle sur son Drive vu que la machine fournie par Google va s’autodétruire après un certain temps.

Pour un RPI on part sur un modèle de référence yolov8n.pt avec le n pour nano.
Après parfois quelques heures, lorsque le modèle a été créer, on peut encore le modifier pour être plus rapide sur un RPI.

Ensuite on l’importe dans la RPI, et un petit programme en Python suffit à faire tourner cette application.

Voila, c’est vraiment en diagonale, il faut compter quelques heures pour prendre la main, mais après c’est simple et surtout très efficace.

[thierryvalk]

Un peu de code pour exemple :
Voici qui permet de faire l'apprentissage:

Code : Tout sélectionner


from ultralytics import YOLO

# Load the model.
model = YOLO("yolov8n.yaml")  # build a new model from scratch
model = YOLO('yolov8n.pt')
 
# Training.
if __name__ == '__main__':
    results = model.train(data=r"C:\Users\Thierry\Documents\yolo\training\data.yaml",epochs=200,imgsz=224,batch=16,amp=False,plots=True,name='yolov8n_ag')
 

C'est pas très complexe.
Comme argument j'ai demandé 200 epochs, une taille d'image de 224 pixels (par défaut c'est 640), batch=16 est pour traiter 16 images à la foi et le résultat sera sauvegardé dans le dossier yolo8n_ag.

On aura pris le soin d'installer utralytics et c'est tout.