Università degli Studi di L’Aquila

Università degli Studi di L’Aquila

DALIDALI

Logic Programming LanguageLogic Programming Language

Dali: un linguaggio logico per Agenti Dali: un linguaggio logico per Agenti

e Sistemi Multiagentee Sistemi Multiagente

“Un agente e’ una entita’ software situata in un ambiente,capace di azioni autonome allo scopo

di raggiungere i propri obiettivi”

DALI

Caratteristiche di DALI:

• Classi di eventi e loro interazione:• Eventi esterni

• Eventi interni

• Eventi del presente

• Eventi del passato

• Azioni

• Interfogliamento delle attivita’

• Priorita’ nelle azioni

• Priorita’ negli eventi

• Gestione dei goals nel planning

• Memoria

Dali: gli eventi esterni e del Dali: gli eventi esterni e del presentepresente“E' la relazione con l'ambiente a determinare la

configurazione del sistema cognitivo di un organismo” (Maturana)

Stage 1: reazione all’eventoFunzione: si innesca la reazioneall’evento secondo le direttive

specificatedalla regola reattiva contenuta nelprogramma logico DALI. suona_la_svegliaE:>mi_alzoA

Stage 2: dopo la reazione, l’ agente e’ capace di ricordare l’evento esterno.

Funzione: ragionamento su cosa e’ accaduto nel passato. sono_pigro:-suona_la_svegliaP

not(mi_alzoP) sono_pigroI:> prendo_un_giorno_di_ferieA

Un evento del presente fa’ in modo che il processo di reazione ad un evento interno venga ‘anticipato’ da un processo di ragionamento (tipico degli eventi interni). Cio’ garantisce la distinzione tra ragionamento sugli eventi e reazione agli eventi!arriva_qualcuno:-suona_il_campanelloN.arriva_qualcunoI:>mi_vestoA.mi_vesto:< sono_svestitoP.suona_il_campanelloE:>apro_la_portaA

Gli eventi esterni vengono processati sulla base della loro priorita’ (alta o normale).

Gli eventi ad alta priorita’ hanno precedenza assoluta sugli altri.

Dali: gli eventi interniDali: gli eventi interni

“Gli agenti riflettono”

Un evento interno puo’ corrispondere ad una azione.

Piu’ eventi interni possono essere correlati scatenando inferenze successive!

Un evento interno e’ una conclusione raggiunta dall’agente alla quale l’agentereagisce similarmente ad un evento esterno!

Le conclusioni interne scatenano la proattivita’ dell’agente!

Stage1: le condizioni di innesco (eventi interni o esterni a cui l’agente ha reagito,azioni compiute,conoscenza,…) sono tutte true, si scatena la reazione

Stage2: dopo la reazione, l’agente e’ capace di ricordare l’evento interno

cucino:-acceso_gasP, metto_pentola_sul_gasP, minuti_cottura(25),passati_minuti(25). cucinoI:>tolgo_pentola_dal_gasA,spengo_gasA.

Il “comportamento” di un evento interno e’ determinato dalle direttive dell’utente:• ogni quanto tempo tentare l’evento;• quante volte ad un evento si deve reagire:

• forever• una volta, due volte,...

e quando:• in assoluto• quando “cambia” una determinata condizione di innesco

• fino a quando (forever, fino ad un certo tempo, fino ad una certa condizione)

Dali: gli eventi interni Dali: gli eventi interni (1)(1)

“Concatenare il pensiero e dedurre...”

sintomo1('demo1/knowledge/log.txt',H1,Time):-findall(str(AT,D),clause(log(_,_,_,AT,_,_,D,_),_),L), length(L,Lu),Lu>5,remove_duplicates(L,L1), member(M,L1),arg(1,M,H1),arg(2,M,Time), carica_fileP('demo1/knowledge/log.txt',_).

sintomo1('demo1/knowledge/log.txt',H1,Time):-findall(str(AT,D),clause(log(_,_,_,AT,_,_,D,_),_),L), length(L,Lu),Lu>5,remove_duplicates(L,L1), member(M,L1),arg(1,M,H1),arg(2,M,Time), intervalloP(_).

sintomo1I(X,H1,Time):>write(sintomo_uno(X,H1,Time)),nl.

sintomo2(T):-carica_fileP(_,_),datime(T),arg(4,T,H),H>=9.sintomo2(T):-carica_fileP(_,_),datime(T),arg(4,T,H),H=<8.sintomo2I(T):>write(sintomo_due(T)),nl.

sintomo3(X):-carica_fileP(X,_),datime(T),arg(4,T,H),H<9,H>8.sintomo3(_):-intervalloP(_),datime(T),arg(4,T,H),H<9,H>8.sintomo3I(X):>write(sintomo_tre(X)),nl, clause(agent(A),_), messageA(manager,inform(changed_time(X),A)).

attacco1(P,date(A,Me,G),time(O,M)):-sintomo2P(T), arg(1,T,A),arg(2,T,Me),arg(3,T,G), arg(4,T,O),arg(5,T,M), clause(log(_,_,P,_,_,_,date(A,Me,G),time(O,M1,_)),_),M-2=<M1,M1<M+3.

