Fichier:Lift.png

2026-03-29T21:38:29Z

2182036 :

Fichier:Pin.jpg

2026-03-29T21:38:12Z

2182036 :

Reconnaissance objet

2026-03-29T21:36:40Z

2182036 : /* Structure des fichiers */

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

{| class="wikitable"
! 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 :'''

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

----

====Contrôle GPIO====

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.

:[[File:version_yolo.png|600px]]

'''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'''

{| class="wikitable"
! 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 <nowiki>https://download.pytorch.org/whl/cpu</nowiki> --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

{| 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====

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

2026-02-25T15:07:06Z

2182036 : /* 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é.
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.
Puisque les sorties du Raspberry pi fonctionne à 3.3 VCC, nous utilisons un petit relais pour alimenter un gyrophare 120 VCA.

----
===Fonctionnement global===

Pour fonctionner, le projet a trois grande étapes

'''1. La programmation python.'''
:Le script Python utilise YOLO (You Only Look Once) de Ultralytics pour détecter des objets en temps réel à partir d’une image, d’un dossier, d’une vidéo ou d’une caméra USB.
:Il charge un modèle .pt, applique l’inférence sur chaque frame, affiche les boîtes englobantes avec le niveau de confiance et calcule le nombre d'image par seconde moyen.
:Il permet aussi d’enregistrer la vidéo traitée et de compter le nombre d’objets détectés à chaque image.
:Ce n'est pas ce programme qui est entrainé a reconnaitre un lift. Il fait seulement le paramétrer (afficher les boites, le degré de confiance et le nombre d'objet détecté.)

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

'''3. Fichier de contrôle GPIO'''
: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.

----
====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.
Il existe deux options : le créer soi-même ou en utiliser un déjà disponible en ligne.
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.

'''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).
:Recherche 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.

'''2. Préparer le dataset à l’entrainement.'''
:Une fois le fichier téléchargé, vous devez l'extraire à l'endroit de votre choix.
:Ensuite, vérifiez que le fichier contient les 3 éléments importants: data.yaml, train, valid.
:Si ces 3 éléments sont présents, tout est correct.

'''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 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, 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.
Vous devez ensuite glisser le fichier téléchargé au même endroit que les autres fichiers énumérés à l'étape 2.
:[[File:version_yolo.png|600px]]

'''4. Entrainement'''
:Il est possible de faire l’entrainement sur Windows, mais comme nous on l'a fait sur Linux vous devrez faire vos recherches par vous-même pour le faire avec
:Windows.

:https://www.youtube.com/watch?v=r0RspiLG260

:Pour le faire sur Linux vous devez avoir téléchargé les librairies: ultralitics, pytorch, python3, pip, opencv.
:Maintenant, ouvres le terminal et 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

:Faites vos recherches pour remplacer les x par les bonnes valeurs selon vos besoins (dépendement, de votre nombre d'images et votre application) .

:Ensuite, vous exécutez la commande et votre ordinateur lance l’entraînement du modèle, ce qui 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.

Reconnaissance objet

2026-02-25T15:06:09Z

2182036 : /* 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é.
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.
Puisque les << i/o >> du Raspberry pi fonctionne à 3.3v, nous utilisons un petit relais pour alimenter le gyrophare.

----
===Fonctionnement global===

Pour fonctionner, le projet a trois grande étapes

'''1. La programmation python.'''
:Le script Python utilise YOLO (You Only Look Once) de Ultralytics pour détecter des objets en temps réel à partir d’une image, d’un dossier, d’une vidéo ou d’une caméra USB.
:Il charge un modèle .pt, applique l’inférence sur chaque frame, affiche les boîtes englobantes avec le niveau de confiance et calcule le nombre d'image par seconde moyen.
:Il permet aussi d’enregistrer la vidéo traitée et de compter le nombre d’objets détectés à chaque image.
:Ce n'est pas ce programme qui est entrainé a reconnaitre un lift. Il fait seulement le paramétrer (afficher les boites, le degré de confiance et le nombre d'objet détecté.)

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

'''3. Fichier de contrôle GPIO'''
: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.

----
====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.
Il existe deux options : le créer soi-même ou en utiliser un déjà disponible en ligne.
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.

'''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).
:Recherche 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.

