ocr .pdf



Nom original: ocr.pdf

Ce document au format PDF 1.5 a été généré par TeX / pdfTeX-1.40.17, et a été envoyé sur fichier-pdf.fr le 16/06/2017 à 16:26, depuis l'adresse IP 82.240.x.x. La présente page de téléchargement du fichier a été vue 994 fois.
Taille du document: 1.1 Mo (28 pages).
Confidentialité: fichier public


Aperçu du document


Rapport de Soutenance
OCRIssou :

Borne Ianis - Cornet Pierre- Joseph ThéophaneBellec Julien

Table des matières
1 Introduction

4

2 Information générales

5

2.1

Présentation des membres . . . . . . . . . . . . . . . . .

5

2.1.1

Pierre Cornet . . . . . . . . . . . . . . . . . . . .

5

2.1.2

Ianis Borne . . . . . . . . . . . . . . . . . . . . .

6

2.1.3

Julien Bellec . . . . . . . . . . . . . . . . . . . . .

6

2.1.4

Théophane Joseph . . . . . . . . . . . . . . . . .

6

2.2

Répartition des tâches . . . . . . . . . . . . . . . . . . .

7

2.3

Avancement du projet . . . . . . . . . . . . . . . . . . .

7

3 Interface

8

4 Segmentation

9

4.1

4.2

Découpage . . . . . . . . . . . . . . . . . . . . . . . . . .

9

4.1.1

Début et aspect visuel du découpage . . . . . . .

9

4.1.2

Extraction des caractères et espaces . . . . . . . .

11

Pré-traitement . . . . . . . . . . . . . . . . . . . . . . . .

13

4.2.1

Le Run Length Smoothing Algorithm (RLSA) . .

13

4.2.2

Traitement du bruit

16

. . . . . . . . . . . . . . . .

5 Réseau de neurones
5.1

17

Implémentation du réseau de neurones . . . . . . . . . .

6 Réseau de neurones

17
18

6.0.1

Le neurone

. . . . . . . . . . . . . . . . . . . . .

18

6.0.2

La couche (layer) . . . . . . . . . . . . . . . . . .

19

6.1

le reseaux neuralNet . . . . . . . . . . . . . . . . . . . .

20

6.2

Sauvegarde et Chargement d’un réseau de neurones . . .

21

Info Spe

EPITA 2021

6.3

Apprentissage . . . . . . . . . . . . . . . . . . . . . . . .

21

6.4

L’exemple d’un réseau : la fonction Xor . . . . . . . . . .

24

7 La Reconnaissance Optique de Caractère

25

8 Conclusion

28

OCRissou

page 3

IanisX

Info Spe

1

EPITA 2021

Introduction
Le but de ce projet est de mettre en place un OCR (Optical Charac-

ter Recognition), un logiciel permettant d’extraire le texte d’une image
source et de l’envoyer dans un document texte dans le but de pouvoir
éditer ce texte par la suite. Pour cela nous utilisons le langage de programmation C, la librairie SDL (Simple DirectMedia Layer) et la librairie
GTK 3 agrementee de l’outil Glade pour réaliser l’interface.

OCRissou

page 4

IanisX

Info Spe

2

EPITA 2021

Information générales

2.1
2.1.1

Présentation des membres
Pierre Cornet

Depuis de nombreuses années, je suis passionné par tout ce qui se
rattache à l’univers du numérique et de l’informatique. C’est pourquoi
dès la fin de ma seconde je me suis fixé comme objectif de rentrer à
l’EPITA.
Lors de mon arrivée à EPITA je n’avais encore que peu de connaissance en programmation (en dehors de connaissances en Python). J’ai fait
de gros progrès depuis mon arrivée à l’EPITA mais je manquais encore
de connaissances en C.
Ce projet est donc important pour moi car il me permet de faire de
gros progrès en C en me faisant envisager un projet complet en C.
De plus après l’échec cuisant de mon projet de SUP ce projet possède
aussi une importance pour moi au niveau de la gestion de groupe car cette
fois encore je suis chef de projet et la réussite de ce projet me permettrait
d’acquérir plus de confiance dans mes futurs projets.
Toutefois, je ne suis pas très emballé par le sujet de ce projet : je suis
bien plus intéressé par tout ce qui touche au réseau et au code affectant
les systèmes des machines. Toutefois je ferais tout pour mener à bien ce
projet.

