La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

Università degli Studi di L’Aquila DALI Logic Programming Language Logic Programming Language.

Presentazioni simili


Presentazione sul tema: "Università degli Studi di L’Aquila DALI Logic Programming Language Logic Programming Language."— Transcript della presentazione:

1 Università degli Studi di L’Aquila DALI Logic Programming Language Logic Programming Language

2 Dali: un linguaggio logico per Agenti e 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

3 Dali: gli eventi esterni e del presente “E' la relazione con l'ambiente a determinare la configurazione del sistema cognitivo di un organismo” (Maturana) Stage 1: reazione all’evento Funzione: si innesca la reazione all’evento secondo le direttive specificate dalla regola reattiva contenuta nel programma logico DALI. suona_la_sveglia E :>mi_alzo A 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_sveglia P not(mi_alzo P ) sono_pigro I :> prendo_un_giorno_di_ferie A 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_campanello N. arriva_qualcuno I :>mi_vesto A. mi_vesto:< sono_svestito P. suona_il_campanello E :>apro_la_porta A Gli eventi esterni vengono processati sulla base della loro priorita’ (alta o normale). Gli eventi ad alta priorita’ hanno precedenza assoluta sugli altri.

4 Dali: 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’agente reagisce 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)

5 Dali: gli eventi interni (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= write(sintomo_due(T)),nl. sintomo3(X):-carica_fileP(X,_),datime(T),arg(4,T,H),H 8. sintomo3(_):-intervalloP(_),datime(T),arg(4,T,H),H 8. sintomo3I(X):>write(sintomo_tre(X)),nl, clause(agent(A),_), messageA(manager,inform(changed_time(X),A)).

6 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= 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 (2) “Concatenare il pensiero e dedurre...”

7 “” 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.

8 STRIPS 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.

9 “” 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)).

10 “"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 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:

11 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 Tuples Space

12 Processing Eventi Azioni Goals La architettura di un agente DALI Pre-processingfile.txt Comunicazione

13 I files di un agente DALI file.txt file.ple File.plf file.pl

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

15 Il ‘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))).

16 Le 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_co nd/until_date(Condizione/Data)). internal_event(Evento_interno,3,1,change([]),forever).

17 La comunicazione in DALI

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

19 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 CooperazioneCompetizione PlanningNegoziazione

20 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

21 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 passando da un unico strato a tre strati consistenti in : filtro sulla comunicazione e protocollo; applicazione del meta ragionamento con supporto di ontologie; interprete

22 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?

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

24 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(_)):- constraint 1,constraint 2,...,constraint n.

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

26 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(_)):- constraint 1,...,constraint n. tell(To,_,send_message(_)):- not(evp(enemy(To))).

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

28 Cosa è una ontologia Una ONTOLOGIA è una specifica degli oggetti, concetti e relazioni 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,…

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

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

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

32 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

33 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.http://www.fipa.org/ FIPA disciplina tutti gli atti comunicativi e definisce anche quali messaggi il receiver può inviare in risposta ad un dato messaggio

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

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

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

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

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

39 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,[condizione 1,…,condizione n ], Agente_sender)

40 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, [condizione 1 …,condizione n ], Agente_sender)) dove le condizioni possono essere delle eventuali richieste insite nell’accettazione della proposta.

41 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, [ragione 1,…,ragione n ], Agente_sender)) dove le ragioni possono essere delle eventuali motivazioni del rifiuto della proposta.

42 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,mot ivation(Motivo), Agente_sender))

43 Propose dangerE:>once(ask_for_help). ask_for_help:-call_policeA. call_police:

44 Propose dangerE:>once(ask_for_help). ask_for_help:-call_policeA. call_police:

45 Propose dangerE:>once(ask_for_help). ask_for_help:-call_policeA. call_police:

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

47 dangerE:>once(ask_for_help). ask_for_help:-call_policeA. call_police:

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

49 scrivi(X):-write(X),nl. New message Insert name of addressee |: anne. Insert Language |: italian. Insert Ontology |: []. Insert From |: pippo. Insert message |: execute_proc(scrivi(pippo),pippo). pippo Execute_proc (DALI)

50 scrivi(X):-write(X),nl. New message Insert name of addressee |: anne. Insert Language |: italian. Insert Ontology |: [scrivi]. Insert From |: pippo. Insert message |: execute_proc(scrivo(pippo),pippo). pippo Ontologia Execute_proc (DALI)

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

52 … New message Insert name of addressee |: pippo. … Insert From |: pino. Insert message |: confirm(vado(domani,montagna),pino). New message Insert 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,mo ntagna),1),values([vado(domani, montagna)]),pippo),italian,[]) … Query_ref (FIPA) past(inform(query_ref(vado(mon tagna,fdvar_1),1), motivation(no_values), pippo), , pippo). ??? Non ho nell’ontologia che vado è simmetrico!

53 … New message Insert name of addressee |: pippo. … Insert From |: pino. Insert message |: confirm(vado(domani,montagna),pino). New message Insert 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,f dvar_4),1), values([vado(domani,montagna)]), pippo),italian,[]) Query_ref (FIPA) past(inform(query_ref(vado(mon tagna,fdvar_4),1), values([vado(domani,montagna)] ),pippo), 59946, pippo). symmetric(vado).

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

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

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

