Cours : 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
Sélectionner la section Introduction

Replier Déplier
Introduction
- Sélectionner l’activité Dans ce tutoriel on va voir comment faire de la dé...
  
  Dans ce tutoriel, nous allons voir comment faire de la détection et de la reconnaissance d’objets sur des images. Nous allons apprendre à entraîner un modèle d’intelligence artificielle pour qu’il soit capable de reconnaître ce que vous souhaitez et qu'il le localise dans l'image avec une boîte englobante.
  
  Un modèle entraîné à reconnaître des "geais bleus" donnera le résultat ci-dessous :
  
  Entraînement supervisé du modèle
  
  Pour entraîner un modèle d'intelligence artificielle à reconnaître quelque chose, il faut lui donner des images où le sujet d'intérêt a déjà été encadré par intervention humaine, c'est ce qu'on appelle une image annotée.
  
  Un prérequis de cette formation est d'être en possession d'une large base d'images : le nombre d’images dont le modèle à besoin n'est pas absolu, ainsi vous pouvez lire cette documentation qui est dédiée au sujet.
  
  La première étape est d'annoter ces images. Cela revient à venir encadrer manuellement ce que l'on souhaite faire apprendre à notre modèle sur toutes les images de notre base de données. Cette étape est fastidieuse mais impérative pour pouvoir entraîner notre modèle. Il est possible que vous trouviez des bases de données déjà annotées sur internet, mais si votre sujet d'intérêt est très niche, cela est peu vraisemblable.
  
  Petit point de vocabulaire
  
  Les sujets d’intérêt doivent porter un nom qui désigne leur catégorie d’appartenance que l’on appelle classe. Donc par exemple on peut avoir une classe “chat” et une classe “chien”, mais on peut aussi avoir une classe “berger australien” et “braque de Weimer”. Vous pouvez choisir absolument ce que vous voulez, que ce soit très général ou très spécifique.
  
  Nous utiliserons dorénavant beaucoup le mot classe, donc il faut bien se rappeler que ce mot correspond simplement aux catégories d’objets que l’on souhaite détecter.
  
  Autre point, il est important de comprendre que le modèle, une fois entraîné sur des données, ne sera efficace que sur des données similaires aux données d’entrainement. Par exemple : si vous n’aviez qu’une classe “chat” et que vos données ne montrent que des chats dans la neige, si vous lui donnez ensuite une image de chats dans une prairie, il ne le reconnaitra pas forcément voire pas du tout. Ayez une base de données qui représente vos cas de détection.
Sélectionner la section Annotation

