Rapport de soutenance
EPITA•2014-2015KhairosGroup
Chady DIMACHKIE
Guillaume AIGUEPERSE
Alexandre SOBRAL MARTINS
Jerry MAIL...
OpenCR Page 2 sur 42
Sommaire
1 Introduction 3
2 Le groupe 4
2.1 Chady DIMACHKIE . . . . . . . . . . . . . . . . . . . . ....
OpenCR Page 3 sur 42
1 Introduction
Dans le cadre du projet de la seconde année nous devons réaliser un logiciel
de reconn...
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...
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 scienti...
OpenCR Page 6 sur 42
3 Prétraitement de l’image
Pour avoir une détections de caractères ainsi qu’une reconnaissance de
ceu...
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 ...
OpenCR Page 8 sur 42
3.2 La convolution
Dans un traitement d’images, l’application d’un filtre de convolution
consiste à re...
OpenCR Page 9 sur 42
Nous allons donc remplacer la valeur du pixel qui est de 50 dans notre cas, par
51.
Nous avons plusie...
OpenCR Page 10 sur 42
en niveau de gris, puis on doit parcourir son tableau de pixels et comparer pour
chaque pixels, leur...
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 =...
OpenCR Page 12 sur 42
3.4 Rotation de l’image
Pour effectuer la rotation, on utilise simplement une matrice de rotation. I...
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 ...
OpenCR Page 14 sur 42
4 Extraction des caractères
Dans un OCR, nous avons besoin de reconnaître des caractères. Pour cela,...
OpenCR Page 15 sur 42
-Les pixels NOIR restent inchangés en sortie.
FIGURE 7 – Run-Lenght Smoothing Algorithm
Cet algorith...
OpenCR Page 16 sur 42
Bien que cette méthode soit simple, celle-ci possède certains problèmes,
puisqu’à partir de certaine...
OpenCR Page 17 sur 42
Tout ceci est fait avec un vecteur PARENT dont les indices forment l’en-
semble des labels possibles...
OpenCR Page 18 sur 42
Grace à cela, on va pouvoir trouver les coordonnées de nos lignes.
Il suffit de parcourir le tableau,...
OpenCR Page 19 sur 42
FIGURE 10 – Détection de caractères - QCM ALGO
Il faut aussi remarquer, que nous travaillons sur des...
OpenCR Page 20 sur 42
5 Réseau de neurones
Pour reconnaître les caractères, nous avons besoin d’un élément permettant
cett...
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
d...
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 re...
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 s...
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...
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), a...
OpenCR Page 26 sur 42
FIGURE 14 – Self Organizing Map
L’algorithme se présente sous cette forme :
-Initialisation : On cho...
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 ...
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 un...
OpenCR Page 29 sur 42
FIGURE 17 – Diagramme de Voronoi - "+" représente un centroïde
FIGURE 18 – Tessellation centroïdale ...
OpenCR Page 30 sur 42
Au début, chaque neurones est désigné comme appartenant à un cluster. Le
neurone avec le vecteur de ...
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 sy...
OpenCR Page 32 sur 42
6 Interface Graphique
Pour l’interface graphique nous utilisons GTK qui fournit de bonnes bases
pour...
OpenCR Page 33 sur 42
4
7 Optimisations
Afin d’obtenir les meilleurs performances pour notre projet et de tirer parti
des a...
OpenCR Page 34 sur 42
Tous les cas précédents sont des cas auxquels nous avons fait face. Cela
nous montre que parallélise...
OpenCR Page 35 sur 42
8 Site Internet
Le site est entièrement en responsive design et s’adapte donc à quasiment
toutes les...
OpenCR Page 36 sur 42
9 Conclusion
Lors de la réalisation de chacune de nos parties, nous avons appris à faire
en sorte qu...
OpenCR Page 37 sur 42
Annexes
A Signification des barres de couleurs
Chaque titre des parties de ce rapport est précédé d’u...
OpenCR Page 38 sur 42
B Références
-"Neural Networks and Physical Systems with Emergent Collective Com-
putational Abiliti...
OpenCR Page 39 sur 42
-http ://www.doc.ic.ac.uk/ nd/surprise96/journal/vol4/cs11/report.html
-LVQ by Kohonen : http ://www...
OpenCR Page 40 sur 42
Table des figures
1 Résultat - Grayscale . . . . . . . . . . . . . . . . . . . . . . . 6
2 Résultat -...
OpenCR Page 41 sur 42
Table des matières
1 Introduction 3
2 Le groupe 4
2.1 Chady DIMACHKIE . . . . . . . . . . . . . . . ...
OpenCR Page 42 sur 42
5.1.3 Convergence vers un attracteur . . . . . . . . . . . . . 23
5.1.4 En pratique . . . . . . . . ...
Prochain SlideShare
Chargement dans…5
×

OpenCR__Rapport_soutenance_Finale

201 vues

Publié le

0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
201
Sur SlideShare
0
Issues des intégrations
0
Intégrations
10
Actions
Partages
0
Téléchargements
1
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

OpenCR__Rapport_soutenance_Finale

  1. 1. Rapport de soutenance EPITA•2014-2015KhairosGroup Chady DIMACHKIE Guillaume AIGUEPERSE Alexandre SOBRAL MARTINS Jerry MAILLOT
  2. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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

×