Programmeringsspråk for GOAL agent - GOAL agent programming language

GOAL er en agent programmeringsspråk for programmering kognitive agenter . MÅLAGENTER henter sitt valg av handling ut fra deres tro og mål. Språket gir de grunnleggende byggesteinene for å designe og implementere kognitive agenter ved å programmere konstruksjoner som tillater og letter manipulering av agentens tro og mål og strukturerer beslutningstaking . Språket gir et intuitivt programmeringsrammeverk basert på sunn fornuft eller praktisk resonnement .

Oversikt

Hovedtrekkene i GOAL inkluderer:

  • Deklarativ tro : Agenter bruker et symbolsk, logisk språk for å representere informasjonen de har, og deres tro eller kunnskap om miljøet de handler etter for å nå sine mål. Dette kunnskapsrepresentasjonsspråket er ikke løst av GOAL, men kan i prinsippet varieres i henhold til behovene til programmereren.
  • Deklarative mål : Agenter kan ha flere mål som spesifiserer hva agenten vil oppnå på et øyeblikk i nær eller fjern fremtid. Deklarative mål spesifiserer en tilstand av miljøet som agenten ønsker å etablere, de spesifiserer ikke handlinger eller prosedyrer hvordan man skal oppnå slike tilstander.
  • Blind forpliktelsesstrategi : Agenter forplikter seg til sine mål og slipper bare mål når de er oppnådd. Denne forpliktelsesstrategien, kalt en blind forpliktelsesstrategi i litteraturen, er standardstrategien brukt av GOAL-agenter. Det antas at kognitive agenter ikke har mål som de mener allerede er oppnådd, en begrensning som er innebygd i GOAL-agenter ved å slippe et mål når det er fullstendig oppnådd.
  • Regelbasert handlingsvalg : Agenter bruker såkalte handlingsregler for å velge handlinger, gitt deres tro og mål. Slike regler kan underspesifisere valg av handling i den forstand at flere handlinger kan utføres når som helst gitt handlingsreglene til agenten. I så fall vil en GOAL-agent velge en vilkårlig aktivert handling for utføring.
  • Politikkbaserte intensjonsmoduler : Agenter kan fokusere sin oppmerksomhet og legge alt de kan for å oppnå en delmengde av sine mål, ved å bruke en delmengde av sine handlinger, og kun bruke kunnskap som er relevant for å nå disse målene. GOAL tilbyr moduler for å strukturere handlingsregler og kunnskap dedikert til å nå bestemte mål. Uformelt kan moduler sees på som politikkbaserte intensjoner i betydningen Michael Bratman .
  • Kommunikasjon på kunnskapsnivå : Agenter kan kommunisere med hverandre for å utveksle informasjon og for å koordinere sine handlinger. MÅL agenter kommuniserer ved hjelp av kunnskapsrepresentasjonsspråket som også brukes til å representere deres tro og mål.
  • Testing : Du kan også skrive tester for GOAL.

MÅL agentprogram

grense = 0 Elevatorworld.png
Et eksempel blokkerer verdensproblemet
Et annet eksempel: En målstyring for flere agentheiser

Et GOAL-agentprogram består av seks forskjellige seksjoner, inkludert henholdsvis kunnskap , tro , mål , handlingsregler , handlingsspesifikasjoner og oppfatningsregler . Kunnskap, er tro og mål representert i en kunnskapsrepresentasjon språk som Prolog , Svar sett programmering , SQL (eller Datalog ), eller planlegging Domain Definition Language , for eksempel. Nedenfor illustrerer vi komponentene i et GOAL-agentprogram ved bruk av Prolog.

Den overordnede strukturen til et GOAL-agentprogram ser ut som: 

main: <agentname> {
  <sections>
}

GOAL-agentkoden som brukes til å illustrere strukturen til en GOAL-agent, er en agent som er i stand til å løse Blocks world problems. Agentens tro representerer den nåværende tilstanden til Blocks-verdenen, mens agentens mål representerer målstaten. Den kunnskapen delen oppført ved siden inneholder tilleggs konseptuelle eller domene kunnskap knyttet til blokkene verden domene. 

knowledge{
  block(a), block(b), block(c), block(d), block(e), block(f), block(g).
  clear(table).
  clear(X) :- block(X), not(on(Y,X)).
  tower([X]) :- on(X,table).
  tower([X,Y|T]) :- on(X,Y), tower([Y|T]).
}

Merk at alle blokkene som er oppført i kunnskapsdelen, dukker opp igjen i trosseksjonen , ettersom posisjonen til hver blokk må spesifiseres for å karakterisere den komplette konfigurasjonen av blokker. 

beliefs{
  on(a,b), on(b,c), on(c,table), on(d,e), on(e,table), on(f,g), on(g,table).
}

Alle kjente blokker er også til stede i målseksjonen som spesifiserer en målkonfigurasjon som gjenbruker alle blokker. 

goals{
  on(a,e), on(b,table), on(c,table), on(d,c), on(e,b), on(f,d), on(g,table).
}