Replier Déplier
Annotation
- 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 preprocessing consiste à appliquer une ou plusieurs transformations aux images annotées de la base de données.
  
  Posons x le nombre d'images de notre base de données. Le preprocessing s’applique à toutes les images de base donc avant le preprocessing on en a x et après aussi. Le preprocessing ne change pas notre nombre d’image. Cependant il modifie nos images de base donc on “perd” nos images de base vu qu’on ne garde que leurs versions modifiées.
  
  Cette étape permet d'appliquer une transformation aux images de la base de données pour les rendre plus uniformes.
  
  Quelques exemples de preprocessing et leur utilité :
  
  ajustement de la taille : très pertinent pour rendre uniforme le dataset en terme de dimensions.
  
  conversion en niveau de gris : si les couleurs sont ne sont pas pertinentes, convertir en nuances de gris permet de gagner de l’espace de stockage et du temps de calcul. Attention, il ne restera que des images en nuances de gris, les images couleurs ne seront plus présentes.
  
  suppression d'artefacts gênants : filtre numérique pour supprimer des éléments de l'image, comme du bruit par exemple.
  
  
  
  Augmentation
  
  On a vu au tout début l’intérêt d’avoir un large éventail de données, cependant, ce n’est pas forcément aisé de rassembler plein d’images avec l’objet dans différentes conditions, donc il est possible de traiter les images numériquement pour leur appliquer des variations afin d'obtenir plus d'images à partir d'une seule image.
  
  C'est le rôle de l'augmentation, qui comme son nom l’indique va permettre de grossir notre base de données. L’intérêt principal est de varier les images comme le montre le schéma ci-dessous: au lieu d’avoir juste une image d’un chat dans le “bon” sens et en couleur, on va appliquer des transformations. Ici le nom au dessus de chaque image correspond à l’opération appliquée. Le modèle sera ensuite capable de reconnaître un chat même si il est en nuance de gris et à "l’envers".
  
  
  
  En sortie de l’augmentation on a donc plus de données qu’en entrée, comme dans l’exemple ci-dessus, si on prend x notre nombre d’image et qu’on applique les 6 transformations du schéma, on aura x + 6*x images donc 7*x images.
  
  Cette opération diffère du preprocessing et le complète : si on rajoute les nuances de gris lors de l’augmentation, on aura les images de base + les images en nuances de gris, le nombre d'image aura doublé. L’entrainement se fera donc sur les images colorées et sur les images en nuances de gris (à l’inverse du preprocessing où les images colorées disparaissent).
  
  
  
  Comment choisir ?
  
  Selon votre cas, vous pouvez choisir de faire du preprocessing et/ou de l’augmentation de données comme nous avons vu. Mais ces changements peuvent soit se faire soit en amont, soit pendant l’entrainement.
  
  Si ces changements sont faits en amont : toutes les variations de l’image principales seront créées donc potentiellement beaucoup de place sera utilisée, mais le modèle n’aura plus qu’à les prendre, donc l’entrainement sera plus rapide. Les changements en amont sont faits sur Roboflow.
  
  À l’inverse, si ces changements sont faits pendant l’entrainement : toutes les variations de l’image principales seront créées en direct et ne seront stockées que temporairement, mais cela prendra du temps de calcul au modèle qui devra fabriquer les images en cours de route. Ceci est fait par YOLOv26 (Yolov26 est le modèle d’intelligence artificielle que nous utiliserons tout à l’heure).
  
  Sur Roboflow, vous pouvez voir exactement ce qui est fait, et choisir point par point ce que vous voulez faire. En revanche, YOLOv26 applique beaucoup de transformation par défaut donc si on veut les désactiver il faut le faire à la main pour chaque transformation, ce qui peut s’avérer être fastidieux.
  
  
  
  Si vous êtes débutant, il est recommandé de ne faire aucune augmentation sur Roboflow car YOLO s’en occupe déjà (vous pouvez quand même faire du preprocessing selon vos besoins). Vous n’avez donc pas besoin de vous embarquer dans la compréhension de chaque transformation.
  
  Sinon, le principal argument qui permet de choisir comment faire l’augmentation est la ressource de calcul. Si vous en avez beaucoup (vous travaillez sur un cluster par exemple), vous pouvez laisser YOLO faire plus de calculs, mais si vous êtes sur votre machine personnelle sans trop de ressources, préférez faire l’augmentation sur Roboflow, cela prendra plus de place mais rendra l’entrainement plus rapide. Dans ce dernier cas, n’oubliez pas de désactiver les nombreux paramètres d’augmentation de YOLO pour ne pas avoir des données complètement difforme à cause de transformations combinées (nous allons voir comment faire plus tard).
- 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

Entraînement

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 :

Allez dans votre dossier de travail
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".

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
  
  Une fois l’entrainement terminé, vous pourrez retrouver vos résultats dans le dossier “runs/detect/train” (à part si vous aviez configuré un autre nom pour votre dossier de résultats).
  
  Dans ce dossier on retrouve toutes les choses ci-dessous (peut varier légèrement) :
  
  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).
- 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é.
  
  
  
  Dans chaque case de cette matrice, on va compter le nombre d'instances de l'occurrence en question.
  
  
  
  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).
  
  
  
  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 :
  
  Pour pousser la logique jusqu’au bout, on a un nombre infini de matrice de confusion car on en a autant qu’il y a de nombres décimaux entre 0 et 1.
  
  Donc cette matrice est un indicateur de la qualité du seuil de confiance choisi. Un des enjeux à la fin de l’entrainement de notre modèle est de choisir le meilleur seuil de confiance pour déployer le modèle.
  
  Mais comment savoir si on a une bonne ou une mauvaise matrice de confusion ? On peut la voir simplement de manière binaire : il y a la bonne diagonale (la classe prédite est identique à la vraie classe) et la mauvaise diagonale (la classe prédite est différente de la vraie classe):
  
  Intuitivement, on comprend qu’il faut faire en sorte de baisser les valeurs de la mauvaise diagonale, mais si vous regardez les matrices de la page précédente, vous pouvez observer que ce n’est pas évidement de mettre les deux cases à 0 simultanément.
  
  Alors des fois il faut choisir lequel des deux facteurs est le plus important et “mettre de côté” l’autre. Par exemple, en médecine, on ne veut surtout pas de faux négatifs (ne pas détecter un cancer bien présent) donc on va minimiser au maximum les faux négatifs aux dépens des faux positifs qui sont moins graves (détecter un cancer alors qu’il n’y a rien).
  
  Sachant qu’une matrice est propre à un seuil de confiance, comment savoir quel seuil de confiance est le meilleur ? On va utiliser des mesures pour pouvoir savoir !
