RECONNAISSANCE D’OBJETS PAR RESEAUX DE NEURONES

Ecole d’ingénieurs de Genève

RECONNAISSANCE D’OBJETS PAR

RESEAUX DE NEURONES

En collaboration avec le Laboratoire de Systèmes d’Informations

et le groupe Viper du Centre Universitaire Informatique de Genève

Travail de Diplôme de

Yannick Evrard

Présenté le 11 décembre 2003 Professeur de projet : M Michel Lazeyras

Remerciement

Remerciement

Je tiens tout d'abord à remercier mon père zofingien, Damien Dellea, vulgo Turbo Asticot, pour m'avoir révélé l'existence des réseaux de neurones, par une nuit fortement embrumée de l'hiver 1998. Cette nuit fut le début de TOUT.

Merci à Marc Von Wil, à François Congedo, à Edouardo Basilico, à Gabriel Demartine et à M Michel Winkenbosch pour les documents prétés, qui se sont avérés de la plus grande utilité.

Merci à Patrick Rosselet et Olivier Loesli pour leur collaboration dans la réalisation de ce projet, et pour m'avoir fournit toute la matière nécessaire à sa réalisation

Merci à M Michel Lazeyras pour la supervision du projet, pour la re-lecture du mémoire, pour les idées fournies, pour… son humour.

Merci à tous mes camarades partageant la même salle pour le diplôme. La bonne humeur et la convivialité sont importantes pour travailler dans les meilleures conditions.

Merci à ma famille pour son soutien moral, pour ses encouragements. Vous avez vu, le premier finit ses études... plus que deux...

Reconnaissance d’images par réseaux de neurones artificiels 3

Table des matières

Table des matières

Remerciement .................................................................................................................. 3

Table des matières ........................................................................................................... 4

1 Préambule ..................................................................................................................... 8

2 Introduction ................................................................................................................ 11 2.1 Description de la nouvelle représentation SVG.................................. 11 2.2 ACSIS............................................................................................................ 13 2.3 Description du projet ................................................................................. 14 2.4 Organisation et plan de l'ouvrage ........................................................... 15

3 Problématique de la reconnaissance d’image ........................................................... 18 3.1 Préliminaires ................................................................................................ 18 3.2 Pré traitement............................................................................................... 19 3.3 Représentation ............................................................................................. 20

3.3.1 Représentation d'un exemplaire............................................................. 21 3.3.2 Représentation des classes..................................................................... 21

3.4 L’apprentissage ........................................................................................... 22 3.5 Ressemblance .............................................................................................. 23 3.6 Résumé .......................................................................................................... 26 3.7 Remarques .................................................................................................... 27

4 Comparaison MATLAB / SNNS ................................................................................ 29 4.1 Avantages/désavantages SNNS .............................................................. 29 4.2 Avantage/désavantage de MATLAB..................................................... 36 4.3 Choix pour la suite du projet.................................................................... 38

5 Application aux logos noir et blanc ........................................................................... 39 5.1 Problématique.............................................................................................. 39 5.2 Représentation des entrées. ...................................................................... 41 5.3 Topologie ...................................................................................................... 46 5.4 Mise en oeuvre ............................................................................................ 47


Table des matières

5.4.1 Couche réductrice .................................................................................. 47 5.4.2 Couche auto organisatrice ..................................................................... 50

5.5 Conclusion.................................................................................................... 53

6 Application aux images couleur................................................................................. 54 6.1 Problématique.............................................................................................. 54 6.2 Reconstruction des contours, architecture et représentations .......... 57

6.2.1 Choix de l'architecture........................................................................... 57 6.2.2 Choix des Représentations .................................................................... 60 6.2.2.1 Informations topologiques.................................................................. 61 6.2.2.2 Informations chromatiques................................................................. 66

6.3 Reconstruction des contours, mise en oeuvre................................................... 67 6.3.1 Récapitulation et architecture adoptée................................................... 67 6.3.2 Apprentissage ........................................................................................ 69 6.3.3 Reconnaissance...................................................................................... 72

6.4 Limites et difficultés .................................................................................. 74 6.4.1 Première ébauche de solution, généralisation........................................ 74 6.4.2 Deuxième ébauche de solution, classification et identification............. 76

6.5 Reconnaissance d'objets, architecture, représentations..................... 77 6.6 Conclusion.................................................................................................... 81

7 Ouverture et conclusion ............................................................................................. 83

Annexe A : Introduction théorique............................................................................... 87 A.1 Neurone formel .......................................................................................... 87 A.2 Perceptron une couche.............................................................................. 89

A.2.1 Introduction .......................................................................................... 89 A.2.2 Description mathématique .................................................................... 89 A.2.3 Algorithme du perceptron une couche.................................................. 90 A.2.4 Limitations et propriétés fondamentales............................................... 91

A.3 Perceptron multicouches.......................................................................... 93 A.3.1 Introduction .......................................................................................... 93 A.3.2 Notation ................................................................................................ 93 A.3.3 Description Mathématique // vers l’algorithme de rétro-propagation .. 94 A.3.3.1 Vers la couche de sortie..................................................................... 95 A.3.3.2 Vers une couche cachée..................................................................... 96 A.3.3.3 Formule générale ............................................................................... 98 A.3.4 Algorithme du perceptron multicouches .............................................. 99 A.3.5 En résumé ........................................................................................... 100


Table des matières

A.4 Fonction de transfert ............................................................................... 101 A.5 La fonction d'erreur ................................................................................. 103 A.6 Le pas d'apprentissage ............................................................................ 104 A.7 Autre modèles connexionnistes............................................................ 105 A.8 Cartes auto-organisatrices et algorithme de Kohonen.................... 106

A.8.1 Introduction ........................................................................................ 106 A.8.2 Topologie............................................................................................ 106 A.8.2 Algorithme d’apprentissage................................................................ 108 A.8.3 Illustrations ......................................................................................... 111

A.9 Mise en oeuvre du modèle connexionniste ....................................... 112 A.9.1 Les entrées pertinentes........................................................................ 112 A.9.2 La collecte des données ...................................................................... 113 A.9.3 Préparation des données ..................................................................... 113 A.9.4 Le nombre de neurones cachés ........................................................... 115 A.9.5 La nécessité de la parcimonie ............................................................. 115

Annexe B Utilisation de l'interface SIR ..................................................................... 119 B.1 Avant propos ............................................................................................. 119 B.2 Présentation, données d'usage............................................................... 120

B.2.1 Introduction......................................................................................... 120 B.2.2 Configuration minimum ..................................................................... 121

B.3 Exemple d'utilisation............................................................................... 122 B.3.1 Sélection d'un stack............................................................................. 123 B.3.2 Navigation dans les images................................................................. 124 B.3.3 Sélection des régions à fusionner........................................................ 125 B.3.4 Type de sauvegarde............................................................................. 127 B.3.5 Choix d'un mot.................................................................................... 128 B.3.6 Apprentissage...................................................................................... 130 B.3.7 Reconnaissance ................................................................................... 132

B.4 Options supplémentaires ........................................................................ 135 B.4 Conclusion ................................................................................................. 140

Annexe C Résultats...................................................................................................... 142 C.1 Logos noir et blanc .................................................................................. 143 C.2 Images couleur.......................................................................................... 145

C.2.1 Arbres bien analysés ........................................................................... 145 C.2.2 Arbres moyennement bien analysés.................................................... 148


Table des matières

C.2.3 Arbres mal analysés ............................................................................ 151 C.2.4 Visages bien analysés ......................................................................... 152 C.2.5 Visages moyennement bien analysés.................................................. 154 C.2.6 Visages mal analysés .......................................................................... 156

Table des figures .......................................................................................................... 160

Table des formules....................................................................................................... 164

Références.................................................................................................................... 167 Bibliographie ........................................................................................................ 167 Internet.................................................................................................................. 168


Chapitre : 1 Préambule

1 Préambule

Depuis près d'un demi-siècle, les chercheurs en intelligence artificielle et les informaticiens développent des machines capables d'effectuer des tâches qui requièrent de l'intelligence. Par exemple, la reconnaissance de formes, le contrôle de processus industriel, la conduite automatique de robots, data-mining,... Tous ces objectifs ambitieux ont stimulé l'inventivité des chercheurs et ont donné lieu à de nombreuses réalisations époustouflantes. Cependant, programmer des machines qui, comme les humains ou encore les animaux, seraient capables de s'adapter et d'évoluer en fonction de nouvelles situations est difficile. L'enjeu importe beaucoup, car il amène à mieux comprendre le comment de nos facultés d'adaptation et de reconnaissance. Aujourd'hui, l'ingénieur sait doter une machine de capacités d'apprentissage et d'évolution, lui permettant de tirer parti de son expérience.

A ce stade, plusieurs approches sont possibles; d'un coté, le concepteur d'une machine apprenante peut s'inspirer du monde biologique et tenter de reproduire certains comportements éthologiques ou le fonctionnement de groupes de cellules. D'un autre côté, une démarche mathématique s'impose pour permettre un travail rigoureux et



cohérent. Mais dans tous les cas, le développeur doit adopter une approche fonctionnaliste de l'esprit selon laquelle celui-ci peut-être considéré comme une fonction calculable, c'est à dire réalisable par une machine de Turing.

A ce niveau, deux courants de pensées s'opposent et se complètent mutuellement; d'une part une approche cybernétique, d'autre part, une approche cognitive.

Le cognitivisme propose le découplage de l'aspect matériel (hardware) et de l'aspect software. C'est sur le logiciel que se reporte toutes les propriétés cognitives du système (sujet). Mais le cognitivisme va plus loin: « Ce courant considère que les symboles manipulés ont le statut de « représentation d'état du monde ». Pour le dire autrement, les symboles envisagés par le cognitivisme ont à la fois une réalité matérielle et une valeur sémantique. [...] les calculs opérés par la machine deviennent une simulation qui préserve la structure de la réalité. [...] Selon cette approche, la pensée à modéliser procède à partir de propositions portant sur le monde, dotés d'une syntaxe, et manipulé par des règles d'inférence strictes d'un langage formel, parmi lesquelles figurent au premier plan la déduction, l'abduction, la généralisation, etc ..., c'est à dire des règles d'inférences liées à la logique » ( Apprentissage artificiel, p.11, Antoine Cornuéjols – Laurent Miclet, 2002 ).

L'approche cybernétique considère, comme pour les cognitivistes, que l'esprit s'assimile à l'activité du cerveau, et que le cerveau doit être considéré comme une machine. Norbert Wiener (1894-1964), Allan Turing(1912-1954) et C.E Shannon (1916-2001) sont trois figures emblématiques de ce mouvement. Le modèle cybernétique s'appuie avant tout sur une dimension dynamique de l'apprentissage et sur la simulation et la reproduction de comportements, éthologiques par exemple. Ce courant s'applique surtout à décrire l'évolution d'un système adaptatif: comment réagit un système confronté à de nouvelles conditions? En revanche, une telle approche expérimentale nuit à la construction de modèles mathématiques et théoriques de l'apprentissage.

Il s'agit donc, dans la problématique connexionniste de l'apprentissage artificiel, d'aborder les questions de l'induction, de l'analogie, de la généralisation et de l'abduction de façon théorique (cognitivisme), sans perdre de vue la réalisation dynamique et la simulation de cet apprentissage par comparaison avec la neurobiologie, par exemple (cybernétique).

Le projet suivant se veut partie des deux philosophies, cybernétique et cognitive, dans le souci de bénéficier des avantages de chacune, et de mieux comprendre, interpréter et mettre en oeuvre le phénomène de l'apprentissage artificiel. Il est même



plus juste de parler de cognitivisme Idéal, car dans le cas de la présente réalisation, les symboles intrinsèques utilisés pour l'apprentissage seront considérés par l'auteur comme noumènes (chose-en-soi), au sens de Kant ou Platon. L'idéalisme modéré de Kant considère que s'il y a des objets dont notre connaissance pourrait éventuellement être directe, donc sûre, (il n'est pas dit qu'il y en ait!), de tels objets ne sauraient être que de nature mentale: idées, données immédiates des sens, etc. Ce ne peuvent être des choses du « monde extérieur », puisque la connaissance de celles-ci passent par l'intermédiaire de sens toujours susceptibles de nous tromper. En conséquence, l'idéalisme maintient que nous n'avons accès qu'à des « représentations » du monde extérieur, des « phénomènes ». De même pour Platon qui pense que nous ne voyons finalement que les ombres des Idées, des choses-en-soi, projetées sur un mur au fond d'une grotte (allégorie de la caverne).

La position Idéaliste se justifie bien dans le sens où une machine apprenante ou un programme n'a accès qu'à des représentations de son environnement et n'agit efficacement que par traitement de ses données internes (opérations mentales). L'ingénieur devient, dans cette optique, un être « transcendantal » au sens de Kant; un être en dehors des représentations de la machine, capable d'appréhender la réalité-en-soi du monde extérieur. Il sait modifier les sens de la machine, choisir les représentations adéquates pour un fonctionnement désiré. Il se place même en dehors de « l'espace » et du « temps » de la machine.

L'idéalisme présente ainsi un lien étroit avec la démarche de l'informaticien dans le cadre d'un projet axé sur les réseaux de neurones. L'analyse développée dans les prochains chapitres décrit justement toutes ces parentés en exposant les activités et les difficultés de l'ingénieur: l'étude des informations provenant de la réalité, choix des représentations adéquates, élaboration d'un modèle, évaluation de la qualité du système.

En définitive, le choix philosophique dirige grandement la démarche du chercheur pour l'approche d'un projet. Dans le présent cas, une réflexion cognitive associée à des identifications avec les sciences neurobiologiques sont le fil conducteur de la recherche permettant d'aboutir à un modèle définitif. Alors que la pensée idéaliste, modérée ou objective1, garantit la cohésion de tout un projet et donne un cadre logique à chaque nouvelle approche ou mise en œuvre.

1En référence à l'idéalisme 'modéré' de Kant et l'idéalisme 'objectif' de Platon


Chapitre :2 Introduction

2 Introduction

2.1 Description de la nouvelle représentation SVG SVG : Scalable Vector Graphics. Ce langage approuvé par le W3C permet d'écrire

des graphiques vectoriels 2D en XML visualisables sur le Web. Ce format introduit le graphisme interactif en temps réel, en agissant directement sur les autres éléments d'un document HTML. Il a été inventé en 1998 par un groupe de travail (comprenant Microsoft, Adobe, IBM, Sun, Xerox, Apple, Corel ...) pour répondre à un besoin de graphiques légers, dynamiques et interactifs.

Une première ébauche du langage est sortie en octobre 1998 et en juin 2000 apparaît déjà la première version du Viewer Adobe (plug-in permettant de visualiser le SVG). Le SVG s'est très vite placé comme un concurrent de Flash et à ce titre, Adobe a intégré ce langage dans la plupart de ses éditeurs.

Le langage SVG compte de nombreux avantages, notamment au niveau de la conception et au niveau du rendu graphique:



Au niveau de la conception

- Il s'agit d'un langage libre de droit (aucune licence demandée).

- Etant issu du XML, il offre la possibilité d'utiliser tous les outils XML dont les parsers, les outils de transformations et les bases de données.

- Le langage est supporté par les technologies d'Internet les plus communes (HTML, GIF, JPEG, PHP, Java script,... ).

- le SVG peut créer du SVG.

- Il est possible de compresser un fichier SVG jusqu'a 95% (en utilisant la compression gzip, car le fichier SVG n’est que du texte).

Au niveau du rendu graphique

- Intégration des trois types d'objets graphiques : formes vectorielles, images, texte.

- Utilisation de nombreux effets graphiques.

- Les balises SVG sont considérées comme des objets et peuvent ainsi recevoir des propriétés ou des attributs de styles ;

- chaque élément du SVG peut être groupé, transformé et composé en objet.

- Possibilité de zoomer et de retailler une zone de vision.

- Les graphiques SVG peuvent intégrer des scripts internes ou externes (ECMAscript ou java script).