OCRissou

page 5

IanisX

Info Spe

2.1.2

EPITA 2021

Ianis Borne

Après avoir redoublé mon premier semestre à l’EPITA, je me suis
rendu compte de la quantité de travail qu’il fallait fournir dans ce cursus. Mes compétences en programmation sont uniquement issues d’Epita,
entre cours dirigés et apprentissage personnel j’ai beaucoup progressé et
j’espère pouvoir le montrer lors de projets. Ce projet represente beaucoup de temps de travail de recherche et de cohabitaion avec le groupe
de travail.

2.1.3

Julien Bellec

Je suis arrivé à Epita il y a plus d’un an, sans aucune expérience en
langage de programmation. J’ai appris le C# en S2 ce qui a permis de
garder certaines marques quant au passage au C en S3. Le projet d’OCR
m’a tout de suite intéressé et le fait de pouvoir faire apprendre à l’ordinateur fut une perspective intéressante.
C’est donc pour cela que je me suis attelé à la mise en place de notre
réseau de neurones. Ce projet est également pour moi l’occasion d’approfondir mes connaissances en C.
2.1.4

Théophane Joseph

Contrairement à beaucoup dans cette formation, je ne me suis intéressé à l’informatique seulement pendant l’année de terminale scientifique. Je ne regrette pas mon choix, j’aime les matières que l’on nous
propose et les enjeux qui s’imposent à nous, futurs ingénieurs (ou pas),
etc. Le projet représente une grande partie de notre travail, je mise maintenant dessus pour m’apprendre les subtilités du C et m’améliorer en
manipulation d’images.
OCRissou

page 6

IanisX

Info Spe

2.2

EPITA 2021

Répartition des tâches

Ianis Pierre Julien Théophane
Interface

x

x

Découpage de l’image

x

x

Pré-traitement

x

x

Réseau de neurone

x

x

XOR

x

x

svg/cgt du réseau de neurone

x

x

2.3

Avancement du projet
Travail réalisé :
Interface

75%

Découpage de l’image

100%

Pré-traitement

100%

Réseau de neurone

100%

Réseau XOR

100%

svg/cgt d’un réseau de neurones

100%

OCRissou

page 7

IanisX

Info Spe

3

EPITA 2021

Interface
Pour l’interface de notre projet, nous utilisons GTK 3+, l’outil de

référence pour les projets en C, ainsi que Glade qui permet une utilisation
simple et ergonomique de l’interface en créant des scripts préfait pour
Gtk. Nous avions prévus grâce a Glade plusieurs panneaux permettant
de naviguer entre l’accueil et un gestionnaire de fichier pour choisir quel
fichier à traitée. Malheureusement l’interface a été traitée en dernier donc
le résultat ne nous satisfait pas. l’interface est lancée par l’exécutable du
projet avec les path de l’image a traiter et le nom du fichier à renvoyée.
Notre interface consiste donc en 2 boutons : un permettant de lancer le
prétraitement et un permettant de lancer l’algorithme de l’OCR.

OCRissou

page 8

IanisX

Info Spe

4

EPITA 2021

Segmentation

4.1

Découpage

Le but du découpage est d’isoler chaque caractère de l’image afin de
pouvoir le transmettre au réseau de neurones pour qu’il soit analysé par
celui-ci. Le découpage peut être découpé en plusieurs parties :
4.1.1

Début et aspect visuel du découpage

