SlideShare une entreprise Scribd logo
Rapport de soutenance
EPITA•2014-2015KhairosGroup
Chady DIMACHKIE
Guillaume AIGUEPERSE
Alexandre SOBRAL MARTINS
Jerry MAILLOT
OpenCR Page 2 sur 42
Sommaire
1 Introduction 3
2 Le groupe 4
2.1 Chady DIMACHKIE . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Guillaume AIGUEPERSE . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Jerry MAILLOT . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.4 Alexandre SOBRAL MARTINS . . . . . . . . . . . . . . . . . . . 5
3 Prétraitement de l’image 6
3.1 Filtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.2 La convolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.3 Binarisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.4 Rotation de l’image . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4 Extraction des caractères 14
4.1 Détection des blocs de texte . . . . . . . . . . . . . . . . . . . . . 14
4.2 Détection de caractères . . . . . . . . . . . . . . . . . . . . . . . . 18
4.3 Remarque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5 Réseau de neurones 20
5.1 Modèle de Hopfield . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.2 Learning Vector Quantization . . . . . . . . . . . . . . . . . . . . . 25
5.3 Choix du réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
6 Interface Graphique 32
7 Optimisations 33
8 Site Internet 35
9 Conclusion 36
Annexes 37
A Signification des barres de couleurs 37
B Références 38
KHAIROS GROUP 2
OpenCR Page 3 sur 42
1 Introduction
Dans le cadre du projet de la seconde année nous devons réaliser un logiciel
de reconnaissance de caractères, convertissant une image contenant du texte
en un ficher texte contenant le texte reconnu.
Pour ce faire, nous avons dû nous organiser d’une telle manière à ce que
les tâches soient réparties entre les membres en fonctions de leur niveau et de
leur temps d’adaptation au langage C, qui nous est imposé cette année.
La réalisation du projet a nécessité plusieurs outils qui nous sont fournis
à travers les libraires SDL et SDL_image pour la manipulation de l’image et
le chargement de certains formats d’images. Nous avons également, utilisé
OpenMP, qui nous permet d’exploiter les architecture parallèles multi-coeurs
de nos machines.
Ce projet, nous permettra, en tant que futurs ingénieurs, de pouvoir tra-
vailler en équipe sur des projets qui nécessitent d’être finalisé rapidement, tout
en répondant au besoin premier défini dans le cahier des charges. Le résultat
final devra également avoir un niveau de performances élevé qui reflétera nos
capacités à développer des solutions logicielles bien conçues.
Ainsi, ce projet auquel nous participons tous nous permet de nous améliorer
en tant que développeur, non seulement au niveau technique. mais aussi au
niveau social.
KHAIROS GROUP 3
OpenCR Page 4 sur 42
2 Le groupe
2.1 Chady DIMACHKIE
Cette année, mon statut passe de "simple" membre à chef de projet, ce qui
fait que mes responsabilités sont lourdes. En tant que chef de projet, il est en
mon devoir de coordonner le travail de chaque membre, tout en aidant ceux
ayant des difficultés.
Ce projet est un moyen pour moi d’apprendre à être un meilleur dévelop-
peur, tout en apprenant à gérer une équipe de quatre membres. Ainsi, j’ai appris
à faire avec tout types de problèmes, tout en les gérant de la manière la plus
optimale possible.
Pour le projet, je m’occuperais de la détection de lignes, ainsi que du
réseau de neurones. Bien-sûr, tout en aidant les autres membres à résoudre
leur problème afin de réaliser la meilleur solution possible dans la plus grande
entente.
2.2 Guillaume AIGUEPERSE
Je suis très content de travailler sur ce projet. Le traitement de l’image et ce
qui est proche de ce domaine n’est pas vraiment ce qui m’attirait parmi le vaste
éventail de sous domaines que comportent l’informatique et la programmation.
Ce projet s’est néanmoins révélé intéressant techniquement. J’ai beaucoup
appris jusqu’à présent grâce à ce projet, et à Chady, qui est un chef de groupe
très pédagogue. J’avais vraiment de grosses lacunes en programmation mais
celles-ci se comblent peu à peu, au fur et à mesure que nous avançons dans ce
projet.
Pour ce projet et cette première soutenance j’ai été chargé de mettre en
place un site web et d’assurer la rotation de l’image, manuelle pour l’instant.
L’implémentation d’une rotation automatique est en cours.
KHAIROS GROUP 4
OpenCR Page 5 sur 42
2.3 Jerry MAILLOT
Originaire de l’île de La Réunion, j’ai décidé après l’obtention de mon
BAC scientifique, d’intégrer EPITA malgré les 10 000 km qui me séparent
de ma famille, mes amis... Principalement intéressé par les mathématiques au
collège, à la découverte de l’algorithmie au lycée, j’ai donc fait le choix de
m’orienter vers le domaine informatique. J’ai donc fait un BAC scientifique
avec l’option Sciences de l’Ingénieur et la spécialité maths, la spécialité ISN
étant inexistante dans le lycée où j’étais. Après l’obtention de mon BAC j’ai
décidé d’intégrer une école d’ingénieur en informatique pour pouvoir me
spécialiser le plus tôt possible, mais aussi pour éviter les bancs de la FAC.
Pour ma première année, je l’ai trouvé assez difficile surtout qu’il fallait que je
découvre tout, mais aussi parce que le rythme de travail est monté d’un cran.
Toujours à EPITA, j’aime bien ce que je fais et ça me motive pour continuer.
Cette année, pour ce projet, comme je ne connaissais pas grand monde dans la
classe, on m’a attribué aléatoirement un groupe, le groupe « Khairos Group
» qui me plaît bien. Étant arrivé en retard dans le groupe et n’ayant pas
spécialement de points forts, j’essaye quand même d’apporter mon aide ainsi
que quelques idées...
2.4 Alexandre SOBRAL MARTINS
Selon moi, ce projet semble être un projet légèrement plus professionnel
que le projet que l’on a dû faire en première année. Cette seconde année me
paraît plus intensive en terme de travail, ce qui me semble être en adéquation
avec le projet qui nous a été donné à faire. En effet, faire un OCR m’a semblé
avoir connotation plus professionnelle que de faire un jeu vidéo. Le fait que ce
projet soit à programmer en langage m’a permis de déouvrir un langage qui
est par la même occasion un langage bas niveau.
Le fait de travailler en groupe me permet de combler certaines lacunes, par le
biais de l’aide des membres du groupe.
KHAIROS GROUP 5
OpenCR Page 6 sur 42
3 Prétraitement de l’image
Pour avoir une détections de caractères ainsi qu’une reconnaissance de
ceux-ci, qui soit performante, il nous faut traiter l’image pour qu’elle soit
utilisable dans de bonnes conditions.
3.1 Filtres
Avant même de commencer la binarisation, il faut s’assurer que l’image
soit assez propre, pour cela, on va appliquer plusieurs filtres, tels que le filtre
médian et une matrice de convolution, sur l’image. Avant l’application de tout
filtre et pour avoir de meilleurs résultats après l’application des filtres, on a
remplacé chaque pixels de l’image par son niveau de gris en utilisant pour
chaque pixels la relation :
r + g + b
3
FIGURE 1 – Résultat - Grayscale
KHAIROS GROUP 6
OpenCR Page 7 sur 42
3.1.1 Le filtre médian
Le filtre médian est un filtre qui va permettre de supprimer les bruits dans
des images à niveaux de gris.
La méthode du filtre médian consiste à appliquer une matrice de convolution
3*3 ou 5*5 ou même x*x (à condition bien évidemment que x appartienne aux
entiers naturels et qu’il soit impair) sur chaque pixels de l’image. Pour notre
projet, nous avons privilégié le choix d’une matrice 3*3 car l’application du
filtre avec une plus grande matrice rend l’image un peu floue.
Nous utilisons donc la matrice :





1 1 1
1 1 1
1 1 1





A l’application du filtre médian, on va donc parcourir l’image pixel par pixel et
remplacer chaque pixels par la valeur médiane de ses voisins. Ce qui fait que
pour chaque pixels, on va récupérer l’intensité de ses 8 voisins qui l’entoure
(intensité = moyenne du niveau de rouge, bleu et vert du pixel), classer les 9
valeurs de la liste en ordre croissant à l’aide d’un tri pour pouvoir extraire la
valeur médiane du tableau et ainsi remplacer l’intensité du pixel en question
par celle de la valeur médiane du tableau.
Exemple :
Soit un pixel quelconque d’une image ayant pour niveau de gris 50 et ses
voisins :
58 42 64
41 50 55
52 46 52
Après l’application de l’algorithme de tri, nous pouvons avons donc :
41 42 46 50 52 52 55 58 64
Après l’application du filtre médian, on va donc remplacer l’intensité du pixel
qui était à 50 par l’intensité médiane qui est à 52.
KHAIROS GROUP 7
OpenCR Page 8 sur 42
3.2 La convolution
Dans un traitement d’images, l’application d’un filtre de convolution
consiste à remplacer les valeurs de tous les pixels de l’image par de nou-
velles valeurs qui sont calculées par un produit de matrices.
Pour faire ce calcul, on va donc devoir parcourir l’image pixels par pixels
et pour chacun d’eux, faire leur matrice qui doit être de même taille que la
matrice de convolution.
Exemple :
Soit une image quelconque. Si nous voulons y appliquer la matrice de
convolution permettant d’augmenter le contraste de l’image :











0 0 0 0 0
0 0 −1 0 0
0 −1 5 −1 0
0 0 −1 0 0
0 0 0 0 0











Prenons un pixel quelconque de l’image sur laquelle nous voulons appliquer
cette matrice. Nous aurons par exemple :











35 40 41 45 50
40 40 42 46 52
42 46 50 55 55
48 52 56 58 60
56 60 65 70 75











