Classification fine par réseau de neurones à convolution
Mémoire
Mathieu Carpentier
Maîtrise en informatique - avec mémoire
Maître ès sciences (M. Sc.)
Classification fine par réseau de neurones à
convolution
Mémoire
Mathieu Carpentier
Sous la direction de:
Philippe Giguère, directeur de recherche Jonathan Gaudreault, codirecteur de recherche
Résumé
L’intelligence artificielle est un domaine de recherche relativement récent. Grâce à lui, plusieurs per-cées ont été faites sur une série de problèmes qui étaient autrefois considérés comme très difficiles. La classification fine est l’un de ces problèmes. Cependant, même si résoudre cette tâche pourrait représenter des avancées tant au niveau scientifique qu’au niveau industriel, peu de recherche y a été effectué.
Dans ce mémoire, nous abordons la problématique de l’application de la classification fine sur des pro-blèmes concrets, soit la classification d’essence d’arbres uniquement grâce à des images de l’écorce et la classification visuelle des moisissures en culture. Nous commençons par présenter plusieurs concepts sur lesquels se basent l’apprentissage profond, à la base de notre solution ainsi que plusieurs expériences qui ont été menées afin de tenter de résoudre le problème de classification d’essence d’arbres à partir d’images de l’écorce. Par la suite, nous détaillons le jeu de données nommé BarkNet 1.0 que nous avons construit dans le cadre de ce projet. Grâce à celui-ci, nous avons été en mesure de développer une méthode permettant d’obtenir une précision de 93,88% en utilisant une seule crop aléatoire dans une image et une précision de 97,81% en utilisant un vote de majorité sur toutes les images d’un arbre. Finalement, nous concluons en démontrant la faisabilité d’appliquer notre mé-thode dans d’autres contextes en montrant quelques applications concrètes sur lesquelles nous l’avons essayée, soit la classification d’essence d’arbres en industrie et la classification de moisissures.
Abstract
Artificial intelligence is a relatively recent research domain. With it, many breakthroughs were made on a number of problems that were considered very hard. Fine-grained classification is one of those problems. However, a relatively small amount of research has been done on this task even though it could represent progress on a scientific, commercial and industrial level.
In this work, we talk about applying fine-grained classification on concrete problems such as tree bark classification and mould classification in culture. We start by presenting fundamental deep learning concepts at the root of our solution. Then, we present multiple experiments made in order to try to solve the tree bark classification problem and we detail the novel dataset BarkNet 1.0 that we made for this project. With it, we were able to develop a method that obtains an accuracy of 93.88% on single crop in a single image, and an accuracy of 97.81% using a majority voting approach on all the images of a tree. We conclude by demonstrating the feasibility of applying our method on new problems by showing two concrete applications on which we tried our approach, industrial tree classification and mould classification.
Table des matières
Résumé ii
Abstract iii
Table des matières iv
Liste des tableaux v
Liste des figures vi
Remerciements vii Introduction 1 1 Théorie et contexte 3 1.1 Apprentissage machine . . . 3 1.2 Apprentissage profond . . . 4 1.3 Classification fine . . . 16 2 Expérimentations préliminaires 21 2.1 Preuve de concept . . . 21 2.2 BarkNet 1.0 . . . 26
2.3 Expérimentations sur BarkNet 1.0 . . . 35
2.4 Entraînement semi-supervisé . . . 40 3 Classification d’essences 43 3.1 Introduction . . . 43 3.2 Expériences . . . 44 3.3 Résultats. . . 45 3.4 Multi-tâches . . . 51
3.5 Autres approches possibles . . . 52
4 Applications 54 4.1 Classification d’essences d’arbres en industrie . . . 54
4.2 Classification de moisissures . . . 58
Conclusion 63
Liste des tableaux
2.1 Jeux de données d’écorces d’arbres existants. . . 22
2.2 Composition du jeu de donnée initial pour la preuve de concept . . . 23
2.3 Matrice de confusion de la preuve de concept . . . 24
2.4 Précision pour chacune des classes de la preuve de concept . . . 24
2.5 Hyper-paramètres pour la preuve de concept . . . 26
2.6 Résultats finaux pour la preuve de concept . . . 26
2.7 Composition du jeu de données BarkNet 1.0 . . . 31
2.8 Résultats selon différentes méthodes de séparation des images . . . 35
2.9 Résultat avec et sans pré-entraînement . . . 36
2.10 Comparaison entre différents modèles. . . 38
2.11 Coefficient de normalisation d’ImageNet. . . 39
2.12 Comparaison entre différents modèles . . . 39
2.13 Résultats avec une perturbation des étiquettes . . . 39
3.1 Précision (%) en classification pour le scénario image individuelle . . . 46
3.2 Précision (%) en classification pour le scénario où toutes les images d’un arbre sont utilisées. . . 49
3.3 Résultats sur les résineux . . . 50
3.4 Précision en utilisant une approche multi-tâches . . . 52
4.1 Composition du jeu de données de FPInnovations . . . 55
4.2 Résultats préliminaires sur le jeu de test . . . 56
4.3 Matrice de confusion des résultats préliminaires . . . 56
4.4 Résultats finaux sur le jeu de test en utilisant uniquement les images avec écorce. . . 57
4.5 Matrice de confusion des résultats finaux. . . 57
4.6 Composition du jeu de données de moisissures . . . 59
Liste des figures
1.1 Représentation de l’opération de la convolution . . . 7
1.2 Champ réceptif pour une couche pleinement connecté . . . 7
1.3 Champ réceptif pour une couche de convolution . . . 8
1.4 Exemple d’images d’écorce que Boudra et collab. (2015) ont classifiées. . . 19
2.1 Courbe d’entraînement de la preuve de concept . . . 25
2.2 Emplacement des sorties pour la création de BarkNet 1.0 . . . 29
2.3 Impact du DBH sur les crops de Acer Saccharicum . . . 30
2.4 Distribution du DBH de Barknet 1.0 . . . 32
2.5 Exemple d’images pour chaque essence . . . 33
2.6 Exemple d’une classification avec l’arrière-plan présent . . . 34
2.7 Courbe d’entraînement selon l’initialisation . . . 37
2.8 Précision avec un entraînement supervisé et semi-supervisé . . . 41
3.1 Différents scénarios utilisés pour le test . . . 46
3.2 Exemple de classification en utilisant plusieurs crops sous forme de grille. . . 47
3.3 Matrice de confusion moyenne pour le vote de classification sur toute l’image . . . . 48
3.4 Résultats obtenus avec un pourcentage réduit d’images ou d’arbres . . . 51
4.1 Images représentatives du jeu de données de FPInnovations . . . 55
Remerciements
En présentant ce mémoire, je tiens à remercier toutes les personnes qui ont aidé, de près ou de loin, au bon déroulement de ces travaux.
Plus particulièrement, je tiens à remercier mon directeur de recherche, le professeur Philippe Giguère, qui, grâce à ses conseils et son encadrement, m’a permis de mener ces recherches à bien.
Je tiens à remercier mon co-directeur de recherche, le professeur Jonathan Gaudreault, pour son sup-port tout au long de la maîtrise.
Mes remerciements s’adressent à Luca Gabriel Serban et Martin Robert pour leur aide lors de la création de BarkNet 1.0.
Je remercie FPInnovations pour les données qu’ils ont fournies et qui m’ont permis d’améliorer la qualité de ce mémoire.
Je remercie la docteure Nathalie Turgeon et Hamza M’Bareche de l’institut universitaire de cardiolo-gie et de pneumolocardiolo-gie de Québec pour leur support et leur aide sur le projet des moisissures.
Introduction
Il existe plusieurs façons de programmer des algorithmes d’intelligence artificielle. Traditionnelle-ment, ces algorithmes étaient écrits à la main et pouvaient résoudre des problèmes très complexes. Par exemple, en 1996, l’ordinateur Deep Blue battait pour la première fois le champion du monde aux échecs. Depuis cet évènement, de multiples avancées ont été faites dans ce domaine, particulièrement dans l’une de ses sous-catégories communément appelée l’apprentissage machine.
L’apprentissage machine, contrairement aux algorithmes traditionnels, vise à laisser l’ordinateur ap-prendreà résoudre un problème, au lieu de lui fournir explicitement une solution. Cette façon de faire permet de résoudre plusieurs types de problèmes qui sont difficiles, voire impossibles, à résoudre en utilisant la programmation classique. Par exemple, comment un ordinateur peut-il reconnaître un chat dans une image ? En effet, il est très complexe de donner une série d’instructions à effectuer pour résoudre ce problème. Il s’agit d’un thème qui revient souvent en informatique, souvent référé sous le nom du paradoxe de Moravec : les problèmes qui semblent simples pour les humains sont souvent les plus difficiles à résoudre pour un ordinateur.
Parmi ces types de problèmes difficiles, la classification visuelle est l’un des plus connus. Dans celui-ci, on possède plusieurs images et plusieurs étiquettes et l’on souhaite savoir quelle étiquette attribuer à chaque image. De nombreuses recherches ont été entreprises afin de résoudre ce problème. Entre autres gr,âce à la compétition ImageNet (Deng et collab. (2009)), dans laquelle il faut classifier des
millions d’images parmi 1000 catégories, qui a permis de stimuler la recherche dans ce domaine. En effet, cette compétition, et la base de données qui l’accompagne, permet facilement de comparer les différentes approches entre elles. De plus, il est aussi possible d’utiliser la base de données pour résoudre d’autres problèmes similaires, comme la classification fine.
Le problème de classification fine est, quant à lui, légèrement plus difficile. En effet, au lieu de cher-cher à classifier parmi des classes relativement différentes, on cher-cherche à classer des images similaires qui appartiennent à une même classe générale. Par exemple, dans la littérature, on cherche parfois à classifier parmi différentes races de chiens, races d’oiseaux ou modèles de voitures.
Un autre exemple de classification fine est la classification d’essences d’arbres. Il est possible de faire cette classification à l’aide de plusieurs attributs comme les feuilles, les fruits, l’apparence générale, etc. Par contre, il serait très intéressant d’être en mesure de faire cette classification en utilisant
uni-quement des images de l’écorce. L’écorce a, en effet, plusieurs avantages comparativement aux autres attributs. Par exemple, elle est facilement accessible et est présente toute l’année, contrairement aux feuilles et aux fruits qui sont souvent hors de portée et qui sont souvent absents pendant l’hiver. De plus, être en mesure d’utiliser uniquement des images pour faire la classification représente un avan-tage économique important, si on la compare avec l’utilisation des scans via laser (LiDAR) ou encore des images hyperspectrales. Malheureusement, il s’agit d’un problème difficile, car l’apparence de l’écorce varie grandement non seulement entre les différentes essences, mais aussi entre les arbres de la même essence. De plus, l’écorce peut facilement comporter des défauts (cicatrices, lichen, etc) qui peuvent venir compliquer la classification.
Un autre exemple d’un problème de classification fine est la classification de moisissures. Présente-ment, une manière populaire de procéder à cette classification est de les observer manuellement via un microscope, et d’utiliser un guide (clé dichotomique) comme support. Cette façon de faire est à la fois laborieuse et hasardeuse, car il est très facile de faire des erreurs. De plus, comme il s’agit d’un problème similaire à la classification d’écorce, il est probablement possible d’utiliser les mêmes techniques pour obtenir des résultats de classification intéressants.
Ce mémoire s’intéresse à résoudre ces deux problèmes, mais en mettant l’accent principalement sur le premier, soit la classification d’essences d’arbre grâce à des images de leur écorce. Pour résoudre ces problèmes, l’apprentissage profond, et en particulier les réseaux de neurones profonds à convolution, ont été mis à partie.
Le mémoire est divisé comme suit. Le chapitre1présente ce qu’est l’apprentissage profond, et fait un bref aperçu de différentes techniques fréquemment utilisées dans le domaine. Le chapitre2introduit le problème de classification des essences d’arbres à partir d’images de l’écorce, présente la création de jeux de données ainsi que plusieurs travaux antérieurs les utilisant pour tenter de trouver une solution à ce problème. Le chapitre3présente notre solution, extraite de l’article qui a été publié à la conférence International Conference on Intelligent Robots and Systems 2018 (IROS 2018) et qui a établi un nouvel état de l’art pour classifier les images d’écorces. Finalement, le chapitre4présente deux autres applications connexes, soit la classification d’essence d’arbres en industrie ainsi que le problème de classification de moisissure.
Chapitre 1
Théorie et contexte
L’apprentissage profond est un domaine de recherche très récent, mais qui connaît une popularité fulgurante. Cette popularité s’explique en partie par ses performances impressionnantes sur plusieurs problèmes longtemps considérés comme très difficiles ainsi que par le très grand nombre de tech-niques et de bonnes pratiques maintenant accessibles qui facilitent grandement son utilisation. De ce fait, il est possible pour un novice d’appliquer celles-ci avec succès, sans trop comprendre les méca-nismes en place. Toutefois, afin d’obtenir des résultats satisfaisants, il est important de comprendre les fondements théoriques sur lesquels l’apprentissage profond se base. Sinon, il est difficile, voire impossible, de faire un choix éclairé parmi les architectures et méthodes d’optimisation disponibles, résultant en une approche par tâtonnement.
Ce chapitre introduit brièvement l’apprentissage profond, ainsi qu’un nombre de techniques qui y sont fréquemment utilisées tout en présentant quelques éléments de mathématique sur lesquels ces tech-niques se basent. Par la suite, une vue d’ensemble du problème de classification fine est décrite. Nous terminerons par un état de l’art sur deux exemples de classification fine : la classification d’essence d’arbres (le sujet principal de ce mémoire) ainsi que la classification de moisissure.
1.1
Apprentissage machine
L’apprentissage machine est un sous-ensemble de l’intelligence artificielle. Il se caractérise par le fait qu’au lieu de programmer explicitement une solution, il laisse l’ordinateur apprendre à résoudre les problèmes par lui-même, en découvrant des caractéristiques dans les données d’entraînement. Cette façon de faire comporte plusieurs avantages. En particulier, elle permet de trouver une solution à plusieurs problèmes de vision qui sont souvent très difficiles à résoudre en utilisant la programmation classique. Malgré tout, l’apprentissage automatique présente aussi des désavantages. Notamment, les réponses fournies par l’ordinateur sont souvent plus difficiles à expliquer, ce qui peut retarder leur déploiement dans l’industrie.
Le modèle est un algorithme qui comporte un certain nombre de paramètres qui seront appris lors de l’entraînement. Plusieurs types de modèle existent. Parmi les plus connus, il y a notamment le Support Vector Machine (SVM), le perceptron ou encore les réseaux de neurones.
Le jeu de données contient les données qui seront utilisées pour l’entraînement. Le plus souvent, ces données sont annotées, mais certains jeux de données ne comportent pas d’annotation et permettent de faire de l’entraînement dit non-supervisé. Le jeu de données est souvent séparé en trois parties, soit i) le jeu d’entraînement, ii) le jeu de validation et iii) le jeu de test. Le jeu d’entraînement est celui qui est pris pour raffiner les paramètres du modèle et ainsi lui permettre de généraliser vers des données inconnues. Le jeu de validation est utilisé pendant l’entraînement pour estimer les performances du modèle et aider à sélectionner les hyper-paramètres. De plus, il peut servir à déterminer à quel moment il est le plus avantageux d’arrêter l’entraînement (early stopping). Finalement, le jeu de test sert à obtenir les résultats et à évaluer les capacités de généralisation du modèle.
Plusieurs types d’entraînement existent. Tout d’abord, il y a l’entraînement supervisé qui consiste à montrer des données annotées au modèle ; celui-ci va tenter de reproduire les annotations sur de nouvelles données. Comme ces données sont aussi annotées, on peut évaluer la réponse du modèle et la comparer aux annotations fournies par un humain. Dans l’entraînement non-supervisé, on ne connaît rien sur les données, mais le modèle va tenter de trouver des similitudes entres elles. L’entraînement semi-supervisé est similaire, mais où seulement une partie des données est annotée. Dans ce type d’entraînement, on peut, par exemple, commencer par entraîner un réseau de façon non-supervisée sur des données non-annotées et ensuite, continuer l’entraînement de façon supervisé sur des données annotées.
Finalement, il existe deux problèmes bien connus liés à l’apprentissage machine, soit le sur-apprentissage et le sous-apprentissage. Ces deux problèmes sont liés intimement à la capacité de généralisation du modèle. Le sous-apprentissage est un peu moins fréquent, mais consiste à obtenir un modèle qui n’est pas suffisamment raffiné pour capturer les particularités des données. Le sur-apprentissage est, quant à lui, le problème contraire où le modèle s’est trop collé sur les données d’entraînement faisant en sorte que lorsqu’il voit une nouvelle donnée en test, il y a une forte probabilité que celle-ci tombe en dehors des données d’entraînement et que le modèle ne soit pas en mesure de bien la traiter. Le problème de sur-apprentissage est très fréquent en apprentissage machine et en particulier avec les réseaux de neurones profonds. C’est pourquoi de nombreuses recherches ont été axées sur le développement de techniques visant à le diminuer pendant l’entraînement. Au final, ces deux problèmes entraînent des performances médiocres et sont donc à éviter.
1.2
Apprentissage profond
Tout comme l’apprentissage machine est un sous-ensemble de l’intelligence artificielle, l’apprentis-sage profond est un sous-ensemble de l’apprentisl’apprentis-sage machine. Dans celui-ci, on utilise exclusivement des réseaux de neurones comportant un certain nombre de couches. Le nom vient du fait qu’on dit que
plus un réseau a un nombre élevé de couches, plus il est profond.
Dans cette section, il est important de noter que seuls les aspects qui ont été pertinents lors de la réalisation des projets décrits aux chapitres subséquents sont détaillés. Pour plus de détails et pour avoir un aperçu plus complet des techniques existantes, il est recommandé d’aller consulter le livre Deep learning(Goodfellow et collab.(2016)).
1.2.1 Architecture
La première étape lors de l’élaboration d’un algorithme d’apprentissage profond est le choix de l’ar-chitecture à utiliser. Cette section présente tout d’abord les éléments de base de ces réseaux, puis détaille les architectures les plus communément utilisées.
Neurone
L’unité de base d’un réseau de neurones (profond ou non) est le neurone ou le perceptron. On peut définir un neurone possédant N entrées de la façon suivante :
y= F N
∑
i=0 wi· xi+ b .Dans l’équation précédente, y représente la sortie du neurone, wiest le poids d’une des entrées, xiest
l’entrée correspondante, F est une fonction généralement non-linéaire et b est un biais.
Cette unité de base est ensuite regroupée pour former différentes couches qui vont ensuite être em-pilées pour former l’architecture globale du réseau. À la base, un réseau de neurones comprend les éléments suivants : une couche d’entrée, une ou plusieurs couches intermédiaires et une couche de sortie. Il n’y a pas de restriction sur le type de couche, le choix étant guidé par la tâche à résoudre. Une des premières couches à avoir existé est la couche pleinement connectée. La couche pleinement connectée est une couche composée d’un ensemble de neurones où chaque neurone prend en entrée toutes les sorties des neurones de la couche précédente. D’autres types de couche existent, dont la couche de convolution détaillée plus bas.
Fonction d’activation
La fonction F introduite dans la section précédente est une fonction qui s’applique avant la sortie du neurone. Cette fonction doit presque toujours être non linéaire, car sinon l’ensemble d’un réseau com-portant plus d’une couche pourrait être simplifié en une seule fonction linéaire. Traditionnellement, c’était la fonction sigmoïde : σ (x) = exe+1x qui était utilisée, car sa dérivée est relativement simple et
est égale à δ σ (x)δ x = σ (x) · (1 − σ (x)). De plus, comme la dérivée est calculée à partir de la valeur de la fonction, il est possible de réutiliser la valeur utilisée lors de la passe avant pour la passe arrière (voir section1.2.3)
Cependant, la fonction sigmoïde est à l’origine de plusieurs problèmes lorsque le réseau devient trop profond. Principalement, lorsque la sortie de F(·) est trop grand ou trop petit, son gradient devient très faible, ce qui empêche sa propagation dans les couches inférieures du réseau et rend l’entraînement très difficile. Ce problème est appelé vanishing gradient.
Pour le résoudre, de nouvelles fonctions d’activation ont été développées. L’une d’entre-elles, la ReLu (Nair et Hinton(2010)), est défini comme suit :
F(x) = 0 si x < 0 x sinon
Cette fonction d’activation est maintenant l’une des plus populaires, car elle est à la fois simple à calculer, donne d’excellents résultats, et permet de contrecarrer en partie le problème du vanishing gradient. Basées sur celle-ci, d’autres fonctions ont d’ailleurs été proposées par la suite comme la Leaky ReLu(Maas et collab.(2013)) où, au lieu d’avoir 0 pour la partie négative de la fonction, une légère pente est utilisée. Un autre exemple de fonction d’activation est la PReLu (He et collab.(2015)) qui possède, quant à elle, une pente paramétrable pour la partie négative qui est apprise par le réseau. Réseau de neurones à convolution
Le réseau de neurones à convolution (CNN) Krizhevsky et collab.(2012) est un type de réseau qui utilise à la base des couches de convolution. Ce type de réseau, apparu en 1989 (LeCun et collab.
(1989)), est très utile pour faire du traitement sur les images. Il est fortement inspiré du constat que le filtrage de signaux par des convolutions s’est imposé dans le domaine du traitement des images numériques. Ce type de réseau a aussi l’avantage de posséder un nombre très limité de paramètres à entraîner comparativement à une couche pleinement connectée, ce qui réduit considérablement la probabilité d’avoir du sur-entraînement.
L’opération de la convolution consiste à prendre un filtre d’une taille donnée et de le faire glisser sur une image en calculant à chaque position la somme du produit scalaire entre la valeur (vecteur) des entrées et les poids associés (vecteur) du filtre. La figure1.1montre visuellement cette opération ainsi que la sortie du filtre pour six positions, obtenues en déplaçant le filtre de 1 pixel à la fois.
Le fait d’appliquer les mêmes poids partout sur l’image permet d’inculquer au réseau un prior que des caractéristiques visuelles similaires peuvent être présentes à plusieurs endroits dans l’image. Ceci est un avantage pour la convolution, car beaucoup moins de paramètres sont nécessaires, réduisant à la fois la quantité de mémoire et diminuant la quantité d’opérations à effectuer. De plus, cette opéra-tion a un champ réceptif plus petit comparativement à celui d’une couche pleinement connectée. Les figures1.2et1.3 illustrent ce phénomène pour les deux couches. Dans les deux figures, les données en entrée xiqui ont une influence sur la sortie s3sont mises en évidence. Ce sont ces entrées qui sont
appelées le champ réceptif de s3. Il est aussi important de noter que plus une couche est profonde dans
le réseau, plus son champ réceptif sur les données en entrée est important. On peut supposer que c’est une des raisons qui explique pourquoi le réseau apprend à extraire des caractéristiques hiérarchiques.
FIGURE1.1 – Représentation de l’opération de la convolution. Tiré deGoodfellow et collab.(2016)
FIGURE 1.2 – Champ réceptif pour une couche pleinement connecté. Tiré deGoodfellow et collab.
FIGURE1.3 – Champ réceptif pour une couche de convolution. Tiré deGoodfellow et collab.(2016)
Typiquement, une couche de convolution fonctionne sur des volumes (tenseurs) de données. Dans le cas des images, il y a spatialement la largeur et la longueur, et la troisième dimension est représenté par les canaux de couleur (red, green, blue) (RGB) (pour la première couche) ou de caractéristiques (pour les couches subséquentes).
Une couche générique de convolution prend 4 hyper-paramètres. Le premier est le nombre de filtres présents dans la couche. Plus il y a de filtres, plus la couche est en mesure d’extraire des caractéris-tiques différentes de la couche précédente. Ce paramètre va aussi définir la profondeur du volume de sortie. Le deuxième est la taille spatiale du filtre (3x3, 5x5, etc.). C’est-à-dire la grosseur de la fenêtre (champs d’activation) sur laquelle le filtre extrait les informations. Le troisième est le pas. Celui-ci représente le déplacement effectué lorsque le filtre glisse sur l’image lors de la convolution. Finale-ment, il y a la quantité de remplissage avec des zéros autour de l’image qui permet de gérer les effets de bord induits par l’opération de convolution. Ce paramètre affecte aussi en partie la taille du volume sortant qui est obtenue avec les équations suivantes :
W2= W1− F + 2P S+ 1 H2=H1 − F + 2P S+ 1 D2= K
F représentant la taille du filtre, P, le remplissage par des zéros, S, le pas et K, le nombre de filtres dans la couche.
Grâce aux propriétés des CNNs et en particulier grâce à leur capacité à extraire les caractéristiques qui se répètent dans l’image, on peut supposer que ceux-ci sont un bon choix pour procéder à la classification de texture. Cela justifie en partie pourquoi nous avons décidé de les appliquer pour tenter de résoudre le problème de classification d’essence d’arbre.
Pooling
Les techniques de pooling sont des techniques permettant de regrouper des informations présentes dans des régions voisines de l’image, et ainsi réduire la taille spatiale du modèle. Ces techniques per-mettent de réduire le nombre de paramètres et, par le fait même, aide à contrôler le sur-apprentissage. L’une des plus fréquemment utilisée est intitulée le max pooling (Zhou et collab.(1988)). Cette tech-nique consiste à conserver utech-niquement la valeur la plus élevée à l’intérieur d’une fenêtre spatiale. Cette fenêtre est normalement déplacée sur des zones de l’image qui ne s’entrecroisent pas, mais ce n’est pas obligatoire.
Une autre technique, un peu moins populaire que le max pooling, est l’average pooling. L’idée est très similaire, avec comme seule différence qu’au lieu de conserver uniquement la valeur maximale, une moyenne des valeurs des pixels est conservée. Cette technique fonctionne bien aussi, mais donne généralement des résultats inférieurs au max pooling.
Un des avantages à faire du pooling est que cela permet de rendre la représentation interne invariante à de petites translations des entrées. De plus, il peut être utile pour gérer des entrées de taille variable. En effet, dans un réseau typique, la taille de la sortie est prédéterminée. Cependant, en utilisant certaines opérations de pooling comme le Global average pooling (Lin et collab.(2013)) ou en modifiant l’offset entre les zones de pooling selon la taille de l’entrée, il est possible de rendre le réseau indépendant à celle-ci. Finalement, cette réduction spatiale causée par les opérations de pooling réduit le nombre d’opérations nécessaires dans les couches subséquentes et, conséquemment, accélère l’entraînement. AlexNet
Le premier réseau de neurones à convolution qui s’est démarqué en remportant la compétition Ima-geNet en 2012 est l’architecture AlexNetKrizhevsky et collab.(2012). Cette architecture comprend 8 couches. Les 5 premières étant des couches de convolution et les 3 dernières étant des couches pleinement connectés.
La première couche de convolution comprend 96 filtres de tailles 11x11 et utilise un pas de 4 pixels. La seconde couche qui prend en entrée la sortie de la première, utilise 256 filtres de tailles 5x5. Les couches trois et quatre, quant à elles, utilise 384 filtres de tailles 3x3. La dernière couche de convolu-tion utilise 256 filtres de tailles 3x3. Finalement, les 2 couches pleinement connectées suivantes ont chacune 4096 neurones et la dernière 1000. Le nombre de neurones de la couche finale n’est pas très important et est souvent modifié pour s’adapter au problème.
Cette architecture a révolutionné le monde de la vision en montrant la puissance des réseaux de neu-rones. Depuis, énormément de recherche se poursuit dans ce domaine, sans pour autant connaître toutes les possibilités que cette technologie peut apporter.
Resnet
Plus récemment, de nouvelles architectures plus performantes qu’AlexNet ont vu le jour. C’est, entres autres, le cas de l’architecture Resnet He et collab. (2016a) qui est devenue très populaire grâce à ses performances impressionnantes et à la facilité avec laquelle il est possible d’entraîner ce type de réseau. Cette architecture a d’ailleurs remporté la compétition ImageNet en 2015 avec une bonne avance sur ses compétiteurs. L’écart de performance (diminution de moitié du taux d’erreur top-5) témoigne d’une réelle percée architecturale, comparativement à d’autres réseaux.
Une des observations qui a été faite avec les réseaux du style d’AlexNet était que plus ils comportent de couches, c’est-à-dire, plus le réseau est profond, plus les performances s’améliorent. Cependant, il fut constaté qu’au-delà d’une certaine profondeur, les performances se dégradentHe et collab.(2016a). L’explication la plus courante est que lorsque le réseau devient trop profond, le gradient éprouve des difficultés à se propager jusqu’aux couches les plus inférieures, ce qui nuit globalement à l’entraîne-ment et donc aux performances.
Pour résoudre ce problème, les auteurs de Resnet ont inventé ce qu’ils ont appelé des connexions par saut. C’est-à-dire, que les différents niveaux du réseau sont reliés entre eux par des connexions identitaires.
Plus formellement, la connexion par saut est généralement décrite de la façon suivante. Soit une fonc-tion F(x) qui représente la sortie d’une ou plusieurs couches successives du réseau. La connexion par saut est une simple recopie des valeurs d’entrée x, additionnées à la sortie de cette même couche :
F(x) = F(x) + x.
Les auteurs ont d’ailleurs émis l’hypothèse qu’il est plus facile d’optimiser ce type de connexion, en considérant la sortie F(x) comme un résidu. L’idée étant que si la connexion identitaire était optimale, il serait plus simple pour un algorithme d’apprentissage de mettre ce résidu à zéro, que d’apprendre cette relation par une succession de couches non-linéaires comme dans le cas d’un réseau normal. Finalement, certains auteurs (Veit et collab.) ont aussi suggéré que ce type de réseau fonctionne comme un ensemble de sous-réseaux plus petits. Chacun de ces sous-réseaux pouvant être vue comme un petit chemin différent, parfois transitant par un résiduel, parfois dans la connexion par saut.
1.2.2 Initialisation
Avant de commencer l’entraînement, il est nécessaire d’initialiser les poids du réseau. Pour ce faire, différentes techniques existent. Par défaut, les poids sont souvent initialisés en utilisant une distribu-tion uniforme ou normale, mais des méthodes plus sophistiquées existent, telles les méthodes d’initia-lisation de Xavier ou de Kaiming. Par contre, il est souvent préférable d’utiliser les poids d’un réseau pré-entraîné pour initialiser le réseau. Ces différentes approches sont discutées plus bas.
Kaiming
La fonction d’initialisation de Kaiming (He et collab. (2016b)) est une fonction qui a été proposée spécifiquement pour les réseaux de neurones utilisant une fonction d’activation comme la ReLu. Elle a aussi été proposée en remplacement de l’initialisation Xavier (Glorot et Bengio(2010)) pour ce type de réseau, car les auteurs de celle-ci avaient assumé que l’activation était linéaire, ce qui n’est pas le cas pour la ReLu. Les auteurs affirment aussi que leur méthode améliore la convergence des réseaux très profonds.
L’idée principale de leurs travaux était d’investiguer la variance de chaque réponse produite par une couche. Ce faisant, ils ont conclu qu’une bonne façon d’initialiser une couche est d’utiliser une distri-bution gaussienne ayant une moyenne nulle et une déviation standard deqn2
l avec nl représentant le
nombre de connexions d’une réponse. Dans le cas d’une couche de convolution, ce nombre est n = k2c avec k représentant la taille du filtre et c le nombre de canaux. Dans l’article, les biais sont initialisés à zéro. Cependant, il est tout de même possible d’utiliser une initialisation différente pour ceux-ci. Pré-entraînement
Pré-entraîner un réseau est une méthode qui vise à faire un transfert de connaissances entre deux problèmes différents. La méthode consiste à prendre un réseau qui a été entraîné sur un jeu de données différent de celui du problème que l’on souhaite résoudre. Les poids sont alors réutilisés comme initialisation pour entraîner un deuxième réseau sur le jeu de données cible. Idéalement, le premier réseau va avoir appris sur un jeu de données beaucoup plus important que celui de la tâche cible, ce qui lui permet de développer des extracteurs de caractéristiques qui généralisent bien.
Dans un réseau de neurones à convolution, les premières couches extraient des attributs de bas niveau, comme des arêtes ou des couleurs. Plus les couches sont profondes, plus elles extraient des attri-buts abstraits. Les dernières extrayant généralement des attriattri-buts spécifiques au problème. Comme les premières couches extraient essentiellement des caractéristiques très générales, celles-ci peuvent être réutilisées sur des nouveaux problèmes. Cela permet d’accélérer énormément l’entraînement et d’améliorer les résultats. C’est pourquoi, il est souvent beaucoup plus simple d’utiliser cette tech-nique que d’essayer les autres méthodes d’initialisation étant donné que des modèles pré-entraînés sont facilement accessibles sur Internet.
Il est aussi possible de geler certaines couches du réseau. C’est-à-dire de ne pas modifier les valeurs des paramètres pour certaines couches du réseau. En général, ce sont les premières couches qui sont gelées, car elles ont déjà appris à extraire de bonnes caractéristiques. Cela permet de sauver du temps de calcul, car il n’est plus nécessaire de calculer le gradient pour ces couches et peut aider à réduire le sur-apprentissage. En règle générale, plus le problème qu’on cherche à résoudre est similaire à celui sur lequel le réseau a été pré-entraîné, plus on peut geler un nombre élevé de couches.
1.2.3 Optimisation
Après avoir déterminé l’architecture à utiliser, vient l’étape de l’entraînement. L’entraînement du ré-seau est divisé en deux parties, la passe avant et la passe arrière. Dans la passe avant, le réré-seau calcule une valeur de sortie pour les données d’entrées. Cette valeur dépend des paramètres courant du réseau. Par la suite, lors de la passe arrière, les paramètres du réseau sont modifiés légèrement afin d’optimi-ser la valeur de la sortie. Cette section décrit les différentes parties impliquées dans cette optimisation ainsi que les algorithmes couramment appliqués pour la réaliser.
Fonction de perte
Pour entraîner un réseau de neurones, il est important d’avoir une bonne fonction de perte. Cette fonction est celle que le réseau tente de minimiser lors de l’entraînement, en utilisant la méthode de la descente du gradient. Le choix de cette fonction dépend du problème à résoudre et est par conséquent crucial, car il a un effet direct sur les performances finales souhaitées du réseau.
Pour ce faire, plusieurs types de fonction existent. Pour le problème de la classification, la fonction de perte d’entropie croisée est souvent utilisée. Cette fonction s’applique sur le résultat de la fonction Softmaxappliquée sur la sortie du réseau. La fonction Softmax peut s’exprimer de la manière suivante, avec xireprésentant le résultat d’un des neurones de sortie du réseau possédant N sorties :
S= e
xi
∑Nexn
.
La fonction Softmax est souvent considérée comme étant une estimation de la probabilité de chacune des classes. Pour des problèmes de classification comme les nôtres, c’est donc la fonction de pré-dilection. La fonction de perte d’entropie croisée s’applique ensuite de la façon suivante, avec p(x) représentant la vraie distribution :
L= −
∑
x
p(x) − log S(x).
En d’autres mots, p(x) représente l’étiquette connue pour la classe et la fonction d’entropie croisée s’assure que la probabilité de la vraie classe soit la plus élevée possible et que celle des autres classes approche de zéro.
Descente du gradient
Les réseaux de neurones sont optimisés grâce à la méthode de la descente du gradient. Cette méthode s’applique en calculant le gradient pour chacun des paramètres du réseau. Le gradient pour un para-mètre nous indique à quel point ce dernier a contribué à faire augmenter la fonction de perte. Comme on cherche à diminuer cette dernière, il suffit ensuite de modifier légèrement ce même paramètre, dans la direction opposée au gradient.
Il est possible de calculer le gradient pour chaque paramètre du réseau grâce à la dérivée partielle de chaque paramètre. Par exemple, supposons un réseau très simple possédant un seul neurone et deux
paramètres : w1et w2. Supposons aussi que le neurone utilise une fonction d’activation F(y) = y2 et
que la fonction de perte est la suivante : L(z) = 2z. En incluant tous les paramètres dans la fonction de perte, on obtient la fonction suivante :
L= 2(w1x1+ w2x2)2.
Il suffit ensuite de dériver cette fonction selon chacun des paramètres pour obtenir le gradient associé. Par exemple, pour w1, on obtientδ w1δ L = 4x1(w1x1+ w2x2). Toutefois, en pratique, il est beaucoup plus
facile d’utiliser la règle de la dérivation en chaîne. De plus, cette dernière permet de programmer des modules indépendants qui connaissent leur propre dérivé, ce qui permet d’améliorer grandement la réutilisation du code. C’est d’ailleurs pourquoi la plupart des librairies modernes comme PyTorch ou Tensorflow utilisent cette méthode.
Finalement, pour mettre à jour les poids du réseau, il suffit de modifier légèrement les paramètres dans la direction opposée au gradient selon un hyper-paramètre lr appelé taux d’apprentissage, générale-ment très petit. Par exemple, ce paramètre est souvent de 0.01 au début de l’entraînegénérale-ment. L’équation pour modifier le paramètre w1devient alors :
w1= w1− lr
δ L δ w1
Descente de gradient stochastique
Selon la définition de la méthode de la descente du gradient, celle-ci s’applique une fois que le réseau a vu l’ensemble des données et que le réseau a calculé la valeur de la fonction de perte totale. Cependant, cette façon de faire néglige l’information gagnée sur les premiers exemples d’entraînement et est très coûteuse en temps de calcul.
En pratique, l’entraînement se fait uniquement sur un petit sous-ensemble des données choisi aléa-toirement. C’est-à-dire que la passe arrière se fait uniquement après qu’un petit sous-ensemble des données ait été montré au réseau. Plus ce nombre de données est important, plus l’entraînement est stable, car le gradient calculé représente plus fidèlement la vraie distribution du jeu de données d’en-traînement. Plus ce nombre de données est petit, plus l’entraînement est soumis à des aléas, mais cela peut permettre d’éviter au réseau de rester pris dans un minimum local.
Avec la descente du gradient stochastique, on entraîne donc sur des lots de données. À chaque fois qu’un lot est présenté au réseau et que les valeurs des paramètres sont mises à jour, on dit qu’on vient de faire une itération. Une fois que toutes les données ont été présentées au réseau au moins une fois, on dit qu’on vient de compléter un cycle ou un epoch.
Adam
Une des premières améliorations qui a été apportée à la descente du gradient fut l’ajout du momentum. En gros, le momentum permet de continuer dans la même direction qu’à l’itération précédente, ce
qui permet d’accélérer l’optimisation. En particulier, cette méthode est très efficace lorsque que la direction du gradient reste relativement constante. En effet, plus l’optimisation reste longtemps dans la même direction, plus le pas effectué pour modifier les paramètres sera important. Depuis, plusieurs autres méthodes d’optimisation ont vu le jour. Parmi celles-ci, Adam (Kingma et Ba(2014)) est l’une des plus couramment utilisées.
Adam est défini de la façon suivante. Tout d’abord, l’algorithme utilise le momentum de premier et deuxième degré. Ces deux momentums sont définis ainsi :
m1= β1· m1 + (1 − β1) · dx,
m2 = β2· m2 + (1 − β2) · dx · dx.
β1 et β2 sont des hyper-paramètres généralement initialisés à 0.9 et 0.999 respectivement. dx
repré-sente le vecteur des gradients calculés lors de la propagation arrière. Comme m1et m2sont initialisés
à zéro au départ, deux termes sont ajoutés pour corriger le biais. Ces termes sont les suivants : cb1= m1 1 − β1t, cb2= m2 1 − βt 2 ,
avec t représentant l’itération courante de l’algorithme. Finalement, l’équation utilisée par Adam pour mettre à jour les poids du réseau est la suivante :
x= x − lr ∗√ cb1 cb2+ 10−7
.
Adam est très populaire, car il permet un entraînement rapide qui produit de bons résultats. De plus, il est relativement simple à implémenter. C’est pourquoi, il est souvent utilisé comme méthode d’opti-misation par défaut. Le seul désavantage à utiliser Adam est que cette méthode nécessite un peu plus de mémoire que les autres, quoiqu’en pratique, cette quantité est souvent négligeable et ne nuit pas à l’entraînement.
1.2.4 Régularisation
Tel que mentionné précédemment, une des principales difficultés liées à l’utilisation des réseaux de neurones est que ceux-ci ont tendance à faire du sur-apprentissage très facilement. Pour contrer ce problème, différentes méthodes ont été développées au cours des années. Cette section présente en quelques-unes qui sont souvent employées dans le domaine.
Régularisation L2
La première technique fréquemment utilisée est la régularisation L2. Cette méthode consiste à forcer le réseau à avoir des poids de petites tailles. Elle se base sur l’idée que si un réseau idéal existe pour solutionner le problème, il est possible de modifier tous les poids de ce réseau par la même constante
sans changer le résultat final. Parmi cette infinité de réseaux possibles, on va préférer choisir le réseau ayant les poids les plus proche de zéro, car il s’agit du plus simple.
Pour appliquer cette régularisation, il suffit d’ajouter un terme à la fonction de perte : Lr= L(x) +
1 2λ w
2.
où Lrest la fonction de perte avec la régularisation L2, L est la fonction de perte initiale, w représente
les poids du réseau et λ est un hyper-paramètre permettant de contrôler la force de la régularisation. Le facteur 12 n’est pas nécessaire, mais est souvent ajouté pour que le gradient de ce paramètre soit tout simplement λ w.
Cette régularisation, en limitant la taille des poids, diminue par le fait même la capacité d’expression du réseau. Indirectement, ceci réduit aussi les possibilités pour le réseau d’apprendre par coeur les données d’entraînement.
Normalisation de lot
Une technique très fréquemment utilisée en apprentissage profond est la normalisation de lot, dite batch norm(Ioffe et Szegedy(2015)). En pratique, lors de l’entraînement du réseau, plusieurs don-nées sont présentées simultanément et la mise à jour des poids se fait une seule fois pour l’ensemble des données présentées. Comme mentionné dans la section 1.2.3, plus la taille du lot est petit et plus l’entraînement sera aléatoire et à l’inverse, plus la taille est grande, plus l’entraînement sera stable. Avoir un entraînement comportant certains éléments de hasard n’est pas nécessairement mauvais, car cela permet aussi de sortir plus facilement des minimums locaux. D’un autre côté, avoir un entraîne-ment stable permet souvent d’accélérer celui-ci.
Comme son nom l’indique, cette technique vise à normaliser chaque exemple du lot selon les statis-tiques de ce dernier. C’est-à-dire, enlever la moyenne et diviser par l’écart-type. Plus formellement :
xi=
xi− E[X]
p
Var[X ] + ε.
Cette normalisation comporte plusieurs avantages. Notamment, elle accélère l’entraînement, et permet d’utiliser un taux d’apprentissage (lr) plus élevé. En pratique, elle tend aussi à entraîner des réseaux plus performants, au niveau de la tâche à accomplir. De plus, la normalisation de lot est relativement simple à programmer.
Dropout
Le dropout est une technique employée dans les réseaux de neurones pour augmenter leur capacité de généralisation. Il permet d’empêcher les neurones de devenir co-dépendants les uns des autres, ce qui rend le réseau plus robuste. Lorsque le dropout est utilisé pendant l’entraînement, certains neurones du réseau sont désactivés au hasard. C’est-à-dire que certains neurones du réseau vont aléatoirement
produire une valeur nulle en sortie, peu importe les données en entrée. Le choix des neurones affectés suit généralement une loi uniforme.
En général, le dropout est plus efficace sur les couches pleinement connectées qui sont plus suscep-tible au sur-entraînement. Toutefois, il peut aussi être appliqué sur d’autres types de couches, comme les couches de convolution. Récemment, le dropout semble perdre en popularité, et est souvent rem-placé par d’autres techniques comme la normalisation par lot. Entre autres, parce que les architectures modernes évitent d’utiliser les couches pleinement connectées, trop gourmandes en calcul et sans pour autant améliorer les résultats.
1.3
Classification fine
Le problème générique de classification consiste à prendre une donnée et à lui attribuer une étiquette parmi un ensemble donné connu. On note généralement l’ensemble des données par X et l’ensemble des étiquettes par Y . Ainsi, le problème consiste à attribuer une étiquette yj à une donnée xi. Dans le
cas de l’entraînement supervisé, on connaît l’étiquette véritable pour chaque donnée.
Le problème de classification fine est essentiellement le même. Sa particularité vient du fait que les classes à distinguer sont très similaires entres elles, car elles appartiennent à une même catégorie plus générale. Cela signifie que souvent, les différences à l’intérieur d’une même classe sont plus importantes que les différences entre les classes. Par exemple, c’est le cas du problème de classification de différentes races de chats, où la forme générale de l’animal est très similaire et où seulement des caractéristiques précises les diffèrent.
1.3.1 Jeu de données
Dans la littérature, plusieurs jeux de données existent permettant de faire ce type de classification fine. Premièrement, il est possible d’utiliser un sous-ensemble d’ImageNet, même si celui-ci est générale-ment utilisé pour faire de la classification standard. En effet, à cause de la grande quantité d’images et le fait que chaque image est classé dans un arbre hiérarchique, il est possible de sélectionner une ou plusieurs branches de cet arbre pour faire de la classification fine. Par exemple, ImageNet contient environ 90 races de chiens différentes.
Par ailleurs, d’autres jeux de données spécialisés pour faire de la classification fine existent. Parmi les plus connus, il y a les jeux de données CUB 200 et Stanford Dogs. CUB-200 2010 (Welinder et collab.
(2010)) et 2011 (Wah et collab.(2011)) contiennent chacun deux cents espèces d’oiseaux. CUB-200 2010 est annoté avec une boîte de contour permettant d’indiquer la position de l’oiseau dans l’image. CUB-200 2011 a été amélioré en ajoutant la position de certains attributs de l’oiseau comme le bec, les ailes, etc. Stanford Dogs (Khosla et collab. (2011), quant à lui, est un jeu de données contenant environ 20 000 images de 120 espèces de chiens. Les images sont aussi annotées avec une boîte de contour qui indique la position du chien dans l’image. Autrement, peu d’autres jeux de données pour
classification fine existent. En ce sens, notre propre jeu de données sur les écorces d’arbres, introduit à la section2.2.1, constitue une contribution à cette communauté d’apprentissage automatique.
1.3.2 État de l’art
La majorité des approches de classification fine se base sur l’utilisation des attributs ou parties de l’objet à reconnaître (Zhang et collab. (2016); Gebru et collab. (2017); Lin et collab. (2015)). Par exemple, dans le cas de la reconnaissance des oiseaux, il peut s’agir du bec, des ailes, des pattes, etc. Notamment, les auteurs deZhang et collab.(2014) ont proposé une nouvelle architecture de réseaux en plusieurs parties permettant de classifier les espèces d’oiseaux dans CUB. La première partie du réseau sert à localiser les différentes parties de l’animal. La deuxième, à extraire des caractéristiques de chacune de ces parties et la troisième, à extraire des caractéristiques plus globales de l’oiseau en utilisant la boîte de contour englobant l’oiseau au complet. À la fin, toutes ces informations sont concaténées avant de passer par trois couches pleinement connectées pour faire la classification finale.
Krause et collab.(2015), quant à eux, ont utilisé les annotations des parties pour l’entraînement et ont tenté de les localiser automatiquement dans les images de test. Pour ce faire, ils ont développé une technique permettant de les aligner en utilisant une segmentation de l’oiseau dans l’image. En test, ils utilisent une approche similaire à celle des k-plus proches voisins pour retrouver la segmentation la plus similaire parmi toutes celles produites en entraînement. Cela leur permet ensuite de supposer que les parties de l’oiseau dans l’image de test sont sensiblement aux mêmes endroits que dans l’image d’entraînement.
Dans notre recherche, nous n’avons pas pu reprendre ces techniques pour détecter les parties dans l’image. En effet, dans notre cas, le problème de classification d’écorce était plus proche de la classi-fication de texture relativement uniforme dans lequel il n’y a pas de parties évidentes à annoter. Par contre, pour la classification des moisissures, même si nous n’avons pas pu le faire, il pourrait être intéressant d’indiquer la position des spores et des racines dans l’image afin de pouvoir tester ces techniques.
1.3.3 Classification de moisissures
Très peu de recherche a été effectuée pour tenter d’appliquer l’apprentissage profond à la reconnais-sance visuelle des moisissures. À notre connaisreconnais-sance, la seule recherche existante est celle de Sun et collab.(2016). Dans leur étude, ils ont comparé plusieurs techniques d’apprentissage automatique pour classifier des moisissures présentes sur les grains de riz. Notamment, ils ont comparé les SVMs, les réseaux de neurones standards et les réseaux de neurones à convolution. Pour les réseaux à convo-lution, ils ont développé leur propre architecture en utilisant 2 couches avec des filtres de taille 3x3. La première couche comprend 6 filtres et la deuxième, 12. Avec cette architecture et sans pré-entraîner leur modèle, ils ont obtenu un taux de classification d’environ 90% ce qui est similaire au résultat qu’ils ont obtenu avec le SVM.
1.3.4 Classification d’essence d’arbres
La classification d’essences d’arbres se fait typiquement avec des attributs qui sont, pour les humains, plus facile à identifier, soit la feuille, le fruit, etc. Naturellement, des travaux de recherche ont donc aussi tenté de classer les arbres selon ces mêmes attributs. Par exemple, Kumar et collab. (2012) a développé une application mobile permettant d’utiliser les feuilles pour faire la classification. Pour ce faire, leur approche commence par détecter si une feuille est présente dans l’image avec un SVM. Si une feuille est bien présente, elle est segmenté du fond l’image qui doit être une feuille de papier blanc, en utilisant la méthode Expectation-Maximization (EM). À partir de la feuille segmentée, la méthode calcule ensuite un histogramme de la courbure de la feuille et utilise la méthode des k plus proches voisins sur cet histogramme pour le classement final. Avec cette méthode, ils obtiennent 96,8% de précision sur le top 5 des résultats proposées à l’utilisateur.
Lee et collab.(2017) a été parmi les premiers à utiliser l’apprentissage profond pour faire le classement en utilisant les feuilles. En adaptant un réseau de type AlexNet et en entraînant sur un jeu de données comportant près de 3 000 images pour 44 classes, ils ont obtenu une précision de 99,4%. De plus, en analysant la réponse des filtres à l’intérieur du réseau, ils ont pu constater que de prendre uniquement la forme de la feuille n’est pas un bon choix pour procéder à la classification. En effet, cette forme étant trop similaire entre certaines espèces pour être utile au niveau de la classification. Ils ont aussi remarqué que, dans ce cas, les nervures de la feuille sont un bien meilleur discriminant.
Finalement, la compétition LifeClef qui se déroule à chaque année est une compétition similaire à ImageNet, mais où le but est de faire la classification parmi plusieurs types de végétaux. Celle-ci inclut des arbres, mais aussi des fleurs et des arbustes. Pour cette compétition, plusieurs méthodes ont aussi été développées et récemment, ce sont les réseaux de neurones qui remportent toujours le premier prix (Champ et collab.(2015)). En particulier, en 2017, les gagnants avaient utilisé un ensemble de trois architectures (GoogleLeNet, ResNet-152 et ResNeXT) pré-entraînées sur ImageNet. Ils avaient ensuite entraîné leurs réseaux en augmentant artificiellement la taille des données en faisant des crops aléatoires, des renversement horizontaux, en modifiant la saturation, etc. Au final, ils ont obtenu un taux de précision de 88,5% sur le jeu de données (Goëau et collab.(2017)).
Classification d’écorce
Le problème de classification d’écorce, qui est un problème de classification fine, s’apparente beau-coup au problème plus général de classification de texture. C’est pourquoi les premières avancées faites dans le domaine ont utilisé des approches similaires à ce qui se faisait pour la classification de texture (Sulc et Matas(2013);Sulc (2014);Boudra et collab.(2015)). Par exemple, la figure1.4
montre des exemples d’images d’écorces sur lesquelles ce type de techniques a été appliqué.
Les premières avancées sur le problème date d’environ 2003, où les filtres de Gabor étaient utilisés pour procéder à l’extraction de caractéristiques (Chi et collab.(2003);Huang et collab.(2006)). Fait intéressant, même s’il n’utilisait pas l’apprentissage profondHuang et collab.(2006) utilisait déjà à
FIGURE1.4 – Exemple d’images d’écorce queBoudra et collab.(2015) ont classifiées.
cette époque les réseaux de neurones pour procéder à la classification.
D’autres méthodes plus récentes se sont basées sur des extracteurs de caractéristiques faits à la main (feature engineering). Par exemple,Fiel et Sablatnig(2011) a utilisé des descripteurs Scale-Invariant Feature Transform (SIFT) (Lowe(2004)) pour extraire des caractéristiques de l’image, et un SVM pour procéder à sa classification. Ils ont appliqué leur méthode sur des images d’écorce, de feuilles et d’aiguilles de différentes essences d’arbres, obtenant un taux de classification de 65,5% sur le jeu de données Austrian Federal Forests (AFF) comportant 1183 images et 11 essences d’arbres différentes. Les descripteurs Local Binary Pattern (LBP) ont été utilisé à maintes reprises pour la classification d’écorce. Par exemple, Boudra et collab. (2015) a comparé différents descripteurs (LBP, LBP uni-forme, etc.). Suite à leurs expériences, ils ont suggéré que les descripteurs fonctionnant à différentes échelles spatiales permettent d’obtenir de meilleurs résultats que les autres. Les expériences menées parSulc et Matas(2013) semblent confirmer ces résultats. En utilisant des descripteurs multi-échelles formés par la concaténation d’histogrammes LBPs ainsi qu’un SVM comme classificateur, ils ont été en mesure d’obtenir un taux de classification de 82,5% sur le jeu de données AFF. Similairement à
Fiel et Sablatnig(2011),Blaanco et collab.(2016) a utilisé les LBPs et un Least Square Support Vector Machine (LSSVM) pour procéder à la classification et ont obtenu 82,83% sur un jeu de données privé de 23 essences contenant chacune 40 images en couleurs de haute résolution.
Finalement, certaines approches ont tenté d’exploiter l’information 3D provenant des Lidars pour effectuer cette classification. Par exemple, l’approche proposée parOthmani et collab.(2016) analyse les cicatrices présentes sur l’écorce qui sont capturées par les nuages de points 3D, afin d’identifier les essences. La classification est effectuée par la méthode Random Forest.Mizoguchi et collab.(2017), sont les seuls à avoir appliqué l’apprentissage profond à ce problème. En générant des images de profondeurs 2D à partir des scans Lidars 3D, ils ont pu entraîner un réseau de type AlexNet sur
ces données. Grâce à cette méthode, ils ont obtenu une précision d’environ 90%. Toutefois, leurs expérimentations se sont limitées à seulement deux essences, ce qui rend le problème significativement moins difficile. Il est aussi difficile d’interpréter ces résultats dans un cadre plus vaste, où il faudrait identifier de nombreuses essences.
En observant tous ces travaux, nous avons remarqué que très peu d’approches avait tenté l’apprentis-sage profond pour faire la classification alors que, récemment, celui-ci battait des records de perfor-mances dans tous les domaines de la vision. De plus, nous avons aussi remarqué qu’une des raisons qui pouvaient expliquer ce manque de recherche était l’absence de jeu de données suffisamment important (voir2.1) pour pouvoir appliquer ces nouvelles techniques. Le chapitre suivant détaille comment nous avons tenté de palier à ce problème en créant un nouveau jeu de données ainsi que les expérimentations qui nous ont amené à d’établir un nouvel état de l’art dans le domaine.
Chapitre 2
Expérimentations préliminaires
Le but de notre projet était de classifier des essences d’arbres uniquement grâce à des images RGB standards de leur écorce. Nous avions une forte intuition que c’était possible en utilisant les réseaux de neurones et l’apprentissage profond, car ceux-ci avaient récemment été en mesure d’accomplir des tâches impressionnantes. De plus, comme mentionné dans l’article CNN Features off-the-shelf : an Astounding Baseline for Recognition (Razavian et collab.(2014)), nous savions qu’il était possible d’obtenir des résultats state-of-the-art en reconnaissance en utilisant un réseau de neurones à convo-lution et en utilisant un SVM pour la classification. Cela montre que les caractéristiques extraites par les CNNs sont souvent supérieures à celles qui sont extraites par les méthodes traditionnelles et sug-gère qu’il serait possible de reprendre directement des paramètres pré-entraînés sur ImageNet pour l’extraction de caractéristiques et obtenir d’excellents résultats.
Notre objectif pour le projet était d’obtenir au moins 95% comme taux de précision. Pour ce faire, nous avons procédé à plusieurs expérimentations pour tenter de déterminer la meilleure façon de faire. Certaines ont très bien fonctionné et d’autres moins. Les expériences qui n’ont pas fonctionné nous ont tout de même fait découvrir certains aspects de l’apprentissage profond et nous ont permis, au final, de développer une solution robuste.
Ce chapitre présente les jeux de données qui ont été créés et utilisés pour tenter de résoudre ce pro-blème ainsi que les expériences successives qui ont été effectuées sur ceux-ci afin de découvrir com-ment procéder à la classification d’essence d’arbre en utilisant uniquecom-ment des images de l’écorce.
2.1
Preuve de concept
2.1.1 Jeu de données
Un des principaux problèmes relié à l’apprentissage profond est que celui-ci demande une quantité phénoménale de données pour l’entraînement. Ce problème n’est pas négligeable dans la majorité des cas d’application, car les données annotées appropriées pour l’application en question n’existent souvent pas en quantité suffisante. Il faut donc manuellement les collecter et les étiqueter, en s’assurant
Référence Nombre de classe Nombre d’image Public
Chi et collab.(2003) 8 200 Non
Huang et collab.(2006) 17 300 Non
Trunk12 (Švab(2014)) 12 393 Oui
Bressane et collab.(2015) 5 540 Non
Blaanco et collab.(2016) 23 920 Non
AFF (Fiel et Sablatnig(2011)) 11 1183 Non
TABLE2.1 – Jeux de données d’écorces d’arbres existants
de leur qualité, mais aussi en essayant le plus possible de ne pas introduire de biais humain. Le tableau
2.1montre les jeux de données qui avaient été utilisés dans des travaux antérieurs de reconnaissance d’essence. Il est important de remarquer que la plupart de ces jeux de données contiennent un nombre limité de classe en plus de ne contenir qu’un nombre très limité d’images. De plus, un seul de ces jeux de données est disponible publiquement, ce qui empêche leur utilisation dans la recherche et limite l’effort mondial sur ce problème.
Comme on peut le constater, il n’y a pas de jeu de données suffisamment important pour permettre l’utilisation d’approches basées sur l’apprentissage profond. Par exemple, le plus important jeu de données est le AFF (Fiel et Sablatnig(2011)), qui contient uniquement environ 1 200 images de 11 essences. Ce jeu de donnée est aussi privé, ce qui le rend difficile d’utilisation. Ce manque de don-nées explique peut-être en partie pourquoi la majorité de la recherche sur la reconnaissance d’écorce s’est centrée autour d’extracteur de caractéristiques fait à la main comme les filtre de Gabor (Huang et collab.(2006);Chi et collab.(2003)), les descripteurs SIFTs (Fiel et Sablatnig(2011)) ou les des-cripteurs LBPs (Boudra et collab.(2015);Sulc(2014)) qui peuvent être entraîné en utilisant des jeux de données plus petits.
Afin de pouvoir tester notre hypothèse comme quoi il était possible d’utiliser l’apprentissage profond pour faire la classification de l’écorce, nous avons dû créer un jeu de données. Pour ce faire, nous avons utilisé l’appareil photo d’un téléphone cellulaire pour prendre des images rapprochées de troncs d’arbre, au hasard sur le campus de l’Université Laval et dans des parcs. De plus, afin d’avoir un grand nombre de photos rapidement, nous avons décidé de prendre des vidéos de l’écorce. Ceci permettait d’obtenir plusieurs images pour chaque seconde du vidéo.
Les arbres ont été sélectionnés au hasard parmi les essences dont nous étions confiants que nous pou-vions identifier sans trop faire d’erreurs. De plus, nous avons essayé de récolter un nombre similaire d’arbres et d’images pour chaque essence afin de rendre le jeu de données le plus balancé possible. Ce jeu de données initial comportait neuf classes. Le tableau2.2montre sa composition. Il est impor-tant de remarquer qu’il est très petit et que deux classes, soit le chêne et l’orme, possède un seul arbre
ce qui rend leur utilisation difficile. Pour augmenter la variété entre les images, nous avons décidé d’utiliser uniquement une image sur 5, en laissant tomber 4 trames consécutives dans la vidéo. Ceci est dû au fait qu’il n’y avait pas assez de différences entre deux images consécutives.
Classe Nombre de vidéos Nombre d’arbres Nombre d’images générées
Bouleau 14 7 737 Bouleau jaune 17 13 658 Chêne 9 1 513 Épinette 11 7 380 Érable 15 11 505 Orme 2 1 112 Peuplier 8 4 362 Pommetier 14 7 539 Sapin 15 13 671
TABLE2.2 – Composition du jeu de donnée initial pour la preuve de concept
Il est toutefois important de noter qu’à cette étape, plusieurs erreurs d’annotation étaient possibles, car les images avaient été annotées sans l’aide d’un spécialiste du domaine. De plus, les étiquettes de classe n’étaient pas très précises (il n’y avait pas de distinction entre les images d’épinettes par exemple) pour la même raison.
2.1.2 Architecture du réseau
Comme premières expérimentations, nous avons pris une architecture de réseau relativement simple qui s’apparente à l’architecture d’AlexNet et qui nous permettait d’obtenir rapidement des résultats. Ce réseau comportait 5 couches de convolution ayant toutes une taille de filtre 3x3. La première couche possédait 48 filtres, la deuxième 128, la troisième et la quatrième 192 et la cinquième 128. Chaque couche était suivie par un max pooling de taille 2x2. Par la suite, il y avait 3 couches pleine-ment connectées ayant respectivepleine-ment le nombre de neurones suivants : 400, 50 et 8. De plus, de la normalisation par lot a été ajoutée après chacune des couches. Finalement, un dropout de 10% a été ajouté sur les 2 premières couches pleinement connectés.
Avec cette architecture, entraîner le réseau prenait environ 6h30 sur une carte graphique NVIDIA GTX 1070. Nous obtenions environ 99,9% de précision sur le jeu de donnée d’entraînement. Les tables2.3
et2.4montrent les résultats en test plus en détails. Il est important de noter que nous avons utilisé les images provenant de l’orme uniquement en entraînement, car, pour cette classe, il y avait seulement 2 vidéos provenant d’un seul arbre dans le jeu de données. De plus, malgré qu’un seul chêne soit présent dans le jeu de données, nous avons décidé de le conserver, car il permettait de générer 513 images comparativement aux 112 images générées par l’orme. Bien qu’encourageant, ces résultats illustrent quand même certains problèmes avec la méthode ou avec le jeu de données. Premièrement, les performances globales en test sont entre 75 et 80%, ce qui est indicatif d’un problème important de sur-apprentissage. Ceci est confirmé par la figure2.1, qui montre la précision sur le jeu d’entraînement
et sur le jeu de validation obtenu au cours de l’entraînement. À partir de cette courbe, il est très facile de confirmer ce sur-apprentissage. En effet, l’écart entre la courbe d’entraînement et de validation n’est pas négligeable et il est de plus en plus important au fur et à mesure de l’entraînement. Deuxièmement, on peut voir dans la table2.3que la classification du peuplier a complètement échouée.
Bo. Bo J. Ch. Ép. Er. Pe. Po. Sa.
Bouleau 193 21 7 0 0 0 10 15 Bouleau j. 0 296 0 0 0 0 0 3 Chêne 0 0 248 0 0 0 4 19 Épinette 0 0 2 304 16 0 0 0 Érable 12 0 13 0 276 32 5 8 Peuplier 221 0 1 0 0 6 0 0 Pommetier 0 0 0 11 0 0 303 1 Sapin 0 0 0 20 0 11 0 279
TABLE2.3 – Matrice de confusion de la preuve de concept
Classe Précision Bouleau 78,5% Bouleau jaune 99,0% Chêne 91,5% Épinette 94,4% Érable 79,8% Peuplier 0,0% Pommetier 96,2% Sapin 90,0% Total 78,7%
TABLE2.4 – Précision pour chacune des classes de la preuve de concept
Image de l’arboretum
Certains travaux de recherche, notamment Azizpour et collab.(2014), ont démontré empiriquement qu’une grande variété de classe peut aider à améliorer la capacité de généralisation des réseaux de neurones. Pour cette raison, nous sommes allés récolter des images dans le jardin Roger Van Den Hende situé près de l’université Laval. Nous avons ainsi pu récolter 44 essences supplémentaires. Cependant, étant donné que le jardin contenait souvent un seul arbre pour présenter l’espèce, nous nous sommes retrouvés avec un jeu de données comportant un grand nombre d’essences, mais très peu d’arbres par essence. Nous avons tout de même tenté de les utiliser pour l’entraînement, mais nous n’avons remarqué d’amélioration dans les résultats.
FIGURE2.1 – Courbe d’entraînement de la preuve de concept
2.1.3 Résultats
Afin de potentiellement bénéficier de l’effet de régularisation d’un grand nombre de classesAzizpour et collab.(2014), nous en avons inclus pendant l’entraînement sans les utiliser en test. Les images de l’arboretum n’ayant pas eu d’effet sur les résultats, nous avons plutôt opté pour des images provenant d’ImageNet. Pour ce faire, nous avons choisi sept nouvelles classes : baleine, chat, chien, oiseau, poisson, serpent et singe, chacune contenant entre 1000 et 2000 images, qui ont été employées à titre de classe supplémentaire pendant l’entraînement. Pour l’entraînement final, nous avons pris un resnet50 pré-entraîné sur ImageNet et avons utilisé les hyper-paramètres indiqués dans la table2.5. En apprentissage profond, il est souvent conseillé de réduire le taux d’apprentissage pendant l’en-traînement afin de permettre au réseau de trouver un meilleur minimum. Par défaut, le taux d’ap-prentissage est souvent réduit de façon graduelle tout au long de l’entraînement. Toutefois, une autre technique qui est souvent encouragée est d’utiliser une descente par palier. Ceci permet au réseau de rester plus longtemps avec un grand taux d’apprentissage, et possiblement trouver une meilleure zone avant de diminuer celui-ci. Cependant, diminuer le taux d’apprentissage par palier signifie qu’il faut aussi savoir à quel cycle le diminuer, et de combien. Dans la table2.5, le paramètre "Diminution du taux d’apprentissage" indique que celui-ci était diminué de moitié à chaque numéro de cycle indiqué par le paramètre "Cycle pour la diminution du taux d’apprentissage".
Pour trouver les cycles auxquels diminuer le taux d’apprentissage, plusieurs entraînements sont né-cessaires. Tout d’abord, on entraîne un réseau avec un taux d’apprentissage relativement élevé et on regarde vers quel cycle l’entraînement semble avoir atteint un minimum. Ensuite, on ajoute ce cycle dans la liste et on entraîne un nouveau réseau avec les nouveaux hyper-paramètres. Il suffit ensuite de répéter ces opérations jusqu’à ce qu’il n’y ait plus de gains à obtenir.
Les tableaux2.5et2.6indiquent les hyper-paramètres et les résultats finaux qui ont été obtenus. Dans la table 2.5, le pourcentage d’image provenant d’image net indique que lors de l’entraînement, 30%