Afin de pouvoir pouvoir découper l’image en caractère il a tout d’abord
été nécessaire de passer l’image en nuance de gris puis en noir et blanc.
Afin de réaliser ce passage en noir et blanc il a été nécessaire de parcourir chaque pixel de l’image en relevant leur valeur RGB pour calculer
leur luminance. Si cette luminance est supérieur à un certain seuil alors
les valeurs RGB de ce pixel seront mises à 255 (en blanc), sinon ces valeurs seront mises à 0 (soit en noir). Afin de calculer ce seuil il existe de
nombreuses manières, pour cette première soutenance nous avons choisis
de fixer ce seuil à la valeur 127,soit la moyenne entre 0 et 255. Pour la
dernière soutenance nous envisageons de fixer ce seuil à la moyenne de
la luminance des pixels de l’image.
La seconde étape est le découpage horizontal de l’image. Le but était
de délimiter les lignes des blocs de texte de l’image. Pour cela nous utilisons la fonction findLine qui réunit l’ensemble des différentes opérations
d’affichage et de découpage des lignes. Cette fonction prend en paramètre
une image,ses dimensions ainsi qu’un tableau vide de taille égal à la hauteur de l’image. Nous parcourons donc chaque ligne de l’image. Si la ligne
ne contient que des pixels blancs alors on ajoute un 1 dans ce tableau à
la case correspondante à cette ligne, à l’inverse si la ligne ne contient pas
de pixels blancs on ajoutera un 0. Afin de vérifier si la ligne est blanche

OCRissou

page 9

IanisX

Info Spe

EPITA 2021

on utilisera la fonction whiteLine. On bordera chacune des transitions
de lignes noires aux lignes blanches par une ligne de couleur différente
à l’aide de la fonction colorLine pour obtenir un aspect visuel de ce
traitement.
On va ensuite parcourir toutes les lignes "prélevées" dans le tableau
afin d’isoler des blocs de lignes de pixels que l’on traitera par la suite. On
utilisera la fonction letter qui va détecter les passages de 0 à 1 et de 1 à
0 dans le tableau résultant de findLine et ainsi isoler les blocs de lignes.
Une fois ces blocs bien définis, on va découper les caractères de chaque
lignes. Nous utiliserons pour cela la fonction findColumn, le fonctionnement de cette fonction est similaire à celui de findLine mais appliquée
à un découpage vertical et donc par colonne. On va donc parcourir cette
ligne de gauche à droite en regardant si la colonne est blanche grâce à
whiteColumn. Si on détecte un changement d’une colonne sans pixel
noir à une colonne avec un pixel noir ou plus, alors on va enregistrer la
position et tracer une ligne à l’aide de colorColumn.

OCRissou

page 10

IanisX

Info Spe

4.1.2

EPITA 2021

Extraction des caractères et espaces

Vient maintenant l’extraction des caractères. Ce processus s’effectue
en même temps que la plupart des traitements que nous avons décrit
précédemment.
Le stockage des caractères se fait à l’aide d’un outil en particulier : les
matrices. Ces dernières nous ont permis de placer, dans chacune de leurs
cases, les valeurs des pixels que nous voulions prélever. Ces matrices sont
donc des "struct" comportant la hauteur, la largeur ainsi que le contenu
de la matrice.
Pour extraire nos caractères, on se sert de la fonction de tracé findColumn, qui se chargera de récupérer quatre coordonnées délimitant la
portion d’image qu’il faudra prélever pour extraire un caractère de la
ligne. Ces coordonnées seront ensuite injectés dans l’appel de la fonction
portImgToImg, qui récupérera la portion délimitée. Puis, on convertit
cette nouvelle image, en matrice via la fonction imgToMat.
La prochaine étape est alors de redimensionner la matrice résultante,
dans l’objectif d’obtenir des matrices de mêmes tailles. Nous avons donc
à notre disposition les fonctions suivantes : resize (deux versions), horCut et verCut. La première se décline en deux versions, une qui donnent
des matrices carrées et une autre un peu plus complète qui permet de
choisir les dimensions de la matrice résultante. Les fonctions horCut et
verCut permettent, quant à elles, de raccourcir l’image en enlevant les
lignes vides horizontales et verticales.

OCRissou

page 11

IanisX

Info Spe

EPITA 2021

Enfin, dans l’optique de lier ces caractères entre eux et de les stocker
avant de les envoyer dans le réseau de neurones, nous avons également implémenté une "struct" list, qui représente une liste chaînée. Cette dernière
contient un pointeur *next permettant l’accès à l’élément suivant, une
matrice contenant le caractère et enfin, une variable informant du type
d’espace à utiliser. Nous avons créé deux fonctions liées à cette structure,
toutes deux inspirés du tp Lists, tout d’abord nous avons "initList", qui
comme son nom l’indique, initialise une liste (avec une sentinelle). Puis,
nous avons addList, une fonction qui ajoutera un caractère à la liste chaînée déjà existante.

