Résumé de section

◄Annotation
►Résultats

  • Pour réaliser notre objectif d’avoir une intelligence artificielle qui fait de la détection, il nous faut un modèle. Voyez le comme un cerveau rempli de neurones, lesquels vont devoir apprendre pour réaliser la tâche demandée. Créer un cerveau n’est pas une chose aisée à faire donc on utilise ceux fabriqués par des professionnel·les. Il ne nous reste donc qu’à entrainer les neurones. En l’occurrence, nous allons utiliser les modèles YOLO (You Only Look Once) de l’entreprise Ultralytics. Plusieurs versions existent, au fur et à mesure qu’ils les développent, et nous utiliserons la dernière en date à savoir YOLOv26.

        

    Pour commencer, nous avons besoin de ce qu'on appelle environnement virtuel Python, que nous allons expliquer et créer ensemble.

    Pour ceux qui ne seraient pas familier avec cette notion, les environnements virtuels dans un ordinateur c’est un petit peu comme plusieurs appartements dans une grande maison. Chaque appartement est indépendant, autonome et totalement fonctionnel individuellement. C’est pour faire en sorte que si un nouveau locataire arrive, il ait son chez lui et qu’il y fasse ce qu’il veux au lieu d’être embêté par les règles de vie des autres.

    Nous, c’est pareil, on veut que notre code fonctionne directement, sans avoir de soucis avec l’ordinateur donc on crée un “mini-ordinateur” virtuel à l’intérieur de l’ordinateur physique.

        

    Installation de uv

    Pour créer cet environnement virtuel, nous allons utiliser un outil qui s’appelle uv, c’est un peu comme l’architecte et les ouvrier·es de la maison, c’est cet outil qui sait concevoir des environnements et les construire. 

    On va donc commencer par le télécharger.

    Pour Windows : 

     

        

    Pour Linux/macOS : 

     

        

    Mise en place de l'environnement virtuel (appelé venv pour Virtual ENVironnement)

    Voila, l’outil pour créer un environnement virtuel est 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

           

        • 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 sont pré-entraînés pour gagner du temps d’entraînement et de la précision.

    (Pour les pros de l’IA, Yolo propose aussi de construire son propre réseau de neurones en faisant chaque couche à la main dans un fichier .yaml : voir documentation)

        

    Passons à la ligne suivante :  

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

        

    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.

          

    Autres paramètres utiles de la fonction model.train()

          

    Argument Type Défault

    Description
    time float None Permet de définir un temps maximum de calcul. Si il existe, cet argument ignore le nombre d’époques et va jusqu’au temps indiqué.
    patience int 100 Permet d’indiquer au bout de combien d’époque de stagnation arrêter le code. Par exemple si le code atteint un plateau et y reste pendant 30 époque, on peut dire au code d’arrêter de tourner pour ne pas gaspiller des ressources.
    device int or str or list None Permet d’indiquer quel outil de calcul à utiliser : un seul GPU (device=0), plusieurs GPUs (device=[0,1]) ou CPU (device=cpu).
    project str None Si vous voulez donner un nom au dossier où vont être sauvegarder les résultats de vos entrainements.
    name str None Permet de donner un nom spécifique à un entrainement, donc permet de différencier plusieurs entraînements.
    exist_ok bool FAUX Si ce paramètre est mis sur True, cela permet de remplacer un dossier projet du même nom. Utile pour tester de manière itérative sans avoir à supprimer manuellement l’entrainement précédent.

         

    Ces paramètres sont des paramètres basiques pour personnaliser votre entraînement. Mais pour améliorer l’entrainement, il y a d’autres paramètres que l’on peut ajuster. Nous en parlons plus loin dans la formation sachant que pour commencer, les valeurs par défaut de YOLO permettent d’obtenir des résultats déjà très satisfaisants.

          

    Augmentation

    Nous sommes arrivé·es au point des explications sur la désactivation des augmentations par défaut sur YOLO.

    Dans le cas où vous avez fait de l’augmentation avec Roboflow et que vous ne voulez pas que l’augmentation de YOLO interfère, ajoutez les lignes en bleu dans ci-dessous. Bien penser à garder vos premiers paramètres donc data, epochs, imgsz, etc ...

    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

    )

     

    Sinon, si vous êtes dans le cas où vous n’avez pas fait d’augmentation avec Roboflow car le plus simple est de laisser YOLO en faire par défaut, alors n'écrivez rien de ce qui est en bleu au-dessus et les paramètres prendront leur valeur par défaut et YOLO fera ses augmentations.

    Point étape final

    Votre dossier de travail doit ressembler à ça normalement à la fin :

         

         

    Note : il peut y avoir des variations avec les fichiers train, val et test en fonction de comment vous avez organisé vos données. Le plus important c’est que le fichier data.yaml soit cohérent avec les chemins respectifs.

        

    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 ouvril un terminal dans ce dossier

         

         

    (Si vous êtes sur macOs, ouvrez un terminal comme vu précédemment puis entrez : cd chemin/absolu/vers/votre/dossier/de/travail )

    Dans le terminal, écrivez la commande suivante puis clickez sur entrée : uv run nom_de_votre_fichier_python.py

    La toute première fois que vous effectuez cette commande, la réponse va prendre beaucoup de temps, car avant de lancer votre fichier python, il va falloir que l’architecte lise le plan (pyproject.toml) et mandate les ouvrier·es de construire ce que requiert ce plan (python, ultralytics, etc...) et qu’ensuite ce soit construit. Mais dans la logique, dès la deuxième fois, l’environnement étant déjà fabriqué, la même commande sera beaucoup plus rapide.

         

    Une fois votre entrainement fini, vous aurez besoin de pouvoir évaluer la qualité de cet entrainement. Dans la prochaine section "Résultats", vous serez amené·e à comprendre tous les éléments que YOLO calcule à la fin de son entrainement, mais si vous avez juste besoin de savoir si votre modèle est bien sans comprendre, vous pouvez vous rendre directement dans la sous-section "Conclusion" de "Résultats".

◄Annotation
►Résultats