EPSI KLIPS P I A - christiancouder.files.wordpress.com représentation, de part sa diffusion très large, et de son adaptation à une application orientée objet. Nous avons donc d’abord

19/03/2008

Rapport de projet | Christian Couder, Fabien Joubert, Guy-Ludovic

Rodriguez

EPSI KLIPS - PROJET INTELLIGENCE ARTIFICIEL

KLIPS - Projet Intelligence Artificiel

Rapport de projet

Christian Couder, Fabien Joubert, Guy-Ludovic Rodriguez

EPSI | Monsieur Krit

2

Sommaire I Cahier des Charges

1. Les différentes composantes demandées ................................................................................... 3

a. Caractéristiques du moteur d'inférences : .............................................................................. 3

b. Editeur de projets .................................................................................................................... 4

c. Editeur de règles ...................................................................................................................... 4

d. Editeur de faits ........................................................................................................................ 4

2. Les options facultatives ............................................................................................................... 4

a. Planification du projet ............................................................................................................. 5

b. Choix de l’outil de développement ......................................................................................... 6

c. Environnement de l’activité .................................................................................................... 6

Tableau détaillé de l’environnement .............................................................................................. 6

d. Compétences mises en œuvre ................................................................................................ 6

Tableau détaillé des compétences mises en œuvre ....................................................................... 6

e. Méthodologie d’analyse .......................................................................................................... 7

a. Algorithmes ........................................................................................................................... 10

b. Structure des données : ........................................................................................................ 12

c. Interface graphique ............................................................................................................... 13


Rapport de projet



3

I. Cahier des charges

Notre équipe informatique (COUDER Christian, JOUBERT Fabien, RODRIGUEZ Guy-Ludovic)

spécialisée dans le développement d’applications a accepté de faire l’étude et la réalisation d’un

logiciel nommé « KLIPS » qui doit être un générateur de système à base de connaissance exploitant le

formalisme de règle de production.

Même si de nombreux produits existent déjà pour répondre à une telle demande, l'austérité des

programmes a été remise en cause, si bien que le point clé de ce projet, outre d'avoir un moteur

d'inférence fiable et performant, est de proposer une interface graphique plus ergonomique.

Ainsi, l'application demandée doit fournir les composantes suivantes :

� Un moteur d’inférences

� Un éditeur de projets

� Un éditeur de règles

� Un éditeur de faits

1. Les différentes composantes demandées

a. Caractéristiques du moteur d'inférences :

� Les connaissances sont considérées comme étant certaines.

� Les règles de production n'utilisent pas de variables (moteur d’ordre 0).

� Aucune règle n'a de priorité sur une autre.

� Le moteur d’inférences fonctionne en mode chaînage avant et en régime révocable (stratégie de

résolution de conflits : recherche soit en profondeur, soit en largeur).

� La négation est implémentée: elle l'est par l’absence dans la base de faits (système clos).

� La condition d’arrêt est la saturation de la base de faits.


Rapport de projet



4

b. Editeur de projets

L’éditeur de projets permet de créer, d’éditer, de modifier, et de sauvegarder un projet à travers une

interface graphique. Un projet est composé d’une base de règles et d’une base de faits, et est

identifié par un nom et un descriptif.

c. Editeur de règles

L’éditeur de règles permet de créer, d’éditer, de modifier et de supprimer une règle à travers une

interface graphique. Deux opérateurs logiques sont implémentés : « ET » (AND) et « NON » (NOT).

d. Editeur de faits

L’éditeur de faits permet de créer, d’éditer, de modifier, et de supprimer un fait à travers une

interface graphique. La structure de données utilisée regroupe un champ « identificateur »,

nommé nom et un champ « contenu », nommé description.

2. Les options facultatives

Outre ces composantes indispensables, une marge de manœuvre a été prévue concernant les options

pouvant être ajoutées à l'application. Les options retenues sont les suivantes :

� Implémentation du « OU » dans le moteur d’inférences (mécanisme de récursivité).

� Choix d'une stratégie de résolution parmi Depth et Breadth.

� Exécution pas à pas.

� Aide en ligne pour les utilisateurs.


Rapport de projet



5

II. Analyse du projet

a. Planification du projet

Semaines Détail des tâches

Planification