Cependant, comme tous les langages récents, le plug-in SVG (viewer) est encore très peu implanté sur les navigateurs actuels (il devrait être intégré dans les futures versions d'Internet Explorer). De plus, il n'existe pas aujourd'hui de version pour Netscape. On notera aussi que le SVG risque de se confronter à Flash, qui lui est devenu un vrai standard.



2.2 ACSIS

L'image occupe une place de plus en plus prépondérante en informatique, surtout dans le monde de l'internet. Aujourd'hui, il est nécessaire de proposer de nouvelles méthodes de représentation d'une image afin d'accéder plus directement à son contenu ou à son sens. Dans ce cadre de recherche, le projet ACSIS, Accès au Contenu Sémantique d’Images Segmentées, étudie deux directions:

- D'une part, la recherche d'images par similarité selon le contenu, dans des banques de données. Par exemple, pouvoir identifier des images par l'ensemble des objets contenus dans chacune.

- D'autre part, l'accès par des non voyants à l'information contenue dans une image complexe. Il s'agit donc de donner un sens au contenu (objets) de l'image.

Le projet ACSIS se propose de développer deux éditeurs pour chacune des voies choisies. Ces éditeurs sont en cours d'élaboration, conjointement au groupe « Vision par Ordinateur et Multimédia » du Centre Informatique de l'Université de Genève (CUI). Plus précisément, le premier est élaboré en relation avec l'équipe 'Viper' dirigée par M. Marchand-Maillet, alors que le deuxième est une collaboration avec le groupe 'ABWEB', représenté par M. David Richoz.

Le projet ACSIS s'appuie sur la technologie SVG décrite au chapitre 2.1. L'intérêt d'utiliser SVG réside dans le fait qu'il existe des « viewers » comme BATIK qui permettent de définir des actions liées à un graphique ou à une image. Il est ainsi possible de définir de manière standard un lien entre une action et chaque objet d'une image segmentée.

La segmentation est au cœur du projet. En effet, il est possible de définir plusieurs niveaux de segmentation: du plus fin au plus grossier, du plus bas au plus haut. Le niveau le plus fin consiste en un découpage de l'image en de nombreuses petites zones indivisibles. Il est alors possible de regrouper les régions unitaires, étape par étape, afin de remonter au niveau le plus grossier (peu de zones). Cette opération de découpage et de regroupement s'appelle le « Split and merge » et fournit une représentation pyramidale de la segmentation. La méthode fait ressortir de l'information à chaque niveau. Le projet ACSIS s'applique ainsi à donner une représentation SVG de la pyramide de segmentation, afin que l'utilisateur, au travers d'une représentation interactive puisse facilement faire un choix parmi les différents étages de la pyramide.

Le projet est original à plus d'un titre.



.- Dune part, la démarche proposée offre à l'utilisateur le choix d'une segmentation modulable, et donc modifiable.

.- Par ailleurs, le choix de la technologie SVG permet d'anticiper une standardisation de l'accès aux contenus sémantiques d'images.

Développé sur plus d'une année, le projet ACSIS a réellement débuté en mai 2003 par l'études des premiers algorithmes et se prolongera jusqu'en avril 2004 pour donner naissance à deux produits; l'un permettant la génération de code SVG, et l'autre pour la segmentation interactive d'images complétant le produit du groupe 'Viper' et permettant la recherche d'images selon leur contenu.

2.3 Description du projet

Les méthodes de détections de contours dans une image à tons de gris ou en couleurs sont multiples et variées. Pour ne citer que les plus connues, on retrouve la segmentation par watershed (ligne de partage des eaux), la méthode du « snake » et du « waterSnake », les cartes autos-organisatrices, analyse par arbres de décisions ou graphes,...

Le but de ce projet n'est pas de formuler une nouvelle méthode de détection de contours. Sa spécificité est de chercher une méthode basée sur les réseaux de neurones pour réaliser un système capable de ré-associer différentes zones segmentées d'une image, dans le but de reconstruire des objets entiers et leur donner un sens.

Ainsi, une fois que les recherches sur une architecture adéquate auront été menées, il sera possible de proposer deux analyses différentes:

1 Un programme capable d'identifier des logos noirs blancs par ressemblance avec une banque de données connue. Le but est de pouvoir présenter au programme un nouveau logo, et de savoir s'il est unique ou s'il ressemble trop à d'autres logos, et lesquels.

2 Un programme capable de retrouver dans une banque d'images toutes celles contenant un arbre par exemple, ou un visage. De plus, le projet réalisé sera capable d'identifier l'arbre ou le visage sur l'image en indiquant le contour de l'objet.



La réalisation de l'ensemble passe avant tout par une étude des outils informatiques à disposition, notamment les deux programmes MATLAB et SNNS, et donne naissance à un logiciel interfacé pour la simulation du projet, ainsi qu'au présent document.

2.4 Organisation et plan de l'ouvrage Le document s'agence en différentes sections qui peuvent avoir plus ou moins

d'intérêt pour le lecteur. Le chapitre présent a pour but de mieux signifier la portée de chaque chapitre du document, et donne un résumé succinct des thèmes abordés.

Chapitre 3 « Problématique de la reconnaissance d’image »

Des méthodes générales ont été développées en reconnaissance des formes pour extraire automatiquement des informations des données sensibles afin de caractériser les classes de formes (apprentissage) et d'assigner automatiquement des données à ces classes (reconnaissance). Il s'agit, dans le chapitre 3, de proposer une méthode générale pour l'approche de notre projet, avec brève description des différentes parties de la démarche, comme le pré-traitement, la ressemblance, l'évaluation de la qualité...

Chapitre 4 « Comparaison MATLAB/SNNS »

Plusieurs outils confirmés sont à disposition pour permettre à l'ingénieur de réaliser un projet connexionniste. Le chapitre 4 se veut une comparaison rapide de deux produits performants actuellement sur le marché, dans le but d'en sélectionner un pour la suite de projet: MATLAB et SNNS (Stuttgart Neuronal Network System). On y découvrira une analyse des qualités et des défauts de chacun. On y trouve également la mise en oeuvre d'un simple et même réseau de neurones avec les deux logiciels

Chapitre 5 « Application logos noir/blanc »

La méthodologie décrite au chapitre 3 et le choix des outils fait au chapitre 4 permettent une première mise en oeuvre avec la reconnaissance de logos noir/blanc. Le chapitre 5 relate la procédure adoptée et présente quelques performances. Pour de plus amples résultats, le lecteur pourra consulter l'Annexe C.



Chapitre 6 « Applications aux images couleurs »

Cette section reprend également la démarche proposée au chapitre 3 et 4, mais propose cette fois une application sur des images en couleur. Ce chapitre explique comment il a été opéré une reconnaissance de forme par reconstruction des contours.

Chapitre 7 « Ouverture »

Le projet peut s'inscrire dans un cadre plus grand de recherche, et le chapitre 7, intitulé « Ouverture », propose une vision d'avenir du diplôme réalisé et donne certaine idées d'amélioration, d'applications industrielles possibles,...

Chapitre 8 « Conclusion »

Cette section clôt simplement le projet et reprenant les différents intérêts du développement réalisé.

Annexe A « Introduction théorique »

La première annexe est théorique. Elle présente une approche mathématique du neurone simple, ainsi que la généralisation à un ensemble ou réseau de neurones. Différentes architectures neuronales sont décrites, comme les perceptrons multicouches et les réseaux de Kohonen, ainsi que les algorithmes de convergence (apprentissage) de ces structures.

Annexe B « Interface utilisateur »

Le développement des chapitres 5 et 6 a donné naissance à une interface utilisateur, SIR (Segmented Images Recognising), permettant de simuler la reconnaissance d'images et l'apprentissage d'objets dans cette image. L'annexe 2 est une aide à l'utilisateur qui voudrait se familiariser avec cette interface et l'on y trouve un petit guide décrivant chaque fonctionnalité du produit au travers d'un exemple d'utilisation.

Annexe C « Résultats »

Cette annexe présente des résultats sous forme de liste d'images illustrant les capacités et les limites du projet.

Annexe D « Codes sources »

Pour attaquer la réalisation dans toute sa profondeur, le lecteur courageux ou le programmeur pourra se reporter à cette section pour découvrir le code complet et



commenté du projet.


Chapitre :3 Problématique de la reconnaissance d’image

3 Problématique de la reconnaissance d’image

3.1 Préliminaires Le problème que cherche à résoudre la reconnaissance des formes est d'associer

une étiquette à une donnée qui peut se présenter sous forme d'une image ou d'un signal. Des données différentes peuvent recevoir la même étiquette, ces données sont les réalisations ou les exemplaires de la classe identifiée par l'étiquette. Par exemple, le son /a/ prononcé par différents locuteurs conduit à des signaux différents mais ces différences ne sont pas significatives du point de vue de l'identification du son, ces signaux sont des réalisations ou des représentations de la classe /a/. De même, l'écriture manuscrite du caractère A varie d'un scripteur à l'autre mais le lecteur identifiera le caractère A pour chacune de ces réalisations.

Des méthodes générales ont été développées en reconnaissance des formes pour



extraire automatiquement des informations des données sensibles afin de caractériser les classes de formes (apprentissage) et d'assigner automatiquement des données à ces classes (reconnaissance).

Parallèlement aux travaux sur les méthodes de reconnaissance, se développaient le traitement d'image, la vision par ordinateur, et le traitement de la parole. Ces domaines ont focalisé le problème de la reconnaissance sur des données spécifiques, mais par ailleurs ils ont permis de situer la reconnaissance dans un processus plus vaste d'interprétation d'images ou de compréhension de la parole.

La reconnaissance de forme, de ce fait, se doit de suivre une schématisation claire et précise, dont chaque partie mène à un traitement spécifique. Ce chapitre a pour but de présenter les différentes facettes d’un processus d’interprétation d’images dont les parties intégrantes doivent nécessairement :

- obtenir une représentation des données à traiter qui soit manipulable en machine.

- élimination des bruits, normalisation, re-échantillonnage, amélioration des contrastes, segmentation, etc...

- obtenir une représentation des données compatible avec les outils d'apprentissage et de décision utilisés.

- à partir d'un ensemble d'exemplaires et d’un modèle, construire une représentation des classes (apprentissage).

- valider les décisions de l'analyse sur la base des classes connues, pour une éventuelle modification du système, ou de certaines de ses parties.

3.2 Pré traitement

Les données brutes issues de capteurs sont les représentations initiales de la réalité à partir desquelles des traitements permettent de construire les données qui seront utilisées pour la reconnaissance. Les entrées brutes sont bruitées, elles contiennent des informations parasites, et elles n'explicitent pas les informations utiles pour la reconnaissance. Par exemple, l'information sur la forme des objets à reconnaître est contenue dans le tableau de pixels résultant de la numérisation d'une image mais des



traitements seront nécessaires pour, par exemple, séparer une première fois certaines formes du fond et suivre leurs contours.

Figure 3.1 : schéma type de la numérisation et du pré-traitement

Pour les pré-traitements, le concepteur s'aide des connaissances qu'il possède sur les capteurs, les types données, le problème posé et les méthodes d'apprentissage et de reconnaissance qu'il utilisera.

Le traitement du signal et de l'image sont les principales sources pour les méthodes de pré-traitement : filtrage (des bruits hautes fréquences, par exemple), amélioration des contrastes, extraction de contours ou de squelettes, modélisation du signal temporel, extraction des primitives, etc.

Les pré-traitements et l'apprentissage ont des buts communs qui consistent à éliminer les informations parasites et à conserver les informations pertinentes pour la reconnaissance. La limite entre pré-traitement et apprentissage relève des possibilités des méthodes d'apprentissage utilisées.

3.3 Représentation

Le système de reconnaissance de formes doit posséder des représentations des



formes à classer et des classes à associer.

Les types de représentation sont déterminés par les méthodes utilisées.

Les contenus des représentations sont déterminés par les buts de la reconnaissance.

3.3.1 Représentation d'un exemplaire Plusieurs choix sont possible et dépendent, comme indiqué au chapitre précédent,

des buts et méthodes de la reconnaissance. Néanmoins, il est possible de citer quelques choix:

- Un vecteur de dimension n. Chaque dimension correspond à la mesure d'une caractéristique sur l'exemplaire. Chaque exemplaire est alors un point de Rn.

- Une organisation de primitives sous forme de séquences, de graphes ou de règles de composition.

- Un ensemble de propriétés, une description logique.

- Des fonctions, équations paramétriques des contours etc.

On appelle caractéristique (ou descripteur) une information qui peut être mesurée sur la donnée à reconnaître. Par exemple : l'amplitude moyenne d'un signal sur une fenêtre temporelle, l'énergie dans une bande de fréquence, le rapport hauteur sur largeur d'un caractère manuscrit, le niveau de gris moyen d'une zone d'image etc.

3.3.2 Représentation des classes

Dans le cas où l'on disposerait d'un ensemble d'exemplaires étiquetés, on distingue les démarches qui pratiquent un apprentissage supervisé pour induire la représentation des classes de celles qui ne pratiquent pas d'apprentissage. Dans tous les cas, on recherche des représentations des classes qui permettront d'obtenir les meilleures performances en reconnaissance.



Figure 3.2 : Schéma type du calcul des représentations

3.4 L’apprentissage

L'apprentissage a pour but de généraliser l'information portée par les exemplaires de l'ensemble d'apprentissage pour faire émerger les représentations des classes. Ces représentations doivent permettre de s'affranchir de la variabilité des exemplaires d'une classe lors de la prise de décision. La validation de l'apprentissage est faite par les taux de reconnaissance obtenus sur un ensemble test constitué d'exemplaires différents de ceux de l'ensemble d'apprentissage.

Le type de représentation choisi pour les exemplaires (un vecteur de Rn, une composition de symboles...) va conditionner le type de représentation des classes (un sous-espace de Rn, une grammaire...).



Figure 3.3 : Schéma type d'un apprentissage

3.5 Ressemblance

Ce qui fait problème pour reconnaître des formes comme étant des exemplaires d'une classe est d'une part la variabilité intra-classe et d'autre part la séparabilité des classes. Les exemplaires d'une classe ne sont pas identiques, ils se ressemblent, alors que les exemplaires appartenant à des classes différentes ne se ressemblent pas. Le problème sera donc de formaliser cette ressemblance.

On peut supposer que la ressemblance des exemplaires d'une classe est due à la présence d'invariants caractéristiques de la classe. Par exemple, les rectangles ont toujours quatre côtés qui forment des angles droits. En fait, les réalisations à main levée de rectangles s'éloignent fortement de cette définition. Ce qui conditionne la décision est le fait que la figure ressemble d'avantage à un rectangle qu'à une autre figure géométrique, elle en est plus proche au sens d'une métrique à définir.



La répartition des exemplaires dans l'espace de représentation fait rarement apparaître une parfaite séparation entre les différentes classes, ce qui provoque une ambiguïté dans les décisions. On peut associer une valeur à la décision pour indiquer avec quelle confiance elle a été prise.

Figure 3.4 : Schéma type pour l'évaluation de la qualité

La ressemblance peut être mesurée :

- par la distance d'un exemplaire inconnu à un prototype, c'est l'appariement de formes (Pattern Matching). Méthodes : Programmation dynamique pour la comparaison de chaînes, de graphes, masques élastiques ...



- par la distance d'un exemplaire inconnu à des exemplaires dont on connaît la classe d'appartenance: méthode des k-plus-proches-voisins.

Dans le cas où les classes sont représentées par des sous espaces de Rn, des langages, des descriptions logiques, la ressemblance est donnée par la position de l'exemplaire inconnu par rapport aux espaces définis par les représentations des classes.

Méthodes : théories statistiques de la décision pour un espace Rn, analyse syntaxique pour des classes représentées par des langages,...



3.6 Résumé

Les chapitres précédents ont permis de mettre en place une stratégie d’approche pour l’analyse et la reconnaissance de formes et d’objets. Le schéma suivant s'impose de lui-même:

Figure 3.5 : Schéma type du projet de reconnaissance d'image



Buts des étapes du schéma :

Numérisation : obtenir une représentation des données à traiter qui soit manipulable en machine.

Pré-traitement : élimination des bruits, normalisation, re-échantillonnage, amélioration des contrastes, segmentation, etc...

Calcul des représentations : obtenir une représentation des données compatible avec les outils d'apprentissage et de décision utilisés.

Apprentissage : à partir d'un ensemble d'exemplaires et d’un modèle, construire une représentation des classes.

Analyse : assigner une forme inconnue à une classe.

Validation: valider les décisions de l'analyse sur la base des classes connues, pour une éventuelle modification du système, ou de certaines de ses parties (en rouge).

3.7 Remarques Le présent projet prend naissance à l’étape caractérisée par le calcul des

représentations. Les images analysées sont effectivement pré-traitées, mais cette étape constitue un travail à part entière, réalisé dans le cadre du projet ACSIS par MM Patrick Rosselet et Olivier Loesli. Les images sont avant tout segmentées, selon l’algorithme de Prime, et représentées selon la nouvelle norme SVG. Un fichier SVG contient des informations sur la segmentation de l’image, à savoir :

- Un identifiant de chaque zone segmentée.

- La taille de chaque zone segmentée.

- une représentation RGB et HSB de la couleur de la zone.

- La liste des contours de chaque zone segmentée.



- La liste des voisins de chaque zone segmentée.

A chaque zone est ainsi associée une balise <path> de la forme suivante :

<path id="groupe1" no="71" onclick="click(evt)" fill="rgb(187,169,170)" stroke="black" d="M 99 75,102 75,102 78,102 81,102 84,99 84,z"/>   

Exemple de région d’une image définie selon la norme SVG

La suite de l’étude sera basée sur les informations fournies par des fichiers SVG pour simuler une reconnaissance d’objets.

Il existe beaucoup de modèles d’apprentissage, et il serait vain de vouloir tous les citer. Mais parmi tous, le modèle connexionniste a été retenu et présente le centre du présent travail.


Chapitre :4 Comparaison MATLAB / SNNS

4 Comparaison MATLAB / SNNS

Le travail de l'ingénieur commence toujours par le choix des outils qu'il va utiliser

pour la réalisation d'un projet. Ce choix est de première importance, car c'est lui qui va décider notamment du temps et du coût de développement, de la portabilité du projet, de la qualité du traitement ainsi que de son type,... Ces critères sont ceux qui seront étudiés pour les programmes MATLAB et SNNS.

4.1 Avantages/désavantages SNNS

SNNS est un outil puissant et optimisé offrant une grande flexibilité au niveau de la simulation. Sa compréhension passe par l'analyse de sa structure. Le logiciel s'agence en quatre grandes parties, comme illustré sur la figure 4.1: le noyau du simulateur, Une interface utilisateur graphique, une grammaire permettant l'exécution de scripts Batchman, et un compilateur de réseaux de neurones SNNS2c.



Le noyau du simulateur opère sur la structure interne du réseaux de neurones et gère toutes les opérations à ce niveau.

L'interface graphique (XGUI) donne une représentation intéressante des réseaux et permet directement de créer, manipuler, visualiser et tester un réseau de neurones de différentes manières.

Le langage Batchman est modelé entre des langages comme PASCAL, C, MODULA2 et permet de façon très instinctive, de simuler un réseau de neurones, de l'éditer, de modifier sa structure de sauvegarder ses résultats, comme pour XGUI.

Le compilateur SNNS2c donne l'occasion de compiler un fichier de description SNNS d'un réseau de neurones en code source C. Le fichier « .c » généré par SNNS2c ne bénéficie plus des fonctionnalités de SNNS (édition, modification,...). Ce code généré en C sert surtout à pouvoir implanter le réseau dans un projet plus grand.

Figure 4.1 : Schéma du logiciel SNNS



La simulation d'un projet avec SNNS s'agence en trois parties:

1.-Edition d'une architecture de réseau de neurones par l'interface XGUI : création d'un fichier « .net » (Net_work).

2.-Ecriture de la liste des entrées et des sorties qui seront présentées au réseau de neurones pour un apprentissage : création d'un fichier « .pat » (Pat_tern).

3.-Ecriture d'un script de modélisation de l'apprentissage, et de stockage des résultats : création d'un fichier « .bat » (Bat_chman).

Le logiciel SNNS propose la création de différents modèles connexionnistes. Parmi les plus courants, on reconnaît les perceptrons multicouches, les réseaux dynamiques et bouclés, Kohonen,... SNNS offre également, pour chacun de ces modèles, une panoplie d'algorithmes d'apprentissage, citons en quelques uns, les plus connus: - Back-propagation

- Back-percolation

- K-moyennes

- Apprentissage dynamique par quantification vectorielle

- Monte Carlo

- ...

Un exemple simple permet de bien illustrer les mécanismes du logiciel SNNS:

Il s'agit pour cet exemple de créer un compteur 4-bit modulo 4.

D'entrée, nous pouvons choisir une structure de perceptron (une couche ou multicouches) contenant une couche d'entrée à 4 neurones et d'une couche de sortie à deux neurones. L'interface XGUI de SNNS permet de créer très vite une telle structure neuronale qui sera stockée dans le fichier « Exemple_Net.net ».



Le fichier « Exemple_Net.net » contient l'état de chaque connexion entre neurones du réseau, ainsi que les vecteurs de biais, et des informations relatives à l'initialisation du réseau, à sa fonction de transfert et à son algorithme d'apprentissage. Le fichier « Exemple_Net.net » a l'allure suivante:

Exemple de code 4.1 : Exemple_Net.net SNNS network definition file V1.4-3D generated at Fri Sep 26 14:25:52 2003 network name : NetTestBat1 source files : no. of units : 8 no. of connections : 12 no. of unit types : 0 no. of site types : 0 learning function : Rprop update function : Topological_Order unit default section : act | bias | st | subnet | layer | act func | out func ---------|----------|----|--------|-------|--------------|------------- 0.00000 | 0.00000 | h | 0 | 1 | Act_Logistic | Out_Identity ---------|----------|----|--------|-------|--------------|------------- unit definition section : no. | typeName | unitName | act | bias | st | position | act func | out func | sites ----|----------|----------|----------|----------|----|----------|----------|----------|------- 1 | | | 1.00000 | 0.02064 | i | 2,2,1 ||| 2 | | | 0.00000 | -0.36342 | i | 2,3,1 ||| 3 | | | 0.00000 | -0.73386 | i | 2,4,1 ||| 4 | | | 1.00000 | -0.38463 | i | 2,5,1 ||| 5 | | | 0.23284 | 1.56220 | h | 5,2,1 ||| 6 | | | 0.00000 | 16.11093 | h | 5,3,1 ||| 7 | | | 0.00001 | 7.99998 | o | 8,2,1 ||| 8 | | | 0.99997 | 10.50436 | o | 8,3,1 ||| ----|----------|----------|----------|----------|----|----------|----------|----------|------- connection definition section : target | site | source:weight -------|------|-------------------------------------------------------------------------------------------

---- 5 | | 1:-0.01448, 2:-0.00614, 3:-32.17827, 4:-2.74005 6 | | 1:-2.17056, 2: 4.64729, 3: 7.93761, 4:-31.77466

7 | | 5:-82.95226, 6:48.33743



Une fois le fichier « .net » créé, il faut indiquer dans le formalisme SNNS la liste

des entrées, ainsi que les sorties qui leur sont associées. Cette tâche s'effectue au travers du fichier « Exemple_Pattern.pat ». Le formalisme SNNS est très simple et le fichier « Exemple_Pattern.pat » s'agence ainsi:

Exemple de code 4.2 : Exemple_Pattern.pat SNNS pattern definition file V4.2 /* Description du type de formalisme (SNNS V4.2) generated at Fri Sep 26 14:25:52 2003 /* Ces deux lignes sont obligatoires No. of patterns : 10 /* Nombre de patterns décrit dans le fichier No. of input units : 4 /* Dimension des entrées No. of output units : 2 /* Dimension des sorties /* Description des patterns d'entrée et les sorties respectives à leur associer #Input No 1 : 0 0 0 0 #Output No 1 : 0 0 #Input No 2 : 0 0 0 1 #Output No 2 : 0 1 #Input No 3 : 0 0 1 0 #Output No 3 : 1 0

[...] #Input No 10 : 1 0 0 1 #Output No 10 :



Il s'agit maintenant de relier le réseau de neurones (« .net ») avec les entrées/sorties (« .pat ») pour réaliser l'apprentissage du réseau stocké dans le fichier « .net ». Cela s'effectue grâce à la rédaction du fichier « Exemple_Batch.bat », écrit dans la grammaire proposée par SNNS. Cette grammaire permet de charger facilement un fichier « .net » ainsi qu'un fichier « .pat », et de créer l'apprentissage désiré, de travailler sur le réseau de neurones lui-même,... Le fichier « Exemple_Batch.bat » s'organise de la façon suivante:

Exemple de code 4.3 : Exemple_Batch.bat #EVRARD YANNICK 26.09.2003 #Test d'utilisation de Batchman #Les affectations preliminaires automatiques ############################################ LearningSet = "Exemple_Pattern.pat" Net = "Exemple_Net.net" NetBest = "NetBest.net" #Declaration des paramètres d'apprentissage et d'optimisation ############################################################# InitMin = -1.0 InitMax = 1.0 MaxCycle = 1000 Threshold = 0.000001 TrainSSE = 3.0e+15 BestSSE = 3.0e+15 #Chargement des fichiers ".net" et ".pat" ######################################### loadNet ( Net ) loadPattern ( LearningSet ) #Initialisation du NN ##################### setInitFunc ( "Randomize_Weights" , InitMax , InitMin ) setSeed () initNet () #Choix de la fonction d'apprentissage ##################################### setLearnFunc ( "Rprop" , 0.0 , 0.0 , 0.0 ); #Apprentissage et optimisation ############################## while TrainSSE > Threshold and CYCLES < 1000 do trainNet () TrainSSE=SSE if CYCLES mod 10 == 1 then print("TRAIN CYCLE : ", CYCLES, " ERREUR INSTANTANEE : ", SSE) endif endwhile #Sauvegarde des résultats ######################### saveResult( "./Exemple_Resultat.res" , 1 , PAT , TRUE , TRUE , "create") saveNet(NetBest)



Le même script Batchman permet également de simuler le réseau de neurones après apprentissage et de stocker les résultats dans le fichier « Exemple_Resultat.res ». Le fichier « .res » a l'allure suivante:

Exemple de code 4.4 : Exemple_Resultat.res SNNS result file V1.4-3D generated at Fri Sep 26 14:25:52 2003 No. of patterns : 10 No. of input units : 4 No. of output units : 2 startpattern : 1 endpattern : 10 input patterns included teaching output included #1.1 /* Numéro du pattern présenté en entrée. 0 0 0 0 /* Pattern présenté 0 0 /* Sortie espérée 0 0.00001 /* Sortie effective du perceptron à comparer avec la sortie espérée #2.1 0 0 0 1 0 1 0.00001 0.99997 #3.1 0 0 1 0 1 0 1 0.00001 #4.1 0 0 1 1 1 1 0.99967 0.99997 #5.1 0 1 0 0 0 0 0.00001 0.00001 #6.1 0 1 0 1 0 1 0.00001 0.99997 #7.1 0 1 1 0 1 0 1 0.00001 #8.1 0 1 1 1 1 1 0.99996 0.99993 #9.1 1 0 0 0 0 0 0.00001 0.00001 #10.1 1 0 0 1



4.2 Avantage/désavantage de MATLAB

MATLAB est un outil très puissant offrant une grande panoplie de paquetages contenant nombre de fonctionnalités intéressantes. Parmi ces paquetages, nous trouvons le « NN_ToolBox » ainsi que le « Som_ToolBox ». le « NN_ToolBox » est gratuit et inclus dans toute version standard de MATLAB. Il se compose d'une interface utilisateur (malheureusement pauvre et mal construite), ainsi que d'un jeu de fonctions très complets pour créer, simuler, modifier un réseau de neurones. MATLAB propose, tout comme SNNS, la possibilité de mettre en oeuvre maint architectures neuronales, ainsi que divers algorithmes d'apprentissage.

le « Som_ToolBox » permet, quand à lui, de réaliser des classements par carte auto-organisatrices rapidement et efficacement. Il est composé d'un jeu de fonctions complet permettant d'initialiser une SOM (Self-Organising Map), de l'entraîner, de la représenter, ainsi qu'une grande panoplie de fonctions auxiliaires offrant la possibilité de normaliser les vecteurs d'entrées, d'obtenir grand nombre de résultats intermédiaires, etc. ...

La création d'un projet sous MATLAB est relativement différente de la méthode sous SNNS, et par comparaison, nous nous proposons de présenter le même réseau de neurones mis en oeuvre avec SNNS, à savoir un compteur 4-bit modulo 4 à l'aide d'un perceptron à une couche d'entrée de 4 neurones et une couche de sortie de 1 neurone. Voici le script MATLAB qui réalise cette action:



Exemple de code 4.5 : Exemple MALTAB

% %Exemple de mise en oeuvre d'un perceptron à une couche cachée de 2 %neurones, pour apprendre à compter modulo 4 % %Mise à jour du Workspace en le nettoyant, et fermeture de toutes les %fenetres actives: clear all; close all; %Création du lot d'entrées: les entier de 0 à 15 sous forme binaire: ENTREE = [ 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 ; ... 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 ; ... 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 ; ... 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 ] %Les sorties à associer à chaque entrée: 0, 1, 2, 3, 0, 1, ... SORTIE = [ 0:3 0:3 0:3 0:3 ]; %Paramètres topologiques: One_NetSize = [ 2 , 1 ]; %Taille du premier réseau mima=[zeros(4,1) ones(4,1)]; %MINMAX des entrées %Création d'un nouveau PMC avec les paramètres topologiques indiqués: net=newff(mima,One_NetSize,{'tansig','purelin'},'trainrp'); %Réalisation d'un apprentissage pour le réseau de neurone "net" avec les %paramètres ENTREE et SORTIE: net = train ( net , ENTREE , SORTIE ) ; %Simulation du réseau de neurones et stoquage des résultats dans la %variable RESULTAT: RESULTAT = round ( sim ( net , ENTREE ) ) ;



4.3 Choix pour la suite du projet

MATLAB et SNNS sont deux outils de développement possédant chacun leur intérêt: SNNS offre une grande facilité pour implémenter des réseaux de topologies complexes, alors que MATLAB permet de développer et simuler rapidement un projet.

Les temps d'exécutions ne sont pas tout à fait similaires pour les deux logiciels. SNNS s'exécute en C, ce qui lui fournit une grande efficacité, alors que MATLAB est un langage vectorisé, se qui est un avantage pour la création de modèles connexionnistes, car la majeure partie des opérations mises en oeuvres sont des produits scalaires et matriciels. Cependant, il semble que MATLAB soit plus efficace pour des lots d'apprentissage inférieur à 5'000 vecteurs, alors que SNNS est plus rapide en calcul pour des lots d'apprentissages supérieur à 5'000 exemplaires.

Mais chacun des logiciels soulèvent quelques difficultés:

Ainsi, il est difficile d'implémenter un modèle non-supervisé (Kohonen, k-moyennes,...) avec SNNS de manière cohérente, alors que MATLAB permet la construction de telles architectures avec une facilité déconcertante.

Sous MATLAB, par contre, la réalisation de modèles supervisés (perceptrons,...) complexes, relèvent du domaine de l'acrobate.

Deux éléments majeurs interviennent cependant: le premier, est que le projet ACSIS est actuellement développé en JAVA sous WINDOWS. MATLAB tourne sur environnement WINDOWS également, ce qui est déjà une facilité. De plus, il est possible, et cela très simplement, d'interfacer MATLAB avec le langage JAVA. En effet, MATLAB fonctionne sur la base d'une Machine Virtuelle Java. Ainsi, un script MATLAB peut appeler une classe JAVA, ou même tout un paquetage.

Le deuxième élément majeur provient des considérations sur la taille du lot d'apprentissage. Ce lot dépassera rarement les 5'000 exemplaires.

Ainsi, le choix est fait d'utiliser MATLAB comme outil de développement pour la suite du projet.


Chapitre :5 Application aux logos noir et blancChapitre :6 Application aux images couleur

5 Application aux logos noir et blanc

5.1 Problématique

Le chapitre 3 a posé un cadre pour la reconnaissance d'images, que nous allons reprendre et appliquer pour l'identification de logos noir et blanc. Il s'agit ainsi de proposer une représentation de l'image, puis une méthode d'apprentissage liée à la représentation, et finalement, une série de tests et vérifications pour valider le modèle choisi.

Mais avant tout, il est essentiel de bien comprendre le problème. Une formulation plus complète de celui-ci permettra d'élaborer plus vite une architecture.

Il faut pouvoir dire d'un nouveau logo s'il est unique ou s'il ressemble par trop à un exemplaire déjà existant. C'est à dire qu'il va falloir le classer par rapport à un groupe de logos déjà connus et tous déjà associés à une classe. Si la classe dans laquelle entre le nouveau logo est trop proche des classes déjà existantes, alors on pourra dire que le nouvel exemplaire n'est pas original. Il sera également intéressent de retrouver les logos les plus proches d'une image choisie ( connue ou inconnue).

D'ors et déjà, une structure de réseau de neurones s'impose: les cartes auto-



organisatrices ou réseaux de Kohonen, comme décrits dans l'annexe théorique à section A.8.

Une carte auto-organisatrice est fondée sur le schéma de l'illustration 5.1: le réseau se compose de :

Figure 5.1 : Schéma d’une carte auto organisatrice

1 d'une couche d'entrée de N neurones qui reçoivent toutes les composantes d'un vecteur d'entrée x normalisé appartenant à RN.

2 d'une couche de sortie figurée par un treillis sur N1 N2 ou N3 habituellement. La représentation 2D de la couche de sortie est souvent la plus commode.

Chaque neurone de la seconde couche est relié à toutes les entrées par un poids ωik.

Chacun des ces neurones caractérise une classe à laquelle peut appartenir le vecteur d'entrée.



La particularité des cartes auto-organisatrices de Kohonen réside dans la notion de voisinage d'un neurone. Chaque neurone possède un ensemble de voisins directs, c'est à dire de classes proches. Ainsi, deux patterns d'entrée classés par deux neurones topologiquement proches appartiendront à deux classes séparées mais similaires. La distance entre les sorties sur un treillis 2D caractérise la distance entre deux vecteurs X1 et x2 de Rn.

Cette représentation a donc le mérite de généraliser un ensemble de vecteurs de Rn, et de diminuer le nombre de dimensions des représentations (on passe par exemple de N à 2 dimensions )

Le choix d'une carte auto-organisatrice garantit ainsi de pouvoir définir une « distance » entre tous les logos, ce qui répond entièrement au problème de leur reconnaissance et identification. La distance entre deux exemplaires sur la carte de Kohonen renseigne immédiatement sur la ressemblance ou la dissemblance des deux.

5.2 Représentation des entrées.

Toute l'information du fichier SVG est trop conséquente pour permettre quelconque apprentissage. Il faut donc, dans un premier temps, séparer l'information en sous-groupe. Il est possible, ainsi, de donner une représentation incomplète de l'image en ne considérant que le graphe des voisins de chaque zone segmentée. Une autre représentation consiste en les contours de chaque zones uniquement. La première représentation offre une connaissance topologique de l'image (à rapprocher de la branche mathématique qui porte le même nom), alors que la deuxième représentation fournit une connaissance géographique du logo.

La connaissance de la topologie d'un logo ne permet malheureusement son

identification que dans de très rares cas. D'autant plus que les propriétés topologies d'identité de deux formes sont applicables ici, à savoir que deux objets sont identiques si l'un peut être obtenu de l'autre par transformation continue, sans « déchirement ». L'exemple habituel, décrit largement dans de nombreux d'ouvrages, indique qu'un carré est identique à un cercle, mais pas à un tore. De même, une tasse de café et un Donut (tore) sont topologiquement identiques, car tous deux n'ont « qu'un trou », et donc, par déformation continue du Donut, on peut obtenir une tasse de café. Mais on ne peut pas



générer un Donut à partir d'une sous-tasse sans « déchirer » cette sous-tasse à un moment ou à un autre.

Figure 5.2 : Déformation continue d'une tasse de café pour obtenir un donut (tore)1

Figure 5.3 : Transformation discontinue due à une topologie différente entre une tasse et un disque

Ainsi, les deux logos (c) et (d) de la figure 5.4 sont topologiquement identiques, et

les deux logos(a) et (b) sont topologiquement très différents, et ceci pour un pixel de différence.



Figure 5.4 : Contres-exemples extrêmes pour l’analyse de la topologie

Il faut observer que sur l'image (a) le disque est disjoint de la structure en P, mais

pas dans l'image (b), et ceci pour un pixel de différence. Les images (a) et (b) sont topologiquement différentes. Par contre, les images (c) et (d) ont la même topologie: un seul objet blanc comportant un trou unique

La connaissance topologique du logo de sera pas retenue, car deux images très dissemblables peuvent avoir un même graphe, tout comme deux images très proches peuvent avoir deux graphes fortement différents.

L'information la plus conséquente s'obtient à partir des contours de chaque zones

segmentées. Celle-ci conserve en effet une information sur la répartition géographique des zones, et donc, indirectement, de sa topologie. Cependant, un problème subsiste: si l'on décide de représenter un logo comme étant une image 100x100, toute noire, et ne contenant que les contours des domaines du logo en blanc, on obtient généralement une image noire à plus de 99% : en moyenne, moins de 1% des pixels sont blanc. Dès lors que toutes les représentations sont identiques à 99%, toutes seront identifiées dans une même classe par la SOM (Self Organising Map).

Il s'avère ainsi difficile de ne travailler qu'avec les contours. Dans le cadre des logos noir et blanc, il est alors décidé de travailler directement à partir de l'image JPG.



Cependant, il faut rappeler que les logos sont des images TIF de dimension 100x100; c'est à dire 10'000 composantes par pattern d'entrée. C'est beaucoup trop. Il faut donc réduire la taille de l'image.

Le choix est fait d'utiliser également des réseaux de neurones pour la réduction de l'image. On se propose de « spliter » l'image en sous-régions carrées de 5 pixels de côté. On obtient ainsi 400 petits découpages du logo original. Maintenant, un petit réseau de neurones peut recevoir chaque carré de 5x5 ( vecteur à 25 composantes) et l'identifier à une seule valeur. Cette valeur peut ne pas être la moyenne des 25 pixels du carré. Cela serait même triste. Il est par contre possible d'associer des valeurs à des dispositions différentes des 25 pixels. On obtient finalement une image de 20x20 pixel représentant un logo. Cela permet d'effectuer une division par 25 du nombre de variables du système (de 10'000 à 400). La figure 5.5 présente un schéma pour l'illustration du découpage du logo et de l'analyse par 400 réseaux de neurones.



Figure 5.5 : Réduction d’une image avec 400 réseaux des neurones analysant chacun une petite partie du logo

Les 400 petits réseaux peuvent être implémentés de différentes façons. Deux méthodes on été testées, et toutes deux donnent des résultats similaires au niveau de la qualité et des temps d'apprentissages et d'exécution.

- Implémentation comme carte de Kohonen

- Implémentation comme perceptron multicouches

Les deux méthodes sont reprises dans le chapitre suivant.



5.3 Topologie

Maintenant que nous possédons une représentation réduite du logo, il est possible de réaliser un apprentissage non supervisé sur ces nouvelles images 20x20, à l'aide d'une structure comme illustrée sur la figure 5.1. Chaque logo réduit doit évidement être transformé à nouveau en vecteur de 400 composantes. Si l'on inclut le schéma de la carte auto organisatrice de l'illustration 5.1 au schéma 5.5 de la page précédente, on obtient le modèle général proposé pour la reconnaissance et l'identification de logos noir et blanc, représenté sur la figure suivante (figure 5.6) :

Figure 5.6 : Modèle général de reconnaissance de logos noir/blanc



5.4 Mise en oeuvre

5.4.1 Couche réductrice

A la section5.2, il a été simplement cité deux méthodes pour élaborer un réseau de neurones qui reçoit chaque petite partie d'image (5x5): soit par une SOM, soit par un perceptron multicouches (PMC). Observons la réalisation des deux:

Implémentation comme carte de Kohonen

Pour cette méthode, il est nécessaire de créer avant toute chose un ensemble de configurations d'un carré de 5x5 significatif et suffisamment grand afin d'adapter une carte par apprentissage non supervisé sur cet ensemble. Voici en exemple sur l'illustration 5.7 les exemplaires de bases choisis. Ils sont au nombre de 65.

Figure 5.7 : 65 exemplaires de carrés 5x5



Sur la base d'apprentissage de la figure 5.7, il a été possible d'entraîner un réseau de Kohonen (SOM) de 25 neurones, pour réussir à définir 22 classes séparées. Ainsi, à chaque petite région de 5x5 sera associée une valeur entre 1 et 22. on obtient le genre d'entrée suivante:

Logo 1941 Réduction 1941



Figure 5.8 : Exemples de réponse de la couche réductrice avec une SOM

Il faut constater que les régions toute noir ou toute blanche sont mises à une même

valeur. Cela permet d'identifier les logos autant que leur négatif.



Implémentation comme perceptron multicouches

Le choix d'utiliser un PMC pour l'analyse d'un carré de 5x5 du logo de base implique également la création d'une base d'apprentissage. Pour cela, la base présentée sur la figure 5.7 est reprise.

La différence avec la méthode par SOM est que cette fois il va falloir associer soi-même une classe à chaque vecteur de la base d'apprentissage. Cela permet en fait de pouvoir identifier les 65 vecteurs possibles comme tous différents. Ainsi, toute autre configuration sera rapprochée de l'une des 65 connues.

On utilise pour cette méthode un perceptron à une couche cachée de 10 neurones et un neurone de sortie.

Il ne reste ainsi plus qu'à entraîner le PMC avec la base d'apprentissage, puis à le simuler sur chacune des 400 petites découpes du logo. Les sorties ont l'aspect suivant:




Figure 5.9 : Exemples de réponse de la couche réductrice avec un PMC



5.4.2 Couche auto organisatrice

Cette couche reprend simplement l'image réduite issue de la première couche réductrice. Sur la base d'un lot suffisamment grand de logos réduits, la SOM de la couche auto organisatrice peut classer tous les exemplaires par similarité. Il est décidé d'utiliser pour la carte un treillis 2D de topologie rectangulaire, c'est à dire que chaque neurone a 4 voisins directs. La carte a une dimension de 30x30 (900 neurones). Cela permet de bien différentier les logos, sachant que la base de logos est forte de 2809 exemplaires. Il est évidement possible de choisir une carte plus grande ou plus petite, selon la taille du lot d'exemplaires.

Après apprentissage non supervisé, la carte s'active à chaque présentation d'un exemplaire. Tous les neurones sont plus ou moins activés, mais parmi tous, un l'est plus que les autres. C'est le neurone gagnant. On peut voir sur l'illustration 5.10 ce qu'il se passe au niveau de l'activation de la carte auto organisatrice pour différents logos: les figures vont par triplet et les images du centre et de droite montrent l'état de la carte auto organisatrice. Plus le pixel est blanc, plus l'activation est forte. Les représentations 2D et 3D de la SOM en couleurs chaudes (nuance de jaunes et de rouges) permettent de bien souligner la similarité entre les deux premiers logos (235 et 239). De même, on constate facilement la différence avec le troisième logo (240). Il est très simple d'identifier le maximum de la carte pour chaque logo.



Figure 5.10 : les logos 235 et 239 (a.1 et b.1) sont semblables. On l'observe également sur la représentation 2D ou 3D de l'état du réseau de Kohonen



Voici à titre d'exemples sur la figure 5.11, parmi les 1000 premiers logos de la banque de données, ceux qui appartiennent à la même classe que le logo 235. déjà présenté sur la figure précédente, l'illustration 5.10.

Figure 5.11 : Liste des logos de la même classe que le logo 235 (premier en haut à gauche)

La figure 5.11 permet d'ailleurs de constater que certains logos sont même

identiques: par exemple les logos 260 et 390.

Les temps d'exécutions sont acceptables. Par acceptable, il faut entendre que pour une analyse complète sur les 2809 logos de la banque de données, le calcul dure pendant environ 1h30, dont la plus part du temps passé à la réduction de l'image par la première couche de réseaux de neurones. Rappelons que pour chaque image, l'opération de reconnaissance sur un carré de 5x5 doit être répétée 400 fois. Ainsi, chaque image est analysée pendant deux secondes, c'est à dire 5 [ms] par PMC pour l'analyse d'une petite découpe du logo.

Ensuite, tous les résultats de la première couche sont ré-analysés par la SOM, et le calcul dure environ une minute pour une carte de 900 neurones et 1000 exemplaires



présentés.

De plus amples résultats sous forme de classes d'images sont disponibles en annexe C.

5.5 Conclusion

L'architecture proposée donne de bons résultats, mais malheureusement pas toujours très interprétable. Cela est en partie dû à la grande variabilité des logos parmi le lot proposé de 2809 exemplaires. Tous sont assez différents des autres, en général. On peut qu’en même se réjouir d'une nouvelle application pour les réseaux de neurones. La méthode utilisée sera en partie reprise au chapitre 6, pour la reconnaissance d'images en couleurs, bien que ce problème comporte ses propres spécificités et difficultés.


Chapitre :6 Application aux images couleur

6 Application aux images couleur

6.1 Problématique

Le problème de la reconnaissance d'image n'est pas aisé, comme présenté dans le chapitre 3. La difficulté vient essentiellement de la forme que devront adopter les vecteurs d'entrée à présenter au réseau de neurones. La question est en partie similaire à celle rencontrée pour les logos noir et blanc. Ici encore, il s'agit d'extraire toute l'information pertinente à un bon apprentissage à partir d'un fichier SVG représentant une image. Cependant, contrairement à la problématique des logos, la majeure partie du fichier va s'avérer utile pour la reconnaissance d'images en couleur. Chaque étape de l'utilisation de ses informations sera développée dans les prochains chapitres, mais avant, prenons le temps de réfléchir à une architecture possible pour le réseau de neurones.

La segmentation appliquée à des objets de couleur plus ou moins homogène sur

54


fond uni est extrêmement efficace. Les applications industrielles sont nombreuses (contrôle dans des chaînes de productions,...). Cependant, cette même segmentation sur des images couleur riches en informations s'avère peu effective. Il est difficile de fixer automatiquement un seuil d'arrêt à l'algorithme de segmentation. De ce fait un objet sera souvent sur-segmenté, c'est à dire que cet objet sera découpé en plusieurs zones, alors que nous aurions voulu obtenir un seul contour pour cet objet. Par exemple, un arbre sera rarement segmenté en un seul contour, comme figuré sur la figure 6.1. En effet, celui-ci possède avant tout un tronc et un feuillage de couleur différente, donc il y aura au moins segmentation des deux zones. De plus, le feuillage est varié, les jeux d'ombres et autres artefacts sont nombreux. Il est à nouveau difficile de fusionner ensemble les différentes parties du feuillage, sans prendre le risque de fusionner la prairie avec, ainsi que le ciel.

Figure 6.1 : Exemple de segmentation d'une image couleur

Le présent projet se propose de découvrir une méthode pour reconnaître des objets dans une image, et d'associer un mot à chacun.

55


Le premier problème est alors de pouvoir reconstruire les objets à partir du sous-ensemble constitué des zones de cet objet tel qu'un humain le perçoit. C'est à dire une méthode pour forcer la fusion de certaines zones de l'image segmentées, de façon à reconstruire un objet réel tel que notre arbre de tout à l'heure. Cette méthode ne doit évidemment pas fusionner la prairie avec le feuillage, uniquement les différentes parties du feuillage ainsi que le tronc. De plus, le système qui sera mis en oeuvre devra être indépendant de la taille des entités, ou de leurs positions dans l'image.

Il ne s'agit pas d'établir une méthode connectiviste pour trouver les contours de zones homogènes, mais bien de découvrir une technique permettant de raccorder différentes zones de l'image, ces zones n'étant pas forcément de trames ou de couleurs identiques...

Cette difficulté sera reprise dans les sections 6.2 et 6.3; une solution sera apportée, décrite et illustrée.

La deuxième difficulté est de pouvoir associer un mot ou un concept à un objet. Deux arbres très différents doivent pouvoir être reconnus comme étant des arbres, de même qu'un visage et un arbre doivent être dissociés. Il ne faut pas seulement reconstruire des objets, il faut également être « conscient » ce qui a été reconstruit. Est-ce un visage, une voiture?

L'approche de cette difficulté sera décrite dans les sections 6.4 et 6.5.

56


6.2 Reconstruction des contours, architecture et représentations

6.2.1 Choix de l'architecture

Le choix est fait de travailler sur des images sur-segmentées, car celles-ci n'ont pas définitivement perdu les contours d'un objet que l'on chercherait à identifier. On voit par exemple sur les figures 6.2a, 6.2b et 6.2c que l'image qui contient trop peu de zones ne peut plus être analysée pour reconnaître un arbre.

Figure 6.2 (a, b et c) : exemple de bonne segmentation et de sous-segmentation

Il s'agit donc de proposer un algorithme connexionniste permettant de fusionner les différentes parties de l'arbre pour n'en obtenir plus que son contour.

Pour choisir un bon modèle neuronal, il faut bien interpréter la tâche à accomplir. L'algorithme doit apprendre à fusionner des zones, même si celles-là ne sont pas toutes similaires. Le toit de la maison n'a pas la même couleur ni la même forme que les murs, ou encore, une voiture et ses pneus n'ont strictement rien à voir; pourtant, ces zones appartiennent à une même entité. Mais attention, le tronc brun et la pelouse verte ne doivent pas être associés; le tronc brun et le feuillage vert, oui. En résumé, l'algorithme doit pouvoir identifier les zones de l'image, deux par deux et par voisines, et fournir en réponse si les deux zones doivent être fusionnées ou pas.

Mathématiquement, cela revient à considérer l'espace des vecteurs d'entrée de dimension N appartenant à Rn. Chaque vecteur P est composé d'informations sur

57


chacune des deux zones. Le système proposé doit pouvoir généraliser des vecteurs proches, mais également associer ensemble des vecteurs très distants au sens d'une métrique régulière dans Rn. Dans un même élan, le système devra pouvoir apprendre à dissocier des vecteurs parfois proches (feuillage vert et pelouse verte). Le comportement que devra adopter le système est fortement non-linéaire.

Un algorithme de classement par carte auto-organisatrices ne peut pas être mis en oeuvre pour un pareil travail, car il n'est pas question de n'associer que des zones dont les représentations dans Rn sont proches. Par contre, une méthode d'apprentissage supervisé pourrait s'adapter à la résolution du problème. Un perceptron multicouches apprend à séparer des classes non-linéaires.

Le choix de l'architecture s'oriente donc sur celle d'un perceptron multicouches capable d'apprendre à rassembler des ensembles de zones disparates pour reconstruire des objets, par reconnaissance et identification avec les apprentissages passés.

Ce choix reste pour l'instant trop vague, car il dépend encore du type de représentation pour les vecteurs d'entrée. Si différents formalismes sont possibles pour les exemples à apprendre, il est intéressant de les relier ensemble. C'est à dire que l'on peut utiliser un premier perceptron pour analyser un type de représentation et obtenir une réponse appropriée du réseau de neurones, puis un deuxième perceptron (ou autre architecture...) pour l'analyse d'un deuxième formalisme, etc, jusqu'à obtenir par exemple N perceptrons multicouches travaillant en « parallèle » (la programmation est séquentielle, mais les réseaux de neurones fonctionnent indépendamment les uns des autres). Chaque PMC fournit une réponse qui peut être comparée avec celles des autres PMC, puisque tous travaillent sur un même concept, mais avec des représentations différentes. On peut donc récolter toutes les sorties des PMC pour les réinjecter sur un nouveau perceptron qui fait alors une ré-analyse des résultats de chaque PMC de l'étape précédente.

58


Figure 6.3 : Schéma général d'une architecture à plusieurs PMC

En résumé, l'architecture générale du système se décrit par le schéma de la figure 6.3: une première couche de N PMC reçoit les différentes représentations d'un vecteur d'entrée et fournit en sortie N réponses. Chaque réponse est envoyée sur la couche

59


suivante et ré-analysée pour obtenir la sortie définitive.

6.2.2 Choix des Représentations

Les images ou les informations sur les régions de l'image ne peuvent pas être fournies de manière brute au réseau de neurones. Il va falloir déterminer une représentation de ces données. La décision d'utiliser une représentation plutôt qu'une autre est le choix le plus difficile dans l'agencement d'un système connexionniste. En effet, un vecteur symbolisant une zone segmentée doit être proche d'une zone similaire en terme de distance dans Rn, et deux zones très différentes doivent également avoir deux représentations éloignées l'une de l'autre dans Rn. De plus, l'information de chaque vecteur doit être la plus complète possible et signifier au mieux les caractéristiques réelles d'une zone, ou couple de zones.

Au paragraphe 6.2.1, il a été proposé de présenter au réseau de neurones deux zones voisines et de lui apprendre à décider si ces deux régions doivent être fusionnées ou pas. Ainsi, chaque vecteur d'entrée se composera de l'information des deux régions voisines. La question est maintenant quelle information d'une zone est pertinente, et comment la représenter? Les informations nécessaires se découvrent des propriétés que devrait posséder le système quant à l'apprentissage que l'on veut effectuer.

- La couleur est importante. Des zones de trames et de couleurs similaires devront être fusionnées: les différentes parties du feuillage de l'arbre doivent être associées ensemble. Le réseau doit également apprendre à fusionner des régions de couleurs différentes, mais pas toutes. « Cela dépend » de la situation, de l'objet traité... Donc la couleur est un critère nécessaire, mais pas suffisant pour la reconstruction des formes d'une image.

- La position et la forme d'une zone par rapport à sa voisine est importante. Toujours pour reprendre l'exemple de l'arbre, une zone brune plutôt rectangulaire orientée verticalement (tronc), surmontée d'une zone verte, plutôt grande et déchirée (feuillage) doivent être ré-associées, alors qu'une zone verte, plutôt grande et déchirée (prairie), surmontée d'une zone brune plutôt rectangulaire orientée verticalement (tronc), ne doivent pas être fusionnées. Idéal pour en perdre son Latin. La seule différence entre le couple Feuillage/Tronc et Prairie/Tronc réside surtout dans la position relative des régions, et dans leur forme.

60


Chacun des paramètres, couleur et topologie, doivent être étudiés plus en détail. Tous deux amènent de nouvelles questions et difficultés à résoudre.

6.2.2.1 Informations topologiques

Nous cherchons à présent à trouver une représentation intéressante des informations topologiques d'un couple de zone.

Les données brutes proviennent du fichier SVG représentant la segmentation d'une image couleur. Les contours sont exprimés sous forme de couples de coordonnées indiquant un point du contour d'une zone. Les points sont donnés dans l'ordre sur le contour, dans le sens horaire, le premier point étant celui situé le plus haut à gauche du contour.

Les descriptions sont donc de tailles variables.

Exemple de deux contours:

Image du contour1 Image du contour2

Figure 6.4 : Exemple du contour de deux zones différentes (a et b)

61


Coordonnées du contour 1 :

45, 78,48, 78,51, 78,51, 81,54, 81,54, 84,54, 87,51, 87,51, 90,48, 90,48, 93,45, 93,42, 93,39, 93,36, 93,33, 93,30, 93,27, 93,24, 93,21, 93,18, 93,15, 93,12, 93,9, 93,6, 93,6, 90,9, 90,12, 90,15, 90,18, 90,21, 90,24, 90,27, 90,30, 90,33, 90,36, 90,36, 87,39, 87,42, 87,42, 90,45, 90,45, Coordonnées du contour 2 :

138, 63,141, 63,141, 66,141, 69,141, 72,141, 75,144, 75,144, 78,144, 81,147, 81,147, 84,150, 84,153, 84,153, 87,156, 87,159, 87,162, 87,165, 87,165, 84,168, 84,168, 87,168, 90,165, 90,162, 90,159, 90,156, 90,153, 90,150, 90,147, 90,147, 87,144, 87,144, 90,141, 90,138, 90,138, 87,138, 84,138, 81,138, 78,138, 75,135, 75,135, 72,135, 69,138, 69,138, 66.

Deux voies d'exploitation s'ouvrent: les contours peuvent être représentés soit directement par la liste des coordonnées, soit par la représentation 2D de l'image de ce contour.

Cependant, dans chacun des cas, il sera nécessaire de redimensionner tous les couples de zones voisines, afin que chaque paire entre dans un cadre fixe déterminé. Cela est nécessaire, car les régions sont toutes de tailles différentes, et le perceptron ne peut pas modifier le nombre de ses entrées en cours d'application. Les entrées doivent toutes avoir la même dimension.

Mais surtout, ce changement d'échelle apporte un grand avantage: il permet de s'affranchir du problème de l'homothétie et de la translation. En effet, il semble pertinent d'exiger de notre système qu'il sache reconnaître aussi bien le petit arbre en bas à gauche que le grand arbre en haut à droite. La reconnaissance doit être indépendante de la position des objets, ainsi que de leur taille respective. Par contre, on perd évidement de l'information, mais les contours sont simplifiés.

62


Figure 6.5 (a et b): Exemples de régions originales (a) et redimensionnées (b)

La même opération peut s'appliquer aux contours décrit directement par le fichier SVG.Cela diminue en tout cas la dimension des vecteurs d'entrée, et allège le système entier. L'opération de changement d'échelle sera considérée comme essentielle dans la chaîne des traitements.

Dans le présent projet, tous les couples de zones voisines seront redimensionnés dans un cache de 30X30 pixels.

Un aspect essentiel différencie pourtant les deux représentations possibles:

La représentation par liste des coordonnées des contours ne permet pas d'indiquer leur contenu précis. L'autre représentation, par image du contour, fournit cette information supplémentaire.

63


Figure 6.6 (a et b) : Contours sans (a) et avec (b) contenu

Le choix est fait, pour la représentation par image des contours, de fournir également le contenu de la zone comme présenté sur l'image b de la figure 6.6. Le contenu de la région segmentée provient de l'image de base.

Pour cette représentation, il reste encore à savoir comment représenter la couleur d'un pixel. La réponse est apportée dans le paragraphe suivant (6.2.2.2).

Quant à la représentation par liste des coordonnées des contours, nous ne l'abandonnons pas. L'idée la plus simple d'utilisation de ces informations est de faire figurer dans un vecteur d'entrée, les coordonnées de la première zone et de la deuxième zone. Les coordonnées sont évidement redimensionnées par rapport à un même cadre de 30X30 pixels. Un seul PMC suffit pour ce traitement. Cependant, comme indiqué et illustré dans un précédent travail de l'auteur sur la gestion de robots par réseaux de neurones artificiels [Evr03], un découplage de l'information permet de découvrir différents aspects d'une même réalité, respectivement classés et associés par plusieurs réseaux. De ce découplage résulte un meilleur apprentissage.

Le découplage peut se réaliser de bien des façons. La méthode mise en oeuvre consiste à découper la liste des coordonnées en sous-ensembles disjoints du vecteur principal. Nous pouvons ainsi créer quatre sous-vecteurs constitués respectivement des coordonnées X/Y de la première/deuxième zone. Mais ces quatre vecteurs ne représentent aucun lien entre les deux régions dont il faut décider de la fusion ou pas. Il

64


s'impose alors de re-coupler les sous-vecteurs en les associant deux par deux, un vecteur X/Y d'une zone avec un vecteur X/Y de l'autre zone. Nous obtenons finalement les quatre vecteurs suivants:

V1 ( Region1x , Region2x )

V2 ( Region1x , Region2y )

V3 ( Region1y , Region2x )

V4 ( Region1y , Region2y )

La taille de chaque vecteur est de 450 composantes. 450, car cette valeur est le norme maximum de composantes non nulles que pourrait compter un vecteur. En effet, les deux régions voisines sont réduites ensemble dans un même cadre de 30X30. La situation la plus extrême amènerait à ce que les contours passent par tous les points du cadre, c'est à dire 900 points et 1800 coordonnées (x et y). Cette situation est aberrante, et après de nombreuses observations (plusieurs centaines), il a été constaté que les contours occupent très rarement plus de 50% du cadre. Ainsi, les deux zones comptabilisent au plus 900 coordonnées (50%), et chaque vecteur V1 à V4 compte exactement moitié moins de composantes, c'est à dire 450, pour le cas le plus défavorable (50% du cadre occupé par des contours). Si les deux contours n'ont pas une longueur ensemble de 450, le reste des composantes des vecteursV1 à V4 sont mises à zéro.

Nous sommes dès lors en possession de cinq représentations différentes pour l'information topologique. Cela permet, comme indiqué au paragraphe 6.2.1, de faire adopter à plusieurs PMC des comportements différents pour un même traitement, et donc d'améliorer l'apprentissage, et d'illustrer des volets complémentaires de la reconnaissance d'images.

65


6.2.2.2 Informations chromatiques

L'information portée par la couleur se lit à partir du fichier SVG, comme presque toutes les autres informations. Cependant, SVG propose deux espaces différents de définition des couleurs. RGB et HSB.

Figure 6.7 (a et b) : Représentation RBG (a) et HSB (b) de l'espace des couleurs

La représentation RGB est linéaire, contrairement à la représentation HSB. Le choix se porte donc sur l'utilisation de RGB.

Au paragraphe 7.2.2.1, il est fait mention des couleurs à l'intérieur d'une zone; un problème persiste: la couleur est représentée par trois entiers compris entre 0 et 255. Cependant, un triplet ne peut pas être une composante d'un vecteur d'entrée, il faut donc rabattre la représentation des couleurs d'un espace à 3 dimensions (N3) sur un espace à une dimension (N) par une relation linéaire. Si les niveaux de RGB varient de 0 à 255, on peut proposer une relation du type

C = 2552*R + 255*G + B , (1)

ou R, G et B sont les niveaux de rouge de vert et de bleu, et ou C est l'image dans N du triplet (R,G,B) de N3 . « C » est donc la nouvelle couleur du pixel concerné.

De plus, le calcul est immédiat pour trouver qu'il y a au total 16 millions de couleurs (224). La variance induite dans un pattern d'entrée est gigantesque, et il va de soit de réduire cette variance en diminuant le nombre de couleurs. Par exemple, on peut ramener le nombre de niveaux de 255 à 25 (ou 10) pour Red, pour Green, et pour Blue,

66


ce qui ramène le nombre de couleurs à 16'000 environ (ou 1'000).

Le codage impliqué par la relation (1) et la réduction par 25 du nombre de niveaux d'intensité RGB sera celui utilisé pour la couleur à l'intérieur des zones pour la représentation topologique.

L'information du fichier SVG quant à la couleur peut également être utilisée pour simuler un perceptron directement. L'idée est de créer un nouveau vecteur de représentation pour chaque couple de régions voisines, à partir des niveaux R, G et B moyens de chaque zones. Nous obtenons ainsi pour chaque couple, un vecteur à six composantes [R1, G1, B1, R2, G2, B2] qui peut stimuler un perceptron en vue d'un apprentissage éventuel.

6.3 Reconstruction des contours, mise en oeuvre

6.3.1 Récapitulation et architecture adoptée

Tout au long de la section 6.2, nous avons mis en place la structure des représentations à fournir à différents perceptrons. Nous récapitulons:

Nous avons trois représentations parallèles:

-L'image du couple de zones voisines en vraies couleurs, mais re-normalisées de 0 à 16'275 (=253+252+25) et recadrée dans un cache de 30X30. Donc, un vecteur de dimension 900, et de Minmax [0 ; 16'275].

-La liste des coordonnées des deux contours, redimensionnés, contenue dans 4 vecteurs de dimension 450 et de Minmax [1 ; 30].

-La couleur moyenne RGB des deux régions, contenue dans un vecteur de dimension 6 et de Minmax [0 ; 255].

Ces représentations conduisent tout naturellement à une architecture neuronale pour l'apprentissage et la reconnaissance d'objets par fusion.

67


Figure 6.8 : Architecture neuronale

Le réseau proposé se compose d'une première couche de trois unités de traitement, chacun fournissant une sortie 1 ou 0, selon qu'il faut fusionner ou pas le couple de zones présenté. La premières unité compte 900 entrées, une couche cachée de 500 neurones et une sortie (1 neurone). La deuxième unité se compose de 5 perceptrons: les 4 premiers reçoivent les représentations et ont 450 entrées, 50 neurones cachés et une sortie. Le cinquième reçoit les sorties des 4 premiers et compte 10 neurones cachés ainsi qu'une sortie. La troisième unité, celle traitant des couleurs, a 6 entrées, 5 neurones cachés et un neurone de sortie. Le modèle comporte également une deuxième couche de une unité de traitement, qui reçoit simplement les sorties de la première couche pour reprendre une décision par rapport au trois sorties. Cette unité est également un PMC à 3 entrées, 5 neurones cachés et un neurone de sortie.

Le réseau de neurones proposé fonctionne en deux étapes: une étape d'apprentissage et une étape de reconnaissance, qui seront décrite dans les deux prochains paragraphes.

68


6.3.2 Apprentissage

Lors de cette phase de fonctionnement, chaque couche va devoir appliquer son apprentissage l'une après l'autre. D'abord la première couche:

il suffit d'appliquer l'algorithme de rétro propagation du gradient avec un lot de n vecteurs d'entrée et les n sorties respectives à associer. Cela pour les trois unités de la première couche.

Ensuite, il faut re-simuler la première couche de PMC avec tout le lot d'entrées pour obtenir le lot des n réponses correspondantes de chacune des trois premières unités.

Pour la deuxième couche, il faut maintenant simuler la rétro propagation avec les n réponses de la première couche, et le lot des n sorties, le même qu'utilisé pour l'apprentissage de la première couche.

La structure est adaptée!

Ci-dessous, quelques graphiques pour illustrer l'apprentissage de toute la structure. Il y a quatre graphiques qui contiennent chacun deux courbes. La première en bleu est la suite de réponses attendue pour un apprentissage sur 500 zones, et la deuxième en vert et la réponse du PMC indiqué (1er, 2ème,...)

69


(a) Réponse du réseau traitant de l’image (b) Réponse du réseau traitant des contours

(a) Réponse du réseau traitant des couleurs (b) Réponse du réseau de la deuxième couche

Figure 6.9 : Graphique de la réponse de chaque partie du système comparée à la réponse idéale. Le réseau traitant de l’image (a) rend une moyenne

Les graphiques montrent que le premier réseau est inefficace: celui ci répond la moyenne exacte des entrées désirées ( 1/n * Σ(si) ), ce qui peut arriver lorsque l'on travaille avec l'erreur quadratique moyenne. Une autre mesure de cette inefficacité se réalise par le gradient instantané de l'algorithme de rétro propagation: si cette valeur est grande, c'est que le système est loin d'avoir atteint un puits de stabilité. La pente (le gradient) qui mène à ce puits est forte. Par contre, si le gradient est proche de zéro, c'est que le réseau n'apprend plus, que ses coefficients synaptiques ne se modifient plus, et que le réseau a atteint un état stable. Mais cet état n'en est pas pour autant intéressant. A chaque pas d'itération de l'algorithme de la rétro propagation, le gradient diminue pour tendre asymptotiquement vers zéro. Mais plus la chute du gradient est brutale, plus

70


l'apprentissage est mauvais. C'est ce critère en « dérivée seconde » (dérivée du gradient) qui indique la qualité de l'apprentissage.

L'algorithme d'apprentissage appliqué au premier PMC provoque une chute spectaculaire du gradient dès les premières itérations pour descendre en dessous des 10-6 en moins de 50 pas de calculs, alors que plusieurs centaines, voire milliers d'itérations sont nécessaires habituellement.

Pour la suites du travail, il est décidé de ne plus tenir compte du PMC traitant des données topologiques sous formes d'image 2D. Celui-ci n'est d'aucune utilité, et surtout alourdit et ralentit fortement le système entier. La topologie utilisée dès lors devient celle de la figure 6.10.

71


Figure 6.10 : Topologie de base pour la reconstruction des contours

6.3.3 Reconnaissance

Lors de cette phase, une image est choisie, et à partir de cette image et du fichier SVG correspondant, on établit la liste des couples de zones, et pour chaque couple, on calcule les vecteurs d'entrées du système. Chaque n-uplets de vecteurs est présenté au réseau de neurones et en sortie, on obtient finalement la liste des couples à re-fusionner.

La re-fusion des zones n'est cependant pas évidente: comme illustré sur les exemples de

72


la figure 6.11, on voit que les régions peuvent s'associer en groupes différents, voire même à contours communs, et pourtant il s'agit de reconstruire ces groupes de connexité sans les confondre. Par exemple, supposons que le réseau reconnaisse les domaines formant l'arbre de la figure 6.11, ainsi que les zones de la maison accolée à l'arbre, sans toute fois associer l'arbre et la maison. Il est important de différencier les deux ensembles de régions. Un algorithme a été mis en oeuvre pour résoudre ce problème.

Figure 6.11 : Les fusions de zones voisines sont indiquées sur la première image (traits rouges, verts et bleus). L’idéal est de reconstruire les objets comme sur la deuxième image. La troisième image est un mauvais exemple.

73


6.4 Limites et difficultés

Plusieurs apprentissages et simulations ont été menées avec différents groupes d'objets, notamment des visages, des arbres, des maisons et des voitures. Le système réagit bien tant que l'on reste dans un même groupe d'objets, par exemple les arbres. Après un apprentissage sur une vingtaine d'images, le réseau réagit relativement bien pour retrouver le contours d'autres arbres sur de nouvelles images,

Cependant, le système réagit très mal dès que l'on cumule des entités des types différents. Par exemple, l'apprentissage cumulé de visages et d'arbres amène le réseau à fusionner presque toutes les zones, et ne permet plus de travailler correctement.

6.4.1 Première ébauche de solution, généralisation

La solution au problème du chapitre précédent s'impose d'elle-même: il suffit de cumuler les systèmes: un réseau de neurones qui reconnaît exclusivement des visages, une autre architecture qui identifie uniquement des voitures,...

Cela offre de rendre encore plus modulaire le fonctionnement du réseau. En effet, pour que le système reconnaisse une classe supplémentaire d'objet, il suffit de rajouter un nouveau réseau spécialisé dans ce traitement. Les avantages évidents de cette méthode sont multiples:

- Pour l'analyse d'un nouvel objet ou concept, seul une sous partie du système doit subir un apprentissage. Et rappelons que l'apprentissage est de loin la partie la plus longue du traitement.

- Le niveau de fiabilité du système s'en trouve amélioré. Il y a moins de risque de fusionner des groupes de zones qui n'auraient pas dû.

- Le temps de traitement de la simulation du réseau de neurones est rapide, et l'adjonction d'un nouveau module à simuler ne ralentit que très peu le traitement.

- La base des vecteurs d'entrée et des classes à associer sera également plus simple à établir:

74


On peut ainsi proposer un schéma final pour le système de reconstruction des contours, le schéma de la figure 6.12:

Figure 6.12 : schéma pour le système de reconstruction des contours

Mais attention, cette structure demande un apprentissage adapté: l'ensemble des 7 PMC qui analysent les arbres doit éviter à tout pris de reconstruire d'autre objets. Ainsi, à cet effet, il faudra lui présenter aussi autre chose que des arbres et lui apprendre à ne rien fusionner dans cette image sans arbre.

75


La nouvelle méthode proposée ne donne toujours pas de résultats satisfaisants, même si l'amélioration des performances se ressent. Il est difficile de quantifier ce progrès. Celui-ci demande de vérifier les traitements du système pour de nombreuses images avec contrôle par un humain. Le travail est fastidieux mais permet tout de même une analyse qualitative.

Prenons par exemple la structure qui reconstruit les contours des arbres. Elle sait reconnaître un chêne plutôt bien. Mais elle fusionne encore d'autres zones que l'arbre et reconstruit souvent plusieurs objets par image. Supposons que la structure découvre 3 objets différents. Parmi ceux-là figure l'arbre, bien reconstruit dans plus de la moitié des cas. Les deux autres objets sont des regroupements de zones qui n'auraient pas dû avoir lieu, des erreurs.

Manifestement, le traitement par PMC uniquement est incomplet. Il convient de raffiner les méprises du système de reconstruction des contours.

6.4.2 Deuxième ébauche de solution, classification et identification

La structure proposée au paragraphe précédent (6.4.1) a le défaut persistant de réaliser des fusions malheureuses et de découvrir des objets qui n'en sont pas. Toutes les tentatives pour éliminer ces objets superflus par un traitement direct s'avouent inefficaces.

Par contre, il est envisageable de rajouter une couche de traitement pour classer et identifier les « objets trouvés ». Ce traitement se doit d'être connexionniste, évidemment.

Les mots « classement » et « identification » inspirent tout de suite à une carte auto-organisatrice, comme utilisé pour le travail sur les logos noir et blanc au chapitre 5.

Le traitement est assez simple: reprenons une fois encore l'exemple de la structure qui reconstruit les arbres, ainsi que les trois objets découverts (un arbre et deux objets insensés). Chaque entité sera comparée à une banque de données contenant toutes sortes d'objets: des arbres, des maisons, des visages,... Si l'un de ceux découverts par la structure est présenté à la SOM (Self Organising Map), il sera classé par rapport à tous ceux déjà connu. S'il est plus proche d'un arbre, alors on considère que l'objet est bien un arbre. Sinon, on l'ignore. L'opération est réitérée pour tous les objets trouvés par tous

76


les sous-systèmes.

Il ne reste plus qu'à définir la structure de la carte auto-organisatrice.

6.5 Reconnaissance d'objets, architecture, représentations

L'architecture retenue est un système à deux SOMs superposées. Voici la raison:

Considérons une première carte ou réseau de Kohonen. Celui-ci doit avoir une structure assez grande, car les objets sont très variables. Les visages ne seront pas tous regroupés parfaitement au même endroit, de même pour les arbres ou les autres objets. Si une quantité trop faible de neurones est utilisée, par exemple 16 (4x4), alors des arbres seront classés trop proche des visages et les objets seront indiscernables.

Cependant, il ne faut pas perdre de vue que, comme expliqué dans l'annexe théorique A.8, le temps de convergence d'un réseau de Kohonen est excessivement long. Un nombre exessif de neurones rendrait le système inexploitable.

400 semble un bon compromis. Une carte de 20x20 permet déjà de différencier les quelques objets qui ont pu être traité dans le cadre du projet (arbres, visages, maisons, voitures).

Cependant cette différentiation n'est pas évidente, au regard des résultats présentés à la figure 6.13. On y observe l'état de la carte pour six arbres connus, dix visages connus, et le dernier pour un nouvel objet qu'il faut identifier. On constate que l'activation des six premières cartes est en général plus sombre, avec des pics plus marqués. Alors que les cartes des dix visages sont toutes plus disparates, plus floues. La dix-septième carte, celle d'un objet inconnu, ressemble plutôt à la 7ième, 15ième et 16ième carte, donc à un visage.

77


Figure 6.13 : Etat de la SOM pour 6 arbres(1 à 6), 10 visages (7 à 16) et un objet inconnu (17)

Et voici sur l'illustration 6.13 l'image et tous les contours à gauche (a) et à droite, entouré en rouge, l'objet « inconnu » qui ressemble à des visages:

(a) : Image et tous les contours (b) : L’objet inconnu était un visage

Figure 6.14 : Recherche d’un objet ‘inconnu’

78


Habituellement, on identifie la classe des patterns analysés selon la position du neurone le plus activé. Pour les réponses présentées à l'illustration 6.13, il n'y à pas « un » neurone ou voisinage de neurones spécialement activés. Les similarités entre les cartes sont différentes..

C'est pourquoi il s'avère nécessaire d'effectuer un nouveau traitement pour identifier les cartes par ressemblance. Une deuxième SOM sait effectuer ce travail. Elle s'agence exactement comme la première, et se superpose à elle comme présenté sur l'illustration 6.15:

Figure 6.15 : Deux SOM superposées pour le classement et l’identification des objets

Les objets sont ainsi mieux identifiables. Comme il se peut qu'il y ait encore certaines confusions, il est décidé de considérer un voisinage de taille 3 pour le neurone le plus activé de la carte de l'objet inconnu. Si se voisinage contient le neurone d'activation maximum d'autres cartes, alors on choisit l'objet qui est le plus souvent représenté dans ce voisinage. Ainsi, l'objet reconstruit par le système pour les arbres peut très bien être proche de deux arbres et de trois visages différents. Alors celui-ci est interprété comme visage, et se voit abandonné, puisque ce n'est pas un arbre.

Au final, l'architecture générale proposée pour le système entier se découvre à la figure 6.16.

79


Figure 6.16 : Schéma général pour tout le système de reconnaissance d’images couleur

80


6.6 Conclusion

Les résultats du système complet mis en oeuvre donne quelques bons résultats pour des images relativement simples. Sur des images plus complexes, la reconnaissance d'objets pose encore problème. Il est par exemple difficile de travailler sur un lot d'images telles que les quatre proposées à la figure 6.17.

(a) (b)

(c) (d)

Figure 6.17 : Exemples d’images trop complexes et non traitables

La partie de système qui reconstruit les contours, à base de PMC, ne donne pas toujours de très bons résultats. Il ne fusionne pas des objets au hasard, loin de là. Il a plutôt tendance à « déborder » un peu, c'est à dire à englober les zones voisines d'un objet. Par exemple, il arrive assez souvent qu'un visage soit reconstruit avec quelques régions qui l'entoure, comme sur l'image suivante, qui est une capture de l'interface réalisée dans le cadre du projet, et décrite dans l'annexe B.

81


Figure 6.18 : Exemple de débordement

Cependant, plus les lots d'apprentissages sont nombreux, meilleurs sont les traitements. Les échéances du projet ont permis de réaliser des apprentissages sur environ 150 images. Si l'on présente une image déjà apprise ou très proche au système, celui-ci réagit relativement bien. Pour les nouvelles images, le résultat reste un peu incertain. Mais une fois de plus, les performances vont en s'améliorant au fur et à mesure d'apprentissages de nouveaux objets.

L'annexe C présente de plus amples résultats sous forme d'images.

82

Chapitre :7 Ouverture et conclusion

7 Ouverture et conclusion

Les recherches menées pendant 12 semaines donnent plusieurs bons résultats,

ainsi que quelques-uns illustrant les limites de la reconnaissance d’images par réseaux de neurones telle que réalisée pour le présent mémoire.

Le travail sur les logos noir et blanc s’avère concluant. Ceux-là sont classés par ressemblance dans une mesure plutôt correcte.

Quant aux images en couleur, leur traitement se révèle plus difficile et limité. Les temps de création de lots d’apprentissages sont relativement longs. Dans le cadre de ce projet, les photos brutes ont d’abord dues être analysées par un premier tiers pour réaliser l’opération de découpage de l’image (Split). L’opération peut durer plusieurs heures pour une centaine d’exemplaires. Ensuite, une deuxième personne reçoit ces images splitées pour effectuer une opération de Merge. A nouveau, une heure au moins est nécessaire au regroupement des régions (segmentation) et leur stockage dans un fichier SVG. En troisième partie, les images peuvent être analysées pour leur reconnaissance.

Ensuite, il faut passer un temps pour évaluer la qualité de la segmentation et ainsi,

83


les fichiers SVG qui seront traitées. Cependant, le travail qui consiste à sélectionner sur un grand lot d’images les zones formant un même objet est très long, et s’évalue en jours. Ces délais inhérents à tout modèle connexionniste n’ont permis de réaliser des tests « que » sur un lot de 400 exemplaires de segmentations différentes.

Les résultats d’un réseau de neurones sont directement liés à la taille de sa base d’apprentissage et à la taille des vecteurs d’entrées. Si les vecteurs sont grands, il faut une base d’apprentissage conséquente. Au regard des résultats obtenus, l’amélioration est franche entre un lot de 20 images et un autre de 100 images. Il est tout à fait pensable que ces résultats soient encore meilleurs avec des lots plus nombreux. Cela n’a malheureusement pas pu être vérifié, et la recherche s’est limitée sur le nombre d’images.

Cependant, au regard des graphiques (b) (c) et (d) de la figure 6.9, on constate que les apprentissages sont de très bonne qualité. Les tests ont été menés avec un maximum de plus de 12’000 vecteurs d’entrées. La qualité de l’apprentissage est pareille avec une erreur quadratique relative toujours inférieure à 1%, donc très bonne.

Le système proposé peut ainsi s’améliorer encore en dehors du cadre du projet actuel. Il suffit de continuer à créer des lots de vecteurs d’entrées et à réaliser des apprentissages. Le modèle connexionniste est évolutif et adaptatif. Il n’est pas figé.

En outre, il est possible que d’autres architectures donnent de meilleurs résultats. Ou alors une autre approche. Une idée exploitable est de travailler sur plusieurs étages de la pyramide de segmentation en même temps. Actuellement, le modèle mis en œuvre ne travaille que sur un étage. Il semble que l’on puisse apprendre quelque chose de la façon dont fusionnent les régions d’un étage à l’autre.

Le projet accomplit repose avant tout sur la recherche. Il est maintenant intéressant de proposer des applications où les analyses effectuées peuvent s’avérer utiles.

La réalisation autours des logos noir et blanc permet finalement de regrouper, de classer, d’associer toutes sortes de représentations noir et blanc. Le système peut alors s’intégrer dans toute chaîne de production au niveau du contrôle de la qualité, de pièces fabriquées par exemples. Le modèle proposé peut reconnaître facilement une pièce qui serait trop distante des caractéristiques de fabrication requises, et cela avec une bonne résistante au bruit.

Finalement, le modèle proposé sait reconnaître et classer toutes sortes d’images noir et blanc et peut ainsi être appliqué à autre chose que des logos noir et blanc. Par

84


exemple des images médicales (radiologie, IRM), astronomiques, nucléaires, …

Le système créé pour la reconnaissance d’images en couleur permet quant à lui d’annoter des images et de définir des informations supplémentaires sur son contenu. Un peu dès lors imaginer une application pour des moteurs de recherches d’images, comme Google, mais plus performants. Aujourd’hui, le fameux Google effectue une recherche sur des images en scrutant le titre de ces images. Ainsi, une recherche sur le mot arbre fournit non seulement des plantes, mais également des arbres généalogiques, des schémas,… Ce ne serait pas le cas avec un moteur basé sur la représentation SVG des images. Ce dernier scruterait les images selon une certaine borne « <--object … » par exemple. Le projet réalisé permet l’annotation automatique de ces images.

Par contre, il est difficilement envisageable d’intégrer le modèle dans un projet robotique, car les temps de traitement ne sont pas adaptés.

Finalement, tout c’est déroulé dans de bonnes conditions et les objectifs ont été atteints. Cela grâce à la toute première réflexion de l’ouvrage, à savoir la position philosophique à adopter pour la réalisation d’un projet connexionniste. Il est bon, pour ces dernières lignes de se remémorer les choix de l’auteur, de prendre un peu de recul et de constater dans quelle mesure ils se sont révélés importants.

La réflexion cognitive a permis de bien saisir le modèle en tant que « sujet », c’est à dire d’appréhender son fonctionnement direct : la topologie des réseaux, les algorithmes d’apprentissages, l’analyse préalable de sa capacité de classement, …

La réflexion cybernétique a également beaucoup apporté. En effet, elle a permis d’améliorer les qualités du système au travers de la considération dynamique de sa simulation : comment réagit le réseau de neurones si l’on rajoute un nouveau mot ? Y a-t-il des vecteurs d’entrées qu’il est préférable de ne pas présenter ? Quel est le nombre de neurones cachés nécessaire ?…

En dernier lieu, l‘approche idéaliste de Kant et Platon a offert un cadre rigoureux et cohérent de recherche, surtout au travers des différents découpages du travail, et de la réflexion de base sur le « comment » de la reconnaissance d’images, au chapitre 3.

Encore loin de la fameuse « intelligence artificielle », le Graal des connexionnistes, les réseaux de neurones n’en sont pas moins livrés à un bel avenir. Les constructions époustouflantes et nouvelles qui naissent essentiellement dans les centres de recherches commencent à offrir des outils techniques de premier choix réellement utiles sur le marché. Un réseau de neurones gagnera-t-il un jour le grand concours de Turing ?

85


86

Annexe A : Introduction théorique


A.1 Neurone formel La figure 4.1 présente le fonctionnement d'un neurone formel . Il s'agit d'un

composant calculatoire faisant la somme pondérée des signaux reçus en entrée (calculant la quantité h) à laquelle on applique une fonction de transfert, ici la fonction seuil (fonction de Heavyside), afin d'obtenir la réponse de la cellule (notée y).

Figure A.1 : Identification entre neurone biologique et neurone formel

87


La figure A.2 donne les notations que nous utilisons dans cet ouvrage.

Figure A.2 : Notations d'un neurone artificiel

En reprenant les notations de l'illustration A.2, la sortie d'un neurone est définie par :

(1)

où u désigne le seuil de la fonction de transfert H (Heavy-side, sigmoïde,...). Il est possible d'une part de généraliser ce comportement à n'importe quelle cellule i, il suffit de rajouter un indice supplémentaire à toutes les quantités afin de spécifier leur relation avec i, d'où l'on obtient :

(2)

. Certains modèles, comme les réseaux RBF (Radial Basis Function) utilisent pour

hi la quantité :

(3)

88


A.2 Perceptron une couche

A.2.1 Introduction Mis au point à partir du milieu des années 50 (57-61) par Rosenblatt, le perceptron

se veut un modèle de l'activité perceptive. Il s'agit d'associer des configurations présentées en entrée sur la rétine à des réponses. Constitué de 2 couches de cellules (et donc une couche de connexions), l'une pour la saisie (la rétine), l'autre pour la réponse. Imaginons un perceptron constitué d'une rétine 6X6 et d'une couche de sortie de 26 cellules. La tâche du perceptron sera de reconnaître les lettres présentées sur la rétine, chaque lettre sera associée à une cellule de sortie. Ainsi, lorsque l'on présente un A on souhaite que la première cellule soit active et toutes les autres inactives.

A.2.2 Description mathématique Le nombre de cellules (de chaque couche) est adapté à la dimension de l'espace

des valeurs. À chaque cellule de la couche de sortie on associe une valeur θi appelée seuil d'activation, ainsi qu'une fonction de transfert fi qui renvoie la valeur +1 si la somme pondérée des entrées est supérieure au seuil et 0 sinon (on se place dans l'hypothèse de cellules binaires i.e. deux états au choix, 0 et 1 ou -1 et 1). Plus formellement, si on note ωij la connexion de la cellule j (rétine) vers la cellule i (sortie), on pose

(4)

où sj désigne le signal transitant entre les cellules j et i .

L'objectif est d'entraîner le réseau jusqu'à ce que la valeur obtenue en sortie soit égale à la valeur désirée (on est dans le cadre d'un apprentissage supervisé). Pour cela on utilise la règle de Hebb (du nom de son inspirateur Donald Hebb) qui consiste à renforcer les connexions entre deux cellules si elles répondent similairement et à diminuer cette valeur sinon. On pose :

89


(5)

ou encore, si on rend le temps explicite dans l'équation

(6)

dans laquelle ai(t) désigne la valeur calculée (au temps t) par le réseau sur la sortie

i, tandis que di correspond à la valeur désirée ; sj(t) correspond au signal transitant sur la connexion de j à i de poids ωij(t), η(t) étant le pas (ou coefficient) d'apprentissage au temps t. Ce pas sert à moduler l'impact de l'erreur sur la connexion.

A.2.3 Algorithme du perceptron une couche L'algorithme d'apprentissage est donné de manière informelle ci-après, une

version plus informatique étant donnée par la suite : Algorithme d’apprentissage du perceptron simple : Répéter jusqu’à ce que le réseau ait appris Pour chaque donnée de la base faire Propager l’information jusqu’à la sortie Si la sortie obtenue est différente de la sortie attendue Alors Modifier les poids des connexions Se rappeler que le réseau n’a pas appris correctement FinSi finRépéter Le passage à la version plus informatique repose sur la transformation de la

boucle Répéter ... Jusqu'à en une boucle Tant que ... Faire. Cette transformation nécessite l'introduction d'une variable δ qui va être positionnée à 1, pour pouvoir entrer dans la boucle. Une fois dans la boucle, on va supposer que l'apprentissage est correct, on positionne ainsi δ à une valeur différente de 1, par exemple 0. Puis lorsque l'on comparera la valeur attendue avec la valeur désirée, si les deux informations sont

90


différentes, on positionnera δ à 1, pour assurer une nouvelle itération sur l'ensemble des données à apprendre.

δ :=1 ; Tant que δ ==1 faire /* à chaque début de cycle, on réinitialise δ */ δ:=0 Pour chaque donnée à apprendre faire Pour chaque cellules de la couche de sortie faire Calculer ai Si ai!= di Pour chaque cellules appartenant à la rétine Mettre à jour ωij FinPourChaque δ:=1 finSi finPourChaque finPourChaque finTantQue δ est un marqueur qui permet de savoir si le réseau a subi au moins une

modification au cours d'un cycle (ou époque) durant lequel on a présenté toutes les données de la base d'apprentissage. Bien entendu, si une donnée provoque une modification du réseau (mise à jour d'une ou plusieurs connexions), lorsque l'on présente la donnée suivante, elle passera dans le réseau modifié.

A.2.4 Limitations et propriétés fondamentales

Rosenblatt a démontré la convergence de l'algorithme d'apprentissage du perceptron : « Si le problème admet une solution, alors l'algorithme trouvera une solution au problème en un temps fini et ce indépendamment de l'ordre de présentation des données ».

L'ordre de présentation des données n'influe pas sur la découverte de la solution mais sur les étapes du traitement.

91


Le perceptron ne résout que des problèmes linéairement séparables. Tout problème non linéairement séparable peut être transformé en un problème

équivalant linéairement séparable, mais il n'existe pas d'algorithme permettant d'automatiser la transformation.

À la fin des années 1960 on ne connaissait pas d'algorithme permettant d'effectuer l'apprentissage d'un Perception Multicouches tel que celui permettant de résoudre le problème du OU exclusif. Cet argument a servi à L. Minsky et S. Papert pour étayer le fait que le domaine de recherche sur les réseaux de neurones soit sans avenir.

92


A.3 Perceptron multicouches

Figure A.3 : Réseau à couches multiples

A.3.1 Introduction

La séparation linéaire proposée par le perceptron à une seule couche n’est pas

suffisante pour toute une classe de problèmes. Le perceptron multicouches offre une alternative intéressante et très utilisée.

A.3.2 Notation On considère un réseau possédant l +1 couches de connexions, c'est-à-dire avec l

couches cachées H1 ...H l, auxquelles on rajoute la rétine, notée R et la couche de sortie notée S. Chaque couche de cellules contient un certain nombre de cellules, notés N0, N1, N2, …, Nl, Nl +1. Une connexion joignant une cellule i à une cellule j sera notée ωk

ji si elle appartient à la kème couche de connexions. La sortie de la cellule i appartenant à la kème couche de cellules sera notée sk

i=fi(aki); lorsque k=0, (la cellule appartient à la

rétine) on pose s0i = xi, lorsque k= l +1 (la cellule appartient à la couche de sortie) on

pose ski=ai. On appelle activation de la cellule i de la kème couche la valeur :

(7)

93


Enfin on notera, dip la valeur désirée sur la cellule i pour le pattern p , et oi

p la valeur obtenue pour le pattern p sur la sortie i.

A.3.3 Description Mathématique // vers l’algorithme de rétro-propagation

Maintenant que les notations sont définies, nous allons voir comment on peut généraliser la règle delta dans le cadre du PMC. On considérera que toutes les fonctions de transfert utilisées sont continues et dérivables. On définit l'erreur globale du système comme la somme des erreurs partielles obtenues pour chaque pattern fourni en entrée. En d'autre terme :

(8)

On cherche maintenant à minimiser l'erreur quadratique instantanée du système,

par la méthode du gradient stochastique. On définit la variation sur un poids ωij pour un pattern p par :

(9)

Il est maintenant nécessaire de calculer cette expression. Nous allons scinder le

calcul en deux parties, d'une part pour les connexions allant vers la couche de sortie (conditions aux bords), et d'autre part pour les connexions aboutissant sur une couche cachée.

94


A.3.3.1 Vers la couche de sortie Dans ce cas, on rappelle que si=oi

p . On définit les notations suivantes :

(10)

On peut décomposer la variation du poids ωij en deux terme, par la règle de la dérivée de fonction composées:

(11)

Le premier terme s'évalue directement de la relation (8):

(12)

Le second terme nécessite une deuxième décomposition, car la sortie si est encore fonction de l'activation ai du neurone i.

(13)

Le premier terme de cette décomposition n'est autre que la dérivée de la fonction de transfert évaluée pour l'activation ai du neurone i:

(14)

95


Le deuxième terme vient directement de la relation (7):

(15)

En résumé on trouve :

(16)

A.3.3.2 Vers une couche cachée Il va falloir maintenant exprimer la modification des poids pour une connexion

qui ne va pas sur la couche de sortie.

On suppose que l'on souhaite modifier le poids d'une connexion ωij appartenant à une couche c, 1<c<l. Il s'agit donc d'arriver à exprimer Ep en fonction de ωc

ij, on va le faire en utilisant la composition des dérivées. Regardons comment cela fonctionne pour c=l avant de généraliser à n'importe quelle valeur de c.

En analysant les formules, on constate que ωijl sert au calcul de ai

l qui lui-même permet le calcul de si

l , cette valeur est injectée au niveau des connexions ωkil+1 et

contribue donc aux erreurs obtenues lors du calcul de chaque okp .

Ce qui nous permet d'écrire :

(17)

Il est possible maintenant de calculer chacun des termes intervenants dans la

somme:

96


Le premier terme s'évalue directement de la relation (8):

(18)

Le deuxième terme n'est autre que la dérivée de la fonction de transfert du kième neurone de la couche l+1, évaluée pour l'activation de ce même neurone:

(19)

Le troisième terme s'obtient par dérivation de l'expression générale de l'activation

d'un neurone, décrite par la relation (7):

(20)

le quatrième terme, comme pour le deuxième, est la dérivée de la fonction de

transfert, mais évaluée pour le neurone i de la couche l

(21)

Le dernier terme, enfin, découle comme le troisième de la dérivation de la relation d'activation (7):

(22)

À partir de là, il est immédiat d'étendre l'égalité pour une couche quelconque c

telle que 1<c<l. Et ainsi bâtir la formule générale mise en œuvre dans le cadre de la rétro-propagation du gradient. Pour une couche c quelconque, il suffit de dire que ωc

ij

97


participe au calcul de aci, ce dernier permet de calculer sc

i, cette valeur étant ensuite injectée sur les connexions issues de i et aboutissant sur les cellules k de la couche c+1, contribuant ainsi aux erreurs de la couche c+1, d'où l'expression suivante :

(23)

A.3.3.3 Formule générale On va maintenant synthétiser la formule pour l'adapter à n'importe quelle couche

de connexions. Pour cela on va poser :

(24)

Ce qui va nous permettre de reformuler la variation de poids :

(25)

avec :

(26)

(27)

Cette réécriture nous permet ainsi d'obtenir une procédure récursive pour le calcul

des δ pour chaque cellule du réseau et nous rend possible la définition de l'algorithme général de rétro-propagation du gradient pour l'apprentissage dans un PMC.

98


A.3.4 Algorithme du perceptron multicouches 1.- Choix de la valeur n, du seuil minimal, du nombre d'itérations. 2.-Initialisation aléatoire des poids à des petites valeurs. 3.-Choix d'un pattern d'entrée xp. 4.- Propagation (en avant) dans le réseau pour obtenir op. 5.-Calculer δi

l+1 sur la sortie

avec ai

l+1 l'activation de la cellule i de la couche l+1 6.- Calculer les δ de la couche précédente par propagation arrière de l'erreur: pour c allant de l à 1 faire

endFait 7.- Mettre à jour les poids en utilisant

8.- retourner en 3) et répéter pour l'entrée suivante, jusqu'à ce que l'erreur

en sortie soit inférieure à la limite fixée ou que le nombre maximum d'itérations soit atteint.

99


A.3.5 En résumé

Tout ce passe comme si on utilisait le réseau dans deux directions, un calcul ``en avant'' pour déterminer la réponse du réseau à une ``stimulation'', puis un calcul en ``arrière'' pour évaluer les modifications à apporter aux connexions afin d'améliorer le comportement global du système. Il est important de remarquer que le réseau ne peut influer que sur les poids des connexions et (éventuellement) sur les seuils des cellules. Il ne peut, en aucun cas modifier son architecture ni les fonctions de transferts utilisées. De plus pour que le calcul soit possible il est impératif que les fonctions de transfert soient continues (et donc dérivables).

Par ailleurs, du fait même des propriétés sur le calcul du gradient on n'a plus la garantie de la convergence, c'est pourquoi on a besoin d'introduire une borne sur le nombre d'itérations (époques). De plus, comme on effectue des calculs sur machine, on sait que ces calculs sont entachés d'erreur, il devient donc illusoire de vouloir atteindre les valeurs optimales, d'où la nécessité d'introduire un seuil minimal d'erreur (ε). Enfin, comme le processus d'apprentissage est initialisé aléatoirement, il est nécessaire d'effectuer plusieurs simulations avec les mêmes paramètres initiaux - ceci nous assure une stabilité statistique de l'apprentissage.

On peut remarquer que le réseau est sujet à de très nombreux paramètres, la plupart sont à la charge du concepteur et peu de latitude est laissée au réseau. Une fois choisies l'architecture (nature du réseau, nombre de couches, nombre de cellules par couches) et les bases d'apprentissage, de test et de validation, il reste encore de nombreux paramètres à déterminer, parmi ceux-ci on peut citer :

1.-La fonction de transfert 2.-La fonction d'erreur 3.-Le pas d'apprentissage

100


A.4 Fonction de transfert Il existe de nombreux candidats dans le domaine des fonctions continues, la figure

4.4 présente l'allure générale des fonctions (pas toutes continues) les plus utilisées.

Figure A.4 : Format des fonctions de transfert les plus courantes

La première fonction (a) correspond à la fonction de Heaviside (H). la fonction (b) est une fonction qui est linéaire entre deux valeurs (elle est

continue par morceaux). les fonctions (c) et (d) correspondent à deux sigmoïdes:

101


(30)

Et: (31)

Ainsi que leur dérivée respective:

(32)

Et: (33)

la fonction (e) étant une gaussienne:

(34)

D'autres fonctions sont possibles.

102


A.5 La fonction d'erreur L'objectif de l'apprentissage est de minimiser la distance entre la valeur désirée et

la valeur obtenue (par calcul). La fonction la plus utilisée dans les textes est l'erreur quadratique (celle que nous avons utilisée). Le problème majeur de cette fonction est d'avoir une dérivée ``cubique'' en l'activation, elle admet donc trois racines ( ai = 0 , ai = 1 , ai = di) dont seule la dernière possède un intérêt pour l'apprentissage. Ce qui provoque une faible vitesse de convergence en fin d'apprentissage. Plusieurs méthodes ont été étudiées pour circonvenir le problème, actuellement on s'oriente, dans la pratique vers d'autres fonctions d'erreur telle que la «fonction de corrélation croisée» :

(35)

dont la dérivée (partielle) par rapport à ai est :

(36)

Ce qui est égal à:

(37)

qui a le bon goût de minimiser l'espérance de l'erreur (comme l'erreur quadratique) tout en ayant une dérivée linéaire par rapport à ai . Un gain d'un facteur 10 a été constaté en pratique et, une fois entraîné, le réseau possède des performances accrues.

103


A.6 Le pas d'apprentissage La rétro-propagation est une technique de descente de gradient qui doit converger

vers la solution, sous réserve que la surface d'erreur soit continue. Habituellement, on fait varier le pas au cours du temps (intuitivement, il s'agit de reproduire un phénomène constaté en psychologie sur des sujets apprenants, où lorsque les sujets sont ``neufs'' ils ont tendance à absorber l'information avec très peu d'esprit critique, alors que des sujets plus expérimentés sont plus réticents à acquérir de nouveaux concepts remettant en cause leur ``culture''), en prenant au début de l'apprentissage des valeurs proches de 1, et en faisant tendre ce coefficient vers 0. Une autre technique consiste à ajouter un terme inertiel (backpropagation with momentum) dans la correction :

(38)

Cette technique, proposée à l'origine par Rumelhardt et al. (1986), atténue les

effets d'un pas d'apprentissage trop important (mais rajoute un paramètre). Le coefficient 0<a(t)<1 étant souvent accru au cours du temps.

D'autres techniques ont été élaborées pour résoudre ce problème (QuickProp, Delta-bar-Delta).

104


A.7 Autre modèles connexionnistes Il existe beaucoup d'autres modèles de réseaux de neurone, et tous ne peuvent pas

être décrits. Ici ne seront cité que les plus communes des topologies.

-On parle parfois de réseau à connexions récurrentes : les connexions récurrentes ramènent l'information en arrière par rapport au sens de propagation défini dans un réseau multicouche. Ces connexions sont le plus souvent locales (fig. 6).

Figure A.5 : Réseau à connexions récurrentes

-Réseau à connexion complète : c'est la structure d'interconnexion la plus générale (fig. 4.6). Chaque neurone est connecté à tous les neurones du réseau (et à lui-même).

Figure A.6 : Réseau à connexions complète

105


Les Réseaux de neurones présentés dans le prochain chapitre sont des réseaux à connexions complètes. Il s'agit des réseau à compétitions, des cartes auto-organisatrices et des réseaux de Kohonen.

A.8 Cartes auto-organisatrices et algorithme de Kohonen

A.8.1 Introduction Dans un apprentissage non supervisé, il n'y a pas de tuteur, plus exactement le

réseau ne reçoit aucune information de l'environnement lui indiquant quelles devraient être ses sorties ou même si celles-ci sont correctes. Le réseau doit donc découvrir par lui-même les corrélations existant entre les patterns d'apprentissage. Les cellules et les connexions doivent dégager un certain degré d'auto-organisation. Manifestement, pour permettre un tel apprentissage, il est nécessaire que les données contiennent un certain degré de redondance.

A.8.2 Topologie La topologie d'un réseau de Kohonen et relativement simple: elle ne comporte pas

vraiment de couche cachée. Le réseau se compose:

106


Figure A.7 : Schéma d'un réseau de Kohonen

- d'une couche d'entrée de N neurones qui reçoivent chacun les composantes d'un vecteur d'entrée x normalisé appartenant à RN.

- d'une couche de sortie figurée par un treillis sur N1 N2 ou N3 habituellement. La représentation 2D de la couche de sortie est commode pour une première visualisation de la topologie, du fonctionnement et de la raison d'être des réseaux de Kohonen.

Chaque neurone de la seconde couche est relié à toutes les entrées par un poids ωik.

Chacun des ces neurones caractérise une classe à laquelle peut appartenir le vecteur d'entrée.

La particularité des cartes auto-organisatrices de Kohonen réside dans la notion de voisinage d'un neurone. Chaque neurone possède un ensemble de voisins directs, c'est à dire de classes proches. Ainsi, deux patterns d'entrée classés par deux neurones topologiquement proches appartiendront à deux classes séparées mais similaires. La distance entre les sorties sur un treillis 2D caractérise la distance entre deux vecteurs X1 et x2 de Rn.

107


Cette représentation a donc le mérite de généraliser un ensemble de vecteur de Rn, et de diminuer le nombre de dimensions des représentations (on passe par exemple de N à 2 dimensions )

A.8.2 Algorithme d’apprentissage

Nous notons ‘x’ x l’entrée de la carte et ωk les poids des synapses arrivant sur le neurone k (voir figure A.7). L’algorithme d’apprentissage est le suivant :

1.-Initialisation des poids des neurones de sortie (valeurs aléatoires faibles).

2.-Présentation d’un exemple de la base et détermination du neurone de sortie le plus proche de l’exemple présenté (neurone élu). A cette fin, on détermine la distance euclidienne entre l’exemple présenté et tous les neurones de sortie caractérisés par leurs poids. Le neurone k élu est celui pour lequel :

(39)

3.-Adaptation de poids selon la formule :

(40)

α(t) est le taux d’apprentissage et V(j,k,t) la fonction de voisinage. Seuls les poids

des neurones dans le voisinage de l’élu sont modifiés. Le taux d’apprentissage α(t) est une fonction qui diminue avec le temps. Il existe

plusieurs expressions pour le coefficient α :

(41)

Ou e

ncore:

108


(42)

La fonction de voisinage V(j; k; t) est généralement une fonction de la famille des « Mexican-hat » ou DOG (Difference Of Gaussians) telle que représentée sur la figure A.8.

Figure A.8 : Difference of Gaussians (DOG)

Pour la description théorique, il est plus convenable de considérer une simple

gaussienne, évoluant avec le temps, de la forme :

(43)

La distance d(j; k) entre l’élu (d’indice j) et le neurone d’indice k peut être définie de

plusieurs manières. Nous retenons la city-block distance :

(44)

109


pour une carte de dimension 2 (x et y). La fonction de voisinage se rétrécit au court du temps. Cela est censé rapporter un

phénomène physiologique observé sur des sujets apprenant: plus un sujet à révisé un savoir, plus il est difficile pour lui de reformer son esprit à une autre discipline. Le sujet éprouve une certaine réticence à abandonner sa propre culture pour une nouvelle culture. Le rétrécissement de la fonction de voisinage au cours du temps symbolise ce durcissement du système, qui perd sa plasticité de départ. Cette variation temporelle est caractérisée par le coefficient σ(t) défini par :

(45)

Si l’apprentissage n’est pas terminé, on adapte α(t) et V(j; k; t) et on reprend au point 2. L’arrêt de l’algorithme est obtenu si l'erreur ε descend sous un certain seuil. ε représente la somme des différences, pour les N exemples de la base, entre chaque entrée et l’élu correspondant :

(46)

Les simulations réalisées montrent qu'il y a deux phases dans le déroulement de

l'algorithme: - une phase initiale assez courte, pendant laquelle le voisinage σ et le taux ε sont

grands, conduit à une modification rapide des poids et à la formation d'une discrétisation grossière de l'espace d'entrée ;

- une deuxième phase de convergence 10 à 100 fois plus longue permet d'affiner

la représentation et d'obtenir la carte finale grâce à des paramètres σ et ε plus faibles.

110


A.8.3 Illustrations Les planches suivantes sont présentées uniquement à titre d'illustration. Elles n'ont

pas de rapport direct avec le projet en court, mais permettent de symboliser au mieux le fonctionnement des cartes auto-organisatrices. L'exemple est repris de la littérature et figure dans la thèse de Jean-Luc Buessler [BUS99]:

Figure A.9 (a à e): Exemple de formation d'une carte auto-organisatrice

111


A.9 Mise en oeuvre du modèle connexionniste Comment mettre en œuvre ces réseaux de neurones ? Plusieurs étapes doivent être respectées. La mise en œuvre d’un réseau de

neurones nécessite: • de déterminer les entrées pertinentes, c’est-à-dire les grandeurs qui ont une

influence significative sur le phénomène que l’on cherche à modéliser, • de collecter les données nécessaires à l’apprentissage et à l’évaluation des

performances du réseau de neurones, • de trouver le nombre de neurones cachés nécessaires pour obtenir une

approximation satisfaisante, • d’estimer les valeurs des paramètres correspondant à un minimum de la fonction

de coût, c’est-à-dire d’effectuer un apprentissage, • d’évaluer les performances du réseau de neurones à l’issue de l’apprentissage. En fonction des résultats obtenus, il peut être nécessaire d’effectuer plusieurs

itérations de tout ou partie de cette procédure. Nous allons aborder successivement ces différents points.

A.9.1 Les entrées pertinentes Le problème de la détermination des entrées pertinentes se pose de manière très

différente selon les applications envisagées. Si le processus que l’on veut modéliser est un processus industriel conçu par des ingénieurs, le problème est important mais pas crucial, car, en général, on connaît bien les grandeurs qui interviennent et les relations causales entre celles-ci. Ainsi, dans un procédé de soudage par points, on fait fondre localement les deux tôles à souder en faisant passer un courant électrique très important (quelques kilo-ampères) pendant quelques milli-secondes, entre deux électrodes qui exercent une pression mécanique sur les tôles. La qualité de la soudure dépend évidemment de l’intensité du courant, de la durée pendant laquelle il est appliqué, de l’effort exercé par les électrodes pendant le passage du courant et pendant la phase de

112


solidification, de l’état de surface des électrodes, de la nature des tôles, et de quelques autres facteurs qui ont été très largement étudiés en raison de l’importance industrielle du procédé. On connaît donc la nature des entrées désirables pour un modèle ; il peut être néanmoins utile de faire un choix parmi ces grandeurs, en ne prenant en considération, en entrée du modèle, que celles qui agissent de manière très significative sur le processus

En revanche, si le processus à modéliser est un processus naturel complexe

(écologique par exemple), ou un processus économique, social ou financier, la détermination des entrées pertinentes peut être beaucoup plus délicate. Ainsi, si l’on veut prédire une propriété chimique d’une molécule, le choix des descripteurs pertinents n’est pas évident ; de même, pour déterminer le concept de ressemblance d'objets. Ce problème (et, plus généralement, le problème de la sélection de modèle) n’est pas spécifique aux réseaux de neurones : il se pose pour toutes les techniques de modélisation, qu’elles soient linéaires ou non.

A.9.2 La collecte des données Nous avons vu que, pour pouvoir effectuer l’apprentissage, il faut disposer de

données. Celles-ci doivent être en nombre suffisant, et être suffisamment représentatives des données qui seront présentées au modèle lors de son utilisation. Lorsque la grandeur que l’on veut modéliser dépend de nombreux facteurs, c’est-à-dire lorsque le modèle possède de nombreuses entrées, il n’est pas possible de réaliser un « pavage » régulier dans tout le domaine de variation des entrées : il faut donc trouver une méthode permettant de réaliser uniquement des expériences qui apportent une information significative pour l’apprentissage du modèle : il faut réaliser un « plan d’expériences ». Pour les modèles linéaires, l’élaboration des plans d’expériences est bien maîtrisée ; ce n’est pas le cas pour les modèles non linéaires. Et les systèmes mis en œuvre pour le présent projet sont fortement non-linéaires.

A.9.3 Préparation des données Cette préparation inclut plusieurs étapes pour convertir un ensemble de données

brutes en données traitables par un réseau. Ces transformations doivent être appliquées sur chaque variable d'entrée et chaque variable de sortie.

- Classification des types de données

113


- Evaluation statistique Pour les données numériques, on se doit de calculer la moyenne, l'écart type, le

minimum et le maximum. Pour les valeurs nominales, on s'intéressera au nombre de valeurs possibles, et au nombre de valeurs pour chaque catégorie.

- Suppression des données atypique Il faut à tout pris éviter les apprentissages contradictoires. La structure entière du

réseau s'écroule dans de telles situations -Contrôle qualité Il existe de nombreux facteurs liant la quantité de données nécessaire à

l'apprentissage dans un réseau. L'un d'entre eux est la dimension des données. Plus le modèle contient de variables, plus on aura besoin de données, c'est pourquoi on est parfois amener soit à réduire la dimension de l'espace des données, soit à augmenter l'échantillon.

-Construire la base d'exemples Lorsque l'on dispose d'un vaste échantillon, il est raisonnable de n'en considérer

qu'une partie (sélectionnée aléatoirement), mais il faut que le sous-ensemble respecte les propriétés de l'échantillon total. Pour cela on comparera les moyennes et variances des deux ensembles. Les points suivants seront appliqués au sous-ensemble sélectionné et non à la base initiale. Pour construire un modèle équilibré, il faut que l'échantillon soit représentatif et équilibré.

-Réduction des dimensions : Plus la taille de la rétine est importante, plus le nombre de connexions du réseau

augmente. Les poids étant les variables du système, il faudra un échantillon très important (éventuellement, exponentiel en le nombre de connexions). La théorie de l'échantillonnage nous dit qu'il existe une relation exponentielle entre la taille de l'espace des données et le nombre nécessaire pour être représentatif de l'espace.

-Transformation

Les valeurs désirées pour chaque donnée doivent appartenir à Im(f) où f est la fonction de transfert utilisée. Certaines sigmoïdes sont à valeur dans [0..1] d'autres dans [-1..1]. Il est souvent pratique de ré-échelonner les données pour appartenir au même ensemble de valeurs. Cette transformation peut, suivant le cas, être linéaire ou pas en fonction de la distribution initiale.

114


-Encodage Une fois traitées, les données doivent être encodées pour satisfaire les besoins du réseau. Les valeurs numériques peuvent être utilisées telles quelles ou être transformées. Les données de nature nominale doivent toujours être codées.

A.9.4 Le nombre de neurones cachés L’écart entre l’approximation réalisée par un réseau de neurones et la fonction à

approcher est inversement proportionnelle au nombre de neurones cachés [BARRON 1993] ; malheureusement, ce résultat, comme d’autres considérations n’est pas constructif, en ce sens qu’il ne peut que donner des estimations, ou des bornes larges, du nombre de neurones cachés nécessaires. Il n’existe pas, à l’heure actuelle, de résultat théorique permettant de prévoir le nombre de neurones cachés nécessaires pour obtenir une performance spécifiée du modèle, compte tenu des données disponibles.

A.9.5 La nécessité de la parcimonie L’idée la plus naturelle consisterait à choisir le nombre de neurones cachés le plus

grand possible, puisque c’est ce qui assure la plus grande précision à l’approximation uniforme d’une fonction. Ce serait oublier que le problème réel que l’on se pose n’est pas un problème d’approximation uniforme, mais un problème d’ajustement d’une fonction à un nombre fini de points ; il faut donc, non seulement que la fonction réalisée par le réseau de neurones passe « le plus près possible », au sens des moindres carrés, des points utilisés pour l’apprentissage (l’ensemble de ces points est appelé « ensemble d’apprentissage »), mais également qu’il soit capable de généraliser de manière satisfaisante. Si le réseau de neurones possède un nombre de paramètres excessif, en raison d’un nombre excessif de neurones cachés, sa sortie peut passer avec une très grande précision par tous les points d’apprentissage, mais fournir des résultats dépourvus de signification entre ces points ; s’il possède un nombre de paramètres trop restreint, le modèle n’est pas suffisamment riche pour rendre compte de la complexité de la fonction de régression inconnue. Ce dilemme (appelé « dilemme biais-variance ») est le problème essentiel que doit affronter le concepteur de modèles : il résulte du fait que la modélisation « boîte noire » entre dans la catégorie des problèmes dits « mal

115


posés », en ce sens qu’ils ne peuvent pas être résolus complètement en fonction des données dont on dispose.

Figure A.10 : Problème de la parcimonie La figure A.10 présente le résultat de l’apprentissage, à partir des même points de

mesure, de deux réseaux à une couche cachée de neurones à fonction d’activation sigmoïde : à l’évidence, le réseau le plus parcimonieux en neurones cachés est celui qui présente les meilleures capacités de généralisation, tandis que le réseau qui a trop de paramètres conduit au phénomène classique de « sur-ajustement » (en anglais overfitting). En pratique, on s’efforcera toujours de faire en sorte que le nombre de paramètres ajustables soit petit devant le nombre d’exemples. Si, au vu des résultats portés sur la figure A.10, le choix entre les deux réseaux est évident, il n’en va pas de même lorsque le modèle possède plusieurs entrées, car il n’est alors pas possible de représenter graphiquement le résultat de manière aussi simple. Il faut donc trouver un critère global de jugement des performances du réseau. Pour ce faire, il convient de constituer, outre l’ensemble d’apprentissage utilisé pour le calcul des poids du réseau, un ensemble de test, constitué de données différentes de celles de l’ensemble

116


d’apprentissage, à partir duquel on estime les performances du réseau après un apprentissage. L’indice de performance le plus fréquemment utilisé est l’erreur quadratique moyenne commise sur l’ensemble de test (ou ensemble d’estimation des performances), désignée par EQMT :

(47)

117

Annexe B Utilisation de l'interface SIR

118



B.1 Avant propos Le projet de recherche à donné naissance à une interface utilisateur. Le

programme réalisé offre plusieurs fonctionnalités tant pour l'apprentissage, la création des patterns d'entrées, la simulation du réseau de neurones, l'affichage des résultats. L'interface proposée s'est ainsi avérée des plus utiles pour le développement du projet.

A l'intention du futur utilisateur, l'annexe 2 se veut un descriptif du logiciel SIR (Segmented Images Recognising) au travers d'un exemple simple d'utilisation. La présentation se divise en trois sections qui sont la création des lots d'apprentissages, l'apprentissage et la reconnaissance.

119


B.2 Présentation, données d'usage

B.2.1 Introduction

Mais avant tout, décrivons un peu l'utilité générale de l'interface. Le logiciel développé s'applique exclusivement à la recherche sur les images couleur. Le but du programme est de mettre en oeuvre de façon abordable toute la structure du réseau de neurones décrite dans le chapitre 6.

Il s'agit donc visualiser des images « .jpg » ainsi que leurs représentations segmentées. Avec quelques simples clicks sur la photo, l'utilisateur peut sélectionner des zones à associer et créer des lots d'apprentissages pour différents mots. Par exemple, créer un lot de vecteurs d'entrées pour le réseau qui doit reconnaître des arbres, un autre pour les visages, etc; cela de la manière la plus automatique.

Maintenant, l'interface permet de réaliser différents types d'apprentissages pour un réseau de neurones avec le lot d'entrées approprié, et même de simuler la totalité du système d'un seul click.

Chaque réseau de neurones est en fait composé de 7 perceptrons multicouches et il est possible, soit de créer de nouveaux réseaux avec les paramètres désirés, soit d'éditer les paramètres d'apprentissage de n'importe quel PMC en cours de travail. Le programme permet même d'éditer la topologie d'un PMC quelconque (nombre de neurones cachés, minmax des sorties,...), au prix évidement de la réinitialisation du PMC.

La deuxième partie de l'interface met en oeuvre un réseau de neurones et permet deux modes de fonctionnement:

-L'utilisateur choisit un image. Le système reconnaîtra les objets de cette image.

-L'utilisateur choisit un objet. Le système reconnaîtra toutes les images contenant cet objet.

L'affichage des résultats est simple et explicite.

Ainsi, en résumé, il est naturel de définir trois « actes » pour l'utilisation de l'interface:

120


Acte 1. Création de lots d'apprentissages à partir d'images.

Acte 2. Apprentissage et éventuellement modifications des paramètres d'apprentissage.

Acte 3. Simulation et affichage des résultats.

B.2.2 Configuration minimum

Actuellement, l'interface SIR fonctionne sous environnement WINDOWS 98/2000/XP, et requiert la présence de la version 6.5 R13 de MATLAB. Certaines fonctionnalités d'affichages des fenêtres ne sont pas compatibles avec les versions précédentes de MATLAB.

En outre, la présence du « SDCToolBox » est essentielle au bon déroulement du programme. Certains algorithmes utilisent quelques fonctions de ce toolbox très pratique pour améliorer les temps de calcul. Malheureusement, cet outil n'est pas gratuit et n'est pas fourni avec les versions même complètes de MATLAB. Il est cependant possible d'en télécharger une version complète valable un mois sur le site officiel du « SDC_ToolBox », à l'adresse suivante:

http://www.mmorph.com/

Pour l'installation du toolbox, toutes les indications sont bien données sur site ou dans le document «Howtoinstall.txt », dans la racine du répertoire d'installation.

Il faut encore posséder le SOM_ToolBox, et l’installer à la racine du disque C. Ce jeu de fonction se télécharge depuis le site :

http://www.cis.hut.fi/projects/somtoolbox/

Lancement de l'interface

Depuis un shell MATLAB, il faut se placer dans le répertoire où se trouve le fichier « SIR.m » et exécuter la commande > SIR et presser sur retour.

121


B.3 Exemple d'utilisation

Au lancement, le programme s'ouvre sur la fenêtre suivante:

Figure B.1 : Fenêtre d'ouverture de l'interface SIR

122


B.3.1 Sélection d'un stack

Dès lors, il est possible d'accomplir plusieurs actions, mais commençons par nous familiariser avec le logiciel. La fenêtre est vide, c'est à dire que aucun réseau de neurones n'est chargé, ni aucune image. Commençons par indiquer un stack d'images sur lequel travailler. Pour cela, il suffit de cliquer sur le bouton NEW STACK, le seul qui ne soit pas grisé.

Une fenêtre modale vous indique qu'il s'agit de votre premier stack. Un click sur OK ouvre un explorateur. Il suffit alors d'indiquer une image dans un répertoire, et le lot d'image de tout le répertoire sera chargé. Par exemple, la sélection d'un fichier dans la figure B.4 charge tous les fichiers du même dossier. Cliquer sur OPEN pour charger le stack et revenir à la fenêtre de base.

Attention, le dossier indiqué doit contenir les images ainsi que les fichiers SVG respectivement associés portant le même nom que l'image (mis à part l'extension, bien sur).