attacco1I(P,date(A,Me,G),time(O,M)):>clause(agent(Ag),_), messageA(manager,send_message(attacco1(P,date(A,Me,G),time(O,M,00)),Ag)).

attacco2(X,H,D):-sintomo1P(X,H,D).attacco2I(X,H,D):>clause(agent(A),_),trasf(X,K),trasf(H,H1), clause(log(_,_,_,H,_,_,D,T),_), messageA(manager,send_message(attacco2(H1,D,T,K),A)).

attacco3(H,D,_):-informP(avviso_attacco(H,D,_),_),ntrasf(H,H1),clause(log(_,_,H1,_,_,_,_,_),_).attacco3I(H,D,_):>clause(agent(A),_), messageA(manager,send_message(attacco3(H,D,_),A)).

Dali: gli eventi interni Dali: gli eventi interni (2)(2)

“Concatenare il pensiero e dedurre...”

“”

Dali: i goals Dali: i goals

Dali possiede due tipi di goals:

• goals che l’agente tenta di perseguire: Sono legati agli eventi interni. Quando un agente invoca un goal, attiva l’evento interno corrispondente che tenta le precondizioni. Se quest’ultime diventano vere, si attiva il piano.

• goals che l’agente verifica se “eseguiti”

Quando un agente trova un goal da “testare” verifica se vi e’ il corrispondente evento del passato o un fatto.

I goals da ottenere sono trattati come eventi interni. Se raggiunti, sono ricordati dall’ agente come eventi del passato.

goE:>put_shoesG.put_shoes:-put_right_shoeG,put_left_shoeG,right_shoe_onP,left_shoe_onP.put_shoesI:>left_and_right_shoes_onA,retractall(past(_,_,_)).

put_right_shoe:-put_right_sockG,right_sock_onP.put_right_shoeI:>right_shoe_onA.

put_left_shoe:-put_left_sockG,left_sock_onP.put_left_shoeI:>left_shoe_onA.

put_right_sock:-have_right_sockP.put_right_sockI:>right_sock_onA.

put_left_sock:-have_left_sockP.put_left_sockI:>left_sock_onA.

STRIPS e DALI: planningSTRIPS e DALI: planning“L’idea dello STRIPS planner e’ dividi e conquista:per creare un piano per ottenere un insieme di goals,occorre creare un piano per ottenere un goal ed un piano per ottenere il resto”

Facciamo la spesa...con DALI

vaiE:>sono_a_casaA,compra_tuttoG.compra_tutto:-procura_bananaG,procura_latteG,vai_a_casaG,pago_bananaP,pago_latteP,sono_a_casaP.compra_tutto:-procura_chiodiG,vai_a_casaG,pago_chiodiP,sono_a_casaP.

compra_tuttoI:>acquisto_tuttoA.

procura_banana:-vai_al_supermercatoG,compra_bananaG,sono_al_supermercatoP,compro_bananaP.procura_bananaI:>pago_bananaA....

procura_chiodi:-vai_alla_ferramentaG,compra_chiodiG,sono_in_ferramentaP,compro_chiodiP.procura_chiodiI:>pago_chiodiA.

vai_al_supermercato:-sono_a_casaP,isa(supermercato_aperto).vai_al_supermercato:-sono_in_ferramentaP,isa(supermercato_aperto).vai_al_supermercatoI:>sono_al_supermercatoA.

vai_alla_ferramenta:-sono_al_supermercatoP.vai_alla_ferramenta:-sono_a_casaP.vai_alla_ferramentaI:>sono_in_ferramentaA.

vai_a_casa:-sono_in_ferramentaP.vai_a_casa:-sono_al_supermercatoP.vai_a_casaI:>sono_a_casaA.

compra_banana:-sono_al_supermercatoP.compra_bananaI:>compro_bananaA....compra_chiodi:-sono_in_ferramentaP.compra_chiodiI:>compro_chiodiA.

“”

Dali: la comunicazione e le azioni Dali: la comunicazione e le azioni

Atomi azione rappresentano in DALI le azioni. Le azioni hanno:

Sempre successo se non hanno precondizioni

Hanno successo solo quando la condizione e’ true, se hanno precondizioni.

L’interprete DALI, quando una azione e’ true,la pone in coda in attesa di essere ripresa ed eseguita. Cio’ permette il controllo sulle azioni ed evita che una azione venga compiuta quando il contesto non lo permette (servire una birra se le birre sono finite!). Quando cio’ accade l’azione viene rimessa in coda in attesa che il contesto la renda ammissibile. Se questo non accade l’agente la elimina.

Nel linguaggio logico DALI le azioni sono ettichettate con una A e possono essere:

• una azione semplice (scritta sullo schermo o su un file)• un messaggio inviato ad altri agenti (con il suffisso message)

LE AZIONI POSSONO AVERE PRIORITA’ ALTA O NORMALE!

suona_il_campanelloE(gino)):>apro_la_portaA, messageA(gino,send_message(ciao,pippo)).

“"risolvere" un problema equivale a "comprenderlo"; e "comprendere" significa, in ultima analisi, ricondurre la situazione presente a una

situazione gia' nota del passato”