En MÅL-agent kan ha flere mål samtidig. Disse målene kan til og med være motstridende ettersom hvert av målene kan realiseres på forskjellige tidspunkter. For eksempel kan en agent ha et mål om å se en film i kinoen og være hjemme (etterpå).

I MÅL skilles ulike forestillinger om mål ut. Et primitivt mål er en påstand som følger av målbasen i forbindelse med begrepene definert i kunnskapsgrunnlaget. For eksempel, tower([a,e,b])er et primitivt mål, og vi skriver for goal(tower([a,e,b])å betegne dette. Opprinnelig tower([a,e,b])er det også et oppnådd mål siden agenten ikke tror at a er på toppen av e, e er på toppen av b, og b er på bordet. Oppnåelsesmål er primitive mål som agenten ikke tror er tilfelle og er betegnet med a-goal(tower([a,e,b]). Det er også nyttig å kunne uttrykke at et mål er oppnådd . goal-a(tower([e,b])brukes for å uttrykke for eksempel at tårnet [e,b]er oppnådd med blokk e på toppen av blokk b. Både prestasjonsmål og forestillingen om et oppnådd mål kan defineres: 

a-goal(formula) ::= goal(formula), not(bel(formula))
goal-a(formula) ::= goal(formula), bel(formula)

Det er en betydelig litteratur om definering av begrepet et prestasjonsmål i agentlitteraturen (se referansene).

MÅL er et regelbasert programmeringsspråk. Reglene er strukturert i moduler. Den hovedmodul til et mål middel spesifiserer en strategi for valg av handlinger ved hjelp av aksjons regler. Den første regelen nedenfor sier at flytting av blokk X på toppen av blokk Y (eller muligens tabellen) er et alternativ hvis et slikt trekk er konstruktivt, dvs. flytter blokken i posisjon. Den andre regelen sier at å flytte en blokk X til tabellen er et alternativ hvis blokk X er feilplassert. 

main module{
  program{
    if a-goal(tower([X,Y|T])), bel(tower([Y|T])) then move(X,Y).
    if a-goal(tower([X|T])) then move(X,table).
  }
}

Handlinger, for eksempel bevegelseshandlingen som er brukt ovenfor, spesifiseres ved hjelp av en STRIPS- stil-spesifikasjon av forutsetninger og etterforhold. En forutsetning spesifiserer når handlingen kan utføres (er aktivert). En posttilstand spesifiserer hva effekten av å utføre handlingen er. 

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

Til slutt består hendelsesmodulen av regler for behandling av hendelser som persepter mottatt fra miljøet. Regelen nedenfor spesifiserer at for alle mottatte oppfatninger som indikerer at blokk X er på blokk Y, og X antas å være på toppen av Z ulik Y, skal den nye fakta på (X, Y) legges til trosgrunnlaget og atomet på (X, Z) skal fjernes. 

event module{
  program{
    forall bel( percept(on(X,Y)), on(X,Z), not(Y=Z) ) do insert(on(X,Y), not(on(X,Z))).
  }
}

Programmeringsspråk for relaterte agenter

Programmeringsspråket for GOAL-agenten er relatert til, men forskjellig fra andre agentprogrammeringsspråk som AGENT0 , AgentSpeak , 2APL , Golog , JACK Intelligent Agents , Jadex , og for eksempel Jason . Kjennetegnet ved GOAL er begrepet et erklærende mål. Mål for en MÅL-agent beskriver hva en agent ønsker å oppnå, ikke hvordan man skal oppnå det. I motsetning til andre språk er GOAL-agenter forpliktet til sine mål og fjerner bare et mål når det er fullstendig oppnådd. GOAL gir et programmeringsrammeverk med sterkt fokus på deklarativ programmering og resonneringsevnen som kognitive agenter krever.

Se også

Referanser

Merknader

Litteratur om forestillingen om et mål:

  • Lars Braubach, Alexander Pokahr, Daniel Moldt og Winfried Lamersdorf (2004). Målrepresentasjon for BDI Agent Systems, i: The Second International Workshop on Programming Multiagent Systems.
  • Philip R. Cohen og Hector J. Levesque (1990). Intensjon er valg med forpliktelse. Kunstig intelligens 42, 213-261.
  • Andreas Herzig og D. Longin (2004). C & l intensjon revidert. I: Proc. av 9. Int. Konferanseprinsipper for kunnskapsrepresentasjon og resonnement (KR'04), 527–535.
  • Koen V. Hindriks, Frank S. de Boer, Wiebe van der Hoek, John-Jules Ch. Meyer (2000). Agentprogrammering med erklærende mål. I: Proc. av 7. Int. Workshop om intelligente agenter VII (ATAL'00), s. 228–243.
  • Anand S. Rao og Michael P. Georgeff (1993). Intensjoner og rasjonell forpliktelse. Teknisk. Rep. 8, Australian Artificial Intelligence Institute .
  • Birna van Riemsdijk, Mehdi Dastani, John-Jules Ch. Meyer (2009). Mål i konflikt: semantiske grunnlag for mål i agentprogrammering. International Journal of Autonomous Agents and Multi-Agent Systems.

Eksterne linker