Or, les espaces sont aussi à prélever. Afin de nous faciliter la tâche, nous
avons implémenté une "struct" endSeg, permettant de stocker dans une
variable entière, le nombre de pixel constituant un espace entre deux
caractères, et permettant également de stocker la matrice contenant l’espace. Encore une fois, findColumn fait le prélèvement des espaces. On
enregistre donc le nombre de pixels entre les caractères dans la variable
de la struct endSeg contenant la valeur d’espace .
Ensuite, la fonction totalAverageSpace nous permettra de calculer l’espace moyen, donc le nombre de pixels blanc moyen, entre chaque caractères ou mots. La fonction endSeg s’occupera, ensuite, de comparer cette
moyenne aux valeurs d’espaces de chaque struct endSeg représentant un
espace. Puis si une valeur est inférieur à la moyenne, elle aura la valeur 0,
si elle est supérieur à la moyenne, elle aura la valeur 2. Les fins de lignes
auront une valeur de -1.

OCRissou

page 12

IanisX

Info Spe

4.2
4.2.1

EPITA 2021

Pré-traitement
Le Run Length Smoothing Algorithm (RLSA)

Le Run Length Smoothing Algorithm est un algorithme publié en
1981 par L. Abele et F. Wahl permettant de segmenter les informations
présentes sur un document. En quelques mots, l’idée consiste à relier les
pixels noirs séparés par moins de n pixels blancs (n étant la précision de
l’algorithme). En faisant varier n, on pourra détecter les paragraphes, les
lignes, etc.
Ainsi, nous avons implémenté cet algorithme dans notre projet. Pendant
tout le long de cet pré-traitement, la fonction copySurface sera très souvent utilisé. Elle consiste en la simple copie de notre image d’origine,
ayant pour but de ne pas modifier notre image d’origine. Nous allons
maintenant décrire les étapes de cet algorithme.
Tout d’abord, nous commençons par effectué un parcours horizontal sur
une copie de l’image original. La fonction horizontalImg, prenant notre
image et un degré de précision n en paramètres, permet de faire ce balayage. En effet, on appelle, dans un premier temps, copySurface afin
d’opérer sur une autre image que celle d’origine, puis on parcourt l’image
de gauche à droite dans l’objectif de trouver un pixel noir. Une fois que
l’on a trouvé un pixel noir, on vérifie si le prochain pixel noir se trouve à
une distance strictement inférieur à la précision n. Si oui, tous les pixels
blanc entre les deux pixels noirs deviennent noir également, sinon on les
laisse tels qu’ils sont.
Ensuite, notre seconde étape est un balayage vertical, nous avons donc
une fonction dans la lignée de horizontalImg, qui s’appelle verticalImg.
Celle-ci a les mêmes paramètres que son prédécesseur et les même principes, cependant on parcourera la copie de notre image (je vous avez dit
qu’on utiliserait souvent cette fonction ) verticalement.
OCRissou

page 13

IanisX

Info Spe

EPITA 2021

La fin de ces deux étapes se marquent par l’obtention de deux images :
une avec des bandes noires horizontales remplaçant les textes (horizontalImg) et une avec des bandes noires verticales (verticalImg). La troisième
sera, naturellement, de mettre en commun les deux images.
Nous allons donc utiliser la fonction eqImg qui prend en paramètres les
deux images et l’image originale. La fonction travaillera sur une copie de
l’image original (encore !) et vérifiera si le pixel (issu de l’image résultante
du balayage horizontal) est noir, tandis que l’on vérifiera si l’autre (celui issu de l’image résultante du balayage vertical) est blanc. Si les deux
conditions sont vérifiés, le pixel résultant (sur la copie de l’image original
cette fois-ci) devient noir, sinon il devient blanc. On fait cela pour tous
les pixels des deux images, on enchaîne ensuite avec un second balayage
horizontale, et ainsi, nous avons délimité les zones de textes.
Il reste alors une dernière étape, mettre en commun l’image original et
celle issu de l’étape précédente. Nous allons donc utiliser la fonction withoutImg, prenant en paramètres les deux images, qui permettra de traiter chaque pixel des deux images. Elle testera si les deux pixels (ceux
des deux images) sont noirs, dans le cas favorable, le pixel de l’image
résultante (copie de l’image originale) sera noir, sinon il sera blanc.
A la fin de cet algorithme de pré-traitement, on obtient une image exploitable ne contenant que les textes d’une image, cependant nous avons
relevé des pertes de pixels et donc des pertes d’information, qui peuvent
fausser la reconnaissance de certains caractères. Il se peut que cela soit
dût à notre degré de précision qui ne soit pas assez adapté au prétraitement.

