Détection automatique d'objets sur vos images

Résumé de section

• Sélectionner la section GÉNÉRALITÉS

  Replier Déplier

  GÉNÉRALITÉS

  Tout replier Tout déplier

  • Sélectionner l’activité Zone texte et média

    

         

    Dans cette formation, vous allez apprendre à entraîner un modèle d’intelligence artificielle pour détecter les objets de votre choix sur vos images. La détection d'objets est une technologie du domaine de la Vision par Ordinateur qui permet aux systèmes informatiques d'identifier et de localiser des éléments spécifiques au sein d’images. Contrairement aux tâches plus simples de classification d’image, qui assignent une étiquette unique à une image entière, la détection d'objets offre une compréhension granulaire en prédisant simultanément la classe d'un objet (par exemple, « personne », « voiture », « chien ») et sa localisation spatiale dans l’image.  

    Pour réaliser cette formation, vous avez besoin d’un ordinateur et d’une connexion internet. 

    Il est important de noter qu’entraîner un modèle d’intelligence artificielle est énergivore. Il existe de nombreux modèle déjà entraîné à détecter des objets, comme la plateforme de Ultralytics ou sur la plateforme Hugging Face d’où vous pouvez récupérer les modèles gratuitement car ils sont en open source. Dans des contextes spécifiques, où l'offre existante est insuffisante, le développement et l'entraînement d'un modèle personnalisé demeurent nécessaires.