'''2. Préparer le dataset à l’entrainement.'''
:Une fois le fichier téléchargé, vous devez l'extraire à l'endroit de votre choix.
:Ensuite, vérifiez que le fichier contient les 3 éléments importants: data.yaml, train, valid.
:Si ces 3 éléments sont présents, tout est correct.

'''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 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, 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.
Vous devez ensuite glisser le fichier téléchargé au même endroit que les autres fichiers énumérés à l'étape 2.
:[[File:version_yolo.png|600px]]

'''4. Entrainement'''
:Il est possible de faire l’entrainement sur Windows, mais comme nous on l'a fait sur Linux vous devrez faire vos recherches par vous-même pour le faire avec
:Windows.

:https://www.youtube.com/watch?v=r0RspiLG260

:Pour le faire sur Linux vous devez avoir téléchargé les librairies: ultralitics, pytorch, python3, pip, opencv.
:Maintenant, ouvres le terminal et 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

:Faites vos recherches pour remplacer les x par les bonnes valeurs selon vos besoins (dépendement, de votre nombre d'images et votre application) .

:Ensuite, vous exécutez la commande et votre ordinateur lance l’entraînement du modèle, ce qui 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.

Reconnaissance objet

2026-02-25T15:05:08Z

2182036 : /* 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é.
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.
Puisque les <<i/o>> du Raspberry pi fonctionne à 3.3v, nous utilisons un petit relais pour alimenter le gyrophare.

----
===Fonctionnement global===

Pour fonctionner, le projet a trois grande étapes

'''1. La programmation python.'''
:Le script Python utilise YOLO (You Only Look Once) de Ultralytics pour détecter des objets en temps réel à partir d’une image, d’un dossier, d’une vidéo ou d’une caméra USB.
:Il charge un modèle .pt, applique l’inférence sur chaque frame, affiche les boîtes englobantes avec le niveau de confiance et calcule le nombre d'image par seconde moyen.
:Il permet aussi d’enregistrer la vidéo traitée et de compter le nombre d’objets détectés à chaque image.
:Ce n'est pas ce programme qui est entrainé a reconnaitre un lift. Il fait seulement le paramétrer (afficher les boites, le degré de confiance et le nombre d'objet détecté.)

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

'''3. Fichier de contrôle GPIO'''
: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.

----
====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.
Il existe deux options : le créer soi-même ou en utiliser un déjà disponible en ligne.
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.

'''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).
:Recherche 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.

'''2. Préparer le dataset à l’entrainement.'''
:Une fois le fichier téléchargé, vous devez l'extraire à l'endroit de votre choix.
:Ensuite, vérifiez que le fichier contient les 3 éléments importants: data.yaml, train, valid.
:Si ces 3 éléments sont présents, tout est correct.

'''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 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, 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.
Vous devez ensuite glisser le fichier téléchargé au même endroit que les autres fichiers énumérés à l'étape 2.
:[[File:version_yolo.png|600px]]

'''4. Entrainement'''
:Il est possible de faire l’entrainement sur Windows, mais comme nous on l'a fait sur Linux vous devrez faire vos recherches par vous-même pour le faire avec
:Windows.

:https://www.youtube.com/watch?v=r0RspiLG260

:Pour le faire sur Linux vous devez avoir téléchargé les librairies: ultralitics, pytorch, python3, pip, opencv.
:Maintenant, ouvres le terminal et 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

:Faites vos recherches pour remplacer les x par les bonnes valeurs selon vos besoins (dépendement, de votre nombre d'images et votre application) .

:Ensuite, vous exécutez la commande et votre ordinateur lance l’entraînement du modèle, ce qui 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.