Dali: gli eventi del passato Dali: gli eventi del passato

EVENTI

DEL

PASSATO

Eventi esterni e del presente

Eventi interni

Azioni

Goals

Reazione

sunny_weatherE :> open_the_windowA.

rainy_weatherE:>close_the_windowA

open_the_window:<close_the_windowP

close_the_window:< open_the_windowP

Il periodo di tempo in cui un evento del passato viene “ricordato” e’ anch’esso definito dalle direttive dell’utente:

• forever• fino ad un certo tempo (until_time)• fino a quando si verifica una data condizione (until_cond)

GUSCIO DALI

Elabora,estrae e gestisce gli eventi, le azioni, le regole e la comunicazione dell’agente DALI in esso contenuto

PROGRAMMA LOGICO DALI

Descrive il comportamento dell’agente utilizzando la sintassi del linguaggio logico DALI

Agente

DALI 2

Agente

DALI 3

Agente

DALI 1

Agente

DALI n

LINDA PRIMITIVE COMMUNICATION

Dali: la architettura multiagente Dali: la architettura multiagente

Tuples Space

ProcessingEventiAzioni Goals

La architettura di un agente DALILa architettura di un agente DALI

Pre-processing file.txt

Comunicazione

Comunicazione

I files di un agente DALII files di un agente DALI

file.txt

file.ple

File.plf

file.pl

Le liste del file pleLe liste del file ple

[invitation,sega_la_legna,set,get,notify,call,ack,reply,return].

[go_by_car,wait_ack(DestAgent,TimeStamp,SeqId,AckContent),wait_reply(DestAgent,TimeStamp,SeqId,VarName,VarValue),…].

[go_by_car,take_the_bus,ask_susan_to_join,aiuto(X),message(To,set(A,T,SeqId,VarName,VarValue)),message(To,get(A,T,SeqId,VarName)),…].

[go_by_car].

[].

[].

[].

[].

Eventi esterni

Eventi interni

Azioni

Condizioni

Eventi del presente

Goals da ottenere

Goals da testare

Fatti da ricordare

Il ‘naming’ del file plIl ‘naming’ del file pl

eve(predator_attacks(var_X)):-once(try_to_escape(var_X)).

try_to_escape(var_X):-a(fly(var_X)).

try_to_escape(var_X):-a(run(var_X)).

cd(fly(var_X)):-evp(bird(var_X)),not(evp(abnormal(var_X))).

Le direttive del file plfLe direttive del file plf

action(Azione,normal). action(Azione,high).

external_event(Evento_esterno,normal).

past_event(Evento/Azione,20).

mod(Evento_esterno,check).

internal_event(Evento_interno,3,forever,true,until_cond/until_date(Condizione/Data)).

internal_event(Evento_interno,3,1,change([]),forever).

La comunicazione in DALI

Percezione ed azionePercezione ed azione

Un agente è un oggetto attivo con la capacità di percepire, ragionare ed agire.

Assumiamo che:

• un agente ha una KB ed un meccanismo per fare inferenza sulla sua conoscenza

• un agente ha la CAPACITA’ di COMUNICARE

parte PERCEZIONE(ricevere messaggi)

parte AZIONE(inviare messaggi)

Cooperare o competere?Cooperare o competere?

La comunicazione permette agli agenti di coordinare le loro azioni ed il loro comportamento.

La coordinazione è una proprietà di un sistema di agenti che compiono una certa attività in un ambiente condiviso.

La COOPERAZIONE è una coordinazione tra agenti non antagonisti mentre la NEGOZIAZIONE è una coordinazione tra agenti competitivi o interessati a se stessi.

COORDINAZIONE

Cooperazione Competizione

Planning Negoziazione

Obiettivo

dotare il linguaggio di un robusto protocollo di comunicazione capace di fornire agli agenti opportune primitive per cooperare

assicurare un 'filtro' sui messaggi in ingresso ed in uscita in modo da proteggere le entità software da atti comunicativi dannosi

introdurre un livello di meta-ragionamento per agevolare l’interpretazione dei messaggi

Nuova architettura degli agenti Dali

Filtro comunicazione

Metaragionamento

Interprete

Progr.Logico

Dali

Filtro comunicazione

Metaragionamento

Interprete

Progr.Logico

Dali

Messaggi

L’architettura DALI precedente ha subito notevoli variazioni passandoda un unico strato a tre strati consistenti in :

filtro sulla comunicazione e protocollo; applicazione del meta ragionamento con supporto di ontologie; interprete

Difendere gli agenti… In un progetto di cooperazione tra agenti intelligenti è

necessario tenere il più possibile sotto controllo il processo di comunicazione. Un agente, se non opportunamente ‘difeso’, può essere soggetto a danneggiamenti della base di conoscenza o delle regole comportamentali.

Talvolta, però, può accadere che un agente invii ad un altro un messaggio con contenuto sbagliato arrecando volontariamente o involontariamente un enorme danno. Come riconoscere un messaggio giusto da uno sbagliato?

Il filtro Dali

Come riconoscere un messaggio giusto da uno sbagliato? Il filtro adottato in DALI cerca di rispondere, per quanto possibile, a questo quesito.