- 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 :
  
  
  
  Cette courbe est utilisée pour trouver le seuil de confiance optimal pour déployer votre modèle.
  
  Un des principaux avantages de cette mesure par rapport à la courbe de précision-rappel est sa sensibilité aux valeurs extrêmes. En tant que moyenne harmonique, le score F1 pénalise fortement les valeurs très basses. Un modèle avec une précision parfaite mais un rappel proche de zéro aura un score F1 très faible, ce qui n'est pas toujours flagrant en regardant simplement une courbe.
  
  Cette courbe sert à trouver quel est le seuil de confiance optimal, c’est-à-dire celui qui permet de maximiser la précision et le rappel en même temps. Ce seuil est l’abscisse du maximum de la courbe comme dessiné sur la courbe ci-dessous :
  
  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
  
  Qu’est-ce que le multi-classe ? C’est quand vous avez plus d’une classe à détecter, par exemple vous avez penny, dime et nickel (trois types de pièces différents).
  
  Dans votre matrice de confusion, vous aurez donc autant de ligne et de colonne que de classe, auxquelles on rajoute la ligne et la colonne “negative” (”background”) qui correspond à l’absence de classe.
  
  Voyons à quoi elle ressemble :
  
  Les lignes correspondent aux prédictions et les colonnes à la vérité terrain selon chaque classe.
  
  
  
  On retrouve bien la bonne diagonale qui correspond toujours au fait que la classe de la prédiction est la même classe que la vérité terrain.
  
  En revanche, il n’y a plus de mauvaise diagonale. Les mauvaises prédictions couvrent maintenant le reste des cases de la matrice.
  
  La colonne tout à droite correspond aux objets qui ont été détecté mais faisaient en fait partie du fond. Inversement, la dernière ligne correspond aux choses non détectés qui faisaient en fait partie d’une classe.
  
  
  
  Avec la nouvelle forme de matrice de confusion que nous venons de voir, il va être nécessaire de définir qui sont les vrais positifs, vrais négatifs, faux positifs et faux négatifs. Cela permettra de sortir les calculs de précision, rappel et F1-score pour trouver le meilleur seuil de confiance pour le déploiement de notre modèle.
  
  Pour ramener une matrice multi-classe à une matrice 2x2, on va fonctionner classe par classe. À la fin on devrait avoir autant de matrice de confusion 2x2 que de classe (sans compter "background") à détecter.
  
  Pour les remplir, on va voir ensemble comment déterminer qui correspond à quoi.
  
  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.
  
  Les vrais positifs sont ceux prédit “penny” qui en était bien donc on a qu’une seule case, celle qui est verte à l'intersection de la ligne "penny" et de la colonne "penny".
  
  Ensuite, les cases de la même ligne correspondent aux objets que le modèle a prédit comme “penny” mais qui n’en était pas donc les faux positifs (les cases sur la même ligne que la case verte).
  
  Enfin, les cases de la même colonne correspondent aux objets que le modèle a prédit comme tout sauf “penny” mais qui était bien un “penny” donc les faux négatifs (les cases sur la même colonne que la case verte).
  
  Pour les faux négatifs et les faux positifs, on va sommer les valeurs de toutes les cases concernées.
  
  
  
  Une fois qu’on a nos 3 valeurs (TP, TN, FP), on va pouvoir calculer la précision et le rappel, et en déduire les deux autres courbes précision-rappel et F1-score. Comme vu précédemment, on va refaire ce processus avec tous les seuils de confiance pour pouvoir tracer les courbes de précision et de rappel en fonction de ce seuil.
  
  Puis quand les courbes d’une classe sont tracées, on fait avec la classe d’après et ainsi de suite jusqu’à ce qu’elles soient toutes faites. On se retrouve donc avec autant de courbe que de classe.
  
  Pour avoir une vue d’ensemble, on fait une moyenne de toutes ces courbes, c’est la courbe en gras que l’on voit sur la courbe du F1-score ci-dessous.
  
  Et le “0.40 at 0.146” à côté de “all classes” correspond au pic de la courbe : le maximum est 0.40 et son abscisse est 0.146, donc dans cette expérience, il faudrait choisir un seuil de confiance de 0.146.
  
  
  
  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 six courbes de gauche (les loss) : le modèle apprend et fait moins d’erreurs
  
  Ces 6 courbes correspondent à l’erreur entre les prédictions et la vérité terrain, en haut pour l’entrainement et en bas pour la validation.
  
  Lors d’un entrainement, il y a un phénomène auquel il faut faire attention : le surapprentissage (overfitting). Pour faire simple, cela signifie que le modèle est en train d’apprendre par cœur les données d’entrainement.
  
  Pourquoi cela est un problème ? Car le modèle ne saura pas généraliser, ne saura pas se débrouiller sur des données différentes de sa base d'entraînement.
  
  Comment savoir si notre modèle a surappris ? Cela se voit avec les données de validation car le modèle ne surapprend pas sur celles là pour la simple et bonne raison qu'il ne s'entraine pas avec, il les utilise juste pour s'évaluer.
  
  Donc quand vous regardez les courbes d’erreur, si celles de l’entrainement (celles en haut) continuent de descendre alors que celles de la validation (celles en bas) remontent au bout d’un moment, c’est signe que votre modèle surapprend car les pertes liées à la validation ré-augmentent.
  
  Par exemple ci-dessus, on voit que les courbes de validation ne font que décroitre, donc c’est un signe que notre modèle généralise bien pour l’instant.
  
  Si on constate du surapprentissage, quelles sont les conséquences ?
  
  Comme vu précédemment, YOLO enregistre deux modèles : best.pt et last.pt. Dans last.pt vous retrouverez votre modèle qui a surappris. En revanche, dans best.pt, YOLO stocke les poids qui donnaient le meilleur résultat combiné de l’entrainement et de la validation, donc avant que le surapprentissage entre en jeu.
  
  Donc si on a les poids avant le surapprentissage dans best.pt, quel est le problème du surapprentissage ? On peut le voir comme une consommation de ressource inutile car le modèle va trop loin. Ainsi, pour remédier à cela, on peut utiliser le paramètre “patience” qui permet de dire au modèle “si après x époques le modèle ne s’améliore plus (donc les poids de best.pt ne changent pas), alors arrête de t’entrainer” en passant x (un entier positif) comme paramètre de patience.
  
  les quatre courbes de droite (precision, recall, mAP50, mAP50-95) : le modèle devient plus performant
  
  Elles permettent de voir si notre modèle a atteint son plein potentiel.
  
  Ces courbes permettent de visualiser si le modèle s’améliore, donc un bon indicateur que le modèle est arrivé en fin de course est de regarder si ces courbes ont atteint un plateau. Dans ce cas là, on saura que notre modèle a atteint son état le plus performant et n’a plus de perspective d’amélioration.
  
  Par exemple, dans le cas ci-dessus, on voit qu’après 20 époques, nos courbes sont encore en train de croitre donc on comprend que le modèle aurait besoin de plus d’époque pour se stabiliser.
