2 a g e n t <- g e n e r a t e N e x t R a n d o m r e t u r n s ID , 3 a s s e r t a ( i n t e n t i o n ( ID ,[ i S e n d ( ’ p o n g _ a g e n t ’ , ’ ping ’ ) ]) ) , 4 a g e n t <- i n s e r t I n t e n t i o n ( ID ) . 5
6 ’ <- ’ ( o n R e c e i v e d M e s s a g e ( S , pong ) ,[ true ] ,[ i S e n d ( S , ping ) ]) . Codice sorgente 3.1: Agente Ping
3.3
Esempi linguaggio
In questa sezione verranno mostrate alcuni casi d’uso del linguaggio appena descritto. Nello specifico verr`a mostrato un primo scenario dove sono stati confi- gurati gli agenti per realizzare un semplice scambio di messaggi (o Ping Pong). Nel secondo esempio, invece, viene illustrato come poter utilizzare l’estensione Spatial Tuples supportata dal linguaggio.
Ping Pong
In questo primo esempio `e presentato il problema del Ping Pong. In questo esempio sono definiti due agenti, Ping e Pong, ognuno dei quali risponde ad un messaggio ricevuto. L’agente Ping, alla ricezione del messaggio ‘pong’ da parte dell’agente Pong risponder`a con un messaggio ‘ping’. Viceversa, l’agente Pong, alla ricezione del messaggio ‘ping’ da parte dell’agente Ping risponder`a con un messaggio ‘pong’.
Per far iniziare lo scambio di messaggi `e stato utilizzato ‘init’ per impostare all’interno di uno dei due agenti, nello specifico l’agente Ping, un’intenzione iniziale. In questo modo, al primo ciclo di ragionamento, l’agente eseguir`a l’intenzione e invier`a il primo messaggio.
In entrambe le teorie dei due agenti `e stata richiamata ‘iSend(S, M)’, dove S `e il destinatario e M `e il messaggio, che `e un’azione interna dichiarata e gestita nel- l’ambiente sul quale `e utilizzato il linguaggio. Nel Codice sorgente 3.1 viene inviato
1 init : -
2 true .
3
4 ’ <- ’ ( o n R e c e i v e d M e s s a g e ( S , ping ) ,[ true ] ,[ i S e n d ( S , pong ) ]) . Codice sorgente 3.2: Agente Pong
1 init : - 2 w r i t e T u p l e ( bb , msg ( bob , h e l l o ) ) , 3 w r i t e T u p l e ( bb , msg ( carl , h e l l o ) ) , 4 t a k e T u p l e ( bb , msg ( alice , X ) ) , 5 t a k e T u p l e ( bb , msg ( alice , X ) ) . 6 7 ’ <- ’ ( o n R e s p o n s e M e s s a g e ( msg ( X , Y ) ) ,[ true ] ,[ true ]) . Codice sorgente 3.3: Alice
all’agente Pong il messaggio ‘ping’, mentre nel Codice sorgente 3.2 il messaggio inviato all’agente Ping `e ‘pong’.
Message passing through Spatial Tuples
In questo esempio viene mostrato come possono essere utilizzate le primiti- ve del modello Spatial Tuples incorporate nel linguaggio descritto in precedenza. Nello specifico viene mostrato come tre agenti (Alice, Bob e Carl) comunicano tra loro inserendo messaggi negli spazi di tuple a loro vicini, usandoli come ‘lavagna’. L’agente Alice nel suo ciclo di configurazione, esegue due scritture sulla ‘lavagna’ (spazio di tuple) inserendo messaggi per Bob e Carl e successivamente effettua al- tre due richieste allo spazio di tuple richiedendo due messaggi a lei destinati senza conoscerne il contenuto. Una volta ricevuti i messaggi non fa niente.
L’agente Bob, nel suo ciclo di configurazione, effettua una richiesta allo spazio di tuple per ricevere messaggi a lui destinati. Inoltre, nella sua teoria, `e definito un comportamento in caso di ricezione del messaggio: manda ad Alice lo stesso
3.3 Esempi linguaggio 35 1 init : - 2 t a k e T u p l e ( bb , msg ( bob , X ) ) . 3 4 ’ <- ’ ( o n R e s p o n s e M e s s a g e ( msg ( bob , X ) ) , 5 [ true ] ,[ w r i t e T u p l e ( bb , msg ( alice , X ) ) ]) . Codice sorgente 3.4: Bob
1 init : -
2 t a k e T u p l e ( bb , msg ( carl , X ) ) .
3
4 ’ <- ’ ( o n R e s p o n s e M e s s a g e ( msg ( carl , X ) ) ,
5 [ true ] ,[ w r i t e T u p l e ( bb , msg ( alice , X ) ) ]) . Codice sorgente 3.5: Carl
messaggio che ha ricevuto.
Capitolo 4
AgentSpeak in tuProlog su
Alchemist
In questo capitolo verr`a esposta la parte di implementazione mancante nel capi- tolo precedente. Pi`u precisamente `e descritto come `e stato scelto di implementare il modello ad agenti su Alchemist, fornendo un’analisi del mapping, e di come `e stato utilizzato il linguaggio per definire l’interprete, scendendo nel dettaglio di come `e stata realizzata la gestione delle intenzioni, lo spostamento dell’agente e l’estensione Spatial Tuples. Ulteriori dettagli relativi all’implementazione verranno analizzati nel capitolo successivo.
La scelta della piattaforma `e ricaduta su Alchemist poich`e fornisce un meta- modello molto adattabile a vari ambiti applicativi e una struttura di simulazione gi`a consolidata ed efficace.
Come detto in precedenza `e possibile realizzare implementazioni del modello ad agenti utilizzando il linguaggio definito in questo lavoro di tesi anche sfruttando altre piattaforme che consentono di lavorare con la libreria tuProlog.
4.1
Mapping modelli
In precedenza sono stati descritti il modello ad agenti e il meta-modello di Alchemist. Ora, dopo aver definito il linguaggio, per procedere all’implementa-
zione `e necessario capire quale sia il migliore modo, in termini di performance e espressivit`a, per unire i due modelli. In questa fase si vuole quindi pensare come realizzare sul meta-modello fornito da Alchemist il modello ad agenti cercando eventuali incongruenze o opportunit`a per massimizzare il risultato.
Si `e partiti analizzando le entit`a del meta-modello e per ognuna `e stato posto l’interrogativo sul fatto che potesse rappresentare l’agente. Fin da subito sono state ritenute inadatte l’Environment e la Molecola: il primo perch`e `e esso stesso lo spazio e non avrebbe potuto rappresentare l’ambiente degli agenti; la Molecola perch`e fornisce un livello di dettaglio troppo elevato e non ha una struttura che consente di contenere lo stato dell’agente.
Le entit`a rimaste da analizzare sono quindi il Nodo e la Reazione, la quale contiene Condizioni e Azioni.
Mappando il Nodo come agente ne deriva che l’Environment corrisponder`a allo spazio degli agenti mentre, all’interno dell’agente, le Molecole e le relative Concentrazioni potranno essere utilizzate per gestire la ‘belief base’ e le Reazioni saranno riferite ai piani, utilizzando le Condizioni come clausola per scatenare le Azioni. Questo tipo di mapping consente di realizzare simulazioni di sistemi non complessi, in cui agenti allo stesso livello operano e comunicano tra loro.
Posizionando l’agente nella Reazione, quindi pi`u internamente rispetto al pre- cedente mapping, il Nodo diventer`a un contenitore di agenti e l’Environment lo spazio nel quale si muovono i nodi. Ogni agente avr`a il riferimento ad una Condi- zione e ad una Azione: quest’ultima conterr`a il ciclo di ragionamento dell’agente mentre la Condizione ne determiner`a la clausola di esecuzione (che in questo caso `e impostata per essere sempre vera e scatenare periodicamente l’azione). Utilizzan- do questa seconda ipotesi sar`a possibile realizzare simulazioni di sistemi complessi, nei quali dei nodi, che potrebbero essere dispositivi mobili (ad esempio cellulari), si muovo nello spazio ed ognuno al suo interno contiene un gruppo di agenti che possono interagire sia internamente che esternamente.
Dopo aver analizzato le due possibili alternative presentate, `e stato scelto il mapping in cui l’agente `e posizionato nella Reazione poich`e permette una maggiore espressivit`a e un’apertura verso pi`u scenari applicativi.