MODULO 1LinguaggixCoord&Coop1 ABACO (Agent-Based Architecture for Cooperation) : unarchitettura ad...

MODULO 1 LinguaggixCoord&Coop 1

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

attributi state

behaviors (ACL scripts)

Coordination Mechanisms Aggregazioni di agenti

Composizione uniforme di agenti per rappresentare “Coordination Mechanisms” a qualunque livello


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


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


La struttura interna degli agenti (dett.)

script

Working memoryattribute

attribute

value

value

script

local data behavior

internal state

script

script


La sintassi del linguaggio di coordinamento (ACL)

<any-data-type>* ; <agent-type>* <value>::=

<attribute>* | behavior < info >::=

<attribute: value>* | new-behavior: <behavior> < data >::=

tell (<data> [{<attribute: value>*}]) |

ask (<info> [{<attribute: value>*}]) |

create (<attribute: value>* [{<attribute: value>*}]) |

define (<attribute: value>* [{<attribute: value>*}])

<message>::=

<agent-type>+ | <agent-name>+ <list>::=

all (<list>) | anyof (<list>) <agent>::=

send to <agent> : <message> <out-comm>::=

<local computation> | <communication> <reaction>::=

<reaction> | <reaction> ; <handler><handler>::=

<message> [IF<cond>] <handler> | <cond> <handler><pattern>::=

<pattern>+ <behavior>::=

<communication> ::= [IF <cond>] <out-comm> | [IF <cond>] <out-comm> // <communication>


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


La struttura di ABACO (architettura)

End user

Description agents

UA

User roles

Programmer

CM-definer

System agents Application agents

build behaviors

build CMs

put instances of CMs at work

GUI

Wrapper agent

Template agents

Instance agents

EI

LICM

EI LICM

Compound CM

LICM

EI LICM

Compound CM

Get behavior

Compound CM1

Compound CMn

Instance of Instance of


ciclo di interazione tra attore umano ed agenti architettura

Attore um

ano Azioni su interfaccia

wrapper agent

user agent

stimolo

preparazione

interfaccia

agentiridirige stimolo ad agenti

Risposta

con contenuti opportuni


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


creazione di Template agents

Category(DA)

create(CM, category, category_ name {<defined_by: Role_name>}) create_agent(CM, category, category_ name);

send to category_ 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 to Role_name: tell(new-behavior:

assigned

send to UA: tell(<define:category, category_name>{<CM:value> })

)

UA

Category(DA)

create Category(TA)

Category(TA)

CM-definercreate Category(TA) + add default behavior

Template level

Description level

Role_name

add behavior


definizione di Template agents (cont)

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

UAdefine (responsible for)

Role(TA)

CM-definer

Template levelTaskTA)define (responsible for)

define (under responsibility of)



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)

)

UA

Role(DA)

define (responsible for) Role(TA)

CM-definer ask behavior

Template level

Description level

tell behavior



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

)

UA

Task(DA)

define (under responsibility of) Task(TA)

CM-definer ask behavior

Template level

Description level

tell behavior


definizione di Template agents

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

UA

tell(event:activate) Role(TA)CM-definer

Template level

tell(event:activate)

tell(activate)

Task(TA)

tell(event:activate)

Instance levelTask(IA)

tell(activate)


assegnamento di Attori a Ruoli

ACTOR

define(<assigned_to:Role_name>) send to Role_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>})

UA

Actor

define (assigned to)

Role

CM-definer ask behavior tell behavior


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

)

UA

create constellationIA

CM-definer

create IA

Role_nameadd behavior


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)


Una semantica per ACL

Select <message>|<cond>

IN

<cond1> <condn>

out1

Agent interpreter

<handler1>

<cond1>

out1

<handlern>

<condn>

outn

Script1 Scriptn

outn

restart


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)


Il ciclo di vita per progettare supporti al coordinamento

Operational semantics

agents’ aggregationCONCEPTUAL ARCHITECTURE

Operational semanticscomponents’ composition

CONCRETE ARCHITECTURE

Implementation

field of workdistributed actors

define/modify

actions

coordination mechanismCAWs relations + artifact

coordination

MODULO 1LinguaggixCoord&Coop1 ABACO (Agent-Based Architecture for Cooperation) : unarchitettura ad...

Documents

Transcript of MODULO 1LinguaggixCoord&Coop1 ABACO (Agent-Based Architecture for Cooperation) : unarchitettura ad...