1 / 21

ABACO: per che cosa

ABACO (Agent-Based Architecture for Cooperation) : un’architettura ad agenti a supporto del coordinamento di attivita’ svolte da attori (umani). ABACO: per che cosa. ABACO is e’ una semantica operazione per la notazione Ariadne Categories of Articulation Work Agenti

rasul
Télécharger la présentation

ABACO: per che cosa

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. ABACO(Agent-Based Architecture for Cooperation): un’architettura ad agenti a supporto del coordinamento di attivita’ svolte da attori (umani) LinguaggixCoord&Coop

  2. ABACO: per che cosa ABACO is e’ una semantica operazione per la notazione Ariadne Categories of Articulation Work Agenti attributi state behaviors (ACL scripts) Coordination Mechanisms Aggregazioni di agenti Composizione uniforme di agenti per rappresentare “Coordination Mechanisms” a qualunque livello LinguaggixCoord&Coop

  3. ABACO: perche’ usare gli agenti ABACO e’ un’architettura multi-agente Un approccio sistemico localita’ interazione capacita’ di percepire l’ambiente degli agenti Comportamento globale emerge da: interazioni locali + reazione a stimoli dall’ambiente LinguaggixCoord&Coop

  4. La struttura di ABACO (agenti) Stato interno + comportamento in termini di comunicazioni Un agent communication language (ACL) uniforme garantisce interoperabilita’ tra agenti eterogenei Le primitive importanti: create(<attribute:value>*...) define(<attribute:value>*...)/tell(new behavior:<behavior>...) LinguaggixCoord&Coop

  5. internal state attribute value Working memory script script script attribute value local data behavior La struttura interna degli agenti (dett.) script LinguaggixCoord&Coop

  6. La sintassi del linguaggio di coordinamento (ACL) <behavior>::= <pattern>+ <pattern>::= <message> [IF<cond>] <handler> | <cond> <handler> <handler>::= <reaction> | <reaction> ; <handler> <reaction>::= <local computation> | <communication> <communication>::= [IF <cond>] <out-comm>| [IF <cond>] <out-comm>// <communication> <out-comm>::= send to <agent> : <message> <agent>::= all (<list>) | anyof (<list>) <list>::= <agent-type>+ | <agent-name>+ <message>::= tell (<data> [{<attribute: value>*}]) | ask (<info> [{<attribute: value>*}]) | create (<attribute: value>* [{<attribute: value>*}]) | define (<attribute: value>* [{<attribute: value>*}]) < data >::= <attribute: value>* | new-behavior: <behavior> < info >::= <attribute>* | behavior <value>::= <any-data-type>* ; <agent-type>* LinguaggixCoord&Coop

  7. Tre ruoli utente • Comportamenti modulari da assegnare ad agenti (description agents-DA) • Programmatore • Definizione incrementale di CM/agenti (template agents-TA) • management/ utente finale (CM designer ) • Attivazione a run-time di CM/agenti (instance agents-IA) • utente finale LinguaggixCoord&Coop

  8. La struttura di ABACO (architettura) User roles System agents Application agents Description agents Get behavior Template agents build behaviors Programmer Compound CM CM CM LI LI EI UA build CMs GUI CM-definer Wrapper agent EI put instances of CMs at work End user Compound CM CM CM LI LI EI Instance of Instance of Instance agents Compound CMn Compound CM1 LinguaggixCoord&Coop

  9. agenti ridirige stimolo ad agenti stimolo wrapper agent user agent Attore umano Azioni su interfaccia Risposta con contenuti opportuni preparazione interfaccia ciclo di interazione tra attore umano ed agenti architettura LinguaggixCoord&Coop

  10. Principi di base per la creazione e definizione di TA • I DA creano i TA corrispondenti con il comportamento minimale: capacita’ di richiedere al DA “pezzi di comportamento” • Costruzione incrementale di TA • In parallelo, il DA fornisce al ruolo “definitore” il comportamento che gli consente, quando “assigned” ad un Attore, di dire al Wrapper di costruire l’interfaccia che consente all’attore umano che gioca quel ruolo, di iniziare la definizione del TA • Costruzione incrementale della interfaccia • Ad ogni definizione di pezzi di TA, si attiva la richiesta del relativo comportamento al DA, attraverso il comportamento di default LinguaggixCoord&Coop

  11. Category(DA) Description level create Category(TA) create Category(TA) + add default behavior CM-definer add behavior UA Role_name Category(TA) Template level creazione di Template agents • Category(DA) • create(CM, category, category_ name {<defined_by: Role_name>}) à • create_agent(CM, category, category_ name); • send tocategory_ name: tell(new-behavior: • define(<attribute: value>{<CM:value> }) à • send to Category(DA): ask(behavior {<attribute: value>,<reply: category_ name>}) • tell(new-behavior: behavior) à • incorporate_behavior • ); • send toRole_name: tell(new-behavior: • assigned à • send toUA:tell(<define:category, category_name>{<CM:value> }) • ) LinguaggixCoord&Coop

  12. definizione di Template agents (cont) CM-definer UA define (responsible for) define (responsible for) TaskTA) Role(TA) Template level define (under responsibility of) • UA • tell(<define:category, category_name>{<CM:value> }) à • send to Wrapper: tell(<define:category, category_name>{<CM:value>}) • define(<responsible for Task:Task_name, Role_name > {<CM:value>}) à • send to Role_name: define(<responsible for Task: Task_name>{<CM:value>}) || • send to Task_name: define(<under responsibility of: Role_name>{<CM:value>}) • // scatenano il default behavior di Task e Role => ask al loro DA LinguaggixCoord&Coop

  13. Role(DA) Description level CM-definer ask behavior tell behavior UA define (responsible for) Role(TA) Template level definizione di Template agents (cont) • Role(DA) • ask(behavior {<responsible for Task: Task_name>,<reply: Role_name>}) à • send to Role_name: tell(new-behavior: • assigned à • send to UA: tell(<event: activate, Task_name>{<activator:Role_name><assigned:Actor_name>}) • tell(<activate:Task_name>{<activator:Role_name><assigned:Actor_name><activated:I_of_Task_name>}) à • send to Task_name: tell(<event:activate>{<activator:Role_name><assigned:Actor_name><activated:I_of_Task_name>}) • tell(<result:value>{<assigned:Actor_name>}) à • update_local_data(result) • ) LinguaggixCoord&Coop

  14. Task(DA) Description level CM-definer ask behavior tell behavior UA define (under responsibility of) Task(TA) Template level definizione di Template agents (cont) • Task(DA) • ask(behavior {<under-responsibility-of: Role_name>,<reply: Task_name>}) à • send to Task_name: tell(new-behavior: • tell(<event: activate>{<activator:Role_name><assigned:Actor_name><activated: I_of_Task_name>}) à • compute_local_data; • send to Role_name: tell(<result:value>{<assigned:Actor_name>}) • ) LinguaggixCoord&Coop

  15. definizione di Template agents Task(TA) Template level Role(TA) tell(event:activate) CM-definer tell(activate) tell(event:activate) UA tell(activate) Task(IA) Instance level tell(event:activate) • UA • tell(<event: activate, Task_name>{<activator:Role_name><assigned:Actor_name>}) à • send to Wrapper: tell(<event: activate, Task_name>{<activator:Role_name><assigned:Actor_name>}) • tell(<event: activated, Task_name>{<activator:Role_name><assigned:Actor_name><activated: I_of_ Task_name>}) à • send to Role_name: tell(<activate:Task_name>{<activator:Role_name><assigned:Actor_name><activated: I_ of_Task_name>}) LinguaggixCoord&Coop

  16. Actor define (assigned to) CM-definer tell behavior ask behavior UA Role assegnamento di Attori a Ruoli • ACTOR • define(<assigned_to:Role_name>) à • send toRole_name: ask(behavior{<assigned:Actor_name >}) • tell(<new-behavior:behavior>) à • assigned = true; • incorporate_behavior • Role • ask(behavior {<assigned:Actor_name >}) à • send to Actor_name: tell(<new-behavior:behavior>}) LinguaggixCoord&Coop

  17. IA create IA create constellation CM-definer UA add behavior Role_name creazione di Costellazioni • UA • create(<createConstellation:name>{< defined_by: Role_name >) à • create_constellation(name, local_interface_name); • send to Role_name: tell(new-behavior: • assigned à • send to UA: tell(<defineConstellation: name>) • ) LinguaggixCoord&Coop

  18. Una semantica per ACL (cont) • Semantica operazionale di ACL • espressa in termini di SA nets • Interprete dell’agente e’ una Rete di Petri che • seleziona i messaggi ricevuti • ne sceglie uno in base al match con gli script (LHS) • attiva il comportamento di reazione (RHS) LinguaggixCoord&Coop

  19. IN <condn> <handlern> outn Una semantica per ACL Agent interpreter Script1 Scriptn <cond1> Select <message>|<cond> <handler1> <cond1> <condn> out1 out1 outn restart LinguaggixCoord&Coop

  20. Conclusioni • Per chi interessato: • Integrazione in ABACO di aspetti spaziali fisici • context-aware computing • Progetti di utilizzo di RTP per implementare ABACO • (cfr. Lucidi ABACORTP) LinguaggixCoord&Coop

  21. field of work distributed actors actions coordination define/modify coordination mechanism CAWs relations + artifact agents’ aggregation CONCEPTUAL ARCHITECTURE Operational semantics components’ composition CONCRETE ARCHITECTURE Implementation Il ciclo di vita per progettare supporti al coordinamento Operational semantics LinguaggixCoord&Coop

More Related