Creation d’un jeu de données pour la détection et la reconnaissance des chiffres manuscrits dans des cartes anciennes 

Quelques problèmes du deep learning

Maintenant que la composition d’un modèle est définie, nous allons expliquer ce que sont les risques de surentraînement ou de sous-entraînement ainsi que le problème de manque de données.
Comment savoir si le modèle est correctement entraîné ? Dans un premier temps, nous pouvons suivre l’évolution des métriques de performances. Par exemple, nous pouvons exécuter le nombre d’époques suffisant pour que la précision du modèle dépasse 90% lors de la phase d’entraînement. Néanmoins, il peut arriver que le modèle ne soit pas performant lors de la phase de test malgré cette précision. En effet, comme l’explique [Chollet, 2020] cette imprécision sur des nouvelles données se justifie par un sur-apprentissage du modèle sur les données d’entraînement. Cela signifie que le modèle a appris par cœur les caractéristiques des données d’entraînement, au lieu de trouver celles qui sont communes à toutes les données, et d’en faire une généralisation. Ainsi, lorsque le modèle est testé sur des nouvelles données, il n’est pas capable d’atteindre une précision équivalente à celle de la phase d’entraînement. C’est pourquoi, il est important de trouver l’équilibre entre la généralisation et l’optimisation du modèle.
Ensuite, un mauvais entraînement peut-être causé par un manque de données d’apprentissage. Si l’ensemble de données est trop petit et trop peu représentatif, le modèle peut ne pas apprendre correctement la tâche qui lui a été demandée. Pour pallier à ce manque de données, il existe la méthode de la data augmentation (ou augmentation de données en français). [Chollet, 2020] explique qu’il s’agit de traitements aléatoires effectués pour déformer les données en utilisant des déformations horizontales, verticales et des rotations.
Cela permet donc de créer des données supplémentaires en se basant sur celles existantes.

Les réseaux de neurones

Afin de mettre en place un modèle de deep learning, il faut d’abord choisir une architecture. L’architecture d’un réseau désigne la façon dont les couches de neurones sont agencées les unes par rapport aux autres. Le choix de l’architecture est surtout fait en fonction des données qui seront utilisées en entrée de ce réseau. Le Tableau 2 résume les trois grandes familles d’architectures à utiliser en fonction du type de données d’entrée, sur les conseils de [Chollet, 2020].

Les réseaux entièrement connectés

Ce type de réseaux ne traite que les données vectorielles et n’effectue pas de réelles hypothèses sur l’organisation des caractéristiques. Pour chaque couche de ces réseaux, tous les neurones sont connectés aux neurones de la couche suivante. Cela entraîne donc un nombre de paramètres important à calculer pour le modèle. L’avantage de ces réseaux est qu’ils sont facilement applicables à différents types de problème, cependant leurs performances, notamment de temps de calculs, peuvent être moins bonnes que celles d’autres architectures de réseaux.

Les réseaux récurrents (RNN)

De manière générale, lorsqu’un réseau analyse une donnée, il la traite dans son ensemble et en une seule fois. Il ne garde pas en mémoire une partie de la donnée qui lui permettrait de comprendre la suite de celle-ci. Cependant, les RNN permettent de garder en mémoire ce que le modèle a vu. En effet, [Chollet, 2020] explique que ces réseaux traitent des séquences de données « en parcourant les éléments de la séquence et en maintenant un état contenant des informations relatives à ce qu’il a vu jusqu’à présent ». Ce fonctionnement est mis en application en créant des neurones qui interagissent de façon non linéaires les uns avec les autres. Cela permet de créer des réseaux qui traitent des séries temporelles de données.

Les réseaux de neurones convolutifs (CNN)

Étant donné que nous travaillons avec des données images, nous allons utiliser un réseau CNN comme dans [Chollet, 2020].

Fast R-CNN

