GOAL agent programmeringsspråk

GOAL är ett agentprogrammeringsspråk för programmering av kognitiva agenter . GOAL-agenter hämtar sitt val av handling från sina övertygelser och mål. Språket tillhandahåller de grundläggande byggstenarna för att designa och implementera kognitiva agenter genom att programmera konstruktioner som tillåter och underlättar manipulering av en agents övertygelser och mål och för att strukturera dess beslutsfattande . Språket ger en intuitiv programmeringsram baserad på sunt förnuft eller praktiska resonemang .

Översikt

Huvuddragen i GOAL inkluderar:

  • Deklarativa övertygelser : Agenter använder ett symboliskt, logiskt språk för att representera den information de har, och deras övertygelser eller kunskap om miljön de agerar utifrån för att uppnå sina mål. Detta kunskapsrepresentationsspråk är inte fixerat av GOAL utan kan i princip varieras efter programmerarens behov.
  • Deklarativa mål : Agenter kan ha flera mål som anger vad agenten vill uppnå någon gång i en nära eller avlägsen framtid. Deklarativa mål anger ett tillstånd i miljön som agenten vill upprätta, de anger inte åtgärder eller procedurer för hur man uppnår sådana tillstånd.
  • Strategi för blind engagemang : Agenter förbinder sig till sina mål och släpper mål först när de har uppnåtts. Denna åtagandestrategi, som kallas en blind engagemangsstrategi i litteraturen, är standardstrategin som används av GOAL-agenter. Kognitiva agenter antas inte ha mål som de tror redan är uppnådda, en begränsning som har byggts in i GOAL-agenter genom att släppa ett mål när det har uppnåtts helt .
  • Regelbaserat åtgärdsval : Agenter använder så kallade åtgärdsregler för att välja handlingar, givet deras övertygelser och mål. Sådana regler kan underspecificera valet av åtgärd i den meningen att flera handlingar kan utföras när som helst givet agentens åtgärdsregler. I så fall kommer en GOAL-agent att välja en godtyckligt aktiverad åtgärd för exekvering.
  • Policybaserade avsiktsmoduler : Agenter kan fokusera sin uppmärksamhet och lägga alla sina ansträngningar på att uppnå en delmängd av sina mål, genom att använda en delmängd av sina handlingar, och endast använda kunskap som är relevant för att uppnå dessa mål. GOAL tillhandahåller moduler för att strukturera handlingsregler och kunskap som är dedikerad till att uppnå specifika mål. Informellt kan moduler ses som policybaserade avsikter i Michael Bratmans mening .
  • Kommunikation på kunskapsnivå : Agenter kan kommunicera med varandra för att utbyta information och för att samordna sina handlingar. GOAL-agenter kommunicerar med hjälp av kunskapsrepresentationsspråket som också används för att representera deras övertygelser och mål.
  • Testning : Du kan också skriva tester för GOAL.

GOAL agentprogram

border=0 Elevatorworld.png
Ett exempel blockerar världsproblem
Ett annat exempel: En GOAL Multi-Agent Hisskontroller

Ett GOAL-agentprogram består av sex olika sektioner, inklusive kunskap , övertygelser , mål , handlingsregler , handlingsspecifikationer respektive perceptregler . Kunskapen, föreställningarna och målen är representerade i ett kunskapsrepresentationsspråk som till exempel Prolog , Answer set programmering , SQL (eller Datalog ) eller Planning Domain Definition Language . Nedan illustrerar vi komponenterna i ett GOAL-agentprogram med hjälp av Prolog.

Den övergripande strukturen för ett GOAL-agentprogram ser ut så här:

huvud: { }

GOAL-agentkoden som används för att illustrera strukturen hos en GOAL-agent är en agent som kan lösa Blocks världsproblem . Agentens övertygelser representerar det nuvarande tillståndet i Blocks-världen medan agentens mål representerar måltillståndet. Kunskapsavsnittet som listas härnäst innehåller ytterligare konceptuell eller domänkunskap relaterad till Blocks världsdomän . 


        
  
     
    
     
 kunskap  {  block  (  a  ),  block  (  b  ),  block  (  c  ),  block  (  d  ),  block  (  e  ),  block  (  f  ),  block  (  g  ).  rensa  (  tabell  ).  rensa  (  X  )  :-  block  (  X  ),  inte  (  på  (  Y  ,  X  )).  torn  ([  X  ])  :-  på  (  X  ,  bord  ).  torn  ([  X  ,  Y  |  T  ])  :-  på  (  X  ,  Y  ),  torn  ([  Y  |  T  ]).  }

Observera att alla block som listas i kunskapssektionen dyker upp igen i beliefs -sektionen igen eftersom positionen för varje block måste specificeras för att karakterisera den fullständiga konfigurationen av block. 

övertygelser{ på(a,b), på(b,c), på(c,tabell), på(d,e), på(e,tabell), på(f,g), på(g,tabell) . }

Alla kända block finns också i målsektionen som specificerar en målkonfiguration som återanvänder alla block. 

mål{ på(a,e), på(b,tabell), på(c,tabell), på(d,c), på(e,b), på(f,d), på(g,tabell) . }

