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