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.