September 2008ESAW 081 SMAC - IRIT – UPS Sylvain Roug le, TOULOUSEJean-Paul Arcangeli, FRANCE Marie-Pierre Gleizes, Frédéric Migeon 1 ADELFE Design, AMAS-ML in Action A Case Study

September 2008, 24-26thESAW 082 Case Study: Foraging Ant Simple but illustrative example Already developed in our team [Topin 99] Adaptive MAS approach adequacy Behaviours entirely specified Focus on modelling language and transformations Environment: Nest, Obstacles, Ants, Food, Pheromone Goal: foraging !

September 2008, 24-26thESAW 083 Results Simulation tool 3 man/day Behavior rules 0,5 man/day Functional Details Speed modulation Food editing Ants managing Zooming

September 2008, 24-26thESAW 084 Outline Problematics Adaptive Multi-Agent Systems Flexible Agent model ADELFE Methodology Model Driven Engineering Model Driven ADELFE Conclusion and Future Works

September 2008, 24-26thESAW 085 Context Complex systems: Ambient Intelligence, Simulation, Problem solving, Swarm robotics,... Characterized by : Emergent properties, Numerous interactions, Context awareness,... These systems require adaptive approaches dealing with: Dynamic constraints, Evolving environment, Unreliable infrastructure,... 5

September 2008, 24-26thESAW 086 Problematics Adaptive Multi-Agent Systems Self-organising systems Support system functional adaptation Flexible Agent model Agent operating mechanisms adaptation Proposition: Combine AMAS and Flexible agent in the design of complex systems Aim : Benefit from both levels and both concerns of adaptation

September 2008, 24-26thESAW 087 Principles : Global function realized = result of the organizational process between agents Change the organization: change the global function To change the organization: self-organization by cooperation Agents are in a cooperative state = functional adequacy is reached Agents have to be cooperative But there are unwanted situations: Non Cooperative Situations No NCS detected  nominal behaviour is performed (local function) NC state (exception or anticipation)  cooperation failure recovering AMAS (Adaptive Multi-Agent Systems)

September 2008, 24-26thESAW 088 (Domain Specific) Modelling Language

September 2008, 24-26thESAW 089 Modularity Agent defined as micro-component assembly Re-usability Micro-components constitute reusable units Mediator design pattern The mediator gathers services from micro-components Separation between: Operating mechanisms Agent behaviour Delegation Mediator delegates operating services to behaviour component Flexible Agent : Implementation Principles

10 Combining Functional/Operational Adaptation Functional AdaptationOperational Adaptation Agent Classical Learning Approaches Flexible Agent SystemAMAS approach different kinds of adaptation, different levels of concerns Self-adaptation of the system = cooperation of agents Non Cooperative Situations detection Implementation with flexible agent Agent oriented specific middleware

11 Outline Problematics Adaptive Multi-Agent Systems Flexible Agent model ADELFE Methodology Model Driven Engineering Model Driven ADELFE Experiments Analysis Conclusion and Future Works

September 2008, 24-26thESAW 0812 ADELFE Methodology Main characteristics Specific agent-based methodology  Exploiting the AMAS Principles → cooperation  Open systems, adaptive to changes in the environment For engineers aware of MAS Principles Based on RUP and standard notations (UML, AUML) Top down approach: Analysis phase - identification of agents Bottom up approach: Design phase – agent design Needs Precise and specific concepts to assist the designer’s task Specification of cooperation rules Guidelines for the system implementation