Figure B.3 : Ouverture d'un nouveau stack d'images

123


Figure B.4 : Explorateur: sélection d'un répertoire

B.3.2 Navigation dans les images

Une fois qu'un stack d'images est sélectionné, les boutons NEXT et PREV sont dégrisés et peuvent être utilisés pour se déplacer dans un lot d'images. Il est ainsi possible de disposer d'une première image pour travailler en cliquant par exemple sur le bouton NEXT.

Figure B.5 : Bouton NEXT

Apparaissent alors dans la partie supérieure de l'interface, l'image originale sur la gauche, et la même image mais segmentée sur la droite. La reconstruction de l'image segmentée peut prendre du temps en fonction de la taille de l'image, et le nombre se segmentations, mais généralement, pas plus de quelques secondes, pour les plus gros fichiers.

124


Figure B.6 : Image originale (gauche) et image segmentée (droite)

Une analyse qualitative de la segmentation de l'image permet déjà de choisir si l'on peut continuer à travailler avec cette image. Si le cas d'une mauvaise segmentation se présente, il est plus judicieux de ne pas travailler avec et de charger la suivante.

Lorsque l'utilisateur à choisi un exemplaire sur lequel effectuer un apprentissage, il peut alors sélectionner des zones de cette image pour reconstruire un objet entier. Plus tard, un réseau de neurones apprendra à fusionner les zones indiquées par l'utilisateur, par exemple un arbre.