OCRissou

page 14

IanisX

Info Spe

EPITA 2021

Étape a : Image de base
Étape b : Balayage horizontale
Étape c : Balayage vertical
Étape d : Mise en commun des balayages
Étape e : Images avec seulement les blocs de texte

OCRissou

page 15

IanisX

Info Spe

4.2.2

EPITA 2021

Traitement du bruit

Le bruit des images quant à lui, est la présence d’informations parasites qui s’ajoutent de façon aléatoire aux détails de la scène photographiée numériquement. Cela peut s’avérer problématique pour le bon
fonctionnement de la reconnaissance de caractères.
Nous avons donc implémenté des fonctions qui vont nous permettre de
supprimer le bruit du mieux que nous le pouvons. La fonction removeNoise va essayer de le faire, elle prend en paramètre l’image dont nous
voulons éliminer le bruit et une précision n (valeur entière). Le principe
est que nous allons traiter chaque pixel noir de notre image avec une
fonction nearby (prenant les coordonées du pixel traité ainsi que l’image
traité),qui vérifiera que chacun des pixels ont des pixels voisins noires.
Si le nombre de voisins noirs est inférieur à la précision n, alors le pixel
devient blanc, sinon il reste noir.
Les nuisances produites par des pixels isolés sont donc neutralisés.

OCRissou

page 16

IanisX

Info Spe

5

EPITA 2021

Réseau de neurones

5.1

Implémentation du réseau de neurones

Nos neurones sont composés de 4 paramètres :
- Input, (tableau de double) contenant les entrées possibles (ici les valeurs
binaires 0 ou 1).
- Weight, (tableau de double) contenant les poids de nos neurones.
- err, (double), la marge d’erreur.
- bw, (double), un seuil à atteindre dont dépend la valeur sortante.
La première version de notre réseau de neurones est basse sur l’initialisation de tableaux de double contenant tous les poids, biais et taux
d’erreurs de nos neurones. Tous ces doubles sont initialisés dans la fonction train(). C’est la façon la plus intuitive d’incrémenter nos valeurs, a
l’intérieur de la fonction train() on applique la méthode mathématique
détaillée dans le livre Neural Neutwork and Deep Learning : chaque neurone du layer voit son output actualisé en fonction des inputs et aux
poids de la couche précédente, dans notre réseau XOR deux neurones
sont pris en compte à chaque fois. Puis on actualise les valeurs d’erreurs
de nos neurones en propagation arrière(backpropagation), actuellement
nous le faisons en dur, pour la prochaine soutenance des fonctions sera dédiée à l’actualisation de tous les neurones. Ensuite on actualise les poids
de nos neurones en fonction des inputs du neurone actuel et de l’erreur
précédemment calculé. Comme pour les calculs des erreurs il faudra implémenter une fonction dédiée à cette opération. //

OCRissou

page 17

IanisX

Info Spe

6

EPITA 2021

Réseau de neurones
Pour cette seconde soutenance nous avons refait notre réseau de neu-

rones from scratch grâce a l’expérience acquise pour la première soutenance. L’initialisation des poids, biais et taux d’erreurs sont devenus les
attributs de struct neuron. Les neuron sont contenus dans un autre struct
layer, les layer sont contenus dans notre réseaux sont eux aussi contenue
dans un struct neuralNet.

6.0.1

Le neurone