Partant de cette première tentative pour mettre en place un réseau de détection et de reconnaissance d’objet à partir d’un CNN, le même auteur a voulu résoudre les principaux problèmes de la méthode R-CNN. Comme l’explique [Girshick, 2015], le nouveau modèle nommé Fast R-CNN (ou R-CNN rapide en français) est neuf fois plus rapide que le R-CNN lors de la phase d’entraînement et 213 fois lors de la phase de test. Cette progression est notamment due aux modifications apportées au début du processus.
En effet, au lieu de sélectionner 2 000 régions et de toutes les traiter au sein d’un CNN, le Fast R-CNN applique un réseau convolutif directement sur l’image entière pour en extraire une feature map. Puis, la recherche sélective est appliquée sur cette feature map pour trouver des régions d’intérêt. Enfin, pour chaque région, le modèle prédit une boîte englobante ainsi que la probabilité d’appartenance de cette boîte à une classe.
Cette méthode est plus performante que la précédente, cependant elle fait toujours appelle à la recherche sélective qui, d’après [Gandhi, 2018], est lente et fastidieuse.

Faster R-CNN

Jusqu’ici les améliorations apportées ont permis d’accélérer le processus de reconnaissance des objets, mais cela n’est toujours pas suffisant pour traiter des images en temps réel. En effet, si nous souhaitons faire de la reconnaissance d’objet sur des vidéos de surveillance par exemple, il faut que le traitement soit plus rapide que la fréquence d’acquisition des images.
Pour cela, [Ren et al., 2016] proposent une nouvelle approche. Celle-ci consiste à remplacer l’algorithme de recherche sélective par un réseau entièrement convolutif. Ce réseau est appelé Region Proposals Network (RPN), littéralement, réseau de proposition de régions en français. Ensuite, après une opération de RoIPooling, [Ren et al., 2016] utilisent un Fast R-CNN qui reprend les propositions de régions du RPN comme données d’entrée pour trouver les boîtes englobantes et leur probabilité d’appartenance à une classe (voir Figure 8).

Les travaux existants dans le domaine de la reconnaissance de caractères

La reconnaissance de caractères numériques écrits à la main est un des premiers cas traité par les réseaux de neurones convolutifs. [LeCun et al., 1989] a traité le cas de la reconnaissance des chiffres pour le service postal des États-Unis (voir l’introduction de la partie I.2). Nous savons aussi que le jeu de données a une importance capitale pour l’élaboration d’un modèle deep learning autant lors de la phase d’entraînement que de test.
Avec l’apparition de nouveaux jeux de données de chiffres manuscrits, la mise en place de réseaux de neurones pour les reconnaitre a pris de l’ampleur et notamment avec l’organisation de compétitions comme celles du site Kaggle par exemple.

Les jeux de données existants

Afin que le modèle ne soit ni surentraîné ni sous-entraîné, le jeu de données doit être adapté au problème. En effet, si un modèle est entrainé à reconnaitre des images de chats, il ne sera pas capable de reconnaitre une vache, sauf si nous utilisons un modèle pré-entraîné.
Cela paraît logique mais cette notion peut se transposer à des niveaux plus fins. C’est pourquoi, il est préférable que le jeu de données d’entraînement soit proches des données qui seront utilisées en phase de test.
Ainsi, c’est dans cette optique que de nombreux jeux de données ont été créés et sont disponibles en open data. Ils sont en général téléchargeables sur Internet et peuvent être organisés de différentes façons. Parmi elles, les données peuvent être organisées dans des dossiers portant le nom de la classe ou encore, les images peuvent être en vrac et leurs étiquettes sont renseignées dans un fichier texte. Dans le cadre de la reconnaissance de chiffres manuscrits, plusieurs jeux de données ont été mis en place au fil du temps et peuvent tous présenter des avantages pour notre problématique.

La méthode DIGITNET

Le travail de [Kusetogullari et al, 2020] est fortement lié avec le sujet de ce mémoire,puisque le sujet est la détection et la reconnaissance de chiffres et de nombres dans des images de documents anciens. Ces documents anciens sont datés entre 1800 et 1940, ce qui offre un large panel de documents et d’écritures différents. L’objectif est d’automatiser cette tâche avec de l’apprentissage profond.

Création d’un jeu de données adapté au problème