B.3.3 Sélection des régions à fusionner

Pour cela, il faut cliquer sur le bouton SELECT ZONES.

Figure B.7 : Bouton SELECT ZONES

125


Cela fait, deux lignes, horizontale et verticale, se positionnent au niveau du curseur de la souris. L'utilisateur est en mode sélection. Il peut maintenant cliquer sur des zones de l'image de droite (image segmentée) et voir à chaque clique le contour de la région sélectionnée se redessiner en rouge sur l'image de gauche (image originale), comme présenté sur la figure B.8.

Figure B.8 : présence d'un nouveau curseur et affichage des contours sélectionné sur l'image originale (gauche)

Après avoir indiqué toutes les régions de l'arbre, un simple clique en dehors de l'image met fin à la phase de sélection des régions à fusionner. A la fin de cette phase, deux checkboxs ainsi qu'un bouton SAVE SELECTION apparaissent en dessous du bouton SELECT. Le bouton SAVE SELECTION n'est pas encore activé, car toutes les informations n'ont pas été données.

126


Figure B.9 : Bouton SAVE SELECTION grisé

B.3.4 Type de sauvegarde

En effet, il existe deux modes possibles pour sauver une sélection. D'un côté, on peut simplement décider que les zones indiquées sont les régions à fusionner, et en rester là (liste de fusion). Il faut alors cocher la case « Only selected » D'un autre coté, on peut estimer que les régions non sélectionnées sont des régions qu'il ne faut absolument pas fusionner (liste de non-fusion). Dans ce cas là, il faut cocher la case « All couples », cela sauvegardera les 2 ensembles de zones: celles à associer, et celles à dissocier. Ce choix permet d'éviter les problèmes avec une image contenant deux arbres par exemple. Dans une telle situation, si l'on indique les régions du premier arbre, il ne faut pas que le réseau apprenne à ne pas fusionner le deuxième arbre, cela fausserait complètement sa simulation.

