Résumé de section

◄ANNOTATIONS
►RÉSULTATS

  • La mise en œuvre d'un système de détection d'objets nécessite l'emploi d'un modèle d'intelligence artificielle, architecture neuronale complexe dont la conception ex nihilo est réservée à des experts. L'approche standard consiste donc à exploiter des modèles préexistants développés par des professionnels, en se concentrant exclusivement sur la phase d'entraînement des paramètres neuronaux.

    Dans ce contexte, nous utiliserons l'architecture YOLO (You Only Look Once), développée par l'entreprise Ultralytics. Bien que plusieurs itérations aient été publiées au fil du temps, ce tutoriel se fonde sur la version la plus récente disponible, dénommée YOLOv8.

    La mise en œuvre de ce projet nécessite préalablement la configuration d'un environnement virtuel Python. Conceptuellement, cet espace isolé fonctionne comme un logement autonome au sein d'un système hôte : il garantit l'indépendance des dépendances logicielles et des configurations, évitant ainsi les conflits potentiels avec d'autres applications ou avec le système d'exploitation lui-même.

    Cette isolation permet d'exécuter le code dans un contexte contrôlé et reproductible, assimilable à un « mini-ordinateur » virtuel, assurant ainsi la stabilité et la portabilité du projet sans altérer l'environnement global de la machine physique.

          

             

    INSTALLATION DE UV

                  

    La création de cet environnement virtuel repose sur l'outil "uv", qui agit comme l'architecte et le constructeur chargé de concevoir et de déployer ces espaces isolés.

    La procédure d'installation de "uv" varie selon le système d'exploitation. Il convient de se référer aux supports vidéo ci-dessous.

         

    Pour Windows : 

     

        

    Pour Linux/macOS : 

     

        

            

    MISE EN PLACE DE L'ENVIRONNEMENT VIRTUEL

                

    L’outil pour créer un environnement virtuel est à présent installé (l’architecte et les ouvrier·es sont arrivé·es). Il faut maintenant créer le plan de l’appartement en précisant tout ce dont on a besoin. C'est justement dans ce fichier que nous allons préciser qu'il nous faut Python et la librairie Ultralytics. Ce plan est un fichier .toml que l’on va fabriquer ensemble. 

    Commencez par ouvrir un éditeur de texte (bloc-notes par exemple pour Windows). 

    Et dans un fichier vierge, copiez-collez les lignes suivantes : 

    [project]

    name = "your_project_name"

    version = "0.1.0"

    description = "Add your description here"

    readme = "README.md"

    requires-python = ">=3.12"

    dependencies = [ "ultralytics>=8.4.18", ]

                                                                                                  

    Ensuite faites “Enregistrez sous” :

    • allez dans votre répertoire de travail (là où vous aviez extrait votre archive .zip de Roboflow)
    • dans Type sélectionnez “Tous les fichiers (*.*)”
    • dans Nom du fichier écrivez “pyproject.toml” (ce nom doit être exact, il ne peut pas être différent).
    • et enfin, enregistrez.

        

         

    Point important : vérifiez que ".toml" est bien l'extension de votre fichier. Pour cela, vous devez d'abord afficher les extensions des documents (Afficher --> Afficher (tout en bas) --> Extensions de noms de fichiers) puis vérifier que le nom du fichier termine bien par ".toml".

                       

                   

    CODE PYTHON

             

    Maintenant, créez un fichier python toujours dans le même dossier, de la même façon que précédemment :

    • ouvrez un outil d’édition de texte
    • écrivez les trois lignes ci-dessous (vous pouvez copier-coller)
    • “enregistrer sous”
    • mettez l’extension .py (même démarche qu’avant mais au lieu du .toml, il faut mettre .py).

          

    Les lignes en question :

    from ultralytics import YOLO

    model = YOLO(“yolo26n.pt”)

    results = model.train(data=”data.yaml”, epochs=100, imgsz=640)

          

    EXPLICATIONS DES DIFFÉRENTES LIGNES

           

        • model = YOLO(“yolo26n.pt”)

          

    Cette ligne sert à préciser quel modèle on veut entraîner. Yolo propose 5 tailles de modèle : nano (“n”), small (“s”), medium (“m”), large (“l”), extralarge (“x”). Cela fonctionne intuitivement, les petits sont plus rapides mais moins robustes et les plus grands prennent plus de temps de calcul mais sont plus performants. Ici, le 'n' dans 'yolo26n.pt' correspond à la taille nano.

    Ces modèles, pré-entraînés sur de vastes jeux de données, permettent d'optimiser la convergence et la performance finale. 

        

    Passons à la ligne suivante :  

        • results = model.train(data=”data.yaml”, epochs=100, imgsz=640)

        

    Cette seconde instruction lance la phase d'apprentissage supervisé selon les paramètres suivants :

    • data : mettez le nom de votre fichier .yaml fourni dans le .zip de Roboflow
    • epochs : les époques correspondent au nombre de fois que le modèle doit tourner. Pour faire très simple, le modèle regarde toutes les images dans le dossier d’entrainement pour ajuster ses paramètres. Le nombre d’époques correspond au nombre de fois où il passera à travers toutes les images.
    • imgsz : correspond à la taille de vos images, donc indiquez celle que vous avez mise dans Roboflow. Sachant que 640 est la valeur par défaut donc si vous voulez des images plus grandes (ou plus petites) il faut absolument le préciser sinon elles seront rapetissées (ou agrandies).

        

    Pour vous donner quelques ordres de grandeur des paramètes classiques :

    • model : yolo26n.pt (version Nano pour la vitesse) ou yolo26s.pt (Small pour la précision).
    • epochs : 100 est la valeur par défaut. Pour de petits jeux de données, vous pouvez monter à 300.
    • imgsz : 640 est la valeur par défaut. Utilisez 320 pour plus de rapidité ou 1280 pour détecter de très petits objets.
    • batch : -1 pour l'ajustement automatique à votre mémoire VRAM, ou 16 par défaut.
    • device : 0 pour utiliser votre premier GPU ou cpu si vous n'en avez pas.

            

    Concernant la taille du modèle, il est recommandé de passer à un modèle plus grand que YOLO26s (comme les versions m, l, ou x) dans les situations suivantes :

    • Besoin d'une précision maximale : Si votre modèle actuel souffre d'underfitting (sous-apprentissage) et ne parvient pas à capturer les détails complexes, un modèle plus large offre une plus grande capacité d'apprentissage.
    • Complexité du dataset : Pour des jeux de données volumineux (> 50 000 images) avec de nombreuses classes ou des scènes denses, les modèles Medium ou Large sont plus performants.
    • Objets difficiles : Si vous travaillez sur des images haute résolution avec de très petits objets (comme l'imagerie aérienne ou médicale), la capacité accrue aide à réduire les erreurs de détection.
    • Ressources matérielles suffisantes : Utilisez un modèle plus grand si votre déploiement se fait sur serveur (comme le cluster ISDM MESO) ou sur GPU puissant plutôt que sur mobile ou CPU.

                 

                  

    AUGMENTATION DE DONNÉES SUR YOLOv26

                  

    Dans l'éventualité où une augmentation de données a déjà été effectuée via Roboflow, il est impératif de désactiver les transformations par défaut de YOLO afin d'éviter toute interférence ou distorsion excessive des images.

    Pour ce faire, il convient d'ajouter les paramètres de désactivation spécifiques (identifiés en bleu) à la fonction `model.train()`. Ces arguments doivent s'ajouter à la configuration initiale, en conservant simultanément les paramètres fondamentaux tels que `data`, `epochs`, `imgsz` et tous les autres que vous avez pu préciser.

    model.train(

    data="data.yaml",

    epochs=100,

    imgsz=640,

    hsv_h=0.0, # Disable color (Hue)

    hsv_s=0.0, # Disable color (Saturation)

    hsv_v=0.0, # Disable color (Value)

    degrees=0.0, # Disable rotation

    translate=0.0, # Disable translation

    scale=0.0, # Disable scaling

    shear=0.0, # Disable shear

    perspective=0.0, # Disable perspective

    flipud=0.0, # Disable vertical flip

    fliplr=0.0, # Disable horizontal flip

    mosaic=0.0, # Disable mosaic

    mixup=0.0, # Disable mixup

    copy_paste=0.0, # Disable copy-paste

    auto_augment=None, # Disable auto-augment policies

    erasing=0.0 # Disable random erasing

    )

     

    À l'inverse, si aucune augmentation n'a été appliquée via Roboflow, il est recommandé de s'en remettre aux transformations natives de YOLO. Dans ce cas de figure, aucun paramètre supplémentaire ne doit être spécifié dans la fonction `model.train()` : l'omission des arguments de désactivation permet au modèle d'activer automatiquement ses routines d'augmentation par défaut, simplifiant ainsi la configuration.

                     

                   

    POINT ÉTAPE FINAL

               

    La structure finale du répertoire de travail doit correspondre à l'organisation présentée dans le support visuel ci-dessous. Cette arborescence garantit que le script d'entraînement puisse accéder correctement aux fichiers de configuration, aux jeux de données annotés et aux ressources nécessaires à l'exécution du modèle.

         

         

    Il convient de noter que la répartition des fichiers d'entraînement (train), de validation (val) et de test peut varier selon l'organisation spécifique de vos données. La contrainte fondamentale réside dans la cohérence absolue entre les chemins d'accès définis dans le fichier `data.yaml` et la structure réelle de votre arborescence de fichiers, afin d'assurer le bon chargement du jeu de données par le modèle.

        

            

    LANCER LE CODE

                  

    Normalement tout est prêt, donc on va pouvoir lancer le code, pour cela :

    1. Allez dans votre dossier de travail
    2. Faites un click droit pour ouvrir un terminal dans ce dossier (visuel ci-dessous pour Windows)

         

         

    Sous macOS, accédez au répertoire de travail via la commande `cd` suivie du chemin absolu dans le terminal. Lancez ensuite l'exécution du script avec la commande `uv run nom_de_votre_fichier_python.py`.

    L'exécution initiale de cette commande nécessite un temps de traitement significatif, car l'outil `uv` doit interpréter le fichier de configuration `pyproject.toml` et provisionner l'environnement virtuel avec toutes les dépendances requises (Python, Ultralytics, etc.). Une fois cet environnement construit, les exécutions subséquentes seront considérablement plus rapides à se lancer.

    À l'issue de l'entraînement, une phase d'évaluation de la performance du modèle est indispensable. La section suivante, « Résultats », détaille l'interprétation des métriques calculées par YOLO. Pour une analyse sommaire de la qualité du modèle sans entrer dans les détails techniques, il est possible de se référer directement à la sous-section « Conclusion » de ce même chapitre.

◄ANNOTATIONS
►RÉSULTATS