Dans la première version de notre réseau, nos neurones sont des ensembles de double et de tableaux de doubles. Pour la seconde soutenance
nous utilisons le plein potentiel du langage C en créant une classe struct
neuron, dans le fichier neuron.c les formules mathématiques utilisée, sigmoid et sigmoid d, sont directement issue des cours trouvée en ligne.

Pour la seconde soutenance nous avons implémenté nos neurones dans
une structure avec les paramètres suivant :
- synapses (array de "double") : Array contenant les poids des synapses
arrivant au neurone.
- syn (int) : Taille de l’array "synapses".
- sum (double) : Valeur arrivant au neurone.
- delta (double) : Valeur du taux d’erreur du neurone.
- out (double) : Valeur sortante du neurone.
Les valeurs de "synapses" permettent d’obtenir la valeur "sum". La valeur
"syn" correspond à la taille de la couche précédent la couche du neurone.
La valeur "out" s’obtient en appliquant la fonction d’activation sur la
valeur "sum". La valeur "delta" correspond a l’erreur de la valeur "out"
OCRissou

page 18

IanisX

Info Spe

EPITA 2021

du neurone (valeur voulue - out).

Figure 1 – Schéma d’un neurone

6.0.2

La couche (layer)

La connectivité des réseaux, c’est-à-dire la manière dont les neurones
sont connectés peut être totale (tous les neurones connectés entre eux)
ou par couches. Il va donc y avoir propagation des informations entre
les différents neurones connectés. Chaque neurone va donc acquérir mais
également stocker des informations provenant des couches de neurones
avant et après lui.
Pour notre prototype de réseau, nous avons implémenté un simple réseau
monocouche, composé que d’une couche d’entrée et d’une couche de
sortie.
Pour la dernière soutenance nous avons implémenté une structure "layer"
contenant 2 champs :
- N (array de "neuron") : Array contenant tout les neurones de la couche.
- size (int) : Valeur du nombre de neurones contenus dans la couche.
La valeur de "size", en plus de donner le nombre de neurones dans la
couche, donne le nombre de synapses entrantes d’un neurone de la couche
suivant la couche actuelle (Cf. neuron). Il y a "size" neurones dans N.

OCRissou

page 19

IanisX

Info Spe

6.1

EPITA 2021

le reseaux neuralNet

La structure "neuralNet" contient 4 champs :
- layers (array de "layer") : Array contenant toutes les couches du réseau.
- size (int) : Valeur du nombre de couches contenus dans le réseau.
- lastLayer (array de "neuron") : Array contenant les neurones de
la dernière couche du réseau.
- lSize (int) : Valeur de la taille de la dernière couche.
La valeur de "size" donne le nombre de couches que contient le réseau (en
comprenant la première couche, la(les) couche(s) cachée(s) et la dernière
couche). Ainsi, dans "layers", il y a toutes les couches. L’array "lastLayer"
existe pour faciliter l’accès a la couche de résultat. La valeur "lSize" donne
la taille de ce dernier.

Figure 2 – Réseau monocouche

OCRissou

page 20

IanisX

Info Spe

6.2

EPITA 2021

Sauvegarde et Chargement d’un réseau de neurones

Lors de l’apprentissage de notre réseau de neurones les poids évoluent
et sont sauvegardés à chaque fois dans un fichier.Cela nous permet de
sauvegarder mais aussi de charger des réseaux de neurones. La sauvegarde
d’un réseau de neurones se passe de la façon suivante :
On parcours tous les neurones du réseau en commençant par le premier de la première couche.
Lorsqu’on arrive sur une nouvelle couche, on écrit dans le document
"L".
Lorsque l’on arrive sur un nouveau neurone, on écrit "N".
Lorsque l’on est sur un neurone, on écrit dans le document toutes les
valeurs de ses synapses, dans l’ordre, c’est a dire de la synapse connectant
le neurone actuel au premier neurone de la couche précédente au dernier.
Chacune de ces synapses est précédée d’un "S", puis lorsqu’on l’a écrit,
on la suit d’un "F" marquant la fin de la valeur. Le "F" est rajouté afin
de faciliter le chargement d’un réseau de neurones a partir d’un fichier
créé par cette méthode.

6.3

Apprentissage