Afin de mettre en place leur projet, [Kusetogullari et al, 2020] ont décidé de créer leur propre jeu de données. Comme ils l’expliquent dans leur article, les jeux de données existants tel que MNIST ou USPS ne conviennent pas pour l’entraînement de leur modèle.
En effet, ces données sont normalisées alors que la taille des caractères numériques n’est jamais fixe dans les documents anciens. De plus, les images sont en noir et blanc alors que les documents qui seront testés sont en couleur. Enfin, les chiffres de ces jeux de données ont été nettoyés de toutes dégradations, alors que le but ici est d’apprendre au modèle à s’adapter aux difficultés des documents anciens. Un jeu de données qui pourrait convenir serait le dataset 2 d’ARDIS, cependant [Kusetogullari et al, 2020] jugent qu’il ne contient pas un nombre suffisant de caractères pour entraîner un modèle.

Mise en place d’un réseau Faster R-CNN

Dans cette partie, nous détaillons les étapes qui ont permis de mettre en place une architecture Faster R-CNN. Cela dans le but de procéder à la détection et à la reconnaissance de caractères numériques dans des planches cadastrales anciennes, notamment les numéros de parcelles. En effet, après plusieurs recherches concernant les architectures utilisées pour procéder à de la reconnaissance de chiffres, aucun ne traite de l’architecture Faster R-CNN.
C’est pourquoi nous avons choisi d’étudier cette architecture afin de comparer ses performances avec celles des autres études.
Dans un premier temps, nous allons présenter la préparation de l’outil de travail qui a permis de réaliser des traitements deep learning. Puis, nous avons appliqué un exemple d’architecture Faster R-CNN qui traite de la détection et de la classification des cellules du sang en se servant d’images prises au microscope. Cela permet de tester l’installation des différents outils et de vérifier notre bonne utilisation de ce modèle.
Ensuite, nous mettons en place notre propre jeu de données afin d’entraîner un modèle applicable aux planches cadastrales anciennes. En effet, au moment de ce TFE, seuls les jeux de données composés d’images sur lesquelles ne figurent qu’un seul chiffre sont disponibles en open data. Il est donc nécessaire d’élaborer une base d’images composées de plusieurs chiffres, ainsi que les étiquettes contenant les coordonnées des boîtes englobantes des objets.

Préparation de l’outil de travail

L’environnement de travail

Nous travaillons sous le système d’exploitation Linux. Pour être en capacité de lancer les programmes et d’avoir un temps de calcul raisonnable, nous avons mis en place un serveur de calcul composé d’une carte graphique (ou GPU) Nvidia Quadro RTX6000. Cette carte a une mémoire de 24 Go et un total de 700 cœurs. Pour faire fonctionner ce GPU, il est nécessaire d’installer l’interface de programmation CUDA qui est un ensemble de pilotes permettant au GPU d’exécuter des calculs parallélisés, ainsi que cuDNN qui est « une bibliothèque de primitives hautement optimisées pour l’apprentissage profond » [Chollet, 2020].
Afin de faire des calculs deep learning en langage Python, il est préférable dans un premier temps d’utiliser certaines bibliothèques comme Keras et tensorflow. Ce sont deux bibliothèques très utilisées car elles sont libres d’accès et leurs contenus sont bien documentés . Cependant, il faut faire attention aux versions téléchargées. En effet, les deux bibliothèques sont liées (voir Figure 15) et donc les versions doivent correspondre pour que le programme soit fonctionnel. Ici, nous avons utilisé la version 2.0.3 de Keras et la version GPU de tensorflow 1.15.0. D’autres bibliothèques sont nécessaires pour faire fonctionner leréseau Faster R-CNN et la mise en place de l’environnement est expliqué en Annexe 1.

Les performances du GPU

Afin de constater l’efficacité d’un GPU par rapport à l’utilisation d’un CPU, nous avons effectué des tests. Pour cela, nous avons entraîné le modèle en paramétrant le nombre d’époque à 1 et la longueur d’une époque à 10. Nous avons d’abord entraîné ce modèle sur le CPU et avons obtenu un temps de calcul égal à 19 minutes. Puis, nous avons effectué le même calcul sur le serveur GPU, et cette fois-ci nous avons un temps de calcul de 35 secondes, soit un facteur de 32,5. Grâce à ce test nous avons confirmé que l’utilisation d’un GPU permet de réduire drastiquement le temps de calculs, ce qui permettra par la suite d’effectuer plus de tests. Le temps de calculs peut encore être réduit en copiant directement les données sur le serveur au lieu de les importer depuis un serveur distant et donc d’éviter des temps de latence liés au réseau informatique.