• Sélectionner la section INTRODUCTION

  Replier Déplier

  INTRODUCTION

  • Sélectionner l’activité Dans ce tutoriel on va voir comment faire de la dé...

    Ce tutoriel expose les méthodologies relatives à la détection et à la reconnaissance d'objets au sein d'images. Il détaille les protocoles d'entraînement de modèles d'intelligence artificielle afin d'assurer l'identification de cibles spécifiques et leur localisation spatiale précise par le biais de boîtes englobantes.

    Un modèle entraîné à reconnaître des fractures donnera le résultat ci-dessous :

    

    (Source : https://doi.org/10.1259/bjr.20200975)

                      

        

    ENTRAÎNEMENT SUPERVISÉ DU MODÈLE

                 

    L'entraînement d'un modèle d'intelligence artificielle à la détection d'objets repose sur l'apprentissage supervisé. Cette approche nécessite la soumission au modèle d'images préalablement annotées, où les sujets d'intérêt ont été délimités par intervention humaine, fournissant ainsi la « vérité terrain » indispensable à l'apprentissage autonome des caractéristiques de l'objet.

    La constitution de ces données de référence exige une phase d'annotation manuelle, consistant à encadrer les objets cibles par des rectangles. Bien que laborieuse, cette étape est impérative. Si des bases de données annotées existent, leur disponibilité reste limitée pour des domaines de niche, rendant souvent nécessaire la création de jeux de données personnalisés.

    Le modèle exploité dans ce cadre est l'architecture « YOLO », dont les spécificités techniques seront détaillées ultérieurement.

                   

               

    NOTION DE CLASSE

                        

    Les sujets d'intérêt doivent être associés à une étiquette désignant leur catégorie d'appartenance, dénommée « classe ». Cette taxonomie offre une flexibilité totale : elle peut être générale (ex. : « chat », « chien ») ou hautement spécifique (ex. : « berger australien », « braque de Weimar »), selon les objectifs de détection.

    Le terme « classe », récurrent dans la suite de ce document, désigne exclusivement les catégories d'objets ciblées par le modèle.

    

                

                 

    DIVERSITÉ DES DONNÉES

               

    Il est important de noter que l'efficacité d'un modèle entraîné est intrinsèquement liée à la représentativité de ses données d'apprentissage. Un modèle spécialisé dans la détection de chats en milieu neigeux, par exemple, pourrait échouer à identifier ces mêmes animaux dans un contexte différent, tel qu'une prairie. Par conséquent, la constitution du jeu de données doit refléter fidèlement la diversité des scénarios de déploiement envisagés pour garantir la robustesse du système.

    

• Sélectionner la section ANNOTATIONS

  Replier Déplier

  ANNOTATIONS

  • Sélectionner l’activité test

    Il existe plusieurs outils d’annotations gratuits comme CVAT, Label Studio ou Roboflow et ici nous utiliserons et détaillerons l’utilisation de ce dernier.

    Rendez-vous sur le site internet de Roboflow.

    Le site de Roboflow est assez intuitif, donc il est facile d'y naviguer, cependant, nous passerons sur les étapes importante. Commencez par vous créer un compte ("Sign in"), puis suivez les étapes ci-dessous

     

                 

    Nous allons maintenant devoir passer par quelques explications avant de continuer.

        

    Il y a deux types de modification des données : le preprocessing et l’augmentation. On va passer sur l’utilité et les subtilités de chacune des deux étapes.

          

           

    PREPROCESSING

                      

    Le prétraitement (preprocessing) consiste à appliquer des transformations uniformes à l'intégralité du jeu de données annoté. Soit x le nombre initial d'images ; cette opération préserve la cardinalité de l'ensemble (x images avant et après), mais substitue les fichiers originaux par leurs versions transformées, entraînant la perte irréversible des données brutes. L'objectif principal est l'homogénéisation du jeu de données.

    Les transformations courantes incluent :

    • Le redimensionnement : assure l'uniformité des dimensions pour l'ensemble du dataset.
    • La conversion en niveaux de gris : élimine l'information chromatique lorsque celle-ci est non pertinente, optimisant ainsi l'espace de stockage et la puissance de calcul requise. Cette opération est exclusive : les images couleurs originales sont définitivement remplacées.
    • La suppression d'artefacts : applique des filtres numériques pour éliminer le bruit ou d'autres perturbations visuelles indésirables.

                

           

    AUGMENTATION

                

    Bien que la diversité des données soit cruciale, la collecte d'images dans des conditions variées s'avère souvent complexe. L'augmentation de données pallie cette contrainte en générant artificiellement de nouvelles images à partir d'échantillons existants par l'application de transformations numériques.

    Cette technique permet d'enrichir et de diversifier le jeu de données d'entraînement. En soumettant au modèle des variantes d'une même image (par exemple, en niveaux de gris ou inversée), on améliore sa robustesse et sa capacité de généralisation, lui permettant de reconnaître les objets indépendamment de leur orientation ou de leurs propriétés chromatiques.

    

                        

    L'augmentation de données se distingue du prétraitement par son effet multiplicateur sur le volume du jeu de données. Si x représente le nombre d'images initiales et que six transformations sont appliquées, l'ensemble final comprendra 7x images (x originales plus 6x générées). 

    Contrairement au prétraitement qui substitue les données brutes, l'augmentation les complète en conservant les originaux. Par exemple, l'ajout d'une conversion en niveaux de gris durant cette phase double le jeu de données : le modèle est ainsi entraîné simultanément sur les versions colorées et sur les versions en nuances de gris, maximisant ainsi la diversité des exemples sans perte d'information initiale.

          

           

    COMMENT CHOISIR LE SUPPORT D'ANNOTATIONS ?

                

    Le prétraitement et l'augmentation peuvent s'effectuer soit en amont (Roboflow), soit dynamiquement (YOLOv8). La première méthode, gourmande en stockage, accélère l'entraînement par la génération préalable des données. La seconde, économe en espace, alourdit la charge computationnelle en créant les variations à la volée.

    Le choix stratégique dépend des ressources matérielles : privilégiez la génération dynamique (YOLOv8) sur les infrastructures puissantes, et l'approche en amont (Roboflow) sur les machines limitées, en désactivant alors les augmentations par défaut de YOLOv8 pour éviter les distorsions.

    
    
    

    Reprenons maintenant la procédure sur Roboflow :

     

    
    QUIZZ

     

    
    
    

     

  • Sélectionner l’activité Ressources

    Ressources

  • Sélectionner l’activité Diapo_Annotation

    

    Diapo_Annotation Fichier
  • Sélectionner l’activité ppt_Annotation

    

    ppt_Annotation Fichier
  • Sélectionner l’activité Test de satisfaction Annotation

    

    Test de satisfaction Annotation Sondage
  • Sélectionner l’activité hfrhfh
• Sélectionner la section ENTRAÎNEMENT

  Replier Déplier

  ENTRAÎNEMENT

  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.

  • Sélectionner l’activité Ressources (copie)

    Ressources

  • Sélectionner l’activité Diapo_Entraînement

    

    Diapo_Entraînement Fichier
  • Sélectionner l’activité ppt_Entraînement

    

    ppt_Entraînement Fichier
  • Sélectionner l’activité Test de satisfaction Entraînement

    

    Test de satisfaction Entraînement Sondage
• Sélectionner la section RÉSULTATS

  Replier Déplier

  RÉSULTATS

  • • Replier Déplier

      INTRODUCTION

      À l'issue de l'entraînement, les résultats sont stockés dans le répertoire `runs/detect/train`, sauf configuration personnalisée d'un chemin alternatif. Ce dossier contient l'ensemble des artefacts nécessaires à l'évaluation de la performance du modèle et à son déploiement ultérieur.

      Bien que cette section détaille l'interprétation complète des données générées, une analyse sommaire des critères de réussite est disponible directement dans la conclusion de ce chapitre. L'arborescence de ce répertoire comprend généralement les éléments suivants (sous réserve de légères variations selon la configuration) :

      

          

      On va voir ce que représente chaque élément un a un. 
  • • Replier Déplier

      WEIGHTS

      Le dossier “Weights” correspond au fruit de votre labeur car dedans il y a les poids de votre modèle. C'est votre cerveau après apprentissage. 

      Il y a deux fichiers dedans : “best.pt” et “last.pt”. Cela se comprend de la manière suivante : les poids des neurones changent de manière régulière lors de l’entrainement et la qualité des poids est évaluée grâce à une fonction spécifique. Donc last.pt correspond aux derniers poids en date et best.pt correspond aux meilleurs poids qu’il y a eu de tout l’entrainement. On verra la subtilité d'avoir deux fichiers plus tard. 

      
  • • Replier Déplier

      args.yaml

      args.yaml contient tous les paramètres qu’a utilisé YOLO pour son entrainement incluant tous ceux qui avaient des valeurs par défaut que vous n’avez pas modifié et tous ceux sans argument (donc à 0). 

      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". 
  • • Replier Déplier

      INTRODUCTION À LA MATRICE DE CONFUSION

      

      En vision par ordinateur, on utilise beaucoup l’outil “matrice de confusion” et on peut en déduire beaucoup de statistiques pertinentes pour évaluer un modèle.

      On va devoir passer par une partie théorique avant de pouvoir comprendre ce que l’on voit dans les fichiers ci-dessus.

      Pour notre partie théorique, nous nous mettrons dans le cas où nous essayons de détecter des pièces anglaise appelées "penny".

             

                        

      MATRICE DE CONFUSION

                               

      Une matrice de confusion est un tableau qui va synthétiser et trier les prédictions du modèle pour pouvoir les analyser.

      Ici, il faut faire la distinction entre ce qui vrai et ce qui a été prédit. Un objet appartient à une classe, c'est ce qu'on appelle la vérité terrain (un chat appartient à la classe "chat").

      D'autre part, le modèle va faire des prédictions en attribuant une classe à un objet. Mais le modèle peut se tromper, ce qu'il prédit ne correspond pas forcément à la réalité (le chat peut finir dans la classe "chien" par exemple).

          

      On va donc distinguer :

      • la vérité terrain : la vraie classe des objets
      • les prédictions : les résultats du modèle

      Dans chacune de ces deux catégories on a deux résultats possibles : positif (présence de penny) et négatif (absence de penny).

      Cela crée quatre combinations possibles :

      

       

                      

      Pour une lecture plus simple, ces quatre combinaisons sont rassemblées dans un tableau à deux entrées. Les lignes correspondent à ce que le modèle a prédit et les colonnes correspondent à la vérité terrain.   

      

      • TP : True Positive (vrai positif)
        • Ce qui était à détecter et qui a bien été détecté.
        • Exemple : il y avait un “penny” et il a bien été détecté.

          

      • TN : True Negative (vrai négatif)
        • Ce qui n’était pas à détecter et qui n’a pas été détecté.
        • Exemple : il n’y avait pas de “penny” et aucun “penny” n’a été détecté.

           

      • FP : False Positive (faux positif)
        • Ce qui aurait dû être détecté comme négatif mais a été détecté comme positif.
        • Exemple : il n’y avait pas de “penny” mais un “penny” a été détecté.

          

      • FN : False Negative (faux négatif)
        • Ce qui aurait dû être détecté comme positif mais a été détecté comme négatif.
        • Exemple : il y avait un “penny” mais il n’a pas été détecté.

          

      Pour remplir chaque case de cette matrice, on va compter le nombre d'instances de chaque combinaison.  

          

          

      EXEMPLE

      L'image ci-dessous correspond à la vérité terrain, c’est-à-dire aux annotations faites à la main donc ce que le modèle est censé trouver :

      

           

      L'image suivante correspond aux détections faites par le modèle sur la même image après l’entrainement :

      

           

      Si on fait le jeu des 7 erreurs entre les deux images :

      

          

      On remplit ensuite la matrice de confusion avec chaque instance :

      

             

      On remplit chaque case en comptant le nombre total d'occurrence de chaque évènement, donc dans le cas très scolaire ci-dessous, il y en une de chaque. Concernant les vrais négatifs, on ne les compte pas. En effet, pour de la détection, un vrai négatif n’a pas vraiment de sens, ça revient à dire : il n’y avait rien à détecter et rien n’a été détecté, mais à l’échelle d’une image, cela se transforme vite en bruit, c’est-à-dire que chaque pixel pourrait être un vrai négatif avec cette définition, donc on ne les prend pas en compte.

                  

      À partir de cette matrice, on peut tirer plusieurs métriques pour caractériser notre modèle. Ultralytics nous sort 4 courbes : précision-confiance, rappel-confiance, précision-rappel et score F1. On va voir comment les interpréter, mais commençons par définir chaque terme.

           

                     

      CONFIANCE

                      

      Lorsque le modèle fait une prédiction, il fourni avec sa détection une valeur traduisant la certitude de sa prédiction, une probabilité. Cette valeur, comprise entre 0 et 1 est ce qu’on appelle la confiance (1 étant la certitude absolue).

      Il y a donc une nécessité de choisir une valeur seuil pour permettre au modèle de trancher. Si la confiance de la détection est supérieure, la détection est acceptée (l’objet est labellisé “penny”), sinon, elle est rejeté (l’objet est labellisé “background”/negative).

             

      EXEMPLE

      Prenons le graphique ci-dessous comme exemple : 

      

           

      Lecture du graphique : le point “1” correspond à la prédiction faite sur l’image 1. Le point est vert donc sur l’image il y a un penny. On peut lire en ordonnée que le modèle détecte la présence d’un penny avec une confiance d’environ 0.55.

      Autre exemple : le point “2” correspond à la prédiction faite sur l’image 2. Le point est rouge donc sur l’image il n’y a pas de penny. On peut lire en ordonnée que le modèle détecte la présence d’un penny avec une confiance d’environ 0.6.

          

      Choisissons arbitrairement un seuil à 0.5. Visuellement, cela revient à tracer un trait horizontal là où la confiance vaut 0.5, puis on “accepte” tous les points au dessus et on “rejette” tous les points en dessous :

      

              

      Comment remplir la matrice :

      • le point “1” est au dessus du seuil de confiance donc prédit positif (contenant un penny) et est vert (contient bien un penny) → vrai positif (True Positive, TP)
      • le point “2” est au dessus du seuil de confiance donc prédit positif (contenant un penny) et est rouge (ne contient pas de penny) → faux positif (False Positive, FP)
      • le point “3” est en dessous du seuil de confiance donc prédit négatif (ne contenant pas de penny) et est vert (contient bien un penny) → faux négatif (False Negative, FN)
      • le point “4” est en dessous du seuil de confiance donc prédit négatif (ne contenant pas de penny) et est rouge (ne contient pas de penny) → vrai négatif (True Negative, TN)
      • le point “5” est au dessus du seuil de confiance donc prédit positive (contenant un penny) et est vert (contient bien un penny) → vrai positif (True Positive, TP)

              

      Maintenant, prenons un seuil de 0.75, par le même procédé, on aura :

      

             

      • le point “1” est en dessous du seuil donc prédit négatif mais vert → faux négatif (False Negative, FN)
      • le point “2” est en dessous du seuil donc prédit négatif et est rouge → vrai négatif (True Negative, TN)
      • le point “3” est en dessous du seuil donc prédit négatif mais est vert → faux négatif (False Negative, FN)
      • le point “4” est en dessous du seuil donc prédit négatif et est rouge → vrai négatif (True Negative, TN)
      • le point “5” est au dessus du seuil donc prédit positive et est vert → vrai positif (True Positive, TP)

             

      Enfin, prenons un seuil de 0.35 :

      

             

      • le point “1” est au dessus du seuil donc prédit positif et est vert → vrai positif (True Positive, TP)
      • le point “2” est au dessus du seuil donc prédit positif mais est rouge → faux positif (False Positive, FP)
      • le point “3” est au dessus du seuil donc prédit positif et est vert → vrai positif (True Positive, TP)
      • le point “4” est en dessous du seuil donc prédit négatif et est rouge → vrai négatif (True Negative, TN)
      • le point “5” est au dessus du seuil donc prédit positive et est vert → vrai positif (True Positive, TP)

                   

      Pour un même modèle, on peut donc voir qu’il y a plusieurs matrices de confusion possibles, directement liées à la valeur du seuil de confiance choisi :

      

              

      Il existe une infinité de matrices de confusion, correspondant à la continuité des seuils de confiance possibles entre 0 et 1. Cette matrice constitue l'indicateur principal pour évaluer la pertinence du seuil sélectionné en vue du déploiement du modèle.

      L'optimisation d'une matrice de confusion exige souvent un compromis, car la réduction simultanée des faux positifs et des faux négatifs est rarement possible. Le choix du seuil dépend alors de la criticité des erreurs : en médecine, par exemple, on privilégie l'élimination des faux négatifs (pathologies non détectées) au détriment des faux positifs, moins graves. Des métriques quantitatives sont ensuite nécessaires pour identifier objectivement le seuil de confiance optimal arbitrant ce compromis.
  • • Replier Déplier

      BoxR_curve.png - BoxP_curve.png

      Visualisons ces mesures grâce à un schéma :

      

             

      En utilisant le dernier schéma, on peut écrire la précision et le rappel comme ci-dessous :

      

               

      Donc mathématiquement, on peut formaliser de la façon suivante :

      

      

                    

      Il est donc possible d'en faire des courbes pour voir l'évolution des ces mesures en fonction du seuil de confiance.

                 

                    

      PRÉCISION-CONFIANCE

                              

      

             

      Comment la construire ? Pour tous les seuils de confiance compris entre 0 et 1 :

      • on établit la matrice de confusion pour ce seuil
      • on calcule la précision associée à cette matrice spécifique
      • on place le point dans le graphique

            

      À l’inverse, comment la lire ? Par exemple, pour un seuil de confiance de 0.4, on lit une précision de 0.92, on en déduit que pour un tel seuil on a assez peu de faux positifs.

          

      À retenir : plus la courbe est haute, meilleure est la précision du modèle.

                    

      POUR ALLER PLUS LOIN

      Il faut faire attention avec cette courbe car elle ne prend pas du tout en compte les faux négatifs, mais surtout, plus le seuil monte, de moins en moins de valeur sont prises en compte donc la montée de la précision est “artificielle”.

      Cela s’explique car le modèle n’accepte quasiment plus rien, donc si il ne détecte que un vrai positif avec 98% de confiance et c’est tout, il aura donc 100% de précision. Mais dans ce cas, plein de “vrais positifs”, jugé négatifs car sous le seuil de confiance, seront oubliés.

             

      RAPPEL-CONFIANCE

                               

      

             

      Comment la construire ? Pour tous les seuils de confiance compris entre 0 et 1 :

      • on établit la matrice de confusion pour ce seuil
      • on calcule le rappel associé à cette matrice spécifique
      • on place le point dans le graphique

           

      À l’inverse, comment la lire ? Par exemple, pour un seuil de confiance de 0.8, on lit un rappel de 0.78, on en déduit que pour un tel seuil on a beaucoup de faux négatifs.

             

      À retenir : plus la courbe est haute et met du temps à descendre, meilleur est le rappel du modèle.

              

      POUR ALLER PLUS LOIN

      La courbe finira nécessairement à 0 car plus on augmente le seuil de confiance, plus le modèle est “strict”, il n’accepte que des prédictions dont il est sûr, donc le nombre de faux négatifs augmente drastiquement ce qui annule la fraction.

              

      La précision et le rappel sont deux métriques intéressantes et complémentaires, c’est à dire que pour avoir une vision globale du modèle il faut regarder les deux en même temps mais surtout voir comment l’une évolue par rapport à l’autre.

      Pour éviter de faire des va-et-vient entre les deux graphiques, des métriques les combinent directement, donc on introduit la courbe de précision-rappel et le score-F1 dans la prochaine section.
  • • Replier Déplier

      BoxPR_curve.png - BoxF1_curve.png

      PRÉCISION-RAPPEL

                     

       La courbe de précision-rappel permet de voir l’évolution simultanément de la précision et du rappel selon le seuil de confiance. Elle est construite de manière très spéciale.

           

                 

      Comment la construire ? Cette courbe est construite point par point car une troisième dimension est cachée, le seuil de confiance.

      On commence par le point le plus à gauche : ce point correspond à la valeur de la précision et du rappel lorsque le seuil de confiance est à 1. 

      On trace ensuite celui juste à sa droite : on prend le seuil 0.99 et on calcule la précision et le rappel depuis la matrice de confusion. Et ainsi de suite.

            

      À l’inverse, comment la lire ? Prenons le point où le seuil de confiance est à 0.5 (si on prend la courbe à ses extrémités avec nos doigts et qu’on la tend, ce sera le milieu), on peut lire qu’à ce seuil, la précision est de 0.65 et le rappel à 0.67 (approximativement).

      

            

      À retenir : plus la courbe monte dans le coin en haut à droite, meilleur est le modèle (le modèle ici est plutôt mauvais, ne vous y referez pas).

                                                                                                                                                                                                               

      POUR ALLER PLUS LOIN

      La courbe de précision-rappel est utilisée pour calculer une autre métrique que vous retrouverez à quelques endroits dans les résultats : Average Precision (AP). Cette métrique correspond à l’aire sous la courbe de précision-rappel. C’est la valeur décimal que l’on peut lire à côté du nom de la classe dans la légende.

      

              

      Par extension la mAP correspond à la mean Average Precision donc à la moyenne des AP quand on a plusieurs classes (nous en reparlerons plus tard). 

      Quel est l'utilité de cette mesure ? Comme mentionné dans le point "à retenir", plus la courbe monte en haut à droite, meilleur est le modèle mais "monter en haut à droite" est subjectif alors l'Average Precision a été introduite pour quantifier à quelle point la courbe monte donc à quel point l'aire sous la courbe est grande. Donc plus la valeur de la AP ou de la mAP est grande, meilleur est le modèle.

                               

      POUR ALLER ENCORE PLUS LOIN

      Juste après “mAP”, vous pouvez lire “@0.5” ce qui correspond à la valeur seuil pour “l’Intersection over Union” (IoU). 

      Pour comprendre ce que c’est, il faut le voir comme l’outil de vérification du modèle : le modèle prédit une boite pour englober un objet et d’autre part, il a la boite de vérité terrain. Mais il a besoin de quantifier si sa boite à lui est bien placée par rapport à l’endroit exact où elle devait être, donc on introduit un nouvel outil que l’on va expliquer, l'IoU.

      Prenons ces deux boites :

      

             

      La boite verte correspond à la vérité terrain et la boite orange a la prédiction du modèle. Elle n’est pas placée idéalement pourtant elle semble quand même englober le même objet. 

      Donc pour avoir une valeur attestant de la précision du placement de la boite, on va calculer le rapport entre l’intersection des deux boites et leur union, comme schématisé ci-dessous :

      

             

      Il est nécessaire de choisir un seuil qui permet de rejeter ou garder une prédiction. Dans le cas précédent où on avait un seuil d'IoU à 0.5, cela revient à dire que si une boîte de prédiction ne recouvre pas la boite vérité terrain à au moins 50%, c’est qu’elle est mal placée donc non acceptée.

           

      Quel est la différence entre la confiance et l'IoU ?

      La confiance sert lorsque le modèle prédit alors que le seuil d'IoU sert lorsque le modèle vérifie ses prédictions.

      Prenons le processus d'entrainement étape par étape :

           

      Étape 1 : choix des valeurs des seuils de confiance et de IoU (arbitrairement) :

      • seuil de confiance = 0.5
      • seuil d’IoU = 0.5

      Étape 2 : le modèle commence à s’entrainer, donc il regarde une image, puis fait des prédictions qui sont accompagnées chacune d’une confiance.

      Étape 3 : d’après le seuil de confiance donné (0.5), le modèle accepte toutes les prédictions dont la confiance est supérieure et rejette les autres.

      Étape 4 : vient ensuite la vérification des boîtes, donc comme pour le jeu des 7 erreurs de tout à l’heure, le modèle prend l’image avec les prédiction d’un côté et l’image avec la vérité terrain de l’autre puis compare. Chacune des boites prédites est comparée via l’IoU aux boites de vérité terrain, et si le ratio dépasse le seuil d'IoU (0.5), alors la boite est validée en tant que “vrai positif”. Sinon, si l’IoU est inférieure, la boite est rejetée mais comme elle avait passé le test de confiance, alors c’est une fausse alerte donc “faux positif”.

      Étape 5 : enfin, une fois que tout est vérifié, les boites de la vérité terrain qui n’ont pas trouvé détection à leur pied se retrouve dans les “faux négatifs”.

           

      La différence principale réside dans le fait que le seuil d'IoU ne sert que lors de l'entrainement car une fois déployé, le modèle ne se supervisera plus, il ne pourra pas. Alors que le seuil de confiance est crucial pour le déploiement du modèle.

      L'étape 4 utilise la méthode de l'Intersection over Union comme juge de ses prédictions. Cette étape remplace une intervention humaine qui jugerait de la qualité de la prédiction.

      Le schéma ci-dessous tente de synthétiser le processus d'entrainement d'un modèle : 
      

      

      Sachez que vous pouvez choisir votre seuil d'IoU, donc en fonction de la précision nécessaire à votre projet, prenez un seuil plus ou moins haut. Un bonne fourchette est [0.5; 0.8], Ultralytics conseille de prendre une valeur comprise dans cet intervalle.

              

      Enfin, il existe une dernière métrique que vous pourrez observer plus tard : la mAP50-95. Elle consiste à calculer la mAP pour toutes les valeurs de seuils d’IoU comprises entre 0.5 et 0.95 avec un pas de 0.05 (donc : 0.5, 0.55, 0.6, ..., 0.9, 0.95) et à en faire la moyenne.

      Cette métrique est particulièrement intéressante car elle est exigeante en termes de précision de placement de la boite donc en regardant l’évolution de cette valeur, on peut voir si notre modèle englobe correctement. C’est une métrique très commune dans l’industrie de la vision par ordinateur.

                                                                                                                                                                                                               

                                

                  

      F1-SCORE

                                  

      Le F1-score est la moyenne harmonique de la précision et du rappel en fonction du seuil de confiance, donc correspond à la formule suivante : 

      

                  

      La courbe F1 permet de déterminer le seuil de confiance optimal pour le déploiement du modèle. En tant que moyenne harmonique de la précision et du rappel, le score F1 pénalise sévèrement les déséquilibres : une précision parfaite associée à un rappel nul engendre un score très faible, une nuance que les courbes classiques peuvent masquer.

      Le seuil optimal correspond à l'abscisse du maximum de cette courbe, représentant le point d'équilibre idéal maximisant simultanément la précision et le rappel.

      

                                   

      On trouve donc ici qu’un seuil de 0.1 de confiance serait optimal pour maximiser rappel et précision en même temps. (C’est un très mauvais modèle mais c’est juste pour l’exemple!)

      À retenir : l'abscisse du maximum offre une bonne option de seuil de confiance.

                           

      Lorsque la courbe F1 présente un plateau plutôt qu'un pic unique, le choix du seuil de confiance idéal dépend de vos objectifs spécifiques :

      

                    

      • Priorité à la précision (éviter les faux positifs) : choisissez la valeur à l'extrémité droite du plateau (seuil plus élevé). Cela garantit que le modèle ne prédit que lorsqu'il est très sûr, minimisant les erreurs de détection.
      • Priorité au rappel (éviter les faux négatifs) : choisissez la valeur à l'extrémité gauche du plateau (seuil plus bas). Cela permet de capturer un maximum d'objets réels, quitte à accepter quelques fausses alertes.
      • Équilibre : Si aucune contrainte ne prévaut, le centre du plateau est souvent un choix robuste.
  • • Replier Déplier

      confusion_matrix.png - confusion_matrix_normalized.png

      Dans un contexte multi-classes, la matrice de confusion s'étend pour inclure une ligne et une colonne par catégorie, plus une dimension « background » (négatif) représentant l'absence d'objet. Les lignes indiquent les prédictions et les colonnes la vérité terrain.

      La diagonale principale conserve sa signification de prédictions correctes. Les erreurs de classification occupent désormais l'ensemble des cellules hors diagonale. La colonne "background" recense les fausses détections (objets prédits mais absents), tandis que la ligne "background" identifie les objets réels non détectés.

      Pour calculer les métriques de performance (précision, rappel, score F1) et déterminer le seuil de confiance optimal, il est nécessaire de décomposer cette matrice globale. L'analyse s'effectue selon une approche « un-contre-tous »  : une matrice binaire 2x2 est générée pour chaque classe individuellement, isolant les vrais positifs, faux positifs, vrais négatifs et faux négatifs spécifiques à cette catégorie.

      Déjà, nous n’avons pas besoin des vrais négatifs comme vu tout à l'heure. 

      Voyons comment trouver les trois restantes en prenant encore une fois la classe “Penny” comme exemple. 

      

                         

      Pour une classe donnée (ex. : « penny »), les métriques se définissent ainsi à partir de la matrice :

      • Vrais Positifs (TP) : Unique cellule à l'intersection de la ligne et de la colonne de la classe (diagonale).
      • Faux Positifs (FP) : Somme de toutes les autres cellules de la ligne de la classe (prédites comme la classe mais appartenant à une autre).
      • Faux Négatifs (FN) : Somme de toutes les autres cellules de la colonne de la classe (appartenant à la classe mais prédites comme une autre).

             

      Ces valeurs permettent de calculer la précision et le rappel pour un seuil de confiance spécifique, chaque matrice de confusion correspondant à un seuil unique ; la répétition de ce calcul sur l'ensemble des seuils possibles génère ainsi les courbes de performance. Ce processus itératif est répété pour chaque classe, produisant autant de courbes individuelles. Une courbe de synthèse, dite « moyenne » (représentée en gras sur les graphiques), est ensuite dérivée de l'agrégation de l'ensemble des courbes par classe, offrant une vue globale de la performance du modèle.

      À titre indicatif, la valeur optimale du seuil de confiance, correspondant à l'abscisse du maximum de la courbe F1, est directement indiquée dans la légende, immédiatement après la mention « all classes ».

                         

                          

      MATRICE DE CONFUSION MULTI-CLASSE NORMALISÉE

               

      Enfin, il reste la matrice de confusion normalisée. Elle permet d’avoir une vision globale car au lieu de donner les chiffres, elle donne des pourcentages.

      

                             

      Comment la lire ? 

      La matrice de confusion normalisée permet de voir les pourcentages de détection pour chaque classe donc elle se lit colonne par colonne. Par exemple, pour les “Penny” de haut en bas :

      • 1% ont été pris pour des “Dime”
      • 5% ont été confondu avec des “Nickel”
      • 82% des “Penny” ont bien été reconnu
      • 12% n’ont pas du tout été détecté

      On a bien 100% en faisant la somme donc c’est bon.
  • • Replier Déplier

      labels.jpg

      labels.jpg est une image avec quatre graphiques similaires à l’image ci-dessous :

      

                                 

      En haut à gauche : la répartition des différentes classes.

      En haut à droite : superposition de toutes boites englobantes.

      En bas à gauche : les coordonnées du centre des boites englobantes.

      En bas à droite : les dimensions des boites englobantes.

      Ce sont des statistiques sur les données annotées, ce fichier est indépendant de l’entrainement.
  • • Replier Déplier

      results.csv  -  results.png

      Ces documents contiennent les mêmes métriques, l’un sous forme de tableau csv, l’autre sous forme de graphiques. 

      

                         

      Les graphiques de résultats se divisent en deux groupes permettant d'évaluer la convergence et l'efficacité du modèle :

      • les  six courbes de gauche (les loss) : le modèle apprend et fait moins d’erreurs

           

                         

      Les courbes de métriques (deux colonnes de droite) : Précision, Rappel, mAP50 et mAP50-95 illustrent la montée en compétence du modèle. L'objectif est d'observer la progression de ces courbes jusqu'à l'atteinte d'un plateau. Une stabilisation indique que le modèle a atteint son potentiel maximal et que l'entraînement peut cesser. À l'inverse, une croissance continue suggère qu'un prolongement de l'entraînement est nécessaire.

                               

      • les quatre courbes de droite (precision, recall, mAP50, mAP50-95) : le modèle devient plus performant

      

           

      Les courbes de perte (trois colonnes de gauche) : Elles montrent l'évolution de l'erreur (loss) durant l'entraînement et la validation. Une décroissance simultanée de ces deux courbes est le signe idéal d'un modèle qui apprend correctement et généralise bien ses acquis.

            

      POUR ALLER PLUS LOIN

      Le surapprentissage survient lorsque le modèle mémorise par cœur les données d'entraînement au lieu d'apprendre des motifs généralisables. Il devient alors incapable de performer sur de nouvelles données.

      • Détection visuelle : Ce phénomène se repère par une divergence des courbes de perte. Si la courbe d'entraînement (haut) continue de descendre alors que celle de validation (bas) remonte, le modèle surapprend. La courbe de validation agit comme un témoin neutre, car le modèle ne s'entraîne pas sur ces données.
      • Gestion automatique et ressources : YOLO atténue ce risque en sauvegardant deux versions : last.pt (état final, potentiellement surappris) et best.pt (meilleurs poids enregistrés avant la dégradation de la validation). Bien que best.pt garantisse la performance, le surapprentissage reste une consommation inutile de temps et d'énergie de calcul.
      • Optimisation via le paramètre patience : Pour éviter ce gaspillage, il est recommandé d'utiliser le paramètre patience. Celui-ci arrête automatiquement l'entraînement si aucune amélioration n'est détectée sur la validation après un nombre défini d'époques, assurant ainsi que le processus s'interrompt dès que le modèle atteint son optimum.
  • • Replier Déplier

      train_batchx.jpg - val_batchx.jpg

      La quantité d'images générées de ce type est proportionnelle à la taille de votre jeu de données. Ces fichiers offrent un retour visuel sur le comportement du modèle à différentes étapes :

      • train_batchx.jpg : Illustre les échantillons d'entraînement, c'est-à-dire les images annotées (« vérité terrain ») soumises au modèle durant la phase d'apprentissage.
      • val_batchx_labels.jpg : Présente les images du jeu de validation accompagnées de leurs annotations réelles, servant de référence pour l'évaluation.
      • val_batchx_pred.jpg : Affiche les prédictions effectuées par le modèle sur les images de validation. La superposition des boîtes englobantes prédites et des classes identifiées permet d'apprécier visuellement la précision du modèle (localisation et classification) et d'identifier d'éventuelles erreurs.
  • • Replier Déplier

      CONCLUSION

      Si les fichiers de résultats de votre modèle sont satisfaisant, vous pourrez ensuite tester votre modèle sur d’autres données, notamment votre dossier “test”.

      Mais comment savoir si son modèle est bien ? Ouvrez votre dossier de résultats et repassons sur les points importants à aller vérifier.

        

      SYNTHÈSE DES MÉTRIQUES DE PERFORMANCE

                 

      • Score mAp50-95 :
        • où le trouver : dans le fichier results.csv. Point important : dans ce fichier, le séparateur est une virgule "," alors que si vous utilisez Excel, il s'attend à des point-virgule donc le fichier sera illisible. Pour pallier ce problème, ouvrez d'abord votre fichier dans un éditeur de texte, et rajoutez une première ligne où vous écrirez "sep=," comme dans l'image ci dessous :

      

            

      • • enregistrez la modification, fermez le fichier puis vous pouvez l'ouvrir dans Excel.
        • chaque ligne correspond à une époque et chaque colonne contient les valeurs des différentes mesures de pertes, de métriques et du taux d'apprentissage pour l'époque donnée. La colonne qui nous intéresse est celle appelée : metrics/mAP50-95(B).
        • descendez tout en bas de votre document pour pouvoir avoir la valeur de cette métrique lors de la dernière époque de votre modèle.
        • quelle valeur est une bonne valeur : 
          • inférieur à 0.3 : mauvais
          • supérieur à 0.5 : pour des objets complexes : bien
          • supérieur à 0.7 : excellent

                       

      • Courbes de pertes :
        • où les trouver : dans le fichiers results.png pour pouvoir visualiser directement les courbes pour voir leur tendance.
        • ce qu'il faut observer :
          • si les deux courbes descendent et se stabilisent, votre modèle est bien
          • si les courbes de validation (val) remontent alors que celles de l'entrainement (train) descendent, votre modèle est mauvais (signe de surapprentissage)

                        

      • Score F1 :
        • où la trouver : c'est le fichier BoxF1_curve.png 
        • ce qu'il faut vérifier :
          • il faut que le courbe monte haut, le plus proche de 1.0.
        • ce qu'il faut récupérer :
          • récupérez l'abscisse du maximum car c'est la valeur optimale à donner à votre seuil de confiance. C'est la valeur qui est écrite dans la légende à côté de "all classes". On y lit : "all classes valeur_max at seuil_optimal" donc vous récupérez la deuxième valeur pour la mettre dans la variable "conf" au moment du déploiement de votre modèle.

                   

      • Retour visuel (valbatchXpred.jpg) :
        • ces images correspondent à la sortie du modèle, donc cela vous permet d'avoir un retour visuel de votre entrainement. Vous pouvez y vérifier que la détection se passe bien, que les boites sont au bon endroit et qu'aucun objet n'est oublié.

                       

                  

      VALIDATION SUR LE JEU DE TEST

             

      Si le modèle semble satisfaisant, évaluez le sur des données inédites (dossier « test ») :

      Chargement : Importez le modèle optimisé (best.pt) situé dans runs/detect/trainX/weights :

      from ultralytics import YOLO

      model = YOLO(“chemin/vers/votre/fichier/best.pt”)  # n’hésitez pas à mettre le chemin absolu sauf si vous êtes sur le cluster

                             

      Configuration : Assurez-vous que le fichier data.yaml contient le chemin vers le jeu de test (ou créez un data_test.yaml).

      Exécution : Lancez la validation spécifique :

      metrics = model.val(split=”test”)

             

      Analyse : Consultez les résultats générés dans runs/detect/valX. Si les performances sont insuffisantes, un réentraînement est nécessaire.

                           

                

      RÉENTRAINEMENT ET OPTIMISATION

                          

      Pour améliorer un modèle sous-performant, deux stratégies sont possibles :

      • Prolongation de l'entraînement :
        
        • Chargez impérativement les poids de la dernière époque (last.pt) et non les meilleurs (best.pt).
        • Lancez l'entraînement avec l'option resume=True. Le paramètre epochs indique alors le nombre total d'époques visé (ex. : pour passer de 100 à 150 époques, indiquez epochs=150).

      from ultralytics import YOLO

      model = YOLO(“chemin/vers/votre/fichier/last.pt”)

      results = model.train(epochs=150, resume=True)

      • Ajustement des hyperparamètres : Si la prolongation de l'entraînement s'avère insuffisante, il pourra être nécessaire de modifier la configuration du modèle (taux d'apprentissage, taille du batch, architecture, etc.). Ces réglages avancés, spécifiques à chaque cas d'usage, ne sont pas détaillés dans ce document ; il est recommandé de consulter la documentation officielle d'Ultralytics ou les ressources spécialisées en ligne pour approfondir ces aspects.
  • Sélectionner l’activité Diapo_Résultats

    

    Diapo_Résultats Fichier
  • Sélectionner l’activité ppt_Résultats

    

    ppt_Résultats Fichier
  • Sélectionner l’activité Test de satisfaction Résultats

    

    Test de satisfaction Résultats Sondage
• Sélectionner la section UTILISATION DU MODÈLE ENTRAÎNÉ

  Replier Déplier

  UTILISATION DU MODÈLE ENTRAÎNÉ

  Une fois l'entraînement terminé, l'intégration du modèle dépend de votre environnement de déploiement.

  1. Exportation du modèle (environnements non-Python) : si votre application ne repose pas sur Python, il est nécessaire d'exporter le modèle (initialement au format PyTorch .pt) vers un format optimisé pour votre matériel cible (ex. : TensorRT pour GPU, CoreML pour iOS, TFLite pour mobile). Cette conversion améliore significativement la vitesse d'inférence et réduit la consommation de ressources. La liste complète des formats supportés et les arguments d'exportation sont disponibles dans la documentation officielle d'Ultralytics.

  2. Utilisation en environnement Python : si vous restez dans l'environnement Python utilisé pour l'entraînement, le chargement et l'exécution sont directs :

  from ultralytics import YOLO 

  model = YOLO("best.pt") # Charger le meilleur modèle

  results = model.predict(source="chemin_vers_votre_image/image.jpg", conf=0.25) # N'oubliez pas de spécifier le seuil de confiance optimal ici
  

                   

  3. Exploitation des résultats : l'objet results contient les détections sous la forme d'une liste d'objets boxes. Pour chaque objet détecté, vous pouvez extraire :

  • Coordonnées : Via xyxy (coins haut-gauche/bas-droite) ou xywh (centre/largeur/hauteur), ainsi que leurs versions normalisées (xyxyn, xywhn).
  • Confiance : Via l'attribut conf (score de probabilité entre 0 et 1).
  • Classe : Via l'attribut cls (index correspondant aux catégories définies dans votre fichier data.yaml).
  • Suivi : Via l'attribut id si la méthode model.track() a été utilisée.

       

  Exemple d'itération sur les détections :

  results = model("image.jpg")

  for r in results: # itère sur chaque objet détecté dans l'image

  print(r.boxes.xyxy) # coordonnées des coins (haut gauche/bas droit)

  print(r.boxes.xywh) # coordonnées du centre et de la taille de la boîte avec w ("width") : la largeur et h ("height") : la hauteur

  print(r.boxes.conf) # scores de confiance

  print(r.boxes.cls) # index de la classe

           

  Ces données structurées peuvent ensuite être intégrées directement dans votre logique métier pour des calculs ultérieurs ou des actions automatisées.
• Sélectionner la section COMPLÉMENT FACULTATIF

  Replier Déplier

  COMPLÉMENT FACULTATIF

  CETTE PARTIE EST COMPLÈTEMENT FACULTATIVE

                

  Yolo propose différents paramètres qui peuvent changer l’issue de l’entraînement, on va voir lesquels mais pour cela, nous allons devoir aborder quelques thématiques propres à l’intelligence artificielle : la fonction de perte (aussi appelée fonction de coût) et l’optimiseur.

  Le schéma ci-dessous permet de comprendre comment les différentes composantes s’organisent entre elles. Nous allons voir étape par étape ce qu’il se passe.

  

                 

  Commençons par le modèle vu qu’on travaille avec depuis le début.

  

                   

  Le modèle peut être vu comme un jeu de chute de bille, voir la photo ci-dessous. Le principe de ce jeu est de lâcher une bille en haut d’un plateau vertical rempli de clous et de regarder dans quel bac elle tombe en bas pour marquer des points.

  

                  

  Le fonctionnement du modèle est similaire au plateau de clous, c’est-à-dire que le modèle en lui même est passif, il prend juste une entrée (bille → image), la fait passer dans son algorithme (clous → neurones) puis donne une sortie (bac → classe + boite).

  Les clous sont semblables aux neurones du modèle, c’est-à-dire que si on veut que la bille aille bien où nous voulons, il va falloir placer les clous judicieusement. C’est exactement pareil avec notre modèle, il est passif, mais les autres composantes du schéma (fonction de perte et optimiseur) vont venir arranger les clous pour que notre modèle soit capable de faire tomber les billes dans le bon bac.

             

  Propagation avant

             

  La propagation avant est le fait de donner une image (ou plusieurs) au modèle et de regarder ce qu'il se passe quand cette image traverse le modèle. Donc lâcher la bille depuis le haut du plateau et regarder dans quel bac elle arrive.

  Pour parler de la propagation avant, ou forward pass, nous allons utiliser une seconde analogie que nous garderons le long de l’explication du modèle.

  Un·e professeur·e décide de faire un travail noté. Faire un examen comporte plusieurs étapes similaires à un entrainement :

  • préparer le sujet → annoter les données
  • le donner à faire aux élèves → propagation avant
  • corriger leur travail → fonction de perte
  • les évaluer de nouveau plus tard pour s’assurer qu’ils ont appris → répétition des trois pas précédents

                 

  

                     

  L’élève est semblable à un paramètre du modèle, il a des connaissances, puis en fonction de celles ci, il donne des réponses. L’ensemble des élèves constitue le modèle entier.

                    

     

  Fonction de perte

               

  Maintenant, regardons la fonction de perte :

  

                   

  Maintenant que le professeur a récupéré les copies il va les corriger. Donc comparer les réponses aux bonnes réponses attendues. Mais il peut avoir plusieurs critères pour noter une copie :

  • exactitude des résultats
  • pertinence des explications
  • belle écriture/lisibilité

               

  Ainsi, à l’aide de ces trois paramètres, la performance se verra attribuée une note.

                  

  

                 

  De la même façon, pour savoir si le modèle a fait une bonne prédiction, on va prendre des critères et voir à quel point ils sont satisfaits. Ces critères sont rassemblés dans une équation qu’on appelle une fonction de perte. La fonction de perte est en charge d’évaluer l’écart entre une prédiction et la vérité terrain. Le but est de pouvoir quantifier cet écart, pouvoir mettre un nombre dessus pour avoir une idée de la qualité du résultat.

  YOLOv26 utilise trois critères :

  • choix de la bonne classe (cls) : pour quantifier une “distance” entre deux classes, on peut le voir comme un arbre phylogénétique où chaque chemin pèse de 1 dans la balance. Par exemple, si le modèle prédit “bird” à la place de “snake”, on a une distance de 5. Ce n’est pas ainsi que YOLO fait, mais cela permet de se faire une idée.
  • précision dans le positionnement de la boite englobante (box) : pour ce cas, on va regarder à quel point la boite prédite et la boite réelle se chevauchent.
  • affinage de la précision des boites pour les objets aux contours flous (dfl) : on ne va pas s’attarder sur cette mesure car elle est un peu complexe.

               

  Pour une prédiction faite, on aura donc trois pertes :

  • celle liée à la classe : cls_loss
  • celle liée au placement de la boite englobante : box_loss
  • celle liée à la précision des bordures de la boite : dfl_loss

                  

  On les additionne ensuite pour avoir un score global de la prédiction. Cette addition constitue la base de la fonction de perte.

  

                   

  Ce qui est très important à comprendre, c’est que même si on ne les voit pas, les paramètres sont à “l’intérieur” de chaque perte. Cela est très utile car cela va nous permettre plus tard de nous guider : si la cls_loss est grande c’est parce que le paramètre 158 est pas comme il faut etc...

  Sous cette forme, la fonction de perte est incomplète, il y a plusieurs éléments à rajouter.

                        

  Pour commencer, on ajoute une pondération, c’est à dire un facteur devant chaque perte pour pouvoir hiérarchiser les pertes dans le résultat total. On peut le voir comme les coefficients des matières au lycée : coefficient 7 en maths donc la note de maths pèse beaucoup dans la moyenne alors qu’on a que coefficient 2 en français donc la note est moins “moins importante” dans le calcul de la moyenne.

  Prenons λ₁, λ₂ et λ₃ nos coefficients (appelés “gain” en vision par ordinateur), l’équation devient :

  

                   

  Les trois lambdas ont des valeurs prédéfinies par YOLO (λ₁ = 0.5, λ₂ = 7.5, λ₃ = 1.5) mais vous pouvez toujours les modifier si vous voulez.

           

  Il reste un dernier membre à cette fonction de perte. Ce membre de l’équation ne sert plus à mesurer l’écart entre la prédiction et la vérité terrain mais est un terme qui va servir de pénalisation. Bien sûr, toujours dans l’optique d’améliorer notre modèle. Voyons l’intérêt.

  Un phénomène assez courant en apprentissage (même pour les humains) est le surapprentissage, c’est-à-dire quand on apprend par cœur nos données d’entrainement au lieu d’apprendre à généraliser. Exemple : apprendre par cœur une démonstration de mathématiques sans comprendre la méthode.

  Comment cela se traduit pour un modèle ? Ses paramètres prennent de très grandes valeurs qui sont adaptées aux données d’entrainement mais une fois confrontés à de nouvelles images, ce sera un échec.

  Donc comment faire en sorte que le modèle ne tombe pas dans le surapprentissage ? En intégrant la somme des poids dans la fonction de perte, comme ça, le modèle ne peut s’améliorer qu’en ayant des paramètres de faible valeurs. (Utile de rappeler ici que l’objectif est de faire en sorte que le résultat de la fonction de perte doit être le plus petit possible.) 

  La forme que prends ce membre de l’équation est la suivante :

  

             

  Ce terme porte un nom spécifique en anglais : weight decay (le terme français est L2 régularisation, mais nous utiliserons ici le terme anglais donc weight decay).

  La forme finale de la fonction de perte est donc :

  

               

  Pour chaque prédiction faite (donc chaque image), on récupère la valeur issue de la fonction de perte puis on moyenne cette valeur avec toutes les autres images pour avoir une valeur unique. Cette valeur correspond à ce qu’on pourrait appeler le score du modèle et le but va être de minimiser ce score pour rendre l’écart entre la prédiction et la réalité la plus petite possible.

  Ce sera la mission de l’optimiseur : modifier les paramètres du modèle pour que l’erreur diminue.

  Pour comprendre comment fonctionne l’optimiseur, il est astucieux de visualiser spatialement la fonction de perte. Pour visualiser la fonction de perte en trois dimensions on va imaginer un réseau constitué de 2 paramètres. (Ce qui n’est pas beaucoup car même un escargot a 11 000 neurones 🐌). On obtient une surface qui peut ressembler à celle ci-dessous:

  

                   

  Contrairement à ce que laisse penser le schéma ci-contre, on ne peut pas calculer la fonction de perte dans son entièreté et voir le minimum directement, car ce serait démesuré en terme de calcul (il y a plus de calculs à faire qu’il n’y a d’atomes dans l’univers).

  Simulons un entraînement : le modèle vient de finir une propagation avant et donc calcule son erreur grâce à la fonction de perte. Cela nous place à un endroit donné de la courbe : petite chèvre 🐐 des montagne ci-dessous :

  

                 

  L’objectif ici est de descendre jusqu’au point le plus bas, donc l’endroit pointé par la flèche, mais on ne sait pas où il est dans le cas pratique.

  Donc la seule chose que l’on peut faire c’est regarder notre environnement très proche pour regarder la “tendance” de la montagne. Imaginez : vous êtes perdu en randonnée et il y a un brouillard très épais. Vous ne voyez pas où vous devez aller, mais vous savez que vous devez descendre pour avoir une chance de manger votre dessert préféré à nouveau 🍰. Vous entreprenez donc avec vos pieds de chercher de quel côté le relief descend le plus, c'est le même principe ici.

              

  Optimiseur

             

  C’est lui qui va se charger de trouver le chemin à prendre pour descendre de la montagne.

  

                            

  L’optimiseur va faire pareil que vous sur la montagne embrumée, il va regarder autour de son point de départ dans quelle direction il doit aller pour descendre.

  L’outil mathématique qui permet de trouver la pente la plus raide (steepest slope/descent en anglais) sur une surface est le gradient (car oui, le modèle n’a malheureusement pas de pieds pour tâter le sol...). Le gradient est une dérivée vectorielle, c’est-à-dire qu’il permet de trouver la tangente la plus penchée d’une surface de dimension x. Ce processus qui consiste à prendre le gradient pour trouver la descente s’appelle, de manière très originale, la descente de gradient (gradient descent en anglais).

  Une fois que l’on a la direction, il faut décider de la taille du pas qu’on fait. Est-ce qu’on fait une grande enjambée au risque de tomber sur quelques chose qu’on n’avait pas vu, ou un pas tout petit pour avancer de manière plus sûre mais donc prendre plus de temps ?

  C’est un des rôles de l’optimiseur, il va décider comment le modèle avance, soit prudemment, soit frénétiquement, soit de manière adaptée au contexte.

  La longueur du pas que l’optimiseur va faire prendre au modèle s’appelle le taux d’apprentissage (learning rate en anglais).

  Les deux graphiques ci-dessous montrent comment le taux d’apprentissage influence l’entrainement :

                 

  

                                              

  Sachant que sortir d’un “trou” n’est pas forcément une mauvaise chose car on peut se retrouver dans un minimum local, c’est-à-dire un minimum par rapport au relief adjacent mais qui ne correspond pas au point le plus bas de la montagne de manière globale.

  Sur le dessin ci-dessous par exemple, on ne veut pas rester coincé·es dans le point “1”, on veut retrouver la plaine tout en bas.

  

                        

  Donc il ne faut pas non plus un pas trop petit.

          

  Il existe des techniques pour adapter le pas en fonction de l’entrainement, comme dans l’exemple ci-dessous. Cela permet une approche beaucoup plus sur-mesure de l’entrainement.

  

              

  Une fois qu’on a la direction et la taille du pas, on va pouvoir avancer dans cette direction. Pour cela, l’optimiseur va modifier les paramètres pour aller à ce point là.

  Dans le cas ci-dessous, pour faire descendre vers le point la petite chèvre, il faut baisser la valeur des deux paramètres.

  

                  

  Dans le cas pratique, pour calculer comment chaque paramètre doit être modifié, l’optimiseur utilise les dérivées partielles (dérivée selon chaque paramètre) calculées par l’algorithme de rétroprogation pour ajuster la valeur de chaque poids du modèle.

  Une fois tous les paramètres modifiés, le modèle reprend l’entrainement avec d’autre propagation avant pour continuer d’améliorer ses paramètres. Donc le modèle "descend" progressivement de sa montagne au fur et à mesure des entraînements.

  

                

  L’entrainement s’arrête que le modèle “stagne” dans un minimum. C’est à ce moment que le modèle peut être testé sur de nouvelles données pour vérifier qu’il généralise bien.

              

  Pour reprendre le parallèle avec la classe d’élève :

  Le professeur a fini de corriger les copies et il estime qu’une correction devant la classe s’impose. Il va essayer de corriger les erreurs des élèves en leur faisant comprendre le mieux possible d’où elles viennent. Cette partie dépend de la manière de corriger du professeur.

  Comme vu précédemment, à partir des résultats de la fonction de perte l’optimiseur va permettre de calculer les changements à apporter au modèle afin qu’il se rapproche du résultat souhaité. Les changements vont dans une direction et représentent la compréhension de l’élève vis à vis des erreurs. On appelle ça la rétropropagation, car on part de la fin du modèle pour mettre à jour l’intégralité de celui ci.

  

              

  Les changements sont opérés sur chaque paramètre du modèle. Il y a différents optimiseurs qui ont des caractéristiques différentes, cela représente les différentes méthodes que le professeur peut utiliser pour faire comprendre la correction. Le plus classique est la descente de gradient simple.

                

  Récapitulatif

                

  

                        

  Lien avec vos données

                 

  Petit aparté rapide pour faire le lien avec les données que l’on a préparé au tout début. Nous avons vu que nous pouvions donner jusqu’à trois dossiers d’images à YOLO : train, val et test.

  Mais comment le modèle s’en sert-il ? Supposons un entraînement en 100 époques.

                 

  

                   

  • • TRAIN

  Le dossier d’images “train” est utilisé pour faire le processus décrit précédemment, à savoir : propagation avant → fonction de perte → optimisation.

  Disons qu’il y a 1600 images dans notre dossier train.

  Le dossier est divisé en groupe d’images appelés batchs (16 images par batch par défault, mais ce paramètre peut-être changé), et ce qu'il va se passer, c’est que YOLO va formatter ces 16 images comme un volume (il va les concaténer spatialement en quelque sorte). Cela a plusieurs intérêts :

  • cela est plus en phase avec le fonctionnement de l’ordinateur car le fait que les images soient organisées comme ça lui permet de les traiter en parallèle plutôt que les unes à la suite des autres, ce qui lui fait gagner du temps
  • à la fin de chaque batch, le modèle fait une rétropropagation pour adapter les paramètres, donc on a 100 rétropropagations (batchs de taille 16 dans un dossier de 1600 images) dans une époque, au lieu d'une seule grosse rétropropagation à la fin d’une époque.

                  

  • • VAL

  La validation arrive à la fin de chaque époque (à part si vous avez mis manuellement val=False). Il est crucial de noter que le modèle fait des prédictions sur ces images mais aucune phase de rétropropagation ne suivra, donc le modèle n'apprendra pas sur ces images, ce qui fait qu'à chaque phase de validation, le modèle se comporte comme si c'était la première fois qu'il voyait ces images. Cette étape permet surtout de sortir des métriques, notamment la matrice de confusion et tout ce qui en découle. C’est notamment grâce à cette étape que le modèle est capable de choisir quelle itération du modèle est la meilleure pour pouvoir la mettre dans la fichier “best.pt”.

             

  • • TEST

  Enfin, le dossier test permet de tester votre modèle sur d'autres données. Il faut lancer une commande spécifique. Vous pouvez retrouver toutes les infos dans la conclusion de la section "Résultats".

                 

  Si on fait une petite frise du fonctionnement d’un entrainement, on a :

  

      

  

                           

  À savoir que YOLO modifie la combinaison des images dans les batchs entre chaque époque. 

                       

               

  Étude d'un cas pratique

                  

  En deep learning l’architecture de modèle classique est le réseau de neurones dense, c’est-à-dire que chaque couche de neurones est complètement connectée à ses voisines.

  

                  

  Chaque cercle correspond à un neurone et chaque flèche à un paramètre. Il dispose d’une couche d’entrée et d’une couche de sortie et entre ces 2 là un certains nombre de couches, dites cachées.

  L’entrée contient la donnée sur laquelle on entraîne le modèle et au travers des paramètres et des neurones on récupère une sortie. C’est ce qu’on a précédemment appelé la propagation avant.

  Lorsque l’on utilise le résultat de la fonction de perte pour mettre à jour les poids c’est la rétropropagation et l’optimisation, qui arrive à la fin de chaque batch.

  Lorsque l’on a traité toutes les données, donc à l’issue de tous les batchs, on a terminé une époque.

  Nous allons faire un exemple numérique afin de bien comprendre ce qu’il se passe.

  Les neurones de la couche d’entrée contiennent les informations sur la donnée d’entrée.

  

                

  Un neurone suit une règle de base afin de calculer sa valeur :

  

               

  Avec ω_kj le poids (paramètre) qui part du neurone j pour aller au neurone k, h_j la valeur du neurone j et Φ une fonction d’activation.

  Prenons l’exemple du calcul de h₃ et utilisons la fonction identité qui est linéaire pour faire le calcul, même si de manière générale la fonction doit être non linéaire.

  

                

  Si on fait la même chose pour tout le réseau on a : 

  

         

  À la fin nous avons la prédiction de notre neurone sur la valeur, qui est assez loin de la vérité.

  Nous allons maintenant utiliser une fonction de perte pour estimer cette erreur. Nous utiliserons l’écart au carré :

  

                 

  Nous avons l’erreur à la fin de la propagation avant, il faut maintenant mettre à jour les paramètres afin d’améliorer le modèle à l’aide de la rétropropagation.

             

  Nous allons utiliser une descente de gradient simple avec un taux d’apprentissage noté de 0.1.

  

                

  Pour mettre à jour par exemple le poids w₃₅ on utilise la formule suivante pour calculer son gradient :

  

                

  Et ensuite pour mettre à jour sa valeur on utilise la dérivée partielle précédente et le taux d’apprentissage, selon l’optimiseur la formule peut changer : 

  

               

  Donc le poids prend la valeur 0.54 :

  

                        

  Ce processus est effectué sur tous les poids car on peut toujours exprimer la valeur d’un neurone par rapport aux poids desquels il dépend.

  Il faut penser qu’il faut dériver la fonction d’activation, qui ici était la fonction identité.

                

         

  Convolutional Neural Network (CNN)

          

  YOLO traite des images, le fonctionnement du modèle est donc différent de ce que l’on a montré précédemment. C’est un modèle CNN qui utilise des filtres, afin d’extraire les caractéristiques des images. Les valeurs contenues dans les filtres sont les paramètres du CNN. Voici un exemple d’extraction de caractéristique avec un filtre.

  

                 

  Si on regarde le calcul ayant donné la case rouge R de la sortie on a :

  

           

  Comme pour l’exemple précédent il y a une fonction d’activation. Chaque couche contient plusieurs filtres différents et il y a en général plusieurs couches successives.

  La rétropropagation fonctionne de la même manière que dans l’exemple précédent afin de mettre à jour les paramètres, qui sont ici les valeurs des filtres.

               

  Nous avons vu de manière succincte comment fonctionnait un modèle. Jusque là nous avons vu les paramètres, donc ce qui compose effectivement notre modèle, similaires à des neurones. Maintenant, nous allons parler des hyperparamètres.

  Par opposition aux paramètres qui sont modifiés tout au cours de l’entraînement, les hyperparamètres sont fixés au début de l’entrainement et ne bougent plus après (avec quelques exceptions).

  Comme hyperparamètre on retrouve :

  • le nombre d’époques (fixé au début mais peut-être interrompue grace à l’hyperparamètre patience)
  • la taille des batchs (valeur constante, peut être fixée ou choisie en fonction de la puissance de calcul de votre machine)
  • tous les coefficients que l’on a vu jusque là donc λ₁ (cls_loss), λ₂ (box_loss), λ₃ (dfl_loss), α (weight decay) qu’on retrouve dans la fonction de perte. (fixes)
  • le taux d’apprentissage (varie pendant l’entrainement)
  • tout ce qui est lié à l’augmentation de données (fixe)
  • et plusieurs autres sur lesquels nous allons nous attarder

                 

  Ces hyperparamètres jouent un rôle important dans l’entrainement et il est parfois compliqué de savoir exactement les valeurs optimales, alors il faut tester plusieurs combinaisons.

  Ajuster ces paramètres s’appelle le finetuning. Et chaque combinaison d’hyperparamètre aura des résultats différents.

  

                     

  Passons maintenant sur quelques hyperparamètres intéressants.

             

  Dropout

             

  Le dropout est un hyperparamètre qui va agir directement sur l’entrainement en changeant quelques dynamiques.

  Revenons à notre classe d’élèves. Supposons une épreuve où les élèves doivent s’organiser par petits groupes pour faire des exercices notés avec pour objectif d’avoir la meilleure moyenne générale. Chaque groupe est assigné une matière différente. Si jamais le groupe assigné aux mathématiques est très bon, les autres groupes des autres matières n’auront pas besoin d’être bon pour avoir une bonne moyenne de classe. Dans le schéma, les flèches représentent les élèves et les neurones sont les matières.

  Comme on a vu dans l’exemple, l’activation d’un neurone se fait avec tous les paramètres qui lui sont associés, cela va de même pour la sortie, la moyenne dans notre analogie.

  Le but du dropout est de désactiver certains neurones lors des différentes propagations avant afin de ne pas dépendre de neurones spécifiques et de leurs paramètres associés et de bien généraliser le modèle. C’est une technique de régularisation.

  Par exemple, si le modèle a “compris” que les oiseaux avaient un bec et ne se focalise plus que là-dessus, le moment où le bec est caché pour x raison, il ne sait plus reconnaitre un oiseau.

  Le dropout est une valeur comprise entre 0 et 1. Il faut le comprendre comme une probabilité qu’un neurone se désactive lors d’une propagation avant.

  On peut le schématiquement le voir comme ça :

  

                    

              

  Momentum

               

  Le momentum est un hyperparamètre qui va agir directement sur l'optimiseur en influençant la direction prise pour la descente de gradient.

  Regardons le phénomène visible sur le schéma ci-dessous. C’est une vue “du dessus” de la descente de gradient :

  

                

  On voit bien que le chemin peut être très zigzaguant et que cela nous fait perdre en rapidité pour atteindre le minimum.

  Pour éviter cela, il existe une méthode qui s’appelle le momentum, qui consiste à garder en mémoire les déplacements précédents, similairement à une boule très lourde qui roule et dont la direction est difficile à changer à cause de l’inertie.

  Concrètement que se passe-t-il ? On calcule le gradient du point où nous sommes, mais au lieu d’aller strictement dans cette direction, on va faire une somme de vecteur en combinant le nouveau avec celui de l’itération précédente. Faisons un schéma :

  

                      

  On se retrouve donc avec une descente de gradients beaucoup plus fluide et continue, comme sur le schéma ci-dessous :

  

            

  Mathématiquement, cela s’écrit :

  

            

  Où ν est un coefficient compris entre 0 et 1 et qui permet de pondérer la prise en compte de la direction précédente. Sachant que le coefficient (1-ν) est pas systématique et sa présence dépend de la méthode utilisée.

          

      

  Conclusion

  Lors de l'entrainement d'un modèle d'intelligence artificielle, il y a de nombreux hyperparamètres qui sont là pour différentes raisons, soit pour converger plus rapidement, soit pour avoir un modèle plus précis ou plus robuste. En fonction de ce que vous voulez, vous pouvez modifier les hyperparamètres, mais chaque entrainement est unique et le même changement n'aura pas la même la même réaction sur deux entrainement différents. Changer les hyperparamètres n'est donc pas une science exacte mais un processus empirique, donc il vous faudra tester plusieurs combinaison pour savoir laquelle fonctionne le mieux.

  Ultralytics fournit aussi un algorithme qui permet de chercher les meilleurs hyperparamètres, c'est la fonction model.tune(). Elle permet de lancer un entrainement qui va se répéter automatiquement en changeant ses hyperparamètres toute seule. Ce processus qui consiste à chercher les meilleurs hyperparamètres s'appelle le finetuning. 

       

  Voyons rapidement comment fonctionne la fonction. Pour la syntaxe de base on a :

        

  model.tune(

  data=data.yaml,

  epochs=30,

  iterations=300)

                   

  On retrouve data et epochs qui sont identiques à un entrainement normal. En revanche, iterations est un nouveau paramètre, c'est le paramètre qui permet de préciser le nombre de répétition que fera le modèle. C'est-à-dire que dans notre cas, le modèle va s'entrainer sur 30 époques en changeant 300 fois la combinaison d'hyperparamètres. On aura donc un temps de travail équivalent à 9000 époques, ce qui est très grand, surtout si vous avez beaucoup d'images, mais avec les bonnes ressources de calcul, cela peut vous permettre d'avoir un modèle plus performant à la fin. Vous trouverez toutes les informations nécessaires sur cette page d'Ultralytics.

            

  De manière générale, le site d'Ultralytics est très bien fait avec beaucoup de ressource mais est en anglais. Vous pouvez cependant poser des question à leur chatbot à qui vous pourrez parlez en français si vous y êtes plus à l'aise.

  • • Replier Déplier

      Compréhension rudimentaire d'un modèle de Deep Learning

      • Sélectionner l’activité Ressources (copie) (copie) (copie)

        Ressources

      • Sélectionner l’activité Test de satisfaction Compréhension d'un modèle de Deep Learning

        

        Test de satisfaction Compréhension d'un modèle de Deep Learning Sondage