Nous allons donc faire le produit des deux matrices que l’on divise par la
sommes des valeurs de la matrice de convolution :
⇒
42∗(−1)+46∗(−1)+50∗5+55∗(−1)+56∗(−1)
(−1)+(−1)+5+(−1)+(−1)
⇒
(−42)+(−46)+250+(−55)+(−56)
1 = 51
KHAIROS GROUP 8
OpenCR Page 9 sur 42
Nous allons donc remplacer la valeur du pixel qui est de 50 dans notre cas, par
51.
Nous avons plusieurs types de matrices de convolution différentes qui peuvent
être utilisées selon le besoin de l’utilisateur s’il juge son image assez sale ou
pas assez propre. Selon l’effet qu’il veut donner a son image, il va donc choisir
la matrice de convolution adaptée.
FIGURE 2 – Résultat - Grayscale
3.3 Binarisation
Pour avoir une détections de caractères ainsi qu’une reconnaissance de
ceux-ci, qui soit performante, il nous faut traiter l’image pour qu’elle soit
utilisable dans de bonnes conditions.
Binarisation :
La Binarisation est une étape nécessaire dont dépendent les parties qui
suivent, pour cela il nous faut l’implémenter.
Pour ce faire, nous avons eu le choix entre 3 méthodes.
3.3.1 La méthode classique
Cette méthode que nous allons appeler classique est la méthode la plus
simple à implémenter. Pour ce faire, il nous faut bien évidemment une image
KHAIROS GROUP 9
OpenCR Page 10 sur 42
en niveau de gris, puis on doit parcourir son tableau de pixels et comparer pour
chaque pixels, leurs valeurs avec 128. Si cette valeur est inférieure à 128, elle
est remplacée par 0 et dans le cas contraire, par 255.
3.3.2 Méthode avec le seuil local
Nous avons aussi essayé d’implémenter une méthode qui va calculer un
certain seuil local auquel on va comparer la valeur de chaque pixels et les
modifier selon s’ils sont supérieurs ou inférieurs à la valeur de ce seuil mais
cette méthode conservait beaucoup de bruit dans l’image finale, elle n’a donc
pas été retenue.
3.3.3 Méthode d’OTSU
La Méthode d’Otsu, est une méthode utilisée pour binariser une image.
Il nous faut donc trouver un seuil à partir de la forme de l’histogramme de
l’image. A partir de ce seuil, on va pouvoir binariser l’image en comparant
chaque pixels à la valeur du seuil, si elle est inférieure, on l’a passe à 0 sinon à
255. Pour pouvoir utiliser cette méthode, il faut au préalable que l’image soit
en niveau de gris.
Pour utiliser cette méthode, nous allons procéder sous forme d’etapes :
1. On fait un parcours de l’image pixelspar pixels et on représente la
probabilité de chaque niveau d’intensité dans un histogramme.On aura
donc un histogramme ayant sur l’axe des abscisses, les 256 valeurs
possibles du niveau d’intensité et sur l’axe des ordonnées, la probabilité
d’apparition de ces niveaux d’intensité.
FIGURE 3 – Exemple d’histogramme
KHAIROS GROUP 10
OpenCR Page 11 sur 42
2. On initialise la probabilité d’être à la ième classe et la moyenne de la
ième classe au seuil t = 0. A ce seuil, ωi = 0 et µi = 0
3. On parcours tous les seuils depuis t = 1 jusqu’à t = 255 (niveau d’in-
tensité maximal). A chaque itération, on met à jour ωi et µi puis on
calcule la variances inter-classe à partir de la formule intra-classe.
4. Le seuil avec lequel on va procéder à la binarisation correspond à la
variance inter-classe σ2
b(t) maximale obtenue
Finalement, après application de la binarisation, nous avons un resultat sem-
blable à celui de la figure ci-dessous :
FIGURE 4 – Résultat - Page de livre
KHAIROS GROUP 11
OpenCR Page 12 sur 42
3.4 Rotation de l’image
Pour effectuer la rotation, on utilise simplement une matrice de rotation. Il
suffit de parcourir l’image et pour chaque pixel de coordonnées (x, y), on ap-
plique les formules suivantes, où (cx, cy) sont les coordonnées du pixel central :
cos(α) ∗ (x − cx) + sin(α) ∗ (y − cy) + cx
− sin(α) ∗ (x − cx) + cos(α) ∗ (y − cy) + cy
FIGURE 5 – Avant la rotation
FIGURE 6 – Après la rotation
Lors des essais, il est arrivé que l’image sorte du cadre. La solution était
d’effectuer la rotation en fonction du point central, pour éviter qu’une partie
de l’image ne disparaisse après rotation, ce qui arrivait si la rotation se faisait
KHAIROS GROUP 12
OpenCR Page 13 sur 42
en fonction de l’angle supérieur gauche.
On vérifie aussi pour chaque pixel que nous ne sortions pas des bords de la
matrice, pour éviter de redéfinir un pixel n’importe où.
La prochaine étape est de ne plus avoir à donner un angle manuellement. Il
faut utiliser un algorithme permettant de déterminer l’angle d’inclinaison du
texte, et donc l’angle de correction à appliquer.
Pour détecter l’angle d’inclinaison du texte et le corriger, nous avons choisi
d’utiliser la transformée de Hough, appliquée à une droite. L’intérêt de cette
solution est qu’elle offre un moyen de trouver l’angle d’inclinaison du texte,
en utilisant les coordonnées polaires (rho, theta) plutôt que les coordonnées
cartésiennes de chaque point, et simplifie donc le problème.
On va, pour chaque pixel noir, faire varier theta de 0 à 180 degrés puis
calculer rho en fonction de l’angle theta en radians, et incrémenter l’accumula-
teur pour les valeurs de rho et theta correspondantes. Une fois l’accumulateur
remplit, il ne reste plus qu’à le parcourir en fonction de rho et theta, et chercher
pour quelle valeurs de (rho, theta) l’accumulateur présente la plus grande
valeur.
Cette méthode permet d’obtenir l’angle d’inclinaison du texte, il ne reste
ensuite plus qu’à effectuer une rotation de l’image pour repositionner le texte
correctement.
On a cependant toujours quelques soucis dans quelques cas particuliers,
pour lesquels l’angle trouvé n’est pas le bon.
KHAIROS GROUP 13
OpenCR Page 14 sur 42
4 Extraction des caractères
Dans un OCR, nous avons besoin de reconnaître des caractères. Pour cela,
nous avons besoin d’algorithmes permettant l’extraction de lignes, caractères
et autres blocs.
4.1 Détection des blocs de texte
Tout d’abord, dans le processus d’extraction des caractères, il faut détecter
les lignes. Ce qui veut dire qu’il faut pouvoir stocker toutes les lignes avec
certaines informations qui leurs sont propres.
Nous avions implémenté une méthode de "lancé de rayons". Bien que
celle-ci avait un temps d’exécution très réduit, elle ne fournissait uniquement
de bons résultats, sur des images dont la disposition du texte se rapproche de
celle des pages de ce rapport.
Nous avons donc dû mettre en place une méthode plus performante au
niveau de la détection des blocs de caractères.
Cette méthode consiste à appliquer le Run-Length Smoothing Algorithm
à l’horizontal, puis de détecter et donner un label à toutes les composantes
connexes, pour enfin appliquer un algorithme d’extraction de caractères dans
ces blocs.
4.1.1 Run-Length Smoothing Algorithm
Pour notre méthode, nous devons appliquer le Run-Length Smoothing
Algorithm, afin de connecter tout éléments qui, en formant ensuite un bloc,
nous aideront à isoler les blocs contenant du texte, ainsi que les images.
Le Run-Length Smoothing Algorithm est appliqué à une séquence de
d’éléments binaires, dans laquelle on n’aura que du NOIR ou du BLANC.
Ainsi, l’algorithme suit les règles suivantes :
-Les pixels BLANC deviennent NOIR, en sortie, si le nombre de pixels
BLANC adjacents est inférieur ou égal à une constante C prédéfinie.
KHAIROS GROUP 14
OpenCR Page 15 sur 42
-Les pixels NOIR restent inchangés en sortie.
FIGURE 7 – Run-Lenght Smoothing Algorithm
Cet algorithme a pour effet, de regrouper les zones de pixels NOIR séparés
par moins de C pixels. Le choix de la constante C est important, puisqu’il aide
à regrouper les éléments de telle façon à ce qu’ils y ait des images et du textes
dans des blocs différents.
Bien que cette méthode soit très pratique, elle a également un défaut, puisque le
calcul de la constante C n’est pas facile et de plus, la valeur n’est pas toujours
fiable, de ce fait, après de nombreux tests, nous avons opté pour C = 22.
4.1.2 Connected Components Labeling
Dans cette partie, nous allons devoir étiqueter les blocs isolés, afin de
pouvoir les détecter comme étant une ligne contenant potentiellement des
caractères. Ainsi, il est possible de classifier les éléments de l’image, assez
facilement, dans le but de distinguer les images du texte, pour ensuite stocker
les coordonnées des blocs de texte.
Notre première implémentation était basée sur le fait que l’algorithme est
très facile à mettre en place en utilisant une version récursive.
Celle-ci permettrait, de regarder tous les voisins noirs d’un pixel noir et de
leur donner le même label. Continuant ainsi sur le même bloc, puis sur le reste
de l’image à la recherche de nouveaux blocs.
KHAIROS GROUP 15
OpenCR Page 16 sur 42
Bien que cette méthode soit simple, celle-ci possède certains problèmes,
puisqu’à partir de certaines dimensions, de certaines images, il est très facile
d’avoir un Stack Overflow. On peut contourner la limite de taille de la Stack,
grâce aux fonctions fournies dans "sys/resource.h", mais cette technique n’est
évidemment pas viable, puisque ça ne réglerait pas le problème sur d’autres
images encore plus grandes.
Ainsi, nous avons préféré implémenter une méthode en itératif à deux
passes, c’est-à-dire, qui parcours l’image deux fois.
4.1.2.a Union–Find Data Structure
Les Union-Find (ou Disjoint-Set) sont une structure de donnée comportant
deux opérations, telles que :
-Union : Regroupe deux set (ou classe d’équivalence), en un. -Find : Trouve
le set auquel un élément donné appartient. On peut égaler déterminer si deux
éléments sont dans le même set.
Ainsi, on peut déterminer une relation d’équivalence entre plusieurs élé-
ments.
Cette structure permet de stocker plusieurs classes d’équivalences. Celles-
ci sont stockées sous forme d’une structure arborescente, dans laquelle un
noeud de l’arbre représente un label et pointe vers son noeud père.
FIGURE 8 – Disjoint-Sets
KHAIROS GROUP 16
OpenCR Page 17 sur 42
Tout ceci est fait avec un vecteur PARENT dont les indices forment l’en-
semble des labels possibles et dont les valeur sont les labels des fils du parent.
Les Union-Find, rendent l’algorithme de Connected Components Labeling,
plus efficace. Celui-ci est effectué en deux passes.
La première passe propage le label d’un pixel, juste en dessous, à sa droite,
à sa gauche et au dessus. Lorsqu’on arrive au cas où un pixel peut se voir
attribuer différents labels, il prend le plus petit, et une classe d’équivalence
est créée dans la structure Union-Find. Après cette première passe, toutes les
classes d’équivalences possibles ont été déterminées et ne contient qu’un label
qui est la racine de son propre arbre dans la structure.
Lors de la seconde passe, on effectue une correction en attribuant à chaque
pixel le label de sa classe d’équivalence
FIGURE 9 – Connected Components Labeling
Ainsi, on a toutes nos componsantes connexes séparées, et notre image est
donc classifiée.
4.1.3 Extraction des lignes
Avec tous les traitement effectué, c’est-à-dire, le Run-Length Smoothing
Algorithm à l’Horizontale et la classification de l’image avec l’algorithme de
Connected Components Label utilisant les Union-Finds, on a à notre disposi-
tion un tableau avec toutes les lignes et images sous forme de blocs étiquetés.
KHAIROS GROUP 17
OpenCR Page 18 sur 42
Grace à cela, on va pouvoir trouver les coordonnées de nos lignes.
Il suffit de parcourir le tableau, et pour chaque composante qu’on rencontre,
on cherche le maximum en abscisse, en ordonnée et pareil pour le minimum,
avec cela, on a les équations de quatre droites, qui nous donnent un rectangle
qui entoure notre ligne.
Ainsi, nous avons notre tableau de lignes, qui va nous permettre d’en
extraire les caractères.
4.2 Détection de caractères
La détection de lignes étant fonctionnelle, on peut maintenant détecter les
caractères. Pour cela, on va utiliser une technique similaire de lancé de rayons.
Dans la partie d’avant, nous avons lancé des rayons à l’horizontale pour
les lignes. Pour les caractères nous en lancerons à la verticale. Ainsi, lors de
l’appel de la fonction de détection de caractères, nous lui donnerons la ligne
dans laquelle on veut extraire les caractères. La fonction lancera des rayons du
bas de la ligne vers le haut, c’est-à-dire qu’elle commencera un lancé de rayon
vertical à partir du point P1 et finira à P2, tels que :
P1


Top left abscissa + offset X
Bottom right ordinate


P2


Top left abscissa + offset X
Bottom right ordinate - offset Y