Figure B.10 : Checkbox pour le type de sauvegarde

Ainsi, la première checkbox apparue propose de ne sauvegarder que la liste de fusion, alors que la deuxième offre de sauvegarder les listes de fusion et de non-fusion. Une fois que ce choix est fait, le bouton SAVE SELECTION est encore inactif, car il reste à indiquer le nom de l'objet sélectionné, et donc par-là même, dans quel fichier vont être sauvegardés les nouvelles listes sélectionnées par l'utilisateur.

127


B.3.5 Choix d'un mot

Pour ce faire, on observe sur la droite de la partie supérieure (en haut à droite) une listbox (General Type), vide pour l'instant, ainsi qu'une case pour éditer un texte (New Type). La listbox contient l'ensemble des objets déjà sélectionnés, et la case de texte permet d'entrer un nouveau mot qui ne serait pas présent dans la listbox. Pour l'exemple que nous traitons ici, la listebox est vide et il va falloir indiquer un mot dans le text-edit inférieur.

Figure B.11 : Choix d'un mot dans la listbox « General type » ou saisie dans la case « New type »

Après écriture dans la case, ne pas oublier d'appuyer sur ENTER pour valider le mot. Cette action dégrise enfin le bouton SAVE SELECTION.

128


Figure B.12 : Mot choisi et bouton SAVE SELECTION dégrisé