Le résultat que renverra le neurone de sortie sera comparé avec le
résultat que le réseau de neurones devrait renvoyer. Nous obtenons alors
une marge d’erreur qui sera utilisé dans notre fonction d’apprentissage
dans une boucle afin de réduire la-dite marge d’erreur. Les erreurs se
réduisant au fil du nombre de tours, le résultat se rapprochera de plus en
plus du résultat correct.

OCRissou

page 21

IanisX

Info Spe

EPITA 2021

Il existe plusieurs modes d’apprentissage pour les neurones. Tout
d’abord il y a l’apprentissage supervisé. Dans ce type d’apprentissage,
le réseau de neurones s’adapte en comparant le résultat qu’il a calculé et
le résultat attendue. Le réseau de neurones va donc se modifier petit à
petit jusqu’à qu’il atteigne la bonne configuration.

Il existe une autre méthode qui s’appelle le renforcement. Dans celleci, le réseau de neurone doit apprendre à faire un rapport entre les entrée
et les sorties grâce à une estimation de son erreur. C’est-à-dire que le réseau va optimiser un index de performance qu’on lui donne et qui va lui
permettre de savoir si la réponse est bonne ou non, mais sans connaître
la bonne réponse.

Dans notre configuration, nous utiliserons l’apprentissage supervisé.
Pour cela nous avons besoin de la technique de rétropropagation, aussi
appelé rétropropagation du gradient (backpropagation en anglais) . Cette
méthode permet de calculer le gradient de l’erreur de chaque neurone, de
la dernière couche à la première.L’algorithme est simple à comprendre.
On commence par calculer l’erreur de la ou les sorties i. Pour cela on
utilise la formule :

erreur(i) = Sdesiree − Sobtenue
Ensuite on parcours chaque couche du réseau, en partant de la couche
de sortie, en propageant l’erreur de la couche k à la couche (k − 1) par
les liens synaptiques. La figure 3 illustre brièvement le fonctionnement
de l’algorithme.

OCRissou

page 22

IanisX

Info Spe

EPITA 2021

Figure 3 – Calcul de rétropropagation

OCRissou

page 23

IanisX

Info Spe

6.4

EPITA 2021

L’exemple d’un réseau : la fonction Xor

Pour la première soutenance nous avions implémenté un réseau neuronal capable d’apprendre la fonction XOR qui, pour rappel, renvoie 1
si les entrées sont à 0 et 1, 0 dans les autres cas. Notre réseau de neurones est composé de deux neurones d’entrée (input) d’une couche cachée
de deux neurones et enfin d’un neurone de sortie (output). Le neurone
de sortie devra effectuer une fonction mathématique (fonction sigmoïde)
avec les données reçus (input) avant de renvoyer le résultat.

OCRissou

page 24

IanisX

Info Spe

7

EPITA 2021

La Reconnaissance Optique de Caractère
A l’aide de toutes les fonctionnalités mises en places nous avons fi-

nalement pu créer un OCR. Le programme utilise donc le chargement
d’image,le traitement de l’image, le découpage,le traitement des éléments
découpes et la création d’un fichier contenant le texte extrait de l’image
au départ.

Chargement de l’image
Le chargement de l’image s’effectue grâce au chemin d’accès passe en
paramètre lors de lancement de l’interface, pour la charger, il suffit de
cliquer sur le bouton permettant le traitement de l’image. L’image non
traité apparaît alors.

Traitement de l’image
Lorsque l’image non traitée est chargée, il suffit d’appuyer sur une touche
du clavier afin de lancer le traitement de l’image et ainsi faire apparaître
l’image traitée. Les traitements effectues sur l’image sont : une binarisation afin d’obtenir un rendu de l’image en noir et blanc, un traitement du
bruit pour éliminer les potentiels pixels parasites et un traitement grâce
au RLSA afin d’optimiser le traitement ultérieur.

Découpage
A partir de cette étape, tout se fait simultanément lorsque l’utilisateur
clique sur le bouton permettant la reconnaissance optique de caractère.
Lors du découpage, le programme va découper l’image en caractères, et
grâce à une structure de listes chaînées, va stocker dans l’ordre de lecture
chaque caractère sous forme de matrice, et dans une autre structure de
listes chaînées,une codification afin de savoir si il y a un espace ou un
OCRissou