September 2008, 24-26thESAW 0813 Model Driven Engineering Aim: ease systems design Promote models as “first class citizen” Models provide abstraction Models define precise concepts for systems design Models are conform to meta-models (defined with MOF (OMG), Ecore (Eclipse)) Automatic treatments Means to assist designers and developers Gather and automate good practices or expertise Support by model transformations (transformation languages: ATL †, Kermeta ‡ ) Allow code generation Domain Specific Modelling Language Dedicated modelling language (concise and specific) Described by a domain meta-model (close to domain experts needs) († (‡

September 2008, 24-26thESAW 0814 Outline Problematics Adaptive Multi-Agent Systems Flexible Agent model ADELFE Methodology Model Driven Engineering Model Driven ADELFE Domain Specific Modelling Language Design Implementation Experiments Analysis Conclusion and Future Works

September 2008, 24-26thESAW 0815 AMAS-ML : Adaptive Multi-Agent System Modelling Language Dedicated to the specification of : System composition (agents, entity) Agent Cooperative properties Agent Cooperative behaviour µADL : micro-Architecture Description Language Dedicated to the specification of : Specific agent middleware Agent operating mechanisms models Domain Specific Modelling Language

September 2008, 24-26thESAW 0816 Model Driven ADELFE (1/2) Design Enhanced Design Phase Use of UML 2.0 Use of AMAS-ML diagrams to specify : System / environment composition Cooperative agent structure Cooperative agent behaviour: Cooperation and nominal rules Use of model transformations : Link AMAS-ML to UML 2.0 : Get information from requirements model Express interactions thanks to UML Sequence diagrams

September 2008, 24-26thESAW 0817 Model Driven ADELFE (2/2) Implementation Implementation phase Wanted result: AMAS Implementation using flexible agent middleware capabilities. Need: to express concerns separation (operational/behavioural) between AMAS concepts. Model transformations are used to: Automate the mapping between AMAS-ML and µADL. Generate agent behaviour code. Make Agent Yourself (MAY) generation tool: Generate specific flexible agent middleware Use µADL model as input

September 2008, 24-26thESAW 0818 Transformations Overview 1. AMAS-ML to µADL : ATL Transformation 12 rules, 5 helpers, 380 code lines. Example : -- Transforming AMAS Actuator into homonymic muADL MuComponents. rule Actuators2MuComponent{ from actuator : AMAS!Actuator to actuatorCt:muADL!MuComponent( name <- actuator.name, provided <- thisModule.resolveTemp(actuator,'providedActuatorInterface'), privateServices collect(act|thisModule.resolveTemp(act,'service')) ), providedActuatorInterface:muADL!Interface( name <- actuator.name+'I' ) } 1. AMAS-ML to µADL : ATL Transformation 12 rules, 5 helpers, 380 code lines. Example : -- Transforming AMAS Actuator into homonymic muADL MuComponents. rule Actuators2MuComponent{ from actuator : AMAS!Actuator to actuatorCt:muADL!MuComponent( name <- actuator.name, provided <- thisModule.resolveTemp(actuator,'providedActuatorInterface'), privateServices collect(act|thisModule.resolveTemp(act,'service')) ), providedActuatorInterface:muADL!Interface( name <- actuator.name+'I' ) } 2. AMAS-ML to Java : ATL Transformation 2 queries, 10 helpers, 130 code lines. Example : -- Transforming AMAS Actuator into homonymic muADL MuComponents. helper context AMAS!Rule def : generateIfThenElse(): String = '\t/**\n\t* Generated '+ if self.oclIsTypeOf(AMAS!CooperativeRule) then 'cooperative rule : ' +self.name+' handles '+self.handledNCSName()+ ' situation :\n\t* ' +self.description else 'standard rule : ' + self.name endif +' \n\t*/\n' +'\tif ('+ self.trigger.condition.generateCondition()+'){\n' +self.impliedActions->iterate(a; accA: String=''|accA+'\t\t'+a.generateAction()+'\n\t\t}'); 2. AMAS-ML to Java : ATL Transformation 2 queries, 10 helpers, 130 code lines. Example : -- Transforming AMAS Actuator into homonymic muADL MuComponents. helper context AMAS!Rule def : generateIfThenElse(): String = '\t/**\n\t* Generated '+ if self.oclIsTypeOf(AMAS!CooperativeRule) then 'cooperative rule : ' +self.name+' handles '+self.handledNCSName()+ ' situation :\n\t* ' +self.description else 'standard rule : ' + self.name endif +' \n\t*/\n' +'\tif ('+ self.trigger.condition.generateCondition()+'){\n' +self.impliedActions->iterate(a; accA: String=''|accA+'\t\t'+a.generateAction()+'\n\t\t}');

September 2008, 24-26thESAW 0819 Developer Conclusion Simple, Efficient, Automated Prototype in 3 days, Behaviour part 0,5 day Ant API, 53ko, 17 classes, 9 interfaces Environment, 69ko, 29 classes Behaviour and main, 6ko, 2 classes API Details Kernel : 4 classes, 1 “markup” interface Agent Generated micro-components : 1 class per each

September 2008, 24-26thESAW 0820 AMAS Designer Conclusion New version of ADELFE : Using model driven approach: Specific languages (AMAS-ML, µADL) Model transformations Automations in the development process : Facilitate phases transition (from analysis to design) Allow to bridge generic (UML) and specific (AMAS-ML) modelling Ease the implementation Developers focus on application dependent concerns

September 2008, 24-26thESAW 0821 Future Works Improve behavioural design AMAS-ML type system to specify instance values Investigate template based language to generate code Provide a fully integrated tool including : An assistant guiding users all along the process Model validations and simulation Provide an adaptive methodological framework Assist users by proposing adequate method fragments

September 2008ESAW 0822 Questions?

September 2008, 24-26thESAW 0823 Elsy Kaddoum MASC Trois types d’agents coopératifs Conteneur Opérateur Station Conteneurs Opérateurs

September 2008, 24-26thESAW 0824 Elsy Kaddoum MASC