Quando un messaggio viene recepito, esso viene sottoposto ad un check fornito da una struttura altamente modificabile dall’utente ed adeguabile al contesto.

Tale struttura controlla che i campi del messaggio rispondano ai vincoli imposti dal programmatore, altrimenti il messaggio viene cancellato non producendo alcun effetto.

I vincoli sui messaggi in ingresso

Le direttive sul filtro sono contenute nel file ‘communication.txt’ accessibile direttamente dall’utente. Ciò evita di dover cambiare ogni volta il codice dell’interprete.

told(Ag,tipo_messaggio(_)):-constraint1,constraint2,...,constraintn.

I vincoli sui messaggi in ingresso

told(Sender_agent,send_message(Evento_esterno)):- not(evp(inaffidabile(Sender_agent))), interessato_a(Evento_esterno).

told(Sender_agent,execute_proc(Procedure)):- not(evp(inaffidabile(Sender_agent))), conosco(Procedura).

told(Sender_agent,query_ref(Proposizione,3)):- not(evp(inaffidabile(Sender_agent))), carina(Sender_agent).

I vincoli sui messaggi in uscita

Le condizioni di filtro dei messaggi in uscita sono contenute

sempre nel file ‘communication.txt’ ma hanno ‘tell’ come suffisso:

tell(To,From,type_message(_)):- constraint1,...,constraintn.

tell(To,_,send_message(_)):- not(evp(enemy(To))).

Applicazione del meta-ragionamento e delle ontologie

In un sistema multi-agente dove più entità software cooperano alla realizzazione di un obiettivo, come ad esempio la sicurezza di un settore, non tutti i componenti parlano la stessa lingua ma, anche all’interno della stessa lingua, non tutti utilizzano le stesse parole per esprimere un dato concetto.

In questo caso si può istruire l’agente ad applicare un processo di ‘ragionamento’ che lo induca a capire se la situazione che sta incontrando è riconducibile ad una già conosciuta.

Cosa è una ontologiaUna ONTOLOGIA è una specifica degli oggetti, concetti

erelazioni in una area di interesse. Una ontologia include:

proposizioni vere o false indipendentemente da un certo individuo;

Proprietà di singoli individui ;

Relazioni tra coppie di individui o più individui. dove per individuo si intende qualsiasi cosa: gente,

colori, emozioni, numeri,…

L’utilizzo di una ontologia

Supponiamo di avere la seguente regola reattiva.

caso1E(X):>azione1A(X),azione2A(X).

Se l’agente sà che caso1 è semanticamente equivalente a caso2, può rispondere all’evento esterno caso2 pur conoscendo soltanto caso1.

Che caso1 sia equivalente a caso2 può essere una informazione data a run-time dall’agente che invia il messaggio al destinatario oppure può essere contenuto nell’ ontologia associata all’agente che riceve il messaggio.

Il livello di meta-ragionamento

Il ragionamento su una asserzione o chiamata ad evento esterno è stato ottenuto tramite la procedura ‘meta’ agganciata tra lo strato superiore di check e quello inferiore dell’interprete vero e proprio.

Tale procedura è contenuta nel file ‘communication.txt’ e può essere modificata dall’utente senza intaccare il codice dell’interprete. Ciò permette di aggiungere potenzialità a livello di meta-ragionamento in un agente senza avere conoscenze troppo approfondite sull’intero sistema.

Come è fatto il meta-ragionamento…

meta(Initial_term,Final_term,Agent_Sender):-clause(agent(Agent_Receiver),_),functor(Initial_term,Functor,Arity),Arity=0,((ontology(Agent_Sender,Functor,Equivalent_term);ontology(Agent_Sender,Equivalent_term,Functor));(ontology(Agent_Receiver,Functor,Equivalent_term);ontology(Agent_Receiver,Equivalent_term,Functor))),Final_term=Equivalent_term.

meta(Initial_term,Final_term,Agent_Sender):-functor(Initial_term,Functor,Arity),Arity=2,symmetric(Functor),Initial_term=..List,delete(List,Functor,Result_list),reverse(Result_list,Reversed_list),append([Functor],Reversed_list,Final_list),Final_term=..Final_list.

piove

cade_acqua

ama(pippo,pina)

ama(pina,pippo)

send_message_to(anne,inform(query_ref(ama(gina,fdvar_6),1),motivation(no_values),pippo),italian,[])

send_message_to(anne,inform(query_ref(ama(gina,fdvar_7),1),values([ama(pippo,gina)]),pippo),italian,[])

Come è fatto il meta-ragionamento…Insert name of Receiver|: pippo.Insert Language|: italian.Insert Ontology|: [].Insert name of Sender|: pino.Insert message|: confirm(ama(pippo,gina),pino).

Insert name of Receiver|: pippo.Insert Language|: italian.Insert Ontology|: [].Insert name of Sender|: anne.Insert message|: query_ref(ama(gina,X),anne).

Anne

Pippo

Protocollo di comunicazione