Création d’un jeu de données pour la détection et la reconnaissance des chiffres manuscrits dans des cartes anciennes

Maintenant que nous avons analysé le fonctionnement du Faster R-CNN et que nous l’avons appliqué à un exemple connu, nous devons transposer cette application à notre problème de détection et de reconnaissance de chiffres manuscrits.
Dans le but de créer un modèle deep learning capable de reconnaitre des caractères numériques manuscrits, il faut l’entraîner sur un jeu contenant des données semblables aux exemples qu’il rencontrera sur les planches cadastrales. Cependant, le seul jeu de données existant dans la littérature pouvant répondre à ce critère est le dataset DIDA. Mais il n’a pas été possible d’effectuer des tests avant la fin de ce travail car le jeu de données a été disponible trop tardivement. De plus, pour pouvoir réutiliser l’architecture Faster R-CNN précédente, il faut que les annotations soient renseignées dans un tableur. Ainsi, nous avons décidé de mettre en place notre propre jeu de données. Pour cela, nous avons écrit un programme python permettant à la fois de créer les images dont nous avons besoin et de générer le tableur qui répertorie les informations des boîtes englobantes.
L’idée principale de ce programme python est de coller des images de chiffres manuscrits provenant de datasets déjà existants sur une image de couleur unie.
L’objectif général de la création de ce jeu de données est de générer des images ressemblant autant que possible aux planches cadastrales qui seront par la suite testées, en conservant l’unique présence de chiffres manuscrits.
Une seconde possibilité pourrait être de créer un jeu directement à partir d’extraits de planches cadastrales. En effet, les images auraient exactement les mêmes caractéristiques que les planches. Elles contiendraient aussi bien les numéros de parcelle que les contours et les écritures de texte. Le problème de cette solution est la mise en place de ce jeu, car cela nous obligerait à étiqueter des centaines voire des milliers de numéros manuellement, chose que nous voulons éviter. C’est pourquoi la première méthode pour créer le jeu de données est celle qui a été choisie.
Dans la suite de ce mémoire, le terme « imagette » désignera les images des chiffres qui sont collés sur une plus grande image, et le terme « image » désignera une image de notre jeu de données nouvellement créé.

Les imagettes utilisées

Comme l’avait soulevé [Kusetogullari et al, 2020], les chiffres du dataset ARDIS ressemblent à ceux que nous pouvons retrouver dans les documents anciens (voir Figure 19).
C’est donc ce jeu de données que nous avons utilisé.

Prétraitement des imagettes avant leur insertion dans l’image

Tout d’abord, coller les imagettes directement sur l’image n’est pas satisfaisant car la couleur du fond de l’imagette ne correspond pas toujours à celle de l’image (voir Figure 20). Il apparaît donc plus pertinent de prétraiter les imagettes de manière à trouver une correspondance entre les deux couleurs de fond, et ainsi que les chiffres soient intégrés de façon naturelle dans l’image. De plus, la taille des numéros est bien supérieure à la taille de ceux que l’on retrouve sur les cartes scannées, c’est pourquoi nous avons aussi redimensionné les imagettes.

Insertion des imagettes dans l’image

Désormais, nous avons à disposition des imagettes prétraitées, prêtes à être insérées sur une image. Afin, que le jeu de données ne soit pas répétitif, le nombre d’imagettes insérées est choisie aléatoirement entre 1 et 8. De plus, les imagettes sont aussi choisies de façon aléatoire dans le jeu de données ARDIS 2. Nous avons fait en sorte qu’une imagette déjà insérée sur une image ne soit pas réutilisée par la suite. Ensuite, le choix du point d’insertion est aussi aléatoire mais en respectant tout de même deux conditions : les coordonnées du point d’insertion ne doivent pas être sur une autre imagette pour éviter qu’elles ne se superposent et l’imagette ne doit pas être à cheval sur le bord de l’image.
Une fois que l’imagette est introduite, la frontière entre l’imagette et l’image doit être lissée. Pour cela, un filtre passe bas gaussien de taille 3×3 est appliqué sur tout le contour extérieur de l’imagette. Il faut donc déterminer les 9 valeurs de ce filtre. La fonction Python cv2.GetGaussianKernel fournit un noyau gaussien 1D (soit un vecteur colonne de taille 3×1). Ainsi, nous avons calculé les coefficients du noyau gaussien 1D, puis nous l’avons transformé en noyau 2D par produit scalaire. Cela est possible car les noyaux gaussiens sont des filtres séparables.