,
où les valeurs maximales de offset X et Offset Y sont respectivement,
Bottom Right Abscissa − Top left abscissa et,
Bottom Right ordinate − Top left ordinate.
Nous suivons le même principe que la détection de lignes, donc on appelle
la fonction plusieurs fois dans la ligne, pour extraire tous les caractères. Nous
obtenons donc :
KHAIROS GROUP 18
OpenCR Page 19 sur 42
FIGURE 10 – Détection de caractères - QCM ALGO
Il faut aussi remarquer, que nous travaillons sur des caractères imprimés,
nous n’avons donc pas besoin de path finding pour séparer deux lettres, sauf
pour l’italique, même si l’algorithme donne d’assez bon résultats en l’état.
4.3 Remarque
Pour l’extraction des caractères, on aurait pu n’utiliser que l’algorithme de
Connected Components Labeling sur l’image, directement sans Run-Length
Smoothing Algorithm. On aurait eu, ainsi, une detection des caractères beau-
coup plus précise, gérant également, l’italique ou autre.
Bien que, cela ait l’air d’une solution, ce n’est pas le cas, puisque qu’elle a
un temps d’execution très long, ce qui ne nous permet pas de considérer cette
méthode comme étant viable.
KHAIROS GROUP 19
OpenCR Page 20 sur 42
5 Réseau de neurones
Pour reconnaître les caractères, nous avons besoin d’un élément permettant
cette reconnaissance. Sachant que l’être humain est le plus apte à lire un
document composé de texte, grâce à son cerveau, la meilleur solution serait une
structure imitant son comportement. Ainsi, les réseaux de neurones artificiels
sont ce qui s’en rapproche le plus.
Un réseau de neurones est un processeur parallèle composé d’unités de
traitements simples, qui a la particularité de stocker les informations apprises
pour les rendre ensuite, utilisables après traitement. Il est similaire au cerveau,
dans la mesure où :
- Il acquiert des informations à partir de son "environnement" grâce à un pro-
cessus d’apprentissage.
- Il a des neurones inter-connectées grâce auxquelles il peut stocker les infor-
mations acquises.
Pour le réseau, nous avons comparé deux modèles que nous avons testés, afin
de décider le plus apte à reconnaître un large nombre de caractères.
Le premier testé est le modèle de Hopfield avec un apprentissage non
supervisé. Le second est le modèle Learning Vector Quantization qui a un
apprentissage compétitif.
5.1 Modèle de Hopfield
Le réseau de neurones de Hopfield est un type particulier de réseau de neu-
rones récurrent qui peut se comporter comme une mémoire auto-associative.
Cette dernière, contrairement aux mémoire habituellement utilisée, qui per-
mettent de trouver un élément grâce à une adresse qui lui est associée, peut
trouver un élément avec une partie, ou même une déformation de celui-ci. Elle
est également appelée mémoire adressable par contenu. Ainsi, on peut très
bien donner une entrée bruitée et retrouver l’élément voulu.
Ce type de réseau est utilisé pour l’association ou la reconstruction d’un
élément depuis un élément proche.
KHAIROS GROUP 20
OpenCR Page 21 sur 42
5.1.1 Caractéristiques du modèle
Nous allons implémenter un réseau de neurones de Hopfield en temps
discret, basé sur une variante du modèle de McCulloch-Pitts.
Dans ce modèle, les neurones ont deux états, l’état "allumé" et l’état éteint,
représentés respectivement par les valeurs +1 et -1. Une paire de neurones i
et j sont liés par le poids wij qui peut être interprété comme étant l’influence
du neurone i sur j (et réciproquement). On a donc W, la matrice de poids telle
que :
Les neurones se mettent à jour de manières asynchrones.
Il y a deux phases dans un réseau de Hopfield, la "phase de stockage" et la
"phase de récupération ". Lors de la première phase, on stocke des caractères
de N-dimensions. Ceux-ci pourront être récupéré lors de la seconde phase
lorsqu’ils auront été donné au réseau en tant que "caractères d’entraînement".
FIGURE 11 – Réseau de Hopfield
5.1.2 Algorithme
Au tout début, on stocke des caractères a1, a2, ..., ap composés uniquement
de +1 ou -1. Ensuite, il nous faut calculer la matrice de poids, pour cela on
utilise la règle d’apprentissage de Hebb, que l’on peut résumer par
KHAIROS GROUP 21
OpenCR Page 22 sur 42
Il faut noter que la matrice de poids a un axe de symétrie, qui est la
diagonale, puisque
Il faut remarquer que wii = 0, signifie que les neurones ne se connectent
pas à eux-même.
On doit ensuite mettre à jour a(k) :
Où sgn est définie comme suit :
Pendant l’itération, si on a :
Alors, on ne continue pas et a est stable, donc, la sortie sera Y = afixed, sinon
on recommence depuis la mise à jour de a(k).
Il est à noté que le réseau a une capacité de stockage de :
KHAIROS GROUP 22
OpenCR Page 23 sur 42
FIGURE 12 – Modèle de Hopfield en temps discret
Où n est la dimension des caractères.
On peut ainsi schématiser un réseau de neurones de Hopfield, de cette
manière :
5.1.3 Convergence vers un attracteur
La symétrique des connexions entre neurones et l’itération pour la mise à
jour du réseau, permettent de démontrer l’existence d’une fonction monotone
au cours de l’itération, nous permettant d’appliquer le théorème de Lyapounov
qui démontre que la période des attracteurs vaut 1. Ainsi, par analogie avec les
systèmes magnétiques (sur lesquels le principe de Hopfield est basé), on peut
définir "l’énergie" d’un état à un certain instant du réseau, par :
Cette valeur est appelée "énergie" car, lors du choix aléatoire des unités à
mettre à jour, cette "énergie" va soit diminuer, soit stagner (Figure 7). Après
plusieurs mises à jour, le réseau convergera finalement vers un état qui est
un minimum local de la fonction de Lyapounov. De ce fait, si un état est un
minimum local de cette fonction, il sera un état stable du réseau, et donc un
attracteur.
La convergence vers un attracteur est généralement assurée puisque Hop-
field a prouvé que les attracteur de son système dynamique non-linéaire sont
KHAIROS GROUP 23
OpenCR Page 24 sur 42
stables. Bien-sûr, les attracteurs ne sont pas les même en fonctions des états
avec lesquels le système a été initialisé.
FIGURE 13 – Bassin d’attraction
5.1.4 En pratique
Pour nos premiers test, nous utilisions 3 lettres (A, B et C) sous forme de
tableaux de −1 ou +1. Il y avait les caractères que le réseau connaissait et ceux
qui étaient dégradés ou bruités, que le réseau devait reconnaître. Le réseau a
eu un taux de réussite très élevé.
Maintenant, nous prenons les caractères extraits depuis l’image et char-
geons un "charset" contenant l’alphabet que doit connaître le réseau. Nous
avons testé avec le "8" et le "T", la reconnaissance fonctionne très bien. L’al-
gorithme partant du principe que l’image à reconnaître a une taille fixe, il faut
donc un algorithme pour re-dimensionner le caractère extrait, ce qui n’est pas
encore implémenté, c’est-à-dire que la taille est fixée pour le moment.
De plus, le réseau de neurones ne fait que converger vers le bon caractère, il
n’est pas capable de nous dire clairement la lettre qu’il viendrait de reconnaître.
Pour palier ce problèmes, nous avons implémenté un système de "signatures".
5.1.4.a Système de signatures
Ce système calcule, pour chaque caractère connu par le réseau, une si-
gnature pour chaque lettre qu’il peut calculer à partir de l’image de celle-ci,
et donc lorsque le réseau converge vers le caractère, il calculera sa signature
et comparera avec le tableau signatures qu’il a déjà calculé, dans lequel on
associe lettre et signature, pour pouvoir déterminer la lettre reconnue, ainsi le
réseau peut associer lettre et pattern.
KHAIROS GROUP 24
OpenCR Page 25 sur 42
Pour ce faire, on a calculé ceci pour chaque caractère :
Signature = I,J
i=0,j=0 ai ∗ (i ∗ I + j), avec I la longueur maximale du carac-
tère et J sa largeur maximale.
5.1.4.b Cas particulier
Il a aussi été remarqué que la limite sur la capacité de stockage pouvait
provoquer la convergence du réseau de neurones vers des états stables différents
de ceux qui sont stocké (Spurious states en anglais), le plus souvent ils étaient
l’inverse du caractère stocké. Ce qu’on peut faire, c’est qu’en calculant la
signature de la lettre, on calcul la signature de son inverse également. De ce
fait, on comparera la signature du caractère reconnu avec la signature de la
lettre de base, ainsi que celle de son inverse. Finalement, on pourra gérer ce
cas particulier, mais seulement en partie puisque parfois il converge vers un
mélange de l’inverse et de l’original.
5.2 Learning Vector Quantization
Le second modèle testé, est le Learning Vector Quantization qui est un mo-
dèle à apprentissage compétitif. Ce modèle se base sur une approche "Winner-
take-all" et un apprentissage de Hebb. Il se compose d’une couche compétitive
suivie d’une couche linéaire.
Ce qui suit va décrire l’architecture du réseau, en commençant par sa
couche compétitive.
5.2.1 Self Organizing Feature Maps
Le système des Self Organizing Feature Maps, aussi appelé "Réseau de Ko-
honen", possède une structure en "feed-forward", c’est-à-dire que les connec-
tions entre neurones ne forment pas de cycle. Ce système possède une couche
nommée "Computational layer" avec un certain nombre de lignes et colonnes.
Chaque neurone est connecté à tous les éléments en entrée.
Le but est d’apprendre une "Feature Map" à partir de l’espace continu des
entrées, pour l’espace discret en sortie, composé de neurones disposés sous
forme de grille.
KHAIROS GROUP 25
OpenCR Page 26 sur 42
FIGURE 14 – Self Organizing Map
L’algorithme se présente sous cette forme :
-Initialisation : On choisi des valeur au hasard pour le vecteur de poids wj.
-On choisi un vecteur d’entraînement x dans l’espace d’entrée.
-On trouve le neurone gagnant I(x) dont le vecteur de poids est le plus
proche du vecteur en entrée, tel que le minimum est : dj(x) = D
i=0(xi −
wji)2.
-On met à jour les poids, tel que : ∆wji = η(t)Tj,I(x)(xi − wji), où Tj,I(x)
est une fonction donnant donnant un voisinage Gaussien et η(t) le taux d’ap-
prentissage.
-On revient à la deuxième étape, tant que la feature map continue de chan-
ger.
Lorsque la self organizing feature map est stabilisée, on obtient des carac-
téristiques importantes de l’espace en entrée du réseau.
Ainsi, depuis un vecteur x, la feature map Φ nous donne un neurone
gagnant I(x) dans l’espace en sortie et le vecteur de poids wI(x) fournit les
coordonnées de l’image du neurone dans l’espace en entrée.
5.2.2 Vector Quantization
On remarque précédemment, que les Self Organizing Feature Maps per-
mettent d’obtenir un plus petit ensemble d’éléments wI(x) fournissant un bon
moyen d’approximer des représentants des éléments en entrée.
KHAIROS GROUP 26
OpenCR Page 27 sur 42
FIGURE 15 – Propriétés
On appelle ceux-ci des "Code-book vectors". Ceci est le principe de base
des "Vector Quantization", c’est-à-dire, d’avoir une sorte de compression des
données en entrée.
On peut connaître l’erreur des Vector Quantization par le calcul d’une
distance Euclidienne, telle que :
Les doubles barres représentent la norme Euclidienne.
Ce calcul nous donne la distance entre les vecteur x en entrée et leurs
représentants wI(x). Celle-ci doit être la plus petite possible.
Il faut remarquer qu’en utilisant un gradient descendant sur D, on arrive
à obtenir l’étape de mise à jour des poids des Self Organizing Feature Maps,
ce qui confirme que cette étape de mise à jour est la manière la plus optimale
pour approximer les vecteurs en entrée du réseau.
5.2.2.a Encodage-Décodage
On peut représenter les Vector Quantization avec un système constitué
d’encodeur et de décodeur.
Posons c(x) l’encodeur du vecteur x en entrée et x (x) le décodeur de c(x),
on peut grâce à cela, revenir à x avec une perte minimale d’information.
KHAIROS GROUP 27
OpenCR Page 28 sur 42
FIGURE 16 – Modèle d’encodage-décodage
On choisi le vecteur x en entrée de manière aléatoire avec une fonction de
probabilité p(x). Ainsi, on a le taux d’erreur suivant :
5.2.2.b Algorithme de Lloyd Généralisé
Comme vu précédemment, il faut qu’on puisse minimiser D au maximum,
de ce fait, on utilise l’algorithme de Lloyd généralisé.
Celui-ci repose sur deux conditions, qui sont les suivantes :
1. A partir d’un vecteur x en entrée, on choisi c = c(x), tel qu’on puisse
minimiser cette distance :
2. En prenant c, on calcule x (c) tel que la valeur puisse être un centroïde
d’une cellule de Voronoi dans un Diagramme de Voronoi et que la condition 1
soit satisfaite.
Pour les Vector Quantization, on calcule le minimum de la distance pour
c(x) avec la condition 1 et on décode en fonction de la condition 2, jusqu’à
avoir le D minimum.
Grâce à cela, on peut voir que les Self Organizing Feature Maps et les
systèmes de Vector Quantization modélisé par un système de Décordage-
Encodage, ont une correspondance, puisque l’encodeur correspônd à trouver
le meilleur neurone I(x), le décodage x (x) correspond à calculer les poids
KHAIROS GROUP 28
OpenCR Page 29 sur 42
FIGURE 17 – Diagramme de Voronoi - "+" représente un centroïde
FIGURE 18 – Tessellation centroïdale de Voronoi
wj et la foction de probabilité p(x) correspond à la fonction Gaussienne de
recherche de voisins Tj,I(x).
5.2.3 Le modèle LVQ
Le Learning Vector Quantization est une méthode à apprentissage supervisé
de Vector Quantization que l’on peut utiliser quand on a des données en entrées,
auxquelles on a au préalable, donné une classe (ou "cluster").
FIGURE 19 – Learning Vector Quantization
KHAIROS GROUP 29
OpenCR Page 30 sur 42
Au début, chaque neurones est désigné comme appartenant à un cluster. Le
neurone avec le vecteur de poids le plus proche est déclaré vainqueur. Lorsque
le neuronne est vainqueur, on regarde s’il est dans le bon cluster, si c’est le cas,
il est récompensé, sinon, il est "éloigné" du vecteur en entrée :
5.2.3.a Entraînement
L’entraînement ce fait de la manière suivante :
-Initialisation : On donne des poids au hasard, puis on met un taux d’ap-
prentissage
-Pour chaque vecteur x :
–. On cherche le neurone k gagnant, tel que :
–. On met à jours les poids w, tels que :
-On ajuste le taux d’apprentissage. Celui-ci se réduit avec les itérations.
-On arrête, si les conditions sont réunies, sinon, on revient à la deuxième
étape
5.3 Choix du réseau
Après de nombreux tests, nous avons opté pour le modèle Learning Vector
Quantization puisqu’il intègre un modèle supervisé d’apprentissage et qu’il
n’a dont pas les problèmes qui amènent à trouver une interprétation à la sortie
KHAIROS GROUP 30
OpenCR Page 31 sur 42
du réseau, comme ça a été le cas avec le modèle de Hopfield pour lequel nous
avons mis au point un système de signatures.
De même, le modèle de Hopfield ne prend qu’un nombre particulier d’en-
trées à reconnaître, c’est-à-dire qu’il faut lui passer les éléments à reconnaître
par paquets, ce qui complique les choses. Ce n’est pas le cas du modèle Lear-
ning Vector Quantization puisqu’il peut prendre aussi bien un très grand qu’un
petit nombre d’entrée, et les traiter.
Pour ces raisons, le modèle Learning Vector Quantization nous a paru être
la solution la plus viable pour le projet.
KHAIROS GROUP 31
OpenCR Page 32 sur 42
6 Interface Graphique
Pour l’interface graphique nous utilisons GTK qui fournit de bonnes bases
pour pouvoir créer une interface propre et efficace.
Une fois la structure de tout code de base utilisant GTK intégrée, il a fallut
commencer à créer l’interface. L’interface est composée de boutons, zones de
textes et boutons plus spécifiques permettant de charger les fichiers désirés.
Ces éléments sont des widgets qui s’agencent au sein de boîtes qui permettent
de compartimenter les zones de l’interface pour pouvoir les gérer séparément,
comme on le ferait avec un site web et le css. Les boîtes peuvent être hori-
zontales ou verticales, on peut donc agencer les widgets de deux manières au
sein de ces boîtes, qui peuvent elles même s’emboîter les unes dans les autres.
Cette mécanique offre de quoi modeler une interface selon nos besoins.
FIGURE 20 – Aperçu de l’interface graphique
KHAIROS GROUP 32
OpenCR Page 33 sur 42
4
7 Optimisations
Afin d’obtenir les meilleurs performances pour notre projet et de tirer parti
des architectures fortement parallélisée de nos machines, nous avons tenté de
paralléliser ce qui pouvait l’être.
Dans un premier temps, ce qui a été fait n’est que négligeable puisque
l’optimisation ne s’effectue que sur une petite partie du réseau de neurone,
mais pour la prochaine soutenance, nous allons essayer de le faire le plus
possible.
Il faut noter que certains problèmes apparaissent. Par exemple, dans certains
cas où les threads se partagent une tâche, ils peuvent corrompre les données
qui vont ensuite être utilisée par un autre thread.
Un autre exemple est la mauvaise utilisation des threads qui peut mener à
une dégradation des performances, parfois significative. Prenons pour exemple,
le cas où il y a plus de threads software que de threads hardware, ceux-ci
auront chacun un travail à effectuer et celui-ci peut-être trop rapide à effectuer
comparé aux coûts d’initialisation et de fermeture des threads créés. De plus,
les threads doivent chacun patienter qu’un thread ait fini d’utiliser une ressource
partagée pour continuer. Dans ce même cas, le système d’exploitation doit gérer
équitablement les threads, il leur donne donc chacun un temps d’exécution
limite après quoi, le scheduler mettra en suspend le thread courant, provoquant
un coût en ressources puisqu’il y aura sauvegarde puis restauration des états
des registres CPU ainsi que de ces caches (ce qui est plus grave). Ce dernier
cas est plutôt grave, puisque chaque thread va mettre des données dans le
cache qui sont très rapide, mais très petit, et donc lorsqu’un nouveau thread
viendra mettre les données de son contexte, il ira expulser les données du
thread précédent et ainsi de suite. Il se passe la même chose au niveau de la
mémoire virtuelle.
Il y a beaucoup d’autres cas, comme celui du thread lock, qui peuvent être très
dégradants en terme de performances.
KHAIROS GROUP 33
OpenCR Page 34 sur 42
Tous les cas précédents sont des cas auxquels nous avons fait face. Cela
nous montre que paralléliser une tâche peut être complexe, il faut donc bien le
gérer, au risque de dégrader les performances, voire d’avoir des résultats inat-
tendus. De fait, il faudra prendre le temps d’évaluer les gains en performances
pour voir si le fait de paralléliser une telle application est viable.
De ce fait, et par certaines contraintes de temps, bien que nous ayons fait
face à tous ces problèmes, nous avons abandonné la voie du parallélisme et
nous sommes simplement concentrés sur l’optimisation au niveau du corps des
algorithmes.
KHAIROS GROUP 34
OpenCR Page 35 sur 42
8 Site Internet
Le site est entièrement en responsive design et s’adapte donc à quasiment
toutes les situations. Il est sobre et intuitif. Les informations importantes sont
mises en avant et sont accessibles rapidement.
Le site est auto-hébergé sur une petite machine tournant sous Archlinux et est
disponible à l’adresse ‘opencr.heckp.com’.
FIGURE 21 – Aperçu du site
KHAIROS GROUP 35
OpenCR Page 36 sur 42
9 Conclusion
Lors de la réalisation de chacune de nos parties, nous avons appris à faire
en sorte que les solutions développées soient le plus efficaces possibles et ce,
afin de permettre un confort de développement allié à un résultat performant.
Nous avons tous appris que le travail en équipe était primordial afin de
mener à bien ce projet. Évidemment, ce genre de projet a impliqué des désac-
cords entre les membres qui ont pu être résolu au travers de discussions et de
recherches sur le sujet en question.
Finalement, nous avons développé des capacités d’apprentissage en auto-
nomie, tout en sachant coordonner notre travail au sein de notre équipe.
De plus, ce projet nous a mis face aux contraintes du milieu entrepreneurial,
comme le fait que nous ayons un cahier des charges à respecter, tout en
travaillant dans une entente cordiale.
KHAIROS GROUP 36
OpenCR Page 37 sur 42
Annexes
A Signification des barres de couleurs
Chaque titre des parties de ce rapport est précédé d’une barre de couleur.
Celle-ci représente l’étudiant qui a réalisé le travail dont il est question dans la
partie correspondante.
Les couleurs sont attribuées de cette manière :
Chady DIMACHKIE
Guillaume AIGUEPERSE
Jerry MAILLOT
Alexandre SOBRAL MARTINS
Il y a également une couleur représentant le groupe :
Khairos Group
KHAIROS GROUP 37
OpenCR Page 38 sur 42
B Références
-"Neural Networks and Physical Systems with Emergent Collective Com-
putational Abilities", P.N.A.S. USA, vol. 79 (1982), 2554-2558
-"Analysis of Hopfield Autoassociative Memory in the Character Recog-
nition", Yash Pal Singh et al. / (IJCSE) International Journal on Computer
Science and Engineering Vol. 02, No. 03, 2010, 500-503
-"Hopfield Network", Alice Julien-Laferriere de l’ENS Lyon
-"Hopfield and recurrent networks", lien :
http ://iitkgp.vlab.co.in/userfiles/9/file/Hopfield%20network%281%29.pdf
-"NEURAL NETWORK - BASED ENGLISH ALPHANUMERIC CHA-
RACTER RECOGNITION", International Journal of Computer Science, Engi-
neering and Applications (IJCSEA) Vol.2, No.4, August 2012
-Z.B. Xu, Y.Leung and X.W.He,” Asymmetrical Bidirectional Associative
Memories”, IEEE Transactions on systems, Man and cybernetics, Vol.24,
PP.1558-1564, Oct.1994.
-Jehoshua Bruck. "On the convergence properties of the Hopfield model".
Procceedings of the IEEE, 78(10), October 1990.
-Wikipedia : "Hopfield network", "Associative memory", "Recurrent neural
network"
-"Les réseaux de Hopfield", lien :
http ://agerodol.pagesperso-orange.fr/hopfield.html
-R. Rojas : "Neural Networks", Springer-Verlag, Berlin, 1996
-"Hopfield Networks", lien :
http ://www.comp.leeds.ac.uk/ai23/reading/Hopfield.pdf
-Wikipedia : "Hough transform"
-http ://fr.mathworks.com/help/nnet/ug/learning-vector-quantization-lvq-
neural-networks-1.html
-http ://www.wikiwand.com/en/Voronoidiagram
-http ://www.willamette.edu/ gorr/classes/cs449/Unsupervised/competitive.html
-http ://www.wikiwand.com/en/Winner-take-all
-http ://www.labbookpages.co.uk/software/imgProc/otsuThreshold.html
KHAIROS GROUP 38
OpenCR Page 39 sur 42
-http ://www.doc.ic.ac.uk/ nd/surprise96/journal/vol4/cs11/report.html
-LVQ by Kohonen : http ://www.cis.hut.fi/research/lvqpak/lvqdoc.txt
-http ://www.wikiwand.com/en/Otsu
KHAIROS GROUP 39
OpenCR Page 40 sur 42
Table des figures
1 Résultat - Grayscale . . . . . . . . . . . . . . . . . . . . . . . 6
2 Résultat - Grayscale . . . . . . . . . . . . . . . . . . . . . . . 9
3 Exemple d’histogramme . . . . . . . . . . . . . . . . . . . . 10
4 Résultat - Page de livre . . . . . . . . . . . . . . . . . . . . . 11
5 Avant la rotation . . . . . . . . . . . . . . . . . . . . . . . . . 12
6 Après la rotation . . . . . . . . . . . . . . . . . . . . . . . . 12
7 Run-Lenght Smoothing Algorithm . . . . . . . . . . . . . . . 15
8 Disjoint-Sets . . . . . . . . . . . . . . . . . . . . . . . . . . 16
9 Connected Components Labeling . . . . . . . . . . . . . . . . 17
10 Détection de caractères - QCM ALGO . . . . . . . . . . . . . 19
11 Réseau de Hopfield . . . . . . . . . . . . . . . . . . . . . . . 21
12 Modèle de Hopfield en temps discret . . . . . . . . . . . . . . 23
13 Bassin d’attraction . . . . . . . . . . . . . . . . . . . . . . . 24
14 Self Organizing Map . . . . . . . . . . . . . . . . . . . . . . 26
15 Propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
16 Modèle d’encodage-décodage . . . . . . . . . . . . . . . . . 28
17 Diagramme de Voronoi - "+" représente un centroïde . . . . . 29
18 Tessellation centroïdale de Voronoi . . . . . . . . . . . . . . . 29
19 Learning Vector Quantization . . . . . . . . . . . . . . . . . . 29
20 Aperçu de l’interface graphique . . . . . . . . . . . . . . . . 32
21 Aperçu du site . . . . . . . . . . . . . . . . . . . . . . . . . . 35
KHAIROS GROUP 40
OpenCR Page 41 sur 42
Table des matières
1 Introduction 3
2 Le groupe 4
2.1 Chady DIMACHKIE . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Guillaume AIGUEPERSE . . . . . . . . . . . . . . . . . . . 4
2.3 Jerry MAILLOT . . . . . . . . . . . . . . . . . . . . . . . . 5
2.4 Alexandre SOBRAL MARTINS . . . . . . . . . . . . . . . . 5
3 Prétraitement de l’image 6
3.1 Filtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.1.1 Le filtre médian . . . . . . . . . . . . . . . . . . . . . 7
3.2 La convolution . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.3 Binarisation . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.3.1 La méthode classique . . . . . . . . . . . . . . . . . . 9
3.3.2 Méthode avec le seuil local . . . . . . . . . . . . . . . 10
3.3.3 Méthode d’OTSU . . . . . . . . . . . . . . . . . . . . 10
3.4 Rotation de l’image . . . . . . . . . . . . . . . . . . . . . . . 12
4 Extraction des caractères 14
4.1 Détection des blocs de texte . . . . . . . . . . . . . . . . . . 14
4.1.1 Run-Length Smoothing Algorithm . . . . . . . . . . . 14
4.1.2 Connected Components Labeling . . . . . . . . . . . 15
4.1.2.a Union–Find Data Structure . . . . . 16
4.1.3 Extraction des lignes . . . . . . . . . . . . . . . . . . 17
4.2 Détection de caractères . . . . . . . . . . . . . . . . . . . . . 18
4.3 Remarque . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
5 Réseau de neurones 20
5.1 Modèle de Hopfield . . . . . . . . . . . . . . . . . . . . . . . 20
5.1.1 Caractéristiques du modèle . . . . . . . . . . . . . . . 21
5.1.2 Algorithme . . . . . . . . . . . . . . . . . . . . . . . 21
KHAIROS GROUP 41
OpenCR Page 42 sur 42
5.1.3 Convergence vers un attracteur . . . . . . . . . . . . . 23
5.1.4 En pratique . . . . . . . . . . . . . . . . . . . . . . . 24
5.1.4.a Système de signatures . . . . . . . . 24
5.1.4.b Cas particulier . . . . . . . . . . . . 25
5.2 Learning Vector Quantization . . . . . . . . . . . . . . . . . . 25
5.2.1 Self Organizing Feature Maps . . . . . . . . . . . . . 25
5.2.2 Vector Quantization . . . . . . . . . . . . . . . . . . 26
5.2.2.a Encodage-Décodage . . . . . . . . . 27
5.2.2.b Algorithme de Lloyd Généralisé . . 28
5.2.3 Le modèle LVQ . . . . . . . . . . . . . . . . . . . . . 29
5.2.3.a Entraînement . . . . . . . . . . . . . 30
5.3 Choix du réseau . . . . . . . . . . . . . . . . . . . . . . . . . 30
6 Interface Graphique 32
7 Optimisations 33
8 Site Internet 35
9 Conclusion 36
Annexes 37
A Signification des barres de couleurs 37
B Références 38
KHAIROS GROUP 42