Le bouton SAVE SELECTION effectue plusieurs tâches. Premièrement, il calcule tous les patterns d'entrées qui découle de la sélection de l'utilisateur, ainsi que les sorties à associer à chacun de ces patterns. Ensuite, il effectue une sauvegarde de tous ces résultats dans le fichier qui porte le même nom que l'objet indiqué, par exemple dans le fichier « arbre.mat ». Si le fichier « arbre.mat » n'existe pas, il le crée. Sinon, il le charge simplement pour y ajouter les nouvelles informations.

Finalement, si le mot est un mot présenté pour la première fois, alors le bouton SAVE SELECTION crée également un nouveau réseau de neurone qui travaillera exclusivement sur cet objet. C'est le cas dans l'exemple suivi: le mot arbre est présenté pour la première fois, donc il y a création d'un réseau de neurone qui sera associé à tous les arbres, et qui effectuera un apprentissage uniquement à partir du fichier « arbre.mat ». On peut ainsi ajouter autant de mots que l'on veut, l'interface créera un fichier et un réseau de neurones par mot.

Si l'image analysée contient un objet dont le type a déjà été présenté, alors il est possible de sélectionner le mot correspondant dans la listbox. Cette action dégrise également le bouton SAVE SELECTION.

129


Après la sauvegarde, le mot arbre de notre exemple va se placer dans la listbox avec les autre mots déjà sauvegardés, comme présenté sur la figure B.13.