page 25

IanisX

Info Spe

EPITA 2021

retour à la ligne avant le traitement d’un caractère.

Traitement des caractères détectés
Avant tout, il faut savoir que le réseau de neurones utilisé est passé par
l’apprentissage (Cf.l’apprentissage). Lors du traitement des caractères
détectés, le réseau de neurones entre en jeu. Les caractères sont analysés
sous leur forme matricielle, et par conséquent représentés par des matrices de dimension 25 * 25. Le réseau de neurones utilisé comporte donc
25 * 25 = 625 neurones sur sa première couche, et chacun d’eux prend
une valeur de la matrice (0 ou 1).
De ce fait, afin de traiter les caractères détectés, les éléments de la liste
chaînée comportant les caractères et les informations vis-à-vis de la mise
en page sont parcourus simultanément. En ce qui concerne les caractères,
le réseau de neurone est initialisé par la matrice de la lettre analysée, et
la fonction permettant l’avancement du réseau de neurones est appelée,
et ainsi, le résultat est obtenu.
Ensuite, selon le résultat, qui est une couche de neurones comportant 64
neurones, il est possible de déterminer quelle est la lettre étant la plus
probable dans l’analyse. Ces 64 neurones permettent de différencier les
chiffres (0-9), les lettres majuscules (A-Z), minuscules (a-z), la virgule
(’,’) et le point (’.’). Le caractère retenu est celui dont le neurone respectif
est le plus "excité" (sa valeur de sortie est la 2 élevée). Dans le même
temps, la liste chaînée comportant les informations de mise en page est
parcourue et lorsque la valeur de l’élément actuel est 1, un espace se rajoute devant la lettre analysée, et si cette valeur est -1, un retour à la
ligne est effectué.

OCRissou

page 26

IanisX

Info Spe

EPITA 2021

Création du fichier
Le fichier est créé durant l’étape précédente, et tous les caractères détectés sont écrits dans ce fichier. A la fin de l’analyse, le fichier est fermé. Ce
fichier a pour chemin d’accès le deuxième argument lors du lancement de
l’interface. Le texte contenu dans l’image y est ainsi contenu.

OCRissou

page 27

IanisX

Info Spe

8

EPITA 2021

Conclusion
Nous avons donc créé un programme d’OCR qui malgré un rendu

peu efficace possède malgré tout des propriétés intéressantes et fonctionnelles : le nombre de caractères détectés est correcte et la mise en page
reste très semblable a l’image original. Toutefois son majeur défaut est
la reconnaissance peu précise des caractères.
Cela est du a un réseau de neurones trop peu entraîné ou entraîné
avec trop peu d’exemple pour être totalement fonctionnel. Nous possédons donc un programme tout a fait fonctionnel en dehors du réseau de
neurones utilise. Notre programme est donc améliorable en améliorant
notre réseau de neurones.
Ce projet nous a été très enrichissant car il nous a permis de découvrir
des notions telles que le traitement d’image ou bien l’implémentation d’un
réseau de neurones. De plus au niveau de la gestion de groupe ce projet
fut bien plus intéressant que le projet de sup car les membres possédaient
tous déjà une expérience et les objectifs étaient claires et précis.
Malgré des résultats imparfait nous restons fier de notre OCR et des
résultats obtenus. Nous envisageons déjà de mettre suite a ce projet afin
d’obtenir un programme plus fiable et efficace. C’est donc avec confiance
que nous envisageons la suite de nos apprentissages en informatiques. Ce
projet fut enrichissant pour toute l’équipe.

OCRissou

page 28

IanisX


Aperçu du document ocr.pdf - page 1/28

 
ocr.pdf - page 3/28
ocr.pdf - page 4/28
ocr.pdf - page 5/28
ocr.pdf - page 6/28
 




Télécharger le fichier (PDF)


ocr.pdf (PDF, 1.1 Mo)

Télécharger
Formats alternatifs: ZIP Texte



Documents similaires


ocr
rapport de projet ocr
projets12021
reseau de neurones
gestion de donnees massives lecocq sitbon
un commutateur neural de la peur

Sur le même sujet..




🚀  Page générée en 0.056s