« Reconnaissance objet » : différence entre les versions

De Wiki TGE CSTwiki
Aller à la navigation Aller à la recherche
← Modification précédente
2182036 (discussion | contributions)
58 modifications
Aucun résumé des modifications
2182036 (discussion | contributions)
58 modifications
 
(18 versions intermédiaires par le même utilisateur non affichées)
Ligne 1 : Ligne 1 :
==Description du projet==
==Description du projet==
Le but final du projet est de détecter un objet (dans notre cas un lift) dans une image de caméra grâce à un modèle de reconnaissance d'objet pré-entrainé.
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.
Lorsque que le programme détectera un chariot élévateur, un gyrophare s'activera pour avertir les travailleurs.
Le programme se trouvera dans un Raspberry pi 5, un petit ordinateur avec des entrées sorties programmables. La camera sera connectée dans celui-ci directement par USB.
:[[File:lift.png|800px]]
Puisque les sorties du Raspberry pi fonctionne à 3.3 VCC, nous utilisons un petit relais pour alimenter un gyrophare 120 VCA.
 
:[[File:image_proj.png|800px]]


----
----
===Fonctionnement global===
===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.
:[[File:wikilayout.png|800px]]


Pour fonctionner, le projet a trois grande étapes


'''1. La programmation python.'''
:Le script charge un modèle .pt et applique la détection sur chaque image, affiche les boîtes englobantes avec le niveau de confiance et calcule le nombre d'image par seconde moyen.
{| class="wikitable"
:Il permet aussi d’enregistrer la vidéo traitée et de compter le nombre d’objets détectés à chaque image.
! Fichier !! Rôle !! Catégorie
:Ce n'est pas ce programme qui est entrainé a reconnaitre un objet. Il fait seulement le paramétrer (afficher les boites, le degré de confiance et le nombre d'objet détecté.)
|-
 
| main.py || Fichier principal — lance la détection YOLO et contrôle les GPIO || Exécution
'''2. Le fichier .pt (Pré-entrainée)'''
|-
:Un modèle YOLO déjà entraîné (.pt) est une intelligence artificielle qui a déjà appris à reconnaître certains objets grâce à un entraînement préalable sur une grande quantité d’images.Le modèle pré-entrainé c'est comme le cerveau du projet.
| 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
|}
----