Contenu connexe

En vedette

Diaporama 20 novembre
Diaporama 20 novembreDiaporama 20 novembre
Diaporama 20 novembreunicef33
 
CENTROS DEL PROFESORADO - Autoformación - Modalidad GRUPOS DE TRABAJO - Instr...
CENTROS DEL PROFESORADO - Autoformación - Modalidad GRUPOS DE TRABAJO - Instr...CENTROS DEL PROFESORADO - Autoformación - Modalidad GRUPOS DE TRABAJO - Instr...
CENTROS DEL PROFESORADO - Autoformación - Modalidad GRUPOS DE TRABAJO - Instr...
Consejería de Educación
 
Les fiches-outils-de-lorganisaton1
Les fiches-outils-de-lorganisaton1Les fiches-outils-de-lorganisaton1
Les fiches-outils-de-lorganisaton1Papis Wesh
 
Convergencias Perifericas
Convergencias PerifericasConvergencias Perifericas
Convergencias Perifericas
Alejandro Simonoff
 
Final ethanol cookstoves & fuel ppt (e - f) (2)
Final ethanol cookstoves & fuel   ppt (e - f) (2)Final ethanol cookstoves & fuel   ppt (e - f) (2)
Final ethanol cookstoves & fuel ppt (e - f) (2)
Cara Mullen
 
Sondage ifop pour atout+3
Sondage ifop pour atout+3Sondage ifop pour atout+3
Sondage ifop pour atout+3
ecoles2commerce
 
Riesgos
RiesgosRiesgos
Riesgos
ggarcas
 
Perg
PergPerg
Perg
Cristian
 
Grupo 1
Grupo 1Grupo 1
Acba présentation iut ga ld j 280313
Acba présentation iut ga ld j 280313Acba présentation iut ga ld j 280313
Acba présentation iut ga ld j 280313conferencedd
 
Linkedin - Fonctionnement et stratégies de visibilité
Linkedin - Fonctionnement et stratégies de visibilitéLinkedin - Fonctionnement et stratégies de visibilité
Linkedin - Fonctionnement et stratégies de visibilité
Louis-Philippe Dea
 
Cintia carpio
Cintia carpioCintia carpio
Cintia carpio
Azucena Prado Espinoza
 
Caperucita morada y los aliens
Caperucita morada y los aliensCaperucita morada y los aliens
Caperucita morada y los aliens
hermanosargensola
 
Manual identidad corporativa
Manual identidad corporativaManual identidad corporativa
Manual identidad corporativa
Anabel Lee
 

En vedette (17)

Diaporama 20 novembre
Diaporama 20 novembreDiaporama 20 novembre
Diaporama 20 novembre
 
CENTROS DEL PROFESORADO - Autoformación - Modalidad GRUPOS DE TRABAJO - Instr...
CENTROS DEL PROFESORADO - Autoformación - Modalidad GRUPOS DE TRABAJO - Instr...CENTROS DEL PROFESORADO - Autoformación - Modalidad GRUPOS DE TRABAJO - Instr...
CENTROS DEL PROFESORADO - Autoformación - Modalidad GRUPOS DE TRABAJO - Instr...
 
Les fiches-outils-de-lorganisaton1
Les fiches-outils-de-lorganisaton1Les fiches-outils-de-lorganisaton1
Les fiches-outils-de-lorganisaton1
 
Convergencias Perifericas
Convergencias PerifericasConvergencias Perifericas
Convergencias Perifericas
 
Final ethanol cookstoves & fuel ppt (e - f) (2)
Final ethanol cookstoves & fuel   ppt (e - f) (2)Final ethanol cookstoves & fuel   ppt (e - f) (2)
Final ethanol cookstoves & fuel ppt (e - f) (2)
 
Sondage ifop pour atout+3
Sondage ifop pour atout+3Sondage ifop pour atout+3
Sondage ifop pour atout+3
 
Riesgos
RiesgosRiesgos
Riesgos
 
Perg
PergPerg
Perg
 
Grupo 1
Grupo 1Grupo 1
Grupo 1
 
Acba présentation iut ga ld j 280313
Acba présentation iut ga ld j 280313Acba présentation iut ga ld j 280313
Acba présentation iut ga ld j 280313
 
Linkedin - Fonctionnement et stratégies de visibilité
Linkedin - Fonctionnement et stratégies de visibilitéLinkedin - Fonctionnement et stratégies de visibilité
Linkedin - Fonctionnement et stratégies de visibilité
 
Final
FinalFinal
Final
 
Cintia carpio
Cintia carpioCintia carpio
Cintia carpio
 
Mediacion
MediacionMediacion
Mediacion
 
Tableau resp.
Tableau resp.Tableau resp.
Tableau resp.
 
Caperucita morada y los aliens
Caperucita morada y los aliensCaperucita morada y los aliens
Caperucita morada y los aliens
 
Manual identidad corporativa
Manual identidad corporativaManual identidad corporativa
Manual identidad corporativa
 

Similaire à OpenCR__Rapport_soutenance_Finale

S2_Projet_-_Groupe_18_-_Cahier_des_charges.pdf
S2_Projet_-_Groupe_18_-_Cahier_des_charges.pdfS2_Projet_-_Groupe_18_-_Cahier_des_charges.pdf
S2_Projet_-_Groupe_18_-_Cahier_des_charges.pdf
louise645546
 
Rapport de Soutenance 1
Rapport de Soutenance 1Rapport de Soutenance 1
Rapport de Soutenance 1BartOunay
 
Rapport-ilovepdf-compressed
Rapport-ilovepdf-compressedRapport-ilovepdf-compressed
Rapport-ilovepdf-compressedArthur Cousseau
 
Cours adobe photoshop cs v8.0-fr - conseils et astuces dexperts
Cours   adobe photoshop cs v8.0-fr - conseils et astuces dexpertsCours   adobe photoshop cs v8.0-fr - conseils et astuces dexperts
Cours adobe photoshop cs v8.0-fr - conseils et astuces dexpertsMohamed Nouri
 
Rapport de projet de fin d"études
Rapport de projet de fin d"étudesRapport de projet de fin d"études
Rapport de projet de fin d"études
Mohamed Boubaya
 
Étude et résolution numérique de deux modèles basés sur des équations aux dér...
Étude et résolution numérique de deux modèles basés sur des équations aux dér...Étude et résolution numérique de deux modèles basés sur des équations aux dér...
Étude et résolution numérique de deux modèles basés sur des équations aux dér...
Ayoub Boudlal
 