Figure B.13 : Nouveau mot inséré dans la listbox

Maintenant, l'utilisateur peut recommencer les manipulations depuis la navigation dans les images, ou décider d'effectuer un premier apprentissage. Proposons-nous de réaliser un premier apprentissage sur l'arbre que l'on vient de traiter.

B.3.6 Apprentissage

Pour réaliser un apprentissage, il faut évidemment indiquer quel mot il va falloir apprendre. Pour cela, l'utilisateur sélectionne un mot dans la listbox de la partie supérieure, par exemple « arbre », et clique simplement sur le bouton LEARN OBJECTS (attention, si le mot sélectionné est arbre, l'apprentissage va se réaliser pour le réseau de neurones spécifique aux arbres). Lors de cette action, une nouvelle fenêtre modale apparaît, comme sur la figure B.14.

130


Figure B.14 : Choix du type d'apprentissage

Le logiciel demande à l'utilisateur quel type d'apprentissage réaliser. Il peut choisir entre :

- apprendre uniquement le dernier objet dont on a indiqué les zones.

- apprendre tous les objets qui correspondent à un arbre, c'est à dire réaliser un apprentissage de tout le fichier « arbre.mat ».

- apprendre tous les objets (arbre, visage, maison, voiture,...) et donc adapter tous les réseaux de neurones avec tous les fichiers respectifs « arbre.mat », « visage.mat », « maison.mat »...

Il ne reste plus qu'à sélectionner le type d'apprentissage désiré et appuyer su OK. L'apprentissage s'effectue!

Attention, lors de l'apprentissage de ne pas faire apprendre un objet au mauvais réseau de neurone, par exemple de faire apprendre un visage au réseau prévu pour les arbre. Cette situation peut survenir lorsque l'utilisateur décide de n'effectuer un apprentissage que sur les dernières régions sélectionnées. Ainsi, s'il a indiqué par quelques clicks que l'objet était un visage, et qu'ensuite l'utilisateur sélectionne le mot arbre dans la listebox, alors c'est le réseau prévu pour les arbres qui va « subir » l'apprentissage d'un visage. Ce phénomène est relativement grave, puisque le réseau associé aux arbres va soudain faire des apprentissages incohérents. Il apprend par exemple à ne jamais fusionner deux zones roses, puis à fusionner deux zones roses. Idéal pour en perdre son Latin.

L’entraînement prend beaucoup de temps: de quelques secondes pour un objet ou deux à quelque heures, pour un apprentissage de tous les objets pour tous les réseaux de

131


neurones.

B.3.7 Reconnaissance

La partie du logiciel qui traite de la reconnaissance se trouve dans la partie inférieure de l'interface. Cette section peut fonctionner sous deux modes différents:

-Reconnaissance des objets dans une image

-Reconnaissance d'un objet dans des images

Figure B.15 : Section inférieure de l'interface, prévue pour la reconnaissance des objets.

Dans les deux modes, il est impératif d'indiquer dans un premier temps un dossier contenant des images. Pour ce faire, la manœuvre est identique à celle de la partie prévue pour l'apprentissage: il suffit de cliquer sur le bouton NEW STACK et d'indiquer une image quelconque du dossier choisi.

132


Figure B.16 : Bouton NEW STACK

Cela fait, l'utilisateur doit choisir entre l'un des deux modes de fonctionnement.

N objets dans 1 image