- Replier Déplier
  train_batchx.jpg - val_batchx.jpg
  
  Le nombre d'images de ce type dépend de la taille de votre dataset.
  
  “train_batchx.jpg” sont des exemples des images que le modèle reçoit pour son entraînement, donc des images labellisées
  
  “val_batchx_labels.jpg” c’est la même chose, donc c’est l’entrée du modèle mais cette fois pour faire de la validation.
  
  “val_batchx_pred.jpg” sont les images aves les labels en sortie du modèle donc des prédictions faites par le modèle. Donc vous pouvez y voir des boites pas forcément au bon endroit, avec ou non le bon label de classe etc, permet d’avoir un retour visuel de ce que fait le modèle.
- 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 :
  
  le 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
  
  les courbes de pertes (loss) :
  
  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)
  
  
  
  la courbe du 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.
  
  les images 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é.
  
  Si votre modèle vous semble satisfaisant, vous pouvez donc le tester sur vos données du dossier "test" pour voir comment il se débrouille. Pour cela, vous devez d’abord charger votre modèle tout juste entrainé. Il se trouve dans le dossier runs/detect/trainx/weights normalement et c’est le fichier best.pt :
  
  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)
  
  
  
  Puis vous pourrez lancer un processus de validation mais en précisant bien que vous voulez que ce soit les données de test qui soient utilisée. N’oubliez pas d’aller rajouter le chemin test dans votre fichier data.yaml au préalable (il faut que ce soit le même fichier data.yaml que lors de l'entrainement pour que le modèle trouve le chemin, sinon, vous pouvez créer un nouveau fichier en changeant le nom, comme data_test.yaml par exemple, mais dans ce cas là, il faudra le préciser dans la fonction ci-dessous comme un autre paramètre, donc data=data_test.yaml).
  
  metrics = model.val(split=”test”)
  
  Vous retrouverez ensuite les résultats dans runs/detect/valx, que vous pourrez analyser comme nous venons de le faire.
  
  Si ces nouveaux résultats vous conviennent aussi, parfait. Sinon, il sera sûrement nécessaire d’entrainer à nouveau votre modèle. Peut être il serait judicieux de changer quelques paramètres d’entrainement, mais rajouter des époques peut suffire.
  
  On va donc partir dans cette direction. Pour reprendre un entraînement afin de le prolonger, commencez par charger les derniers poids et non les meilleurs (très important!) , à savoir last.pt :
  
  from ultralytics import YOLO
  
  model = YOLO(“chemin/vers/votre/fichier/last.pt”)
  
  Lancez ensuite un entraînement comme au début mais avec le paramètre resume=True. Concernant le nombre d’époque, le nombre que vous mettrez là est le nombre total d’époques que le modèle fera, donc si votre last.pt est issu d’un entrainement de 100 époques, la commande ci-dessous permettra d’aller jusqu’à 150, donc d’en rajouter 50 et non d'en rajouter 150.
  
  results = model.train(epochs=150, resume=True)
  
  Enfin, si les résultats ne vous conviennent toujours pas, vous pouvez songer à changer quelques paramètres du modèle, donc pour ça nous avons fait une partie dédiée que vous trouverez juste à la suite, dans la prochaine section.
- 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é
Vous avez fini d'entraîner votre modèle et vous vous demandez maintenant comment vous en servir ou comment l'intégrer à votre code déjà existant.



Si vous êtes dans un environnement Python, vous pouvez garder le modèle tel quel, sinon vous devez l'exporter. L'exportation permet de convertir un modèle YOLO (initialement en PyTorch .pt) dans un format optimisé pour des matériels spécifiques, améliorant ainsi la vitesse d'inférence (jusqu'à cinq fois plus rapide sur GPU avec TensorRT par exemple) et réduisant la consommation de ressources sur les appareils mobiles ou embarqués. Vous pouvez trouver tous les formats dans lesquels YOLO peut exporter sur cette page dédiée au sujet, ainsi que les arguments d'export expliqués juste au dessus.