57 … New message Insert name of addressee |: pippo. Insert Language |: italian. Insert Ontology |: []. Insert From |: anne. Insert message |: confirm(asserisci(questo),anne). past(asserisci(questo), , anne). Confirm (FIPA)

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

59 … New message Insert name of addressee |: pippo. Insert Language |: italian. Insert Ontology |: []. Insert From |: anne. Insert message |: disconfirm(asserisci(questo),anne). past(asserisci(questo), , anne). Confirm (FIPA)

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

61 … New message Insert name of addressee |: pippo. … Insert From |: anne. Insert message |: confirm(asserisci(questo),anne). New message Insert name of addressee |: pippo. … Insert From |: anne. Insert message |: agree(asserisci(questo),anne). send_message_to(anne, inform(agree(asserisci(questo)),val ues(yes),pippo),italian,[]) past(inform(agree(asserisci(questo) ),values(yes),pippo), 53827, pippo). Agree

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

63 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,comm unication_fipa,communication],liraMode(local,classpath,ho st,port,agent_name,ClassJavaName)).

64 esempi

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

66 The Dali Interpreter 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).

67 The Dali Interpreter 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).

68 Dali examples Anne invitationE:>once(go_out). go_out:-go_by_carA. go_by_car:ask_susan_to_joinA. Directives for the interpreter action(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,t rue,until_cond(past(go_by_car))). agent('dali demo/anne',anne,'anne_ontology.txt', italian,[communication,communication_fipa],no). File name: anne.txt

69 Dali examples File name: anne.txt USER MODULE make(take_the_bus,_) make(go_by_car,_) make(ask_susan_to_join,_) New message Insert name of addressee |: anne. Insert Language |: italian. Insert Ontology |: []. Insert From |: pino. Insert message |:send_message(invitation,pino). New message Insert name of addressee |: anne. Insert Language |: italian. Insert Ontology |: []. Insert From |: pino.Insert message |: confirm(car_available,pino). New message Insert name of addressee |: … Insert message |:send_message(invitation,pino).

70 Dali examples Animal predator_attacksE(X):>once(try_to_escape(X)). try_to_escape(X):-flyA(X). try_to_escape(X):-runA(X). fly(X):

71 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,u ntil_cond(past(put_shoes)))...

72 Dali examples USER MODULE make(right_sock_on,_) make(right_shoe_on,_) make(left_sock_on,_) make(left_shoe_on,_) make(left_and_right_shoes_on,_) New message Insert name of addressee |: pippo. Insert Language |: italian. Insert Ontology |: []. Insert From |: pino. Insert message |: confirm(have_left_sock,pino). New message Insert name of addressee |: pippo. Insert Language |: italian. Insert Ontology |: []. Insert From |: pino. Insert message |: confirm(have_right_sock,pino). New message Insert name of addressee |: pippo. Insert Language |: italian. Insert Ontology |: []. Insert From |: pino. Insert message |: send_message(go,pino).

73 Dali examples Anne e l’ontologia grandinaE:>compro_un_ombrelloA, corro_a_casaA. New message Insert name of addressee |: anne. Insert Language |: italian. Insert Ontology |: []. Insert From |: pino. Insert message |: send_message(grandina,pino). New message Insert name of addressee |: anne. Insert Language |: italian. Insert Ontology |: [grandina]. Insert From |: pino. Insert message |: send_messagee(cade_grandine,pino). New message Insert 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)

74 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,[]).

75 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(iol e),pippo),italian,[]) send_message_to(pippo,inform(agree(con osco(iole)),values(no),pluto),italian,[]) send_message_to(pippo,inform(agree(con osco(iole)),values(yes),pluto),italian,[]) New message Insert name of addressee |: pluto. … Insert message |: confirm(conosco(iole),pippo).

76 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 message Insert name of addressee |: anne. Insert Language |: italian. Insert Ontology |: []. Insert From |: pippo. Insert message |: propose(take_the_bus,[piove],pippo). New message Insert 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:1032 send_message_to(pippo,reject_proposal(take_t he_bus,[],anne),italian,[]) send_message_to(pippo,accept_proposal(take_ the_bus,[],anne),italian,[])

77 Dali examples PIPPO ANNE New message Insert name of addressee |: anne. Insert Language |: italian. Insert Ontology |: []. Insert From |: pippo. Insert message |:propose(take_the_bus,[piove],pippo). New message Insert 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,moti vation(false_conditions),anne),italian,[])

78 New message Insert name of addressee |: anne. Insert Language |: italian. Insert Ontology |: []. Insert From |: pippo. Insert message |: confirm(car_available,pippo). New message Insert 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), , anne). past(accepted_proposal(go_by_car,[],anne), , anne). Pippo Anne


Scaricare ppt "Università degli Studi di L’Aquila DALI Logic Programming Language Logic Programming Language."

Presentazioni simili


Annunci Google