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

2. 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 !

3. 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

4. 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

5. 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

6. 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

7. 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)

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

9. 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. 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. 11 Outline Problematics Adaptive Multi-Agent Systems Flexible Agent model ADELFE Methodology Model Driven Engineering Model Driven ADELFE Experiments Analysis Conclusion and Future Works

12. 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

13. 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) († http://www.eclipse.org/m2m/atl/)http://www.eclipse.org/m2m/atl/ (‡ http://www.kermeta.org/)http://www.kermeta.org/

14. 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

15. 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

16. 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

17. 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

18. 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}');

19. 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

20. 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

21. 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

22. September 2008ESAW 0822 Questions?

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

24. September 2008, 24-26thESAW 0824 Elsy Kaddoum MASC