Chip_Ninja____Rapport_soutenance_finale
Chip_Ninja____Rapport_soutenance_finaleChip_Ninja____Rapport_soutenance_finale
Chip_Ninja____Rapport_soutenance_finaleChady Dimachkie
 
Deploy automatic in the cloud
Deploy automatic in the cloudDeploy automatic in the cloud
Deploy automatic in the cloud
Abdelhalim KADDOUR GUETTAOUI
 
Openerp à la poste maroc
Openerp à la poste marocOpenerp à la poste maroc
Openerp à la poste maroc
HORIYASOFT
 
Conception et developpement d'un site web pour la suggestion et notification ...
Conception et developpement d'un site web pour la suggestion et notification ...Conception et developpement d'un site web pour la suggestion et notification ...
Conception et developpement d'un site web pour la suggestion et notification ...
Mohamed Boubaya
 
Visualisation graphique R avec ggplot2
Visualisation graphique R avec ggplot2Visualisation graphique R avec ggplot2
Visualisation graphique R avec ggplot2
Daname KOLANI
 
Tutorial GGPlot2
Tutorial GGPlot2Tutorial GGPlot2
Tutorial GGPlot2
📡 Vincent Isoz
 
SDIC-PL0678.pdf
SDIC-PL0678.pdfSDIC-PL0678.pdf
SDIC-PL0678.pdf
ColmainNassiri1
 
Rapport pfe isi_Big data Analytique
Rapport pfe isi_Big data AnalytiqueRapport pfe isi_Big data Analytique
Rapport pfe isi_Big data Analytique
Yosra ADDALI
 
Conception et développement d'une marketplace basée sur l'architecture micros...
Conception et développement d'une marketplace basée sur l'architecture micros...Conception et développement d'une marketplace basée sur l'architecture micros...
Conception et développement d'une marketplace basée sur l'architecture micros...
Adem Amen Allah Thabti
 
Rapport de stage PFE ( DUT) chez Synthèse Conseil - Jaiti Mohammed
Rapport de stage PFE ( DUT) chez Synthèse Conseil  - Jaiti MohammedRapport de stage PFE ( DUT) chez Synthèse Conseil  - Jaiti Mohammed
Rapport de stage PFE ( DUT) chez Synthèse Conseil - Jaiti Mohammed
Mohammed JAITI
 
Rapport Mini-Projet Recherche Opérationnelle
Rapport Mini-Projet Recherche OpérationnelleRapport Mini-Projet Recherche Opérationnelle
Rapport Mini-Projet Recherche Opérationnelle
CibamboSteven
 
Développement d'un forum de discussion
Développement d'un forum de discussionDéveloppement d'un forum de discussion
Développement d'un forum de discussion
Youssef NIDABRAHIM
 

Similaire à OpenCR__Rapport_soutenance_Finale (20)

S2_Projet_-_Groupe_18_-_Cahier_des_charges.pdf
S2_Projet_-_Groupe_18_-_Cahier_des_charges.pdfS2_Projet_-_Groupe_18_-_Cahier_des_charges.pdf
S2_Projet_-_Groupe_18_-_Cahier_des_charges.pdf
 
Rapport de Soutenance 1
Rapport de Soutenance 1Rapport de Soutenance 1
Rapport de Soutenance 1
 
Rapport-ilovepdf-compressed
Rapport-ilovepdf-compressedRapport-ilovepdf-compressed
Rapport-ilovepdf-compressed
 
Cours adobe photoshop cs v8.0-fr - conseils et astuces dexperts
Cours   adobe photoshop cs v8.0-fr - conseils et astuces dexpertsCours   adobe photoshop cs v8.0-fr - conseils et astuces dexperts
Cours adobe photoshop cs v8.0-fr - conseils et astuces dexperts
 
Rapport de projet de fin d"études
Rapport de projet de fin d"étudesRapport de projet de fin d"études
Rapport de projet de fin d"études
 
Étude et résolution numérique de deux modèles basés sur des équations aux dér...
Étude et résolution numérique de deux modèles basés sur des équations aux dér...Étude et résolution numérique de deux modèles basés sur des équations aux dér...
Étude et résolution numérique de deux modèles basés sur des équations aux dér...
 
Chip_Ninja____Rapport_soutenance_finale
Chip_Ninja____Rapport_soutenance_finaleChip_Ninja____Rapport_soutenance_finale
Chip_Ninja____Rapport_soutenance_finale
 
Deploy automatic in the cloud
Deploy automatic in the cloudDeploy automatic in the cloud
Deploy automatic in the cloud
 
Openerp à la poste maroc
Openerp à la poste marocOpenerp à la poste maroc
Openerp à la poste maroc
 
vanderpypendaniel_msc
vanderpypendaniel_mscvanderpypendaniel_msc
vanderpypendaniel_msc
 
Conception et developpement d'un site web pour la suggestion et notification ...
Conception et developpement d'un site web pour la suggestion et notification ...Conception et developpement d'un site web pour la suggestion et notification ...
Conception et developpement d'un site web pour la suggestion et notification ...
 
Visualisation graphique R avec ggplot2
Visualisation graphique R avec ggplot2Visualisation graphique R avec ggplot2
Visualisation graphique R avec ggplot2
 
Tutorial GGPlot2
Tutorial GGPlot2Tutorial GGPlot2
Tutorial GGPlot2
 
Rapport de Synthese
Rapport de SyntheseRapport de Synthese
Rapport de Synthese
 
SDIC-PL0678.pdf
SDIC-PL0678.pdfSDIC-PL0678.pdf
SDIC-PL0678.pdf
 
Rapport pfe isi_Big data Analytique
Rapport pfe isi_Big data AnalytiqueRapport pfe isi_Big data Analytique
Rapport pfe isi_Big data Analytique
 
Conception et développement d'une marketplace basée sur l'architecture micros...
Conception et développement d'une marketplace basée sur l'architecture micros...Conception et développement d'une marketplace basée sur l'architecture micros...
Conception et développement d'une marketplace basée sur l'architecture micros...
 
Rapport de stage PFE ( DUT) chez Synthèse Conseil - Jaiti Mohammed
Rapport de stage PFE ( DUT) chez Synthèse Conseil  - Jaiti MohammedRapport de stage PFE ( DUT) chez Synthèse Conseil  - Jaiti Mohammed
Rapport de stage PFE ( DUT) chez Synthèse Conseil - Jaiti Mohammed
 
Rapport Mini-Projet Recherche Opérationnelle
Rapport Mini-Projet Recherche OpérationnelleRapport Mini-Projet Recherche Opérationnelle
Rapport Mini-Projet Recherche Opérationnelle
 
Développement d'un forum de discussion
Développement d'un forum de discussionDéveloppement d'un forum de discussion
Développement d'un forum de discussion
 