Enregistrement des étiquettes dans un tableur

Pour chaque imagette insérée, les données nécessaires à l’apprentissage du modèle sont enregistrées dans le fichier nommé annotation.csv.
Pour l’utilisation de ce fichier pendant la phase d’entraînement, il est nécessaire de le convertir en fichier texte (extension .txt), avec comme séparateur la virgule. De plus, si le dossier contenant les images ou le code train_frcnn.py sont déplacés , il faudra vérifier que les chemins indiqués dans la première colonne soient toujours corrects.
Une fois que le bon nombre d’imagettes est inséré dans l’image, cette dernière est enregistrée et le programme peut passer à la création des images suivantes. A l’issue de ces traitements, nous obtenons un jeu de donnée d’entraînement composé d’un total de 1663 images contenant 7596 chiffres manuscrits. La Figure 21 montre quelques exemples d’images obtenues après la création du jeu de données.

Adaptation de l’architecture Faster R-CNN à la reconnaissance des chiffres manuscrits dans les cartes anciennes

Pour pouvoir utiliser le réseau Faster R-CNN sur notre jeu de données, nous devons adapter ses paramètres. Dans la partie II.1.2.3, nous avons vu les principaux paramètres à modifier pour obtenir des résultats cohérents. Nous allons donc tous les passer en revue et expliquer les valeurs choisies pour l’entraînement du modèle.

Les paramètres du fichier config.py

Tout d’abord, en ce qui concerne le choix du réseau convolutif pré-entrainé qui intervient dans la première partie du Faster R-CNN, nous n’avons pas d’autre choix que d’utiliser le ResNet50. En effet, n’ayant pas réussi à faire fonctionner le VGG16, nous n’avons pas de résultats concernant cette méthode, et ce paramètre ne changera pas au cours des différents tests.
Nous ne ferons pas non plus de data augmentation, du moins dans un premier temps, afin d’évaluer les performances du jeu de données que nous avons mis en place.
Ensuite, il faut choisir les paramètres des ancres comme vu à la section I.4.4.1. Ces éléments sont très importants car ce sont eux qui vont définir la taille des boîtes englobantes que va rechercher le modèle. Ainsi, pour que les dimensions des boîtes correspondent à celles renseignées dans le fichier annotation.txt, nous avons choisi une échelle d’ancre de 28 et un ratio de 1/2. Cela engendre une taille de proposition de boîte de 28×56 pixels ce qui permet une marge pour la détection des chiffres. Nous avons effectué plusieurs tests notamment avec des échelles d’ancres égales à 20, 28 et 40 et des rapports largeur/hauteur égaux à 1/1, 1/2 et 2/1.
Nous avons modifié le nombre de RoI directement en ligne de commande. La valeur retenue après plusieurs tests est la valeur 18. Celle-ci a été déterminée grâce à [Erdem, 2020].
Étant donné que nos images sont au format 256x256x3 (largeur, hauteur et nombre de canaux ici RGB) et que l’architecture du réseau réorganise ses données au format 14x14x1024, nous pouvons trouver le nombre de RoI en faisant 256/14 ce qui donne 18 RoI.
Le reste des paramètres du fichier config.py n’est pas modifié car il s’agit des paramètres utilisés couramment pour obtenir des résultats corrects. Nous les changerons dans le cas où le modèle ne serait pas suffisamment performant.

Les paramètres de la ligne de commande