Si vous restez dans l'environnement Python que vous aviez lors de l'entrainement, pour utiliser votre modèle, il suffit d'utiliser les lignes suivantes :

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

L'objet results contient l'objet boxes. Et cet objet regroupe les informations suivantes pour chaque détection :

coordonnées : accessibles via xyxy (coordonnées coin haut gauche et bas droite), xywh (coordonnées du centre/largeur/hauteur), ou leurs versions normalisées xyxyn et xywhn.

confiance : l'attribut conf donne le score de probabilité (0 à 1) pour chaque boîte.

classes : l'attribut cls contient l'index de la classe prédite (vous pouvez retrouver à quoi correspondent les indices dans le fichier data.yaml utilisé pour l'entrainement)

tracking : Si vous utilisez model.track(), l'attribut id contient les identifiants de suivi.



Voyons un exemple de code :

results = model("image.jpg")

for r in results: # vous aurez autant de résultats qu'il y a d'objets détectés sur l'image

print(r.boxes.xyxy) # récupération des coordonnées des coins

print(r.boxes.xywh) # récupération des coordonnées du centre et de la taille de la boîte

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

print(r.boxes.cls) # index qui correspond à la classe de l'objet en question

Vous pouvez donc récupérer les informations qui vous intéresse de cette manière et les utiliser pour des calculs ou autre dans la suite de votre code.
Sélectionner la section Pour aller plus loin

Replier Déplier
Pour aller plus loin
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
Sélectionner la section Nouvelle section

Replier Déplier
Nouvelle section