OpenCR__Rapport_soutenance_Finale

  • 1. Rapport de soutenance EPITA•2014-2015KhairosGroup Chady DIMACHKIE Guillaume AIGUEPERSE Alexandre SOBRAL MARTINS Jerry MAILLOT
  • 2. OpenCR Page 2 sur 42 Sommaire 1 Introduction 3 2 Le groupe 4 2.1 Chady DIMACHKIE . . . . . . . . . . . . . . . . . . . . . . . . . 4 2.2 Guillaume AIGUEPERSE . . . . . . . . . . . . . . . . . . . . . . 4 2.3 Jerry MAILLOT . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2.4 Alexandre SOBRAL MARTINS . . . . . . . . . . . . . . . . . . . 5 3 Prétraitement de l’image 6 3.1 Filtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 3.2 La convolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 3.3 Binarisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 3.4 Rotation de l’image . . . . . . . . . . . . . . . . . . . . . . . . . . 12 4 Extraction des caractères 14 4.1 Détection des blocs de texte . . . . . . . . . . . . . . . . . . . . . 14 4.2 Détection de caractères . . . . . . . . . . . . . . . . . . . . . . . . 18 4.3 Remarque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 5 Réseau de neurones 20 5.1 Modèle de Hopfield . . . . . . . . . . . . . . . . . . . . . . . . . . 20 5.2 Learning Vector Quantization . . . . . . . . . . . . . . . . . . . . . 25 5.3 Choix du réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 6 Interface Graphique 32 7 Optimisations 33 8 Site Internet 35 9 Conclusion 36 Annexes 37 A Signification des barres de couleurs 37 B Références 38 KHAIROS GROUP 2
  • 3. OpenCR Page 3 sur 42 1 Introduction Dans le cadre du projet de la seconde année nous devons réaliser un logiciel de reconnaissance de caractères, convertissant une image contenant du texte en un ficher texte contenant le texte reconnu. Pour ce faire, nous avons dû nous organiser d’une telle manière à ce que les tâches soient réparties entre les membres en fonctions de leur niveau et de leur temps d’adaptation au langage C, qui nous est imposé cette année. La réalisation du projet a nécessité plusieurs outils qui nous sont fournis à travers les libraires SDL et SDL_image pour la manipulation de l’image et le chargement de certains formats d’images. Nous avons également, utilisé OpenMP, qui nous permet d’exploiter les architecture parallèles multi-coeurs de nos machines. Ce projet, nous permettra, en tant que futurs ingénieurs, de pouvoir tra- vailler en équipe sur des projets qui nécessitent d’être finalisé rapidement, tout en répondant au besoin premier défini dans le cahier des charges. Le résultat final devra également avoir un niveau de performances élevé qui reflétera nos capacités à développer des solutions logicielles bien conçues. Ainsi, ce projet auquel nous participons tous nous permet de nous améliorer en tant que développeur, non seulement au niveau technique. mais aussi au niveau social. KHAIROS GROUP 3
  • 4. OpenCR Page 4 sur 42 2 Le groupe 2.1 Chady DIMACHKIE Cette année, mon statut passe de "simple" membre à chef de projet, ce qui fait que mes responsabilités sont lourdes. En tant que chef de projet, il est en mon devoir de coordonner le travail de chaque membre, tout en aidant ceux ayant des difficultés. Ce projet est un moyen pour moi d’apprendre à être un meilleur dévelop- peur, tout en apprenant à gérer une équipe de quatre membres. Ainsi, j’ai appris à faire avec tout types de problèmes, tout en les gérant de la manière la plus optimale possible. Pour le projet, je m’occuperais de la détection de lignes, ainsi que du réseau de neurones. Bien-sûr, tout en aidant les autres membres à résoudre leur problème afin de réaliser la meilleur solution possible dans la plus grande entente. 2.2 Guillaume AIGUEPERSE Je suis très content de travailler sur ce projet. Le traitement de l’image et ce qui est proche de ce domaine n’est pas vraiment ce qui m’attirait parmi le vaste éventail de sous domaines que comportent l’informatique et la programmation. Ce projet s’est néanmoins révélé intéressant techniquement. J’ai beaucoup appris jusqu’à présent grâce à ce projet, et à Chady, qui est un chef de groupe très pédagogue. J’avais vraiment de grosses lacunes en programmation mais celles-ci se comblent peu à peu, au fur et à mesure que nous avançons dans ce projet. Pour ce projet et cette première soutenance j’ai été chargé de mettre en place un site web et d’assurer la rotation de l’image, manuelle pour l’instant. L’implémentation d’une rotation automatique est en cours. KHAIROS GROUP 4
  • 5. OpenCR Page 5 sur 42 2.3 Jerry MAILLOT Originaire de l’île de La Réunion, j’ai décidé après l’obtention de mon BAC scientifique, d’intégrer EPITA malgré les 10 000 km qui me séparent de ma famille, mes amis... Principalement intéressé par les mathématiques au collège, à la découverte de l’algorithmie au lycée, j’ai donc fait le choix de m’orienter vers le domaine informatique. J’ai donc fait un BAC scientifique avec l’option Sciences de l’Ingénieur et la spécialité maths, la spécialité ISN étant inexistante dans le lycée où j’étais. Après l’obtention de mon BAC j’ai décidé d’intégrer une école d’ingénieur en informatique pour pouvoir me spécialiser le plus tôt possible, mais aussi pour éviter les bancs de la FAC. Pour ma première année, je l’ai trouvé assez difficile surtout qu’il fallait que je découvre tout, mais aussi parce que le rythme de travail est monté d’un cran. Toujours à EPITA, j’aime bien ce que je fais et ça me motive pour continuer. Cette année, pour ce projet, comme je ne connaissais pas grand monde dans la classe, on m’a attribué aléatoirement un groupe, le groupe « Khairos Group » qui me plaît bien. Étant arrivé en retard dans le groupe et n’ayant pas spécialement de points forts, j’essaye quand même d’apporter mon aide ainsi que quelques idées... 2.4 Alexandre SOBRAL MARTINS Selon moi, ce projet semble être un projet légèrement plus professionnel que le projet que l’on a dû faire en première année. Cette seconde année me paraît plus intensive en terme de travail, ce qui me semble être en adéquation avec le projet qui nous a été donné à faire. En effet, faire un OCR m’a semblé avoir connotation plus professionnelle que de faire un jeu vidéo. Le fait que ce projet soit à programmer en langage m’a permis de déouvrir un langage qui est par la même occasion un langage bas niveau. Le fait de travailler en groupe me permet de combler certaines lacunes, par le biais de l’aide des membres du groupe. KHAIROS GROUP 5
  • 6. OpenCR Page 6 sur 42 3 Prétraitement de l’image Pour avoir une détections de caractères ainsi qu’une reconnaissance de ceux-ci, qui soit performante, il nous faut traiter l’image pour qu’elle soit utilisable dans de bonnes conditions. 3.1 Filtres Avant même de commencer la binarisation, il faut s’assurer que l’image soit assez propre, pour cela, on va appliquer plusieurs filtres, tels que le filtre médian et une matrice de convolution, sur l’image. Avant l’application de tout filtre et pour avoir de meilleurs résultats après l’application des filtres, on a remplacé chaque pixels de l’image par son niveau de gris en utilisant pour chaque pixels la relation : r + g + b 3 FIGURE 1 – Résultat - Grayscale KHAIROS GROUP 6
  • 7. OpenCR Page 7 sur 42 3.1.1 Le filtre médian Le filtre médian est un filtre qui va permettre de supprimer les bruits dans des images à niveaux de gris. La méthode du filtre médian consiste à appliquer une matrice de convolution 3*3 ou 5*5 ou même x*x (à condition bien évidemment que x appartienne aux entiers naturels et qu’il soit impair) sur chaque pixels de l’image. Pour notre projet, nous avons privilégié le choix d’une matrice 3*3 car l’application du filtre avec une plus grande matrice rend l’image un peu floue. Nous utilisons donc la matrice :      1 1 1 1 1 1 1 1 1      A l’application du filtre médian, on va donc parcourir l’image pixel par pixel et remplacer chaque pixels par la valeur médiane de ses voisins. Ce qui fait que pour chaque pixels, on va récupérer l’intensité de ses 8 voisins qui l’entoure (intensité = moyenne du niveau de rouge, bleu et vert du pixel), classer les 9 valeurs de la liste en ordre croissant à l’aide d’un tri pour pouvoir extraire la valeur médiane du tableau et ainsi remplacer l’intensité du pixel en question par celle de la valeur médiane du tableau. Exemple : Soit un pixel quelconque d’une image ayant pour niveau de gris 50 et ses voisins : 58 42 64 41 50 55 52 46 52 Après l’application de l’algorithme de tri, nous pouvons avons donc : 41 42 46 50 52 52 55 58 64 Après l’application du filtre médian, on va donc remplacer l’intensité du pixel qui était à 50 par l’intensité médiane qui est à 52. KHAIROS GROUP 7
  • 8. OpenCR Page 8 sur 42 3.2 La convolution Dans un traitement d’images, l’application d’un filtre de convolution consiste à remplacer les valeurs de tous les pixels de l’image par de nou- velles valeurs qui sont calculées par un produit de matrices. Pour faire ce calcul, on va donc devoir parcourir l’image pixels par pixels et pour chacun d’eux, faire leur matrice qui doit être de même taille que la matrice de convolution. Exemple : Soit une image quelconque. Si nous voulons y appliquer la matrice de convolution permettant d’augmenter le contraste de l’image :            0 0 0 0 0 0 0 −1 0 0 0 −1 5 −1 0 0 0 −1 0 0 0 0 0 0 0            Prenons un pixel quelconque de l’image sur laquelle nous voulons appliquer cette matrice. Nous aurons par exemple :            35 40 41 45 50 40 40 42 46 52 42 46 50 55 55 48 52 56 58 60 56 60 65 70 75            Nous allons donc faire le produit des deux matrices que l’on divise par la sommes des valeurs de la matrice de convolution : ⇒ 42∗(−1)+46∗(−1)+50∗5+55∗(−1)+56∗(−1) (−1)+(−1)+5+(−1)+(−1) ⇒ (−42)+(−46)+250+(−55)+(−56) 1 = 51 KHAIROS GROUP 8
  • 9. OpenCR Page 9 sur 42 Nous allons donc remplacer la valeur du pixel qui est de 50 dans notre cas, par 51. Nous avons plusieurs types de matrices de convolution différentes qui peuvent être utilisées selon le besoin de l’utilisateur s’il juge son image assez sale ou pas assez propre. Selon l’effet qu’il veut donner a son image, il va donc choisir la matrice de convolution adaptée. FIGURE 2 – Résultat - Grayscale 3.3 Binarisation Pour avoir une détections de caractères ainsi qu’une reconnaissance de ceux-ci, qui soit performante, il nous faut traiter l’image pour qu’elle soit utilisable dans de bonnes conditions. Binarisation : La Binarisation est une étape nécessaire dont dépendent les parties qui suivent, pour cela il nous faut l’implémenter. Pour ce faire, nous avons eu le choix entre 3 méthodes. 3.3.1 La méthode classique Cette méthode que nous allons appeler classique est la méthode la plus simple à implémenter. Pour ce faire, il nous faut bien évidemment une image KHAIROS GROUP 9
  • 10. OpenCR Page 10 sur 42 en niveau de gris, puis on doit parcourir son tableau de pixels et comparer pour chaque pixels, leurs valeurs avec 128. Si cette valeur est inférieure à 128, elle est remplacée par 0 et dans le cas contraire, par 255. 3.3.2 Méthode avec le seuil local Nous avons aussi essayé d’implémenter une méthode qui va calculer un certain seuil local auquel on va comparer la valeur de chaque pixels et les modifier selon s’ils sont supérieurs ou inférieurs à la valeur de ce seuil mais cette méthode conservait beaucoup de bruit dans l’image finale, elle n’a donc pas été retenue. 3.3.3 Méthode d’OTSU La Méthode d’Otsu, est une méthode utilisée pour binariser une image. Il nous faut donc trouver un seuil à partir de la forme de l’histogramme de l’image. A partir de ce seuil, on va pouvoir binariser l’image en comparant chaque pixels à la valeur du seuil, si elle est inférieure, on l’a passe à 0 sinon à 255. Pour pouvoir utiliser cette méthode, il faut au préalable que l’image soit en niveau de gris. Pour utiliser cette méthode, nous allons procéder sous forme d’etapes : 1. On fait un parcours de l’image pixelspar pixels et on représente la probabilité de chaque niveau d’intensité dans un histogramme.On aura donc un histogramme ayant sur l’axe des abscisses, les 256 valeurs possibles du niveau d’intensité et sur l’axe des ordonnées, la probabilité d’apparition de ces niveaux d’intensité. FIGURE 3 – Exemple d’histogramme KHAIROS GROUP 10
  • 11. OpenCR Page 11 sur 42 2. On initialise la probabilité d’être à la ième classe et la moyenne de la ième classe au seuil t = 0. A ce seuil, ωi = 0 et µi = 0 3. On parcours tous les seuils depuis t = 1 jusqu’à t = 255 (niveau d’in- tensité maximal). A chaque itération, on met à jour ωi et µi puis on calcule la variances inter-classe à partir de la formule intra-classe. 4. Le seuil avec lequel on va procéder à la binarisation correspond à la variance inter-classe σ2 b(t) maximale obtenue Finalement, après application de la binarisation, nous avons un resultat sem- blable à celui de la figure ci-dessous : FIGURE 4 – Résultat - Page de livre KHAIROS GROUP 11
  • 12. OpenCR Page 12 sur 42 3.4 Rotation de l’image Pour effectuer la rotation, on utilise simplement une matrice de rotation. Il suffit de parcourir l’image et pour chaque pixel de coordonnées (x, y), on ap- plique les formules suivantes, où (cx, cy) sont les coordonnées du pixel central : cos(α) ∗ (x − cx) + sin(α) ∗ (y − cy) + cx − sin(α) ∗ (x − cx) + cos(α) ∗ (y − cy) + cy FIGURE 5 – Avant la rotation FIGURE 6 – Après la rotation Lors des essais, il est arrivé que l’image sorte du cadre. La solution était d’effectuer la rotation en fonction du point central, pour éviter qu’une partie de l’image ne disparaisse après rotation, ce qui arrivait si la rotation se faisait KHAIROS GROUP 12
  • 13. OpenCR Page 13 sur 42 en fonction de l’angle supérieur gauche. On vérifie aussi pour chaque pixel que nous ne sortions pas des bords de la matrice, pour éviter de redéfinir un pixel n’importe où. La prochaine étape est de ne plus avoir à donner un angle manuellement. Il faut utiliser un algorithme permettant de déterminer l’angle d’inclinaison du texte, et donc l’angle de correction à appliquer. Pour détecter l’angle d’inclinaison du texte et le corriger, nous avons choisi d’utiliser la transformée de Hough, appliquée à une droite. L’intérêt de cette solution est qu’elle offre un moyen de trouver l’angle d’inclinaison du texte, en utilisant les coordonnées polaires (rho, theta) plutôt que les coordonnées cartésiennes de chaque point, et simplifie donc le problème. On va, pour chaque pixel noir, faire varier theta de 0 à 180 degrés puis calculer rho en fonction de l’angle theta en radians, et incrémenter l’accumula- teur pour les valeurs de rho et theta correspondantes. Une fois l’accumulateur remplit, il ne reste plus qu’à le parcourir en fonction de rho et theta, et chercher pour quelle valeurs de (rho, theta) l’accumulateur présente la plus grande valeur. Cette méthode permet d’obtenir l’angle d’inclinaison du texte, il ne reste ensuite plus qu’à effectuer une rotation de l’image pour repositionner le texte correctement. On a cependant toujours quelques soucis dans quelques cas particuliers, pour lesquels l’angle trouvé n’est pas le bon. KHAIROS GROUP 13
  • 14. OpenCR Page 14 sur 42 4 Extraction des caractères Dans un OCR, nous avons besoin de reconnaître des caractères. Pour cela, nous avons besoin d’algorithmes permettant l’extraction de lignes, caractères et autres blocs. 4.1 Détection des blocs de texte Tout d’abord, dans le processus d’extraction des caractères, il faut détecter les lignes. Ce qui veut dire qu’il faut pouvoir stocker toutes les lignes avec certaines informations qui leurs sont propres. Nous avions implémenté une méthode de "lancé de rayons". Bien que celle-ci avait un temps d’exécution très réduit, elle ne fournissait uniquement de bons résultats, sur des images dont la disposition du texte se rapproche de celle des pages de ce rapport. Nous avons donc dû mettre en place une méthode plus performante au niveau de la détection des blocs de caractères. Cette méthode consiste à appliquer le Run-Length Smoothing Algorithm à l’horizontal, puis de détecter et donner un label à toutes les composantes connexes, pour enfin appliquer un algorithme d’extraction de caractères dans ces blocs. 4.1.1 Run-Length Smoothing Algorithm Pour notre méthode, nous devons appliquer le Run-Length Smoothing Algorithm, afin de connecter tout éléments qui, en formant ensuite un bloc, nous aideront à isoler les blocs contenant du texte, ainsi que les images. Le Run-Length Smoothing Algorithm est appliqué à une séquence de d’éléments binaires, dans laquelle on n’aura que du NOIR ou du BLANC. Ainsi, l’algorithme suit les règles suivantes : -Les pixels BLANC deviennent NOIR, en sortie, si le nombre de pixels BLANC adjacents est inférieur ou égal à une constante C prédéfinie. KHAIROS GROUP 14
  • 15. OpenCR Page 15 sur 42 -Les pixels NOIR restent inchangés en sortie. FIGURE 7 – Run-Lenght Smoothing Algorithm Cet algorithme a pour effet, de regrouper les zones de pixels NOIR séparés par moins de C pixels. Le choix de la constante C est important, puisqu’il aide à regrouper les éléments de telle façon à ce qu’ils y ait des images et du textes dans des blocs différents. Bien que cette méthode soit très pratique, elle a également un défaut, puisque le calcul de la constante C n’est pas facile et de plus, la valeur n’est pas toujours fiable, de ce fait, après de nombreux tests, nous avons opté pour C = 22. 4.1.2 Connected Components Labeling Dans cette partie, nous allons devoir étiqueter les blocs isolés, afin de pouvoir les détecter comme étant une ligne contenant potentiellement des caractères. Ainsi, il est possible de classifier les éléments de l’image, assez facilement, dans le but de distinguer les images du texte, pour ensuite stocker les coordonnées des blocs de texte. Notre première implémentation était basée sur le fait que l’algorithme est très facile à mettre en place en utilisant une version récursive. Celle-ci permettrait, de regarder tous les voisins noirs d’un pixel noir et de leur donner le même label. Continuant ainsi sur le même bloc, puis sur le reste de l’image à la recherche de nouveaux blocs. KHAIROS GROUP 15
  • 16. OpenCR Page 16 sur 42 Bien que cette méthode soit simple, celle-ci possède certains problèmes, puisqu’à partir de certaines dimensions, de certaines images, il est très facile d’avoir un Stack Overflow. On peut contourner la limite de taille de la Stack, grâce aux fonctions fournies dans "sys/resource.h", mais cette technique n’est évidemment pas viable, puisque ça ne réglerait pas le problème sur d’autres images encore plus grandes. Ainsi, nous avons préféré implémenter une méthode en itératif à deux passes, c’est-à-dire, qui parcours l’image deux fois. 4.1.2.a Union–Find Data Structure Les Union-Find (ou Disjoint-Set) sont une structure de donnée comportant deux opérations, telles que : -Union : Regroupe deux set (ou classe d’équivalence), en un. -Find : Trouve le set auquel un élément donné appartient. On peut égaler déterminer si deux éléments sont dans le même set. Ainsi, on peut déterminer une relation d’équivalence entre plusieurs élé- ments. Cette structure permet de stocker plusieurs classes d’équivalences. Celles- ci sont stockées sous forme d’une structure arborescente, dans laquelle un noeud de l’arbre représente un label et pointe vers son noeud père. FIGURE 8 – Disjoint-Sets KHAIROS GROUP 16
  • 17. OpenCR Page 17 sur 42 Tout ceci est fait avec un vecteur PARENT dont les indices forment l’en- semble des labels possibles et dont les valeur sont les labels des fils du parent. Les Union-Find, rendent l’algorithme de Connected Components Labeling, plus efficace. Celui-ci est effectué en deux passes. La première passe propage le label d’un pixel, juste en dessous, à sa droite, à sa gauche et au dessus. Lorsqu’on arrive au cas où un pixel peut se voir attribuer différents labels, il prend le plus petit, et une classe d’équivalence est créée dans la structure Union-Find. Après cette première passe, toutes les classes d’équivalences possibles ont été déterminées et ne contient qu’un label qui est la racine de son propre arbre dans la structure. Lors de la seconde passe, on effectue une correction en attribuant à chaque pixel le label de sa classe d’équivalence FIGURE 9 – Connected Components Labeling Ainsi, on a toutes nos componsantes connexes séparées, et notre image est donc classifiée. 4.1.3 Extraction des lignes Avec tous les traitement effectué, c’est-à-dire, le Run-Length Smoothing Algorithm à l’Horizontale et la classification de l’image avec l’algorithme de Connected Components Label utilisant les Union-Finds, on a à notre disposi- tion un tableau avec toutes les lignes et images sous forme de blocs étiquetés. KHAIROS GROUP 17
  • 18. OpenCR Page 18 sur 42 Grace à cela, on va pouvoir trouver les coordonnées de nos lignes. Il suffit de parcourir le tableau, et pour chaque composante qu’on rencontre, on cherche le maximum en abscisse, en ordonnée et pareil pour le minimum, avec cela, on a les équations de quatre droites, qui nous donnent un rectangle qui entoure notre ligne. Ainsi, nous avons notre tableau de lignes, qui va nous permettre d’en extraire les caractères. 4.2 Détection de caractères La détection de lignes étant fonctionnelle, on peut maintenant détecter les caractères. Pour cela, on va utiliser une technique similaire de lancé de rayons. Dans la partie d’avant, nous avons lancé des rayons à l’horizontale pour les lignes. Pour les caractères nous en lancerons à la verticale. Ainsi, lors de l’appel de la fonction de détection de caractères, nous lui donnerons la ligne dans laquelle on veut extraire les caractères. La fonction lancera des rayons du bas de la ligne vers le haut, c’est-à-dire qu’elle commencera un lancé de rayon vertical à partir du point P1 et finira à P2, tels que : P1   Top left abscissa + offset X Bottom right ordinate   P2   Top left abscissa + offset X Bottom right ordinate - offset Y  , où les valeurs maximales de offset X et Offset Y sont respectivement, Bottom Right Abscissa − Top left abscissa et, Bottom Right ordinate − Top left ordinate. Nous suivons le même principe que la détection de lignes, donc on appelle la fonction plusieurs fois dans la ligne, pour extraire tous les caractères. Nous obtenons donc : KHAIROS GROUP 18
  • 19. OpenCR Page 19 sur 42 FIGURE 10 – Détection de caractères - QCM ALGO Il faut aussi remarquer, que nous travaillons sur des caractères imprimés, nous n’avons donc pas besoin de path finding pour séparer deux lettres, sauf pour l’italique, même si l’algorithme donne d’assez bon résultats en l’état. 4.3 Remarque Pour l’extraction des caractères, on aurait pu n’utiliser que l’algorithme de Connected Components Labeling sur l’image, directement sans Run-Length Smoothing Algorithm. On aurait eu, ainsi, une detection des caractères beau- coup plus précise, gérant également, l’italique ou autre. Bien que, cela ait l’air d’une solution, ce n’est pas le cas, puisque qu’elle a un temps d’execution très long, ce qui ne nous permet pas de considérer cette méthode comme étant viable. KHAIROS GROUP 19
  • 20. OpenCR Page 20 sur 42 5 Réseau de neurones Pour reconnaître les caractères, nous avons besoin d’un élément permettant cette reconnaissance. Sachant que l’être humain est le plus apte à lire un document composé de texte, grâce à son cerveau, la meilleur solution serait une structure imitant son comportement. Ainsi, les réseaux de neurones artificiels sont ce qui s’en rapproche le plus. Un réseau de neurones est un processeur parallèle composé d’unités de traitements simples, qui a la particularité de stocker les informations apprises pour les rendre ensuite, utilisables après traitement. Il est similaire au cerveau, dans la mesure où : - Il acquiert des informations à partir de son "environnement" grâce à un pro- cessus d’apprentissage. - Il a des neurones inter-connectées grâce auxquelles il peut stocker les infor- mations acquises. Pour le réseau, nous avons comparé deux modèles que nous avons testés, afin de décider le plus apte à reconnaître un large nombre de caractères. Le premier testé est le modèle de Hopfield avec un apprentissage non supervisé. Le second est le modèle Learning Vector Quantization qui a un apprentissage compétitif. 5.1 Modèle de Hopfield Le réseau de neurones de Hopfield est un type particulier de réseau de neu- rones récurrent qui peut se comporter comme une mémoire auto-associative. Cette dernière, contrairement aux mémoire habituellement utilisée, qui per- mettent de trouver un élément grâce à une adresse qui lui est associée, peut trouver un élément avec une partie, ou même une déformation de celui-ci. Elle est également appelée mémoire adressable par contenu. Ainsi, on peut très bien donner une entrée bruitée et retrouver l’élément voulu. Ce type de réseau est utilisé pour l’association ou la reconstruction d’un élément depuis un élément proche. KHAIROS GROUP 20
  • 21. OpenCR Page 21 sur 42 5.1.1 Caractéristiques du modèle Nous allons implémenter un réseau de neurones de Hopfield en temps discret, basé sur une variante du modèle de McCulloch-Pitts. Dans ce modèle, les neurones ont deux états, l’état "allumé" et l’état éteint, représentés respectivement par les valeurs +1 et -1. Une paire de neurones i et j sont liés par le poids wij qui peut être interprété comme étant l’influence du neurone i sur j (et réciproquement). On a donc W, la matrice de poids telle que : Les neurones se mettent à jour de manières asynchrones. Il y a deux phases dans un réseau de Hopfield, la "phase de stockage" et la "phase de récupération ". Lors de la première phase, on stocke des caractères de N-dimensions. Ceux-ci pourront être récupéré lors de la seconde phase lorsqu’ils auront été donné au réseau en tant que "caractères d’entraînement". FIGURE 11 – Réseau de Hopfield 5.1.2 Algorithme Au tout début, on stocke des caractères a1, a2, ..., ap composés uniquement de +1 ou -1. Ensuite, il nous faut calculer la matrice de poids, pour cela on utilise la règle d’apprentissage de Hebb, que l’on peut résumer par KHAIROS GROUP 21
  • 22. OpenCR Page 22 sur 42 Il faut noter que la matrice de poids a un axe de symétrie, qui est la diagonale, puisque Il faut remarquer que wii = 0, signifie que les neurones ne se connectent pas à eux-même. On doit ensuite mettre à jour a(k) : Où sgn est définie comme suit : Pendant l’itération, si on a : Alors, on ne continue pas et a est stable, donc, la sortie sera Y = afixed, sinon on recommence depuis la mise à jour de a(k). Il est à noté que le réseau a une capacité de stockage de : KHAIROS GROUP 22
  • 23. OpenCR Page 23 sur 42 FIGURE 12 – Modèle de Hopfield en temps discret Où n est la dimension des caractères. On peut ainsi schématiser un réseau de neurones de Hopfield, de cette manière : 5.1.3 Convergence vers un attracteur La symétrique des connexions entre neurones et l’itération pour la mise à jour du réseau, permettent de démontrer l’existence d’une fonction monotone au cours de l’itération, nous permettant d’appliquer le théorème de Lyapounov qui démontre que la période des attracteurs vaut 1. Ainsi, par analogie avec les systèmes magnétiques (sur lesquels le principe de Hopfield est basé), on peut définir "l’énergie" d’un état à un certain instant du réseau, par : Cette valeur est appelée "énergie" car, lors du choix aléatoire des unités à mettre à jour, cette "énergie" va soit diminuer, soit stagner (Figure 7). Après plusieurs mises à jour, le réseau convergera finalement vers un état qui est un minimum local de la fonction de Lyapounov. De ce fait, si un état est un minimum local de cette fonction, il sera un état stable du réseau, et donc un attracteur. La convergence vers un attracteur est généralement assurée puisque Hop- field a prouvé que les attracteur de son système dynamique non-linéaire sont KHAIROS GROUP 23
  • 24. OpenCR Page 24 sur 42 stables. Bien-sûr, les attracteurs ne sont pas les même en fonctions des états avec lesquels le système a été initialisé. FIGURE 13 – Bassin d’attraction 5.1.4 En pratique Pour nos premiers test, nous utilisions 3 lettres (A, B et C) sous forme de tableaux de −1 ou +1. Il y avait les caractères que le réseau connaissait et ceux qui étaient dégradés ou bruités, que le réseau devait reconnaître. Le réseau a eu un taux de réussite très élevé. Maintenant, nous prenons les caractères extraits depuis l’image et char- geons un "charset" contenant l’alphabet que doit connaître le réseau. Nous avons testé avec le "8" et le "T", la reconnaissance fonctionne très bien. L’al- gorithme partant du principe que l’image à reconnaître a une taille fixe, il faut donc un algorithme pour re-dimensionner le caractère extrait, ce qui n’est pas encore implémenté, c’est-à-dire que la taille est fixée pour le moment. De plus, le réseau de neurones ne fait que converger vers le bon caractère, il n’est pas capable de nous dire clairement la lettre qu’il viendrait de reconnaître. Pour palier ce problèmes, nous avons implémenté un système de "signatures". 5.1.4.a Système de signatures Ce système calcule, pour chaque caractère connu par le réseau, une si- gnature pour chaque lettre qu’il peut calculer à partir de l’image de celle-ci, et donc lorsque le réseau converge vers le caractère, il calculera sa signature et comparera avec le tableau signatures qu’il a déjà calculé, dans lequel on associe lettre et signature, pour pouvoir déterminer la lettre reconnue, ainsi le réseau peut associer lettre et pattern. KHAIROS GROUP 24
  • 25. OpenCR Page 25 sur 42 Pour ce faire, on a calculé ceci pour chaque caractère : Signature = I,J i=0,j=0 ai ∗ (i ∗ I + j), avec I la longueur maximale du carac- tère et J sa largeur maximale. 5.1.4.b Cas particulier Il a aussi été remarqué que la limite sur la capacité de stockage pouvait provoquer la convergence du réseau de neurones vers des états stables différents de ceux qui sont stocké (Spurious states en anglais), le plus souvent ils étaient l’inverse du caractère stocké. Ce qu’on peut faire, c’est qu’en calculant la signature de la lettre, on calcul la signature de son inverse également. De ce fait, on comparera la signature du caractère reconnu avec la signature de la lettre de base, ainsi que celle de son inverse. Finalement, on pourra gérer ce cas particulier, mais seulement en partie puisque parfois il converge vers un mélange de l’inverse et de l’original. 5.2 Learning Vector Quantization Le second modèle testé, est le Learning Vector Quantization qui est un mo- dèle à apprentissage compétitif. Ce modèle se base sur une approche "Winner- take-all" et un apprentissage de Hebb. Il se compose d’une couche compétitive suivie d’une couche linéaire. Ce qui suit va décrire l’architecture du réseau, en commençant par sa couche compétitive. 5.2.1 Self Organizing Feature Maps Le système des Self Organizing Feature Maps, aussi appelé "Réseau de Ko- honen", possède une structure en "feed-forward", c’est-à-dire que les connec- tions entre neurones ne forment pas de cycle. Ce système possède une couche nommée "Computational layer" avec un certain nombre de lignes et colonnes. Chaque neurone est connecté à tous les éléments en entrée. Le but est d’apprendre une "Feature Map" à partir de l’espace continu des entrées, pour l’espace discret en sortie, composé de neurones disposés sous forme de grille. KHAIROS GROUP 25
  • 26. OpenCR Page 26 sur 42 FIGURE 14 – Self Organizing Map L’algorithme se présente sous cette forme : -Initialisation : On choisi des valeur au hasard pour le vecteur de poids wj. -On choisi un vecteur d’entraînement x dans l’espace d’entrée. -On trouve le neurone gagnant I(x) dont le vecteur de poids est le plus proche du vecteur en entrée, tel que le minimum est : dj(x) = D i=0(xi − wji)2. -On met à jour les poids, tel que : ∆wji = η(t)Tj,I(x)(xi − wji), où Tj,I(x) est une fonction donnant donnant un voisinage Gaussien et η(t) le taux d’ap- prentissage. -On revient à la deuxième étape, tant que la feature map continue de chan- ger. Lorsque la self organizing feature map est stabilisée, on obtient des carac- téristiques importantes de l’espace en entrée du réseau. Ainsi, depuis un vecteur x, la feature map Φ nous donne un neurone gagnant I(x) dans l’espace en sortie et le vecteur de poids wI(x) fournit les coordonnées de l’image du neurone dans l’espace en entrée. 5.2.2 Vector Quantization On remarque précédemment, que les Self Organizing Feature Maps per- mettent d’obtenir un plus petit ensemble d’éléments wI(x) fournissant un bon moyen d’approximer des représentants des éléments en entrée. KHAIROS GROUP 26
  • 27. OpenCR Page 27 sur 42 FIGURE 15 – Propriétés On appelle ceux-ci des "Code-book vectors". Ceci est le principe de base des "Vector Quantization", c’est-à-dire, d’avoir une sorte de compression des données en entrée. On peut connaître l’erreur des Vector Quantization par le calcul d’une distance Euclidienne, telle que : Les doubles barres représentent la norme Euclidienne. Ce calcul nous donne la distance entre les vecteur x en entrée et leurs représentants wI(x). Celle-ci doit être la plus petite possible. Il faut remarquer qu’en utilisant un gradient descendant sur D, on arrive à obtenir l’étape de mise à jour des poids des Self Organizing Feature Maps, ce qui confirme que cette étape de mise à jour est la manière la plus optimale pour approximer les vecteurs en entrée du réseau. 5.2.2.a Encodage-Décodage On peut représenter les Vector Quantization avec un système constitué d’encodeur et de décodeur. Posons c(x) l’encodeur du vecteur x en entrée et x (x) le décodeur de c(x), on peut grâce à cela, revenir à x avec une perte minimale d’information. KHAIROS GROUP 27
  • 28. OpenCR Page 28 sur 42 FIGURE 16 – Modèle d’encodage-décodage On choisi le vecteur x en entrée de manière aléatoire avec une fonction de probabilité p(x). Ainsi, on a le taux d’erreur suivant : 5.2.2.b Algorithme de Lloyd Généralisé Comme vu précédemment, il faut qu’on puisse minimiser D au maximum, de ce fait, on utilise l’algorithme de Lloyd généralisé. Celui-ci repose sur deux conditions, qui sont les suivantes : 1. A partir d’un vecteur x en entrée, on choisi c = c(x), tel qu’on puisse minimiser cette distance : 2. En prenant c, on calcule x (c) tel que la valeur puisse être un centroïde d’une cellule de Voronoi dans un Diagramme de Voronoi et que la condition 1 soit satisfaite. Pour les Vector Quantization, on calcule le minimum de la distance pour c(x) avec la condition 1 et on décode en fonction de la condition 2, jusqu’à avoir le D minimum. Grâce à cela, on peut voir que les Self Organizing Feature Maps et les systèmes de Vector Quantization modélisé par un système de Décordage- Encodage, ont une correspondance, puisque l’encodeur correspônd à trouver le meilleur neurone I(x), le décodage x (x) correspond à calculer les poids KHAIROS GROUP 28
  • 29. OpenCR Page 29 sur 42 FIGURE 17 – Diagramme de Voronoi - "+" représente un centroïde FIGURE 18 – Tessellation centroïdale de Voronoi wj et la foction de probabilité p(x) correspond à la fonction Gaussienne de recherche de voisins Tj,I(x). 5.2.3 Le modèle LVQ Le Learning Vector Quantization est une méthode à apprentissage supervisé de Vector Quantization que l’on peut utiliser quand on a des données en entrées, auxquelles on a au préalable, donné une classe (ou "cluster"). FIGURE 19 – Learning Vector Quantization KHAIROS GROUP 29
  • 30. OpenCR Page 30 sur 42 Au début, chaque neurones est désigné comme appartenant à un cluster. Le neurone avec le vecteur de poids le plus proche est déclaré vainqueur. Lorsque le neuronne est vainqueur, on regarde s’il est dans le bon cluster, si c’est le cas, il est récompensé, sinon, il est "éloigné" du vecteur en entrée : 5.2.3.a Entraînement L’entraînement ce fait de la manière suivante : -Initialisation : On donne des poids au hasard, puis on met un taux d’ap- prentissage -Pour chaque vecteur x : –. On cherche le neurone k gagnant, tel que : –. On met à jours les poids w, tels que : -On ajuste le taux d’apprentissage. Celui-ci se réduit avec les itérations. -On arrête, si les conditions sont réunies, sinon, on revient à la deuxième étape 5.3 Choix du réseau Après de nombreux tests, nous avons opté pour le modèle Learning Vector Quantization puisqu’il intègre un modèle supervisé d’apprentissage et qu’il n’a dont pas les problèmes qui amènent à trouver une interprétation à la sortie KHAIROS GROUP 30
  • 31. OpenCR Page 31 sur 42 du réseau, comme ça a été le cas avec le modèle de Hopfield pour lequel nous avons mis au point un système de signatures. De même, le modèle de Hopfield ne prend qu’un nombre particulier d’en- trées à reconnaître, c’est-à-dire qu’il faut lui passer les éléments à reconnaître par paquets, ce qui complique les choses. Ce n’est pas le cas du modèle Lear- ning Vector Quantization puisqu’il peut prendre aussi bien un très grand qu’un petit nombre d’entrée, et les traiter. Pour ces raisons, le modèle Learning Vector Quantization nous a paru être la solution la plus viable pour le projet. KHAIROS GROUP 31
  • 32. OpenCR Page 32 sur 42 6 Interface Graphique Pour l’interface graphique nous utilisons GTK qui fournit de bonnes bases pour pouvoir créer une interface propre et efficace. Une fois la structure de tout code de base utilisant GTK intégrée, il a fallut commencer à créer l’interface. L’interface est composée de boutons, zones de textes et boutons plus spécifiques permettant de charger les fichiers désirés. Ces éléments sont des widgets qui s’agencent au sein de boîtes qui permettent de compartimenter les zones de l’interface pour pouvoir les gérer séparément, comme on le ferait avec un site web et le css. Les boîtes peuvent être hori- zontales ou verticales, on peut donc agencer les widgets de deux manières au sein de ces boîtes, qui peuvent elles même s’emboîter les unes dans les autres. Cette mécanique offre de quoi modeler une interface selon nos besoins. FIGURE 20 – Aperçu de l’interface graphique KHAIROS GROUP 32
  • 33. OpenCR Page 33 sur 42 4 7 Optimisations Afin d’obtenir les meilleurs performances pour notre projet et de tirer parti des architectures fortement parallélisée de nos machines, nous avons tenté de paralléliser ce qui pouvait l’être. Dans un premier temps, ce qui a été fait n’est que négligeable puisque l’optimisation ne s’effectue que sur une petite partie du réseau de neurone, mais pour la prochaine soutenance, nous allons essayer de le faire le plus possible. Il faut noter que certains problèmes apparaissent. Par exemple, dans certains cas où les threads se partagent une tâche, ils peuvent corrompre les données qui vont ensuite être utilisée par un autre thread. Un autre exemple est la mauvaise utilisation des threads qui peut mener à une dégradation des performances, parfois significative. Prenons pour exemple, le cas où il y a plus de threads software que de threads hardware, ceux-ci auront chacun un travail à effectuer et celui-ci peut-être trop rapide à effectuer comparé aux coûts d’initialisation et de fermeture des threads créés. De plus, les threads doivent chacun patienter qu’un thread ait fini d’utiliser une ressource partagée pour continuer. Dans ce même cas, le système d’exploitation doit gérer équitablement les threads, il leur donne donc chacun un temps d’exécution limite après quoi, le scheduler mettra en suspend le thread courant, provoquant un coût en ressources puisqu’il y aura sauvegarde puis restauration des états des registres CPU ainsi que de ces caches (ce qui est plus grave). Ce dernier cas est plutôt grave, puisque chaque thread va mettre des données dans le cache qui sont très rapide, mais très petit, et donc lorsqu’un nouveau thread viendra mettre les données de son contexte, il ira expulser les données du thread précédent et ainsi de suite. Il se passe la même chose au niveau de la mémoire virtuelle. Il y a beaucoup d’autres cas, comme celui du thread lock, qui peuvent être très dégradants en terme de performances. KHAIROS GROUP 33
  • 34. OpenCR Page 34 sur 42 Tous les cas précédents sont des cas auxquels nous avons fait face. Cela nous montre que paralléliser une tâche peut être complexe, il faut donc bien le gérer, au risque de dégrader les performances, voire d’avoir des résultats inat- tendus. De fait, il faudra prendre le temps d’évaluer les gains en performances pour voir si le fait de paralléliser une telle application est viable. De ce fait, et par certaines contraintes de temps, bien que nous ayons fait face à tous ces problèmes, nous avons abandonné la voie du parallélisme et nous sommes simplement concentrés sur l’optimisation au niveau du corps des algorithmes. KHAIROS GROUP 34
  • 35. OpenCR Page 35 sur 42 8 Site Internet Le site est entièrement en responsive design et s’adapte donc à quasiment toutes les situations. Il est sobre et intuitif. Les informations importantes sont mises en avant et sont accessibles rapidement. Le site est auto-hébergé sur une petite machine tournant sous Archlinux et est disponible à l’adresse ‘opencr.heckp.com’. FIGURE 21 – Aperçu du site KHAIROS GROUP 35
  • 36. OpenCR Page 36 sur 42 9 Conclusion Lors de la réalisation de chacune de nos parties, nous avons appris à faire en sorte que les solutions développées soient le plus efficaces possibles et ce, afin de permettre un confort de développement allié à un résultat performant. Nous avons tous appris que le travail en équipe était primordial afin de mener à bien ce projet. Évidemment, ce genre de projet a impliqué des désac- cords entre les membres qui ont pu être résolu au travers de discussions et de recherches sur le sujet en question. Finalement, nous avons développé des capacités d’apprentissage en auto- nomie, tout en sachant coordonner notre travail au sein de notre équipe. De plus, ce projet nous a mis face aux contraintes du milieu entrepreneurial, comme le fait que nous ayons un cahier des charges à respecter, tout en travaillant dans une entente cordiale. KHAIROS GROUP 36
  • 37. OpenCR Page 37 sur 42 Annexes A Signification des barres de couleurs Chaque titre des parties de ce rapport est précédé d’une barre de couleur. Celle-ci représente l’étudiant qui a réalisé le travail dont il est question dans la partie correspondante. Les couleurs sont attribuées de cette manière : Chady DIMACHKIE Guillaume AIGUEPERSE Jerry MAILLOT Alexandre SOBRAL MARTINS Il y a également une couleur représentant le groupe : Khairos Group KHAIROS GROUP 37
  • 38. OpenCR Page 38 sur 42 B Références -"Neural Networks and Physical Systems with Emergent Collective Com- putational Abilities", P.N.A.S. USA, vol. 79 (1982), 2554-2558 -"Analysis of Hopfield Autoassociative Memory in the Character Recog- nition", Yash Pal Singh et al. / (IJCSE) International Journal on Computer Science and Engineering Vol. 02, No. 03, 2010, 500-503 -"Hopfield Network", Alice Julien-Laferriere de l’ENS Lyon -"Hopfield and recurrent networks", lien : http ://iitkgp.vlab.co.in/userfiles/9/file/Hopfield%20network%281%29.pdf -"NEURAL NETWORK - BASED ENGLISH ALPHANUMERIC CHA- RACTER RECOGNITION", International Journal of Computer Science, Engi- neering and Applications (IJCSEA) Vol.2, No.4, August 2012 -Z.B. Xu, Y.Leung and X.W.He,” Asymmetrical Bidirectional Associative Memories”, IEEE Transactions on systems, Man and cybernetics, Vol.24, PP.1558-1564, Oct.1994. -Jehoshua Bruck. "On the convergence properties of the Hopfield model". Procceedings of the IEEE, 78(10), October 1990. -Wikipedia : "Hopfield network", "Associative memory", "Recurrent neural network" -"Les réseaux de Hopfield", lien : http ://agerodol.pagesperso-orange.fr/hopfield.html -R. Rojas : "Neural Networks", Springer-Verlag, Berlin, 1996 -"Hopfield Networks", lien : http ://www.comp.leeds.ac.uk/ai23/reading/Hopfield.pdf -Wikipedia : "Hough transform" -http ://fr.mathworks.com/help/nnet/ug/learning-vector-quantization-lvq- neural-networks-1.html -http ://www.wikiwand.com/en/Voronoidiagram -http ://www.willamette.edu/ gorr/classes/cs449/Unsupervised/competitive.html -http ://www.wikiwand.com/en/Winner-take-all -http ://www.labbookpages.co.uk/software/imgProc/otsuThreshold.html KHAIROS GROUP 38
  • 39. OpenCR Page 39 sur 42 -http ://www.doc.ic.ac.uk/ nd/surprise96/journal/vol4/cs11/report.html -LVQ by Kohonen : http ://www.cis.hut.fi/research/lvqpak/lvqdoc.txt -http ://www.wikiwand.com/en/Otsu KHAIROS GROUP 39
  • 40. OpenCR Page 40 sur 42 Table des figures 1 Résultat - Grayscale . . . . . . . . . . . . . . . . . . . . . . . 6 2 Résultat - Grayscale . . . . . . . . . . . . . . . . . . . . . . . 9 3 Exemple d’histogramme . . . . . . . . . . . . . . . . . . . . 10 4 Résultat - Page de livre . . . . . . . . . . . . . . . . . . . . . 11 5 Avant la rotation . . . . . . . . . . . . . . . . . . . . . . . . . 12 6 Après la rotation . . . . . . . . . . . . . . . . . . . . . . . . 12 7 Run-Lenght Smoothing Algorithm . . . . . . . . . . . . . . . 15 8 Disjoint-Sets . . . . . . . . . . . . . . . . . . . . . . . . . . 16 9 Connected Components Labeling . . . . . . . . . . . . . . . . 17 10 Détection de caractères - QCM ALGO . . . . . . . . . . . . . 19 11 Réseau de Hopfield . . . . . . . . . . . . . . . . . . . . . . . 21 12 Modèle de Hopfield en temps discret . . . . . . . . . . . . . . 23 13 Bassin d’attraction . . . . . . . . . . . . . . . . . . . . . . . 24 14 Self Organizing Map . . . . . . . . . . . . . . . . . . . . . . 26 15 Propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 16 Modèle d’encodage-décodage . . . . . . . . . . . . . . . . . 28 17 Diagramme de Voronoi - "+" représente un centroïde . . . . . 29 18 Tessellation centroïdale de Voronoi . . . . . . . . . . . . . . . 29 19 Learning Vector Quantization . . . . . . . . . . . . . . . . . . 29 20 Aperçu de l’interface graphique . . . . . . . . . . . . . . . . 32 21 Aperçu du site . . . . . . . . . . . . . . . . . . . . . . . . . . 35 KHAIROS GROUP 40
  • 41. OpenCR Page 41 sur 42 Table des matières 1 Introduction 3 2 Le groupe 4 2.1 Chady DIMACHKIE . . . . . . . . . . . . . . . . . . . . . . 4 2.2 Guillaume AIGUEPERSE . . . . . . . . . . . . . . . . . . . 4 2.3 Jerry MAILLOT . . . . . . . . . . . . . . . . . . . . . . . . 5 2.4 Alexandre SOBRAL MARTINS . . . . . . . . . . . . . . . . 5 3 Prétraitement de l’image 6 3.1 Filtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 3.1.1 Le filtre médian . . . . . . . . . . . . . . . . . . . . . 7 3.2 La convolution . . . . . . . . . . . . . . . . . . . . . . . . . 8 3.3 Binarisation . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 3.3.1 La méthode classique . . . . . . . . . . . . . . . . . . 9 3.3.2 Méthode avec le seuil local . . . . . . . . . . . . . . . 10 3.3.3 Méthode d’OTSU . . . . . . . . . . . . . . . . . . . . 10 3.4 Rotation de l’image . . . . . . . . . . . . . . . . . . . . . . . 12 4 Extraction des caractères 14 4.1 Détection des blocs de texte . . . . . . . . . . . . . . . . . . 14 4.1.1 Run-Length Smoothing Algorithm . . . . . . . . . . . 14 4.1.2 Connected Components Labeling . . . . . . . . . . . 15 4.1.2.a Union–Find Data Structure . . . . . 16 4.1.3 Extraction des lignes . . . . . . . . . . . . . . . . . . 17 4.2 Détection de caractères . . . . . . . . . . . . . . . . . . . . . 18 4.3 Remarque . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 5 Réseau de neurones 20 5.1 Modèle de Hopfield . . . . . . . . . . . . . . . . . . . . . . . 20 5.1.1 Caractéristiques du modèle . . . . . . . . . . . . . . . 21 5.1.2 Algorithme . . . . . . . . . . . . . . . . . . . . . . . 21 KHAIROS GROUP 41
  • 42. OpenCR Page 42 sur 42 5.1.3 Convergence vers un attracteur . . . . . . . . . . . . . 23 5.1.4 En pratique . . . . . . . . . . . . . . . . . . . . . . . 24 5.1.4.a Système de signatures . . . . . . . . 24 5.1.4.b Cas particulier . . . . . . . . . . . . 25 5.2 Learning Vector Quantization . . . . . . . . . . . . . . . . . . 25 5.2.1 Self Organizing Feature Maps . . . . . . . . . . . . . 25 5.2.2 Vector Quantization . . . . . . . . . . . . . . . . . . 26 5.2.2.a Encodage-Décodage . . . . . . . . . 27 5.2.2.b Algorithme de Lloyd Généralisé . . 28 5.2.3 Le modèle LVQ . . . . . . . . . . . . . . . . . . . . . 29 5.2.3.a Entraînement . . . . . . . . . . . . . 30 5.3 Choix du réseau . . . . . . . . . . . . . . . . . . . . . . . . . 30 6 Interface Graphique 32 7 Optimisations 33 8 Site Internet 35 9 Conclusion 36 Annexes 37 A Signification des barres de couleurs 37 B Références 38 KHAIROS GROUP 42