Ci sono diversi protocolli attraverso i quali gli agenti possono comunicare. Uno di essi è il protocollo FIPA (http://www.fipa.org/) che è basato sul concetto di messaggio. I messaggi sono inviati avanti ed indietro tra un agente sender ed un agente receiver ed hanno una specifica strutturazione.

FIPA disciplina tutti gli atti comunicativi e definisce anche quali messaggi il receiver può inviare in risposta ad un dato messaggio

Il protocollo FIPA

Seguendo il protocollo di base FIPA, l'unità di comunicazione di DALI ha assunto la seguente struttura:

receiver: nome dell'agente che riceve il messaggio (lo stesso del file di attivazione);

language: il linguaggio per mezzo del quale il messaggio è espresso;

ontology: l'ontologia adottata dall'agente sender per interpretare il messaggio;

sender: nome dell'agente che invia il messaggio; content: contenuto del messaggio.

Primitive Dali e primitive FIPA

Il nuovo interprete Dali vede il protocollo di comunicazione come due librerie. Ciò permette di associare ad un agente protocolli diversi senza modificare il codice interno dell’interprete variando semplicemente due files: ‘communication.txt’ dove si trova il check ed il file ‘communication_fipa.pl’ che contiene le primitive di comunicazione.

Dali ha adottato, al momento, diverse tipologie di messaggi FIPA aggiungendone alcuni fuori dal protocollo data la particolarità degli agenti Dali. Il protocollo FIPA, infatti, disciplina la comunicazione tra agenti che cooperano allo svolgimento di obiettivi visti come sequenze di azioni.

Send_message (DALI)

Permette ad un agente Dali di inviare un messaggio ad un altro agente allo scopo di attivare una regola reattiva tramite un evento esterno.

Un evento esterno nel linguaggio Dali è un messaggio o uno stimolo ambientale di cui l’agente prende atto e a cui risponde applicando la corrispondente regola reattiva nel suo programma logico, se la possiede.

La sintassi del send_message per inviare un evento esterno da modulo utente è:

send_message(Evento_esterno, Agente_sender)

Send_message (DALI)

predator_attacksE(X):>once(try_to_escape(X)).try_to_escape(X):-flyA(X).try_to_escape(X):-runA(X).fly(X):<birdP(X),not(abnormalP(X)).

make(run(penguin),96328)make(fly(duck),147492)

New messageInsert name of addressee|: animal. … Insert message|: confirm(bird(duck),pippo).New message…Insert From|: pippo. Insert message|:send_message(predator_attacks(duck),pippo).

Propose (FIPA)

Identifica l’azione di sottomettere da parte di un agente ad un altro la proposta di compiere una certa azione date alcune precondizioni.

Le precondizioni sono inserite all’interno di una lista aggregata al messaggio.

La nuova strutturazione permette ad un agente Dali di

chiedere ad un altro l’esecuzione di una singola azione, senza invocare alcuna regola, purchè questa azione sia conosciuta dall’agente e quindi inserita all’interno del programma logico.

Propose L’accettazione della proposta di compiere una azione è

legata alla verifica delle condizioni relative al messaggio. Se esse sono vere, l’agente che ha ricevuto il propose, invierà un messaggio all’agente proponente dicendo di accettare la proposta, altrimenti la rifiuterà.

Ogni azione Dali è sottoposta alla verifica delle precondizioni all’azione interne al programma logico.

La sintassi del propose per il modulo utente è:

propose(Action,[condizione1,…,condizionen], Agente_sender)

Accept-proposal (FIPA)

Identifica l’atto di accettare la proposta di compiere una azione da parte di un agente ed è strettamente legato all’atto comunicativo propose.

Questo comando è interno al processo di comunicazione e la sua sintassi è:

message(Ag_receiver, accept_proposal(Azione_accettata, [condizione1…,condizionen], Agente_sender))

dove le condizioni possono essere delle eventuali richieste

insite nell’accettazione della proposta.

Reject-proposal (FIPA)

Identifica l’atto di rifiutare la proposta di compiere una azione da parte di un agente ed è strettamente legato all’atto comunicativo propose.

Questo comando è interno al processo di comunicazione e la sua sintassi è:

message(Agente_receiver, reject_proposal(Azione_rifiutata, [ragione1,…,ragionen], Agente_sender))

dove le ragioni possono essere delle eventuali motivazioni del rifiuto della proposta.

Failure (FIPA)

Identifica l’atto di dire ad un altro agente che una azione è stata tentata ma il tentativo è fallito.

Ciò accade quando, pur avendo accettata la proposta di compiere una azione, un agente verifica che le condizioni interne al programma logico non la permettono.

La sintassi di tale primitiva è:

message(Agente_receiver,failure(Azione_fallita,motivation(Motivo), Agente_sender))

Propose dangerE:>once(ask_for_help).ask_for_help:-call_policeA.call_police:<have_a_phoneP.ask_for_help:-screamA.

send_message_to(pippo,reject_proposal(call_police,[],pippo),italian,[])

New messageInsert name of addressee|: pippo. Insert Language|: italian. Insert Ontology|: []. Insert From|: pippo. Insert message|: propose(call_police,[near_home],pippo).


send_message_to(pippo,failure(call_police,motivation(false_conditions),pippo),italian,[])

New messageInsert name of addressee|: pippo. Insert Language|: italian. Insert Ontology|: []. Insert From|: gino. Insert message|: propose(call_police,[],gino).

Cancel (FIPA)

Identifica la richiesta di cancellare una certa azione ordinata da un agente.

Nel caso di un agente Dali con un numero di eventi ed azioni limitate, la richiesta di compiere una azione viene eseguita in tempi relativamente più brevi di quelli dell’arrivo di una richiesta di cancellazione.

la cancellazione della azione avviene sia dalla coda ad alta priorità che da quella a priorità normale.

La sintassi del comando è: message(Agente_receiver,cancel(Azione_canc, Ag_sender))

dangerE:>once(ask_for_help).ask_for_help:-call_policeA.call_police:<have_a_phoneP.ask_for_help:-screamA.

New messageInsert name of addressee|: pippo. Insert Language|: italian. Insert Ontology|: []. Insert From|: anne. Insert message|: cancel(call_police,[],anne).

Cancel (FIPA)

Execute_proc (DALI)

Questo atto comunicativo riguarda la chiamata di semplici procedure all’interno del programma logico Dali.

Il codice non si limita ad invocare il check ma fa riferimento allo strato del meta-ragionamento ed alle ontologie.

La sintassi da modulo utente e’: execute_proc(Procedura, Agente_sender)

Query_ref (FIPA)

Indica l’atto di domandare ad un altro agente se conosce uno o un insieme di fatti che dimostrano la proprietà richiesta.

Come primo argomento il query_ref prende la proprietà richiesta, come secondo accetta un numero che è il limite sul numero di matching che un agente si aspetta di ottenere.

La sintassi di questo atto comunicativo per il modulo utente è:

query_ref(Proprietà,N,Agente_sender)

…

New messageInsert name of addressee|: pippo. …Insert From|: pino. Insert message|: confirm(vado(domani,montagna),pino). New messageInsert name of addressee|: pippo. …Insert From|: anne.Insert message|: query_ref(vado(Y,montagna),1,anne).

send_message_to(anne,inform(query_ref(vado(montagna,fdvar_1),1),motivation(no_values),pippo),italian,[])send_message_to(anne,inform(query_ref(vado(fdvar_3,montagna),1),values([vado(domani,montagna)]),pippo),italian,[]) …

Query_ref (FIPA)

past(inform(query_ref(vado(montagna,fdvar_1),1),motivation(no_values),pippo), 479379, pippo).

??? Non ho nell’ontologia che vado è simmetrico!

…

New messageInsert name of addressee|: pippo. …Insert From|: pino. Insert message|: confirm(vado(domani,montagna),pino). New messageInsert name of addressee|: pippo. …Insert From|: anne.Insert message|: query_ref(vado(Y,montagna),1,anne).

send_message_to(anne,inform(query_ref(vado(montagna,fdvar_4),1),values([vado(domani,montagna)]),pippo),italian,[])

Query_ref (FIPA)

past(inform(query_ref(vado(montagna,fdvar_4),1),values([vado(domani,montagna)]),pippo), 59946, pippo).

symmetric(vado).

Inform (FIPA)

L’atto di chiedere ad un agente se conosce la proposizione contenuta nell’agree.

La sintassi di questa primitiva prevede che la proposizione di cui si domanda la conoscenza sia un atomo ground.

La sintassi da modulo utente è: inform(Proposizione,Agente_sender)

Refuse (FIPA)

Indica l’atto di rifiutare qualcosa o una data azione. Questo comando,interno al protocollo di

comunicazione, ha la seguente sintassi: refuse(Cosa_rifiutata,Agente_sender)

Il codice del refuse prevede, dopo il check, la memorizzazione come evento del passato del rifiuto.

Confirm (FIPA)

L’agente sender informa il receiver che una data proposizione è vera. La proposizione viene asserita come evento del passato.

A livello di codice abbiamo il richiamo al check e l’asserzione, come evento del passato, della proposizione contenuta nel confirm.

La sintassi del confirm da modulo utente è:

confirm(Proposizione,Agente_sender)

Disconfirm (FIPA)

L’agente sender informa il receiver che una data proposizione è falsa. La proposizione viene ritratta da evento del passato.

A livello di codice abbiamo il richiamo al check e la ritrazione, da evento del passato, della proposizione contenuta nel disconfirm.

La sintassi del disconfirm da modulo utente è: disconfirm(Proposizione,Agente_sender)

Agree

Indica l’atto di domandare ad un altro agente se conosce un fatto.

A livello di codice abbiamo il richiamo al check ed al livello del meta ragionamento.

La sintassi del disconfirm da modulo utente è: agree(Proposizione,Agente_sender)

…

New messageInsert name of addressee|: pippo. …Insert From|: anne. Insert message|: confirm(asserisci(questo),anne).New messageInsert name of addressee|: pippo. …Insert From|: anne. Insert message|: agree(asserisci(questo),anne).

send_message_to(anne,inform(agree(asserisci(questo)),values(yes),pippo),italian,[])

past(inform(agree(asserisci(questo)),values(yes),pippo), 53827, pippo).

Agree

Invio di messaggi FIPA

Parallelamente alla funzionalità di ricevere messaggi seguendo il protocollo FIPA, gli agenti Dali sono in grado di inviare messaggi aderenti al suddetto protocollo.

La sintassi dell’invio del query_ref è:

send(To,query_ref(X,N,Ag)):-

tell(To,Ag,query_ref(X,N)),send_m(To,query_ref(X,N,Ag)).

Generare un agente Dali

In questa nuova versione di DALI si è deciso di attivare un agente per mezzo di un file di testo che contiene i dati necessari.

La stringa rende anche automatico il processo di attivazione di un agente permettendo di rigenerare automaticamente il processo o di delegare il compito ad altre entità software.

agent('dali examples/agent',pino,'pino_ontology.txt',italian,[lira,communication_fipa,communication],liraMode(local,classpath,host,port,agent_name,ClassJavaName)).

esempi

The Dali Interpreter

Initialization of server:Aprire la shell di Sicstus Prolog e caricare il file ‘active_server.pl’.

Initialization of user module:Aprire una shell di Sicstus Prolog e caricare il file ‘active_user.pl’.Il modulo si mettera’ in attesa dei dati relativi all’invio di un messaggio. I dati richiesti saranno:

- Il nome dell’agente destinatario del messaggio;- Il linguaggio in cui viene espresso il contenuto del messaggio: italian, english,...- L’ontologia adottata;- Il nome dell’agente che invia il messaggio;- Il contenuto del messaggio;

Insert name of addressee|: pippo.Insert Language|: italian.Insert Ontology|: [].Insert From|: pino.Insert message|:send_message(rain,pino).

Insert name of addressee|: pippo.Insert Language|: italian.Insert Ontology|: [piove,cade_acqua].Insert From|: pino.Insert message|:send_message(rain,pino).


La sintassi dei messaggi corrrisponde a quella del protocollo adottato: FIPA nel nostro caso! Qualche esempio:

- Chiamare una regola reattiva con il send_message: send_message(arriva(X),gino)

- Comunicare un fatto ad un agente con il confirm: confirm(piove(oggi),pippo).

- Proporre una azione con il propose: propose(vai_alla_stazione,mamma).

- Invocare una procedura all’interno del programma logico con execute_proc: execute_proc(aggiorna(Y),pluto).


Inizializzazione di un agente Dali:

Aprire una shell di Sicstus Prolog e caricare il file ‘lida.pl’.L’interprete chiederà il nome del file di inizializzazione dell’ agente Dali:

Inserire il percorso ed il nome del file di inizializzazione:|:’pippo.txt’.

Il file di inizializzazione è un file di estensione txt che contiene la stringa con i dati dell’agente Dali da generare:

agent('dali demo/anne',anne,'anne_ontology.txt', italian,[communication,communication_fipa],no).

Dali examples

AnneinvitationE:>once(go_out).go_out:-go_by_carA.go_by_car:<clause(car_available,_).go_out:-take_the_busA.go_by_carI:>ask_susan_to_joinA.

Directives for the interpreteraction(go_by_car,normal).action(take_the_bus,normal).action(ask_susan_to_join,normal).action(copri(_172364),normal).external_event(invitation,normal).external_event(piove,normal).external_event(arriva,normal).past_event(invitation,20).past_event(piove,20).past_event(arriva,20).past_event(go_by_car,20).past_event(take_the_bus,20).past_event(ask_susan_to_join,20).past_event(copri(_171544),20).internal_event(go_by_car,3,forever,true,until_cond(past(go_by_car))).

agent('dali demo/anne',anne,'anne_ontology.txt',italian,[communication,communication_fipa],no).

File name: anne.txt

Dali examples

Animalpredator_attacksE(X):>once(try_to_escape(X)).try_to_escape(X):-flyA(X).try_to_escape(X):-runA(X).fly(X):<birdP(X),not(abnormalP(X)).

Directives for the interpreter

File name: animal.txt

make(run(penguin),_)

make(fly(duck),_)

action(fly(_228740),normal).action(run(_228740),normal).external_event(predator_attacks,normal).past_event(predator_attacks,20).past_event(fly(_228039),20).past_event(run(_228039),20).

New messageInsert name of addressee|: pippo. Insert Language|: italian. Insert Ontology|: []. Insert From|: pino. Insert message|: confirm(bird(penguin),pino). New messageInsert name of addressee|: pippo. Insert Language|: italian. Insert Ontology|: []. Insert From|: pino. Insert message|: confirm(abnormal(penguin),pino).

Dali examples

Planner

goE:>put_shoesG.put_shoes:-put_right_shoeG,put_left_shoeG, right_shoe_onP,left_shoe_onP.put_shoesI:>left_and_right_shoes_onA, retractall(past(_,_,_)).

put_right_shoe:-put_right_sockG,right_sock_onP.put_right_shoeI:>right_shoe_onA.

put_left_shoe:-put_left_sockG,left_sock_onP.put_left_shoeI:>left_shoe_onA.

put_right_sock:-have_right_sockP.put_right_sockI:>right_sock_onA.

put_left_sock:-have_left_sockP.put_left_sockI:>left_sock_onA.

Directives for the interpreter

File name:shoes.txt

action(left_and_right_shoes_on,normal).action(right_shoe_on,normal).action(left_shoe_on,normal).action(right_sock_on,normal).action(left_sock_on,normal).external_event(go,normal).past_event(go,20).past_event(put_shoes,20).past_event(put_right_shoe,20).past_event(put_left_shoe,20).past_event(put_right_sock,20).past_event(put_left_sock,20).past_event(left_and_right_shoes_on,20).past_event(right_shoe_on,20).past_event(left_shoe_on,20).past_event(right_sock_on,20).past_event(left_sock_on,20).internal_event(put_shoes,3,forever,true,until_cond(past(put_shoes)))...

Dali examples

Anne e l’ontologia

grandinaE:>compro_un_ombrelloA, corro_a_casaA.

New messageInsert name of addressee|: anne.Insert Language|: italian. Insert Ontology|: []. Insert From|: pino. Insert message|: send_message(grandina,pino).New messageInsert name of addressee|: anne. Insert Language|: italian. Insert Ontology|: [grandina]. Insert From|: pino. Insert message|: send_messagee(cade_grandine,pino).New messageInsert name of addressee|: anne. Insert Language|: italian. Insert Ontology|: [grandina]. Insert From|: pino. Insert message|:send_message(cade_grandine,pino).

make(compro_un_ombrello,34890)make(corro_a_casa,34890)Eliminated message:not exists meta_rule for send_messagee(go,pino)From:pino:nb-kasko-eagle:1032 make(compro_un_ombrello,119343)make(corro_a_casa,119343)

Dali examples

PIPPO

File name: pippo.txt File name: pluto.txt

PLUTO

:-dynamic isa/3.conosciE(X):-messageA(pluto,agree(conosco(X),1,pippo)).

isa(ama(pippo,iole),45566,pippo).

amaE(X):-messageA(pippo,query_ref(ama(X,Y),1,pluto)).

send_message_to(pippo,query_ref(ama(pippo,fdvar_2),1,pluto),italian,[])

send_message_to(pluto,inform(query_ref(ama(pippo,fdvar_2),1),values([ama(pippo,iole)]),pippo),italian,[]).

Dali examples

PIPPO

File name: pippo.txt File name: pluto.txt

PLUTO

:-dynamic isa/3.conosciE(X):-messageA(pluto,agree(conosco(X),1,pippo)).

isa(ama(pippo,iole),45566,pippo).

amaE(X):-messageA(pippo,query_ref(ama(X,Y),1,pluto)).

send_message_to(pluto,agree(conosco(iole),pippo),italian,[])send_message_to(pluto,agree(conosco(iole),pippo),italian,[])

send_message_to(pippo,inform(agree(conosco(iole)),values(no),pluto),italian,[])send_message_to(pippo,inform(agree(conosco(iole)),values(yes),pluto),italian,[])

New messageInsert name of addressee|: pluto. …Insert message|: confirm(conosco(iole),pippo).

Dali examples

PIPPO ANNE

Insert name of addressee|: anne. Insert Language|: italian. Insert Ontology|: []. Insert From|: pippo. Insert message|: propose(take_the_bus,pippo).New messageInsert name of addressee|: anne. Insert Language|: italian. Insert Ontology|: []. Insert From|: pippo. Insert message|: propose(take_the_bus,[piove],pippo).New messageInsert name of addressee|: anne. Insert Language|: italian. Insert Ontology|: []. Insert From|: pino. Insert message|: confirm(piove,pino).

Eliminated message:not exists meta_rule for propose(take_the_bus,pippo)From:pippo:nb-kasko-eagle:1032send_message_to(pippo,reject_proposal(take_the_bus,[],anne),italian,[])send_message_to(pippo,accept_proposal(take_the_bus,[],anne),italian,[])

Dali examples

PIPPO ANNENew messageInsert name of addressee|: anne. Insert Language|: italian. Insert Ontology|: []. Insert From|: pippo. Insert message|:propose(take_the_bus,[piove],pippo).New messageInsert name of addressee|: anne. Insert Language|: italian. Insert Ontology|: []. Insert From|: pippo. Insert message|: propose(go_by_car,[piove],pippo).

send_message_to(pippo,accept_proposal(take_the_bus,[],anne),italian,[])make(take_the_bus,224766)send_message_to(pippo,accept_proposal(go_by_car,[],anne),italian,[])send_message_to(pippo,failure(go_by_car,motivation(false_conditions),anne),italian,[])

New messageInsert name of addressee|: anne. Insert Language|: italian. Insert Ontology|: []. Insert From|: pippo. Insert message|: confirm(car_available,pippo).New messageInsert name of addressee|: anne. Insert Language|: italian. Insert Ontology|: []. Insert From|: pippo. Insert message|: propose(go_by_car,[piove],pippo).

Dali examples

PIPPO ANNE

send_message_to(pippo,accept_proposal(go_by_car,[],anne),italian,[])make(go_by_car,312094)make(ask_susan_to_join,312109)

past(failed_action(go_by_car,motivation(false_conditions),anne), 197047, anne).past(accepted_proposal(go_by_car,[],anne), 240344, anne).

Pippo

Anne

Università degli Studi di L’Aquila

Documents

Transcript of Università degli Studi di L’Aquila