Aujourd'hui, l'entraînement d'un modèle de détection d'objets devrait être une tâche facile, mais certains peuvent encore avoir du mal. Dans cet article, nous allons apprendre comment choisir, régler et entraîner n'importe quelle architecture d'apprentissage profond de manière transparente pour contrer ce problème.
Avez-vous parfois l'impression de ne pas pouvoir suivre tous les nouveaux modèles à la mode qui sortent chaque jour des laboratoires ?
J'ai l'impression de voir des complots comme celui-ci tous les jours.
Comme j'ai entraîné Yolov3 il y a quelques années et qu'il était génial, j'ai pensé que ce serait une bonne idée de vérifier ces toutes nouvelles architectures et de créer des modèles encore meilleurs !
J'ai donc commencé à chercher des didacticiels, des dépôts Github ou même des poids pré-entraînés afin de pouvoir commencer à utiliser ces nouvelles architectures sophistiquées sur mes propres données pour voir si je pouvais produire de meilleurs modèles d'IA pour les tâches de mon entreprise.
Mais la vérité est que, même si je trouvais les ressources nécessaires pour former ces architectures, je finissais généralement par avoir l'impression que les résultats n'étaient pas beaucoup plus importants que ceux que j'avais réussi à obtenir il y a quelques années.
Est-ce ma faute ? Ai-je fait une erreur dans mon code ? Peut-être que mon jeu de données n'est pas si bon que ça ? Comment puis-je savoir rapidement s'il est meilleur que d'autres modèles ?
Comment pouvez-vous vraiment être sûr de votre capacité à former et à reproduire les résultats ? Comment s'assurer d'avoir toujours la meilleure architecture au bout des doigts ? Et comment pouvez-vous enfin choisir les meilleurs algorithmes pour vos problèmes d'entreprise ?
C'est ce que nous allons couvrir dans cet article. Nous allons diviser cet article en plusieurs parties :
- Choisir un jeu de données adapté à la détection d'objets
- Sélectionner un ensemble de modèles et créer des scénarios de formation
- Comparer les journaux de formation et les métriques
- Comparez les performances en direct sur certaines images
Entrons dans le vif du sujet !
Pour des raisons de simplicité, nous utiliserons la plateforme Picsellia, car elle offre un large éventail d'outils permettant d'effectuer toutes les tâches susmentionnées de manière transparente. Pour en savoir plus sur les fonctionnalités de Picsellia, cliquez ici.
Choisir un ensemble de données
Comme nous allons former des modèles pour une tâche de détection d'objets, nous devons choisir un ensemble de données pour... vous l'avez compris ! La détection d'objets !
Afin d'obtenir des résultats significatifs, nous allons entraîner nos modèles sur ~6500 images annotées de 144 000 voitures et 106 000 piétons, et cela ressemble à ceci.
Le jeu de données s'appelle VizDrone et peut être trouvé entièrement annoté avec 11 classes différentes sur Picsellia.
Sélectionnez les modèles
Picsellia propose quelques architectures SOTA prêtes à l'emploi, y compris les plus récentes (par exemple EfficientDet-dx).
Pour notre test, nous allons comparer les architectures suivantes (les plus récentes contre les plus anciennes) :
- efficientDet-d0 (base efficientDet)
- efficientDet-d2 (plus lourd efficientDet)
- faster-rcnn-resnet50 (ancien modèle)
- ssd-mobilenet-640 (ancien modèle plus léger)
Tout d'abord, créons un projet où nous pourrons programmer une formation pour chacun de ces modèles.
Ensuite, créez vos expériences
Une fois que notre jeu de données est bien attaché, nous devons créer différentes expériences.
Nous allons créer quelques expériences "factices", ce qui signifie que nous n'essaierons pas d'optimiser les hyperparamètres dans cet article (ne vous inquiétez pas, nous aborderons ce sujet dans un autre paramètre).
Cela dit, je vais conserver les paramètres par défaut proposés par Picsellia et utiliser les mêmes paramètres pour chaque expérience afin de n'avoir à comparer que les architectures.
Créez un scénario de formation.
Nous allons initialiser nos différents tests avec cette interface utilisateur dédiée où nous pouvons sélectionner un modèle de base parmi ceux que nous avons vus précédemment et dont les paramètres optimaux ont déjà été configurés.
Après avoir répété l'opération pour tous les modèles, nous pouvons vérifier que tout est en place.
Tout va bien ! Si nous allons dans n'importe quelle expérience et vérifions les fichiers, nous pouvons voir que nous avons réussi à cloner tous les fichiers nécessaires à l'entraînement à partir des modèles pré-entraînés.
Il ne nous reste plus qu'à lancer la formation et à enregistrer chaque métrique et chaque journal sur la plateforme, ce qui est rendu possible par le SDK Python de Picsellia.
Une façon de le faire est de vérifier l'onglet " launch " dans l'une des expériences et de copier la commande pour lancer l'image Docker pré-packagée prête pour la formation.
(Pour des raisons évidentes, nous avons brouillé notre compte et notre jeton de projet, mais vous pouvez les remplacer par les vôtres).
Maintenant, je vais juste copier et coller cette commande dans notre serveur équipé de GPU NVIDIA et voir la magie opérer !
Faisons cela avec les 4 expériences que nous venons de créer et attendons quelques heures pour la formation de l'ensemble.
Comparez les résultats
Si vos formations sont toutes terminées, vous pouvez maintenant retourner dans Picsellia et, dans votre liste d'expériences, les sélectionner toutes et cliquer sur "Comparer".
Vous devriez maintenant voir un tableau de bord de tous les différents journaux de formation, des mesures d'évaluation, etc.
Que pouvons-nous conclure de nos modèles formés ?
Pour effectuer une première analyse, vraiment simpliste, nous n'examinerons que quelques paramètres d'évaluation :
- la mAP (mean Average Precision)
- l'AR (Rappel moyen)
Et certains des journaux de formation :
- la perte totale
Si vous n'êtes pas familier avec ces mesures et que vous voulez les connaître en détail, je vous encourage à consulter cet article de blog qui explique tout en profondeur.
Ici, nous pouvons voir que nos modèles apprennent quelque chose puisque la courbe de perte diminue lentement. Mais c'est assez bruyant...
Pour résoudre ce problème, comme nous avons beaucoup d'images d'entraînement, nous pourrions essayer d'augmenter la taille du lot pendant l'entraînement, régler le taux d'apprentissage pour qu'il diminue plus rapidement qu'il ne le fait réellement (voir la figure suivante) ou utiliser d'autres techniques plus avancées.
Ce que nous pouvons apprendre de ce graphique est que le modèle efficientDets semble converger plus rapidement que l'autre et que la variance de faster-rcnn ne semble pas diminuer avec le temps.
Ce qu'il faut comprendre, c'est que notre analyse n'est en AUCUN cas exhaustive et que chaque architecture aurait besoin de paramètres différents pour optimiser le processus de formation. Mais cela nous donne une bonne intuition sur la façon dont elles se comportent les unes par rapport aux autres, en très peu de temps.
Si nous trions nos expériences en fonction du score AR@10 (plus il est élevé, mieux c'est), nous pouvons constater que notre modèle Faster-RCNN semble avoir de meilleures performances que les autres architectures. Cela signifie que ce modèle sera celui qui aura le plus de chances de NE PAS faire de fausses prédictions.
Comme je l'ai dit, il ne s'agit pas d'une analyse complète et votre travail de data scientist consiste à explorer les modèles en profondeur afin de pouvoir les comparer une fois que vous aurez trouvé les meilleurs paramètres pour chacun d'eux.
Maintenant que nous avons effectué une petite analyse "quantitative", nous allons essayer notre modèle sur quelques images pour voir comment il se comporte sur des données réelles.
Comparez les performances
Dans Picsellia, vous trouverez ce que l'on appelle un "Playground". C'est un endroit où vous pouvez essayer les modèles en direct, juste après les avoir entraînés et avoir enregistré les poids et les points de contrôle.
Pour le test, nous utiliserons l'image suivante où nous pouvons voir la superposition de la vérité du sol. Cette image a été utilisée pour l'évaluation et ne fait donc pas partie de l'ensemble d'apprentissage.
Nous allons maintenant essayer nos modèles, ajuster le seuil et voir comment ils se comportent.
Voici les étapes que nous observons dans l'animation ci-dessus :
- Essayer le modèle efficientDet-d2 et fixer un seuil raisonnable
- Essayez tous les autres modèles avec le même seuil
- Ajustez le seuil jusqu'à ce que nous puissions voir quelques piétons.
- Essayez tous les modèles avec ce seuil
Comme nous pouvons le voir, c'est Faster-RCNN qui semble avoir les meilleures performances sur notre image, ce qui signifie que notre petite analyse précédente n'était pas si éloignée de la vérité !
Conclusion
Le but de cet article était de vérifier si nous pouvions rapidement identifier, utiliser et comparer certaines architectures de modèles (plus ou moins nouvelles) et effectuer une analyse rapide qui guiderait nos futures expériences exploratoires complètes.
Comme nous avons pu le constater, ce ne sont pas les architectures les plus récentes et les plus sophistiquées qui obtiennent les meilleures performances avec notre première approche, ce qui ne veut pas dire qu'elles ne peuvent pas augmenter leurs performances avec un entraînement réel et exhaustif.
Le tout m'a pris une demi-journée, formation comprise, ce qui est une bonne chose car cela signifie que vous ne devez pas passer des jours ou des semaines (voire des mois) à explorer votre projet et à savoir avec certitude s'il a des chances de réussir ou non.
J'espère que vous avez apprécié cet article. Si vous pensez que Picsellia offre un moyen optimal de mener des expériences et que vous souhaitez nous rejoindre, demandez votre essai gratuit de 14 jours ici! Nous vous contacterons rapidement et vous pourrez commencer à travailler rapidement.
A bientôt ! 👋