Réflexion sur le choix du langage (C# ou Java)

Appréhension du sujet

Elaboration du modèle de classes (UML 2.0)

Répartition des tâches en fonction des compétences

individuelles

Développement du moteur d’inférences en mode console

Développement de l’interface graphique

Assemblage entre le moteur et l’interface graphique

Mise en place de la phase de test et des jeux d’essais

Rédaction du rapport

Préparation de la soutenance (Power Point)

Présentation du projet

1 à 2

3 à 4

5 à 6

7 à 8

Fin


Rapport de projet



6

b. Choix de l’outil de développement

Il est important de choisir un langage qui se prête au sujet. Afin de respecter au mieux le cahier des

charges qui nous a été fourni, nous décidons d’utiliser un langage objet qui nous permettrait

d’optimiser les capacités du logiciel.

Pour ce projet, il existe deux langages qui correspondent le mieux à nos besoins, soit le Java, soit le

C#.

D’un point de vue technique le Java et le C# sont similaires et sont même couramment opposés l’un à

l’autre. De plus, le C# est un langage plus récent que le Java, et il apporte quelques nouveautés

techniques en plus d’une interface de développement plus agréable.

Notre apprentissage scolaire nous ayant enseigné les deux, et dans un but pédagogique, nous

décidons d’utiliser le langage que nous maîtrisons le moins afin de compléter nos compétences, soit

le C#.

c. Environnement de l’activité

Tableau détaillé de l’environnement Matériel Logiciel

Des ordinateurs de type :

Pentium IV 2,4Ghz, 1024 Mo de RAM

* Utilisation de NET BEAN avec module UML pour

mettre en place les classes, et pour faire apparaître

toutes nos données et méthodes.

* Utilisation de Microsoft Visual C# pour le

développement de l’activité.

* Système d’exploitation VISTA.

d. Compétences mises en œuvre

Tableau détaillé des compétences mises en œuvre Principales Autres

Développer une application à l’aide d’un langage de

programmation à objets, utiliser, intégrer et

produire des composants logiciels réutilisables.

Développer l’application à l’aide d’un langage de

programmation procédurale.

Représenter schématiquement les données d’un

système d’informations.

Rédiger un rapport sur le projet.

Elaboration d’une aide en ligne.


Rapport de projet



7

e. Méthodologie d’analyse

Afin de modéliser l’application, nous avons décidé d'appliquer la méthode UML, avec ses outils

de représentation, de part sa diffusion très large, et de son adaptation à une application

orientée objet.

Nous avons donc d’abord élaboré un diagramme des cas d’utilisations de l’application:

Après avoir analysé les besoins de l’utilisateur final, nous avons ensuite élaboré les classes

métiers à l’aide du diagramme de classe :


Rapport de projet



8

Diagramme de classe de l’application Klips


Rapport de projet



9

Commentaire du diagramme de classes :

Un projet est composé d’une base de règles et d’une base de faits. La classe projet est munie de

plusieurs fonctions comme la sauvegarde ou charger un projet mais surtout des fonctions Lancer() et

LancePasAPas() qui démarrent et exécutent le moteur.

Une base de faits est composée de faits et une base de règles est composée de règles. Un fait n’est

rien d’autre qu’une référence et le contenu d’un fait. Une règle est composée d’un nom, d’une

description, d’une condition et d’une production.

Nous avons modélisé la condition par une classe Premisse qui peut engendrer deux classes filles

ConditionSimple et ConditionMultiple. Cette modélisation permet de mieux gérer par la suite les

conditions imbriquées pour pouvoir utiliser les « OU » à l’intérieur d’une condition.

Une production est une liste de faits. Elle ne nécessite pas d’héritage comme la prémisse car on ne

gère que l’opérateur « ET ».


Rapport de projet



10

III. Mise en œuvre du projet

a. Algorithmes

Algorithme du fonctionnement du moteur :

Tout d’abord, nous avons utilisé le même algorithme du chaînage que celui du cours :

Nous avons juste ajouté la gestion des priorités Depth et Breadth à l’intérieur de cet algorithme.

La partie la plus difficile a été de faire le parseur StringToRegle en utilisant de la récursivité car à

partir de simple fonction de la classe String il a fallu décortiquer les chaines caractères pour en faire

une règle en retour.

Signature de la fonction : public regle StringToRegle( string chaine, string chaine2, string reference, string commentaires)


Rapport de projet



11

En ce qui concerne la fonction qui détermine les règles applicables, nous avons élaboré une fonction

qui vérifie qu’une règle est valide ou non, soit, vraie ou fausse. La fonction utilise une autre fonction

ConditionValide() qui permet de vérifier si la condition est vraie ou fausse.Voici le code de la

fonction ConditionValide() :

public Boolean ConditionValide( basedefait BF1) { int i = 0; Boolean bobol = true ; fait F1 = new fait (); if ( this .GetOperateurNon() == false ) // Si C'est un fait avec l'opérateur Non { while ((i < (BF1.GetListeFait().Count)) && (bobol == true )) { F1 = ( fait )BF1.GetListeFait()[i]; if ( this .Getfait().GetNom() == F1.GetNom()) { bobol = false ; } i++; } if (bobol) { return false ; } else { return true ; }; // si il n'a pas été trouvé alors règle vérifiée } if ( this .GetOperateurNon() == true ) // Si C'est un fait normal { i = 0; while ((i < BF1.GetListeFait().Count) && (bobol == true )) { F1 = ( fait )BF1.GetListeFait()[i]; if ( this .Getfait().GetNom() == F1.GetNom()) { bobol = false ; } i++; } if (bobol) { return true ; // si il a été trouvé alors règle vérifiée } else { return false ; }; } return false ; // Par défault on renvois faux }


Rapport de projet



12

b. Structure des données :

Les objets métiers (Projets, Basederègle, Basedefait) sont stockés dans des fichiers binaires. Cette

structure de fichiers, est donc sécurisée car ce sont des fichiers propriétaires Microsoft.

Nous avons deux fonctions très utiles qui permettent l’enregistrement d’un projet, d’une base de

faits et d’une base de règles! Ce sont les fonctions Charger() et Sauvegarder().

La fonction SauvegarderProjet() par exemple :

public void EnregistrerProjet( projet Projet1, string fichier) { IFormatter fmt1 = new BinaryFormatter (); // Format binaire Stream stream1 = new FileStream (fichier, FileMode .Create, FileAccess .Write); // Créer un fichier fmt1.Serialize(stream1, Projet1); // encode objet projet dans le fichier stream1.Close(); } Et la fonction complémentaire ChargerProjet() : public projet ChargerProjet( string fichier) { IFormatter fmt1 = new BinaryFormatter ();// Format binaire Stream stream1 = new FileStream (fichier, FileMode .Open, FileAccess .Read); // Ouvrir un fichier temporaire projet _projet = ( projet )fmt1.Deserialize(stream1); //Charger le fichier en objet stream1.Close(); return _projet; }

c. Interface graphique

i. La page principale

La page principale possède des caractéristiques lui permettant d’avoir

éditant celle-ci, nous pouvons changer le fond de la fenêtre principale standard comme le montre la

capture d’écran suivante :

L’édition nous permet d’obtenir le fond suivant


Christian Couder, Fabien Joubert, Guy

Interface graphique

La page principale

La page principale possède des caractéristiques lui permettant d’avoir une image en fond d’écran. En

ci, nous pouvons changer le fond de la fenêtre principale standard comme le montre la

Changement de fond d’écran

L’édition nous permet d’obtenir le fond suivant :

Projet Intelligence Artificiel

Rapport de projet



13

une image en fond d’écran. En

ci, nous pouvons changer le fond de la fenêtre principale standard comme le montre la


Rapport de projet



14

La page principale offre la possibilité d’accéder aux différentes fonctionnalités du logiciel dès le

lancement de l’application grâce à une liste de sous-menu.

ii. Le menu de la page principale

Le développement du logiciel sous Visual C# permet de mettre en place les interfaces graphiques

ainsi que leurs composants grâce à un éditeur graphique.

Ci-dessous, une capture d’écran montrant l’ajout d’un onglet dans le menu « Projet ». Ainsi, il est

possible d’ajouter directement des éléments et de leur associer des méthodes lors du clique souris

depuis l’éditeur graphique.

Le menu et son édition dans Visual C#

Et voici les différentes parties du menu :


Rapport de projet



15

IV. Exemple de fonctionnement

Nous avons mis en place une aide en ligne dans le logiciel. Cette aide a été réalisée sous Fast Help qui

permet de créer rapidement et efficacement une aide en ligne.

Nous allons maintenant vous montrer un exemple concret de l’application. Tout d’abord, on lance

l’application, on arrive sur la page « PagePrincipale » de l’application.

Puis, on ajoute une règle en passant par le menu Règles -> Créer une règle :


Rapport de projet



16

Puis nous créons une simple règle R1 en remplissant la condition et la production :

Après avoir cliqué sur ajouter, on fait la même chose pour ajouter des faits :


Rapport de projet



17

Ensuite on sélectionne le mode de priorité dans les règles :

Puis on lance le moteur et on peut observer les résultats suivants :


Rapport de projet



18

Conclusions et perspectives

La création du générateur de système à base de connaissance qui exploite le formalisme de règles de

production fut très riche et nous permit de développer et d’affiner certaines de nos connaissances en

Intelligence Artificielle ainsi qu’ en programmation objet.

Les connaissances acquises en Intelligence Artificielle :

Le moteur d’inférences en chaînage avant, rappel priorité DEPTH BREADTH.

La gestion des règles avec les prédicats AND ou OR

Les connaissances apportées en programmation objet :

Le développement d’une interface graphique en C#

Le développement d’un projet concret comportant de nombreuses spécificités.

Dans les perspectives d’avenir du projet, nous aurions souhaité l’implémentation du chaînage arrière

au niveau du moteur d’inférences et des représentations graphiques du raisonnement du moteur.

Documents

EPSI KLIPS P I A - christiancouder.files.wordpress.com représentation, de part sa diffusion très large, et de son adaptation à une application orientée objet. Nous avons donc d’abord