Dans ce mode, il est possible d'utiliser les deux boutons NEXT et PREV pour naviguer parmi les images du dossier.

Lorsque l'utilisateur a choisi une image à analyser, il n'y à plus qu'à presser sur le bouton ANALYSE à droite dans la section RECOGNISING de l'interface. A ce moment précis, les réseaux de neurones associés à chaque mot connus analysent l'image. Ainsi, chacun reconnaît uniquement l'objet pour lequel il est prévu.

Figure B.17 : Bouton ANALYSE

La liste des objets découverts est alors affichée dans la deuxième listbox, et l'utilisateur peut à volonté cliquer sur un mot de la listbox pour voir s'afficher sur l'image de droite le contour de l'objet sélectionné.

133


Figure B.18 : Résultat de l’analyse : les contours de l’objet découvert en rouge sur limage de droite

il est possible de recommencer l'opération autant de fois que l'on veut.

1 objet dans N images

Maintenant, l'utilisateur peut décider de trouver toutes les images du dossier qui contiennent un arbre. Dans ce cas là, il n'y pas besoin de naviguer parmi les images. Il suffit de choisir un objet entre tous ceux déjà connus par le système. La liste de ces objets se trouve dans la troisième listbox, en-bas à droite. Un click sur le mot arbre de la listbox dégrise le bouton FIND OBJECT, sur lequel on peut alors presser pour lancer la recherche.

134


Figure B.19 : Bouton FIND OBJECT

Attention, la recherche dure plus ou moins longtemps, selon le nombre et la taille des images. Au moment ou une recherche est lancée, une barre apparaît au fond à droite, sous la troisième listbox, et indique la progression de l'analyse. De plus, un signal sonore annonce que le traitement est fini.

A ce moment, les deux boutons NEXT et PREV sont à nouveau actif et l'utilisateur peut naviguer parmi les images qui contiennent un ou plusieurs arbres.

Plusieurs exemples de résultats sont présentés dans l’annexe C

B.4 Options supplémentaires

Comme indiqué dans l'introduction de cette annexe, il est possible d'éditer en tout temps chaque paramètre du système entier. Évidemment ceux-là sont nombreux. Par exemple, si le système en cours d'utilisation connaît 10 mots, alors 10 réseaux de neurones sont en oeuvres. Chaque réseau est composé de 7 perceptrons multicouches, et chaque PMC compte pas moins de 15 paramètres: 12 pour l'apprentissage et 3 pour la topologie. On compte donc au total 15x7x10 = 1050 paramètres ajustables pour le système.

L'interface présentée propose une navigation simple parmi ces paramètres pour l'utilisateur téméraire qui voudrait en modifier certains. Pour cela, il faut commencer par presser sur le bouton SET PARAMETERS à droite de la fenêtre principale de

135


l'interface. Cette action ouvre une nouvelle fenêtre intitulée « Set Network Parameters ». Cette fenêtre est séparée en deux parties.

Figure B.20 : Fenêtre d'édition des paramètres

La section supérieure présente, outre un texte d'avertissement, une listbox contenant la liste des mots connus du système, c'est à dire des réseaux correspondants. Si l'utilisateur sélectionne l'une des entrées de la listbox, toujours le mot arbre, la section inférieure de la fenêtre change et affiche les paramètres du réseau de neurones qui reconnaît les arbres.

136


Figure B.21 : Section inférieure de la fenêtre d'édition des paramètres

La section inférieure permet de naviguer aisément parmi les paramètres d'apprentissage de chacun des 7 PMC du réseau sélectionné. La partie supérieure de cette section compte 7 toggle-boutons qui sont les 7 PMC du réseau en question.

- toggles 1 à 4 : CNT1, CNT2, CNT3 et CNT4: ils sont les quatre PMC qui reçoivent les représentations des contours.

- toggle 5 : CNT LAY.2 : voilà le PMC qui reçoit ses entrées des quatre PMC précédents assignés aux contours.

- toggle 6 : RGB : représente le PMC qui traite des informations RGB.

- toggle 7 : LAYER 3 : le dernier PMC qui reçoit ses entrées des réseaux CNT LAY.2 et RGB.

Le reste de cette section présente la liste des paramètres d'apprentissages du PMC en question, dont voici une brève description pour les plus importants:

2 Nb iterations : permet de choisir le nombre de pas pour l'apprentissage

3 Display : offre la possibilité d'afficher la courbe d'évolution de l'erreur globale du PMC. Si la valeur 50 est indiquée, alors la courbe se réaffiche tous les 50 pas d'itérations. Ainsi, si on ne veut pas d'affichage, il suffit de spécifier une valeur plus élevée que le nombre d'itérations.

4 Global error limit : premier critère d'arrêt de l'algorithme d'apprentissage: la valeur indiquée présente la borne inférieure de l'erreur globale. C'est à dire qu'en

137


dessous de cette valeur, on estime que le PMC a réalisé un bon apprentissage.

5 Perform time limit : deuxième critère d'arrêt: il indique après combien de temps, en seconde, l'algorithme d'apprentissage s'arrête. Ce paramètre est habituellement fixé à INF, car les autres critères d'arrêts, ou le nombre d'itérations sont suffisant.

6 Minimal gradient : Ce paramètre indique à partir de quand on estime que le réseau de neurones n'apprend plus. Plus le gradient est petit, moins le réseau s'adapte. En dessous d'une certaine valeur, il est raisonnable de considérer que le réseau à fini de converger et d'apprendre.

Figure B.22 : Liste des paramètres d'apprentissage

12 Alpha : C'est le coefficient d'apprentissage: plus cette valeure est petite, plus vite le réseau adapte ses connexions, mais moins il est capable d'apprendre de nouvelles relations. Au contraire, si le coefficient est élevé, alors le réseau peut facilement se réadapter à un nouvel apprentissage, par contre il lui est difficile de bien apprendre les choses. C'est la différence entre une structure trop plastique et une structure trop rigide.

La section inférieure des paramètres présente encore quatre boutons au fond de la fenêtre: CANCEL, SET TOPOLOGY, APPLY et OK.

Figure B.23 : Boutons de la fenêtre des paramètres

Le bouton CANCEL quitte simplement la fenêtre sans enregistrer les derniers paramètres modifiés. Le bouton APPLY applique les nouveaux paramètres au PMC concerné sans quitter la fenêtre. Le bouton OK enregistre les nouveaux paramètres et

138


quitte la fenêtre.

Il reste un bouton: SET TOPOLOGY. Ce bouton permet de modifier la structure topologique d'un réseau. Evidement, cela va rendre caduque tous les apprentissages précédents pour ce PMC et peut en partie déstabiliser le système entier, bien que l'architecture proposée au chapitre 6 ait la capacité d'emmagasiner de telles déstabilisations: l'information est traitée par 7 chemins différents, ainsi lorsque l'un des chemins est initialisé ou défectueux, les six autres continuent de travailler et pallient en partie le manque de l'un d'entre eux.

Lorsque l'utilisateur presse sur le bouton SET TOPOLOGY, une nouvelle fenêtre s'ouvre

Figure B.24 : Fenêtre pour l'édition des paramètres topologiques

Il y a moyen ici de modifier

- Le nombre de neurones de la couche cachée. Pour l'instant, le programme ne permet que d'éditer des PMC à une couche cachée.

- Le minmax des entrées.

- La fonction de transfert des neurones.

Après modification d'un paramètre, ne pas oublier de presser sur enter. Cela rend

139


le bouton OK actif et permet de valider les modifications une fois celles-ci terminées. Les paramètres d'apprentissage du PMC modifié sont conservés et repris du PCM avant réinitialisation.

B.4 Conclusion A présent, tout est dit sur l’interface SIR. L’utilisateur peut maintenant créer des lots d’apprentissages, entraîner le système entier ou seulement une partie, le simuler selon différents modes. L’utilisateur peut même modifier pratiquement tous les paramètres du système en tout temps (mis à part les phases de calcul, évidemment). Le programme est un programme de recherche et de développement. La version proposée n’est certainement par optimisée et peut également présenter parfois quelques problèmes. Par exemple, si le logiciel est laissé ouvert plus d’un jour sans utilisation, celui-ci ne fonctionne tout simplement plus, tout comme MATLAB. Une autre difficulté non résolue se situe lors d’une analyse pour retrouver les objets d’une image. Si aucun objet n’est découvert, il arrive (mais pas régulièrement) que la listbox prévue à cet effet se bloque avant son réaffichage. Rien de grave, si ce n’est un aspect esthétique diminué dans ce cas là.

140

Annexe C Résultats

141

Annexe C Résultats

Annexe C Résultats

Voici une liste non exhaustive de résultats sous forme d'images. Ceux si sont

présentés pour les logos noir et blanc et pour des arbres et des visages en couleur.

Pour les logos noir et blanc, des classes de regroupement sont présentées. On trouve ainsi quelques ensembles de logos bien et moins bien classé par similarité.

Les images couleur vont toujours par 4, un peu comme pour les photomatons. La première image est l'original. La deuxième est l'image segmentée. La troisième représente l'originale accompagnée par les contours de toutes les zones en rouge. La dernière image figure un objet découvert par le système, entouré en rouge.

142

Annexe C Résultats

C.1 Logos noir et blanc

Voici pour commencer quelques classes ou le système a bien réagi. Une ligne sépare chaque classe :

143

Annexe C Résultats

Et voici quelques exemples de classes « apparemment » males construites. La ressemblance des logos des classes suivantes est difficile à trouver et à comprendre :

144

Annexe C Résultats

C.2 Images couleur C.2.1 Arbres bien analysés Commençons par présenter quelques bons résultats:

145

Annexe C Résultats

146

Annexe C Résultats

147

Annexe C Résultats

C.2.2 Arbres moyennement bien analysés Voici quelques résultats estimés comme passables, acceptables, mais pas très bien tout de même:

On constate que les images moyennement traitées sont des images en général plus complexe, avec plus de détails.

148

Annexe C Résultats

149

Annexe C Résultats

150

Annexe C Résultats

C.2.3 Arbres mal analysés Et voici quelques mauvais traitements pour les arbres. Les objets découverts n'ont rien à voir avec un arbre, ou sont des arbres mal détectés:

151

Annexe C Résultats

C.2.4 Visages bien analysés Comme pour les arbres, présentons quelques visages bien analysés, puis moins bien, et finalement les échecs, les mauvais résultats:

152

Annexe C Résultats

153

Annexe C Résultats

C.2.5 Visages moyennement bien analysés Quelques résultats de visages un peu moins bons; ces images sont celles ou quelques zones en trop ont été fusionnées:

154

Annexe C Résultats

155

Annexe C Résultats

C.2.6 Visages mal analysés Et finalement voici présentés quelques erreurs du système pour la détection de visages:

156

Annexe C Résultats

157

Annexe C Résultats

158

Table des figures

159

Table des figures

Table des figures

Figure 3.1 : schéma type de la numérisation et du pré-traitement …………… 20

Figure 3.2 : Schéma type du calcul des représentations …………………. 22

Figure 3.3 : Schéma type d'un apprentissage…………………………………… 23

Figure 3.4 : Schéma type pour l'évaluation de la qualité……………………….. 24

Figure 3.5 : Schéma type du projet de reconnaissance d'image………………… 26

Figure 4.1 : Schéma du logiciel SNNS…………………………………………. 30

Figure 5.1 : Schéma d’une carte auto organisatrice…………………………….. 40

Figure 5.2 : Déformation continue d'une tasse………………………………….. 42

Figure 5.3 : Déformation discontinue d'une tasse………………………………. 42

Figure 5.4 : Contres-exemples pour l’analyse de la topologie………………….. 43

Figure 5.5 : Schéma réduction d’une image …………………………………… 45

Figure 5.6 : Modèle général de reconnaissance de logos noir/blanc…………… 46

Figure 5.7 : 65 exemplaires de carrés 5x5……………………………………… 47

Figure 5.8 : Réponse de la couche réductrice avec une SOM………………….. 48

Figure 5.9 : Réponse de la couche réductrice avec un PMC…………………….49

Figure 5.10 : Représentation 2D et 3D de la SOM……………………………... 51

160

Table des figures

Figure 5.11 : classe du logo 235………………………………………………... 52

Figure 6.1 : Exemple de segmentation d'une image couleur…………………… 55

Figure 6.2 : bonne segmentation et sous-segmentation………………………… 57

Figure 6.3 : Schéma général d'une architecture à plusieurs PMC……………….59

Figure 6.4 : Exemple du contour de deux zones différentes……………………. 61

Figure 6.5 : Régions originales et redimensionnées……………………………. 63

Figure 6.6 : Contours sans et avec contenu…………………………………….. 64

Figure 6.7 : Représentation RBG et HSB de l'espace des couleurs…………….. 66

Figure 6.8 : Architecture neuronale…………………………………………….. 68

Figure 6.9 : Réponse après apprentissage………………………………………. 70

Figure 6.10 : Topologie de base pour la reconstruction des contours………….. 72

Figure 6.11 : Groupes de connexité…………………………………………….. 73

Figure 6.12 : schéma pour le système de reconstruction des contours……….… 75

Figure 6.13 : Etat de la SOM pour plusieurs objets………………………….…. 78

Figure 6.14 : Recherche d’un objet ‘inconnu’……………………………….…. 78

Figure 6.15 : Deux SOM superposées………………………………………….. 79

Figure 6.16 : Schéma général final………………………………………….….. 80

Figure 6.17 : Exemples d’images trop complexes et non traitables……….…….81

Figure 6.18 : Exemple de débordement………………………………………… 82

Figure A.1 : Neurone biologique et formel………………………………...…… 87

Figure A.2 : Notations d'un neurone artificiel…………………………...……… 88

Figure A.3 : Réseau à couches multiples…………………………………...……93

161

Table des figures

Figure A.4 : Format des fonctions de transfert les plus courantes……………… 101

Figure A.5 : Réseau à connexions récurrentes…………………………..……… 105

Figure A.6 : Réseau à connexions complètes ……………………………..…… 105

Figure A.7 : Schéma d'un réseau de Kohonen……………………………..…… 107

Figure A.8 : Difference of Gaussians (DOG)....................................................... 109

Figure A.9 : Exemple de formation d'une carte auto-organisatrice…………...… 111

Figure A.10 : Problème de la parcimonie……………………………………..… 116

Figure B.1 : Fenêtre d'ouverture de l'interface SIR…………………………….. 122

Figure B.3 : Ouverture d'un nouveau stack d'images…………………………… 123

Figure B.4 : Eplorateur: sélection d'un répertoire………………………………. 124

Figure B.5 : Bouton NEXT................................................................................... 124

Figure B.6 : Image originale et image segmentée………………………………. 125

Figure B.7 : Bouton SELECT ZONES…………………………………………. 125

Figure B.8 : affichage des contours sélectionnés ………………….…………… 126

Figure B.9 : Bouton SAVE SELECTION grisé……………………..………….. 127

Figure B.10 : Checkbox pour le type de sauvegarde……………….……………127

Figure B.11 : Choix d'un mot dans la listbox « General type » …….………….. 128

Figure B.12 : Mot choisi et bouton SAVE SELECTION dégrisé…….………… 129

Figure B.13 : Nouveau mot inséré dans la listbox……………………………… 130

Figure B.14 : Choix du type d'apprentissage…………………………………… 131

Figure B.15 : Section reconnaissance des objets………………………..……….132

Figure B.16 : Bouton NEW STACK..................................................................... 133

Figure B.17 : Bouton ANALYSE ……………………………………………… 133

162

Table des figures

Figure B.18 : Objet découvert…………………………………………….……. 134

Figure B.19 : Bouton FIND OBJECT…............................................................... 135

Figure B.20 : Fenêtre d'édition des paramètres…………………………….…… 136

Figure B.21 : Section inférieure………………………………………………… 137

Figure B.22 : Liste des paramètres d'apprentissage………………………….…. 138

Figure B.23 : Boutons de la fenêtre des paramètres…………………………..… 138

Figure B.24 : Fenêtre pour l'édition des paramètres topologiques…………….... 139

Figure C.1 à fin : résultats sous forme de lots d'images………………………… 143-157

163

Table des formules

Table des formules

(1) : sortie d'un neurone………………….……………………………………. 88

(2) : Généralisation de la sortie………….……………………………………. 88

(3) : Sortie modèle radial…………………..………………………………….. 88

(4) : Activation d'un neurone………………..………………………………… 89

(5) : Variation des poids synaptiques………..………………………………… 90

(6) : Variation des poids synaptiques………..………………………………… 90

(7) : Activation d'un neurone dans un PMC…..………………………………. 93

(8) : Erreur du système…………………………..……………………………. 94

(9) : Variation des poids synaptiques……………..…………………………… 94

(10) : Définition des notations……………………..………………………….. 95

(11) : Rétro propagation pour la couche de sortie…..…………………………. 95





(16) : Formule finale pour la couche de sortie………...………………………. 96

(17) : Décomposition de la variation des poids………..……………………… 96

(18) : Rétro propagation pour une couche cachée………..…………………… 97



164

Table des formules



(23) : Reformulation de la décomposition………………..…………………… 98

(24) : Formule générale de la rétro propagation………………………………..98

(25) : Formule générale de la rétro propagation……………...………………...98

(26) : Formule générale de la rétro propagation………………...……………...98

(27) : Formule générale de la rétro propagation………………………………..98

(30) : Sigmoïde type I......................................................................................... 102

(31) : Sigmoïde type II........................................................................…............ 102

(32) : Dérivée de la sigmoïde type I……………………………………...……. 102

(33) : Dérivée de la sigmoïde type II…………………………………….……. 102

(34) : Gaussienne…………………………………………………………...….. 102

(35) : Fonction de corrélation croisée……………………………………….… 103

(36) : Dérivée de la fonction de corrélation croisée………………………….... 103

(37) : Dérivée de la fonction de corrélation croisée…………………………… 103

(38) : Le pas d'apprentissage………………………..…………………………. 104

(39) : Kohonen: élection du meilleur neurone………..……………………….. 108

(40) : Kohonen: adaptation des poids…………………..………………………108

(41) : Variation du coefficient alpha type I……………..……………………... 108

(42) : Variation du coefficient alpha type II……………..……………………. 109

(43) : Fonction de voisinage……………………………..……………………. 109

(44) : Distance entre neurone :city-block distance………..…………………… 109

(45) : Variation de la fonction de voisinage………………..………………….. 110

(46) : Erreur quadratique…………………………………….………………… 110

165

Table des formules

(47) : Erreur quadratique……………………………………...……………….. 117

166

Références

Références Bibliographie Dreyfus G., (2002). Réseaux de neurones, Méthodologie et applications, Eyrolles

Cornuéjols A. - Miclet L., (2002). Apprentissages artificiels, Concept et algorithmes, Eyrolles

Demartines P., (1995). Analyse de données par réseaux de neurones auto-organisés, thèse de l'Institut National Polytechnique de Grenoble

Bélanger H. (1998). Réseau de Kohonen pour la détection des contours d'objets dans une image à niveau de gris, thèse de l'Ecole de Technologie Supérieure de l'Université du Québec

Buessler J-L, (1999). Architectures neuro-mimétiques modulaires, Application à l'asservissement visuel de systèmes robotiques, thèse de l'Université de Haute-Alsace, U.F.R. Des Sciences et Techniques

Evrard Y., (2003). Rapport du concours robot legos Mindstorm, rapport de l’Ecole d’ingénieurs de Genève.

Blayo F. et Verleysen M., (1996). Que sais-je ? Les réseaux de neurones, Presse Universitaires de France

d’Espagnat B., (1998). Physique et réalité, Diderot Editeur Penrose R. (1993). L’esprit, l’ordinateur et les lois de la physique, InterEditions

167

Références

Internet

Apprentissage à partir d'exemples (notes de cours):

http://www.grappa.univ-lille3.fr/polys/apprentissage/

Introduction aux réseaux de neurones:

http://www.sm.u-bordeaux2.fr/~corsini/Cours/mainRNA/mainRNA.html

CADCOM/Manuel d'utilisation, Reseaux Kohonen:

http://pro.chemist.online.fr/cours/koho1.htm

Cours IFT6266, Introduction aux réseaux de neurones artificiels:

http://www.iro.umontreal.ca/~bengioy/ift6266/neuron/neuron.html

Les logiciels de traitement de l'information, quelques définitions:

http://mist.univ-paris1.fr/logiciel/def.htm#acp3

Back-propagation neural network tutorial:

http://pcrochat.online.fr/webus/tutorial/

Ingénierie de la cognition:

http://www.etis.ensea.fr/~revel/html/cours_IA/cours_IA.html

168

Références

Site officiel du logiciel SNNS:

http://www-ra.informatik.uni-tuebingen.de/SNNS/

Site pour le téléchargement du « SDC_ToolBox »:

http://www.mmorph.com/

Site pour le téléchargement du « SOM_ToolBox »:

http://www.cis.hut.fi/projects/somtoolbox/

169

Documents

RECONNAISSANCE D’OBJETS PAR RESEAUX DE NEURONES