'''3. Fichier de contrôle GPIO'''
====Fichier Python principal (main.py)====
:Le Raspberry pi 5 possède plusieurs pin programmable qui doivent être contrôler à l'aide d'un fichier. Les pins GPIO peuvent être soit une entrée ou une sortie. Le fichier fais aussi le liens entre les variables python et les pins.
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 :'''
{| class="wikitable"
! 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.
----
----
====Création du modèle pré-entrainée====


Pour entraîner le modèle, il faut un dataset, c’est-à-dire une collection d’images déjà annotées.
====Contrôle GPIO====
Il existe deux options : le créer soi-même ou en utiliser un déjà disponible en ligne.
Voici la logique des entrées sorties pour notre projet a guise d'exemple.
Nous recommandons d’en prendre un déjà fait, car créer son propre dataset demande des milliers de photos et beaucoup de temps pour les annoter une par une.
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]]




'''1. Choisir le bon dataset'''
:Nous conseillons d'utiliser la plateforme RobotFlow sur internet pour trouver un dataset.
:Sur Roboflow, va dans l’onglet Universe (bibliothèque publique).
:Rechercher avec des mots-clés précis (ex : “forklift”, “helmet detection”, etc.).
:Vérifie le nombre d’images, la diversité des photos et la qualité des annotations.
:Choisis un dataset avec plusieurs centaines ou milliers d’images bien étiquetées.
:Une fois le bon dataset trouvé, il reste juste à le télécharger en format zip.
:Une erreur que nous avons rencontrée étais que notre dataset n'avais aucune image
:nulle, qui sont une images sans l'objet qu'on veut détecter. les images nulle
:sont important pour l'entrainement.


'''2. Préparer le dataset à l’entrainement.'''
*'''GPIO principal (GPIO_PIN)''' — activé lorsque la classe cible est détectée pendant DUREE_DETECTION secondes.
:Une fois le fichier téléchargé, vous devez l'extraire à l'endroit de votre choix.
*'''Lumière de détection (PIN_LUMIERE_DETECTION)''' — suit exactement le même comportement que le GPIO principal.
:Ensuite, vérifiez que le fichier contient les 3 éléments  importants: data.yaml, train, valid.
*'''Lumière de statut (PIN_LUMIERE_STATUT)''' — s'allume au démarrage du programme et s'éteint à la fermeture.
:Si ces 3 éléments sont présents, tout est correct.
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é====
'''3. Ajouter le Yolo de base.'''
:Yolo possède des modèles de base pré entrainés généralisé et il est nécessaire d'ajouter une
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.
:de ces version à notre dataset pour l’entrainement. Nous utilisons la version 11n qui est la
:version officielle la plus récente. Le n signifie nano. Il existe d'autres modèle plus performants,
'''1. Choisir le bon dataset'''
:mais nous avons besoin de la version la plus léger pour fonctionner avec le Raspberry pi.  
:pour l'ajouter au dataset, vous devez le télécharger à partir du site de Yolo.
: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.).
Vous devez ensuite glisser le fichier téléchargé au même endroit que les autres fichiers énumérés à l'étape 2.
: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.
:[[File:version_yolo.png|600px]]
:[[File:version_yolo.png|600px]]
 
'''4. Entrainement'''
'''3. Entraînement'''
:Il est possible de faire l’entrainement sur Windows, nous conseillons d'utiliser Linux, mais voici une vidéo expliquant les démarches nécessaire avec Windows.
 
:L'entraînement est recommandé sur un ordinateur Linux avec une carte graphique NVIDIA.
:https://www.youtube.com/watch?v=r0RspiLG260
:Dans le terminal, entrer la commande :
 
 
: '''yolo detect train model=yolo11n.pt data=data.yaml epochs=100 imgsz=640 batch=16 patience=20'''
:Pour le faire sur Linux, vous devez avoir téléchargé les librairies suivantes:
*ultralitics
{| class="wikitable"
*pytorch
! 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
*python3
*opencv
 
----
:Nous conseillons l'utilisation de l'outil pip pour rendre l'installation de c'est librairie plus simple.
 
====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.
:Maintenant, Dans le terminal entrez la commande:
 
:'''yolo detect train model=yolo11n.pt data=data.yaml epochs=X imgsz=X batch=X patience=X'''
 
 
*model : modèle de base pré-entraîné utilisé pour commencer.
 
*data : fichier qui indique où sont les images et les classes.
 
*epochs : nombre de cycles d’apprentissage.
 
*imgsz : taille des images (640 si vous utiliser notre python).
 
*batch : nombre d’images traitées en même temps (selon le gpu).
 
*patience : arrête l’entraînement si le modèle n’améliore plus ses performances
 
 
:Il est nécessaire de remplacer les x par les bonnes valeurs selon vos besoins, dépendamment de votre nombre d'images et votre application.
 
 
 
:Ensuite, vous exécutez la commande et votre ordinateur lance l’entraînement du modèle, cela peut prendre plusieurs heures selon la puissance de votre machine et la taille du dataset.Une erreur possible est que votre processeur ou votre environnement ne dispose pas des bibliothèques logicielles nécessaires pour exécuter l’entraînement. Ce problème est plus fréquent sur des ordinateurs plus anciens ou lorsque certaines dépendances ne sont pas correctement installées.


: '''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é.
----
----
====Python de détection====
:Le fichier python gère l'image de la caméra en appliquant le modèle pre-trained sur chaque frame.
:De plus, il affiche le nombre d'objet détectés, les fps, le pourcentage de certitude et la boite
:de détection de classe. Dans notre cas la seule classe est le forklift, mais le même python
:fonctionnerait avec n'importe quelle classe sans modification.
:Dans ce programme vous pouvez aussi décider à partir de quel pourcentage de certitude (confidence) la boite s'affiche.
Il existe d'autres fichiers pythons sur le web adaptés a tout les besoins.


====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.
----
----
=====Contrôle des entrées/sorties digitales=====
 
====Installation des librairies====
:Ce fichier est le point d'entrée du projet (Ces lui qu'on exécute pour démarrer).
:Il lance automatiquement le python de détection et surveille le nombre d'objets
'''Sur le Raspberry Pi 5 (exécution) :'''
:détectés par la caméra via un fichier temporaire .txt partagé entre les deux scripts.
:Il est créer et supprimer à chaque fois.
: pip install torch torchvision --index-url <nowiki>https://download.pytorch.org/whl/cpu</nowiki> --break-system-packages --no-cache-dir
:Lorsque object_count atteint la valeur cible pendant un délai défini, la sortie GPIO
: pip install ultralytics opencv-python lgpio ncnn pnnx --break-system-packages --no-cache-dir
:s'active pour une durée déterminée, puis revient à 0 automatiquement.
:Toutes les valeurs (broche GPIO, délais, seuil de détection) sont modifiables en haut du fichier.
'''Sur un ordinateur Linux (entraînement et conversion) :'''
:Ne pas oublier d'installer la librairie GPIO sur le cranberry pi.
 
: pip install ultralytics torch torchvision opencv-python ncnn pnnx
:[[File:GPIO.png|800px]]
 
{| class="wikitable"
! 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======
 
====Liste de matériel====
*Raspberry pi 5 (8 GB ou plus conseillé)
 
*Raspberry Pi 5 (8 Go recommandé, 4 Go minimum)
*Relais 5v
*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
*Câble d'alimentation 5v 45w
 
*Caméra USB type A
*Caméra USB type A
 
*Relais 5V (module 1 canal)
*Câble micro HDMI (optionnel)
*Gyrophare 120V CA
 
*Câbles Dupont mâle-femelle (connexions GPIO)
*Câbles Dupont pour le relais (GPIO)
*Câble micro HDMI (optionnel — pour connecter un écran)
 
*Clavier/Souris
'''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.

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.

Récupérée de "https://wiki.tge.cegeplabs.qc.ca/index.php?title=Reconnaissance_objet&oldid=1042"