En GOAL-agent kan ha flera mål samtidigt. Dessa mål kan till och med vara motstridiga eftersom vart och ett av målen kan förverkligas vid olika tidpunkter. Till exempel kan en agent ha som mål att se en film på bio och att vara hemma (efteråt).

I GOAL urskiljs olika föreställningar om mål. Ett primitivt mål är ett uttalande som följer av målbasen i förening med de begrepp som definieras i kunskapsbasen. Till exempel torn([a,e,b]) ett primitivt mål och vi skriver mål([a,e,b]) för att beteckna detta. Till en början är torn([a,e,b]) också ett prestationsmål eftersom agenten inte tror att a ligger ovanpå e, e ligger ovanpå b, och b ligger på bordet. Prestationsmål är primitiva mål som agenten inte tror är fallet och betecknas med a-mål(torn([a,e,b]) . Det är också användbart att kunna uttrycka att ett mål har uppnåtts . mål-a(torn([e,b]) används för att uttrycka t.ex. , att tornet [e,b] har uppnåtts med block e ovanpå block b. Både prestationsmålen såväl som föreställningen om ett uppnått mål kan definieras: 

a-goal(formel) ::= mål(formel), not(bel(formel)) goal-a(formel) ::= mål(formel), bel(formel)

Det finns en betydande litteratur om att definiera begreppet uppnått mål i agentlitteraturen (se referenserna).

GOAL är ett regelbaserat programmeringsspråk. Reglerna är uppbyggda i moduler. Huvudmodulen för en GOAL-agent specificerar en strategi för att välja åtgärder med hjälp av åtgärdsregler . Den första regeln nedan säger att flytta block X ovanpå block Y (eller, möjligen, tabellen) är ett alternativ om ett sådant drag är konstruktivt, dvs flyttar blocket i position. Den andra regeln säger att flytta ett block X till tabellen är ett alternativ om block X är felplacerat. 

huvudmodul{ program{ if a-goal(tower([X,Y|T])), bel(tower([Y|T])) then move(X,Y). om a-mål(torn([X|T])) flytta sedan(X,bord). } }

Åtgärder, t.ex. flyttåtgärden som används ovan, specificeras med en STRIPS -stil specifikation av förutsättningar och eftervillkor. En förutsättning anger när åtgärden kan utföras (är aktiverad). Ett postvillkor anger vilka effekterna av att utföra åtgärden är. 

actionspec{ move(X,Y) { pre{ clear(X), clear(Y), on(X,Z), not(X=Y) } post{ not(on(X,Z)), on(X ,Y) } }

Slutligen består händelsemodulen av regler för bearbetning av händelser såsom uppfattningar som tas emot från omgivningen. Regeln nedan specificerar att för alla mottagna uppfattningar som indikerar att block X är på block Y, och X antas vara ovanpå Z olik Y, ska det nya faktumet på(X,Y) läggas till trosbasen och atomen på(X,Z) ska avlägsnas. 

händelsemodul{ program{ forall bel( percept(on(X,Y)), on(X,Z), not(Y=Z) ) do insert(on(X,Y), not(on(X,Z) )). } }

Relaterade agentprogrammeringsspråk

GOAL-agentens programmeringsspråk är relaterat till men skiljer sig från andra agentprogrammeringsspråk som AGENT0 , AgentSpeak , 2APL , Golog , JACK Intelligent Agents , Jadex och till exempel Jason . Det utmärkande för GOAL är begreppet ett deklarativt mål. Mål för en GOAL-agent beskriver vad en agent vill uppnå, inte hur man uppnår det. Till skillnad från andra språk är GOAL-agenter engagerade i sina mål och tar bara bort ett mål när det har uppnåtts helt . GOAL tillhandahåller ett programmeringsramverk med starkt fokus på deklarativ programmering och de resonemangsförmåga som krävs av kognitiva agenter.

Se även

Anteckningar

Litteratur om idén om ett mål:

  • Lars Braubach, Alexander Pokahr, Daniel Moldt och Winfried Lamersdorf (2004). Målrepresentation för BDI Agent Systems, i: The Second International Workshop on Programming Multiagent Systems.
  • Philip R. Cohen och Hector J. Levesque (1990). Avsikt är val med engagemang. Artificiell intelligens 42, 213–261.
  • Andreas Herzig och D. Longin (2004). C&l avsikt återbesökt. I: Proc. av 9:e Int. Konferensprinciper för kunskapsrepresentation och resonemang (KR'04), 527–535.
  • Koen V. Hindriks, Frank S. de Boer, Wiebe van der Hoek, John-Jules Ch. Meyer (2000). Agentprogrammering med deklarativa mål. I: Proc. av den 7:e Int. Workshop om intelligenta agenter VII (ATAL'00), s. 228–243.
  • Anand S. Rao och Michael P. Georgeff (1993). Avsikter och rationellt engagemang. Tech. Rep. 8, Australian Artificial Intelligence Institute .
  • Birna van Riemsdijk, Mehdi Dastani, John-Jules Ch. Meyer (2009). Mål i konflikt: Semantiska grunder för mål i agentprogrammering. International Journal of Autonomous Agents and Multi-Agent Systems.

externa länkar

Hämtad från " https://en.wikipedia.org/w/index.php?title=GOAL_agent_programming_language&oldid=1119268073 "