slide1 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
ABACO: per che cosa PowerPoint Presentation
Download Presentation
ABACO: per che cosa

Loading in 2 Seconds...

play fullscreen
1 / 21

ABACO: per che cosa - PowerPoint PPT Presentation


  • 104 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'ABACO: per che cosa' - rasul


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide1

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

LinguaggixCoord&Coop

abaco per che cosa
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

abaco perche usare gli agenti
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

la struttura di abaco agenti
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

la struttura interna degli agenti dett

internal state

attribute

value

Working memory

script

script

script

attribute

value

local data

behavior

La struttura interna degli agenti (dett.)

script

LinguaggixCoord&Coop

la sintassi del linguaggio di coordinamento acl
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

tre ruoli utente
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

la struttura di abaco architettura
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

ciclo di interazione tra attore umano ed agenti architettura

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

principi di base per la creazione e definizione di ta
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

creazione di template agents

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

definizione di template agents cont
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

definizione di template agents cont1

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

definizione di template agents cont2

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

definizione di template agents
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

assegnamento di attori a ruoli

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

creazione di costellazioni

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

una semantica per acl cont
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

una semantica per acl

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

conclusioni
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

il ciclo di vita per progettare supporti al coordinamento

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