« Reconnaissance objet » : différence entre les versions
| (10 versions intermédiaires par le même utilisateur non affichées) | |||
| Ligne 2 : | Ligne 2 : | ||
Le but du projet est de détecter un objet (dans notre cas, un chariot élévateur) dans une image provenant d'une caméra à l'aide d'un modèle de reconnaissance d'objets préentraîné. Lorsque le programme détecte un chariot élévateur, un gyrophare s'active afin d'avertir les travailleurs de sa présence. Le programme s'exécute sur un Raspberry Pi 5, un micro-ordinateur doté d'entrées et de sorties programmables. La caméra y est connectée directement par USB. Étant donné que les sorties du Raspberry Pi fonctionnent en 3,3 V CC, un relais est utilisé pour commander l'alimentation d'un gyrophare fonctionnant en 120 V CA. | Le but du projet est de détecter un objet (dans notre cas, un chariot élévateur) dans une image provenant d'une caméra à l'aide d'un modèle de reconnaissance d'objets préentraîné. Lorsque le programme détecte un chariot élévateur, un gyrophare s'active afin d'avertir les travailleurs de sa présence. Le programme s'exécute sur un Raspberry Pi 5, un micro-ordinateur doté d'entrées et de sorties programmables. La caméra y est connectée directement par USB. Étant donné que les sorties du Raspberry Pi fonctionnent en 3,3 V CC, un relais est utilisé pour commander l'alimentation d'un gyrophare fonctionnant en 120 V CA. | ||
:[[File: | :[[File:lift.png|800px]] | ||
---- | ---- | ||
| Ligne 17 : | Ligne 17 : | ||
Le dossier de projet est organisé en trois catégories selon leur utilisation. | Le dossier de projet est organisé en trois catégories selon leur utilisation. | ||
:[[File:wikilayout.png| | :[[File:wikilayout.png|800px]] | ||
{| class="wikitable" | {| class="wikitable" | ||
| Ligne 36 : | Ligne 38 : | ||
---- | ---- | ||
====Fichier Python principal (main.py)==== | ====Fichier Python principal (main.py)==== | ||
Le fichier main.py gère l'image de la caméra en appliquant le modèle pré-entraîné sur chaque frame. Il affiche le nombre d'objets détectés, les FPS, le pourcentage de certitude et la boîte de détection de classe. La classe cible, le seuil de confiance et tous les paramètres sont configurables directement en haut du fichier. | Le fichier main.py gère l'image de la caméra en appliquant le modèle pré-entraîné sur chaque frame. Il affiche le nombre d'objets détectés, les FPS, le pourcentage de certitude et la boîte de détection de classe. La classe cible, le seuil de confiance et tous les paramètres sont configurables directement en haut du fichier. | ||
Le programme supporte deux types de sources : une caméra USB ou un fichier vidéo, sélectionnable via la variable SOURCE en haut du fichier. | Le programme supporte deux types de sources : une caméra USB ou un fichier vidéo, sélectionnable via la variable SOURCE en haut du fichier. | ||
| Ligne 72 : | Ligne 75 : | ||
---- | ---- | ||
====Contrôle GPIO==== | ====Contrôle GPIO==== | ||
Voici la logique des entrées sorties pour notre projet a guise d'exemple. | |||
La logique GPIO tourne dans un thread séparé en parallèle de la détection YOLO, ce qui évite tout ralentissement. Trois sorties sont disponibles : | La logique GPIO tourne dans un thread séparé en parallèle de la détection YOLO, ce qui évite tout ralentissement. Trois sorties sont disponibles : | ||
:[[File:pin.jpg|800px]] | |||
*'''GPIO principal (GPIO_PIN)''' — activé lorsque la classe cible est détectée pendant DUREE_DETECTION secondes. | *'''GPIO principal (GPIO_PIN)''' — activé lorsque la classe cible est détectée pendant DUREE_DETECTION secondes. | ||
*'''Lumière de détection (PIN_LUMIERE_DETECTION)''' — suit exactement le même comportement que le GPIO principal. | *'''Lumière de détection (PIN_LUMIERE_DETECTION)''' — suit exactement le même comportement que le GPIO principal. | ||
| Ligne 84 : | Ligne 91 : | ||
---- | ---- | ||
====Création du modèle pré-entraîné==== | ====Création du modèle pré-entraîné==== | ||
| Ligne 146 : | Ligne 153 : | ||
Le format NCNN est optimisé pour les processeurs ARM comme celui du Raspberry Pi. La conversion du modèle .pt en format NCNN permet de passer de '''3 FPS à 12 FPS''' sur le Raspberry Pi 5. Cette étape est fortement recommandée. | Le format NCNN est optimisé pour les processeurs ARM comme celui du Raspberry Pi. La conversion du modèle .pt en format NCNN permet de passer de '''3 FPS à 12 FPS''' sur le Raspberry Pi 5. Cette étape est fortement recommandée. | ||
: '''python3 convert_ncnn.py''' | : '''python3 convert_ncnn.py''' | ||
| Ligne 151 : | Ligne 159 : | ||
:Le script génère un dossier modelv1_ncnn_model/ contenant tous les fichiers nécessaires. | :Le script génère un dossier modelv1_ncnn_model/ contenant tous les fichiers nécessaires. | ||
:Dans main.py, changer MODEL_PATH pour pointer vers ce dossier au lieu du fichier .pt. | :Dans main.py, changer MODEL_PATH pour pointer vers ce dossier au lieu du fichier .pt. | ||
'''Important :''' Effectuer la conversion sur le Raspberry Pi lui-même pour garantir la compatibilité. | '''Important :''' Effectuer la conversion sur le Raspberry Pi lui-même pour garantir la compatibilité. | ||
---- | ---- | ||
====Créer son propre dataset personnalisé==== | ====Créer son propre dataset personnalisé==== | ||
Dernière version du 29 mars 2026 à 21:45
Description du projet
Le but du projet est de détecter un objet (dans notre cas, un chariot élévateur) dans une image provenant d'une caméra à l'aide d'un modèle de reconnaissance d'objets préentraîné. Lorsque le programme détecte un chariot élévateur, un gyrophare s'active afin d'avertir les travailleurs de sa présence. Le programme s'exécute sur un Raspberry Pi 5, un micro-ordinateur doté d'entrées et de sorties programmables. La caméra y est connectée directement par USB. Étant donné que les sorties du Raspberry Pi fonctionnent en 3,3 V CC, un relais est utilisé pour commander l'alimentation d'un gyrophare fonctionnant en 120 V CA.
Fonctionnement global
Le projet repose sur un seul fichier Python principal (main.py) qui gère simultanément la détection YOLO et le contrôle des sorties GPIO grâce à un système de thread séparé.
Structure des fichiers
Le dossier de projet est organisé en trois catégories selon leur utilisation.
| Fichier | Rôle | Catégorie |
|---|---|---|
| main.py | Fichier principal — lance la détection YOLO et contrôle les GPIO | Exécution |
| modelv1_ncnn_model/ | Modèle YOLO converti au format NCNN (dossier) | Exécution |
| record.py | Enregistre une vidéo depuis la caméra USB | Création du dataset |
| extract_frames.py | Extrait des images d'une vidéo pour créer un dataset | Création du dataset |
| convert_ncnn.py | Convertit un modèle .pt au format NCNN | Conversion |
| modelv1.pt | Modèle YOLO original (format PyTorch) | Conversion |
Fichier Python principal (main.py)
Le fichier main.py gère l'image de la caméra en appliquant le modèle pré-entraîné sur chaque frame. Il affiche le nombre d'objets détectés, les FPS, le pourcentage de certitude et la boîte de détection de classe. La classe cible, le seuil de confiance et tous les paramètres sont configurables directement en haut du fichier.
Le programme supporte deux types de sources : une caméra USB ou un fichier vidéo, sélectionnable via la variable SOURCE en haut du fichier.
Paramètres configurables en haut du fichier :
| Paramètre | Description | Valeur par défaut |
|---|---|---|
| MODEL_PATH | Chemin vers le modèle YOLO (.pt ou dossier NCNN) | 'modelv1_ncnn_model' |
| SOURCE | Source vidéo — 'usb0' pour caméra, 'video.mp4' pour fichier | 'usb0' |
| CONFIANCE_MIN | Seuil de confiance minimum (0.0 à 1.0) | 0.5 |
| CLASSE_CIBLE | Classe à détecter, ou 'any' pour toutes les classes | 'Forklift' |
| GPIO_PIN | Broche BCM de la sortie principale | 17 |
| PIN_LUMIERE_DETECTION | Lumière qui suit le GPIO principal | 27 |
| PIN_LUMIERE_STATUT | Lumière allumée au démarrage, éteinte à la fermeture | 22 |
| DUREE_DETECTION | Secondes que la condition doit être maintenue avant activation | 2.0 |
| DUREE_ACTIVATION | Secondes que le GPIO reste actif | 3.0 |
| RESOLUTION | Résolution caméra et inférence | (640, 640) |
Note : La valeur de CLASSE_CIBLE est insensible à la casse. Écrire 'forklift', 'Forklift' ou 'FORKLIFT' donnera le même résultat.
Contrôle GPIO
Voici la logique des entrées sorties pour notre projet a guise d'exemple. La logique GPIO tourne dans un thread séparé en parallèle de la détection YOLO, ce qui évite tout ralentissement. Trois sorties sont disponibles :
- GPIO principal (GPIO_PIN) — activé lorsque la classe cible est détectée pendant DUREE_DETECTION secondes.
- Lumière de détection (PIN_LUMIERE_DETECTION) — suit exactement le même comportement que le GPIO principal.
- Lumière de statut (PIN_LUMIERE_STATUT) — s'allume au démarrage du programme et s'éteint à la fermeture.
Si la condition est toujours vraie à la fin de DUREE_ACTIVATION, le GPIO se renouvelle automatiquement sans coupure. À la fermeture du programme (touche q ou Ctrl+C), toutes les sorties sont éteintes proprement.
Création du modèle pré-entraîné
Un modèle YOLO pré-entraîné (.pt) est une intelligence artificielle qui a appris à reconnaître certains objets grâce à un entraînement préalable sur une grande quantité d'images. C'est le cerveau du projet.
1. Choisir le bon dataset
- Nous conseillons d'utiliser la plateforme Roboflow Universe pour trouver un dataset public.
- Rechercher avec des mots-clés précis (ex : "forklift", "helmet detection", etc.).
- Vérifier le nombre d'images, la diversité des photos et la qualité des annotations.
- Choisir un dataset avec plusieurs centaines ou milliers d'images bien étiquetées.
- Une fois le bon dataset trouvé, le télécharger en format ZIP.
Attention : Vérifier que le dataset contient des images nulles (images sans l'objet à détecter). Ces images sont essentielles pour éviter les faux positifs.
- Une fois extrait, vérifier que le dossier contient les 3 éléments importants : data.yaml, train/ et valid/.
2. Ajouter le modèle YOLO de base
- YOLO possède des modèles de base pré-entraînés. Nous utilisons la version yolo11n (nano), la plus légère pour fonctionner sur Raspberry Pi.
- Télécharger yolo11n.pt depuis le site officiel d'Ultralytics et le placer dans le même dossier que data.yaml.
3. Entraînement
- L'entraînement est recommandé sur un ordinateur Linux avec une carte graphique NVIDIA.
- Dans le terminal, entrer la commande :
- yolo detect train model=yolo11n.pt data=data.yaml epochs=100 imgsz=640 batch=16 patience=20
| Paramètre | Description | Valeur recommandée |
|---|---|---|
| model | Modèle de base pré-entraîné | yolo11n.pt |
| data | Fichier de configuration du dataset | data.yaml |
| epochs | Nombre de cycles d'apprentissage | 100 |
| imgsz | Taille des images (maximum YOLO) | 640 |
| batch | Images traitées simultanément (selon le GPU) | 16 |
| patience | Arrête si plus d'amélioration | 20 |
- Le modèle entraîné sera disponible dans runs/detect/train/weights/best.pt.
- Pour faire l'entraînement sur Windows, voici une vidéo de référence : https://www.youtube.com/watch?v=r0RspiLG260
Librairies requises pour l'entraînement :
- ultralytics
- torch et torchvision
- opencv-python
- python3
Conversion NCNN (optimisation Raspberry Pi)
Le format NCNN est optimisé pour les processeurs ARM comme celui du Raspberry Pi. La conversion du modèle .pt en format NCNN permet de passer de 3 FPS à 12 FPS sur le Raspberry Pi 5. Cette étape est fortement recommandée.
- python3 convert_ncnn.py
- Le script génère un dossier modelv1_ncnn_model/ contenant tous les fichiers nécessaires.
- Dans main.py, changer MODEL_PATH pour pointer vers ce dossier au lieu du fichier .pt.
Important : Effectuer la conversion sur le Raspberry Pi lui-même pour garantir la compatibilité.
Créer son propre dataset personnalisé
Si le dataset public ne correspond pas suffisamment à l'environnement de production, il est possible d'améliorer le modèle en filmant sur place.
1. Filmer plusieurs courtes vidéos (5 à 15 minutes) dans différentes zones et conditions d'éclairage avec record.py.
2. Extraire les frames automatiquement avec extract_frames.py — une image toutes les 3 secondes génère environ 200 à 300 images par vidéo.
3. Annoter les images sur Roboflow en utilisant la fonction Auto-Label avec le modèle existant pour minimiser le travail manuel.
4. Réentraîner le modèle avec le nouveau dataset.
Conseil : Filmer avec la même caméra USB que celle utilisée en production garantit que le modèle sera entraîné sur des images identiques à ce qu'il verra en temps réel.
Installation des librairies
Sur le Raspberry Pi 5 (exécution) :
- pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu --break-system-packages --no-cache-dir
- pip install ultralytics opencv-python lgpio ncnn pnnx --break-system-packages --no-cache-dir
Sur un ordinateur Linux (entraînement et conversion) :
- pip install ultralytics torch torchvision opencv-python ncnn pnnx
| Librairie | Rôle | Pi 5 | PC Linux |
|---|---|---|---|
| ultralytics | Modèle YOLO | ✓ | ✓ |
| torch / torchvision | Moteur d'apprentissage PyTorch | ✓ | ✓ |
| opencv-python | Capture et affichage vidéo | ✓ | ✓ |
| lgpio | Contrôle des broches GPIO | ✓ | ✗ |
| ncnn / pnnx | Conversion et inférence NCNN | ✓ | ✓ |
| numpy | Calculs mathématiques (inclus automatiquement) | ✓ | ✓ |
Liste de matériel
- Raspberry Pi 5 (8 Go recommandé, 4 Go minimum)
- Carte microSD classe A2, 32 Go minimum (SanDisk ou Samsung Endurance recommandé)
- Câble d'alimentation USB-C 5V/5A (27W) — câble officiel Raspberry Pi 5 obligatoire
- Caméra USB type A
- Relais 5V (module 1 canal)
- Gyrophare 120V CA
- Câbles Dupont mâle-femelle (connexions GPIO)
- Câble micro HDMI (optionnel — pour connecter un écran)
Attention : Toujours éteindre le Raspberry Pi proprement avec la commande sudo shutdown -h now avant de couper l'alimentation. Une coupure brusque peut corrompre la carte microSD.