Une approche componentielle pour la modélisation d'agents coopératifs et leur validation

M.-J. Yoo

LIP6 2000/020: THÈSE de DOCTORAT de l'UNIVERSITÉ PARIS 6 LIP6 / LIP6 research reports
168 pages - Octobre/October 1999 - French document.

Get it : 1999 Ko /Kb

Contact : par mail / e-mail

Thème/Team: Objets et Agents pour Systèmes d'Information et de Simulation

Titre français : Une approche componentielle pour la modélisation d'agents coopératifs et leur validation
Titre anglais : A componential approach for modeling and validating cooperative agents

Résumé : Du fait de la popularisation de l'Internet et de la technologie du Web, l'approche visant à adapter le paradigme d'agent à la réalisation d'une application ou d'une interface qui aide l'utilisateur de l'Internet/Web est de plus en plus explorée. Cependant la réalisation d'un système multi-agents sur Internet nécessite de résoudre quelques problèmes complexes posés par les caractéristiques spécifiques suivantes :
1) ouverture de l'environnement de développement et d'exécution
2) problème de coopération entre des agents
3) introduction de la mobilité d'agent
4) besoin de validation
Le modèle d'agent dans un environnement ouvert comme Internet doit être évolutif parce qu'il y a des modifications possibles au cours de l'exécution du système. Par exemple, un nouvel agent peut être introduit dans ce système en remplaçant un ancien. Ainsi une modification du modèle de coopération des agents peut être envisagée dans le comportement des agents existants.
L'ouverture de l'environnement d'exécution d'agents entraîne également le besoin de validation de certaines propriétés dans le système multi-agents, notamment la validité du modèle de coopération des agents. Pour valider le modèle de coopération des agents qui sont dispersés sur les réseaux, une simulation locale ou un test d'exécution sur un site ne sont pas suffisantes pour assurer la validité du modèle entier, il nous faut considérer des méthodes de validation formelle. Du fait de l'évolution des applications sur le Web, le modèle d'agents doit être assez flexible pour que l'on puisse le modifier facilement au cours du cycle de vie. Une partie du modèle doit pouvoir être modifiée sans remise en cause du reste du modèle. Pour ce faire, l'approche componentielle (à base de composants) est un bon moyen pour modéliser des agents. Nous proposons le langage SCD qui permet de modéliser un agent par des composants dans un framework. Les caractéristiques du langage SCD sont les suivantes :
1) Il est facile de modéliser les protocoles de coopération d'agents. Sa syntaxe est basée sur la notion d'état/transition. Ceci permet de décrire facilement des protocoles de coopération d'agents qui sont importants pour réaliser l'aspect coopératif des agents.
2) Le langage permet aussi de modéliser la migration d'agent comme une action intégrée dans un protocole de coopération. La mobilité d'agent est modélisée en décrivant dans le comportement interne d'un composant le moment de migration qui est synchronisé avec d'autres comportements.
3) Le langage permet d'encapsuler un module programmé en Java comme un composant connectable. Ceci facilite le développement d'un service réel en permettant l'utilisation de technologies courantes basés sur Java (e.g., Applet, Java Beans, JDBC, etc.).
4) En outre, le langage SCD peut être traduit en modèle de réseaux de Petri en vue d'une validation formelle à l'aide d'environnements de validation tels que CPN/AMI du thème SRC/LIP6.
L'environnement de composants que nous avons réalisé contient donc :
* un environnement permettant la production des composants exécutables par compilation. La compilation d'un composant SCD est réalisée par notre générateur de code qui parcourt la description du modèle en SCD pour générer le code source en Java.
* un environnement d'exécution des composants en Java. Cet environnement contient des mécanismes de base pour exécuter des composants compilés en Java, par exemple des primitives pour la communication inter-composants, le changement d'états internes d'un composant, des opérations de base d'un composant, etc.
* un environnement d'intégration de composants SCD dans la structure d'agent mobile donnée par une plate-forme d'agents mobiles. Nous avons fourni des mécanismes de base pour l'intégration des composants exécutables dans de telles plates-formes.
Notre architecture d'agent est vue comme un composant composite qui joue un rôle de framework. Le modèle d'agent réalisé par des composants exécutables en Java est ensuite intégré dans une plate-forme d'agents mobiles, notamment JNA et Voyager.
Nous avons choisi un scénario d'agence de voyages (proposé par FIPA) comme exemple de test pour une première application de notre approche. Nous avons modélisé en SCD l'agent agence de voyage et quelques agents serveurs de voyage qui coopèrent suivant les protocoles de coopération, par exemple, protocole d'appel d'offre ("Contract Net"), le protocole 'FIPA-Query-reference', ou le protocole 'FIPA-request', etc. Notre générateur a produit du code exécutable en Java qui a été ensuite intégré dans la plate-forme différentes d'agents mobiles Voyager et JNA. Les agents du scénario ont pu être exécutés sur deux plates-formes d'agents mobiles. Nous avons pu visualiser des échanges de messages entre agents suivant la définition de chaque protocole de coopération. En parallèle, à partir du modèle conçu en SCD, nous avons dérivé le modèle de validation en réseaux de Petri colorés et procédé, en collaboration avec SRC, à la validation de certaines propriétés (pas de blocage non désiré, problème d'équité, etc.) sur notre modèle.
Notre expérimentation exploite également la réutilisabilité des composants SCD. Un des avantages de l'approche componentielle et des frameworks est la possibilité de réutiliser des composants existants pour la conception d'un autre modèle. Nous avons étendu le modèle de protocole d'appel d'offre initial en réutilisant des composants utilisés dans le premier modèle conçu en SCD. Deux exemples sont l'extension vers un protocole d'appel d'offre avec délai de temps ("timeout") ou avec itération ("Iterated-FIPA-Contract-Net").
Dans la conclusion de la thèse, nous résumons et évaluons les résultats obtenus et proposons des pistes pour la suite. Notre expérience montre que l'approche génération de code peut résoudre certaines difficultés sur la programmation des agents mobiles dans une plate-forme d'agents mobiles, par exemple la géstion de la migration d'agent avec multi-threads, le problème de reprise d'une activité après la migration, etc. En dissociant clairement le modèle d'agent de haut niveau qui est donné par la description en SCD et la structure physique d'agents mobiles qui est fournie par une plate-forme d'agent mobile, nous avons simplifié le problème de portabilité du modèle d'agents sur deux différents types de plates-formes.

Abstract : Recently, applying the agent based technology to developping distributed cooperative applications is activated. We can mention the travel agency system within which various applications are in cooperation using a certain agent communication language and various types of cooperation protocols for the purpose of providing a composed travel service.
We analyse the characteristics of this system as follows:
1) developping and execution environment is opened.
2) agent cooperation.
3) agent mobility.
4) Validation problems
In this context, our work aimed to integrate the software developping phases : modeling, implementation and validation. Our issue contains :
1) How can a designer design, validate and implement a multi-agent system in convenient manner in considering the agent mobility ?
2) What is the best solution for using components within each developpment phase?
3) In what way, the implementiation of the same agent model under different types of platform can be achieved? To solve these problems, we have developed a mobile agent modeling and implementation environment with which the designer models agents using different types of software components which can be easily connectable and replaceable.
In this environment the agent modeling and implementation phase can be divided into three different phase:
1. In the agent modeling phase, the intelligent behavior and the collaborative aspect may be differently designed as distinctive components of the agent architecture concerning the mobility. This phase concerns only the abstract high-level agent model, that is to say, the designer does not need to directly manipulate the agent migration method which is specific to a mobile agent platform.
2. The compilation into Java source code and implementation phase makes it possible to generate automatically the operational Java code and implement the agent into a mobile agent platform, which corresponds exactly to the model specified in the 'modeling phase'. One benefit of our approach is to minimize the dependency of agent modeling and implementation environment from the mobile agent platform itself. This is shown by our experimentation with two different types of mobile agent platforms; one for JNA (JavaNet Agent) mobile agent platform [Merlat et al. 97] and the other with Voyager [Voyager 97].
3. The validation of multi-agents' cooperation protocols. In our system we also address the validation of conversation protocols before executing the agents in real world. After designing an agent model, the validation phase verifies certain basic properties of the conversation protocol (no deadlock, no livelock, etc.) through the translation of the protocol specification into a Petri net formalism. We have developed the Soft-Component Description (SCD) language in order to describe different agent parts as connectable components. The agent designer uses this language to model an agent behavior by defining component classes and then composing component instances.
The essential characteristics of SCD are that:
1. it is appropriate to describe the agent conversation protocols or the Task Controller components. SCD semantic is mainly based on the state/transition mechanisms. In case of 'Conversation protocol' components, it is pertinent to represent the conversation states and transition conditions to the next conversation state.
2. for modeling agent specific tasks the designer can encapsulate any Java programs into a connectable component using SCD syntax. This means that any Java application or Applet can be encapsulated and then composed within an agent architecture. For example, if we want to encapsulate a Java object as a connectable component;
3. SCD is able to describe a compound component which can be obtained by the composition of different types of component, i.e., the type 1 or 2 of components listed above, or the compound component itself. The translation from a componential model to a mobile agent is achieved automatically. Once the designer describes the component specification using SCD (SoftComponent Description), it is compiled into Java code which is then encapsulated within a mobile agent's execution body. We have implemented a compiler which produces Java source code from the component model specified using SCD. From one component class description, the compiler produces a component class definition in Java. One of the best benefits of our approach is that the agent modeling and code generation system is weakly dependent upon a given (Java-based) mobile agent platform. This is possible by the compilation of SCD into Java source code. There are some other agent platforms which compile their specification language in order to generate agents, namely SodaBot [Coen 94], LALO [Gauvin et al. 97]. In these cases, the compiled or interpreted information has been directly transformed into a specific agent platform. Thus it is difficult to adapt such systems to another type of environment. But in our case, the compiler generates Java source code which can be integrated into some Java-based agent platform. This has made easy the integration
We have validated the contract net protocol using a colored Petri net tools (CPN-AMI) and verified that there were no deadlock and the protocol terminated in an expented state. The model of contract net protocol was designed using SCD and translated into the colored Petri net by hands respecting some transformation rules.

Mots-clés : composant logiciel, agents mobiles, framework d'agent, protocole de coopération, validation, réseaux de Petri, Java, Voyager

Key-words : software component, mobile agents, agent framework, cooperation protocol, validation, colored Petri net, Java, Voyager

Publications internes LIP6 2000 / LIP6 research reports 2000

Responsable Éditorial / Editor :Valerie.Mangin@lip6.fr