Notre objectif est d'une part de faciliter l'implémentation de
nouveaux moteurs grâce à une plateforme de développement (LAMA )
et d'autre part d'améliorer les mécanismes de contrôle et de
représentation de la connaissance des moteurs Ocapi et Planete
pour concevoir de nouveaux moteurs mieux adaptés au pilotage de
programmes.
Bibliothèque pour le pilotage de programmes
Participants : Sabine Moisan, Jean-Paul Rigault, Régis Vincent
Mots clefs : planification, conception par objets, programmation par objets, génie logiciel
La construction d'outils génériques (ou moteurs), comme
Ocapi ou Planete (dédiés au pilotage de programmes), consiste à
passer d'un modèle (de pilotage de programmes en l'occurrence) à
une implémentation. Ce modèle sous-jacent permet de concevoir des
moteurs bien adaptés à l'expression de la connaissance et
largement utilisables dans différents domaines d'application.
Cependant, à chaque moteur construit correspond une stratégie
souvent figée et difficile à modifier et à étendre. En effet, le
travail de réécriture de moteurs en différents languages ou
d'écriture de variantes d'un même moteur, nécessaires pour des
tests ou des domaines d'applications différents, est très
fastidieux et coûteux en temps, comme nous l'a prouvé notre
expérience. Par exemple le moteur Ocapi est écrit en Lisp, pour
des données statiques avec contrôle d'exécution sophistiqué et le
moteur Planete est écrit en C++, pour des flots de données, avec
un modèle simplifié. Nous proposons de pallier cet inconvénient
en construisant ces moteurs eux-même à partir d'un ensemble
(bibliothèque) de composants et d'instructions
réutilisables. Le but est d'améliorer la rapidité de
construction et de modification des moteurs ainsi que la sécurité
de programmation. La bibliothèque s'adresse au concepteur afin de
faciliter son travail de construction ou de mise au point de
moteurs. Cette démarche permet d'une part de décrire une
stratégie de raisonnement à un niveau abstrait, plus simplement
et plus rapidement qu'en partant d'un langage de programmation et
d'autre part d'implémenter de nouveaux moteurs sans réécriture de
code massive. Ceci permet de mieux séparer modélisations et
implémentations, tout en facilitant le passage des unes aux
autres et les évolutions conjointes des modèles et des
implémentations. Nous avons développé une première version d'une
bibliothèque pour le pilotage de programmes, en nous focalisant
principalement sur les aspects planification. Les instructions de
la bibliothèque travaillent sur des structures de données
communes qui représentent les entités qui interviennent en
pilotage de programmes (comme : plans, opérateurs, buts à
atteindre, etc...). Ces structures de données sont
représentées par des classes de la bibliothèque et les
instructions sont des fonctions ou méthodes de ces classes. Les
instructions sont des instructions de base du raisonnement en
pilotage de programmes (comme : choisir, exécuter,
etc...). Le concepteur a à sa disposition 24 instructions de
base qui utilisent une trentaine de structures de données. Grâce
à un langage simple manipulant ces instructions il peut ainsi
écrire différents moteurs. Cette bibliothèque a été écrite pour
deux langages cibles (C++ et Lisp), la version Lisp étant la plus
avancée. Grâce à cette bibliothèque nous avons développé pour nos
propres besoins différents moteurs. Cette technique de conception
nous a aussi permis de tester facilement différentes variantes du
même moteur (en particulier des variantes du modèle
d'Ocapi).
Mécanismes de gestion des erreurs en pilotage de programmes
Participants : Régis Vincent, Sabine Moisan, Monique Thonnat
Afin de réaliser un système de correction de bases de
connaissances grâce à des techniques d'apprentissage automatique,
nous avions validé un premier système d'apprentissage des règles
d'initialisation de paramètres. La première version de ce système
a été integrée dans la nouvelle version du logiciel Ocapi
[16,15]. Nous avions spécifié un système
complet qui permet de détecter, de corriger et de modifier les
bases de connaissances de manière complètement automatique. Le
système proposé se décompose en trois parties:
1- une détection des erreurs grâce à un mécanisme
d'évaluation
2- une correction ponctuelle du raisonnement, grâce à des
mécanismes de retour en arrière ``intelligents'' [8]
3- une modification de la base de connaissances afin de pas
reproduire les erreurs passées, basée sur l'apprentissage
automatique [2].
Cependant les fonctionnalités d'Ocapi ne permettaient pas de
prendre en compte complètement les erreurs survenues en cours
d'exécution. Nous avons donc utilisé la nouvelle plateforme pour
le pilotage de programmes (LAMA ) pour réaliser l'implémentation
des mécanismes de correction du raisonnement. Ces mécanismes
s'intègrent dans les différentes phases du pilotage de programmes
( planification, exécution, évaluation des
résultats et réparation). L'évaluation peut être
automatique ou en intéraction avec l'utilisateur. Lorsqu'une
erreur a été détectée, il faut déclencher une action de
correction. Cette correction peut consister en une
replanification du plan courant, ou plus simplement en une
re-exécution d'un opérateur connu comme étant sensible. Le but du
mécanisme de correction est de fournir à l'expert, un certain
nombre (si possible minimal) de primitives pour exprimer les
actions à entreprendre en cas d'échec. Ceci implique de définir
des primitives pour propager les indices sur la cause de l'échec
entre les opérateurs. Nous avons défini trois types d'actions de
correction :
1- modification du plan
2- re-exécution d'un opérateur (avec des valeurs de paramètres
différentes)
3- transmission de la suspicion entre les opérateurs.
Ce mécanisme nous a permis de simuler les mécanismes de
réparation implantés dans d'autres systèmes comme SCARP, SIPE,
Ocapi, BORG. De plus, nous avons prouvé que ce mécanisme permet
d'examiner tous les plans possibles. Nous avons développé une
base de connaissances, en collaboration avec Sandrine Mathieu de
l'équipe PASTIS [3], pour
tester LAMA et pour valider les mécanismes de correction de bases
de connaissances.
Modélisation de la connaissance pour le pilotage de programmes
Participants : John van den Elst, Monique Thonnat, Frank van Harmelen, Sabine Moisan
Mots clefs : résolution de problème, génie logiciel, planification
Pour modéliser la connaissance pour le pilotage de programmes nous avons défini des structures générales permettant à un expert d'exprimer la connaissance sur les programmes de la bibliothèque, la connaissance pour construire une solution ( planification), ainsi que la connaissance sur les données qui sont manipulées par les programmes. Pour améliorer la modélisation des connaissances sur les programmes nous avons étudié l'état de l'art sur la réutilisation de composants logiciels dans le domaine du génie logiciel. Pour améliorer la modélisation des connaissances sur la construction d'une solution (modèle fonctionnel pour sélectionner, ordonner et exécuter des programmes) nous avons effectué une étude des techniques de planification. Enfin, pour améliorer la modélisation des connaissances sur la description des données nous nous sommes principalement basés sur le domaine du pilotage de programmes en traitement d'images.
Réutilisation de composants logiciels. Dans le domaine du génie logiciel le thème de la réutilisation de composants a des rapports étroits avec le pilotage de programmes. Sur la base des travaux existants dans ce domaine [Biggerstaff] [Krueger] [Weide], nous avons proposé un modèle [13] pour la description des composants, et nous l'avons appliqué à la description des programmes et composants plus abstraits (comparable avec la notion d'opérateur complexe du modèle Ocapi) pour le pilotage de programmes. Ce modèle est particulièrement bien développé en ce qui concerne les aspects déclaratifs de la description des composants, des relations entre composants et des données. A partir de ce modèle nous avons développé des structures pré-définies pour la construction d'une base de connaissances d'une bibliothèque de programmes. Le modèle contient la représentation à différents niveaux d'abstraction des données et des composants. Un composant contient une fonctionalité, des caractéristiques, des arguments d'entrée et de sortie, des précontraintes, des effets et des paramètres. Les composants qui représentent des programmes de la bibliothèque contiennent une référence à l'algorithme, et des informations sur l'initialisation des paramètres. Les autres composants contiennent de l'information concernant la relation avec leurs sous-composants ; cette relation peut être une relation de décomposition (sous-partie) ou une relation de spécialisation (sorte de).
Techniques de planification. Nos recherches actuelles se focalisent sur le domaine de la planification. Les similarités entre le pilotage de programmes et la planification ont été exploitées pour définir les méthodes de planification les plus appropriées au pilotage de programmes. Nous avons défini un modéle fonctionnel du pilotage de programmes plus dynamique. Ce modèle est principalement basé sur une planification hiérarchique et à base de squelettes, car une structuration des composants est souvent donnée par un expert et doit donc être utilisable. La construction dynamique d'un nouveau squelette est appliquée quand il n'y a pas de squelette prédéfini qui résoud un problème donné (une série de composants doit être sélectionée et ordonnée), quand une décomposition non ordonnée doit être effectuée (la connaissance de décomposition ne précise pas d'ordre prédéfini), ou quand une solution proposée ne termine pas avec succès.
Actuellement nous travaillons sur l'implémentation et l'illustration de ce modèle fonctionel. L'implémentation est basée sur LAMA qui fournit des fonctions de base pour la planification.
Pilotage de programmes en traitement d'images. La structure de représentation des données est motivée par les besoins dans le domaine d'application du pilotage de programmes en traitement d'images. Nous nous sommes basés sur la description d'images en imagerie médicale, et nous avons proposé un modèle qui représente les données selon cinq catégories d'information différentes (ou points de vue) : acquisition, présentation, contenu, implémentation, et les objets du monde réel (voir section 3.1.3). Ce modèle a été comparé avec d'autres approches (VSDE, BORG, SCARP, TRAM), et appliqué à une autre application en traitement d'images (détection de contours pour des scènes routières).