Masterproef
Upcoming SlideShare
Loading in...5
×
 

Masterproef

on

  • 895 views

Master thesis of Maarten Tielemans & Pieter-Jan Speelmans.

Master thesis of Maarten Tielemans & Pieter-Jan Speelmans.

Describes an approach for instructing Super Mario with natural language.

Statistics

Views

Total Views
895
Views on SlideShare
895
Embed Views
0

Actions

Likes
0
Downloads
9
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Masterproef Masterproef Document Transcript

  • Een probabilistische aanpak voor hetaansturen van Mario met natuurlijke taalMaarten TielemansPieter-Jan Speelmans Thesis voorgedragen tot het behalen van de graad van Master in de ingenieurswetenschappen: computerwetenschappen Promotoren: Sien Moens Luc De Raedt Martijn Van Otterlo Assessoren: Martijn Van Otterlo Siegfried Nijssen Begeleiders: Parisa Kordjamshidi Koen Deschacht Martijn Van Otterlo Academiejaar 2010 – 2011
  • c Copyright K.U.LeuvenZonder voorafgaande schriftelijke toestemming van zowel de promotor(en) als deauteur(s) is overnemen, kopiëren, gebruiken of realiseren van deze uitgave of gedeel-ten ervan verboden. Voor aanvragen tot of informatie i.v.m. het overnemen en/ofgebruik en/of realisatie van gedeelten uit deze publicatie, wend u tot het Departe-ment Computerwetenschappen, Celestijnenlaan 200A bus 2402, B-3001 Heverlee,+32-16-327700 of via e-mail info@cs.kuleuven.be.Voorafgaande schriftelijke toestemming van de promotor(en) is eveneens vereist voorhet aanwenden van de in deze masterproef beschreven (originele) methoden, pro-ducten, schakelingen en programma’s voor industrieel of commercieel nut en voorde inzending van deze publicatie ter deelname aan wetenschappelijke prijzen of wed-strijden.
  • VoorwoordHierbij willen we iedereen bedanken die voor raad en steun gezorgd heeft bij hetuitwerken van deze thesis. Speciale dank gaat uit naar mijn begeleiders en promotorenSien Moens, Luc De Raedt, Martijn Van Otterlo en Parisa Kordjamshidi welke onsgedurende het jaar goede raad hebben gegeven voor het oplossen van verscheideneproblemen. Algemener willen we ook de andere professoren en assistenten aan hetdepartement computerwetenschappen bedanken voor de gegeven inzichten in hettoch wel boeiende domein. Verder willen we ook de ontwikkelaars van de Berkeley parser, de Stanford parser,het MarioAI-framework en Mallet bedanken voor het beschikbaar stellen van dezetoepassingen en de bijhorende documentatie. Ook willen we onze familie en vrienden bedanken voor alle steun die zij onstijdens onze opleiding gegeven hebben. Ten slotte bedanken we graag Super Mario, wie meermaals zijn leven heeftgeriskeerd om dit project tot een goed einde te brengen. Maarten Tielemans Pieter-Jan Speelmans i
  • InhoudsopgaveVoorwoord iSamenvatting ivLijst van figuren en tabellen v1 Inleiding 1 1.1 Probleemstelling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.2 Huidige oplossingen . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 1.3 Doelstelling en aanpak . . . . . . . . . . . . . . . . . . . . . . . . . . 6 1.4 Overzicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 De extractie van afhankelijkheidsrelaties 11 2.1 Voorstelling van grammaticale structuur . . . . . . . . . . . . . . . . 11 2.2 Analyse van grammaticale parsers . . . . . . . . . . . . . . . . . . . 14 2.3 Plaats in het proces . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 Het taggen van de instructie 19 3.1 Wat is tagging? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 3.2 Het tagging alfabet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 3.3 De gebruikte techniek . . . . . . . . . . . . . . . . . . . . . . . . . . 22 3.4 Het trainen van de CRF . . . . . . . . . . . . . . . . . . . . . . . . . 23 3.5 Het testen van de CRF . . . . . . . . . . . . . . . . . . . . . . . . . . 24 3.6 Herkennen en herstellen van incorrecte taggings . . . . . . . . . . . . 26 3.7 Plaats in het proces . . . . . . . . . . . . . . . . . . . . . . . . . . . 274 Doelconstructie 29 4.1 Hoe gebeurt doelconstructie? . . . . . . . . . . . . . . . . . . . . . . 29 4.2 Doelstructuur en domeincontrole . . . . . . . . . . . . . . . . . . . . 35 4.3 De plaats in het proces . . . . . . . . . . . . . . . . . . . . . . . . . . 415 Doelcontrole en objectidentificatie 43 5.1 Motivatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 5.2 De aanpak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 5.3 De extractie van wereldinformatie . . . . . . . . . . . . . . . . . . . . 46 5.4 Problemen bij de controle . . . . . . . . . . . . . . . . . . . . . . . . 48 5.5 Het identificeren van objecten . . . . . . . . . . . . . . . . . . . . . . 50 5.6 De plaats in het proces . . . . . . . . . . . . . . . . . . . . . . . . . . 51ii
  • Inhoudsopgave6 Evaluatie van de voorgestelde techniek 53 6.1 Opstelling van de experimenten . . . . . . . . . . . . . . . . . . . . . 53 6.2 Invloed van het aantal gebruikte parse-trees en taggings . . . . . . . 55 6.3 Invloed van het woordenboek . . . . . . . . . . . . . . . . . . . . . . 58 6.4 Vergelijking met een eenvoudige pattern matcher . . . . . . . . . . . 60 6.5 Algemene vaststellingen . . . . . . . . . . . . . . . . . . . . . . . . . 607 Besluit 63 7.1 Geleverd werk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 7.2 Doelstellingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 7.3 Interessante uitbreidingen . . . . . . . . . . . . . . . . . . . . . . . . 66 7.4 Conclusies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68A Extract uit een walkthrough 71B Het tagging alfabet 75C De doelstructuren 79D De patronen voor doelconstructie 85 D.1 Action Coordination . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 D.2 Action Goal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 D.3 Action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 D.4 Conditional Coordination . . . . . . . . . . . . . . . . . . . . . . . . 86 D.5 Constraint Coordination . . . . . . . . . . . . . . . . . . . . . . . . . 87 D.6 Coordination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 D.7 Location . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 D.8 Environment Action . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 D.9 Negation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 D.10 Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 D.11 Relation Action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 D.12 Relation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89E De AIML pattern matcher 91 E.1 Aanpak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 E.2 De patronen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92F De gebruikte testdata 95G Datatransformaties doorheen het proces voor een voorbeeldinstructie 99H Wetenschappelijk artikel 1 105I Wetenschappelijk artikel 2 111J Poster 117Bibliografie 119 iii
  • SamenvattingTaal is de meest natuurlijke manier van communicatie in het dagelijks leven. Decommunicatie met de verscheidene toestellen in de dagelijkse omgeving gebeurt echtermeestal door gebruik te maken van interfaces die minder natuurlijk aanvoelen. Hetis dan ook niet verwonderlijk dat er veel onderzoek gedaan wordt naar de analysevan natuurlijke taal door computers opdat ook met deze systemen op een meereenvoudige manier gecommuniceerd kan worden. De analyse van natuurlijke taalis echter niet eenvoudig. Zo bevat natuurlijke taal veel dubbelzinnigheden. Ominstructies in natuurlijke taal te begrijpen, moeten deze dubbelzinnigheden echteropgelost worden en moet eenduidig bepaald worden wat er juist bedoeld wordt. In deze thesis wordt een aanpak besproken die de betekenis uit instructies innatuurlijke taal haalt. Hierbij wordt rekening gehouden met dubbelzinnighedenin natuurlijke taal. In een eerste stap van deze aanpak zal voor de instructie eenreeks van mogelijke grammaticale structuren opgesteld worden. Deze structurenbeschrijven de grammaticale rol van iedere woordgroep in de instructie. Bovendienzijn deze structuren eenduidig bepaald en dus ondubbelzinnig. Vervolgens zal voordeze structuren een betekenis gezocht worden voor de verschillende woorden inde instructie. Ook dit gebeurt door een verzameling te genereren, in dit geval eenverzameling van mogelijke betekenissen. Iedere combinatie van structuur en betekeniszal op slechts één manier geïnterpreteerd kunnen worden. Met deze twee gegevenskan een doelstructuur opgebouwd worden door patronen in deze data te herkennen.Op basis van deze patronen zal een gegevensstructuur opgebouwd worden die metbehulp van de beschikbare domeinkennis omgevormd kan worden naar de uit tevoeren acties zoals beschreven in de instructie. Het proces is echter nog niet afgelopen wanneer het doel van de instructie gekendis. Het doel kan namelijk incorrect zijn in de context van de huidige wereld. Om ditprobleem op te lossen, zal de doelstructuur afgetoetst worden aan de wereldtoestand.Indien het doel en de wereld elkaar niet tegenspreken, zal het doel aanvaard worden.In het andere geval zal het doel verworpen worden en zal de zoektocht naar eendoelstructuur doorgaan. Met deze aanpak zal dus niet enkel een reeks uit te voerenacties gezocht worden die uitvoerbaar is in het domein, maar een doel dat uitvoerbaaris in de huidige wereld. Dit doel kan dan aan een robot gegeven worden die deinstructie kan uitvoeren.iv
  • Lijst van figuren en tabellenLijst van figuren1.1 Schematische weergave van de datatransformaties doorheen de aanpak. . 72.1 Parse-tree voor Jump over the pipe. . . . . . . . . . . . . . . . . . . . . 122.2 Twee mogelijke parse-trees voor Jump over the pipe on the floor. . . . . 122.3 Stanford Dependency relaties voor Jump over the pipe to the right if the monster is near the block. . . . . . . . . . . . . . . . . . . . . . . . . . . 134.1 Evolutie van de boomstructuur van afhankelijkheidsrelaties (1) naar de relaties tussen de woorden (2) naar de doelstructuur (3) voor de zin Jump over the gap to go right. . . . . . . . . . . . . . . . . . . . . . . . . 375.1 Voorstelling van de Mario-wereld in een array van vakjes met enkele grotere structuren in de wereld. . . . . . . . . . . . . . . . . . . . . . . . 46G.1 De wereld waarin de instructie uitgevoerd wordt. . . . . . . . . . . . . . 99G.2 De datastructuur gegenereerd door de pattern matcher op de afhankelijkheidsrelaties. . . . . . . . . . . . . . . . . . . . . . . . . . . . 101G.3 De doelstructuur voor Start off by going to the right before jumping on the platform and jumping across the gap.. . . . . . . . . . . . . . . . . . 101G.4 De wereldstructuren in de wereld. Geel: platform; Rood: pipe; Blauw: gap103Lijst van tabellen3.1 Tagging alfabet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.2 Resultaten van experimenten van de CRF voor instellingen. Niet volledig verbonden: nfc; volledig verbonden: fc. . . . . . . . . . . . . . . . . . . 253.3 Resultaten van experimenten van de CRF met en zonder woordenboek voor een niet volledig verbonden en sparse. Foute instances is het percentage van instances met een fout waarvan herkend kan worden dat de tagging fout is. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.1 Voorbeeld van de attributen voor de BlockStructure. . . . . . . . . . . . 36 v
  • Lijst van figuren en tabellen6.1 Percentage van correcte doelstructuren voor verschillende waarden voor het aantal parse-trees en taggings over alle testinstructies zonder gebruik te maken van het woordenboek. . . . . . . . . . . . . . . . . . . . . . . . 566.2 Aantal correcte structuren en aantal fouten voor verschillende aantallen taggings voor iedere categorie van testinstructies zonder gebruik te maken van het woordenboek. . . . . . . . . . . . . . . . . . . . . . . . . 576.3 Aantal correcte structuren en aantal fouten voor verschillende aantallen taggings voor iedere categorie van testinstructies met het woordenboek. 596.4 Aantal correcte structuren en aantal fouten voor verschillende technieken. 61C.1 De algemene structuren . . . . . . . . . . . . . . . . . . . . . . . . . . . 79C.2 De structuren voor actie tags . . . . . . . . . . . . . . . . . . . . . . . . 80C.3 De structuren voor coördinatie . . . . . . . . . . . . . . . . . . . . . . . 80C.4 De structuren voor actie coördinatie . . . . . . . . . . . . . . . . . . . . 81C.5 De structuren voor locaties . . . . . . . . . . . . . . . . . . . . . . . . . 81C.6 De structuren voor hoeveelheden . . . . . . . . . . . . . . . . . . . . . . 81C.7 De structuren voor objecten . . . . . . . . . . . . . . . . . . . . . . . . . 82C.8 Structuren voor relaties . . . . . . . . . . . . . . . . . . . . . . . . . . . 83F.1 Voorbeeld van eenvoudige instructies . . . . . . . . . . . . . . . . . . . . 96F.2 Voorbeeld van semi-complexe instructies . . . . . . . . . . . . . . . . . . 97F.3 Voorbeeld van complexe instructies . . . . . . . . . . . . . . . . . . . . . 98vi
  • List of Algorithms 1 Pseudocode van de procedure voor de verwerking van de invoerinstructie tot uitvoerbare doelstructuur. . . . . . . . . . . . . . 8 2 Algoritme voor het omzetten van de instructie naar afhankelijkheidsrelaties. . . . . . . . . . . . . . . . . . . . . . . . . . 17 3 Algoritme voor het omvormen van de invoerinstructie en afhankelijkheidsrelaties naar invoerdata voor de CRF. . . . . . . . . 24 4 Algoritme van de tagging-stap. . . . . . . . . . . . . . . . . . . . . . 28 5 Procedure voor het bepalen van de verbanden tussen de woorden. . . 30 6 Procedure voor het samenvouwen van voorzetselrelaties. . . . . . . . 32 7 Procedure voor het vinden van de root. . . . . . . . . . . . . . . . . 38 8 Algoritme van de doelconstructie-stap. . . . . . . . . . . . . . . . . . 41 9 Algoritme van de doelcontrole-stap. . . . . . . . . . . . . . . . . . . . 52 vii
  • Hoofdstuk 1InleidingIn deze inleiding zal eerst een overzicht gegeven worden rond de probleemstellingvan deze thesis (sectie 1.1). Vervolgens zal er in sectie 1.2 gekeken worden naar deoplossingen op dit probleem die ons aangereikt worden vanuit de literatuur. Hier nawordt een korte bespreking gegeven van de aanpak die in dit werk beschreven zalworden (sectie 1.3) en tenslotte volgt in sectie 1.4 een overzicht met de opbouw vandit document.1.1 ProbleemstellingDe technologie in de wereld evolueert steeds verder. Het is niet onwaarschijnlijk datover enkele jaren steeds meer apparaten zullen opduiken in het dagelijks leven. Decommunicatie tussen gebruiker en apparaat zal dus waarschijnlijk in de toekomstbelangrijker worden. Op dit ogenblik kunnen we zien dat deze communicatie vooralgebeurt door het programmeren van vaste commando’s. Indien de gebruiker eenactie wilt laten uitvoeren, kan hij het overeenkomende commando dan door middelvan een simpele interface oproepen. De huidige interfaces bestaan voornamelijk uittoetsen en in sommige gevallen zelfs simpele spraakcommando’s, zoals bijvoorbeeldbij de modernere autocomputers. Het nadeel hier is dat de gebruiker de interfacemoet leren gebruiken. Zo zal hij moeten leren wat de functie van iedere knop is enwelke de bruikbare commando’s zijn. Het zou echter makkelijker zijn indien de gebruiker de nieuwe interface niet moetleren. Dit zou kunnen door middel van een interface die gebruik maakt van natuurlijketaal. De gebruiker heeft dan de mogelijkheid om in zijn eigen woorden aan het systeemte zeggen welke actie uitgevoerd moet worden. Het apparaat zou dan deze instructiemoeten analyseren en de verschillende woorden en zinsconstructies moeten vertalennaar een duidelijke structuur van uit te voeren taken. Met andere woorden zoekenwe een ondubbelzinnige voorstelling van de informatie in de zin. In het geval van eeninstructie zou deze voorstelling bijvoorbeeld de uit te voeren acties kunnen bevatten. 1
  • 1. Inleiding Wanneer we het meer specifieke domein van robotica bekijken, komt in de instructieeen nieuwe bron van informatie bij. Zo zal de instructie waarschijnlijk niet enkel actiesbevatten die uitgevoerd moeten worden, maar ook posities van objecten waarmeegeïnterageerd moet worden. Bovendien kan in de instructie informatie zitten over deopbouw van de ruimte rondom de robot. De structuur die gezocht wordt, moet indit geval dus ook de informatie over deze objecten bevatten net als hun relaties in deruimte.1.1.1 Problemen bij het analyseren van natuurlijke taalHet analyseren van instructies in natuurlijke taal is echter een complex probleem. Zozijn er aan de ene kant de verschillende vormen van ambiguïteit die roet in het etenkunnen gooien terwijl aan de andere kant de gegeven instructies vaak een hoog-niveaubeschrijving bevatten van de uit te voeren actie[10]. Ambiguïteit is het probleem van dubbelzinnigheid. Hierbij kunnen woordenof zinsdelen op verschillende manieren geïnterpreteerd worden. Ambiguïteit kanvoorkomen in veel vormen. Zo heeft men bijvoorbeeld de ambiguïteit van betekeniswaarbij een woord meerdere betekenissen kan hebben[27]. Een voorbeeld hiervanvindt men bij het woord bank. Dit woord kan namelijk verwijzen naar een financiëleinstelling, maar het kan ook verwijzen naar het voorwerp waar we op kunnen zitten. Een andere vorm van ambiguïteit is dan weer die van grammaticale structuur[21].Bij volgende zin: Spring over de pijp op de grond.kan de bijzin op de grond zowel aan pijp hangen als bij de actie spring horen. Deuitvoer van deze twee verschillende structuren zou zelf ook verschillend kunnen zijn.Zo landt men in de ene situatie op een stuk grond dat achter de pijp ligt. In deandere situatie zou er achter de pijp een afgrond kunnen zijn, waardoor de afgrondin gesprongen wordt. Verder kunnen ook combinaties van deze twee vormen vanambiguïteit voorkomen. Naast ambiguïteit zijn er ook nog andere problemen. De meeste instructies gegevenin natuurlijke taal zijn namelijk hoog-niveau beschrijvingen. Hierbij wordt er enkelgesproken over het doel van de actie maar niet over de tussenliggende stappen diegenomen moeten worden om dit doel te verwezenlijken. Zo is er de instructie: Ga naar de bank en haal geld uit de bankautomaat.Hierbij moet men eerst de correcte weg naar de bank volgen, vervolgens de bankkaartin de automaat plaatsen, een gewenst bedrag intoetsen, de correcte code invoerenen het geld uit de gleuf nemen. Liefst wordt ook de bankkaart weer meegenomenen het geld afgeleverd aan de gebruiker die de instructie gaf. De afhandeling vandeze instructie vraagt dus dat veel kleinere deeltaken opgelost worden waar nietsover gezegd wordt.2
  • 1.1. Probleemstelling Naast deze twee problemen moet men ook nog een ander problemen beschouwen.Zo bedoelen mensen vaak iets anders dan wat ze letterlijk zeggen. Denk maar aan devele spreekwoorden en uitdrukkingen die in de dagelijkse omgang gebruikt wordenzoals: Loop naar de maan.Hier moet het toestel uiteraard niet proberen om op de maan te raken, maar gewooneven weg gaan of gewoon niets doen. Ook geeft men vaak instructies op een beleefdemanier door bijvoorbeeld een vraag te stellen zoals in: Kan je me even helpen?In dit geval moet er uiteraard niet op de vraag geantwoord worden, maar wordteigenlijk de instructie gegeven om te helpen. De bovenstaande problemen zijn algemeen voor eender welke vorm van verwerkingvan natuurlijke taal. In dit werk zal de focus echter liggen op het geven van instructiesaan apparaten. Aangezien een apparaat in een bepaalde ruimte staat en mogelijk kaninterageren met objecten in die ruimte, krijgen we hier nog een extra probleem: deobjecten uit de invoerinstructie moeten gekoppeld worden aan de objecten aanwezigin de omgeving. Voor deze objecten is het dan niet enkel belangrijk dat uit het woordvan het object ondubbelzinnig bepaald kan worden wat het type is, ook de ruimtelijkerelaties tussen de objecten zijn belangrijk. Hier kan structurele ambiguïteit echtereen groot probleem vormen doordat verbanden tussen verschillende objecten kunnenliggen. Instructies in natuurlijke taal analyseren is dus complexer dan op het eerste zichtlijkt. Deze analyse en het herkennen van de structuren in natuurlijke taal is danook het doel van het onderzoek verricht in deze thesis. Hierbij wordt uiteraardrekening gehouden met de problemen van ambiguïteit, complexheid van de instructiesen de problemen met ruimtelijke informatie van objecten. Om dit onderzoek uitte kunnen voeren, hebben we een omgeving gekozen die zeer gelijkaardig is aanhet geven van instructies aan een robot. We kozen voor een simulatieomgeving inde vorm van het MarioAI-project[3]. In deze omgeving zullen instructies gegevenworden aan de agent in de vorm van Super Mario. De instructies worden vervolgensgeanalyseerd en afgetoetst aan de omgeving. We geven nu een korte toelichting overdeze simulatieomgeving.1.1.2 Over de MarioAI omgevingDe MarioAI omgeving bevat een framework dat de Super Mario Bros. wereldsimuleert in Java. Wanneer we deze simulatieomgeving vergelijken met de echtewereld zien we grote gelijkenissen. Zo lost de abstractie naar de MarioAI omgevinggeen van de problemen in natuurlijke taal op (ambiguïteit, complexe instructies,. . . ). Bovendien moet de agent in zijn omgeving in staat zijn de correcte objecten te 3
  • 1. Inleidingidentificeren zoals die vernoemd zijn in de instructie. Als er bijvoorbeeld gesprokenwordt over een pijp, moet de juiste pijp in de omgeving herkend te worden omdeze te gebruiken als argument van de instructie. Ook kan de agent de ruimtelijkeinformatie in de uit te voeren instructie aftoetsen aan de huidige toestand van dewereld. Wanneer de instructie: Spring over de pijp op de grond.gegeven wordt, kan de agent zoeken welke van de grammaticale structuren te verkiezenis door te kijken of er ergens in zijn omgeving een pijp op de grond ligt. Een voordeel van de gebruikte simulatieomgeving is echter dat ze beter te control-eren is. Zo zijn er geen externe factoren die eventuele testen kunnen verstoren enzijn alle effecten van acties op de wereld en de evolutie van de wereld makkelijk tevoorspellen.1.2 Huidige oplossingenVoor de problemen beschreven in de vorige sectie is een breed spectrum aan oplossin-gen beschikbaar in de literatuur. De meeste oplossingen maken gebruik van een ofmeerdere van volgende strategieën: pattern matching, beperking van de invoertaalen het gebruik maken van taalkundige databanken.1.2.1 Pattern matchingPattern matching is een relatief eenvoudige techniek voor het analyseren van natu-urlijke taal[15]. Het herkennen van een structuur in een invoerzin komt namelijkovereen met het herkennen van een bepaald patroon in deze zin. Het systeem kanmet deze techniek een lijst met patronen proberen matchen met de invoerzin en deacties gelinkt aan de gevonden patronen uitvoeren[20]. Omwille van de eenvoud vande techniek wordt hij al zeer lang gebruikt[44] en zeer veel toegepast, voornamelijkin het domein van robotica[26][32]. De ambiguïteit in de zinnen wordt hier meestal opgelost door een score te geven aande patronen. Deze worden toegepast in een bepaalde volgorde - de meest belangrijkeeerst. Voor het bepalen van de te herkennen patronen kan gebruik gemaakt wordenvan verschillende technieken. Zo kan men de patronen leren herkennen met simpelemachine learning technieken, waardoor de meest courante structuren herkend kunnenworden[17]. Een alternatief is het handmatig opstellen van een lijst met bruikbarepatronen.4
  • 1.2. Huidige oplossingen Het nadeel van deze techniek is dat voor het herkennen van geavanceerde instructiesveel patronen nodig zijn. Indien deze patronen niet aanwezig zijn, zal deze instructieniet juist herkend worden. Mogelijk wordt er fout gematcht waardoor er fouteoplossingen gevonden zullen worden. Om dit probleem te vermijden, moet er vooriedere mogelijke structuur een patroon beschikbaar zijn. Dit is meestal niet het gevalen vaak wordt enkel voor de meest courante structuren een patroon gemaakt.1.2.2 Beperking van de invoertaalDe beperking van invoertaal is ook een veelgebruikte techniek[14][18][9]. Hier wordtgebruik gemaakt van een subset van natuurlijke taal. Dit kan zowel op grammaticaalvlak zijn als op vlak van de te gebruiken woorden. De te gebruiken grammaticais meestal simpel en zonder al te veel uitzonderingen. Ze leunt dicht aan bij deeenvoudigere regels van de grammatica van natuurlijke taal. Deze techniek benadertdus natuurlijke taal door een subset ervan te gebruiken als invoertaal. Een gekendvoorbeeld van een zeer beperkte subset van taal is het spel Zork[31] waarbij instructiesgegeven kunnen worden in de vorm van eenvoudige zinnen. Bij deze techniek wordt het probleem van ambiguïteit vaak opgelost door hetverwijderen van alternatieve betekenissen of structuren. Zo worden dubbelzinnighedenin zinnen vaak herleid zodat ze steeds slechts één mogelijke betekenis hebben. Dealternatieve betekenis of structuur wordt dan niet beschouwd. Het grootste probleem met deze techniek is dat de taal gebruikt voor deze aanpakniet natuurlijk is. Hier treedt dus mogelijk het probleem op dat een gebruikergetraind moet worden om met het systeem te werken: het systeem past zich namelijkniet aan de gebruiker aan. Door van de invoertaal een goede benadering te makenvan natuurlijke taal voor het gebruikte domein, kan dit probleem echter verminderdworden.1.2.3 Taalkundige databankenHet gebruik van taalkundige databanken heeft al nut getoond bij het ontwerpen vansystemen voor de herkenning van natuurlijke taal. Hierbij gebruikt men bronnenzoals FrameNet[2][11], WordNet[8][36] en/of VerbNet[7][23]. Er kunnen echter ookandere databanken specifiek voor het gekozen domein gebruikt worden[30]. Deze databanken bevatten informatie over semantiek en de rol die bepaaldewoorden kunnen spelen. Zo bevat FrameNet een semantisch frame voor zeer veelwoorden. WordNet bevat lijsten met synoniemen en VerbNet een uitgebreide indexvan Engelse werkwoorden met onder andere de restricties op elk van de mogelijkeargumenten. 5
  • 1. Inleiding Ambiguïteit kan op basis van deze bronnen opgelost worden door de beschikbareinformatie op te zoeken en te koppelen[34]. Zo zal het semantisch frame van tweegerelateerde woorden waarschijnlijk ook gerelateerd zijn. Indien dit niet het geval is,kan een alternatieve betekenis getest worden. Het grootste nadeel aan deze techniek is dat woorden of structuren die nietvoorkomen in deze databanken niet herkend zullen worden. Vaak worden echterverschillende bronnen aan elkaar gekoppeld om een zeer uitgebreide databank teverkrijgen[39][40]. De hier boven vermelde bronnen worden bovendien steeds uitge-breider en dekken op ogenblik van schrijven al een zeer groot deel van de Engelsetaal. Belangrijk op te merken is echter wel dat dit soort bronnen voor iedere taalopnieuw aangemaakt moeten worden. Dit is een zeer tijdrovende taak.1.3 Doelstelling en aanpakEen grote afwezige in de hiervoor besproken technieken is een aanpak die gebruikmaakt van grammaticale informatie in de invoerzinnen. De focus van dit werk ligtop het gebruiken van deze informatie en deze te combineren met kennis uit de wereld.Op basis van de mogelijke grammaticale structuren van een instructie, zal hier metbehulp van probabilistische hulpmiddelen een analyse van deze instructie gemaaktworden. De informatie over de omgeving zal uit de simulatieomgeving gehaald wordenom te helpen een correcte doelstructuur te bouwen. Deze informatie zal gebruiktworden om te controleren of de doelstructuur uitgevoerd kan worden in de huidigewereld. Indien dit niet het geval is, zal nagegaan worden of er geen andere analysegemaakt kan worden. Het doel van deze thesis ligt vooral in het onderzoeken of door gebruik te makenvan deze informatie de doelen in de invoerinstructies herkend kunnen worden. Doorde keuze van de simulatieomgeving wordt er van uit gegaan dat indien de aanpakbeschreven in dit document succesvol is, deze ook bruikbaar is voor algemeneredomeinen zoals robotica.1.3.1 De aanpakZoals hier boven vermeld, wordt in de hier beschreven aanpak gebruik gemaakt vangrammaticale informatie. Voor een globaal overzicht van de data die gebruikt wordtbij iedere stap van het proces, zie figuur 1.1. Meer gedetailleerde informatie over deverschillende stappen zal later in het werk gegeven worden. Hier volgt een verkortoverzicht. In de eerste twee stappen wordt de instructie geparsed naar zijn k-best parse-trees(stap a), die vervolgens worden omgevormd naar afhankelijkheidsrelaties (stap b).Deze relaties drukken de grammaticale verbanden tussen de verschillende woordenuit. De meest waarschijnlijke parse-tree wordt eerst gekozen en wordt verder gebruikt6
  • 1.3. Doelstelling en aanpak Is u t n t ce r i a b P ret e as r s e Ah n ej e s e t s fa k l h i rl i i d ae k c d d O g c nrl re n eo t e d oe Tg as de t c u o lr t r su u f e f G c nrl re eo t e d oe Wee rl i rl e t s d ae de t c u o lr t r su u Wee i omai rl n r t d f eFiguur 1.1: Schematische weergave van de datatransformaties doorheen de aanpak.in het proces. Het is uiteraard mogelijk dat de eerste parse-tree niet de correcte isvoor de gegeven instructie. Indien er later in het proces problemen opduiken met degekozen structuur zal er gebacktrackt worden over de andere parse-trees. De tagging stap (stap c) voegt semantische informatie toe aan de zin. Hier wordtde instructie geanalyseerd en een reeks mogelijke taggings berekend. Een tagging iseen sequentie van waarschijnlijke tags die toegewezen worden aan de woorden. Eentag is gekoppeld aan semantische informatie en heeft exact één betekenis. Voor detaggings wordt net zoals bij parse-trees de meest waarschijnlijke gekozen om verdermee te werken. Over de andere taggings zal later ook gebacktrackt kunnen worden. Vervolgens wordt de doelstructuur gebouwd (stap d). Hier wordt voor de huidigecombinatie van tags en relaties een structuur opgebouwd die de taken in de instructieondubbelzinnig beschrijft. Een bepaalde doelstructuur kan dus maar op één maniergeïnterpreteerd worden. In deze stap kan echter een probleem opduiken. Zo is hetmogelijk dat de gekozen tags niet gekoppeld kunnen worden aan de relaties diebekomen zijn uit de gekozen parse-tree. Indien dit het geval is, zal gebacktrackt 7
  • 1. Inleidingworden. Eerst zal voor de huidige parse-tree een andere mogelijke tagging getestworden. Indien er geen taggings meer zijn om uit te proberen, zal gebacktracktworden over de parse-tree. Het backtracken loopt door tot alle k-best parse-trees enhun k-best taggings uitgeprobeerd zijn. Indien er geen doel opgebouwd kan worden,zal de instructie als onbelangrijk genoteerd worden. Vanaf het ogenblik dat eengeldige structuur gevonden wordt, geven we deze terug. Er wordt gebruik gemaakt van wereld informatie om te controleren of de gekozengrammaticale structuur en taggin (en dus ook het berekende doel) correct is. Dewereld informatie wordt eerst omgezet naar een reeks wereldrelaties (stap e). Dezezijn uitgedrukt in logica waartegen doelen getest kunnen worden. Samen met derelaties bekomen uit de wereldinformatie zitten in de wereldrelaties ook een setdomeinspecifieke predicaten die de domeinkennis voorstellen. Het testen van dedoelstructuur, bekomen na stap d, gebeurt in stap f. Hier wordt dus bepaald ofde doelstructuur mogelijk is, gegeven de wereldrelaties. Indien deze test faalt, zalnet zoals bij het falen van stap d een backtrack-stap gebeuren waarbij de overigetaggings en parse-trees onderzocht worden. Op het einde van deze procedure, wordt dus een doelstructuur bekomen die opeen enkele manier interpreteerbaar is en die uitvoerbaar is, gegeven de huidigewereldinformatie en de domeinkennis. Een pseudocode beschrijving van de aanpak vindt u in algoritme 1. De methodesdie opgeroepen worden, zullen later in het werk worden uitgewerkt.Algorithm 1 Pseudocode van de procedure voor de verwerking van de invoerin-structie tot uitvoerbare doelstructuur. relatieSets ← parse(instructie) for relaties in relatieSets do taggings ← tag(instructie, relaties) for tagging in taggings do doel ← maakDoel(instructie, relaties, tagging) if doel = null then if testDoel(doel, wereld) = true then return doel end if end if end for end for return f alse8
  • 1.3. Doelstelling en aanpak1.3.2 Oplossing van de gestelde problemenDoor gebruik te maken van de hiervoor beschreven aanpak worden de problemen vanambiguïteit en complexe structuren op een consistente manier afgehandeld. Zo wordtde grammaticale ambiguïteit opgelost door een set mogelijke grammaticale structurente genereren en wordt de semantische ambiguïteit opgelost door een set van mogelijkebetekenissen te bepalen. De gekozen doelstructuur is bovendien opgebouwd met demeest waarschijnlijke grammaticale structuur en zijn meest waarschijnlijke betekeniswaarvoor het bouwen van een doel en de controle op de huidige toestand van dewereld slaagt. Het probleem van de complexe instructies wordt door de voorgestelde aanpakopgelost door het gebruik van een beperkte set afhankelijkheidsrelaties. De instructiesworden namelijk herleid naar die relaties die verder geanalyseerd kunnen worden. Delangere en meer complexe instructies worden op deze manier dus herleid naar clustersvan afhankelijkheidsrelaties die op een gestructureerde manier kunnen verwerktworden. Voor meer informatie over de afhankelijkheidsrelaties wordt verwezen naarhet volgende hoofdstuk. Er zijn echter enkele vereisten om deze techniek te laten slagen. Zo zullen deafhankelijkheidsrelaties goed verwerkt moeten worden opdat de complexe structurenherkend worden en zal de set van tags dus de verschillende betekenissen van degebruikte woorden moeten bevatten. De verschillende betekenissen van de gebruiktewoorden kunnen wel beperkt worden naar de mogelijke betekenissen in het gekozendomein.1.3.3 Vereisten voor de invoerzinVoor het slagen van de techniek en eenvoud van de procedures te garanderen wordenenkele extra eisen opgelegd aan de invoerzin. Zo moet deze een grammaticaal correcteEngelstalige zin zijn. Dit aangezien we gebruik maken van een grammaticale parsevan de invoerzin. Indien deze niet grammaticaal is, bestaat de mogelijkheid dat degoede structuur van de zin niet gevonden kan worden. De reden waarom we enkelEngelstalige zinnen beschouwen, is dat voor de Engelse taal een veel breder gammaaan tools beschikbaar is. Bovendien gebeurt een groot deel van het onderzoek rondde verwerking van natuurlijke taal met het Engels. Verder wordt er ook van uit gegaan dat de invoerzin in het domein van de toepassingvalt. Een zin die niets te maken heeft met het Mario-universum zal dus mogelijkniet correct geanalyseerd kunnen worden. Naar alle waarschijnlijkheid wordt in datgeval een lege doelstructuur teruggegeven aangezien er geen actie te vinden is dievan toepassing is op de huidige wereld. Ook wordt er van uit gegaan dat er steedsinstructies worden gegeven. 9
  • 1. Inleiding Een correcte invoerzin voldoet dus aan volgende regels: • De invoerzin is in het Engels. • De zin drukt een instructie uit. • Het domein van de invoerzin is het Mario-universum. • De zin is grammaticaal correct.Zinnen die niet aan deze eisen voldoen, zullen naar alle waarschijnlijkheid een foutof leeg resultaat teruggeven. De zinnen in natuurlijke taal die gebruikt worden voorhet aansturen van de agent in de simulatieomgeving zullen ondanks deze eisen tochondersteund worden. Aangezien er gekozen is te werken met de Engelse taal, zullen de voorbeelden inde rest van dit document ook in het Engels zijn.1.4 OverzichtDe rest van dit document is opgebouwd in de uitvoeringsvolgorde van de stappen inde procedure. In hoofdstuk 2 wordt een toelichting gegeven over het extraheren vande parse-trees en afhankelijkheidsrelaties. Hoofdstuk 3 bevat meer informatie overde tagging-stap. Hier vindt u welk alfabet er gebruikt wordt en op welke manier detaggings gegenereerd worden. Ook vindt u hier meer informatie over de training enresultaten van de nauwkeurigheid van de module die voor deze stap gebruikt wordt. De informatie over het genereren van doelstructuren vindt u in hoofdstuk 4met onder andere de gebruikte techniek, maar ook hoe fouten bij de opbouw vandeze structuren gedetecteerd kunnen worden. Informatie over de controle van dezedoelstructuren vindt u in hoofdstuk 5 samen met de gebruikte technieken voor hetextraheren van de wereldinformatie. Ook wordt in dit hoofdstuk uitgelegd hoe deobjecten in de omgeving gekoppeld worden aan de objecten die vernoemd worden inde instructie. Hoofdstuk 6 bevat een lijst van testen uitgevoerd op de hier voorgestelde technieken een vergelijking van de behaalde resultaten met een eenvoudig basisalgoritme.Tenslotte wordt in hoofdstuk 7 een korte terugblik gegeven op de voorgesteldetechniek en worden enkele mogelijk interessante uitbreidingen aangehaald.10
  • Hoofdstuk 2De extractie vanafhankelijkheidsrelatiesIn dit hoofdstuk wordt dieper ingegaan op de eerste stap van het transformatieprocesvan instructie tot doelstructuur. Eerst zal toegelicht worden waarom er gekozen isom gebruik te maken van afhankelijkheidsrelaties en welke problemen er opgelostworden door ze te gebruiken (sectie 2.1). Vervolgens wordt een overzicht gegeven vanmethodes om deze afhankelijkheidsrelaties te verkrijgen (sectie 2.2). Tenslotte wordtbesproken hoe deze stap in de rest van het transformatieproces past (sectie 2.3).2.1 Voorstelling van grammaticale structuurIn de natuurlijke taal is de structuur van zinnen bepaald door middel van een setregels. Deze set regels vormt de grammatica van een specifieke taal. In deze sectielichten we enkele manieren toe om deze structuur voor te stellen.2.1.1 Parse-treesEen manier om de structuur van een zin voor te stellen, is door gebruik te maken vaneen parse-tree. Bij het bouwen van een parse-tree worden de woorden en zinsdelenvan de zin geannoteerd met hun lexicale categorie. Enkele voorbeelden van dezecategorieën zijn substantieven, adjectieven, voorzetsels, werkwoorden, voornaamwo-orden en lidwoorden. Voor een voorbeeld van een parse-tree, zie figuur 2.1. Merkook op dat de woorden in de zin gegroepeerd worden naar grotere blokken die ookeen lexicale eenheid vormen zoals de groep over the pipe. Een parse-tree bestaat dusuit groeperingen van delen van de zin tot grotere groepen tot uiteindelijk de hele zingevormd wordt. Wanneer een parser een parse-tree aanmaakt, wordt een lexicale categorie gekozenvoor alle woorden in de zin. Hierbij moet een keuze gemaakt worden tussen deverschillende lexicale categorieën die een bepaald woord kan hebben. Zo kan hetwoord jump een werkwoord zijn (van to jump), maar het kan ook een substantief 11
  • 2. De extractie van afhankelijkheidsrelaties S PP NP V P D NT J mpo e tep e u v rh ip Figuur 2.1: Parse-tree voor Jump over the pipe. S S PP NP PP PP NP PP NP NP NP V P D N PD N T T V P D N PD N T T J mpo e tep eo tef o u v rh i n h l r p o J mpo e tep eo tef o u v rh i n h l r p o Figuur 2.2: Twee mogelijke parse-trees voor Jump over the pipe on the floor.zijn (als in the jump). Bij het parsen moet er dus gedisambigueerd worden op delexicale categorieën. Niet enkel de lexicale categorie van een woord moet gekozen worden bij het parsen.Ook hoe de verschillende woorden aan elkaar hangen, wordt bij het parsen gekozen.Zo kan bij de zin: Jump over the pipe on the floor.het deel on the floor zowel bij aan pipe als aan jump hangen zoals weergegevenin figuur 2.2. Er moet dus bij het parsen ook gedisambigueerd worden op degrammaticale structuur van de zin.2.1.2 AfhankelijkheidsrelatiesEen andere manier om de grammaticale structuur van een zin voor te stellen is doorgebruik te maken van afhankelijkheidsrelaties. Afhankelijkheidsrelaties drukken derelaties tussen verschillende woordgroepen uit. Zo is in de zin uit figuur 2.1 hetwoord the het lidwoord van pipe en is the pipe dan weer een object van het voorzetselover. Een voorbeeld van een dergelijke set afhankelijkheidsrelaties zijn de StanfordDependencies[12].12
  • 2.1. Voorstelling van grammaticale structuurFiguur 2.3: Stanford Dependency relaties voor Jump over the pipe to the right if the monster is near the block. De verzameling van Stanford Dependencies bevat een zeer breed gamma aanmogelijke relaties tussen twee zinsdelen. Zo zijn er relaties voor het uitdrukken van deverschillende soorten van onderwerpen, maar ook voor verschillende modificeerrelaties,objectrelaties, complementrelaties, relaties voor conjuncties, ... Voor een volledigoverzicht van de verschillende relaties verwijzen we naar de Stanford DependencyManual[16]. Een voorbeeld van Stanford Dependencies vindt u in figuur 2.3. Hier ziet uondermeer de prep-relaties die voorzetselrelaties aanduiden en hun bijhorende pobj-relaties die het object van het voorzetsel koppelen aan het voorzetsel. Verder ziet unog de relaties om lidwoorden aan te duiden (det-relaties) en de onderwerpsrelatietussen monster en is. Ook kan de if-then-structuur herkend worden op basis van demark en advcl-relaties. Voor de Stanford Dependencies bestaan er verschillende vormen. Deze bepalenhoe ver de verschillende relaties samengevoegd worden. Zo kan de standaard prep-relatie (voorzetselrelatie) van een bepaald voorzetsel opgevouwen worden naar eenprep_word relatie tussen het woord waar het voorzetsel aan hangt en het objectvan het voorzetsel. In deze relatie wordt word dan vervangen door het voorzetsel.Dit gebeurt ook voor voorzetsels die uit twee woorden bestaan zoals across fromof groepen van drie woorden zoals in front of. In deze gevallen wordt dan deprep_in_front_of relatie tussen het woord waar de voorzetselzin aan hangt en hetobject van het voorzetsel gehangen. Ook conjuncties van meer dan één woord kunnen verkort worden naar een specialeconjunctierelatie. Zo kan bijvoorbeeld gekozen worden om groepen zoals but not eninstead of om te vormen naar een conj_negcc-relatie. Voor deze thesis is gekozen de standaardvorm te gebruiken waarin alle relaties inhun simpelste vorm behouden zijn en dus niet samengevoegd worden. Dit aangezien 13
  • 2. De extractie van afhankelijkheidsrelatiesop deze manier de set van relaties eindig en gekend is. Later werd echter besloten datsommige elementen uit andere vormen van de relaties uiterst nuttig kunnen zijn. Zokan met bepaalde vormen een ref -relatie opgevraagd worden waarbij verschillendewoorden naar hetzelfde fysieke object wijzen zoals in de zin: Jump over the pipe which is on the floor.Voor deze zin zou dan een relatie bestaan tussen which en pipe. Door de keuze omde standaardvorm te gebruiken, kan van deze relatie echter geen gebruik gemaaktworden. De afhankelijkheidsrelaties tonen dus de verbanden tussen de verschillende woordenin de zin in plaats van hoe grotere delen van de zin opgebouwd worden uit de kleineredelen zoals bij de parse-trees. Omdat er een beperkte gekende set is van dezeafhankelijkheidsrelaties en voor iedere zinsstructuur een abstractie naar deze relatiesgemaakt kan worden, voegen deze relaties zeer interessante informatie toe over deopbouw van de zin en de rol van zijn delen. Zo zal een onderwerp bij een actie inde applicatie de agent zijn die de actie moet uitvoeren of uitvoert. Er werd voorgekozen deze informatie te gebruiken als kennis over de structuur van de instructie.Op basis van deze informatie zal later een rol toegekend worden aan de verschillendewoorden en woordgroepen.2.2 Analyse van grammaticale parsersOmdat het doel van deze thesis niet ligt in het extraheren van de afhankelijkheidsre-laties, maar het systeem deze eerder als informatiebron gebruikt, werd gekozen omeen bestaande tool te gebruiken. Om de afhankelijkheidsrelaties te verkrijgen, zijn verschillende opties mogelijk.Zo biedt de Stanford Natural Language Processing groep een eigen parser aan dieeen zin kan omzetten naar de k-best collecties van deze relaties: één voor iederemogelijke parse-tree. Alternatief kan deze parser ook een parse-tree geannoteerd metde Penn Treebank tags[33] als invoer aannemen. In dat geval worden de relaties voordie parse-tree teruggegeven. Bovenstaande mogelijkheden werden iets dieper onderzocht. Bij dit onderzoek lagde focus vooral op het vinden van unieke verzamelingen van afhankelijkheidsrelaties.Verschillende parse-trees kunnen namelijk dezelfde afhankelijkheidsrelaties geven. Ditkomt vooral voor indien de categorieën waarmee de woordgroepen geannoteerd wordenin de parse-trees gelijkaardig zijn. Ook is het belangrijk dat de afhankelijkheidsrelatiescorrect uit de parse-tree gehaald kunnen worden. In het onderzoek beschouwden we volgende drie opties:14
  • 2.2. Analyse van grammaticale parsers • Gebruik maken van de Link Grammar parser en deze parse-tree als invoer geven aan de Stanford parser. • Gebruik maken van de Berkeley parser en deze parse-tree als invoer geven aan de Stanford parser. • Gebruik maken van enkel de Stanford parser.Hier volgt een kort overzicht met de resultaten voor iedere parser.2.2.1 De Link Grammar parserDe Link Grammar parser[41] is de oudste van de gekozen parsers. Naast hetbepalen van een parse-tree heeft deze parser ook een spin-off project dat aan relatie-extractie doet: het RelEx-project[19]. Aangezien er echter gekozen was de StanfordDependencies te gebruiken, werd dit spin-off project niet verder onderzocht. De parser maakt gebruik van een linkage-model waarbij de opeenvolgende woordenen woordgroepen aan elkaar gelinkt worden als waren het puzzelstukken. Voor iederelinkage kan dan opgevraagd worden hoe goed deze is. Bovendien worden de bestelinkages eerst teruggegeven in k-best stijl. Ook merken we op dat de teruggegevenparse-trees uniek zijn en unieke sets van afhankelijkheidsrelaties geven. Er zijn echter ook een paar nadelen aan de parser. Zo zijn er problemen metcomplexere zinnen zoals bij if-then-else en first-next-structuren. Bij dit soort zinnenzijn vaak zeer veel parses nodig alvorens de correcte parse gevonden kan worden.Verder merken we ook op dat conjuncties en punctuaties vaak problemen geven.Deze structuren zijn echter noodzakelijk voor de beoogde toepassing. Omwille vandeze redenen werd de Link Grammar parser niet gebruikt. Het feit dat het parsenbovendien redelijk lang duurt, werd ook als een minpunt beschouwd.2.2.2 De Berkeley parserDe Berkeley parser[37] maakt gebruik van een probabilistische contextvrije gram-matica of PCFG[22]. Het parsen verloopt snel en de parse-trees worden net als bijLink Grammar op een k-best manier teruggegeven. Bovendien merken we op datook hier unieke parse-trees met unieke sets van afhankelijkheidsrelaties teruggegevenworden. Tevens claimt de Berkeley NLP groep dat hun parser de meest nauwkeurigeen snelste is voor een breed gamma aan talen. Het grootste nadeel van de parser is dat er relatief weinig documentatie over tevinden is. Ondanks de vele opties maakt dit de parser moeilijk te gebruiken. Eénvan deze vele opties is de optie voor binarisatie. Met de standaard instellingen geeftde Berkeley parser de parse-trees in binaire vorm terug. Bij het omzetten van dezebinaire bomen naar afhankelijkheidsrelaties loopt het echter vaak mis. Zo kan welbepaald worden dat er een relatie is tussen twee woordgroepen, maar de aard vande relatie kan vaak niet gegeven worden. Wanneer de optie uitgeschakeld wordt en 15
  • 2. De extractie van afhankelijkheidsrelatiesniet-binaire parse-trees teruggegeven worden, is het voor de Stanford parser mogelijkom de afhankelijkheidsrelaties goed te bepalen. Om een goede samenwerking met deStanford parser te verzekeren, is deze optie dus uitgeschakeld.2.2.3 De Stanford parserDe Stanford parser[24] is net als de Berkeley parser een probabilistische parser enmaakt ook gebruik van PCFG’s. In tegenstelling tot de Berkeley parser is voor deStanford parser wel veel documentatie te vinden. Verder zijn er grote gelijkenissenmet de Berkeley parser zoals het teruggeven van de k-best parse trees. De kwaliteitvan deze parse-trees is echter verschillend. De k-best parses zijn onderling nietverschillend. Dezelfde parse kan meerdere keren voorkomen en alternatieven komenniet aan bod. Dit is een zeer ernstige tekortkoming voor de beoogde toepassing.Het meerdere keren analyseren van dezelfde foutieve structuur heeft namelijk geennut. Het is hier wel mogelijk om een unieke lijst met structuren samen te stellen envervolgens enkel deze structuren verder te gebruiken in het proces. Het genererenvan de parse-trees met dezelfde afhankelijkheidsrelaties zal echter meer tijd vragen.2.2.4 De gekozen combinatieGebaseerd op de hier boven vermelde voor- en nadelen van de onderzochte parsers,werd er voor gekozen de Berkeley parser te gebruiken, gecombineerd met de Stanfordparser. Vooral de argumenten dat de Berkeley parser accuraat is en verschillendesets van afhankelijkheidsrelaties geeft, wegen bij deze keuze door. De keuze wordtook ondersteund door externe onderzoeken[13] waar besloten wordt dat de hiergekozen combinatie zowel op gebied van snelheid als nauwkeurigheid zeer goedscoort. Ook bleek dat de nauwkeurigheid van de afhankelijkheidsrelaties voor dezecombinatie beter is dan de nauwkeurigheid van veel gespecialiseerde parsers voorafhankelijkheidsrelaties.2.3 Plaats in het procesDe extractie van afhankelijkheidsrelaties uit de invoerzin gebeurt door eerst te parsennaar een parse-tree met de Berkeley parser en vervolgens deze parse-tree als input tegebruiken voor de Stanford parser. Deze genereert hierop de afhankelijkheidsrelatiesvoor deze parse-tree. Aan de Berkeley parser worden de k-best parse-trees opgevraagd. Het aantalparse-trees dat opgevraagd zal worden, wordt een parameter van het uiteindelijkeprogramma. Zoals vermeld in sectie 1.3 worden de parse-trees verder één voor éénafgehandeld. De gebruikte volgorde is die van afnemende waarschijnlijkheid. Aanhet begin van het proces wordt de meest waarschijnlijke parse-tree gekozen. Dezewordt vervolgens doorgegeven aan de Stanford parser die de afhankelijkheidsrelatiesbepaalt. Deze relaties worden tenslotte doorgegeven aan de volgende stappen in hetproces.16
  • 2.3. Plaats in het proces In een latere stap in het proces, bijvoorbeeld bij het aanmaken van de doelstructuur,kan echter opgemerkt worden dat de gekozen parse-tree fout is. Indien dit het gevalis, wordt de volgende meest waarschijnlijke parse-tree gekozen en wordt het proceshiervoor herhaald. Deze lus stopt wanneer een parse-tree gekozen wordt waarvoorgeen fouten gevonden worden bij het bouwen van de doelstructuur en het testenvan de gemaakte structuur tegen de wereld- en domeinkennis. Er wordt ook uit delus gebroken indien alle beschikbare parse-trees afgewerkt zijn. In dat geval kangeen doelstructuur gevonden worden. Het is echter mogelijk dat het aantal gekozenparse-trees te klein was of dat een andere parameter slecht ingesteld was. Het aantalte controleren parse-trees kan best hoog genoeg ingesteld worden zodat de correcteparse-tree afgewerkt wordt, ook al heeft deze mogelijk een lage probabiliteit en duiktdeze pas laat in de lijst met mogelijke parse-trees op. De methode voor de bepaling van afhankelijkheidsrelaties vindt u in algoritme 2.Algorithm 2 Algoritme voor het omzetten van de instructie naar afhankelijkheid-srelaties. parseT rees ← berkeley.parse(instructie) for i = 1 → parseT rees.size do relaties[i] ← stanf ord.parse(parseT rees[i]) end for return relaties 17
  • Hoofdstuk 3Het taggen van de instructieDit hoofdstuk handelt over de tagging-stap van het transformatieproces van instructienaar doelstructuur. Eerst wordt besproken wat de tagging stap juist inhoudt (sectie3.1). Vervolgens wordt ingegaan op de opbouw van het tagging alfabet (sectie 3.2)waarna de techniek om de tagging uit te voeren toegelicht wordt (sectie 3.3). Hiernawordt uitgelegd hoe de training van het gebruikte mechanisme verloopt (sectie 3.4)en wordt een kort overzicht gegeven over het testen van het gebruikte mechanisme(sectie 3.5). Vervolgens wordt op basis van deze testen een verbetering voorgesteld(sectie 3.6). Tenslotte wordt besproken hoe de tagging stap in de rest van het procespast (sectie 3.7).3.1 Wat is tagging?De tagging-stap is verantwoordelijk voor het toekennen van een semantische betekenisaan de woorden uit de invoerinstructie. Tevens reduceert de stap natuurlijke taaltot een beperkte set gekende tags. Hierbij moet rekening gehouden worden metsemantische ambiguïteit waarbij woorden verschillende betekenissen kunnen hebben.Ook moeten alle synoniemen herleid kunnen worden naar een tag die deze betekenisvoorstelt. Om dit te realiseren, wordt in deze stap aan ieder woord in de zin een tagtoegewezen. Een dergelijke tag heeft juist één betekenis en is niet dubbelzinnig. Inhet ideale geval zou aan ieder woord meteen de juiste tag toegewezen worden. Doorde ambiguïteit in natuurlijke taal is de juiste tag echter niet te bepalen op basisvan enkel het woord: er moet ook gekeken worden naar de omliggende woorden ende rol(len) van het woord in de zin. Zo heeft bijvoorbeeld het woord after tweeverschillende betekenissen in volgende zinnen: Jump across the gap after the pipe. After jumping across the gap, go right.In de ene zin is de betekenis rechts van (gezien dat de Mario-wereld van links naarrechts loopt) terwijl in de tweede zin de betekenis nadien gebruikt moet worden. 19
  • 3. Het taggen van de instructie Er kunnen meerdere mogelijke series van tags bij een bepaalde instructie horen.Hierdoor moet er gezorgd worden dat alle mogelijkheden bestudeerd kunnen worden.Ook zal het alfabet alle mogelijke betekenissen van termen in het gekozen domein,de MarioAI-wereld, moeten bevatten. Indien dit niet het geval is, zal de term nietherkend kunnen worden.3.2 Het tagging alfabetZoals vermeld in sectie 3.1 moet bij het bouwen van het tagging alfabet gezorgdworden dat de verschillende betekenissen van termen in het gekozen domein uitgedruktkunnen worden. Indien bijvoorbeeld een object of structuur uit het domein geen tagheeft in het alfabet, kan het niet herkend worden. Er moet dus gezorgd worden dathet alfabet compleet genoeg is om de meest voorkomende instructies af te handelen.In het ideale geval bevat het tagging alfabet ieder relevant begrip uit het domein.3.2.1 Het bepalen van de tagsOm de betekenissen van woorden in het gekozen domein zo goed mogelijk te dekken,werd er voor gekozen om het tagging alfabet samen te stellen op basis van eenverzameling aan mogelijke voorbeeldinstructies. Deze voorbeeldinstructies werdengevonden in de vorm van walkthroughs. Walkthroughs bevatten omschrijvingen van acties die uitgevoerd moeten wordenom een specifiek level (of meerdere levels) in een videospel uit te spelen. Ze bevattenechter verschillende niveaus van instructies. Zo kunnen voor complexe delen vaneen level de uit te voeren acties op een zeer gedetailleerde manier omschreven zijn.De eenvoudige delen van levels kunnen dan weer op zeer hoog niveau omschrevenworden. Ook worden vaak eenvoudigere delen van een level overgeslagen omdat ervan uit gegaan wordt dat de speler hier niets mis kan doen. Walkthroughs wordenmeestal opgesteld door spelers van een spel die anderen willen helpen om het spel uitte kunnen spelen. De walkthroughs gebruikt als trainings- en testdata zijn afkomstigvan GameFaqs[5]. Een extract van een walkthrough kan u vinden in appendix A. Aangezien de gebruikte simulatieomgeving gebaseerd is op de Super Mario Bros.spellenreeks, kan op basis van walkthroughs voor deze reeks een uitgebreide setaan mogelijke instructies gevonden worden. Uit deze walkthroughs werd een groepzinnen geselecteerd die voldoen aan de vereisten voor een invoerzin zoals beschrevenin sectie 1.3.3. De tags nodig voor deze instructie werden daarna toegevoegd aan hetalfabet. Er werd gekozen enkel tags toe te voegen die nodig zijn voor het uitvoerenvan de acties. Bovendien werd er bij het opstellen van de tags gebruik gemaaktvan de beschikbare domeinkennis. Zo is bijvoorbeeld gekozen om geen tags toe tevoegen voor de omschrijving van de kleur van wereldobjecten. De reden hiervoorligt in het feit dat de verschillende objecten steeds dezelfde kleur hebben. Zo is eenblok steeds bruin. Omschrijvingen voor bijvoorbeeld de positie van een object in de20
  • 3.2. Het tagging alfabet jump run go_to fireball kill exists collect bump avoid moving top bottom left right middle in platform stairs block question_block pipe wall flower monster mario coin gap power-up air floor above below left_of right_of on_top near across side_of between from effect not if until and or action_sub action_after action_before action_goal action_constraint number order next none Tabel 3.1: Tagging alfabetwereld werden wel toegevoegd. Voor lidwoorden werden geen tags opgesteld. Voorvolgende instructies: Jump across the gap. Jump across a gap.voegt het lidwoord geen informatie toe over de concrete wereldsituatie. Na de analyse van een collectie van 684 zinnen uit walkthroughs opgesteld doordrie verschillende personen, kon een set van 55 tags opgesteld worden. De lijst vantags kan u vinden in tabel 3.1. Een lijst met alle tags en hun betekenis opgedeeld inde hieronder vernoemde categorieën vindt u in appendix B. Er is ook een standaardtag gekozen: de none-tag. Deze tag zal toegewezen wordenaan de woorden in een instructie die niet relevant zijn voor de uitvoer van dezeinstructie. Dit zal het geval zijn voor bijvoorbeeld de kleur van een platform. Eenuitbreiding van het hier voorgestelde systeem zou extra tags kunnen toevoegen omook deze betekenissen te kunnen dekken.3.2.2 Soorten tagsTijdens het opstellen van het tagging alfabet, werd reeds snel opgemerkt dat deverschillende tags opgesplitst kunnen worden in categorieën. Het groeperen van detags in verschillende categorieën is gebaseerd op de eigenschappen van de tags zoalsde eigenschap dat het identificeerbare objecten in de omgeving zijn of dat ze eenuitvoerbare actie voorstellen. De veralgemening van tags in groepen wordt later inhet doelconstructie- en doelcontroleproces gebruikt. We maken een onderscheid tussen volgende categorieën:Acties bevatten een actie van de omgeving of een omschrijving van de toestand van de omgeving. 21
  • 3. Het taggen van de instructieActie-coördinaties drukken een verband uit tussen meerdere acties.Voorwaarden verwijzen naar een verband tussen een omschrijving van de omgeving en een actie.Locaties drukken locaties op het scherm uit of zone’s ten opzichte van objecten.Objecten verwijzen naar instantieerbare objecten uit de omgeving.Relaties drukken een verband uit tussen twee of meerdere locaties/objecten of een verband tussen een actie en een locatie/object.Hoeveelheden zijn tags die te maken hebben met aantallen van acties en objecten en volgordes van objecten.Coördinatie is de categorie van tags die twee of meerdere tags van hetzelfde type gaan groeperen in grotere groepen.Negatie bevat een tag die de negatie van een andere tag uitdrukt.Default is de categorie voor de tag die zal verwijzen naar alle woorden die niet als een andere tag kunnen benoemd worden. Wanneer gekeken wordt waarvoor de verschillende tags gebruikt worden, zien weook hier drie deelalfabetten:Het actie-alfabet bevat tags voor de uitvoerbare acties voor onze agent.Het wereld-alfabet bevat tags voor objecten, structuren, relaties en agents in de wereld.Het syntax-alfabet bevat tags voor de coördinatie van de verschillende acties.Voor de opdeling van het alfabet in de verschillende subalfabetten, verwijzen we naarappendix B.3.3 De gebruikte techniekBij het genereren van de taggings voor een bepaalde zin moet, zoals reeds aangehaaldin sectie 3.1, er voor gezorgd worden dat alle mogelijke taggings teruggegeven worden.De meest waarschijnlijke tagging wordt bovendien liefst als eerste teruggegeven. Ookzou het zeer handig zijn indien ongekende woorden getagd kunnen worden op basisvan de omliggende woorden en de grammaticale rol van het woord. De techniek moet dus een probabilistische classificatie doen op de woorden vande invoerzin en moet in staat zijn om een tag toe te kennen op basis van naburigewoorden. Bovendien willen we de mogelijkheid om ook de eerder bepaalde afhanke-lijkheidsrelaties mee te geven aan deze classifier. Op basis hiervan kan namelijkafgeleid worden wat de rol van het woord in de zin is. Om aan al deze eisen tevoldoen, is gekozen gebruik te maken van een Conditional Random Field (CRF)[29].3.3.1 Conditional random fieldsEen conditional random field[29] of CRF is een probabilistisch grafisch model datgebruikt kan worden voor het labelen van sequentiële data. Een CRF is vergelijkbaar22
  • 3.4. Het trainen van de CRFmet een Hidden Markov Model (HMM)[38]: iedere knoop in de grafe stelt eenrandom variabele voor en de bogen tussen deze knopen stellen verbanden tussendeze variabelen voor. Het belangrijkste verschil tussen CRF’s en HMM’s is echterdat de bogen van een CRF ongericht zijn. Bij het trainen van een CRF wordt er van uit gegaan dat de waardes van sommigeknopen steeds geobserveerd kunnen worden terwijl de waardes van de overige knopenafgeleid moeten worden op basis van de beschikbare gegevens. Voor de ongeob-serveerde variabelen van de CRF zal tijdens de trainingsstap een distributie wordengeïnfereerd. De CRF zal deze distributie gebruiken om te voorspellen wat de waardevan een bepaalde variabele is, gegeven een set gekende variabelen. De CRF zal een distributie leren voor de tag die bij een woord hoort. Hierbij zalde CRF gebruik maken van de tags die voor en achter de te voorspellen tag staan ende andere variabelen die meegegeven worden aan de CRF. Voor een uitgebreidere uitleg over CRF’s verwijzen we naar de literatuur[29].3.3.2 MalletVoor de implementatie van de CRF wordt gebruik gemaakt van de Mallet toolbox[35].Deze toolbox is ontwikkeld met het oog op onder andere probabilistische naturallanguage processing en is geschreven in Java. Dit is nuttig aangezien de gebruiktesimulatieomgeving ook in Java geschreven is. Het koppelen van de tools kan hierdoorop een eenvoudige manier gebeuren.3.4 Het trainen van de CRFVoor het trainen van de CRF werd net zoals bij het opstellen van het tagging alfabet(sectie 3.2.1) gebruik gemaakt van walkthroughs. Er is gebruik gemaakt van dezelfdezinnen als bij het opstellen van het tagging alfabet. Naast de woorden waaruit de zinnen bestaan, worden de rollen van dit woord inde afhankelijkheidsrelaties meegegeven. Deze rollen worden bepaald door voor deafhankelijkheidsrelaties die bij het woord horen, het woord te vervangen door een Xen het andere woord te vervangen door een _. De gebruikte afhankelijkheidsrelatiesin de trainingsstap bestaan uit een correcte grammaticale structuur in het gegevendomein. We geven een voorbeeld hoe de trainingsdata wordt opgebouwd aan de hand vanvolgende zin: Now you must run over the small gaps.Bij deze zin horen volgende afhankelijkheidsrelaties: 23
  • 3. Het taggen van de instructie advmod(run-4, now-1), nsubj(run-4, you-2), aux(run-4, must-3), prep(run-4, over-5), det(gaps-8, the-6), amod(gaps-8, small-7), pobj(over-5, gaps-8) Op deze data wordt een procedure opgeroepen die later gebruikt wordt om inputvoor de CRF te produceren voor een ongekende invoerzin. Deze procedure isuitgewerkt in algoritme 3.Algorithm 3 Algoritme voor het omvormen van de invoerinstructie en afhankeli-jkheidsrelaties naar invoerdata voor de CRF. for woord in zin do print woord+“ ” for relatie in relaties do if relatie.f irst = woord then print relatie.type+“(X, _) ” end if if relatie.second = woord then print relatie.type+“(_, X) ” end if end for end for Aan de data bekomen uit dit algoritme wordt vervolgens manueel een tag toegekendaan ieder woord. Wanneer we deze procedure toepassen op de hier boven gegevenvoorbeelddata, geeft dat: now advmod(_,X) none you nsubj(_,X) mario must aux(_,X) none run advmod(X,_) nsubj(X,_) aux(X,_) prep(X,_) run over prep(_,X) pobj(X,_) across the det(_,X) none small amod(_,X) none gaps det(X,_) amod(X,_) pobj(_,X) gapMerk op dat small getagd wordt met none aangezien er geen tag voorzien is voordeze betekenis. Dit kan echter makkelijk toegevoegd worden als uitbreiding net alstags voor andere mogelijke eigenschappen.3.5 Het testen van de CRFVoor het testen van de CRF werd gekeken naar enkele verschillende statistieken. Zowerd gekeken naar de accuracy en recall van iedere tag en naar het aantal zinnenwaarvoor de eerste voorspelling correct is. Er werden testen uitgevoerd voor tweeverschillende instellingen van de CRF: het al dan niet volledig verbonden zijn vande knopen en de gewichten voor de features voor de overgangen tussen de woorden.24
  • 3.5. Het testen van de CRF Set Test nfc-sparse nfc-dense fc-sparse Token accuracy 0,9866 0,9867 0,9865 Instance accuracy 0,7721 0,7742 0,7705 Training Tag accuracy: P 0,9824 0,9826 0,9821 Tag accuracy: R 0,9836 0,9837 0,9835 Tag accuracy: F1 0,9829 0,9830 0,9827 Token accuracy 0,9048 0,9050 0,9050 Instance accuracy 0,2545 0,2487 0,2472 Testing Tag accuracy: P 0,8892 0,8999 0,9009 Tag accuracy: R 0,7982 0,7950 0,7941 Tag accuracy: F1 0,8538 0,8543 0,8583Tabel 3.2: Resultaten van experimenten van de CRF voor instellingen. Niet volledig verbonden: nfc; volledig verbonden: fc.Voor deze gewichten maken we gebruik van twee standen: dense en sparse. De eerstestand gebruikt zoveel mogelijk features voor de overgang. De tweede daarentegengebruikt enkel de tag als feature voor de overgangen. De CRF die uiteindelijk gebruikt wordt in het programma werd geoptimaliseerdop basis van de gemiddelde recall over alle tags. De reden hiervoor ligt in het feitdat het voor de beoogde toepassing vooral belangrijk is dat een tag ooit toegewezenwordt aan een woord. Indien dit niet het geval is, kan het namelijk voorkomen dateen correcte structuur niet gevonden wordt. De gemiddelde accuracy, recall en F1 functie over alle tags kan u zien in tabel3.2. Ook vindt u in deze tabel de token accuracy en instance accuracy. De tokenaccuracy duidt aan hoe vaak een woord de correcte tag krijgt en de instance accuracydrukt uit hoe groot de kans is dat de eerste tagging voor een zin correct is. Er werdgetraind over 500 iteraties en gebruik gemaakt van 10-fold cross validation[25]. Uit deze testresultaten blijkt dat een simpele CRF die niet volledig verbondenis en enkel de tags gebruikt in de overgangen tussen de woorden beter scoort danCRF’s met andere instellingen wanneer er gekeken wordt naar de recall en instanceaccuracy voor de testset. Voor de trainingsset valt de CRF met deze instellingenechter net tussen de twee andere CRF’s in. Op basis van deze vaststellingen werdbesloten om de CRF met de nfc-sparse-instellingen te gebruiken. Merk op dat eentest voor de fc-dense instelling niet uitgevoerd is. De reden hiervoor ligt in het feitdat deze CRF te groot werd om praktisch in het geheugen te laden. Wanneer we kijken naar de fouten die gemaakt worden door de CRF, zien we datvoor woorden waarvoor de tag zeer voor de hand liggend is toch een fout gemaakt kanwordt. Zo wordt het woord Goomba, de naam van een monster in de Mario-wereld, 25
  • 3. Het taggen van de instructievaak fout getagd. Toch is er maar één correcte tag voor dit woord namelijk: monster.De fout getagde woorden krijgen echter tags die veel voorkomen in combinatie met deomliggende tags. Mogelijk lost meer trainingsdata met meer mogelijke combinatiesvan tags dit probleem op.3.6 Herkennen en herstellen van incorrecte taggingsUit testen met de CRF blijkt dat woorden met een beperkte set mogelijke betekenissenvaak toch fout getagd worden. Soms worden er zelfs betekenissen toegeschreven aaneen woord die onmogelijk zijn in het domein. Om deze tekortkoming te compenseren,is er voor gekozen om gebruik te maken van een lexicale database. In deze databasezitten per woord de mogelijke tags. Hiermee zal geprobeerd worden incorrectetaggings te herkennen. Het woordenboek met mogelijke tags per woord is opgesteld door gebruik te makenvan de trainingsdata van de CRF. Voor ieder woord dat meer dan vijfmaal voorkomtin de trainingsdata (een totaal van 13190 woorden waarvan 727 unieke) is een entrygemaakt in het woordenboek. Dit is een totaal van 273 woorden. Voor elk woorduit de trainingdata is er een tabel opgesteld met alle gebruikte tags. Zo heeft hetwoord the steeds de tag none terwijl er voor het woord to de keuze is uit vijf tags:action_goal, on_top, side_of, near en none. Na het bepalen van een tagging door de CRF wordt voor ieder woord in deinstructie gecontroleerd welke mogelijke tags in het woordenboek staan. Indien erslechts één mogelijke tag is, zal deze toegewezen worden. Wanneer er meerdere tagsmogelijk zijn, zal als de gekozen tag in deze lijst staat, de tagging aanvaard worden.Als de gekozen tag niet in de lijst staat, zal de tagging als ongeldig bestempeldworden. Een nadeel van het woordenboek is dat betekenissen voor woorden die niet gezienzijn in de trainingsdata, niet in het woordenboek zullen staan. Indien in een instructieeen woord voorkomt met een betekenis die niet in het woordenboek staat, kan decorrecte tagging dus foutief verworpen worden. De invloed van het woordenboek opde nauwkeurigheid van de taggings zien we in tabel 3.3. Uit de testresultaten bij gebruik van het woordenboek zien we dat de nauwkeurigheidvan de taggings zeer licht stijgt. Dit komt doordat tags bij een woord waarbij maaréén tag mogelijk is, vervangen worden door de correcte tag. Merk op dat voor de test-data meer dan een vierde van de fout voorspelde instances herkend kunnen worden.Door deze taggings te herkennen als foutief, zullen ze later niet gebruikt kunnen wor-den om een doelstructuur te genereren. De op basis van deze taggings gegenereerdedoelstructuren zouden namelijk steeds fout zijn voor de gegeven instructie.26
  • 3.7. Plaats in het proces Set Test zonder met Token accuracy 0,9866 0,9871 Instance accuracy 0,7721 0,7761 Training Foute instances 0 0,0376 Tag accuracy: P 0,9824 0,9828 Tag accuracy: R 0,9836 0,9842 Tag accuracy: F1 0,9829 0,9834 Token accuracy 0,9048 0,9054 Instance accuracy 0,2545 0,2589 Testing Foute instances 0 0,2696 Tag accuracy: P 0,8892 0,8902 Tag accuracy: R 0,7982 0,7991 Tag accuracy: F1 0,8538 0,8596Tabel 3.3: Resultaten van experimenten van de CRF met en zonder woordenboekvoor een niet volledig verbonden en sparse. Foute instances is het percentage van instances met een fout waarvan herkend kan worden dat de tagging fout is. Op basis van deze vaststellingen kan men zich afvragen of de gebruikte techniekvoor het bepalen van de taggings wel optimaal is. Er werd echter geen andere techniekvoor het behalen van meer correcte taggings gezocht.3.7 Plaats in het procesDe tagging-stap wordt uitgevoerd na het uitvoeren van de parsing-stap. De redenhiervoor ligt in het feit dat de afhankelijkheidsrelaties bepaald in de parsing-stapgebruikt zullen worden bij het taggen. De uitvoer van deze stap, de k-best taggings,zal op zijn beurt gebruikt worden als invoer voor de doelconstructie-stap. Om de tagging sequenties te bekomen, worden eerst de invoerinstructie en deafhankelijkheidsrelaties omgezet naar invoerdata voor de CRF. Dit gebeurt zoalsuitgelegd in sectie 3.4. Vervolgens wordt deze data als invoer aan de CRF gegeven.De CRF berekent hierop de k-best mogelijke taggings. Het aantal taggings datteruggegeven moet worden, kan worden ingesteld als een parameter voor de globaleprocedure. De invloed van deze parameter zal later uitgebreider uitgelegd worden,maar het is reeds handig op te merken dat het noodzakelijk is dat minstens voldoendetaggings gegenereerd moeten worden om te zorgen dat de correcte tagging in deteruggegeven set zit. Uiteraard moet ook gezorgd moeten worden dat er niet te veeloverbodige taggings worden teruggegeven. De tagging-procedure is uitgewerkt in algoritme 4. 27
  • 3. Het taggen van de instructieAlgorithm 4 Algoritme van de tagging-stap. inputdata ←“” for woord in instructie do inputdata ← inputdata + woord+“ ” for relatie in relaties do if relatie.f irst = woord then inputdata ← inputdata + relatie.type+“(X, _) ” end if if relatie.second = woord then inputdata ← inputdata + relatie.type+“(_, X) ” end if end for end for return taggings ← crf.apply(inputdata, k)28
  • Hoofdstuk 4DoelconstructieIn dit hoofdstuk wordt de constructie van doelstructuren toegelicht. Eerst wordtuitgelegd hoe de doelconstructie gebeurt (sectie 4.1). Hierin wordt ook uitgelegdwelke patronen gebruikt worden voor het bouwen van de gebruikte gegevensstructuur(sectie 4.1.1). Verder wordt toegelicht hoe de data in deze structuur getransformeerdwordt naar de uiteindelijke doelstructuur (sectie 4.2). Hierbij wordt ook uitgelegd hoehet bij de opbouw van het doel het mogelijk is om fouten tegen de domeinkennis tedetecteren (sectie 4.2.3). Tenslotte wordt de plaats van de doelconstructie besprokenin de globale procedure (sectie 4.3).4.1 Hoe gebeurt doelconstructie?In de eerste stap van de doelconstructie wordt de informatie uit de afhankelijkheidsre-laties en de semantische informatie uit de tagging stap verwerkt. Na de tagging stapis voor elk woord uit de invoerinstructie een tag bekend die de semantische rol van hetbijhorende woord in de instructie uitdrukt. Dit gebeurt door gebruik te maken vanpattern matching. Voor elk van de tags zijn er patronen op afhankelijkheidsrelatiesopgesteld. Indien een patroon matcht, wordt de informatie in deze relaties omgezetnaar een relationele mapping tussen de verschillende woorden. Na deze stap moeten alle belangrijke afhankelijkheidsrelaties verwerkt zijn. Eengroep afhankelijkheidsrelaties is belangrijk als met deze relaties een pad gevormd kanworden tussen twee woorden die niet getagd zijn met de default tag, in dit geval denone tag. Na het toepassen van de patronen op alle woorden in de invoerinstructiewordt er een controle gedaan op de ongebruikte afhankelijkheidsrelaties. Indienhier belangrijke relaties tussen zitten, kan niet alle informatie voor de gekozenafhankelijkheidsrelaties en tags uit de instructie gehaald worden. Dit kan te wijtenzijn aan twee zaken: ofwel ontbreken er patronen ofwel is de gekozen combinatievan relaties en tags incorrect. Er zal gebacktrackt worden over de volgende taggingsen/of parses. 29
  • 4. Doelconstructie Het algoritme voor het bepalen van de verbanden tussen de woorden en de semantis-che rol is beschreven in algoritme 5. Het toepassen van een patroon legt de verbandentussen de verschillende woorden in de zin. Dit gebeurt enkel indien het patroongematcht wordt. Een patroon kan matchen op basis van de afhankelijkheidsrelatiestussen de verschillende woorden en de tags van deze woorden.Algorithm 5 Procedure voor het bepalen van de verbanden tussen de woorden. for woord in instructie do for patroon in patronen do patroon.apply(woord, relaties, tagging) end for end for4.1.1 De patronenZoals besproken in sectie 3.2.2 zijn de tags opgedeeld in verschillende categorieën.Voor deze categorieën zijn patronen gedefinieerd welke de afhankelijkheidsrelaties bijhet woord kunnen verwerken. Voor het bepalen van de patronen is gebruik gemaaktvan dezelfde geannoteerde walktroughs als gebruikt voor het trainen van de CRF. In deze sectie wordt een beperkte set van patronen toegelicht. Voor een completelijst van patronen verwijzen we naar appendix D.Patronen voor objectenVoor objecten zijn er twee belangrijke patronen: het patroon voor het herkennenvan modifiers en het patroon voor het herkennen van relaties. Onder objecten vallende volgende tags: platform, pipe, gap, wall, stairs, coin, power-up, floor, air, flower,mario, monster, block en question_block. De patronen voorgesteld in dit deel zijnechter zeer algemeen en zijn op de meeste types tags van toepassing. Zo zijn dezetwee patronen ook van toepassing op de hoeveelheden en in licht aangepaste vormop de acties.Het patroon voor modifiers van objecten Modifiers komen voor in veel vor-men. Ze hebben dan ook veel verschillende types van relaties. De Stanford Depen-dency Manual[16] maakt melding van volgende types van relaties: abbrev, amod,appos, advcl, purpcl, det, predet, preconj, infmod, partmod, advmod, neg, rcmod,quantmod, tmod, measure, nn, num, number, prep, poss, possessive en prt. Enkelevan deze relaties zijn echter enkel mogelijk voor werkwoorden of bijvoorbeeld conjunc-ties. Sommige andere relaties moeten dan weer afgehandeld worden op een specialemanier zoals bijvoorbeeld de prep-relatie die beschreven wordt in het volgende deel.De set relevante relaties die voorkomt voor objecten in de walkthrough-data is echterveel beperkter: amod, det, advmod, nn, num, poss en possessive. Bij deze relatieskomen echter ook enkele andere relaties die in combinatie met woorden getagd als30
  • 4.1. Hoe gebeurt doelconstructie?objecten een modifier-rol hebben. Deze relaties zijn: aux, dobj en pcomp. Ditpatroon kan bijvoorbeeld toegepast worden op het woord platform voor volgendedata:Instructie: Jump on the left-most small platform.Relaties: prep(jump-1, on-2), det(platform-6, the-3), amod(platform-6, left-most-4), amod(platform-6, small-5), pobj(on-2, platform-6)Tagging: jump, on_top, none, left, none, platformVoor het matchen van dit patroon, moet het woord dat verbonden is via deze relatieniet getagd zijn met de default tag, in dit geval none. Wanneer het patroon wordttoegepast, wordt het gerelateerde woord in de modifier-lijst van het behandelde woordgeplaatst. Ook wordt de afhankelijkheidsrelatie uit de lijst van relaties verwijderd.Indien het gekoppelde woord een none-tag heeft, wordt de relatie gewoon verwijderd.De woorden in de modifier-lijst zullen bij de verdere transformaties op basis van huntag een meer specifieke rol krijgen. Het toepassen van het patroon op bovenstaandezin voegt aan de modifier-lijst van platform het woord left-most toe. De modifiersthe en small worden ook bekeken en hun relaties verwijderd. Aangezien ze beide eennone-tag hebben, worden ze niet toegevoegd aan de modifier-lijst.Het patroon voor relaties tussen objecten Het patroon voor het herkennenvan relaties tussen objecten is iets complexer dan het patroon voor het herkennenvan modifiers. Het is namelijk mogelijk dat een woord een relatie heeft met eenwoord waar een none-tag aan gekoppeld is, wat dan verder wel een relatie heeft meteen woord dat wel een betekenis heeft. Dit is zo voor pipe in volgend voorbeeld:Instructie: Jump over the pipe to the left of the bunch of gaps.Relaties: prep(jump-1, over-2), det(pipe-4, the-3), pobj(over-2, pipe-4), prep(pipe- 4, to-5), det(left-7, the-6), pobj(to-5, left-7), prep(left-7, of-8), det(bunch-10, the-9), pobj(of-8, bunch-10), prep(bunch-10, of-11), pobj(of-11, gaps-12)Tagging: jump, across, none, pipe, near, none, left, side_of, none none, none, gapHier heeft pipe een relatie met gaps. Deze relatie spant over meerdere tags en wordtonderbroken door een aantal relaties met woorden die none zijn. Om dit op te lossenwordt bij het geval van een prep-relatie de keten van prepositierelaties ingeklapt.Dit gebeurt zoals beschreven in algoritme 6. Het algoritme geeft een verzamelingvan relaties terug waarmee het gevonden object gekoppeld is. Indien geen objectmet een nuttige betekenis teruggevonden wordt, krijgen we een leeg resultaat. Voorbovenstaande voorbeeld geeft deze methode als resultaat:Preposities: near+left+side_ofObject: gapsTussen de woorden pipe en gaps wordt het verband near+left+side_of gelegd. Ditverband zal bij de transformatie naar het doelstructuurformaat verder behandeldworden. Indien een van de preposities of objecten met een none-tag nuttige modifiers 31
  • 4. Doelconstructiehebben, worden deze ook toegevoegd aan de lijst met preposities. Deze worden dantoegevoegd tussen vierkante haakjes net na de tag van het woord waar de modifierbij hoort.Algorithm 6 Procedure voor het samenvouwen van voorzetselrelaties. relatie ← vindRelatieOpT ypeV oorW oord(“prep”, woord) preposities ←“” while relatie = f alse do prepositie ← relatie.second {in dit veld zit het voorzetsel bij een prepositie- relatie} if tagging[prepositie] =“none” then preposities ← preposities+“+”+prepositie end if object ← vindRelatieOpT ypeV oorW oord(“pobj”, prepositie) if tagging[object] =“none” then return (preposities, object) end if relatie ← vindRelatieOpT ypeV oorW oord(“prep”, object) end while return f alsePatronen voor actiesHier zullen de patronen voor acties besproken worden. De hier besproken patronenzijn van toepassing op alle acties, maar de acties die niet uitgevoerd kunnen wordendoor Mario zoals exists en moving hebben nog andere mogelijke patronen. Voor dezeverwijzen we naar appendix D. Op acties zijn dezelfde patronen van toepassing als op objecten. Zo kunnen zeook modifiers en voorzetselrelaties hebben. Echter, bij acties is het onderwerp vande actie ook belangrijk. Uit de voorbeelddata kan duidelijk opgemerkt worden datrelaties van het type nsubj de agent aanduiden die de actie uitvoert. Wanneer eenwoord een actie-tag heeft, wordt gecontroleerd of er een nsubj-relatie voor dit woordis. Het gekoppelde woord wordt in dat geval in de subject-lijst van de actie gestoken.Uit een analyse van de door de parser teruggegeven data blijkt echter dat somseen csubj-relatie gebruikt wordt indien de parse-tree fout is. Wanneer deze foutvoorkomt, zijn de andere relaties meestal wel correct. Daarom werd besloten hetpatroon voor de detectie van de agent van een actie, ook relaties van het type csubjte behandelen. De argumenten van beide types van afhankelijkheidsrelaties wordenin de subject-lijst gestopt. Door de structuur van de Stanford Dependencies, kanechter maar één van beide relaties voorkomen voor een bepaald werkwoord[12]. Eenactie zal dus hoogstens één actor-relatie hebben. Het is mogelijk dat deze actor eenconjunctie is van meerdere actors.32
  • 4.1. Hoe gebeurt doelconstructie?Patronen voor if en untilVoor condities wordt een patroon gebruikt dat rekening houdt met meerdere relaties.Uit analyse van voorbeelddata blijkt dat een woord dat getagd wordt met een if ofuntil-tag wel een afhankelijkheidsrelatie heeft met de gekoppelde conditie, maar eenkoppeling met de uit te voeren actie is niet aanwezig. Wel is er bij een correcte parseeen verband aanwezig tussen de conditie en de uit te voeren actie. Het patroon voorhet herkennen van een if-then-structuur en een until-structuur combineert deze tweetypes relaties en koppelt zowel de conditie als de uit te voeren actie aan het woordmet de conditie-tag. Voor het detecteren van de conditie wordt gebruik gemaakt van relaties met typemark en advmod. De conditie wordt gekoppeld door een conditierelatie toe te voegentussen het te verwerken woord en het woord dat de conditie bepaalt. De relatietussen de conditie en de uit te voeren actie kan gevonden worden op basis van eenrelatie van het type advcl. Deze actie wordt in de true-actie-lijst van het te verwerkenwoord gestopt. Neem als voorbeeld volgende data:Instructie: Jump on the pipe if the monster is near the gap.Relaties: prep(jump-1, on-2), det(pipe-4, the-3), pobj(on-2, pipe-4), mark(is-8, if-5), det(monster-7, the-6), nsubj(is-8, monster-7), advcl(jump-1, is-8), prep(is-8, near-9), det(gap-11, the-10), pobj(near-9, gap-11)Tagging: jump, on_top, none, pipe, if, none, monster, exists, near, none, gapHier kan het patroon zoals hierboven staat beschreven toegepast worden. In ditvoorbeeld koppelt is naar de conditie terwijl door de advcl-relatie herkend wordt datjump de actie is die uitgevoerd moet worden. Bij het hier voorgestelde voorbeeld ishet echter interessant op te merken dat in een latere fase niet meteen gecontroleerdkan worden of de conditie voldaan is in de huidige wereld. Het is namelijk mogelijkdat het monster wel in de richting van de kuil wandelt, maar er nog niet dichtbij is.Hier zal mogelijk gewacht moeten worden met het controleren of zal gecontroleerdmoeten worden of de conditie ooit waar kan worden. In dat geval is er echter noggeen zekerheid over de correctheid van de structuur. In hoofdstuk 5 zal hier dieperop ingegaan worden. Het bovenstaande patroon kan toegepast worden voor het herkennen van if-then-structuren. Het is echter mogelijk dat in plaats van een if-then-structuur eenif-then-else-structuur verborgen zit in de instructie. In dat geval moet een derdeafhankelijkheidsrelatie gebruikt worden. De actie die uit te voeren is indien deconditie niet waar is, met een ccomp-relatie gelinkt aan de actie die uitgevoerd moetworden indien de conditie wel waar is. Door te controleren op deze relatie, kan ookdeze grotere structuur gedetecteerd worden. De actie die uitgevoerd moet wordenwanneer de conditie faalt, wordt gekoppeld met de false-actie-lijst. Voor woorden meteen until-tag kan deze relatie uiteraard niet bestaan. Het hier beschreven patroonkoppelt het te verwerken woord met een conditie en een true-actie. Indien het om 33
  • 4. Doelconstructieeen woord met if -tag gaat, wordt ook gecontroleerd of er een false-actie is. Wanneerdeze aanwezig is, wordt ook deze aan het te verwerken woord gekoppeld.Patronen voor coördinatieCoördinatie is de structuur die voorkomt bij het gebruiken van conjuncties endisjuncties zoals and en or. Het is ongetwijfeld de moeilijkste structuur om tebepalen uit de afhankelijkheidsrelaties. De grootste moeilijkheid zit in het feitdat een coördinatiestructuur kan voorkomen tussen ieder type van woorden. Zokunnen twee acties gegroepeerd worden, maar ook twee objecten, locaties of getallen.Bovendien kan de structuur een willekeurig aantal maal eenzelfde structuur bevatten.Neem als voorbeeld volgende data:Instructie: Jump across the gap, run right and kill or avoid the monster.Relaties: prep(jump-1, across-2), det(gap-4, the-3), pobj(across-2, gap-4), conj(jump- 1, run-6), advmod(run-6, right-7), cc(jump-1, and-8), conj(jump-1, kill-9), cc(kill-9, or-10), conj(kill-9, avoid-11), det(monster-13, the-12), dobj(kill-9, monster-13)Tagging: jump, across, none, gap, run, right, and, kill, or, avoid, none, monsterHier zien we dat het eerste woord dat lid is van de coördinatiestructuur in verdererelaties gebruikt kan worden om de hele groep aan te duiden. Dit woord zullen wevanaf nu aanduiden met het hoofd van de structuur. De voor dit patroon relevanteverbanden die uit deze zin bekomen moeten worden zijn:jump-across: gapand: jump, run, oror: kill, avoidor-modifier: monsterMerk op dat dit echter maar één van de mogelijke vormen is. Het is bijvoorbeeldook mogelijk dat de or-groep de and-groep bevat. Deze structuur zal echter eenandere parse-tree hebben. We vertrouwen op de correctheid van de parser dat ookdeze structuur gegenereerd zal worden. Om te zorgen dat alle mogelijke structurengetest kunnen worden, zal een voldoende groot aantal parse-trees onderzocht moetenkunnen worden. Voor het herkennen van het hoofd van de structuur kan gebruik gemaakt wordenvan de cc-relatie. Het herkennen van de elementen in de structuur kan gebeurenop basis van de conj-relatie. Hier moet echter opgelet worden. Wanneer we inbovenstaande voorbeeld kijken, zien we dat kill een conj-relatie heeft met jump. Hieris kill echter het hoofd van de or-structuur. Om dit probleem op te lossen, wordt ineen eerste stap over de afhankelijkheidsrelaties gelopen en wordt van ieder woordbepaald of dit het hoofd van een conjunctie is. Indien dit het geval is, wordt ditwoord in de relaties vervangen met de structuur voor de relaties tussen de eerste34
  • 4.2. Doelstructuur en domeincontroleconj-relatie van dat woord en de eerst volgende cc-relatie die niet de relatie is voor dehuidige groep. Concreet geeft dit voor bovenstaande voorbeeld de volgende relaties:prep(jump-1, across-2), det(gap-4, the-3), pobj(across-2, gap-4), conj(and-8, run-6), advmod(run-6, right-7), cc(jump-1, and-8), conj(and-8, or-10), cc(kill-9, or-10), conj(or-10, avoid-11), det(monster-13, the-12), dobj(or-10, monster-13)Merk op dat in de dobj-relatie een vervanging is gebeurd. het woord monster is indeze parse-tree namelijk een object voor zowel avoid als kill. We zien ook dat killvervangen is in de conj-relatie met and. Nu kan volgend patroon toegepast wordenom de elementen in de coördinatiestructuur te identificeren: 1. Voeg het element toe waarvoor een cc-relatie bestaat met het te verwerken woord als tweede argument. 2. Voeg de elementen toe waarvoor een conj-relatie bestaat met het te verwerken woord als eerste argument.Door deze stappen uit te voeren kunnen de juiste objecten in de coördinatiestructuurgevonden worden. Bovendien kunnen patronen toegevoegd worden voor het vindenvan modifiers en relaties die voor de volledige groep gelden. Deze kunnen gevondenworden met de hoger vermelde patronen.4.2 Doelstructuur en domeincontroleNa de eerste stap van de doelconstructie is de verzameling afhankelijkheidsrelatiesen de semantische informatie uit de tagging stap getransformeerd in relationeleverbanden tussen de woorden. Een verband heeft slechts één betekenis en is nietambigu. Deze verbanden hebben echter een aantal beperkingen. Zo is er geencontrole gebeurd op de correctheid van de relaties en hun argumenten. Verder zijner ook beperkingen in het domein van toepassing welke bepaalde verbanden kunnenuitsluiten. Tenslotte moet ook de modifiers nog verder verwerkt worden. Om deze problemen aan te pakken is er gekozen om de relationele verbanden tetransformeren in een domeinspecifieke structuur. Tijdens deze transformatie gebeurteen controle op de argumenten van de verbanden tussen woorden, zo kan een actiebijvoorbeeld niet de agent zijn van een andere actie.4.2.1 De vorm van de doelstructuurDe doelstructuur bestaat uit verschillende deelstructuren. Iedere tag, uitgezonderdde none-tag, heeft een eigen structuur waarin de informatie gelinkt aan deze tagwordt opgeslagen. Zo bevatten de objecten in de wereld onder andere velden voor decoördinaten van het object in de wereld en bevatten acties een agent die de actieuitvoert (zie tabel 4.1). De structuren voor de tags zitten in een grotere hiërarchie.Zo erft een object alle eigenschappen van de algemene structuur over. Op basis vande informatie bewaard in deze structuren kunnen de acties in de instructie uitgevoerd 35
  • 4. Doelconstructie Naam Attributen BlockStructure not : boolean number : Number order : Order horizontalSideOf : Location verticalSideOf : Location above : List<ObjectStructure> below : List<ObjectStructure> left_of : List<ObjectStructure> right_of : List<ObjectStructure> near : List<ObjectStructure> in : List<ObjectStructure> between : List<ObjectStructure> across : List<ObjectStructure> on_top : List<ObjectStructure> locations: List<LoctionStructure> plural : boolean x1 : int y1 : int question_block : boolean Tabel 4.1: Voorbeeld van de attributen voor de BlockStructure.worden. Voor een overzicht van de verschillende mogelijke structuren, zie appendixC. De doelstructuur is opgebouwd uit deze deelstructuren en heeft de vorm van eenboom. Voor het aanmaken van de doelstructuur wordt eerst het woord gezocht dat deroot van deze boom voorstelt. De root van deze boom is het woord waarvoor een padgevonden kan worden naar alle andere woorden die niet de triviale none-tag hebben.Uit observaties blijkt dat de root uniek bepaald is voor iedere instructie en er is opmoment van schrijven geen voorbeeld bekend waar dit niet het geval is. De oorzaakhiervoor is te vinden in het feit dat de gekozen versie van de Stanford Dependencyrelaties ook opgebouwd zijn in een boomstructuur[12]. De toegepaste patronenvoor het bepalen van de relaties tussen de woorden, moeten de boomstructuurintact houden voor woorden die geen none-tag hebben. Om te controleren dat alleafhankelijkheidsrelaties tussen woorden zonder none-tag gebruikt worden door eenpatroon, wordt voor het aanmaken van de doelstructuren een controle gedaan opde niet gebruikte afhankelijkheidsrelaties. Indien hier relaties te vinden zijn die eenverband uitdrukken tussen twee woorden zonder none-tag, wordt dit gedetecteerden zal er gebacktrackt worden. Voor een voorbeeld van de transformaties van deafhankelijkheidsrelaties naar de doelstructuur, zie figuur 4.1.36
  • 4.2. Doelstructuur en domeincontrole () 1 () 2 pe J mp xo rp u c mp atn g a co _ o l i atn co i ga ol a rs co s go ax u av d d mo pb oj j ump g _o ot gp a t o rh it g a rs co s mo i r di fe dt e te h gp a rh it g () 3 A t n o lt c r co G a r t e i Suu atn co i ga ol J mp t c r G tSrc r u Sr t e uu oo t t e uu a rs co s h r o tli O oi na d f z S e G p t c r Rg tt c r a Sr t e uu i Sr t e h uuFiguur 4.1: Evolutie van de boomstructuur van afhankelijkheidsrelaties (1) naarde relaties tussen de woorden (2) naar de doelstructuur (3) voor de zin Jump over the gap to go right. Voor het vinden van de root kan het eerste woord gezocht worden zonder none-tagen vervolgens kan steeds gezocht worden naar een ander woord dat naar dit woordverwijst. Wanneer er geen woord gevonden kan worden dat naar het huidige woordverwijst, is het huidige woord de root. Dit komt neer op algoritme 7.4.2.2 De opbouw van doelstructurenDe opbouw van de doelstructuren is dankzij de tussenstap die de verbanden tussende woorden bepaalt relatief eenvoudig. Er zijn twee speciale gevallen waarbij hettoekennen van de plaats in de structuur minder duidelijk is: de modifiers en derelaties. Voor de andere verbanden die door de patronen herkend zijn, kunnen deverbanden rechtstreeks in de structuur ingevoegd worden. Hierbij wordt gecontroleerdof de verbanden mogelijk zijn in het domein. Meer informatie over deze controlevolgt in sectie 4.2.3.De transformatie van modifiersIn de lijst met modifiers is in de vorige deelstap een grote variatie aan elementengestopt. Zo zitten in deze lijst zowel echte modifiers zoals not, maar kan er ook eenlocatie in zitten zoals left of zelfs een object zoals monster. Hoe deze modifiers in dedoelstructuur passen, is afhankelijk van de tag van het woord waar ze aan gekoppeldzijn. 37
  • 4. DoelconstructieAlgorithm 7 Procedure voor het vinden van de root. huidigW oord ← f alse for woord in instructie do if tagging[woord] = “none” then huidigW oord ← woord end if end for if huidigW oord = f alse then return f alse end if verwijsW oord ← huidigW oord repeat huidigW oord ← verwijsW oord verwijsW oord ← f alse for woord in instructie do if verwijstN aar(woord, huidigW oord) then verwijsW oord ← woord end if end for until verwijsW oord = f alse return huidigW oord Een tag die bij een woord hoort dat als modifier aan een woord hangt, kan optwee manieren afgehandeld worden. Ofwel is er voor de tag een modify-routinebeschikbaar (bvb voor left), ofwel heeft de modifier een speciale rol bij een anderetag (bvb and). Ook is er nog de groep die bestaat uit not, number en order. Dezetags kunnen bij eender welke andere tag horen. De gekoppelde woorden wordendan toegewezen aan de variabele in de algemene structuur. Voor een lijst van allestructuren en hun attributen, zie appendix C.Modifiers met een speciale rol De modifiers met een speciale rol zijn meestaldomeinspecifiek gekoppeld aan andere tags. Een voorbeeld hiervan vinden we bij dejump-tag. In het domein kunnen twee vormen van sprongen gemaakt worden: eennormale sprong en een sprong met een aanloop. Indien een sprong gemaakt moetworden, kan echter steeds gekozen worden een korte aanloop te nemen. Indien eenrun-modifier gekoppeld is aan jump, kan deze genegeerd worden. Een ander speciaal geval kunnen we vinden bij de and en or-tag. Zoals hogervermeld kan een conjunctie voorkomen tussen iedere groep van twee woorden. Hi-erdoor is het mogelijk dat een groep conjuncties als modifier van een woord wordttoegevoegd terwijl het eigenlijk gaat om meerdere relaties, objecten, onderwerpen,. . . De leden van de coördinatiestructuur moeten dus elk hun correcte rol krijgen.Voor een and-tag kan dit eenvoudig gebeuren door alle leden van de groep toe tepassen op de huidige structuur en af te handelen volgens hun type (relatie, modifier,38
  • 4.2. Doelstructuur en domeincontroleonderwerp,. . . ). In het geval van een or-tag ligt dit echter anders. Hier moet éénvan de mogelijke leden gekozen worden. Momenteel wordt een willekeurige keuzegemaakt uit de leden en wordt dat lid afgehandeld volgens zijn type. Een beteremanier om dit af te handelen zou zijn om te backtracken op de mogelijkheden. Hetis namelijk mogelijk dat een slechte keuze gemaakt wordt waardoor de verificatievan het doel later faalt terwijl bij een andere keuze de verificatie slaagt.Modifiers met modify-routine De meeste modifiers volgen de aanpak van demodify-routine. Hierbij wordt voor het woord dat een ander woord modificeertgecontroleerd of de combinatie van modifiers mogelijk is. Locaties Locaties vormen een speciaal geval indien ze gekoppeld zijn aan eenobject. In dat geval zullen ze toegevoegd worden aan de location-lijst van dat object.Dit betekent dat ze bepalen waar op het scherm het object gezocht moet worden. Inhet geval dat een locatie bij een ander type tag staat, zal de locatie in de side_of-lijstworden toegevoegd. Een actie waar een locatie in de side_of-lijst staat, weet dandat de actie in die richting uitgevoerd moet worden. Relaties Relaties kunnen enkel modifiers zijn indien meerdere relaties bij eenwoord staan en gegroepeerd zijn in een conjunctie. In dat geval wordt op ieder vande relaties de modify-actie opgeroepen voor het woord waar de relatie bij hoort. Hoede relatie afgehandeld wordt, is afhankelijk van het woord waar ze bij staat. Voormeer informatie over het afhandelen van relaties, zie verder in sectie 4.2.2. Objecten Objecten kunnen enkel als modifier staan bij een ander object wan-neer hun modify-operatie opgeroepen kan worden. Het beste voorbeeld vinden we bijmodifiers die bij platform staan. Het type van een platform en of het al dan niet eenmuur is, kan bepaald worden door zijn modifiers. Zo wordt, indien een wall-tag alsmodifier bij een platform staat, de isWall-vlag van het platform aangezet. De blocken floor-tags kunnen zorgen dat het type aangepast wordt. In het geval van block iser sprake van een speciaal geval. Een blok kan namelijk gemodificeerd worden doorquestion_block waardoor het platform niet bestaat uit blokken, maar uit blokkenmet vraagtekens.De transformatie van relatiesDe transformatie van de relaties bij een woord kan vaak op een eenvoudige manierafgehandeld worden. Zo kan gekeken worden naar het eerste deel van de sleutel vanhet verband en vervolgens kan het gekoppelde woord ingedeeld worden in de correctevariabele. Een voorbeeld hiervan vinden we wanneer we een object hebben met eenrelatie. Objecten hebben voor iedere relatie die ze kunnen aangaan een variabele inhun structuur. Indien een object bijvoorbeeld de relatie krijgt near: pipe kan de pijpin de near-lijst van de structuur toegevoegd worden. 39
  • 4. Doelconstructie Ook bij de meeste acties kan de relatie toegewezen worden aan de gelijknamigevariabele. Voor sommige relaties is dit echter niet het geval. Een voorbeeld vindenwe weer bij near. Zo wordt in combinatie met jump bedoeld dat vanaf dat puntgesprongen moet worden terwijl bij run bedoeld wordt dat er naar dat punt gelopenmoet worden. Bij deze aanpak vergeten we echter dat relaties niet steeds uit enkelvoudigeelementen bestaan. Bij het opbouwen van de verbanden tussen de verschillendewoorden werden namelijk verbanden over meerdere woorden samengevoegd tot eengroter geheel. Het is dus mogelijk dat in plaats van near: pipe een object de relatienear+left+side_of: pipe heeft. Deze relatie wordt gevormd indien het object dichtbij de linker zijde van de pijp moet zijn. Uit analyse van de voorbeelddata uit dewalkthroughs blijkt dat bij het samenvouwen van voorzetselrelaties enkel het eerstedeel een specifieke betekenis heeft. De andere delen bevatten informatie over derelatieve locatie ten opzichte van het eerste object. Om deze informatie beschikbaar temaken in de doelstructuur, wordt de relatie geanalyseerd voor locatiegegevens. Indieneen locatie gedetecteerd wordt, voegen we deze toe aan het correcte sideOf-veld vande structuur waarmee de relatie verbonden is. In het geval van near+left+side_of:pipe moet de pijp deze informatie verwerken. Deze relatie geeft als resultaat dat depijp in het near-veld van het object zit en dat de pijp in zijn sideOf-informatie dewaarde left heeft.4.2.3 Het ontdekken van fouten in doelenZoals eerder reeds aangehaald, kan maar een beperkte set van relaties tussen tagsbestaan in het hier omschreven domein. Zo kan aan een if -tag geen object hangen ofkan een object niet via een side_of gekoppeld zijn aan een actie. Bij het opbouwenvan de doelstructuur wordt dan ook gecontroleerd of de bekomen structuur geldig isin het domein van de toepassing. De controle op de geldigheid van een structuur gebeurt in twee stappen: eencontrole of het doel geldig is in het domein en een controle of het doel geldig is in dehuidige wereld. We zullen hier de controle voor geldigheid in het domein bespreken.De controle voor geldigheid in de wereld zal besproken worden in hoofdstuk 5. De controle op de correctheid van de doelstructuur in het domein gebeurt tijdens hettransformatieproces. Indien hier een verband gevonden wordt tussen twee woordenwat onmogelijk is in het domein, is de structuur foutief. Voor ieder verband wordtgekeken waar het verband naartoe getransformeerd moet worden. Vervolgens wordtgekeken of het transformeren van dat verband mogelijk is voor de gekozen tags.Indien dit niet het geval is, wordt een fout gemeld. Ook is het mogelijk dat eenverband aangemaakt is dat onmogelijk is voor een bepaalde tag en dat het dus nietgetransformeerd kan worden. Wanneer een verband gevonden wordt waarvoor geentransformatie mogelijk is, wordt eveneens een fout gemeld. Deze foutmeldingen40
  • 4.3. De plaats in het proceszullen vervolgens een backtrackstap starten waardoor een volgende tagging en/ofparse-tree getest zal worden.4.3 De plaats in het procesHet aanmaken van de doelstructuren is een belangrijke stap in het proces. In deze stapwordt namelijk een eerste controle gedaan op de correctheid van de gekozen parse-treeen tagging. Ook wordt de doelstructuur geproduceerd die later teruggegeven kanworden als output van het proces indien de controle tegen de wereldinformatie in devolgende stap slaagt. Zoals beschreven in de voorgaande secties in dit hoofdstuk bestaat deze stapuit twee delen. Het eerste deel maakt gebruik van pattern matching om op basisvan de afhankelijkheidsrelaties en tags een serie verbanden tussen de woorden tegenereren. Deze verbanden worden vervolgens getransformeerd voor het vormen vande uiteindelijke doelstructuur. Bij deze transformatie is het mogelijk dat een foutgedetecteerd wordt tegen de beschikbare domeinkennis. Indien een fout gedetecteerdwordt, zal een backtrackstap plaatsvinden waardoor de volgende andere parse-tree oftagging beschouwd zal worden. In deze stap wordt dus op basis van de huidige setafhankelijkheidsrelaties, tagging en instructie een doelstructuur gegenereerd of eenfoutmelding teruggegeven. Concreet komt dit neer op de procedure in algoritme 8.Algorithm 8 Algoritme van de doelconstructie-stap. root ← zoekRoot(instructie, relaties, tagging) matchP atronen(instructie, relaties, tagging, patronen) {deze stap past de re- laties aan en verwijdert de gebruikte relaties} if bestaatRelevantP ad(relaties, tagging) then return f alse end if return transf ormeer(root, instructie, tagging) {hier wordt mogelijk f alse terug gegeven bij de detectie van een fout} 41
  • Hoofdstuk 5Doelcontrole enobjectidentificatieDit hoofdstuk handelt over de controle van de in hoofdstuk 4 aangemaakte doelstruc-tuur. Bij het controleren van deze doelstructuur wordt gezocht naar de objectenin de wereld die overeenkomen met de objecten in de invoerinstructie. Eerst wordteen korte motivatie gegeven waarom deze controle tegen de huidige toestand van dewereld nuttig is voor het herkennen van de correcte doelstructuur (sectie 5.1). Hiernawordt toegelicht hoe de doelcontrole juist uitgevoerd wordt (sectie 5.2). Opdat dedoelcontrole kan slagen, moet de wereldinformatie beschikbaar zijn. Daarom wordtbesproken hoe deze verkregen kan worden uit de MarioAI-simulator en hoe deze inaftoetsbare vorm gegoten kan worden (sectie 5.3). Daarna worden enkele problemenbesproken die kunnen optreden bij het controleren van de doelstructuur (sectie 5.4).Vervolgens wordt toegelicht hoe de identificatie van de objecten concreet gebeurt(sectie 5.5). Tenslotte wordt weer afgesloten met een korte plaatsing van deze stapin de rest van het proces (sectie 5.6).5.1 MotivatieIn hoofdstuk 4 werd al uitgelegd dat bij het aanmaken van een doel een controlegebeurt of het aangemaakte doel mogelijk is in het domein. Men kan dus de vraagstellen of extra doelcontrole nog nodig is. Er is echter meer kennis dan enkel dedomeinkennis beschikbaar: er is kennis over de huidige toestand van de wereld.Wanneer een instructie gegeven wordt, zal deze een actie uitdrukken. Mogelijk bevatdeze instructie ook informatie over de omgeving van de agent waarin de instructieuitgevoerd moet worden. Op basis van deze informatie kan gecontroleerd worden ofde gekozen parse-tree en tagging correct zijn. Neem als voorbeeld volgende instructie: Run to the pipe on the platform.Bij deze instructie duikt de vraag op of on the platform aan run of aan pipe hangt.De parser zal indien voldoende parse-trees onderzocht worden, voor beide structureneen parse-tree genereren. Wanneer alles goed verloopt zal uit beide parse-trees in 43
  • 5. Doelcontrole en objectidentificatiecombinatie met de goede taggings een correcte doelstructuur opgebouwd kunnenworden. Nu wordt de ruimtelijke informatie in de wereldinformatie echter belangrijk.Zo is het mogelijk dat er wel een pijp is in de wereld, maar dat deze niet op eenplatform staat. In dat geval zal de voorzetselzin on the platform aan run moetenhangen en zal over het platform gelopen moeten worden in de richting van een pijp.Doordat wereldinformatie beschikbaar is, kan gecontroleerd worden of de objectendie vernoemd worden in de instructie ook in de wereld bestaan. Deze controle kanin het vorige voorbeeld de foute doelstructuur waar de pijp op het platform staatverwerpen indien dit niet voorkomt in de wereld. Er blijft echter mogelijk een tekort bij deze aanpak. Er is namelijk geen zekerheiddat de structuur waar de pijp op het platform staat eerst onderzocht wordt. Destructuur waar op het platform gelopen moet worden, kan slagen in iedere wereldwaar een platform is van waar in de richting van de pijp gelopen kan worden. Dezestructuur zal dus enkel falen in een wereld waar ofwel geen pijp of platform zijn ofwaar enkel platformen zijn waar niet op gelopen kan worden (bijvoorbeeld doordat zevol staan met pijpen). Het zou dus tot op zekere hoogte nuttig kunnen zijn indien deparser eerst de parse-trees teruggeeft die zoveel mogelijk koppelingen hebben tussenobjecten onderling. Op deze manier krijgen we meer beperkingen op de objecten. Bijhet testen op de wereldinformatie zullen hierdoor meer controles uitgevoerd worden.Wanneer een van deze controles faalt, wordt de slechte structuur verworpen. In ditgeval zou de zo complex mogelijke structuur die mogelijk is in de wereld aanvaardworden. De parser geeft de mogelijke parse-trees echter terug in afnemende probabiliteit.Indien het meer waarschijnlijk is dat op het platform gelopen moet worden, zal dieparse-tree eerst teruggegeven worden. Hierdoor is het mogelijk dat niet naar de pijpop het platform gelopen wordt, maar naar een andere pijp. Dit probleem wordt nietverder beschouwd. De reden hiervoor is dat hoewel de bedoelde structuur mogelijkniet gevonden wordt, deze structuur er toch dicht bij aan zal leunen. Bovendien ishet voor een mens mogelijk ook onduidelijk welke betekenis wordt bedoeld bij hethoren van de instructie. Een mens zal hier ook de keuze maken voor de voor hemmeest waarschijnlijke constructie en de overeenkomende acties uitvoeren.5.2 De aanpakBij het controleren van de doelstructuur zal voornamelijk gecontroleerd moetenworden of bepaalde objecten in de wereld bestaan en of de onderlinge relaties tussendeze objecten gelden. Om deze controle op een eenvoudige manier te kunnen uitvoeren,wordt gebruik gemaakt van Prolog. Voor de controle wordt een query gebouwdop basis van de structuur dewelke getest kan worden op de wereldinformatie. Degebruikte Prolog-versie is SWI-Prolog[6].44
  • 5.2. De aanpak De wereldinformatie zal in een eerste stap ingeladen moeten worden in Prolog. DeMarioAI-simulator biedt de wereldinformatie aan in de vorm van een tweedimensionalearray van bytes. Deze array deelt het scherm op in vakjes rond Mario en voor iedervakje is het type blok in de wereld te vinden. Voor ieder vak in de wereld kan dusbepaald worden wat voor blok het bevat. Deze informatie wordt dan doorgegevennaar Prolog. Vervolgens worden predicaten geladen die op basis van deze blokkencomplexere structuren in de wereld kunnen herkennen zoals buizen en platformen.Ook zijn er predicaten voorzien voor de verbanden tussen objecten. Een bijvoorbeeldhiervan zijn de near en on_top-relaties. Op basis van deze predicaten kan een queryopgebouwd worden voor de controle van de doelstructuur. Het opbouwen van de query voor de controle van de doelstructuur maakt gebruikvan de eigenschap dat de structuur een boom is. De opdracht om de query op tebouwen wordt gegeven aan de root van de doelstructuur. Vervolgens geeft iederenode de informatie over zichzelf en zijn identificatie terug, samen met de informatievan zijn kinderen en de informatie over de relaties tussen de huidige node en zijnkinderen. Op deze manier wordt de informatie van iedere node en het verband tussenalle gerelateerde nodes teruggegeven. Er wordt een speciale procedure gebruikt voor het teruggeven van de informatieover de relaties tussen de huidige node en de kinderen. Hierbij wordt de informatieover het type verband meegegeven aan de child-node, die dan de correcte informatiesamenstelt op basis van zijn type. Zo zal bij een or-structuur een disjunctie gemaaktworden over alle mogelijke kinderen. Ook is belangrijk op te merken dat enkele typesvan relaties speciaal zijn. Een belangrijk voorbeeld hiervan is de between-relatie. Ditis namelijk een ternaire relatie. Het kindobject van deze relatie moet een meervoudzijn met aantal twee of een conjunctie van twee objecten. Voor deze elementen kandan de relatie opgebouwd worden. Zoals eerder aangehaald, geeft iedere knoop waar relevant zijn eigen identificatieterug in de query. Deze informatie is enkel relevant voor de objecten in de doelstruc-tuur. De identificatie is een query in de vorm van object(type, X1, X2, Y1, Y2).Hierbij zijn X1 en X2 het meest linkse en meest rechtse x-coördinaat en zijn Y1 en Y2het onderste en bovenste y-coördinaat van het object. Deze query zal instaan voor deinitialisatie van de objecten in de wereld. De relaties tussen de verschillende objectenzullen gebruik maken van deze identificatie om de relaties tussen de verschillendeobjecten te garanderen. Voor meer informatie over deze identificatie verwijzen wenaar sectie 5.5. 45
  • 5. Doelcontrole en objectidentificatieFiguur 5.1: Voorstelling van de Mario-wereld in een array van vakjes met enkele grotere structuren in de wereld.5.3 De extractie van wereldinformatie5.3.1 Het assenstelselZoals reeds vermeld in de vorige sectie, wordt de wereldinformatie in de MarioAI-simulator teruggegeven in de vorm van een tweedimensionale array van bytes waarvoor ieder vakje rond de agent het type van blok in zit (zie figuur 5.1). Voor dezeblokken kan een coördinaat berekend worden ten opzichte van de agent. Bij hetverplaatsen van de agent verschuift deze array mee. Hierdoor verandert ook derelatieve coördinaat van de verschillende blokken. Wanneer bij de aanvang van hetuitvoeren van een doelstructuur de locatie van een bepaalde blok gekend is, kandeze veranderen wanneer een actie uitgevoerd wordt. Hierdoor zou bij het uitvoerenvan de doelstructuur moeten gezorgd worden dat de locaties van de objecten in destructuur aangepast worden. Om dit probleem op te lossen, wordt een absoluut assenstelsel gedefinieerd in delinkerbovenhoek van de wereld. De locaties van iedere blok in de wereld worden danbepaald ten opzichte van dit assenstelsel, waardoor bij verplaatsing van de agentde locaties in de doelstructuur geldig blijven. Let wel op dat voor bewegende delen46
  • 5.3. De extractie van wereldinformatievan de wereld (zoals bijvoorbeeld monsters) de locatie in de doelstructuur aangepastmoet worden ten opzichte van de tijd.5.3.2 De herkenbare objectenIn natuurlijke taal wordt niet over de blokken in de wereld gesproken: er wordtgesproken over grotere structuren in de wereld zoals pijpen, platformen, muren,trappen, . . . De verschillende blokken moeten gegroepeerd kunnen worden tot dezegrotere objecten (zoals de pijp, en de platformen in figuur 5.1). Bovendien moetvoor ieder object dat geïdentificeerd moet kunnen worden een tag aanwezig zijn inhet tagging alfabet. Voor de uitgewerkte toepassing worden volgende structurenondersteund: platformen, trappen, buizen, muren, afgronden en de grond. De kleinereobjecten in de wereld waarvoor tags voorzien zijn, vallen allemaal binnen één vakje.Hierdoor zijn geen complexe structuren nodig voor de herkenning van deze objecten.Wel zijn predicaten uitgewerkt die het type van een vakje koppelen aan de correctetag. Voor al de bovenstaande structuren is een predicaat opgesteld, wat zorgt voorde identificatie van zijn structuur op basis van de wereldinformatie. Let op datin de uitgewerkte toepassing een beperkte set structuren ondersteund wordt. Destructuren waar geen predicaat voor voorzien is, zullen dus niet herkend kunnenworden door de agent. Er zal ook niet geweten zijn hoe een instructie met dezestructuur afgehandeld moet worden. Het zou interessant kunnen zijn om de agentzelf nieuwe structuren te laten leren op basis van uitleg gegeven door de gebruiker.Deze route werd echter niet gevolgd aangezien voornamelijk de nauwkeurigheid vande gepresenteerde aanpak onderzocht wordt.5.3.3 De relatiesVoor de relaties tussen objecten is in de uitgewerkte toepassing net als voor de teherkennen structuren gebruik gemaakt van een beperkte set. Deze set bestaat uit:above, below, left_of, right_of, on_top, near, across, inside, middle en between.Merk op dat inside en middle gebaseerd zijn op locaties. Op een analoge manierworden ook de andere locaties omgevormd tot de verwante relatie. Voor al deze relaties zijn predicaten uitgewerkt waarin de coördinaten van demeegegeven argumenten tegen elkaar worden afgetoetst. Alle relaties aanvaardentwee argumenten op uitzondering van de middle en between-relatie. De middle-relatieaanvaardt slechts één argument. Voor dit argument wordt dan getest of het tussentwee andere willekeurige objecten van hetzelfde type staat en dus “de middelste” is.De between-relatie neemt drie argumenten aan. Hierbij wordt getest of het eersteargument tussen de twee andere argumenten ligt. 47
  • 5. Doelcontrole en objectidentificatie5.4 Problemen bij de controleDe controle van de doelstructuur gebeurt op basis van de query opgebouwd uit dezedoelstructuur. Bij het opbouwen en uitvoeren van deze query komt meer kijken danop het eerste zicht duidelijk is. Zo werd in het vorige hoofdstuk al aangehaald datbij het controleren op de correctheid van een if-then-structuur problemen kunnenoptreden indien de conditie afhankelijk is van de tijd. Ook het opbouwen van debetween-relatie geeft enkele problemen net als de number en order-waarden in destructuren doordat een mogelijk ongekend aantal objecten gezocht zal moeten worden.Deze problemen worden in deze sectie meer toegelicht.5.4.1 Problemen met tijdsafhankelijke informatieAls voorbeeld voor het probleem waar de conditie van een structuur afhankelijk isvan de tijd, grijpen we terug naar het volgende voorbeeld uit hoofdstuk 4: Jump on the pipe if the monster is near the gap.Bij deze instructie is het mogelijk dat het monster in de buurt van een afgrond is.Het is ook mogelijk dat het monster wel in de richting van de afgrond beweegt, maardat het monster momenteel nog ver van de put verwijderd is. Bij het controleren ofde informatie in de instructie geldig is in de huidige wereld, kan dus geen controleuitgevoerd worden op de conditie van een if-then-structuur. Men zou kunnen argumenteren, dat aangezien het gedrag van de wereld in desimulatieomgeving voorspelbaar is, een controle uitgevoerd kan worden of de conditiemogelijk waar wordt in de toekomst. In dat geval kan men een ander probleem krijgen:het is mogelijk dat de gebruiker weet dat de conditie faalt. Zo kan bij bovenstaandvoorbeeld de gebruiker weten dat het monster nooit bij de put kan komen omdat hetmonster gevangen zit. De vraag is dan of de doelstructuur verworpen moet wordenof niet. In het bovenstaande voorbeeld zou bij het aanvaarden van de doelstructuurgeen actie uitgevoerd worden aangezien de conditie nooit waar wordt. Ook bij hetverwerpen van de doelstructuur wordt geen actie uitgevoerd. Het resultaat zou in ditgeval dus hetzelfde zijn. Dit is echter niet waar indien volgende instructie gegevenzou worden: If there is a monster near the gap, kill it, else run to the right.Bij het binnenkomen van deze instructie kan men zich afvragen welke controle ermoet gebeuren. Moet de conditie gecontroleerd worden met het risico dat deze nogniet geldig is? In dat geval is de doelstructuur echter niet ongeldig. Bovendien kande vraag gesteld worden of de controle van de acties moet gebeuren. Het is namelijkmogelijk dat er geen monster bestaat. Indien dan de actie kill it gecontroleerd wordten de controle op het bestaan van een monster uitgevoerd wordt, kan ook dezecontrole falen. Het is mogelijk dat de gebruiker verwacht dat de agent naar rechtszal lopen omdat er geen monster te zien is. Analoog kan een voorbeeld gegeven48
  • 5.4. Problemen bij de controleworden waar de conditie waar is, maar waar de alternatieve actie informatie bevatdie ongeldig is. Men kan dus niet eenvoudig bepalen of de conditie of de acties bij bovenstaandevoorbeelden correcte informatie moeten bevatten voor de huidige wereld. Wel weetmen dat zowel de conditie als de acties informatie moet bevatten die geldig is in hetgekozen domein. Dit is het geval dankzij de controle uitgevoerd bij het aanmakenvan de doelstructuur. Omdat het onduidelijk is of de acties en conditie moetengelden in de huidige wereld werd er voor gekozen geen controle uit te voeren opdeze gegevens. Het is mogelijk dat een incorrecte doelstructuur niet gedetecteerdwordt omdat er een mogelijke wereld is waar deze correct is. Een mogelijk alternatiefzou kunnen zijn om meerdere doelstructuren te analyseren en deze vervolgens demeest waarschijnlijke structuur in de huidige wereld te kiezen. Dit werd niet verderbestudeerd.5.4.2 Problemen met meervoudige objectenMeervouden en volgordes zijn een ander probleem dat voorkomt bij het controleren vande wereldinformatie. Zo wordt vaak gesproken over ongekende aantallen, bijvoorbeeld: Jump over the gaps.De vraag duikt hier op over hoeveel putten er gesprongen moet worden. Moetgesprongen worden over de eerste groep putten? Of moet over alle zichtbare puttengesprongen worden? Het aantal putten waar over gesprongen moet worden, kan inde instructie toegelicht worden met een aantal. In dat geval wordt dit aantal in destructuur opgeslagen zodat over dat aantal putten gesprongen kan worden. Bij hetcontroleren tegen de wereld kan dan op relatief eenvoudige wijze een groep van xunieke objecten gekozen worden. Een probleem duikt dan echter op wanneer dezeobjecten verbanden moeten hebben met andere objecten. Neem als voorbeeld: Jump over the gaps between the pipes.Voor deze controle moet iedere put in de groep tussen twee pijpen zitten. De vraagis of deze pijpen voor iedere put dezelfde moeten zijn. Indien dit niet het geval is,wordt de locatie van de pijpen gekoppeld aan de put. In het andere geval kunnen delocaties van de pijpen onafhankelijk van de putten bekeken worden. Voor volgordes kan een gelijkaardig probleem gedetecteerd worden. Zo kan bij: Jump over the third gap between the pipes.gevraagd worden of het de derde put is tussen twee dezelfde pijpen of gewoon dederde put tussen twee willekeurige pijpen. 49
  • 5. Doelcontrole en objectidentificatie Voor dit probleem is een zeer eenvoudige oplossing gekozen: iedere groep vanobjecten wordt voorgesteld door één object in zijn groep. Wanneer een object eenrelatie heeft met een groep, wordt gecontroleerd of de relatie geldt voor dat object enhet element van de groep. Deze oplossing is verre van de ideale en kan zeker verbeterdworden. Een groot gemis aan deze oplossing is dat voor slechts één object een locatiein de wereld in de structuur opgeslagen wordt. Een mogelijk betere oplossing zouzijn om steeds te kiezen dat de relatie moet gelden tussen de groep en dezelfdeset van objecten. Dit kan leiden tot het verwerpen van correcte doelstructuren.Een alternatief zou weer zijn om meerdere doelstructuren te genereren (zowel voorrelaties met dezelfde objecten en voor relaties met verschillende objecten) en demeest waarschijnlijke te kiezen op het einde van het proces. Deze keuze zou kunnengebeuren door bijvoorbeeld een andere machine learning procedure die getraindwordt om de doelstructuur met de voorkeur van de gebruiker te herkennen.5.5 Het identificeren van objectenZoals hoger vermeld, wordt bij het opbouwen van de query voor ieder object eenidentifier gemaakt waarmee gecontroleerd wordt of het object waar over gesprokenwordt in de instructie ook echt bestaat in de wereld. Deze identifiers zijn opgebouwdop volgende manier: object(*type*, *X1*, *X2*, *Y1*, *Y2*)Hier bij is type het type van het object, zijn X1 en X2 de variabelen voor re-spectievelijk de laagste en hoogste x-coördinaat en Y 1 en Y 2 de variabelen voorrespectievelijk de laagste en hoogste y-coördinaat. Om te zorgen dat ieder objectandere variabelen gebruikt, wordt in de naam van de variabelen gebruik gemaaktvan een unieke code. Deze identifier wordt doorgegeven als deel van de Prolog-query die uitgevoerdwordt op de wereldinformatie. Bij het uitvoeren van deze query, wordt door Prologniet enkel teruggegeven als een resultaat te vinden is. Er worden ook waardenteruggegeven voor de variabelen in de query. Deze waarden kunnen gebruikt wordenom de objecten in de wereld te koppelen aan de objecten in de instructie door zein te vullen in de structuur. Hiervoor wordt de lijst met resultaten uit de querydoorgegeven aan de root van de doelstructuur. Iedere node zal deze informatiedoorgeven aan zijn kinderen. De objecten in de structuur kunnen dan de informatieuit de variabelen halen waarvoor de variabelen de code van het object hebben. De objecten krijgen op deze manier een locatie waarvoor de opgebouwde querygeslaagd is. Dit wilt zeggen dat voor de objecten in de wereld de relaties geldenzoals beschreven in het doel. Het doel bevat dus een set objecten in de wereld diegeldig kunnen zijn als interpretatie. Let wel op dat voor sommige objecten geenidentificatie ingevuld kan worden zoals bij de if-then-structuur. Dit komt doordatop deze structuur geen controle uitgevoerd wordt. Het is dus mogelijk dat sommige50
  • 5.6. De plaats in het procesobjecten niet geïdentificeerd zijn. Deze objecten zullen gekoppeld moeten wordenaan wereldobjecten bij het uitvoeren van de query. Dit is mogelijk bij de controle opde geldigheid van de conditie. Doordat de objecten in de wereld gevonden zijn, kan de instructie correct uitgevoerdworden indien de gekozen objecten ook de objecten zijn die bedoeld worden door degebruiker. Indien dit niet het geval is, bestaat de mogelijkheid dat de uitgevoerdeactie een ander resultaat heeft dan hetgeen bedoeld was. De gekozen resultatenzijn echter een correcte interpretatie van de binnengekomen data. Bovendien is hetmogelijk dat de bedoelde objecten verschillend zijn voor verschillende gebruikers.Hier wordt in de applicatie geen rekening mee gehouden. Een mogelijke uitbreidingvan het systeem kan er in bestaan om een andere heuristiek te gebruiken voor hetidentificeren van de objecten. Mogelijk kan hier zelfs een heuristiek geleerd wordenop basis van de voorkeuren van de gebruiker.5.6 De plaats in het procesIn deze stap wordt een gevonden doel gecontroleerd op geldigheid in de wereld.Zoals reeds beschreven in sectie 5.1 kan dit er voor zorgen dat doelstructuren dieniet mogelijk zijn in de huidige wereld verworpen worden. Indien een structuur decontrole doorstaat, is de kans dat de structuur correct is dus groter dan wanneerde controle tegen de wereldinformatie niet zou gebeuren. Wanneer de controle nietdoorstaan wordt, is de gevonden structuur waarschijnlijk fout. Ook zorgt deze stapvoor het vinden van locaties in de wereld voor de objecten in de structuur. Deze stap neemt als invoer de doelstructuur die bekomen is uit de voorgaande stap-pen in het proces. Bij het doorstaan van de test, kan de doelstructuur teruggegevenworden als doel van de instructie. Indien de test faalt, wordt een foutmeldingteruggegeven. In dat geval zal gebacktrackt worden over de parse-trees of taggings. In het eerste deel van de stap wordt de query opgebouwd die uitgevoerd zalworden op de wereldinformatie. Die wereldinformatie wordt bepaald op basis van dehuidige toestand van de wereld. Hier wordt gebruik gemaakt van de predicaten voorhet herkennen van de structuren in de wereld en de relaties tussen wereldobjecten.Vervolgens wordt de query uitgevoerd waarna, bij een positief resultaat, de bekomenantwoordwaarden worden ingevuld in de locatievariabelen in de doelstructuur. Deprocedure van deze stap is uitgeschreven in algoritme 9. 51
  • 5. Doelcontrole en objectidentificatieAlgorithm 9 Algoritme van de doelcontrole-stap. query ← bouwQuery(root) prolog.laadtInf ormatie(wereld) resultaat ← prolog.execute(query) if resultaat = f alse then vulLocatieIn(root, resultaat) return root end if return f alse52
  • Hoofdstuk 6Evaluatie van de voorgesteldetechniekIn dit hoofdstuk wordt aan de hand van enkele experimenten gekeken hoe goed degepresenteerde techniek presteert. Eerst wordt toegelicht welke experimenten uitgevo-erd zijn (sectie 6.1). Vervolgens worden de resultaten voor elk van de voorgesteldeexperimenten gegeven en besproken (secties 6.2 tot 6.4). Tenslotte geven we nog eenkort overzicht over enkele algemene vaststellingen (sectie 6.5).6.1 Opstelling van de experimentenIn deze sectie zal eerst kort toegelicht worden hoe het systeem waarop de testenuitgevoerd worden is opgebouwd. Vervolgens wordt besproken hoe de testdata voorde verschillende experimenten verzameld is. Verder vindt u welke testen uitgevoerdzijn. Ook argumenteren we waarom de gekozen testen juist uitgevoerd worden enwordt uitgelegd hoe fouten tijdens het testen gedetecteerd worden.6.1.1 Gebruikte systeemDe aanpak voorgesteld in deze thesis maakt gebruik van enkele applicaties. Zoalseerder vermeld in hoofdstuk 2, wordt gebruik gemaakt van de Berkeley parser ende Stanford parser. Voor de Berkeley parser wordt de meest recente versie op hetogenblik van schrijven gebruikt. De gebruikte versie van de Stanford parser is versie1.6.5. Voor de CRF is gebruik gemaakt van Mallet versie 2.0.6, een java-toolkit voor hetbehandelen van natuurlijke taal. De CRF is getraind op basis van de resultaten uithoofdstuk 3: er is gebruik gemaakt van een niet volledig verbonden CRF die enkelgebruik maakt van de naburige tags voor de overgangen tussen de verschillende wo-orden. Deze CRF is getraind gedurende 500 iteraties met data uit drie walkthroughs.Dit zijn 684 instructies met een totaal van 13190 woorden. Het woordenboek datgebruikt is in de testen is eveneens opgebouwd op basis van deze instructies. Het 53
  • 6. Evaluatie van de voorgestelde techniekwoordenboek bevat alle woorden die meer dan vijf keer voorkomen in de trainingsdataen hun mogelijke tags.6.1.2 De gebruikte testdataDe data gebruikt tijdens de testen is net zoals de data gebruikt voor het trainenvan de CRF gebaseerd op walkthroughs. Hiervoor is een walkthrough gekozen dieniet gebruikt is bij het trainen van het systeem. De testdata is opgedeeld in driecategorieën:Eenvoudige instructies: korte instructies (tot tien woorden) bestaande uit een enkele actie gecombineerd met objecten waarvoor hoogstens één relatie met een ander object aanwezig is.Semi-complexe instructies: bevatten tot drie acties in if-then-else-structuren, coördinaties, gevolgen, deelacties, . . . De instructies bevatten tot drie relaties tussen de verschillende objecten bij de acties.Complexe instructies: bestaan uit acties gecombineerd door meerdere van boven- staande structuren. Ook bevatten deze instructies tussenwerpsels en voor de agent oninteressante informatie.Voor elk van deze groepen zijn 20 instructies geselecteerd om de testen mee uit tevoeren. In totaal is dus getest met 60 ongeziene instructies. De instructies vooriedere categorie zijn willekeurig uit de walkthrough gekozen. Voor een extract vande testinstructies, zie appendix F. Om te testen of de instructies correct herkend worden, werd voor iedere instructieeen mogelijke wereld gekozen. Deze keuze is gemaakt op basis van beschikbare levelsin de MarioAI simulator. Uit deze levels werd voor iedere instructie willekeurig eenwereld gekozen waarvoor de instructie uitvoerbaar is.6.1.3 De uitgevoerde experimentenDe testen van de aanpak zijn voornamelijk gericht op het onderzoeken van denauwkeurigheid van de voorgestelde aanpak. Om deze te bepalen zijn drie verschil-lende experimenten uitgevoerd: • Een experiment waarbij de invloed van het gekozen aantal parse-trees en taggings op het systeem bestudeerd wordt. • Een experiment waarbij de invloed van het woordenboek op het systeem bestudeerd wordt. • Een vergelijkingsexperiment waarbij de nauwkeurigheid van de gepresenteerde aanpak vergeleken wordt met een eenvoudige pattern matcher.Voor deze experimenten wordt gemeten hoeveel gegenereerde doelstructuren volledigcorrect zijn in de bijhorende wereld. Verder wordt ook gekeken welke soorten foutengemaakt worden door het systeem. De getelde fouten zijn:54
  • 6.2. Invloed van het aantal gebruikte parse-trees en taggings • fouten in de koppeling tussen de uit te voeren acties en bijhorende objecten; • fouten in de koppeling tussen de objecten onderling; • fouten in de koppeling tussen de acties onderling (onderlinge volgorde); • instructies waarvoor geen doelstructuur gevonden wordt. Een correcte doelstructuur wordt gedefinieerd als de doelstructuur waarvoor alledeelstructuren de correcte onderlinge relaties hebben en deze relaties mogelijk zijnvolgens de gekozen wereld. Als meerdere relaties mogelijk zijn, is iedere mogelijkestructuur correct. Een voorbeeld hiervan vinden we bijvoorbeeld bij de instructie: Jump on the pipe to the right.Voor deze instructie is het zowel correct wanneer naar rechts gesprongen wordt opde pijp als wanneer op de pijp gesprongen wordt die rechts is. Indien meerderebetekenissen van een instructie mogelijk zijn voor een bepaalde wereld, worden alledoelstructuren die een correcte interpretatie bevatten goedgekeurd. Een koppelingtussen twee deelstructuren is fout indien: • de buitenste deelstructuur fout is (bijvoorbeeld een foute actie gekozen wordt); • de gekoppelde deelstructuur ontbreekt; • het type van de koppeling fout is (bijvoorbeeld een above-relatie in plaats van een near-relatie).Een fout wordt maximaal één keer per structuur geteld. Met behulp van de resultaten van deze metingen zal toegelicht worden wat deinvloed van de verschillende parameters is. Ook zal er gekeken worden waar deoorzaak van de getelde fouten te vinden is. Het vergelijkingsexperiment wordt uitgevoerd om te vergelijken hoe de voorgesteldeaanpak scoort ten opzichte van een zeer eenvoudige pattern matching aanpak. Voorde werking van de pattern matcher verwijzen we naar bijlage E. De patronen voordeze pattern matcher zijn opgebouwd op basis van dezelfde instructies als waarmeede CRF getraind is en waarop de patronen voor het opbouwen van de doelstructurengebaseerd zijn. Aangezien de pattern matcher zijn gegenereerde doelstructuur nietaan een wereld kan toetsen, is er gekozen om dit manueel te doen en te controlerenhoeveel van de bekomen structuren geldig zijn in de bijbehorende wereld.6.2 Invloed van het aantal gebruikte parse-trees en taggingsVoor het voorgestelde systeem zijn er twee belangrijke parameters: het aantal teonderzoeken parse-trees en het aantal te onderzoeken taggings. Beide parameterszullen hoog genoeg ingesteld moeten worden om er voor te zorgen dat de correcte databeschikbaar is. Wanneer er bijvoorbeeld te weinig parse-trees onderzocht worden, is 55
  • 6. Evaluatie van de voorgestelde techniek # parse-trees 5 10 20 5 45,0 48,3 48,3 # taggings 10 43,3 46,7 46,7 20 43,3 46,7 46,7 50 43,3 46,7 46,7 100 40,0 43,3 43,3 200 40,0 40,0 40,0Tabel 6.1: Percentage van correcte doelstructuren voor verschillende waarden voorhet aantal parse-trees en taggings over alle testinstructies zonder gebruik te maken van het woordenboek.het mogelijk dat de correcte structuur niet gevonden kan worden doordat de juisteparse-tree niet gekozen werd. Aan de andere kant moet ook gezorgd worden dat niette veel foute gegevens geanalyseerd worden. Dit kan er voor zorgen dat door toevaltoch een combinatie van gegevens gevonden wordt die een mogelijke maar foutievedoelstructuur geeft. Deze verwachtingen worden bevestigd wanneer we tabel 6.1 bekijken. Hierinvindt u de gemiddelde nauwkeurigheid voor verschillende waarden voor het aantalparse-trees en taggings over alle testinstructies. Uit deze resultaten kunnen webesluiten dat de parameter met het aantal parse-trees weinig invloed heeft op deglobale nauwkeurigheid. Het aantal parse-trees verhogen zou bovendien geen effecthebben aangezien voor iedere instructie een doelstructuur gevonden wordt. Hetaantal parse-trees moet dus hoog genoeg zijn, maar hoger gaan dan 20 parse-treeslijkt geen zin te hebben. Uit de resultaten in tabel 6.1 zien we dat het aantal taggings wel degelijk een grooteffect heeft. Wanneer te veel taggings gebruikt worden, kan voor minder structureneen correct resultaat bekomen worden. In tabel 6.2 ziet u de soorten fouten voor de verschillende types van testdata,meerdere waardes voor het aantal taggings en 20 parse-trees. De waarden zijnabsoluut. Voor de categorieën zijn er 20 verschillende instructies, wat het totaalop 60 instructies brengt. Wanneer we deze data bekijken, valt vooral op dat hetgrootste deel van de gemaakte fouten te wijten zijn aan een foute tagging. Welmoet opgemerkt worden dat bij een foute parse-tree vaak ook een foute tagginggekozen wordt. Dit is echter niet altijd het geval. Uit de gegevens blijkt ook datde scores voor de complexe zinnen dicht bij elkaar liggen. We zien wel dat bij decomplexe instructies meer foute parse-trees gebruikt worden. Wel kan, mits eengoede keuze van het aantal taggings, voor de complexe instructies een licht beterresultaat opgetekend worden. Dit is mogelijk omdat de CRF getraind is met vooral56
  • 6.2. Invloed van het aantal gebruikte parse-trees en taggings Aantal taggings 5 10 20 50 100 200 correct 14 12 12 12 12 12 eenvoudig fout object-actie 6 7 7 7 7 7 fout object-object 2 4 4 4 4 4 fout actie-actie 0 0 0 0 0 0 fout door tagging 6 8 8 8 8 8 fout door parse-tree 2 4 4 4 4 4 correct 7 7 7 7 6 6 semi-complex fout object-actie 4 6 5 5 6 6 fout object-object 5 5 5 5 5 5 fout actie-actie 5 7 7 7 8 8 fout door tagging 12 12 12 12 13 13 fout door parse-tree 2 2 2 2 3 3 correct 8 9 9 9 8 6 fout object-actie 8 7 7 7 8 10 complex fout object-object 3 3 3 2 2 4 fout actie-actie 5 5 5 6 7 8 fout door tagging 11 10 10 10 11 13 fout door parse-tree 4 4 5 5 6 8 correct 29 28 28 28 26 24 fout object-actie 18 20 19 19 21 23 fout object-object 10 12 12 11 11 13 totaal fout actie-actie 10 12 12 13 15 16 fout door tagging 29 30 30 30 32 34 fout door parse-tree 8 10 11 11 13 15Tabel 6.2: Aantal correcte structuren en aantal fouten voor verschillende aantallentaggings voor iedere categorie van testinstructies zonder gebruik te maken van het woordenboek.lange en complexe instructies. Deze duiken namelijk vaak op in de walkthroughs. Erblijven echter veel fouten die gemaakt worden door foute taggings. Uit deze resultaten kunnen we besluiten dat het aantal taggings zoals voorspeldbest niet te hoog gezet wordt. De beste keuze lijkt 50 of minder taggings te zijn. Ofer ook gezakt moet worden tot 5 taggings, hangt af welk belang aan iedere vorm vaninstructies gegeven wordt. Indien enkel eenvoudige instructies verwacht worden, kanhet beter zijn om het aantal taggings zeer laag te houden. 57
  • 6. Evaluatie van de voorgestelde techniek6.3 Invloed van het woordenboekIn de vorige sectie kan gezien worden dat veel van de fouten die gemaakt wordendoor het systeem gemaakt worden door het gebruik van een foute tagging. Doorgebruik te maken van het woordenboek, kunnen foute taggings herkend worden. Insommige gevallen is het zelfs mogelijk dat de tagging hersteld kan worden (zie sectie3.6). Algemeen verwachten we dus dat het aantal fouten door incorrecte taggings zalafnemen. Indien we het woordenboek aanschakelen, krijgen we voor 20 parse-trees de re-sultaten uit tabel 6.3. Wanneer we deze resultaten bekijken, valt meteen op dat ereen zeer hoge nauwkeurigheid behaald wordt: voor 53 van de 60 zinnen wordt eencorrecte doelstructuur behaald. Let wel op, deze doelstructuur is (zeker in gevalvan de complexe instructies) maar een van de mogelijke interpretaties. Het is dusmogelijk dat een andere doelstructuur bedoeld wordt door de gebruiker. Opvallendis wel dat het verschil in moeilijkheid tussen de verschillende types van instructiesweggewerkt lijkt te zijn. Bij het bekijken van de nauwkeurigheid valt eveneens op dat doelen voor de semi-complexe instructies beter bepaald kunnen worden dan de doelen voor eenvoudigeinstructies. De reden hiervoor vinden we bij de objecten in deze instructies. Bij deeenvoudige instructies liggen er weinig beperkingen op de verschillende objecten. Dezebeperkingen worden bij de wereldcontrole gebruikt om foute parse-trees en taggingste herkennen. Bij de meer complexe instructies is meer dergelijke wereldinformatieaanwezig en kunnen foute doelstructuren makkelijker herkend worden. Naast de opmerkingen over de nauwkeurigheid, zien we ook dat het aantal foutenin de fout bepaalde structuren zeer laag is. Indien een structuur niet correct bepaaldkan worden, heeft de door het systeem bekomen structuur hoogstens één foutekoppeling tussen structuren. De bekomen structuren die incorrect zijn, leunen duszeer dicht aan bij de correcte structuur. Wel zien we dat er een geval is waar geendoelstructuur bepaald kan worden bij 20 parse-trees. Voor deze instructie werdgeprobeerd het aantal parse-trees te verhogen. De eerste 5000 parse-trees warenechter niet correct. Verder kan opgemerkt worden dat er opvallend minder fouten gemaakt worden dooreen foute tagging wanneer vergeleken wordt met de aanpak zonder het woordenboek.Dit is te verklaren doordat het woordenboek ongeldige taggings elimineert. Hierdoorkan een volgende tagging of parse-tree onderzocht worden. Het grootste deel vangemaakte fouten is, wanneer gebruik gemaakt wordt van het woordenboek, te wijtenaan een foute parse-tree. Dit is vooral het geval bij de complexe instructies.58
  • 6.3. Invloed van het woordenboek Aantal taggings 5 10 20 50 100 200 correct 16 16 17 17 17 17 fout object-actie 2 2 2 2 2 2 eenvoudig fout object-object 1 1 1 1 1 1 fout actie-actie 0 0 0 0 0 0 geen structuur gevonden 1 1 0 0 0 0 fout door tagging 3 3 2 2 2 2 fout door parse-tree 3 3 2 2 2 2 correct 18 19 19 19 19 19 semi-complex fout object-actie 1 0 0 0 0 0 fout object-object 1 1 1 1 1 1 fout actie-actie 0 0 0 0 0 0 geen structuur gevonden 0 0 0 0 0 0 fout door tagging 1 1 1 1 1 1 fout door parse-tree 0 1 1 1 1 1 correct 15 15 16 16 16 17 fout object-actie 2 2 2 2 2 2 complex fout object-object 0 0 0 0 0 0 fout actie-actie 1 1 1 1 1 0 geen structuur gevonden 2 2 1 1 1 1 fout door tagging 2 2 1 1 1 1 fout door parse-tree 5 5 4 4 4 3 correct 49 50 52 52 52 53 fout object-actie 5 4 4 4 4 4 fout object-object 2 2 2 2 2 2 totaal fout actie-actie 5 1 1 1 1 0 geen structuur gevonden 3 3 1 1 1 1 fout door tagging 6 6 4 4 4 4 fout door parse-tree 8 9 7 7 7 6Tabel 6.3: Aantal correcte structuren en aantal fouten voor verschillende aantallen taggings voor iedere categorie van testinstructies met het woordenboek. 59
  • 6. Evaluatie van de voorgestelde techniek6.4 Vergelijking met een eenvoudige pattern matcherUit bovenstaande tests blijkt dat de hier voorgestelde aanpak relatief goed scoort(tot 48% van alle instructies zonder woordenboek en tot 88% bij gebruik van hetwoordenboek). De vraag is nu hoe deze resultaten zich verhouden ten opzichte vaneen naïeve oplossing voor dit probleem. Om dit te bestuderen, is een eenvoudigepattern matcher gemaakt. De patronen die gebruikt worden, zijn gebaseerd op dewalkthroughs waarmee de implementatie van de voorgestelde aanpak is gebouwd.Meer informatie over de pattern matcher vindt u in appendix E. Aan deze pattern matcher werden dezelfde testinstructies gegeven die eerdergebruikt zijn voor het bepalen van de nauwkeurigheid van de voorgestelde aanpak.Aangezien de pattern matcher geen wereld gebruikt, werd ook bepaald of het bekomendoel fout is in de wereld die bij de instructie hoort. Er wordt een vergelijking gemaaktmet de voorgestelde aanpak met en zonder woordenboek, beide met 20 taggings en20 parse-trees. De resultaten van deze testen vindt u in tabel 6.4. Uit deze resultaten kunnen we zien dat de pattern matcher goed scoort voor deeenvoudige instructies, zelfs beter dan de voorgestelde techniek zonder woordenboek.Wanneer we deze twee technieken vergelijken voor de semi-complexe instructies, zienwe dat ze aan elkaar gewaagd zijn. Indien de complexe instructies beschouwd worden,scoort de voorgestelde techniek dan weer sterker. Dit is te verklaren doordat depattern matcher zeer goed de lokale structuren kan herkennen in de instructies. Bijde grotere structuren die voorkomen in de complexe instructies, loopt het echtermis. Voor deze lange instructies kan de voorgestelde aanpak vertrouwen op degrammaticale structuur in de vorm van de afhankelijkheidsrelaties. De voorgesteldeaanpak kan hierdoor met behulp van de afhankelijkheidsrelaties ook de complexestructuren eenvoudig herkennen. Wanneer we de naïeve pattern matching aanpak vergelijken met de voorgesteldeaanpak met woordenboek, zien we dat de resultaten op alle fronten beter zijn metuitzondering van de instructie die niet herkend wordt. Deze instructie wordt echterdoor geen enkele van de geteste technieken correct afgehandeld.6.5 Algemene vaststellingenAlgemeen kunnen we uit deze resultaten besluiten dat de doelstructuren met devoorgestelde aanpak redelijk goed voorspeld worden. Voor de doelstructuren dieniet correct voorspeld kunnen worden, leunt de bekomen doelstructuur redelijk dichtaan bij een correcte doelstructuur. Wel moet opgemerkt worden dat de bekomendoelstructuur maar één van de mogelijke structuren is. Of de bekomen doelstructuurde structuur is die bedoeld wordt door de gebruiker, is nog een andere vraag.60
  • 6.5. Algemene vaststellingen 20-20 zonder woordenboek 20-20 met woordenboek pattern matcher correct 14 12 17 eenvoudig fout in wereld 1 0 0 fout object-actie 4 7 2 fout object-object 4 4 1 fout actie-actie 0 0 0 geen structuur gevonden 0 0 0 correct 7 7 18 semi-complex fout in wereld 2 0 0 fout object-actie 7 5 0 fout object-object 4 5 2 fout actie-actie 7 7 0 geen structuur gevonden 0 0 0 correct 2 9 16 fout in wereld 3 0 0 complex fout object-actie 10 7 2 fout object-object 8 3 0 fout actie-actie 10 5 1 geen structuur gevonden 0 0 1 correct 23 28 51 fout in wereld 6 0 0 totaal fout object-actie 21 19 4 fout object-object 16 12 3 fout actie-actie 17 12 1 geen structuur gevonden 0 0 1Tabel 6.4: Aantal correcte structuren en aantal fouten voor verschillende technieken. 61
  • 6. Evaluatie van de voorgestelde techniek Een vaststelling die wel opvalt is dat het woordenboek een enorm grote invloedheeft op het systeem. Deze invloed ligt voornamelijk in het herkennen en verwerpenvan foutieve taggings. Aangezien deze taggings gegenereerd worden met behulp vanmachine learning technieken, kan de vraag gesteld worden of de gekozen techniekwel een goede is. Een alternatieve conclusie kan zijn dat deze stap een te lagenauwkeurigheid haalt en dus meer en/of meer gevarieerde trainingsdata kan gebruiken.Vermits uit de data blijkt dat het grootste deel van de woorden slechts een beperkteset mogelijke tags kan krijgen, kan eventueel voor een andere techniek gekozenworden die vooral op basis van het woord kiest welke tag mogelijk is. Bij de keuzevan een andere techniek moet dan wel rekening gehouden worden dat ook ongekendewoorden gebruikt kunnen worden in de instructie.62
  • Hoofdstuk 7BesluitIn dit hoofdstuk zal eerst kort toegelicht worden hoe de voorgestelde aanpak gere-aliseerd is (sectie 7.1). Vervolgens wordt gekeken welke van de gestelde doelstellingenbereikt zijn (sectie 7.2). Hierna wordt een kort overzicht gegeven over eventueleuitbreidingen die het systeem beter kunnen maken (sectie 7.3). Tenslotte wordtafgesloten met een kort besluit over dit werk (sectie 7.4).7.1 Geleverd werkIn deze sectie lichten we kort toe hoe de beslissingen genomen zijn waardoor devoorgestelde aanpak tot stand kwam. Ook wordt toegelicht hoe het eindprogrammauitgewerkt werd. Het initiële idee voor dit werk ontsproot uit het idee voor het maken van eenmobiele robot die instructies in natuurlijke taal moet afwerken. Voor het maken vaneen uitvoerbare toepassing hiervoor, werd gekeken naar goede simulatieomgevingen.Dit voornamelijk omdat een tastbare robot niet meteen beschikbaar was. Alssimulatieomgeving werd de zeer eenvoudige wereld van Super Mario gekozen[3].In deze wereld is er een agent dewelke door de wereld kan rondlopen terwijl hijover hindernissen moet springen en monsters moet ontwijken of doden. De hieruitgewerkte applicatie genereert doelstructuren voor de instructies gegeven aan deagent in deze omgeving. Door het gebruik van deze simulator, kan de focus van hetwerk gelegd worden in het analyseren van de natuurlijke taal. Initieel werd er van uit gegaan dat de grammaticale structuur van een zin bepaaldkan worden op basis van de parse-trees van de instructie. Bij het onderzoek naareen goede grammaticale parser, kwamen ook papers over afhankelijkheidsrelatiesnaar voren[12]. Deze relaties voegen zeer nuttige informatie toe over de rollen van deverschillende delen in de instructie. Om deze reden werd besloten de afhankelijkheid-srelaties te gebruiken om de grammaticale structuur om te vormen. Deze keuze werdversterkt door dat uit enkele eenvoudige experimenten met de afhankelijkheidsrelaties 63
  • 7. Besluitopgemerkt werd dat de structuren in de instructie vaak te herkenen waren aan dehand van eenvoudige pattern matching. Na het vinden van een representatie voor de structuur van de instructie werdgezocht naar een methode om de grote set van woorden in natuurlijke taal tebeperken naar een kleine gekende set van betekenissen. Met deze betekenissen zoudan geredeneerd kunnen worden door het programma. Voor het vinden van dezebetekenissen kwam het idee naar voren om aan ieder woord een klasse toe te wijzendie de betekenis van het woord uitdrukt. Hiervoor werd eerst gekeken naar HiddenMarkov Models[38] aangezien deze techniek vaak als voorbeeld gebruikt wordt voorhet classificeren van woorden in lexicale categorieën[28]. Hier werd echter aangegevendat het gebruik van CRF’s[29] mogelijk een beter effect zou geven aangezien hethierbij makkelijker is om rekening te houden met verschillende invoerparameters eneen sterker verband is tussen de verschillende delen van de sequentie. Deze keuze werddan ook gevolgd. Aangezien de grammaticale rollen van de verschillende woordenbeschikbaar waren dankzij de afhankelijkheidsrelaties, werd er voor gekozen deze ookals invoer te geven aan de CRF. Zoals eerder opgemerkt, kunnen in de afhankelijkheidsrelaties patronen herkendworden om structuren in de instructies te vinden. Wanneer de afhankelijkheid-srelaties worden gecombineerd met de semantische informatie verkregen door deCRF, worden deze patronen duidelijker. De patronen kunnen relatief eenvoudigopgesteld worden op basis van voorbeeldinstructies. Dit gebeurde handmatig doorde afhankelijkheidsrelaties en tags bij instructies te analyseren. Bij het herkennen van de patronen in de afhankelijkheidsrelaties werd een goedegegevensstructuur gezocht waarin de data voorgesteld kan worden. Er werd beslotendat de techniek makkelijker naar een ander domein verhuisd kan worden indiener zo weinig mogelijk domeinspecifieke informatie in deze structuur zit. Daaromwerd een gegevensstructuur bepaald waar geen domeinkennis aan gekoppeld is. Dezegegevensstructuur kan door gebruik te maken van domeinkennis omgezet wordennaar de domeinspecifieke structuur. Voor het opbouwen van de doelstructuur, werd al snel ingezien dat veel domeinken-nis gebruikt kan worden om foute structuren te verwerpen. Hierdoor werd besloten dedata verkregen uit de pattern matching op de afhankelijkheidsrelaties te controlerentegen de domeinkennis. Dit zorgt dat de bekomen doelstructuur mogelijk is in hetdomein van de toepassing. Zeer vroeg in het ontwikkelen van de aanpak was al duidelijk dat de wereldin-formatie zeer nuttig kan zijn voor het herkennen van foute doelstructuren. Dewereldinformatie is makkelijk te verkrijgen in de gekozen toepassing. De informatiemoest echter omgevormd worden naar een meer handelbare structuur. Zo moetenobjecten en relaties tussen deze objecten herkend kunnen worden. Omdat later een64
  • 7.2. Doelstellingenquery uitgevoerd zou moeten worden op deze wereldinformatie, werd gekozen omProlog te gebruiken. Dit voornamelijk omdat het in Prolog zeer eenvoudig is ompredicaten te schrijven die de relaties tussen de objecten uitdrukken. Bovendien ishet uitvoeren van een query in Prolog zeer eenvoudig. Omdat absolute resultaten over de nauwkeurigheid van een toepassing weinigzeggendzijn, werd er voor gekozen een eenvoudige toepassing uit te werken in hetzelfdedomein die gebruik maakt van een klassieke techniek. Hiervoor werd gekozen vooreen eenvoudige pattern matcher aangezien dit een veelgebruikte techniek is voorhet afhandelen van instructies in natuurlijke taal. Bovendien is deze aanpak relatiefeenvoudig te implementeren. Om het implementatieproces nog meer te versnellen,werd gezocht naar een framework waarbinnen deze pattern matcher geïmplementeerdkon worden. Het gebruikte framework is het ALICE framework[1]. Dit maakt gebruikvan AIML[43] voor het voorstellen van de patronen. Deze patronen kunnen doorverschillende tools gebruikt worden voor het aanmaken van de correcte doelstructuur. Bij het analyseren van de resultaten uit de experimenten werd opgemerkt datvoor veel instructies een incorrecte doelstructuur gegenereerd werd doordat een foutetagging gebruikt wordt. Vaak wordt zelfs een totaal onmogelijke tag toegewezen aaneen woord. Om dit probleem op te lossen, werd gekozen om een woordenboek opte stellen wat de verschillende mogelijke betekenissen van een set gekende woordenbevat. Deze keuze werd geïnspireerd door taalkundige databanken zoals besproken inhoofdstuk 1. In een eerste teststap werd dit woordenboek manueel opgesteld. Omdatde resultaten positief leken, werd een procedure uitgewerkt om het woordenboekautomatisch op te stellen op basis van de testdata. Het effect van dit woordenboekis zeker niet te onderschatten wanneer de resultaten van de experimenten bekekenworden. Wel deed deze keuze de vraag rijzen of de keuze om een CRF te gebruikenwel de goede was. Een analoog resultaat als hetgeen wat nu verkregen wordt, kanwaarschijnlijk behaald worden door taggings op te stellen op basis van de woordenin het woordenboek. Dit werd echter niet verder getest.7.2 DoelstellingenDe doelstelling van dit werk ligt zoals reeds aangehaald in de inleiding vooral inhet onderzoeken naar het nut van het gebruik van de grammaticale structuur vande invoerinstructie en de beschikbare wereldinformatie bij het analyseren van eeninstructie door een robot. Wanneer we terugkijken op de resultaten van de uitgevoerdeexperimenten (hoofdstuk 6), kunnen we zien dat de voorgestelde aanpak wel degelijkgoede resultaten geeft. Dit is vooral het geval indien het woordenboek gebruiktwordt. De vraag rijst nu of deze resultaten enkel te wijten zijn aan het gebruik vande grammaticale structuur en wereldinformatie. Hierover kunnen geen duidelijkeconclusies getrokken worden. De stap voor het herkennen van de betekenis (detagging stap) zorgt namelijk voor een deel van de disambiguatie. Deze stap heeft 65
  • 7. Besluitdus een invloed op de correctheid van de doelstructuren. Deze invloed is redelijkgroot aangezien de parameter voor deze stap zeer belangrijk is (zie sectie 6.2). Wat wel duidelijk gezien kan worden wanneer de resultaten van de pattern matchervergeleken worden met de voorgestelde aanpak, is dat de pattern matcher doelstruc-turen zal genereren die incorrect zijn voor de wereld bij de instructie. Aangeziende voorgestelde aanpak controleert of het verkregen doel correct is voor de huidigewereld, worden geen doelen gegenereerd die onmogelijk zijn in de wereld. Deze extracontrole draagt dus voor een deel bij aan de correctheid van het systeem. Verderzorgt deze wereldcontrole er voor dat de koppelingen tussen de deelstructuren envooral de relaties tussen de objecten vaker correct zijn. Dit is ook een gevolg vande controle tegen de wereldinformatie. Indien een relatie onmogelijk is in de wereld,kan dit namelijk herkend worden waardoor de bijhorende doelstructuur verworpenkan worden. Uit de resultaten van de experimenten kan opgemerkt worden dat de complexereinstructies beter geanalyseerd kunnen worden door de voorgestelde aanpak dandoor de pattern matcher. Zoals eerder vermeld kan met pattern matching zeermakkelijk de lokale structuren in een instructie gevonden worden. De voorgesteldeaanpak lijkt echter ook de grotere structuren beter te voorspellen. Onder groterestructuren vallen bijvoorbeeld de ordening van de acties of over het algemeen deinstructies waar een verband bestaat tussen woordgroepen waartussen een anderewoordgroep aanwezig is. Deze verbanden kunnen in de voorgestelde techniek gevondenworden dankzij de afhankelijkheidsrelaties. De volledige vermindering van het aantalfouten tegen de complexe structuren kan echter niet toegeschreven worden aan dezeafhankelijkheidsrelaties. Zoals eerder vermeld heeft ook de wereldcontrole hier zijninvloed. Ook zien we dat indien het woordenboek niet gebruikt wordt, er nog steedsrelatief veel fouten gemaakt worden tegen deze grote structuren. Wel moet opgemerktworden dat deze fouten vooral te wijten zijn aan de foute taggings. Het lijkt erdus op dat het gebruik van de afhankelijkheidsrelaties de techniek meer schaalbaargemaakt heeft: ook voor complexere instructies kan, mits een goede tagging, eengoede structuur gevonden worden. Een dieper onderzoek over de invloeden van hetgebruik van de grammaticale informatie op de correctheid van de doelstructuren isechter aangewezen vooraleer duidelijke conclusies getrokken kunnen worden.7.3 Interessante uitbreidingenVoor het hier voorgestelde systeem, zijn enkele interessante uitbreidingen mogelijk.Zo werd eerder aangehaald dat de bepaalde structuur slechts één van de mogelijkeinterpretaties van de instructie voorstelt die mogelijk is in de huidige wereld. Hetkan echter interessant zijn om verschillende mogelijke structuren te genereren en uitdeze structuren diegene te kiezen die de voorkeur van de gebruiker heeft of meerwaarschijnlijk is in de huidige wereld.66
  • 7.3. Interessante uitbreidingen Het genereren van meerdere structuren kan ook op andere gebieden interessantzijn. Zo kan een foute tagging of foute parse leiden tot een doelstructuur die geldigis in de huidige wereld, maar die niet de gegevens uit de instructie voorstelt. Hethuidige systeem stopt zodra een geldige doelstructuur in de huidige wereld gevondenwordt. Indien een woord bijvoorbeeld onterecht met een none-tag getagd is, zal ditresulteren in een kleinere structuur. Er is namelijk een deel van de informatie in deinstructie niet gebruikt. Door meerdere structuren te genereren, kan mogelijk eenoplossing gevonden worden voor dit probleem. Met deze structuren kan een similaritymeasure opgesteld worden. De doelstructuren die hard afwijken van de anderen(bijvoorbeeld omdat een deel van de structuur ontbreekt), kunnen dan verworpenworden. Het huidige systeem heeft een beperkte set van instructies en structuren in de werelddie herkend kunnen worden. Een uitbreiding kan er in liggen deze verzamelingendynamisch uit te breiden. Op deze manier kan de agent leren wat interessantestructuren in de wereld zijn. Dit kan uitgewerkt worden door voor de woordenwaarvoor een lage waarschijnlijkheid voor de gekozen tag is, om uitleg te vragenbij de gebruiker. Deze kan dan het bedoelde object in de wereld aanduiden ofde opgegeven actie opdelen in kleinere gekende deelacties. Dit kan eventueel ookgebeuren door een tweede instructie te geven die hetzelfde betekent als de eersteinstructie. Alternatief kan bijvoorbeeld reinforcement learning[42] gebruikt wordenwaarbij de agent bij ongekende woorden en structuren zelf een betekenis zoekt doorstructuren in de wereld te gokken of willekeurige acties uit te voeren. Gezien de gekozen techniek om semantische betekenissen aan woorden te koppelen(de CRF) veel foute taggings genereert, kan gekeken worden om deze te vervangenmet een andere bruikbare techniek. Het kan hierbij nuttig zijn om de mogelijke tagsbij woorden waarvoor een beperkte set betekenissen mogelijk is (zoals ook bepaaldin het woordenboek) te beperken. De techniek zou dan slechts uit een beperkte settags kunnen kiezen bij ieder woord. Hiervoor kan het ook nuttig zijn om de lexicalecategorie van het woord mee in rekening te brengen. Zo zal een object bijvoorbeeldwaarschijnlijk een substantief zijn terwijl de kans bij werkwoorden groot is dat hetwoord een actie uitdrukt. Ook aan het deel voor wereldcontrole en objectidentificatie kunnen nog verbe-teringen uitgevoerd worden. Zo kunnen betere oplossingen voor de tijdsafhanke-lijke informatie en het probleem met meerdere objecten gezocht worden. Ook deheuristieken voor het kiezen van objecten in de wereld kunnen beter. Momenteelwordt een willekeurig object wat voldoet aan de eisen teruggegeven. Hier zou hetechter mogelijk zijn om alle objecten terug te geven en vervolgens uit deze mogeli-jkheden een keuze te maken aan de hand van een heuristiek. Deze kan eventueelbepaald worden door de voorkeuren van de gebruiker. 67
  • 7. Besluit7.4 ConclusiesAlgemeen kunnen we besluiten dat de hier voorgestelde aanpak goede resultatenbehaalt. Wanneer het woordenboek gebruikt wordt, kan voor bijna alle instructieseen correcte interpretatie gevonden worden. Dat de aanpak goede resultaten haalt,zien we ook wanneer we vergelijken met de eenvoudige pattern matcher. Hier zienwe dat de methode met woordenboek opvallend veel beter scoort. Ook het aantalfouten dat gemaakt wordt, is opvallend lager dan bij de pattern matcher. Wel moetopgemerkt worden dat een kleine afwijking in een instructie een totaal ander resultaatkan hebben na het uitvoeren van een actie. Wanneer de resultaten van de experimenten naast elkaar gelegd worden, zien wedat het verschil in nauwkeurigheid tussen de voorgestelde aanpak met en zonderwoordenboek groot is. Dit is zo omdat indien het woordenboek niet gebruikt wordt,veel foute taggings gebruikt worden voor het bepalen van de doelstructuur. Devoorspelde taggings zijn dus vaak incorrect. De huidige techniek voor het bepalenvan deze taggings is dus onvoldoende. Bij het kiezen van een techniek voor hetbepalen van deze taggings zou het verstandiger geweest zijn meerdere alternatievente onderzoeken. De keuze voor afhankelijkheidsrelaties lijkt dan weer wel goed. De voorgesteldetechniek kan namelijk zowel eenvoudige als complexe structuren herkennen. Hetherkennen van de mogelijke structuren gebeurt door patronen te herkennen op dezeafhankelijkheidsrelaties. Het lijkt er dus op dat de afhankelijkheidsrelaties zorgen datinstructies met een meer complexe zinsbouw op dezelfde manier geanalyseerd kunnenworden als de instructies met een simpele zinsbouw. Dit is een enorm voordeeltegenover klassieke pattern matching. Hierbij moet voor het matchen van complexeinstructies namelijk een lijst van speciale patronen voorzien worden.68
  • Bijlagen 69
  • Bijlage AExtract uit een walkthroughAuteur: Brian P. SulpherBron: http://www.gamefaqs.com/nes/525243-super-mario-bros/faqs/20569. o-----------o | World 1-1 | o-----------oStart your journey by running to the right to hit a ? block, kill a Goomba,and then hit the three ? blocks (two coins, and one Super Mushroom). Afterthis adventure, head right to go over the pipes and the three Goombas, andwhen you pass the second and third Goombas, go halfway between the pipe andthe bottomless pit. Jump up to reveal a hidden block that contains a 1-UpMushroom! The pipe can also be gone down to a bonus room with multiplecoins. 1-Up +--+++----++ | |++ ++ +--+ | | | | | | | |-+----+----------------------------+ +---- | | | |Jump across the gap, hit the bricks above as the two Goombas fall down soyou can then collect the power-up from the ? block, and then head right overthe gap. Kill the two Goombas that approach, hit the brick by itself as itis a Coin Block (hit until it turns into a spent block), and then hit the ?block for a coin. Next, you should hit the second brick of two for a 71
  • A. Extract uit een walkthroughStarman, collect it, and then run right as you plow through up to eightGoombas.Jump carefully over the one last gap, and then head up the staircase to thetop, where you should run and jump off at the Flagpole for the top to scorehigh (like 5,000 or 2,000 points).... o-----------o | World 8-2 | o-----------oYou get a big welcoming party to start 8-2. Two Green Paratroopa Koopas aswell as Lakitu with his pet Spinies will attack you as you climb astaircase. Upon getting over the staircase, hit the four ? blocks forcoins, and then head under the brick row in the sky to see Lakitu leave (atleast he left quickly). Use the Springboard to hit a brick that containsthe only recurring 1-Up in the game (it will be there if you die and have torestart the level).Now you need to go right while fighting off three Green Paratroopa Koopas,and you need to keep pace with the aforementioned 1-Up Mushroom moving tothe right along the row of bricks. Once you see a lower row of bricks, jumponto them to wait and receive your 1-Up (if you were too fast/too slow, itwill not be there to be collected).Now head right past the gaps and the Bullet Bill cannon to find a GreenParatroopa Koopa with a dual Bullet Bill cannon further along. Jump pastthem to find a Power-Up in the second brick you will see (just watch outfor the Green Paratroopa Koopa), and then go past the Bullet Bill cannon onyour right. The next section has a Buzzy Beetle between a Bullet Billcannon (already mentioned), and a ground level Bullet Bill cannon. Just goatop the bricks to avoid that, and then the next section has two BuzzyBeetles between the Bullet Bill ground cannon and a tall Bullet Bill cannon(the second brick from the left has a Coin Block here).Now continue right over the Piranha Plant pipe to fight a Green ParatroopaKoopa, another Piranha Plant pipe, and another hard jump. For this jump youcan get down on the first one block wide platform, get to the very edge ofit, and then run over the small gap to the second one block wide platformwhere you hop across the gap to the other side. You can also run betweenthe two Piranha Plants, take a low leap onto the second Piranha plant pipe,and then take a huge leap off of it to clear the wide gap (this way requires72
  • a fair amount of skill).Now that you are across the gap, you can go down the first Piranha Plantpipe (your time will be low of likeliness, so skip it), and then head rightpast the next Piranha Plant pipe (where the Bonus Room sends you back intothe level) to fight three Green Paratroopa Koopas with a Bullet Bill cannonto complicate things further.Jump the gap, fight the two Goombas from the mini-stairs, and then go overthe dual Bullet Bill cannon below to fight a Green Paratroopa Koopa. Nowyou should carefully climb the rather shoddy stairs (jump the gapscarefully) to reach the top, where you can take a hug running leap for thetop of the Flagpole. 73
  • Bijlage BHet tagging alfabet Tag Alfabet Categorie Verklaring jump Actie Actie spring run Actie Actie loop go_to Actie Actie ga naar fireball Actie Actie schiet een vuurbal kill Actie Actie schakel uit collect Actie Actie verzamel bump Actie Actie spring tegen de onderkant van avoid Actie Actie ontwijk (enkel in combinatie met monster) exists Wereld Actie bestaat (controle of een object in de wereld bestaat of een re- latie geldt) moving Wereld Actie beweegt (kan enkel uitgevoerd worden door een monster) top Wereld Locatie bovenaan het scherm/object bottom Wereld Locatie onderaan het scherm/object left Wereld Locatie links aan het scherm/object right Wereld Locatie rechts aan het scherm/object middle Wereld Locatie aan het midden van het scherm/object in Wereld Locatie in een object (bijvoorbeeld een gap) platform Wereld Object een platform stairs Wereld Object een trap block Wereld Object een blok question_block Wereld Object een vraagteken op een blok pipe Wereld Object een buis 75
  • B. Het tagging alfabet wall Wereld Object een muur flower Wereld Object een bloem-monster monster Wereld Object een monster mario Wereld Object de agent mario coin Wereld Object een muntstuk gap Wereld Object een gat in een platform power-up Wereld Object een power-up in de vorm van een bloem of een paddenstoel air Wereld Object de lucht floor Wereld Object een vloer platform number Wereld Hoeveelheden een getal zoals: one, two, three, ... order Wereld Hoeveelheden een rangtelwoord zoals: first, second, third, ... next Wereld Hoeveelheden het volgende above Wereld Relaties boven below Wereld Relaties onder left_of Wereld Relaties links van right_of Wereld Relaties rechts van on_top Wereld Relaties op near Wereld Relaties dichtbij across Wereld Relaties aan de overkant van side_of Wereld Relaties aan de zijde van (in combinatie met een locatie) between Wereld Relaties tussen from Syntax Relaties vanaf (als in Go from A to B) effect Syntax Relaties een effect door een actie bvb to in Bump the brick to collect a coin. not Syntax Negatie negatie if Syntax Voorwaarden als, dan structuur until Syntax Voorwaarden totdat and Syntax Coördinatie en or Syntax Coördinatie of action_sub Syntax Actie coördinatie deze tag duidt een subactie aan bvb by in Go across the gap by jumping. action_after Syntax Actie coördinatie nadat action_before Syntax Actie coördinatie voordat action_goal Syntax Actie coördinatie deze tag duidt een doel aan bvb to in Jump to go across the gap.76
  • action_constraint Syntax Actie coördinatie deze tag duidt een constraint bij een actie aan bvb while in Jump over the gap while col- lecting the coins.none Syntax Default de standaard tag, heeft geen betekenis 77
  • Bijlage CDe doelstructurenIn deze bijlage vindt u enkele tabellen met hierin de verschillende soorten vanstructuren, de structuren waarvan ze overerven en hun attributen. De tabellen zijnopgebouwd op basis van het type van de structuren. Naam Erft van Attributen Structure not : boolean number : Number order : Order horizontalSideOf : Location verticalSideOf : Location ConditionStructure Structure ModifierStructure Structure Tabel C.1: De algemene structuren 79
  • C. De doelstructuren Naam Erft van Attributen ActionStructure Structure subject : Object target : Object effect : Object MotionActionStructure ActionStructure from : ObjectStructure across : ObjectStructure AvoidStructure ActionStructure BumpStructure ActionStructure CollectStructure ActionStructure ExistsStructure ActionStructure above : List<ObjectStructure> ConditionStructure below : List<ObjectStructure> left_of : List<ObjectStructure> right_of : List<ObjectStructure> near : List<ObjectStructure> in : List<ObjectStructure> between : List<ObjectStructure> across : List<ObjectStructure> on_top : List<ObjectStructure> FireballStructure ActionStructure GoToStructure MotionActionStructure JumpStructure MotionActionStructure KillStructure ActionStructure fireball : boolean MovingStructure MotionActionStructure ConditionStructure RunStructure MotionActionStructure WalkStructure MotionActionStructure Tabel C.2: De structuren voor actie tags Naam Erft van Attributen ConjunctionStructure RelationStructure conjunctions : List<Structure> ConditionStructure ObjectStructure ActionStructure LocationStructure OrderStructure NumberStructure AndStructure ConjunctionStructure OrStructure ConjunctionStructure Tabel C.3: De structuren voor coördinatie80
  • Naam Erft van AttributenActionAfterStructure Structure action1 : ActionStructure action2 : ActionStructureActionBeforeStructure Structure action1 : ActionStructure action2 : ActionStructureActionConstraintStructure Structure action : ActionStructure constraint : ActionStructureActionGoalStructure Structure action : ActionStructure goal : ActionStructureActionSubStructure Structure action1 : ActionStructure action2 : ActionStructureIfThenStructure Structure condition : ConditionStructure trueAction : ActionStructure falseAction : ActionStructureUntilStructure Structure condition : ConditionStructure trueAction : ActionStructure Tabel C.4: De structuren voor actie coördinatieNaam Erft van AttributenLocationStructure StructureBottomStructure LocationStructureInStructure LocationStructure argument : ObjectStructure RelationStructureLeftStructure LocationStructureMiddleStructure LocationStructureRightStructure LocationStructureTopStructure LocationStructure Tabel C.5: De structuren voor locaties Naam Erft van Attributen NumberStructure ModifierStructure value : int OrderStructure ModifierStructure value : int NextStructure OrderStructure Tabel C.6: De structuren voor hoeveelheden 81
  • C. De doelstructuren Naam Erft van Attributen ObjectStructure ModifierStructure above : List<ObjectStructure> below : List<ObjectStructure> left_of : List<ObjectStructure> right_of : List<ObjectStructure> near : List<ObjectStructure> in : List<ObjectStructure> between : List<ObjectStructure> across : List<ObjectStructure> on_top : List<ObjectStructure> locations : List<LocationStructure> plural : boolean AirStructure ObjectStructure BlockStructure ObjectStructure x1 : int y1 : int question_block : boolean CoinStructure ObjectStructure x1 : int y1 : int FloorStructure ObjectStructure x1 : int x2 : int y1 : int y2 : int FlowerStructure MonsterStructure GapStructure ObjectStructure x1 : int x2 : int y1 : int y2 : int MarioStructure ObjectStructure x1 : int y1 : int MonsterStructure ObjectStructure x1 : int y1 : int PipeStructure ObjectStructure x1 : int x2 : int y1 : int y2 : int flower : FlowerStructure cannon : MonsterStructure PlatformStructure ObjectStructure x1 : int x2 : int y1 : int y2 : int isWall : boolean type : {BLOCK, QUES- TION_BLOCK, MIXED, FLOOR} PowerUpStructure ObjectStructure x1 : int82 y1 : int QuestionStructure ObjectStructure x1 : int y1 : int StairsStructure ObjectStructure x1 : int x2 : int y1 : int y2 : int
  • Naam Erft van AttributenRelationStructure ConditionStructure argument : Structure ModifierStructureAboveStructure RelationStructureAcrossStructure RelationStructure argument2 : ObjectStructureBelowStructure RelationStructureBetweenStructure RelationStructureEffectStructure RelationStructureFromStructure RelationStructureLeftOfStructure RelationStructureNearStructure RelationStructure argument2 : ObjectStructureOnTopStructure RelationStructureRightOfStructure RelationStructureSideOfStructure RelationStructure Tabel C.8: Structuren voor relaties 83
  • Bijlage DDe patronen voordoelconstructieIn deze bijlage vindt u de patronen gebruikt bij het extraheren van de semantischerollen en de koppelingen tussen de woorden in de instructie. De patronen zijnopgedeeld in groepen. Iedere groep is van toepassing op een bepaalde set tags.D.1 Action CoordinationTags: action_before, action_after, action_subaction1: De eerste actieaction2: De tweede actie Voor het extraheren van deze twee variabelen, kan gebruik gemaakt wordenvan twee patronen. Het eerste maakt gebruik van een mark-relatie tussen het tebehandelen woord en action2 en een advcl-relatie tussen action1 en action2. Hettweede patroon maakt gebruik van een prep-relatie tussen het te behandelen woorden action1 en een pcomp of pobj-relatie tussen action1 en action2.D.2 Action GoalTags: action_goalgoal: De doelactieaction: De uit te voeren deelactie Hier wordt gebruik gemaakt van twee mogelijke patronen. Patroon 1 maaktgebruik van een mark-relatie tussen het te behandelen woord en de goal en een ccompof xcomp-relatie tussen goal en action. Patroon 2 maakt gebruik van een aux-relatietussen het te behandelen woord en de goal en een advcl-relatie tussen goal en action. 85
  • D. De patronen voor doelconstructieD.3 ActionTags: walk, jump, run, duck, go_to, collect, fireball, kill, bump, turn, avoidsubject: De agent dewelke de actie uitvoertmodifier: De modifiers van de actie (lijst)relaties: De relaties tov argumenten van de actie (lijst met verschillende keys)subject Voor de extractie van subject, worden twee types van afhankelijkheid-srelaties gebruikt tussen het te behandelen woord (de actie) en subject: nsubj encsubj.modifiers De modifiers worden geëxtraheerd op basis van volgende set van relatiestussen het te behandelen woord en de modifier: advmod, amod, dobj, pcomp, aux, num,nn, prt en det. Merk op dat hier ook relaties bijzitten die enkel aan substantievengekoppeld kunnen zijn. Dit is mogelijk omdat een woord getagd als actie mogelijkeen substantief is.relaties Onder de relaties vallen de voorzetselrelaties. Omdat deze echter kunnenlopen over meerdere woorden met none-tags, worden deze samengevoegd tot eenketen totdat een object gevonden wordt. De relaties waar over samengevouwen wordtzijn in volgorde prep en pobj. Indien het gevonden object in de pobj-relatie none is,wordt een verdere prep-relatie gezocht. De opeenvolgende voorzetsels worden aanelkaar gehangen door gebruik te maken van het plusteken. Naast objecten wordenook locaties opgevouwen in deze keten. De modifiers van de preposities worden meeopgevouwen in een deellijst die aangeduid wordt met vierkante haakjes die staat bijhet voorzetsel waarbij de modifiers staan.D.4 Conditional CoordinationTags: if, untilcondition: De conditietrueAction: De actie uit te voeren indien de conditie waar isfalseAction: De actie uit te voeren indien de conditie onwaar is. Komt enkel voor bij if.condition De conditie wordt herkend op basis van twee relaties tussen het tebehandelen woord en condition: advmod en mark. Een conditie is verplicht voordeze structuur.trueAction De trueAction kan herkend worden op basis van een advcl-relatietussen condition en trueAction. Dit veld is eveneens verplicht.86
  • D.5. Constraint CoordinationfalseAction Deze variabele komt enkel voor wanneer het te behandelen woordeen if -tag heeft. De variabele wordt ingevuld op basis van een ccomp-relatie tussentrueAction en falseAction.D.5 Constraint CoordinationTags: action_constraintaction: De uit te voerende actieconstraint: De concurrerende actie die gelijktijdig met de eerste actie uitgevoerd moet worden of de toestand die geldig moet zijn gedurende de uitvoer van de actie De variabelen voor deze tag kunnen ingevuld worden op basis van twee patronen.Het eerste patroon maakt gebruik van een mark-relatie tussen het te behandelenwoord en constraint en een advcl-relatie tussen constraint en action. Het tweedepatroon heeft de vorm van een conjunctie. Hierbij is een cc-relatie tussen constrainten het te behandelen woord en een conj-relatie tussen constraint en action. Er magslechts één conj-relatie zijn.D.6 CoordinationTags: and, orconjunction: De leden van de coördinatiestructuur (lijst)modifier: De modifiers van de structuur (lijst)relaties: De relaties tov argumenten van de structuur (lijst met verschillende keys)conjunction Coördinatiestructuren worden gerefereerd op basis van het hoofdvan de structuur. Dit hoofd is het eerste lid van de structuur. Om er voor tezorgen dat naar de hele structuur gewezen wordt, wordt in een een eerste stap dithoofd vervangen. Dit gebeurt door ieder voorkomen van dit hoofd te vervangenmet het te verwerken woord voor alle relaties tussen de eerste conj-relatie van degroep en de eerst volgende cc-relatie die niet de relatie is voor de huidige groep. Deafhankelijkheidsrelaties zijn gesorteerd op oplopende index van de dependent van derelatie. Hierna wordt de conjunction-lijst ingevuld door gebruik te maken van decc-relatie en de conj-relaties tussen het te verwerken woord en de conjunction.modifiers en relaties Deze worden analoog aan de modifiers en relaties vanAction bepaald (zie D.3).D.7 LocationTags: top, bottom, left, right, middle, inmodifier: De modifiers van de structuur (lijst) 87
  • D. De patronen voor doelconstructierelaties: De relaties tov argumenten van de structuur (lijst met verschillende keys) De variabelen worden analoog aan de modifiers en relaties van Action bepaald(zie D.3).D.8 Environment ActionTags: exists, movingsubject: De agent dewelke de actie uitvoertmodifier: De modifiers van de actie (lijst)relaties: De relaties tov argumenten van de actie (lijst met verschillende keys)subject Het subject wordt bepaald op dezelfde manier als bij Action. Het is voordeze tag echter mogelijk om op extra manieren het subject te vinden. Er zijn tweerelaties op basis van welke subject ook ingevuld kan worden: rcmod en partmod.Deze relaties zijn tussen het te behandelen woord en subject. Indien subject reedsingevuld is, worden de gekoppelde woorden gelijk gesteld met het subject. In hetandere geval worden ze als modifier toegevoegd.modifiers en relaties Deze worden analoog aan de modifiers en relaties vanAction bepaald (zie D.3).D.9 NegationTags: not Deze structuur wordt herkend op basis van een neg-relatie tussen het te behandelenwoord en het gemodificeerde woord. Indien deze relatie voorkomt, wordt het tebehandelen woord toegevoegd in de modifier-lijst van het gemodificeerde woord.D.10 ObjectTags: platform, pipe, gap, wall, stairs, coin, power-up, floor, air, flower, mario, monster, block, order, number, next, question_blockmodifier: De modifiers van het object (lijst)relaties: De relaties van het object (lijst met verschillende keys) De variabelen worden analoog aan de modifiers en relaties van Action bepaald(zie D.3).88
  • D.11. Relation ActionD.11 Relation ActionTags: near, acrossmodifier: De modifiers van de actierelatie (lijst)relaties: De relaties van de actierelatie (lijst met verschillende keys) De variabelen van deze structuur worden ingevuld op een analoge manier als dievan Environment Action (zie D.8). De modifiers van deze relatie kunnen echter ookingevuld worden op basis van de pobj en pcomp-relaties. Ook worden de elementendie als subject staan, in de modifier-lijst toegevoegd.D.12 RelationTags: above, below, on_top, side_of, left_of, right_ofmodifier: De modifiers van de relatie (lijst)relaties: De relaties van de relatie (lijst met verschillende keys) De variabelen worden analoog aan de modifiers en relaties van Action bepaald(zie D.3). De modifiers van deze relatie kunnen echter ook ingevuld worden op basisvan de pobj en pcomp-relaties. 89
  • Bijlage EDe AIML pattern matcherIn deze bijlage vindt u de gebruikte werkwijze voor het opstellen van een pat-tern matcher voor de natuurlijke taal. Verder worden ook alle gebruikte patronenweergegeven.E.1 AanpakVoor de pattern matcher is gebruik gemaakt van Alicebot [1]. Van Alibot zijnopensource versies geschreven in verschillende programmeertalen. Er is gekozen omgebruik te maken van Program D[4], een versie geschreven in Java. Alicebot maaktgebruik van AIML[43] of Artificial Intelligence Markup Language om zijn patronenuit te drukken. De patronen gebruikt door de pattern matcher zijn met de handopgesteld. Aangezien de pattern matcher de voorgestelde aanpak moet emuleren,is er gekozen om de kennis uit de voorgestelde doelstructuur te gebruiken tijdenshet opstellen van de patronen. Voor iedere deelstructuur uit de voorgestelde aanpakzijn een aantal patronen opgesteld die het mogelijk moeten maken om instructiesin natuurlijke taal, door middel van de parser, naar de doelstructuur om te zetten.Er is gebruik gemaakt van de trainingsdata in de vorm van walkthroughs om depatronen voor de pattern matcher op te stellen. De patronen worden op een gulzige manier gematcht. Dit betekent dat zodraeen patroon gevonden wordt dat kan matchen, dit patroon ook toegepast wordt.Hierdoor moeten de regels voor grotere structuren zoals and, or, before en aftervooraan in de lijst met patronen staan. Het te vroeg toepassen van deze patronenkan echter tot fouten leiden. Bij het opstellen van de patronen werd al snel duidelijkdat sommige woorden zoals to, on en it ambigue betekenissen kunnen hebben. Ditmaakt het moeilijk om een correct patroon op te stellen voor deze woorden. Correctoplossen van deze problemen zou een gigantische verhoging van het aantal patronenvereisen. Daarom is er voor gekozen om voor deze structuren slechts één patroonte voorzien. De structuren waarvoor geen patroon aanwezig is, zullen niet herkendworden. 91
  • E. De AIML pattern matcher Opdat met een beperkte set patronen gewerkt kan worden, is gekozen de invoerin-structies eerst te reduceren naar een alfabet van gekende woorden. Deze reductiegebeurt door voor ieder woord het een synoniem in het alfabet te selecteren. Dezereductie gebeurt handmatig. Hierbij vond voor sommige instructies een disambiguatieplaats. Dit kan een lichte positieve invloed hebben op de resultaten van het systeem.E.2 De patronenVoor de patronen is gebruik gemaakt van AIML. AIML maakt het mogelijk omwildcards (* en _) te gebruiken. Bijgevoegd is een extract van de gebruikte patronen,de overige patronen zijn analoog.<category> <pattern>_ and _</pattern> <template> and[conjunctions:[<srai><star index="1"/></srai>,<srai><star index="2"/></srai>]] </template></category><category> <pattern>if _ then _ else _</pattern> <template> if[condition:<srai><star index="1"/></srai>, trueAction:<srai><star index="2"/></srai>, falseAction:<srai><star index="3"/></srai>] </template></category><category> <pattern>if _ then _</pattern> <template> if[condition:<srai><star index="1"/></srai>,trueAction:<srai><star index="2"/></srai>] </template></category><category> <pattern>block</pattern> <template>block[]</template></category><category> <pattern>block _</pattern> <template>block[<srai><star index="1"/></srai>]</template></category><category> <pattern>pipe</pattern> <template>pipe[]</template></category><category> <pattern>pipe _</pattern> <template>pipe[<srai><star index="1"/></srai>]</template></category><category> <pattern>left</pattern>92
  • E.2. De patronen <template>left[]</template></category><category> <pattern>right</pattern> <template>right[]</template></category><category> <pattern>left of *</pattern> <template>left_of:<srai><star index="1"/></srai></template></category><category> <pattern>right of *</pattern> <template>right_of:<srai><star index="1"/></srai></template></category><category> <pattern>bump _</pattern> <template>bump[target:<srai><star index="1"/></srai>]</template></category><category> <pattern>jump _</pattern> <template>jump[target:<srai><star index="1"/></srai>]</template></category><category> <pattern>* _</pattern> <template><srai><star index="1"/></srai>,<srai><star index="2"/></srai></template></category> 93
  • Bijlage FDe gebruikte testdataIn deze bijlage vindt u enkele voorbeelden van de gebruikte testdata. Bij iedereinstructie hoort een willekeurig bepaalde wereld waarin de instructie mogelijk is.Eenvoudige instructies zijn korte instructies (tot tien woorden) en bestaand uit eenenkele actie gecombineerd met objecten waarvoor hoogstens één relatie met eenander object aanwezig is. De semi-complexe instructies bevatten tot drie acties inif-then-else-structuren, coördinaties, gevolgen, deelacties, . . . De instructies bevattentot drie relaties tussen de verschillende objecten bij de acties. Complexe instructiesbestaan uit acties gecombineerd door meerdere van bovenstaande structuren. Ookbevatten deze instructies tussenwerpsels en voor de agent oninteressante informatie. 95
  • F. De gebruikte testdata Go to the right. Collect the power-up left of the gap.. Kill the goomba on top of the question block. Avoid the goomba below the platform. Jump from the pipe to the platform. Tabel F.1: Voorbeeld van eenvoudige instructies96
  • Hit the middle of the three blocks for a Power-Up, then go up the stairs. Jump over the pipe and jump on the goomba. Go to the right until you are near a gap. Go to the left before killing the goomba. Run to the left if there is a goomba on the plat- form.Tabel F.2: Voorbeeld van semi-complexe instructies 97
  • F. De gebruikte testdata Jump on the platform, the pipe and the question block before killing the goomba. Avoid the goomba and hit the first block for 10 coins. Start off by going to the right before jumping on the platform and ending with a jump across the gap. If there is a platform after the pipe then go right before collecting the power-up. Kill the goomba, run to the right or jump over the gap and collect the power-up. Tabel F.3: Voorbeeld van complexe instructies98
  • Bijlage GDatatransformaties doorheenhet proces voor eenvoorbeeldinstructieIn deze bijlage wordt een overzicht gegeven van de verschillende datatransformatiesdoorheen het proces (zie ook figuur 1.1). Hiervoor maken we gebruik van volgendeinstructie:Start off by going to the right before jumping on the platform and jumping across the gap.Bij deze instructie gebruiken we de wereld weergegeven in figuur G.1. Eerst wordt Figuur G.1: De wereld waarin de instructie uitgevoerd wordt. 99
  • G. Datatransformaties doorheen het proces voor eenvoorbeeldinstructievoor de invoerinstructie de verzameling met afhankelijkheidsrelaties gegenereerd.Deze set is de volgende: advmod(start-1, off-2), prep(start-1, by-3), pcomp(by-3, going-4),prep(going-4, to-5), det(right-7, the-6), pobj(to-5, right-7), prep(going-4, before-8), pcomp(before-8, jumping-9), prep(jumping-9, on-10), det(platform-12, the-11), pobj(on-10, platform-12), cc(jumping-9, and-13), conj(jumping-9, jumping-14), prep(jumping-14, across-15), det(gap-17, the-16), pobj(across-15, gap-17)Vervolgens wordt deze set relaties omgevormd naar invoer voor de tagger. Dit gebeurtzoals beschreven in sectie 3.4. Deze invoer is: start advmod(X,_) prep(X,_) off advmod(_,X) by prep(_,X) pcomp(X,_) going pcomp(_,X) prep(X,_) prep(X,_) to prep(_,X) pobj(X,_) the det(_,X) right det(X,_) pobj(_,X) before prep(_,X) pcomp(X,_) jumping pcomp(_,X) prep(X,_) cc(X,_) conj(X,_) on prep(_,X) pobj(X,_) the det(_,X) platform det(X,_) pobj(_,X) and cc(_,X) jumping conj(_,X) prep(X,_) across prep(_,X) pobj(X,_) the det(_,X) gap det(X,_) pobj(_,X) Hieruit wordt volgende tagging berekend:none none none go_to near none right action_before jump on_top none platform and jump across none gapDeze informatie wordt dan doorgegeven aan de pattern matcher die patronen in dedata zal herkennen en een domeinonafhankelijke doelstructuur opstelt. Dit resulteertin volgende de structuur weergegeven in figuur G.2. Deze datastructuur wordtvervolgens omgezet naar de uiteindelijke doelstructuur waarop reeds een controletegen de domeinkennis gebeurt. Deze doelstructuur is weergegeven in figuur G.3.Hierop wordt deze doelstructuur gecontroleerd op geldigheid in de wereld. Hiervoorwordt een query opgesteld die uitgevoerd zal worden op de wereldinformatie. Dezequery bestaat enkel uit de object identifiers aangezien er geen verbanden zijn tussende verschillende objecten:100
  • a t n b fr co _ eoe i atn co 1 i atn co 2 i g _o ot ad n na er cn ntn o j co s u i rh it g j ump j ump o _o n tp a rs co s p tr lf m ao gp aFiguur G.2: De datastructuur gegenereerd door de pattern matcher op de afhanke- lijkheidsrelaties. A t n eoe t c r co B frSr t e i uu atn co 1 i atn co 2 i G T Src r oo t te uu ad n tre ag t cn ntn o j co s u i Rg tt c r J mp t c r i Sr t e u Sr t e h uu uu J mp t c r u Sr t e uu tre ag t a rs co s Pafr t c r l omSr t e t uu G p tc r a Sr t e uuFiguur G.3: De doelstructuur voor Start off by going to the right before jumping on the platform and jumping across the gap.. 101
  • G. Datatransformaties doorheen het proces voor eenvoorbeeldinstructie object(mario, M_X, M_X, M_Y, M_Y), object(platform, PLATFORM_29517777_X1, PLATFORM_29517777_X2, PLATFORM_29517777_Y1, PLATFORM_29517777_Y1), object(gap, GAP_3016381_X1, GAP_3016381_X2, GAP_3016381_Y1, GAP_3016381_Y2).Voordat deze query uitgevoerd kan worden, moeten echter eerst de wereldinformatieomgezet worden naar Prolog en zullen de composites herkend moeten worden. Eenextract van deze informatie is: block(mario, 41, -10) block(coin, 38, 0) block(coin, 39, 0) block(unbreakable_brick, 37, -2) block(unbreakable_brick, 38, -2) block(breakable_brick, 39, -2) block(breakable_brick, 40, -2) block(unbreakable_brick, 37, -5) block(breakable_brick, 38, -5) block(unbreakable_brick, 39, -5) block(coin, 38, -9) block(coin, 39, -9) block(coin, 38, -10) block(coin, 39, -10) block(border_cannot_pass, 32, -11) block(border_cannot_pass, 33, -11) block(border_cannot_pass, 34, -11) block(monster, 36, -11) block(monster, 38, -11) block(breakable_brick, 39, -11) block(breakable_brick, 40, -11) block(breakable_brick, 41, -11) block(border_cannot_pass, 42, -11) block(border_cannot_pass, 43, -11) block(flower_pot, 48, -11) block(flower_pot, 49, -11) ... Uit deze informatie kunnen onder andere de wereldstructuren herkend wordenzoals aangegeven in figuur G.4. Bij het uitvoeren van de query worden de objectenuit de doelstructuur geïdentificeerd met objecten in de wereld. De gekozen gap isde meest rechtse en het gekozen platform is het bovenste. De eindstructuur is devolgende:102
  • Figuur G.4: De wereldstructuren in de wereld. Geel: platform; Rood: pipe; Blauw: gapaction_before[ action1:goto[target:right[]]; action2:and[ conjunctions:[ jump[target: platform[ wall:false; type:MIXED; x1:37; y1:-2; x2:40; y2:-2 ] ], jump[across: gap[ x1:44; y1:-12; x2:48; y2:-11 ] ] ] ]] 103
  • Bijlage HWetenschappelijk artikel 1 105
  • Instructing Mario by using natural language Pieter-Jan Speelmans & Maarten Tielemans Abstract 1.1. The problem setting In order to perform actions expressed in natural This paper handles the problem of understanding language, it is important for a computer to fully un-movement instructions given in unrestrained language derstand the meaning of these instructions. One of theand provides a framework for handling those problems. major problems in extracting the meaning from unre-We suggest an approach which uses grammatical struc- stricted natural language is ambiguity. A different prob-tures to extract features in the form of Stanford depen- lem is the complexity of the instructions represented indencies from the instructions and combining these fea- natural language (Bugmann, 2003).tures with relational environment information in orderto solve ambiguity. The paper focusses on instructing 1.1.1. Ambiguity:. One type of ambiguity, is ambigu-an agent in a simulated Super Mario environment. ity of words. For example in Jump on the mushroom.1. INTRODUCTION the mushroom can refer to a power-up mushroom, to an enemy or even to a part of the environment. The goal of this paper is to control an agent in There is also ambiguity of grammatical structure.an environment by using unrestrained natural language. For exampleThe chosen setting for testing our approach is playing a Jump on the platform to the left.game of Super Mario with written unrestrained instruc-tions. can refer to jumping on a platform that is located to the We chose to use the MarioAI framework1 and its left of Mario or jumping to the left side of the screenworld for testing the techniques presented in this paper. while standing on top of a platform.The MarioAI framework is an open source framework Since there is no perfect solution for ambiguity, afor simulating the Mario world. It provides the ability clear analysis of the world needs to happen before de-to code agents for interacting with this world as well ciding which meaning is (most) correct.as the ability to extract environmental information. Wefeel that the Mario world is a good placeholder for the 1.1.2. Complexity of instructions:. There is a big gapreal world because it presents the same challenges and in complexity between computer instructions and hu-difficulties but at the same time it does not exhibits the man instructions. Computers need low level instruc-same problems - the Mario world is manageable and tions like going left/right/up/down while natural lan-controllable. guage tends to express compound instructions on a higher level. A mapping from these complex instruc- In section 1.1 we start by explaining the problem tions to computer understandable instructions is neededsetting. Section 1.2 handles the approaches which are to solve this problem.being currently used in the literature to solve the pre-sented problems. In section 2 we explain how we plan 1.2. Known approacheson solving these problems by mapping the instructionsonto dependency relations (section 2.1) and extracting 1.2.1. Restricting the input language:. One of therelational information about the world (section 2.2). Fi- known approaches is restricting the input language tonally in section 3 we explain how we can use these re- unambiguous language. This approach removes thelations for learning goals and resolving these goals. problem of ambiguity. In a further stage even the com- plexity of instructions can be handled by only allowing 1 http://www.marioai.org/ simple or preset instructions. (Clark et al., 2005)
  • The biggest problem with this approach is the fact 2.1. Instruction to dependency relationsthat the language is no longer unrestricted. This meansthe users need to adapt to the system instead of the sys- Major universities have already done research ontem adapting to the users. Due to this disadvantage we extracting grammatical information and relations fromchoose not to use this approach. sentences. Most of their work has been released under an open source license and is freely available for use.1.2.2. Pattern matching:. This technique tries to find An initial comparison has been done between some ofpatterns in the input sentences. These patterns are then the alternatives.mapped to meaning and lower level instructions. This A prerequisite for the task of agent instructing isapproach has been widely applied in the domain of solving the problem of ambiguity. This requires therobotics. (Califf et al., 1997) parser to be able to display (all) alternative parses for The biggest advantage of this approach is that the the input sentence. After filtering out the parsers whichpattern matching is quite easy and works relatively well. were unable to display multiple parses, a comparisonA disadvantage however is that the approach is not between the Link Grammar parser, the Berkeley parseradaptive to new kinds of instructions. Instructions for and the Stanford parser has been done.which there is no pattern, will be ignored. 2.1.1. Link Grammar. The Link Grammar2 parser1.2.3. Using a semantic frame:. The context of the (Sleator and Temperley, 1991) is the parser which haswords used in the instructions can in some cases be been around the longest of the chosen parsers. On topused to reduce ambiguity. By using lexical resources of just being able to parse the sentence with Penn Tree-like FrameNet, WordNet or VerbNet, a semantic frame bank annotations (Bies et al., 1995), there is also a rela-can be found for the words in the sentence. By explor- tion extraction tool which spun off the original project:ing the relations between those frames, certain mean- the RelEx3 (Ross and Vepstas, 2008) dependency rela-ings of the sentence can be annotated as more or less tionship extractor.likely. (Johnson et al., 2003) The parser uses a linkage model which links groups A disadvantage for this approach is that a good lex- of words together. Each possible linkage for the sen-ical resource is needed for the application and its do- tence gets a score indicating how good the linkage is.main. Also the semantic frame isn’t able to make a The returned linkages are all different.distinction between multiple environmental states. For There are however a couple of disadvantages aboutexample when saying the parser. So is it that the parser has problems with if- then-else and first-next constructs. On top of that, there are problems with conjunctions and punctuation. These Jump on the platform with a flower. are some crucial disadvantages since people tend to use these constructs when giving instructions.knowledge about the environment and the domain is When adding RelEx to the parser in order to extractneeded rather than a semantic frame. dependencies, we also notice the parsing is incredibly slow.2. PLANNED APPROACH 2.1.2. Berkeley parser. The Berkeley parser4 (Petrov Our suggested approach on solving this problem et al., 2006) uses a probabilistic context-free grammaruses grammatical structures. From our input instruc- (PCFG) (Johnson, 1998) for parsing the sentences. Thetion, parse trees are generated. From those parse trees, parser is fast and it is possible to request the k-mostdependency relations can be extracted. This would re- likely unique trees. The trees are also annotated us-sult in a collection of sets of relations. ing the Penn Treebank annotations. The Berkeley NLP On the other end, we have the world information. group also claims their parser is the most accurate andThis information is abstracted into a set of world rela- one of the fastest for a wide variety of languages.tions like above, below, left of, right of, ... The major disadvantages of the parser are that it The next step then is to combine the dependency does not come with a relation extraction tool and thatrelations and the world relations onto the goals which the code is undocumented. Despite all its configurationneed to be realized. For combining the relations, we options, this makes the parser harder to use.suggest using a learning algorithm. 2 http://www.link.cs.cmu.edu/link/ For a global overview of our approach, see figure 3 http://wiki.opencog.org/w/RelEx1. 4 http://nlp.cs.berkeley.edu/link?page=Parsing
  • Figure 1. Schematic representation of the approach.2.1.3. Stanford parser. The Stanford lexical parser5 extractor. This gives the advantage of having multiple(Klein and Manning, 2003), is a fairly new parser which different trees while we still have the expressibility ofalso uses PCFGs. One of its key features is the possibil- the Stanford dependencies.ity to extract dependencies. The format of these depen- This choice is also motivated by Cer et al. (2010)dencies is called Stanford Dependencies (de Marneffe where a thorough analysis of the speed and accuracyet al., 2006). for deriving Stanford dependencies is given. They con- The parser has been developed in Java and is well cluded that a high accuracy is achieved using thesedocumented. It also annotates the sentences with the parsers. This accuracy is even better than most of thePenn Treebank annotations and the k-best trees kan be dependency-based parsers.requested. These trees are however not unique whichmakes it possible that some important trees are not re- 2.2. Mario World to relationsturned because their probability is too low. In plentyof test cases the same tree was returned in such abun- For the task of instructing Mario, we chose to rep-dance that the other parse trees were pushed out of the resent the world by a set of relationships between ob-returned k-best lists. jects in the world and Mario itself. We used SWI-Prolog The dependency extractor is a very useful tool. It and its Java front-end JPL to combine the power of Pro-can be used on any Penn Treebank annotated sentence, log with the MarioAI framework.which makes it possible to be combined with other For simplicity, we start out by only allowing staticparsers. The returned dependencies are collapsed using worlds. This means there will be no support for mon-the head of the relations. This results in more meaning- sters or breakable bricks in our environments.ful relations.2.1.4. Our choice. Based on the advantages and disad- 2.2.1. Composite objects. The MarioAI frameworkvantages of these parsers, we decided to use the Berke- provides the world information in the form of a twoley parser to parse the input instructions. The output of dimensional array of bytes. The type of brick in thethe Berkeley parser is than fed to the Stanford relation world is encoded in this information. We chose to group these bricks in more general objects like platform, wall 5 http://nlp.stanford.edu/software/lex-parser.shtml and pipe. This grouping happens based on background
  • above/2 below/2 goals. The learner will use the dependency relations ex- left of/2 right of/2 tracted from the input sentence as well as a relational diagonally below left/2 diagonally below right/2 representation of the world together with background diagonally above left/2 diagonally above right/2 knowledge about the objects in the world. By using this next to/2 ontop/2 background knowledge, the learner should be able to between/3 remove the ambiguity in the instruction and execute the correct task. Table 1. Supported place prepositions For this learner there are plenty of options like re- lational learning, probabilistic models, pattern match- ing, classification, reinforced learning, ... Currently weknowledge which we added to the system. We believe are investigating which learning algorithm can solve thethese groupings will result in more accuracy for our task problem with the highest accuracy. We are also consid-since people tend to speak about the bigger objects in ering the use of FrameNet, WordNet and VerbNet forstead of the specific bricks when instructing an agent. finding synonyms for both actions and objects with the The background knowledge for identifying clusters goal to increase the accuracy of the learners.of bricks is fairly straightforward. For a platform/wall ahorizontal/vertical line of bricks or ground is required. One of the possibilities we are looking into is theFor pipes we use a two adjacent columns of pipe-bricks possibility to determine the types of goals by makingwith the same height. More structures can be added use of the verbs in the instruction as well as the condi-later if we feel there is a need for them. One example of tions they are under and their order of execution. Witha structure which will probably be added is the notion those goal types we believe it to be easier to extract theirof a pit. arguments and define the world object corresponding to it. Apart from the ability to combine individual bricksinto composite types, there is also the ability to checkwhether or not a brick is part of a specific platform by 3.2. Goal structureusing the part of/2 predicate. For representing the goals in the system, we can see2.2.2. Place propositions. The relations between the they are ordered in a hierarchy. We can clearly iden-objects are fairly straightforward. It is important to be tify more general actions like killing a monster. Theable to denote how two objects are oriented to each more specific actions are killing a monster using a fire-other. In order to do this, we provide background ball, using a shell or by jumping on it. The same mini-knowledge for extracting relations like left, right, above, structures can be built for the other actions.below... On top of that, it is useful to be able to express We can also see that there are some restrictions onproximity of objects. In the Mario environment, it is the goals. The goals should be non ambiguous so eachcommon to speak of notions such as next to or express- goal can be interpreted in only one way. It is also clearing something is on an object. We only support one the structure for representing our goals should add sup-ternary relation at this moment: a between-relation. port for conditions like if-then-else statements, conjunc- For a list of all possible relations between objects, tions and disjunctions and concurrency. The negationsee table 1. of actions can also be added in the goal structure but we can also use the constraint that when something is not3. FUTURE GOALS mentioned, its state should not change.3.1. Learning actions 3.3. Goal realization The amount of possible actions in the Mario en- Finally for realizing the goals outputted by thevironment is fairly limited. You can jump on or over learner, we currently suggest using a simple planning al-things, kill monsters using a shell, a fireball or by jump- gorithm in combination with a pathfinder. The pathfind-ing on them, move, collect power-ups and coins and ing algorithm should be able to map the goals onto thejump against bricks in order to destroy them or release simple Mario actions: left, right, up, down, jump, shoot.a coin or power-up. Since the amount of actions which The planning algorithm should be able to determine aMario can perform in the world is limited, we believe it correct order of the actions which need to be executedto be possible to train a learning algorithm to correctly for realizing the given goals as well as handle and checkdetermine the goals and the order of execution of these the conditions.
  • 4. CONCLUSION As represented in this paper we suggest extract-ing Stanford dependency relations from instruction andcombining these relations with relational and structuralinformation extracted out of the environment. By com-bining this information, we believe an accurate solutionfor mapping natural language instructions onto goalscan be reached. These goals are than to be executedby an agent.References [1] Bugmann, G. 2003. Challenges in Verbal Instruction of Domestic Robots. In: Proceeding of the ASER03, the 1st International Workshop on Advances in Service Robotics. [2] Clark, P., P. Harrison, T. Jenkins, J. Thompson, R.H. Wojcik, . 2005. Acquiring and Using World Knowledge Using a Restricted Subset of English. In: FLAIRS 2005, pp. 506511. [3] Mary Elaine Califf and Raymond J. Mooney. 1997. Re- lational Learning of Pattern-Match Rules for Informa- tion Extraction. University of Texas in Austin. [4] Christopher Johnson, Miriam Petruck, Collin Baker, Michael Ellsworth, Josef Ruppenhofer, and Charles Fill- more. 2003. Framenet: Theory and practice. Berkeley, California. [5] Sleator, D., and D. Temperley. 1991. Parsing English with a link grammar. Technical Report CMU-CS-91- 196, Carnegie Mellon University. [6] Bies, A., M. Ferguson, Karen Katz, and Robert MacIn- tyre. 1995. Bracketing Guidelines for Treebank II style Penn Treebank Project. Linguistic Data Consortium. [7] Ross, M., and L. Vepstas, 2008. RelEx. OpenCog Project. http://opencog.org/wiki/RelEx. [8] Petrov, S., L. Barrett, R. Thibaux, and D. Klein. 2006. Learning accurate, compact, and interpretable tree an- notation. In Proceedings of COLING-ACL 2006. [9] Johnson, M. 1998. PCFG models of linguistic tree rep- resentations. Computational Linguistics 24 4 , 613-632.[10] Klein, D., and C. D. Manning. 2003. Accurate unlexi- calized parsing. In Proceedings of the 41st Meeting of the Association for Computational Linguistics.[11] de Marneffe, M.-C., B. MacCartney, and C. D. Manning. 2006. Generating typed dependency parses from phrase structure parses. In LREC 2006.[12] Cer, D., M.-C. de Marneffe, D. Jurafsky, and C. D. Man- ning. 2010. Parsing to stanford dependencies: Trade- offs between speed and accuracy. In LREC 2010.
  • Bijlage IWetenschappelijk artikel 2 111
  • Instructing Mario: an approach for determining goals from natural language instructions Pieter-Jan Speelmans & Maarten Tielemans Abstract top of that, the behavior of the Mario world is easier to predict and domain knowledge can be extracted more This paper presents an approach which is able to easily.determine goals from instructions given in unrestrained At first we will give a birds eye view of the sug-natural language to movable robots. The approach uses gested approach (section 1.1). In the next section wethe grammatical structures from the instruction in or- will discuss the proposed approach in more detail (sec-der to extract a goal structure. Apart from that, the tion 2). Here we will discuss the extraction of gram-approach also guarantees that the resulting goal struc- matical structure (section 2.1), the extraction of seman-ture contains actions which are possible in the world by tic knowledge (section 2.2), the construction of the goalverifying it against the current state of the world. The structures (section 2.3) and the verification of the goalapproach is presented using a Super Mario Bros simu- structure (section 2.4). Next we will discuss some ex-lation environment. perimental results in order to evaluate the approach (section 3). Finally we will give a short conclusion (sec- tion 4).1. INTRODUCTION 1.1. Quick overview of the represented ap- When extracting meaning from natural language, proachthere are multiple problems occurring. These prob-lems consist of (but are not limited to) ambigu- The problem of ambiguity of structure is han-ity of structure[10], ambiguity of meaning[12], fig- dled by examining the different possible grammati-ure of speech, . . . [4] Currently these problems are cal structures of the instruction and using the mostbeing solved using pattern matching on the input likely ones. The grammatical structure which is usedinstruction[8], the usage of lexical databases[15] or in this approach consists of the Stanford Dependencyeven by limiting the input to a restricted grammar and Relations[5][9]. These express the grammatical role ofvocabulary[7]. the words in the instruction in a relational form. In this paper we represent an approach to analyse In order to solve the problem of ambiguity of mean-and extract meaning from instructions in unrestricted ing, multiple semantic meanings of the words in the in-natural language by applying it in the domain of Su- struction will be generated. These meanings consist of aper Mario. The approach mentioned in this paper uses predefined alphabet in the chosen domain. They are ex-the grammatical structure of the sentence and combines tracted using a dataset extracted from instructions in theit with the semantic meaning of the words. domain in the form of Super Mario Bros walkthroughs. The framework used to test this approach is the In order to generate the different possible meanings,MarioAI framework[2]. This framework is an open this dataset is used to train a Conditional Random Fieldsource simulator for the Super Mario world. It pro- (CRF)[13]. An expansion of the represented approachvides the ability to code agents which can interact with will also use this dataset in order to filter out the gener-this world as well as the ability to extract environmen- ated meanings which are impossible.tal information. We feel that the Mario world is a good The combination of the grammatical structure andplaceholder for the real world because it presents the semantical information is used to determine a goalsame challenges and difficulties but at the same time it structure which is possible in the current domain. Whendoes not exhibits the same problems - the Mario world determining the goal, illegal combinations of the struc-is manageable and controllable by offering a limited set ture and semantics can be detected. These combinationsof objects and events which can appear in the world. On will be refuted and the next combination will be exam-
  • ined. This parser returns the parse trees in Penn Treebank In order to ensure that this goal is possible in the annotation[14].current state of the world, information is extracted from From the parse trees of the instruction, the Stan-the environment. Against this information, the goal ford Dependency Relations can be extracted. This ex-structure is checked. When the goal structure passes the traction happens by passing the parse trees to the Stan-check against the world, meaning all objects described ford Parser[11]. This will transform the parse tree intoin the goal can be identified with objects in the world, the dependency relations. Note that there are manythe structure is accepted as the goal for the given in- forms of dependency relations. For this approach thestruction. However if the structure fails the test, the cur- standard form of these relations is used. This becauserent combination of grammatical structure and semantic the standard form offers a limited set of possible rela-information will be rejected causing the examination of tions between words. Also note that the Stanford Parserthe next combination. can parse an input sentence to sets of possible depen- dency relations without the need of parsing to a parse2. APPROACH tree first. However, the method used in this approach seems to generate dependency relations which are more The approach presented in this paper can be out- correct[6].lined in four big steps: 2.2. Extraction of semantic meaning 1. The grammatical structure of the input instruction is extracted. For each grammatical structure for the input sen- tence, multiple semantic interpretations can be gener- 2. The semantic meaning of the words are extracted. ated due to ambiguity of semantic meaning. This step 3. The grammatical structure and semantic informa- will generate a list containing different semantic mean- tion are combined in a goal structure. ings for the given grammatical structure. The amount of meanings to be returned, can be configured using a 4. The goal structure is checked against the world. parameter for the approach.In the rest of this section these steps will be discussed 2.2.1. The alphabet. For extracting a list of semanticin more detail. meanings, first a list of possible meanings of words in the chosen domain was created. These possible mean-2.1. Extraction of grammatical structure ings form an alphabet which will be used throughout the rest of the approach. This alphabet we will call the tag- This step will generate a set of distinct grammatical ging alphabet. The alphabet is constructed using a setstructures for the given input sentence. The amount of of possible instructions for the Mario universe obtainedstructures to be returned will be a configuration param- from walkthroughs from Super Mario Bros games[3].eter for of the approach. These instructions were analyzed while writing down The grammatical structure of the sentence is repre- the different meanings each relevant word in the in-sented in the form of Stanford Dependency Relations. structions has. Irrelevant words are those whom holdThese offer a relational representation of the grammati- no meaning in the domain. An example we can find incal dependencies between different parts of the instruc- the colors: each object in the domain has a predefinedtion. These relations express grammatical roles like color so when speaking of an object, its color has nosubject and object relations. This representation offers added value.useful information since the grammatical role of a wordis often linked to its semantic role. On top of that each 2.2.2. The used technique. For generating lists ofset of dependency relations can be interpreted in a sin- meanings for the instruction, a CRF is used. A CRFgle way. can generate a possible tag for an instruction using a In order to generate the Stanford Dependencies, probabilistic approach by calculating the most probablefirst the parse trees for the input instruction are gener- tag for a given sequence of words. When calculatingated. This gives a tree representation of the instruction this tag, a CRF uses the possible tags of the surround-with the words of the instruction as leaves and lexical ing words.categories as the internal nodes. A parse tree repre- To this CRF not only the words in the instructionsents a specific grammatical structure. This means that are given, but also the grammatical roles for each wordfor a parse tree there is no ambiguity of structure. The as extracted from the grammatical structure. This hap-parse trees are generated using the Berkeley Parser[16]. pens by passing all Stanford dependency relations for a
  • given word to the CRF. These relations are abstracted by possible semantic meaning of a word, a set of patternreplacing the given word with an X and all other words matching rules on the dependency relations has beenwith underscores. created. These rules process the roles expressed in the The CRF has been trained using the same walk- dependency relations to create a relational map.throughs as were used to construct the tagging alphabet. After this step all important dependency relationsFor each instruction a correct grammatical structure was need to be processed. A dependency relation is deemedadded. Each word in the instruction was also given the important if it can be used to connect two words thatcorrect tag. have a semantic meaning in the domain. If after ap- plying the patterns, there are still important dependency2.2.3. Recognition and repair of incorrect taggings. relations that are not processed than the parse or taggingWhen generating possible taggings for an instruction will be incorrect.using the CRF, some problems can be detected. TheCRF chooses tags for words which are likely when 2.3.2. Domain knowledge. In this step, domainlooking at the surrounding tags yet unlikely when look- knowledge gets used in order to verify the correctnessing at the word it belongs to. In order to detect these of the map obtained after applying patterns on the de-wrong taggings, a dictionary was created. This dictio- pendency relations and the semantic information. In or-nary contains a list of words and a set of tags which are der to tackle these problems, the relational map is trans-possible for that word. The dictionary was also com- formed in a domain specific structure which restricts in-posed using walkthroughs. Each word occuring more correct relations. When during this transformation pro-than five times in the training data was added to the dic- cess information is found which is not correct accordingtionary. The list of possible tags for these words con- to the domain knowledge, the current parse tree and tag-tains all tags given to that word in the training data. ging are considered to be wrong. Using this dictionary a tagging can be checked oncorrectness: if the dictionary does not contain the tag 2.4. Goal verification on the worldgiven to a word in the list of possible tags for that word,the tagging is considered incorrect. However when the After the goal has been constructed, it can bedictionary contains only one possible tag for a given checked to see if it is possible in the current state ofword, the tagging is not rejected but it will be repaired. the world. This check is realized by transforming theThis means the incorrectly predicted tag will be re- world knowledge into Prolog. From the goal structureplaced by the only tag possible for that word. a Prolog query will be extracted which will check the world information. If the query succeeds, the variables2.3. Construction of goal structures in the query, filled in by Prolog, will be injected into the goal structure so it can identify its objects with the Once both a grammatical structure and semantic objects in the world.meaning are known, a goal structure will be created.This happens by generating a goal by using pattern 2.4.1. Transforming the world knowledge. Thematching on the dependency relations with the help of world information is converted into a Prolog programthe semantic meaning. Next domain knowledge gets which can recognize the different objects in the worldsused to check if the generated goal is possible in the and the relations between these objects. The objectsMario domain. which the program should be able to recognize are those objects which are expressible using tags. If a2.3.1. Pattern matching on dependency relations. certain object cannot be expressed using a tag, it doesWhen analyzing sets of dependency relations, it be- not have to be recognized since the goal structurecomes clear that certain useful goal structures such as will not be able to contain it. The same goes forthe order of actions, conditions for actions, relations the different relations between the objects: for eachbetween actions and objects and between objects them- relation expressed in a tag, a Prolog predicate shouldselves can be detected using one or more dependency exist.relations. Using the semantic knowledge gathered from When transforming the world information to Pro-the tags belonging to each word, these structures can be log, there is one thing to take into account. The iden-detected by searching for patterns in these relations. tifiers of the objects will contain coordinates where in In this step the information from the dependency the world the object is located. However when therelations and the semantic information from tagging agent moves in the environment, relative coordinatesgets processes in order to create a goal structure. This can change. This is the case in the MarioAI worldhappens by applying pattern matching rules. For each where the environment is returned relative to Mario.
  • This means that if the agent moves, the locations stored tions were analysed:in the goal structure might become invalid. In order toavoid this, absolute coordinates can be used. Alterna- Simple instructions: short instructions consisting oftively the coordinates in the goal structure can be up- up to ten words which contain at most one actiondated when the agent moves. For this approach absolute combined with up to two objects.coordinates were used. Semi-complexe instructions: consist of up to three2.4.2. Creating the query. In the query as many infor- actions ordered in if-then-else structures, co-mation which can be verified should be checked. For the ordination structures, consequences, subactions,given domain, it was chosen to verify the different lo- . . . The instructions also contain up to three differ-cations between the objects in the goal structure. How- ent objects for each action.ever not all these relations can be checked even tho theycan be expressed in the query. The information which Complexe instructions: consist of actions ordered incannot be checked easily is that which is linked to tem- combinations of the structures mentioned above.poral information. For example consider the sentence: These instructions also contain information which“Kill the monster when it’s near the gap.. For this in- is irrelevant for the execution of the actions.struction, you cannot check if the monster is near the For the evaluation a total of 60 instructions is be-gap since it is possible that this is not the case (tho it ing used, 20 of each type. Each of these instructions ismight be in the future). For this problem a simple so- being considered in a predefined world. This world islution is picked: if there is temporal information linked randomly chosen, with the constraint that the instruc-to a part of the structure, that part of the structure will tion is executable in the world.not be checked. A possible other solution might be to For the instructions not only the amount of cor-predict if this condition could become possible in the rectly generated goals is calculated but also the typesfuture. That solution might cause problems if the user of mistakes made in the generated instructions areknows the monster will never be near the gap and wants counted. These types are based on the couplings be-no action to be performed. For each part of the structure tween the parts of the goal structure. A coupling be-for which a check must be performed, all its objects and tween two parts is wrong if either the type of the cou-the relations between those objects are to be expressed pling is wrong, the type of the parent structure is wrongin the query. or the child part is missing. Since it is possible for the pattern matching approach to generate goal structures2.4.3. Coupling the goal objects to structure objects. which are invalid in the current world, the amount ofSince the Prolog query built out of the goal structure goals which are incorrect in the current world is alsocontains identifiers for each of the objects in the parts counted. The results are shown in table 1.of the instruction which can be checked, the variables in When analyzing these results we see that the naivethese identifiers will be filled in if the query succeeds. pattern matching approach scores quite good on simpleThis means the identifiers can be linked to objects in the instructions. For semi-complex and complex instruc-world. This means the result of the query can be given tions however, the accuracy takes a big dive. The ver-to the goal structure so it can fill in the identifiers for sion of the suggested approach which does not use a dic-each of its objects. tionary to detect incorrect taggings is more stable when looking at the different types of instructions. Simple3. EVALUATION OF THE APPROACH instructions are still being handled better yet the accu- racy of semi-complex and complex instructions is about For the evaluation of the approach, it was compared the same. The pattern matching approach does performto a simple pattern matching approach based on the AL- better when looking at the simple instructions yet over-ICE chatbot[1][17]. The patterns for this chatbot were all the suggested approach performs better.constructed by hand using the walkthrough data which When we bring the suggested approach which doesis used to train the system for the suggested approach. use the dictionary in the comparison, we notice that itFor the evaluation done in this part, the system was con- scores a lot better than the other two approaches. Notfigured to consider 20 grammatical structures and 20 only is the difference between the types of instructionssemantic meanings. We give results for the approach gone, for all instructions the accuracy has risen. Thewhen using the dictionary and when not using the dic- goal structures which are incorrect for this approach aretionary in order to check for correctness of the taggings. also fairly close to the correct solution: there is only one For each of these systems, three types of instruc- error in each structure. This improvement suggests that
  • 20-20 with dictionary that matching patterns in the grammatical structure of 20-20 no dictionary the instructions is more flexible than matching patterns pattern matcher on the instruction itself. References [1] Alice aiml. URL: https://code.google.com/ p/aiml-en-us-foundation-alice/. correct 14 12 17 [2] Marioai. URL: http://www.marioai.org/. wrong in world 1 0 0 [3] Super mario bros walkthroughs. URL: simple wrong object-action 4 7 2 http://www.gamefaqs.com/nes/ wrong object-object 4 4 1 525243-super-mario-bros/faqs. wrong action-action 0 0 0 [4] G. Bugmann. Challenges in verbal instruction of do- no structure found 0 0 0 mestic robots. Proc. of 1st Intl. Ws. on Adv. in Service correct 7 7 18 Rob.(ASER03), pages 112–116, 2003. semi-complex wrong in world 2 0 0 [5] M. catherine De Marneffe, B. Maccartney, and C. D. Manning. Generating typed dependency parses from wrong object-action 7 5 0 phrase structure parses. In In LREC 2006, 2006. wrong object-object 4 5 2 [6] D. Cer, M. catherine De Marneffe, D. Jurafsky, and C. D. wrong action-action 7 7 0 Manning. Parsing to stanford dependencies: Trade-offs no structure found 0 0 0 between speed and accuracy. In In LREC 2010, 2010. correct 2 9 16 [7] P. Clark, P. Harrison, T. Jenkins, J. Thompson, and wrong in world 3 0 0 R. Wojcik. Acquiring and using world knowledge us- complex wrong object-action 10 7 2 ing a restricted subset of english. In In FLAIRS 2005, wrong object-object 8 3 0 pages 506–511, 2005. [8] K. M. Colby, R. C. Parkison, and W. S. Faught. Pattern- wrong action-action 10 5 1 matching rules for the recognition of natural language no structure found 0 0 1 dialogue expressions. Technical report, Stanford, CA, correct 23 28 51 USA, 1974. wrong in world 6 0 0 [9] M.-C. de Marneffe and C. D. Manning. Stanford depen- wrong object-action 21 19 4 dencies manual, 2008. total wrong object-object 16 12 3 [10] D. Hindle and M. Rooth. Structural ambiguity and lexi- wrong action-action 17 12 1 cal relations, 1993. no structure found 0 0 1 [11] D. Klein and C. D. Manning. Accurate unlexicalized parsing. In In proceedings of the 41st annual meeting of the Association for Computational Linguistics, pagesTable 1. Comparison of the suggested ap- 423–430, 2003.proach with a simple pattern matcher [12] R. Krovetz and W. B. Croft. Lexical ambiguity and in- formation retrieval. ACM TRANSACTIONS ON INFOR- MATION SYSTEMS, 10:115–141, 2000. [13] J. Lafferty. Conditional random fields: Probabilis-the taggings used to generate the goal structures for the tic models for segmenting and labeling sequence data.approach without the dictionary are often faulty. pages 282–289. Morgan Kaufmann, 2001. [14] M. P. Marcus, B. Santorini, and M. A. Marcinkiewicz. Building a large annotated corpus of english: The penn4. CONCLUSION treebank. Computational Linguistics, 19(2):313–330, 1993. From the experiments we can conclude that the [15] A. maria Giuglea and R. Moschitti. Semantic role label-suggested approach is successful for finding correct ing via framenet, verbnet and propbank. In In Proceed-goal structures for instructions. When comparing a clas- ings of COLING-ACL, 2006.sic approach (accuracy of about 38%) with the sug- [16] S. Petrov, L. Barrett, R. Thibaux, and D. Klein. Learninggested approach without dictionary, we already see a accurate, compact, and interpretable tree annotation. Inbig relative improvement (about 47%). The dictionary In ACL 06, pages 433–440, 2006. [17] R. Wallace. The elements of aiml style. Alice AI Foun-approach obliviates these results with a stunning 85% dation, 2003.accuracy. The suggested approach is able to more easilyhandle complex instructions, especially when the dic-tionary is used to detect faulty taggings. This suggests
  • Bijlage JPoster 117
  • Bibliografie[1] Alice aiml. URL: https://code.google.com/p/ aiml-en-us-foundation-alice/.[2] Framenet. URL: http://framenet.icsi.berkeley.edu/.[3] Marioai. URL: http://www.marioai.org/.[4] Program d. URL: http://aitools.org/Main_Page.[5] Super mario bros walkthroughs. URL: http://www.gamefaqs.com/nes/ 525243-super-mario-bros/faqs.[6] Swi-prolog. URL: http://www.swi-prolog.org/.[7] Verbnet. URL: http://verbs.colorado.edu/~mpalmer/projects/verbnet. html.[8] Wordnet. URL: http://wordnet.princeton.edu/.[9] B. Akan, B. Curuklu, G. Spampinato, and L. Asplund. Object selection using a spatial language for flexible assembly. In Emerging Technologies & Factory Automation, 2009. ETFA 2009. IEEE Conference on, pages 1–6. IEEE, 2009.[10] G. Bugmann. Challenges in verbal instruction of domestic robots. Proc. of 1st Intl. Ws. on Adv. in Service Rob.(ASERŠ03), pages 112–116, 2003.[11] M. P. C. B. M. E. J. R. C. Johnson, C. Fillmore and E. Wood. Framenet: Theory and practice. Technical report, 2003.[12] M. catherine De Marneffe, B. Maccartney, and C. D. Manning. Generating typed dependency parses from phrase structure parses. In In LREC 2006, 2006.[13] D. Cer, M. catherine De Marneffe, D. Jurafsky, and C. D. Manning. Parsing to stanford dependencies: Trade-offs between speed and accuracy. In In LREC 2010, 2010.[14] P. Clark, P. Harrison, T. Jenkins, J. Thompson, and R. Wojcik. Acquiring and using world knowledge using a restricted subset of english. In In FLAIRS 2005, pages 506–511, 2005. 119
  • Bibliografie[15] K. M. Colby, R. C. Parkison, and W. S. Faught. Pattern-matching rules for the recognition of natural language dialogue expressions. Technical report, Stanford, CA, USA, 1974.[16] M.-C. de Marneffe and C. D. Manning. Stanford dependencies manual, 2008.[17] F. A. For, M. E. Califf, and R. J. Mooney. Relational learning of pattern-match rules for information extraction. pages 328–334, 1999.[18] N. E. Fuchs, K. Kaljurand, and T. Kuhn. Attempto Controlled English for Knowledge Representation. In C. Baroglio, P. A. Bonatti, J. Małuszyński, M. Marchiori, A. Polleres, and S. Schaffert, editors, Reasoning Web, Fourth International Summer School 2008, number 5224 in Lecture Notes in Computer Science, pages 104–124. Springer, 2008.[19] K. Fundel, R. Küffner, R. Zimmer, and S. Miyano. RelexŰrelation extraction using dependency parse trees. Bioinformatics, 23, 2007.[20] P. Gorniak and D. Roy. Speaking with your sidekick: Understanding situated speech in computer role playing games. In Proceedings of Artificial Intelligence and Digital Entertainment, 2005.[21] D. Hindle and M. Rooth. Structural ambiguity and lexical relations, 1993.[22] M. Johnson. Pcfg models of linguistic tree representations. Computational Linguistics, 24:613–632, 1998.[23] K. Kipper, H. T. Dang, and M. Palmer. Class-based construction of a verb lexicon. 2000.[24] D. Klein and C. D. Manning. Accurate unlexicalized parsing. In In proceedings of the 41st annual meeting of the Association for Computational Linguistics, pages 423–430, 2003.[25] R. Kohavi. A study of cross-validation and bootstrap for accuracy estimation and model selection. In International joint Conference on artificial intelligence, volume 14, pages 1137–1145. Citeseer, 1995.[26] T. Kollar, S. Tellex, D. Roy, and N. Roy. Toward understanding natural language directions.[27] R. Krovetz and W. B. Croft. Lexical ambiguity and information retrieval. ACM TRANSACTIONS ON INFORMATION SYSTEMS, 10:115–141, 2000.[28] J. Kupiec. Robust part-of-speech tagging using a hidden markov model* 1. Computer Speech & Language, 6(3):225–242, 1992.[29] J. Lafferty. Conditional random fields: Probabilistic models for segmenting and labeling sequence data. pages 282–289. Morgan Kaufmann, 2001.120
  • Bibliografie[30] S. Lauria, G. Bugmann, T. Kyriacou, and E. Klein. Mobile robot programming using natural language. Robotics and Autonomous Systems, 38(3-4):171–181, 2002.[31] P. Lebling, M. Blank, and T. Anderson. Zork: A computerized fantasy simulation game. IEEE Computer, 12(4):51–59, 1979.[32] M. Levit and D. Roy. Interpretation of spatial language in a map navigation task. Systems, Man, and Cybernetics, Part B: Cybernetics, IEEE Transactions on, 37(3):667–679, 2007.[33] M. P. Marcus, B. Santorini, and M. A. Marcinkiewicz. Building a large annotated corpus of english: The penn treebank. Computational Linguistics, 19(2):313–330, 1993.[34] A. maria Giuglea and R. Moschitti. Semantic role labeling via framenet, verbnet and propbank. In In Proceedings of COLING-ACL, 2006.[35] A. K. McCallum. Mallet: A machine learning for language toolkit. http://mallet.cs.umass.edu, 2002.[36] G. A. Miller. Wordnet: A lexical database for english. Communications of the ACM, 38:39–41, 1995.[37] S. Petrov, L. Barrett, R. Thibaux, and D. Klein. Learning accurate, compact, and interpretable tree annotation. In In ACL Š06, pages 433–440, 2006.[38] L. R. Rabiner and B. H. Juang. An introduction to hidden Markov models. IEEE ASSP Magazine, pages 4–15, January 1986.[39] Óscar Ferrández, M. Ellsworth, R. Muñoz, and C. F. Baker. Aligning framenet and wordnet based on semantic neighborhoods. In N. C. C. Chair), K. Choukri, B. Maegaard, J. Mariani, J. Odijk, S. Piperidis, M. Rosner, and D. Tapias, edi- tors, Proceedings of the Seventh conference on International Language Resources and Evaluation (LREC’10), Valletta, Malta, may 2010. European Language Resources Association (ELRA).[40] L. Shi and R. Mihalcea. Putting pieces together: Combining framenet, verbnet and wordnet for robust semantic parsing. In CICLing, pages 100–111, 2005.[41] D. D. K. Sleator and D. Temperley. Parsing english with a link grammar. In In Third International Workshop on Parsing Technologies, 1991.[42] R. Sutton, A. Barto, and R. Williams. Reinforcement learning is direct adaptive optimal control. Control Systems Magazine, IEEE, 12(2):19–22, 1992.[43] R. Wallace. The elements of aiml style. Alice AI Foundation, 2003.[44] J. Weizenbaum. ElizaŮa computer program for the study of natural language communication between man and machine. Commun. ACM, 9:36–45, January 1966. 121
  • K.U.Leuven Faculteit Ingenieurswetenschappen 2010 – 2011 Fiche masterproefStudenten: Maarten Tielemans Pieter-Jan SpeelmansTitel: Een probabilistische aanpak voor het aansturen van Mario met natuurlijke taalEngelse titel: Instructing Mario with natural language by using a probabilistic ap- proachUDC : 621.3Korte inhoud:Deze thesis beschrijft een aanpak voor het behandelen van instructies in natuurlijketaal gebruikt om een robot aan te sturen in een ruimte. De aanpak lost de voornaamsteproblemen bij de analyse van natuurlijke taal op door gebruik te maken van degrammaticale structuur van de instructie en semantische informatie verkregen uit declassificatie van woorden in de instructie. Verder wordt ook de informatie over deomgeving van de robot en de beschikbare domeinkennis gebruikt om te controlerenof de doelen verkregen uit de instructie al dan niet mogelijk zijn.Thesis voorgedragen tot het behalen van de graad van Master in deingenieurswetenschappen: computerwetenschappenPromotoren: Sien Moens Luc De Raedt Martijn Van OtterloAssessoren: Martijn Van Otterlo Siegfried NijssenBegeleiders: Parisa Kordjamshidi Koen Deschacht Martijn Van Otterlo