L’élément qui ne change pas en ligne de commande est le format des données d’annotations, puisque nous avons gardé le formalisme du fichier texte. Bien évidemment, les chemins de sauvegarde des données de sorties changeront en fonction des tests effectués.
Le paramètre que nous avons fait varier est le nombre d’époques. En effet, lors de l’exemple des cellules de sang, la documentation conseillait d’entraîner le modèle pendant 500 époques. Nous avons donc testé cette valeur, cependant nous avons constaté que l’entraînement durait entre 22h et une journée. Afin de réduire ce temps de calcul, nous avons diminué ce nombre à 250 puis à 120 époques pour effectuer des tests plus rapides.
Une fois que les autres paramètres seront convenables, nous pourrons ré-augmenter cette valeur.

Table des matières

I MISE EN CONTEXTE 
I.1 PROBLEMATIQUES SOULEVEES LORS DE LA VECTORISATION DE CARTES ANCIENNES
I.1.1 Notions générales
I.1.2 La vectorisation de documents anciens : problématiques liées au deep learning
I.2 GENERALITES SUR LE DEEP LEARNING
I.2.1 Fonctionnement d’un réseau de neurones
I.2.1.1 Fonctionnement d’un neurone
I.2.1.2 La fonction de perte
I.2.1.3 Les métriques de performance
I.2.1.4 L’optimiseur
I.2.2 Quelques problèmes du deep learning
I.3 LES RESEAUX DE NEURONES
I.3.1 Les réseaux entièrement connectés
I.3.2 Les réseaux récurrents (RNN)
I.4 LES RESEAUX DE NEURONES CONVOLUTIFS (CNN)
I.4.1 La convolution dans les réseaux de deep learning
I.4.2 CNN basé sur les régions (R-CNN)
I.4.3 Fast R-CNN
I.4.4 Faster R-CNN
I.4.4.1 Le Region Proposal Network (RPN)
I.4.4.2 Entraînement du Faster R-CNN
I.5 LES TRAVAUX EXISTANTS DANS LE DOMAINE DE LA RECONNAISSANCE DE CARACTERES
I.5.1 Les jeux de données existants
I.5.1.1 MNIST
I.5.1.2 ARDIS
I.5.1.3 USPS
I.5.2 La méthode DIGITNET
I.5.2.1 Création d’un jeu de données adapté au problème
I.5.2.2 Fonctionnement du modèle DIGITNET
I.5.2.3 Résultats obtenus
II MISE EN PLACE D’UN RESEAU FASTER R-CNN 
II.1 PREPARATION DE L’OUTIL DE TRAVAIL
II.1.1 L’environnement de travail
II.1.2 Mise en œuvre du Faster R-CNN : exemple des cellules dans le sang
II.1.2.1 Présentation de la structure du dossier contenant l’architecture Faster R-CNN
II.1.2.2 Présentation du jeu de données
II.1.2.3 Compréhension des paramètres du code
II.1.2.4 Les valeurs de sorties obtenues à la fin de l’entraînement
II.1.2.5 Difficultés rencontrées pour exécuter l’entraînement
II.1.2.6 Les performances du GPU
II.2 CREATION D’UN JEU DE DONNEES POUR LA DETECTION ET LA RECONNAISSANCE DES CHIFFRES MANUSCRITS DANS DES CARTES ANCIENNES
II.2.1 Les imagettes utilisées
II.2.2 Le fond de l’image
II.2.3 Prétraitement des imagettes avant leur insertion dans l’image
II.2.4 Insertion des imagettes dans l’image
II.2.5 Enregistrement des étiquettes dans un tableur
II.3 ADAPTATION DE L’ARCHITECTURE FASTER R-CNN A LA RECONNAISSANCE DES CHIFFRES
MANUSCRITS DANS LES CARTES ANCIENNES
II.3.1 Les paramètres du fichier config.py
II.3.2 Les paramètres de la ligne de commande
III ANALYSE DES RESULTATS
III.1 OPTIMISATION DES PARAMETRES POUR L’ENTRAINEMENT
III.2 PREPARATION DES PLANCHES CADASTRALES
III.3 ANALYSE DES RESULTATS OBTENUS ET PERSPECTIVES
Conclusion 
Bibliographie 
Table des annexes 
Annexe 1 Notice de démarrage du Faster R-CNN 
Liste des figures 
Liste des tableaux 

Lire le rapport complet