Académique Documents
Professionnel Documents
Culture Documents
Thème Mémoire :
Présenté par :
DEDICACE....................................................................................................................................II
AVANT-PROPOS ....................................................................................................................... IV
I. DEFINITIONS............................................................................................................................... 14
II. PRESENTATION DES DONNEES ............................................................................................ 22
III. PREPROCESSING ....................................................................................................................... 27
IV. IMPLEMENTATION ET RESULTATS .................................................................................... 28
Partie 3 : OCR ............................................................................................................................. 36
I. DEFINITIONS............................................................................................................................... 38
II. PRESENTATION DES DONNEES ............................................................................................ 38
III. PREPROCESSING ....................................................................................................................... 39
IV. IMPLEMENTATION ET RESULTATS .................................................................................... 39
CONCLUSION GENERALE ..................................................................................................... 43
WEBOGRAPHIE ......................................................................................................................... 44
Ce mémoire s’inscrit dans le cadre du stage de fin d’étude du Master en Data Science – Big
Data au sein de l’International Data Science Institute. Il constitue une occasion de mettre en
application les compétences techniques acquises durant le parcours d’études sur un problème réel
d’entreprise. Pour cela, il nous a été demandé de réfléchir sur la reconnaissance d’Images de
documents suivie de la reconnaissance textuelle sur des documents d’identités. En plus de la
consolidation de nos acquis, ce travail permettra à l’entreprise de disposer de moyens permettant
le développement d’applications plus intelligentes facilitant les interactions entre le client et sa
maison d’assurance. Les difficultés rencontrées dès le début de ce stage nous ont très vite appris à
être beaucoup plus autonome, ouvert d’esprit et structuré dans le travail. En clair, cette expérience
de stage a été beaucoup formatrice pour nous car elle s’est effectuée à distance, dans une structure
qui pour nous, dispose d’une nouvelle manière de travailler (utilisation de la méthode agile).
Cg : Carte grise
RN : Réseaux de neurones
ML : Machine Learning
Pc : Permis de conduire
Ce mémoire se subdivise en deux parties essentielles que sont d’une part, la reconnaissance
d’images et d’autre part, l’extraction de textes sur des documents d’identités : cas de la carte grise.
Dans l’exécution de cette tâche, nous nous sommes heurtés à un faible volume d’images et un
manque de GPU sur notre poste de travail, rendant ainsi lent l’exécution de cette tâche.
Dans la deuxième partie de notre travail, nous utilisons essentiellement la bibliothèque OpenCV
de python pour le traitement de nos images (gestion des contours de l’image, réduction des bruits,
seuillage, etc. …). Ensuite nous isolons les parties de l’image dont nous voulons extraire une
information textuelle et grâce à la bibliothèque Pytesseract de python, l’information pertinente de
cette image est extraite sous forme de texte.
Souvent dans le corpus d’un document PDF, certaines pages présentent plusieurs pièces. Dans ce
cas, avant toutes actions, nous décomposons le document en sous-documents contenant chacun une
seule pièce, grâce à une détection de contours. Cette opération permet de faciliter le processus
d’extraction de caractères sur la pièce dont le résultat est fortement tributaire de la qualité des
images.
Malgré tout, la mise en place d’applications pour la souscription d’un contrat d’assurance depuis
son domicile devient possible car disposant d’un moyen permettant en back de vérifier la nature et
la conformité (ou l’exactitude) des documents fournis par le client à chaque champ.
For image recognition, it is a question of implementing a range of algorithms, in this case the
algorithms of Deep Learning models for the classification of images. We train on the one hand a
set of algorithms to classify images which contain identity documents of other images and on the
other hand a set of algorithms allowing to categorize the images of identity documents (CNI,
permits of driving, gray card). On both sides, we choose the best model. These two models, coupled
with the edge detection algorithm, allow us to perform this first task of recognizing part images in
a PDF document with a performance of over 96%.
In performing this task, we encountered low image volume and a lack of GPUs on our workstation
making it slow to complete this task.
In the second part of our work, we mainly use the python OpenCV library for the processing of our
images (management of image contours, noise reduction, thresholding, etc.). Then we isolate the
parts of the image from which we want to extract textual information and thanks to python's
Pytesseract library, the relevant information from that image is extracted as text.
Often in the document corpus (a document is a PDF of several pages), some pages of some
documents have several parts. In this case, before any actions, we break down the document into
several, each containing a single part, thanks to an outline detection. By doing this, our algorithm
gives the information of the different parts present in the document. This operation makes it
possible to use the different parts present separately and thus facilitate the process of extracting
characters from the part. These extraction operations are done with many errors given the quality
of the images.
However, the implementation of applications for the subscription of an insurance contract from
his home becomes possible because it has a means to verify the nature and the veracity of the
documents provided by the customer in each field.
Ces différents canaux suscités ont d’une manière ou d’une autre façonné le quotidien voire le
naturel d’un bon nombre de personnes. Par soucis d’innovation et de réponse aux besoins actuels
des clients, c’est tout naturellement que les entreprises cherchent sinon entreprennent le
développement de nouveaux moyens techniques équipés de systèmes intelligents répondant le plus
aux nouveaux besoins du consommateur. Pour cela les entreprises comptent tirer parti des données
produites par leurs clients afin de fournir des services facilitant et améliorant l’expérience client à
travers des systèmes intelligents se renforçant grâce aux données. Ainsi, dans le cas de SAHAM
ASSURANCE MAROC la reconnaissance d’images et la détection optique de caractères est au
centre des réflexions pour la fiabilisation des documents échangés et la facilitation du processus de
souscription aux contrats d’assurance.
Ce passage à des systèmes plus intelligents pour améliorer le business fait inévitablement intervenir
l’Intelligence Artificielle (IA) plus précisément le Deep Learning. Cette dernière méthode a montré
son efficacité dans le traitement des images et leur classification au fil des années lors des
différentes éditions du concours annuel : ILSVRC1.
C’est dans ce contexte que le thème intitulé : Reconnaissance d’images suivi d’OCR nous a été
attribué dans le cadre de notre stage de fin d’étude du Master en Data Science – Big Data. Au terme
de ce stage, SAHAM ASSURANCE disposera en interne de sa solution pour les tâches de
reconnaissance d’images et d’OCR. Ce qui lui donnera une autonomie vis-à-vis des solutions
externes mais aussi lui permettra financièrement de faire des économies.
1
ImageNet Large Scale Visual Recognition Challenge ou "Compétition ImageNet de Reconnaissance Visuelle à
1
Grande Échelle
Figure 1 : logo_saham
En octobre 2018, Sanlam, premier groupe d’assurance en Afrique avec une capitalisation
boursière de 16 milliards de dollars, a procédé à l’acquisition de la totalité des filiales Saham
Assurance du groupe SAHAM, en augmentant sa participation de 46,6% à 100% dans le capital de
Saham Finances.
Sanlam est un groupe financier de référence qui est coté sur le JSE Limited (Bourse de
Johannesburg) et sur le Namibian Stock Exchange (Bourse de la Namibie).
Fondé en 1918 en tant que compagnie d'assurance vie, le groupe Sanlam, basé en Afrique du Sud,
s'est par la suite transformé en une entreprise de services financiers diversifiés.
Le groupe développe des solutions financières complètes et personnalisées au profit des clients
particuliers et institutionnels dans tous les segments du marché, et ce, à travers l’ensemble de ses
pôles d'activités : Sanlam Personal Finance, Sanlam Emerging Markets, Sanlam Investments,
Santam et la société nouvellement créée Sanlam Corporate. Les domaines d’expertise du groupe
incluent l’assurance (vie et générale). Le groupe opère dans l'assurance, l’ingénierie financière, la
retraite, les fiducies, les testaments, les dommages, la gestion d'actifs, la gestion des risques, les
activités de marchés de capitaux et la gestion de fortune.
Au Maroc, SAHAM Assurance devenu membre du groupe Sanlam Pan Africa est leader dans le
domaine de l’assurance Non-Vie, N°1 de l’Automobile et de la Santé.
Avec plus de 481 agents généraux, SAHAM Assurance dispose du réseau exclusif le plus étendu
au Maroc, lui permettant d’assurer une présence régionale très forte et de développer au mieux une
politique de proximité avec l’ensemble de ses clients.
Ainsi, partant du constat que le comportement du client évolue rapidement, et qu’il y a une
impérieuse nécessité de placer l’assuré au cœur des process de la compagnie, la Digital Factory a
été créée dans l’objectif principal d’offrir la meilleure proposition de valeur, en s’appuyant pour
cela sur l’innovation, le travail collaboratif et la méthode Agile.
Espace collaboratif par excellence, la Digital Factory regroupe des équipes aux profils
pluridisciplinaires engagées autour de la transformation globale de la Compagnie. C’est ainsi que
des experts métier planchent aux côtés de jeunes développeurs, de « Scrum Masters », « Experts
de la donnée » et autres profils formés aux dernières technologies.
La Digital Factory se veut ‘Customer centric’ et proactive pour livrer des produits efficaces et utiles
pour les métiers en un temps beaucoup plus court. Pour cela, en plus des compétences recrutées et
de leurs expériences, elle mise sur une approche organisationnelle du travail : L’agilité2 à travers
la méthode Scrum3.
Pour cela, elle est subdivisée en plusieurs équipes scrum (squads) chargées de missions bien
précises et travaillant en synergie sur des projets. En plus des squads, une équipe managériale dite
transverse assure le management global de tous les projets au sein de la Digital Factory.
Data Fraude
Equipe Transverse
Sinistres Business
Figure 2 : schema_organisationnel
2
Est un ensemble de pratiques de pilotage et de réalisation des projets prônant quatre valeurs fondamentales que sont
5
les individus et leurs interactions, être à même de fournir des logiciels opérationnels, la collaboration constante avec
l’utilisateur final et l’adaptation au changement.
3
Méthodologie de l’agilité se caractérisant par les éléments fondamentaux que sont la définition des rôles, les
évènements(meeting), les artefacts (le plan de réalisation de l’objectif général, des objectifs spécifiques et comment
l’on suit ces évolutions jour après jour), et les règles.
Cette équipe est focalisée sur la partie acquisition des clients, en charge de transformer l'Entrée en
Relation, l'expérience de souscription des clients (comme permettre aux clients de souscrire aux
contrats d’assurances depuis leurs domiciles) et de mettre en place le modèle opérationnel de
gestion du renouvellement.
➢ Sinistres
Cette équipe a la charge de transformer la gestion des sinistres, aussi bien à travers la refonte de la
gestion des parcours et de celle des sinistres matériels et corporels, que dans la structuration de
l'écosystème de partenaires (par ex. garagistes, experts automobiles, avocats, ...), afin d'améliorer
l'expérience client final tout en réduisant les coûts.
➢ Fraude
Cette équipe a la charge de transformer la gestion de la Fraude chez Saham, aussi bien la fraude
sur sinistres matériels, sur sinistres corporels que fraude à la souscription.
➢ Data Factory
Cette équipe a la charge d’être une source de valeur fondamentale de la Digital Factory. Elle met à
disposition l'ensemble des données à chaque use-case pour exposer les données, faciliter la prise
de décision (reporting, business intelligence) et créer de l'intelligence métier (Advanced Analytics
/ Machine Learning).
• un Scrum Master
• Un Product Owner (ou propriétaire du produit en français)
• Une équipe de développement
Le Scrum Master est responsable de la compréhension, de l'adhésion et de la mise en œuvre de la
méthode Scrum qu'il maîtrise parfaitement. C'est un facilitateur qui aide à améliorer la
communication au sein de l’équipe et cherche à maximiser la productivité et le savoir-faire de celle-
ci. Il est considéré comme le coach de l'équipe de développement.
Le Product Owner porte la vision du produit à réaliser. Il travaille en interaction avec l’équipe de
développement qui doit suivre ses instructions. C'est lui qui établit la priorité des fonctionnalités à
développer ou à corriger, et qui valide les fonctionnalités terminées. Il est responsable de la gestion
du Product backlog (ou carnet de produit en français).
L'équipe de développement est chargée de transformer les besoins définis par le Product Owner
en fonctionnalités utilisables. Elle est pluridisciplinaire et possède toutes les compétences
nécessaires pour réaliser le projet, sans faire appel à des prestations externes. Il n'y a pas de notion
de hiérarchie, toutes les décisions sont prises ensemble.
b. Evènements Scrum
La vie d'un projet Scrum est rythmée par un ensemble de réunions définies avec précision et
limitées dans le temps.
Un Sprint est un intervalle de temps maximum pendant lequel une version terminée et utilisable du
produit est réalisée. Chaque sprint a un objectif et une liste de fonctionnalités à réaliser.
Les tâches à accomplir pendant le Sprint sont déterminées par l'ensemble de l'équipe Scrum lors de
la réunion de planification de Sprint. La durée de cette réunion est limitée à 8 heures pour les
Sprints d'un mois. Cette réunion permet à l'équipe d'établir les éléments qu'elle traitera au cours de
ce Sprint et comment elle procédera.
Il s'agit du bilan du Sprint réalisé. Une fois le Sprint terminé, l'équipe Scrum et les parties prenantes
se réunissent pour valider ce qui a été accompli pendant le Sprint.
Le but est l'adaptation aux changements qui peuvent survenir et l'amélioration continue du
processus de réalisation.
Cette réunion quotidienne de 15 minutes est très importante. Il peut en avoir deux c’est-à-dire une
en début de journée et l’autre en fin comme c’est le cas au sein de la Digital Factory. Le but est de
faire un point sur la progression journalière du Sprint. Elle permet à l'équipe de synchroniser ses
activités et de faire un plan pour les prochaines 24 heures. Chaque membre de l'équipe de
développement doit répondre à ces trois questions :
C'est le plan détaillé de la réalisation de l'objectif du Sprint, défini lors de la réunion de planification
du Sprint. Le Sprint backlog est mis à jour régulièrement par l'équipe afin d'avoir une vision précise
de la progression du Sprint.
➢ L'incrément
Il s'agit de l'ensemble des éléments terminés du Product backlog pour le Sprint en cours, ainsi que
ceux des Sprints précédents. L'incrément doit fonctionner et être utilisable.
Ce graphique simple indique l'état d'avancement dans la réalisation des tâches du Sprint backlog.
Le Burndown Chart est actualisé tous les jours par le Scrum Master après la mêlée quotidienne.
Dans le cas de la Digital Factory une application « Jira Software » permet d’avoir pour chaque
membre de l’équipe, une visibilité de ses tâches à accomplir, ses tâches en cours et celles qui
doivent être testées ou validées et donc considérées comme achevées.
Dans cette partie, nous décrivons l’environnement de travail c’est-à-dire le matériel physique et le
software à disposition dans lequel nous avons évolué tout au long de ce stage. Aussi, nous mettons
en lumière l’existant en matière de solutions pour la reconnaissance d’images et d’OCR. Pour finir
cette partie, nous présentons le cahier de charges qui nous a guidé tout au long de ce stage.
1. Environnement de travail
Le stage devrait initialement se tenir dans les locaux de la Digital Factory de Saham Assurance
Maroc mais pour cause de crise épidémique Covid-19, nous avons effectué notre stage depuis nos
domiciles en Côte d’Ivoire par télétravail. Pour effectuer nos travaux nous avons utilisé nos
ordinateurs portables personnels (Marque : Dell Latitude E6540, Mémoire vive :16Gb,
Processeur : Intel(R) Core (TM) i5-4310M CPU @ 2.70GHz, 2701 MHz). Au niveau logiciel,
nous avons travaillé avec l’IDE Jupyter Notebook, écris nos algorithmes et entrainer nos modèles
grâce au langage de programmation python.
2. Etat de l’existant
La mise en place d’une solution d’OCR et aussi de reconnaissance d’images est un projet de
l’équipe business de la Digital Factory. L’utilisation d’une telle solution est essentielle si l’on veut
proposer des solutions digitales telles les applications pour la facilitation des processus de
souscription aux contrats d’assurance. Pour cela, l’équipe s’est penchée sur une solution externe
de Microsoft Azur pour réaliser les tâches de reconnaissance et vers Kofax pour l’OCR.
Dans le cadre de ce stage, nous avons adopté une solution interne pour éviter la dépendance aux
produits externes qui pourraient constituer une source d’exposition des données à caractère
personnel des clients SAHAM. Dans le même temps réaliser une telle solution en interne, serait
source d’économie pour la société.
3. Objectifs du projet
❖ Benchmark des algorithmes prédictifs permettant la reconnaissance.
❖ Définition des applications de la reconnaissance d’images sur le parcours client assurance
automobile (souscription -gestion du sinistre-gestion de la fraude-Production automobile…)
Figure 3: logo_reconnaissance
1. Machine Learning
Le machine Learning (apprentissage automatique en Français) est une discipline de
l'intelligence artificielle qui se fonde sur des approches mathématiques et statistiques pour donner
à l’ordinateur, la capacité d'« apprendre » à partir de données qu’on lui fournit. Elle se constitue de
plusieurs types d’apprentissage que sont : l’apprentissage supervisé, l’apprentissage non-supervisé
et l’apprentissage par renforcement.
Figure 4: logo_ml
a. Apprentissage supervisé
C’est une méthode dans laquelle la fonction d’apprentissage est construite sur un ensemble de
données dont la variable cible est connue en amont. En guise d’exemple, on utilisera une méthode
d’apprentissage supervisé dans le cas où l’on veut mettre en place un modèle de détection de fraude
2. Deep Learning
Le Deep Learning ou apprentissage profond en français est une sous-catégorie du Machine
Learning qui se réfère à un ensemble de techniques et de technologies d’apprentissage automatique,
basées sur les réseaux de neurones artificiels.
3. Computer vision
4. Reconnaissance d’images
La reconnaissance d’images, sous-catégorie de la Computer Vision et de l’Intelligence
Artificielle, représente un ensemble de méthodes de détection et d’analyse d’images.
4
Une ligne de notre jeu de données.
15
Figure 5: logo_rn
Un neurone artificiel est une entité unique du réseau portant une information et permettant la
communication de l’information au sein du réseau. Pour une entrée x = (X1, X2, …, Xn), le neurone
effectue un ensemble d’opérations schématisées ci-dessous.
Figure 6: neurone_simple
c. Fonction de combinaison
Les xi représentent les neurones d’entrée, les wij sont les poids de
connexion et netj la sortie. La fonction de combinaison est utilisée
pour calculer la somme des entrées de la manière suivante :
𝑁
d. Poids de connexion
Un poids de connexion quantifie l’information échangée entre deux neurones d’un réseau.
Les valeurs des poids des couches sont apprises par rétropropagation du gradient : on calcule
progressivement pour chaque couche, en partant de la fin du réseau, les paramètres qui minimisent
la fonction de perte régularisée.
e. Fonction d’activation
La fonction d'activation est une fonction mathématique appliquée à un signal en sortie d'un
neurone artificiel. Considérons un neurone avec N cellules en entrée notées Ci : 1 ≤ i ≤ N et N poids
de connexion wij (connexion entre le neurone i de Ci et le neurone j), pour obtenir la valeur Y.
En sortie, on utilise une fonction d’activation qui peut être de plusieurs types. Le choix de la
fonction d'activation dépend de l'application. Ci-après quelques fonctions d’activation.
Figure 7: fonction_sigmoide
ⅇ𝒛 𝒋
𝝈(𝒛)𝒋 =
∑𝒌=𝟏 ⅇ𝒛𝒌
𝒇(𝒙) = 𝒙+ = 𝒎𝒂𝒙(𝒙, 𝟎)
Où x représente la sortie d’un neurone. Cette fonction est appelée le redresseur. Les unités
linéaires rectifiées, par rapport à la fonction sigmoïde ou à des fonctions d'activation similaires,
permettent un apprentissage plus rapide et efficace des architectures neuronales profondes sur
des ensembles de données volumineux et complexes.
Figure 8: fonction_relu
Figure 9: exemple_de_convolution
Padding est une opération qui consiste à ajouter des bordures à une image. Dans la plupart des cas,
on ajoute des zéros pour constituer la bordure. Cela permet après plusieurs opérations de
convolutions, de conserver sinon limiter la réduction de dimensions de l’image. Ci-dessous un
exemple d’une image de dimension 4x4 avant et après le Padding.
ii. Strides
Le paramètre stride se comporte comme le pas de convolution. Nous donnons l’exemple ci-dessous
pour illustration.
Stride = 1
Stride = 2
Le noyau de la convolution est une petite image permettant de réaliser l’opération de convolution.
Elle peut être de n’importe quelle taille selon les cas de figure.
Exemple :
• 3x3
• 21 x 21
d. Transfer Learning
Au cours de notre étude nous procédons à l’augmentation des images. Pour cela de chaque image,
on en tire plusieurs via des opérations de transformation telles que la rotation dans plusieurs angles,
un floutage, un zoom, un filtrage, etc… Cette opération a pour but de fournir un peu plus d’images
à nos modèles pour améliorer leur apprentissage.
2. Pour la construction du modèle permettant d’indiquer ou non la présence d’u
document d’identité (Modèle 1)
Pour cette première partie nous décrivons la structuration des données pour la mise en place du
modèle indiquant la présence d’une pièce d’identité sur une image. Pour cela, nous organisons nos
différentes images dans des dossiers selon la structure suivante :
Data
ot
id
*ot : contient les images de tout types ne contenant pas de pièces d’identité.
Cette structuration a pour but de faciliter la labellisation de nos différentes images et donc de
construire les modèles plus aisément.
Les images sont de types couleur et blanc noir dont la taille minimale des images est de 149×96×3
et une taille maximale de 1700×2337×3.
ot 284 6532
id 224 5152
Total 508 11684
Dans cette partie, notre corpus de documents est composé essentiellement d’images de documents
administratifs en l’occurrence d’images de Carte nationale d’Identité CNI, de carte grise, de permis
Data
*Chaque sous dossier contient les images du type indiqué par le nom de celui-ci.
Les images de notre base sont de types couleur ou blanc et noir et ont une taille minimale de 86×
146×3 et une taille maximale de 2339×1702×3.
CNI 60 1380
Carte grise recto 20 460
Carte grise verso 19 437
Permis de conduire 14 322
Autres documents 273 6279
Total 386 8878
III. PREPROCESSING
1. Construction des ensembles : d’apprentissage et de test
Pour faciliter l’utilisation des images dans nos différents algorithmes nous mettons en place un
certain nombre de traitements. Dans un premier temps nous chargeons l’ensemble de nos images
dans notre environnement de développement (dans python) nous redimensionnons les images sous
un format unique pour les remettre sous un format uniforme. Dans un second temps, nous
transformons ces images en des tableaux. Ceci fait, la concaténation des tableaux de toutes les
images constitue l’entrée de nos algorithmes. Il est aussi important de souligner que les images
sont concaténées par catégorie. Ainsi, l’ensemble constitué est par la suite subdivisé pour
l’apprentissage et pour le test.
La structuration de la base telle que définie ci-dessus, permet de labelliser de façon très aisée notre
base de données. Nous codons par « 0 » une carte grise verso, par « 1 » une carte grise recto, par
« 2 » un permis de conduire, par « 3 » une CNI et « 4 » pour les documents de tout autre type. Par
suite, on crée un vecteur pour chaque classe d’images, de longueur le nombre d’images contenues
dans cette classe. Ainsi, notre variable Y est construite en additionnant ces vecteurs.
Dans cette première partie de notre travail dédiée à la reconnaissance d’images de documents
d’identité dans un PDF, nous avons implémenté un script sous forme d’API qui comprend deux
modèles de CNN (modèle 1 et modèle 2) et un algorithme de détection de contours pour l’extraction
des images de pièces présentes sur une image.
Tout d’abord, en entrée du script nous prenons un document PDF de plusieurs pages. Ensuite nous
convertissons chacune des pages en des images qui passeront dans le modèle 1 en vue de vérifier
si elles contiennent ou non un document d’identité. Si non, l’image est abandonnée. Dans le cas
contraire, l’image passe dans un script de détection de contours qui repère les pièces en présence
sur l’image. Enfin via le modèle 2, on identifie et enregistre les pièces telles que la carte grise face
recto, la carte grise face verso et la CIN.
P0.jpg
P1.jpg
P2.jpg
A cette étape de l’algorithme, chaque page du document PDF est transformée en image. Les figures
24 et 25 donnent l’illustration avec une page du PDF. Elle est réalisée à l’aide d’un script python.
ii. Modèle1
Comme l’illustre la figure 23, le modèle 1 intervient dans l’algorithme pour classer les images
contenant au moins une des pièces d’identité (CNI, Carte grise, Permis de conduire) et celles qui
iv. Modèle 2
Le modèle 2 est un modèle de classification dont le but est de donner la classe de l’image en
entrée. Les différentes classes sont : CNI, carte grise recto, carte grise verso, permis de conduire
et nous mettons dans une classe « autres » les images dont la catégorie n’est pas dans celles citées
précédemment.
v. Enregistrement des pièces
A cette étape d’enregistrement des pièces, l’algorithme sélectionne comme CNI l’image respectant
ces deux conditions suivantes : celle ayant une probabilité supérieure à 95% d’être une CNI et
Au regard du fait que le volume d’images mis à notre disposition est très petit, nous avons planché
sur l’utilisation du Transfer Learning. Ces architectures nous permettent bien que disposant de peu
d’images, d’arriver à en extraire les caractéristiques de celles-ci. Cela est possible à cause du
nombre élevé de couches cachées et de paramètres.
Pour lutter contre le surapprentissage, après avoir récupérer les modèles par Transfer Learning nous
ajoutons des couches de dropout supplémentaires et des couches denses. Dans le cas de
l’InceptionResnet (le modèle présentant le meilleur score), on a apporté la modification suivante
au modèle récupérer :
a. Modèle 1
Tableau 4: resultat_modele1
b. Modèle 2
Tableau 5: resultat_modele2
Au vu de ces résultats, nous avons retenu aussi InceptionResNetV2 pour le modèle 2 pour la nature
des pièces présentes sur une image.
L’algorithme met environ 3 minutes à s’exécuter. Ce temps est relativement long mais s’explique
par les deux modèles qui sont appliqués. Ces modèles sont des architectures très lourdes, ce qui
met du temps pour les charger dans l’environnement logiciel de notre ordinateur portable. Malgré
cet inconvénient d’être chronophage, nous avons été obligés de recourir à ces architectures du fait
de la petite taille de notre corpus d’images.
Le tableau 6 présente les résultats de la détection de contours qui permet d’extraire les pièces d’identité.
Tableau 6 : resultat_detction_contours
Nombre 60 2 0 62
Pourcentage 96,67% 3.33% 0% 100%
Conclusion
Au terme de cette première partie, nous proposons un livrable sous forme d’API résumant le
process de reconnaissance d’images. Toutefois, si un corpus d’images plus important est mis à
notre disposition, nous pourrons construire aisément une architecture moins lourde en termes de
nombres de paramètres. Ce qui aura le bénéfice de réduire considérablement le temps d’exécution
de l’algorithme.
Cette deuxième partie de notre étude est dédiée à l’extraction d’informations textuelles sur une
image. Pour cela, nous mettons en œuvre, après avoir chargée l’image sur laquelle nous voulons
extraire les informations textuelles un ensemble de traitements de l’image facilitant la lisibilité des
caractères présents sur l’image. Par suite, nous passons à l’extraction des caractères proprement
dite via l’outil d’OCR open source de python « Pytesseract ». Cette étude est très importante en ce
sens qu’elle permettra de préremplir des champs d’un formulaire à partir d’informations extraites
sur une image d’un document d’identité téléchargé ou enregistré.
L’OCR renferme tous les procédés informatiques utilisés pour la reconnaissance de texte sur une
image et sa traduction en texte.
2. Seuillage
Le seuillage est une opération de binarisation de l’image. Elle vise à fixer un seuil, et à faire passer
tous les pixels de l’image au-dessus du seuil à 1 et à 0 les pixels en dessous du seuil. Cela permet
d’avoir une image en blanc et noir permettant ainsi la mise en évidence des lettres sur l’image.
Nous avons écrit une API prenant en paramètre le chemin de notre image et le champ que l’on veut
extraire, puis nous ramène la valeur du champ. Les grandes étapes du script sont résumées par le
schéma ci-dessous dans le cas de l’extraction du champ numéro de châssis :
a. Illustration
1. Redressement + elimination de contours
Cette étape permet de placer la pièce de façon totalement horizontale pour faciliter au maximum la
lecture des caractères.
2. Prétraitement
Les prétraitements sont essentiellement les opérations de transformations en nuances de gris, de
seuillage et d’élimination de bruits.
Pytesseract extrait toutes les informations textuelles sur tout le verso de la carte grise. Pour
identifier la valeur du champ numéro de châssis, nous recherchons parmi tous les caractères
extraits, la chaine la plus proche de « Numéro du châssis » via un calcul de similitude à l’aide de
la bibliothèque fuzzymatch de python. Dès qu’une telle chaine est trouvée, la suivante dans la liste
des caractères extraits est le numéro recherché. Si cette chaine n’est pas trouvée on recherche juste
la chaine de caractère de longueur 17. En effet le numéro de châssis est de longueur 17 et est
probablement le seul numéro d’une telle longueur.
▪ Type de carburant
Pour l’extraction de ce champ, on détermine la chaine la plus similaire à « diesel » et on enregistre
le score de similitudes. On fait le même travail avec « essence ». Des deux résultats obtenus on
retient le meilleur score. Ainsi le type de carburant retourné est celui d’entre essence ou carburant
qui a matché avec le plus gros score une chaine de caractère de la liste retournée par Pytesseract.
3. Résultats
Les résultats suivants ont été obtenus après les différentes démarches pour les différents champs
explicitées ci-dessus..
Tableau 7 : resultat_extract_chassis_num
*NB :
• 388 = 22 x 17 + 2 x7.
• « 22 » représente le nombre de cartes grises dont la longueur du numéro de châssis est de
17.
• « 2 » représente le nombre de cartes grises dont la longueur de numéro de châssis est de
longueur 7.
b. Type de carburant
c. Marque
Tableau 9 : resultat_extract_brand_field
Tableau 10 : performance_algo_redressement
Conclusion
En conclusion de cette partie, nous avons proposé une solution d’OCR qui gère l’extraction des
champs que l’on souhaite sur le verso de la carte grise. Cette extraction est gérée au cas par cas. Il
est bon de noter que l’extraction des caractères se fait presque tout le temps avec des erreurs, mais
nous réduisons ces erreurs avec l’ensemble des traitements évoqués plus haut.
Au terme de cette étude, nous retenons que notre thématique « Reconnaissance d’images suivie
d’OCR » a été traitée dans son entièreté.
D’une part, nous avons travaillé à la mise en place d’un algorithme capable de prendre en entrée
un document PDF et de faire ressortir exactement les pièces d’identités qui y sont contenues. Cela
s’est fait par la mise en place de deux modèles de reconnaissance d’images de très bonnes
performances, d’un algorithme de détection de contours efficace sur toutes les qualités de
documents, et d’un algorithme qui détecte l’inclinaison des documents d’identités contenus dans
le PDF, les redresse et les enregistre dans un dossier. Notons que dans le cas de l’algorithme de
reconnaissance de documents, l’axe d’amélioration reste le temps d’exécution qui peut être résolu
par l’utilisation de machines disposant de GPU mieux adapté pour le traitement d’images.
D’autre part, nous avons travaillé à la mise en place d’une solution permettant de faire l’OCR sur
le verso d’une carte grise. Pour ce faire, nous mettons en œuvre plusieurs méthodes de traitements
d’images telles que la conversion de l’image en niveaux de gris, le seuillage et l’élimination de
bruits. De plus, selon le champ à extraire, certaines parties de l’image sont abandonnées pour
focaliser les efforts de notre outil d’OCR sur la zone d’intérêt. Cela améliore considérablement les
performances de notre système. Après avoir effectué les traitements et réalisé l’extraction des
informations textuelles, nous mettons en œuvre le processus de recherche de l’information
pertinente en identifiant la chaine de caractères la plus probable. Cela est possible par un calcul de
similitude entre le nom du champ et les caractères retournés par notre outil d’OCR. Puis, les erreurs
au niveau de certaines lettres mal prédites sont corrigées pour optimiser les résultats. L’axe
d’amélioration de cette solution serait d’accroitre la robustesse en augmentant le nombre des
images pour permettre d’effectuer davantage de tests.
Les deux solutions proposées ont été transformées en API pour la portabilité du code.
Au cours de ce stage, les difficultés majeures ont été l’accès aux données, à cause de leur caractère
confidentiel et de leur faible quantité. Néanmoins, nous avons rempli les exigences du cahier de
charges. Par ailleurs, ce projet a été en tous points très enrichissant pour nous. En effet, il nous a
permis d’élargir nos connaissances en Deep Learning, en traitement d’images et d’apprendre sur
l’OCR et la mise en place d’API.
AVANT-PROPOS ....................................................................................................................... IV
I. DEFINITIONS............................................................................................................................... 14
1. Machine Learning ....................................................................................................................... 14
2. Deep Learning ............................................................................................................................. 15
3. Computer vision ........................................................................................................................ 15
4. Reconnaissance d’images ........................................................................................................... 15
5. Réseaux de Neurones ................................................................................................................. 16
6. Réseaux de neurones convolutifs .............................................................................................. 19
II. PRESENTATION DES DONNEES ............................................................................................ 22
1. Augmentation de données ......................................................................................................... 22
I. DEFINITIONS............................................................................................................................... 38
1. OCR ............................................................................................................................................ 38
2. Seuillage...................................................................................................................................... 38
II. PRESENTATION DES DONNEES ............................................................................................ 38
III. PREPROCESSING ....................................................................................................................... 39
IV. IMPLEMENTATION ET RESULTATS .................................................................................... 39
1. Implémentation .......................................................................................................................... 39
2. Résultat ....................................................................................................................................... 41
CONCLUSION GENERALE ..................................................................................................... 43
WEBOGRAPHIE ......................................................................................................................... 44