Victor Sjölin, [email protected]...

LINKÖPINGS UNIVERSITET

Artificiell intelligens i en virtuell värld Ett fördjupningsarbete om artificiell intelligens inom spelbranschen

Victor Sjölin, [email protected]

2011-09-18

mailto:[email protected]

729G11 Fördjupningsarbete Victor Sjölin Artificiell Intelligens 2 AI inom spelbranschen vicsj486

Table of Contents

1. Förord...................................................................................................................................... 2

2. Beteende ................................................................................................................................. 3

2.1 Finite-State Machine .............................................................................................................. 4

2.2 Genetiska algoritmer ........................................................................................................ 6

2.3 Artificiella neruala nätverk ...................................................................................................... 11

3. Diskussion ................................................................................................................................. 15

4. Referenser ............................................................................................................................. 16

Böcker: ...................................................................................................................................... 16

Internetartiklar: ......................................................................................................................... 16

Spelreferenser: .......................................................................................................................... 16


1. Förord

Oavsett vad du sysslar med i dagens moderna samhälle så har du med största sannolikhet någon gång kommit i kontakt med artificiell intelligens, kanske utan att ens vara medveten om det. AI (som artificiell intelligens förkortas) får en allt större roll i vårt dagliga liv, och oavsett om du shoppar på nätet, beställer tågbiljetter via telefon eller använder en GPS så kommer du att stöta på det i någon form . En industri som blir mer och mer beroende av framstegen inom AI-fältet är spelindustrin. Oavsett om vi talar om relativt enkla spel som luffarschack, där datorn hela tiden har full koll på vad som händer på spelplanen, eller betydligt mer avancerade moderna spel där datorn styr flera olika agenter som simulerar mänskligt beteende och är helt oberoende av varandra så spelar AI en oerhört stor roll.

Det är viktigt att klargöra att många saker som kallas för AI inom spelvärlden inte alls skulle kallas för AI inom den akademiska världen. Inom spelvärlden är målet att underhålla, och hur man uppnår detta mål är inte alltid av största intresse. En oinsatt spelare är ofta precis lika glad om en agent i spelet följer ett antal ”förscriptade” händelser (det vill säga ett strikt manus som talar om för agenten exakt vad den ska göra vid en viss tidpunkt), som om den faktiskt besitter någon form av riktigt AI och istället agerar på egen hand utifrån vad den utsätts för och/eller de förutsättningar den har för tillfället. Dessa strikt scriptade spel och deras metoder är dock inte av lika stort intresse när man studerar artificiell intelligens i ordet rätta bemärkelse, och artikeln kommer därför inte lägga någon större vikt vid dessa.

Målet med AI i spel är att skapa en värld som känns levande, med invånare som uppträder intelligent på ett trovärdigt sätt. Det finns vanligtvis tre kategorier som världens invånare faller inom; allierade, neutrala eller fientliga. Agenter som tillhör någon av de två förstnämnda kategorierna benämns vanligtvis som NPC’s, vilket betyder Non-Playable Characters. Även om AI inte per definition måste vara i from av en människo/djurliknande-varelse så är det väldigt ofta just om dessa NPC’s intelligens man talar om när man diskuterar AI inom spel, och det är främst dessa som kommer att diskuteras i artikeln.


2. Beteende

En stor del av utmaningen med att skapa artificiell intelligens i ett spel är att få agenterna att göra intelligenta val. En utvecklare skulle teoretiskt sett kunna definera en samling handlingar som en viss agent kan utföra och sedan låta den slumpa fram en handling och hoppas att det blir rätt, men det skulle med allra största sannolikhet leda till att agenten gör ”dåliga” val och därmed bryter spelarens illusion av att agenterna faktiskt är tänkande individer. Istället strävar utvecklarna efter att programmera agenten på ett sådant sätt att den gör rationella val givet situationen den befinner sig i. För att uppnå detta finns det två huvudsakliga sätt att programmera agenternas beteende på som man använder sig av, fördefinerat-beteende och målorienterat-beteende (Funge, 2010).

Om en agents beteende anses vara fördefinerat eller målorienterat avgörs av om agenten är deterministisk i sitt val av handlingar. Att en agent är deterministisk i sina val av handlingar innebär att den inte minns vilka andra alternativ den hade att välja på. En icke-deterministisk agent, däremot, minns vilka alternativ som fanns och vilket av dem den valde, och kan därför välja att gå tillbaka ett steg i sitt beslutsfattande och överväga de andra alternaven för att se om något av dem hade tagit den närmare målet. Båda metoderna har sina fördelar och sina nackdelar, och en utvecklare måste därför se till att välja den metod som bäst passar det syfte agenten är tänkt att fylla. (Funge, 2010)

Agenter som gör deterministiska val är strikt regelbundna och utför handlingar baserat på den input-data deras sensoriska system fångar upp. Detta gör att de är väldigt förutsägbara och därmed lätta att implementera och felsöka. Då de enbart agerar utifrån den samling regler de har tillgängliga så har de även väldigt kort responstid, vilket i många fall är väldigt viktigt och därmed en stor fördel. Det faktum att de är så regelstyrda gör dock att de agenter som följer denna princip lätt blir förutsägbara, de har ofta bara en respons till en viss händelse, oavsett andra omständigheter, vilket gör att utvecklare måste göra en avvägning när de bestämmer sig för på vilket sätt de ska koda en viss agent.

Ett klassiskt exempel på hur deterministiska agenter funerar är Namco’s Pac Man. Spelet går ut på att man som spelare åker runt i en labyrint-liknande bana och äter piller för att plocka poäng. På banan finns det spöken som planlöst åker runt, men som fort de får syn på spelaren inleder en jakt för att äta upp honom. Utplacerat på banan finns dock några få blå piller, så kallade power pills, som ger spelaren möjligheten att själv äta spöken om man får tag i dem. Så fort spelaren lyckas äta upp en av dessa piller så skiftar spökenas prioritet, från att aktivt jaga spelaren när den är inom synhåll till att helt plötsligt fly för att undvika att bli uppätna. När det blå pillrets effekt efter några sekunder har avtagit återgår spökena till att jaga spelaren, som inte längre är ett hot mot dem.

Som tur är så finns det då icke-deterministiska agenter som har andra egenskaper än de deterministiska. En icke-deterministisk agent har förmågan att lära sig av erfarenhet vilket gör att den blir mycket mer dynamisk än sin deterministiska motsvarighet. Detta leder även till att de har en viss grad av osäkerhet, en utvecklare kan aldrig veta säkert vad agenten kommer att lära sig och hur det kommer att påverka spelupplevelsen. Det gör även att det blir mycket svårare att felsöka i en sådan agent, eftersom den kan teoretiskt sett kan uppföra sig helt annorlunda varje genomspelning. Den här sortens AI är både betydligt mer avancerad och resurskrävande än den deterministiska vilket gör att många utvecklare väljer att använda sig av enklare metoder, men de som verkligen har lagt ner tid på att implementera den här sorts AI har visat mycket imponerande resultat, till exempel Lionhead Studios’ Black & White.


2.1 Finite-State Machine

Finite State-Machine (FSM) är ett väldigt vanligt och effektivt deterministiskt sätt att programmera enklare agenter. En FSM är uppbygd av ett antal states, en uppsättning inputs och en uppsättning outputs (Funge, 2010). Metoden bygger på att agenten har flera olika states som den kan befinna sig i. Metoden är sekventiell, vilket innebär att agenten bara kan befinna sig i ett state i taget, och FSMen definerar under vilka omständigheter (det vill säga input från omvärlden) agenten ska byta state (Champandard, AIGameDev). Bild 1 nedan är ett exempel på hur en fientlig agents FSM skulle kunna se ut. De vita rutorna representerar här möjliga states som innehåller olika handlingar. De vita pilarna representerar de input-villkor som tvingar agenten att byta state när de uppfylls.

Bild 1.

Som framgår av bilden så startar den här agenten med ”search for player” som state. Den har sedan två möjliga villkor som kan få den att ändra state, antingen om den ser spelaren eller på något sätt får information om var spelaren befinner sig. Om något av dessa villkor uppfylls så kommer agenten att övergå till det state som pilen som representerar villkoret pekar på. På så sätt fortsätter agenten att ändra states och handlingar beroende på den input den får, vilket gör att den känns mycket mer levande än agenter baserade på scripts, vilket är en mer primitiv metod för att definera en agents beteende, vilket också gör att den inte är särskilt intressant ur ett AI-perspektiv och kommer därför inte att läggas någon större vikt vid i den här uppsatsen.


Metoden har både för och nackdelar. Till fördelarna hör att agenter som använder sig av FSMs är mycket lätta att implementera och felsöka i (Seamann och Bourg, 2004). Den kräver även väldigt lite prestanda då den är uppbyggd på ”if then”-premisser, vilket även innebär att den har mycket kort responstid, något som är väldigt viktigt inom spelvärlden för att allt ska flyta på utan att illusionen av intelligens bryts. Förutsatt att de regler som FSMen är uppbyggd av är väl genomtänkta så framstår ofta agenten beteende som naturligt. Det faktum att en FSM så enkelt kan målas ut som i Bild 1 gör också att det är mycket enkelt att få en överblick på hur dess regler se ut och man kan på så sätt enkelt undvika logiska snedsteg.

Metoden har dock som sagt sina nackdelar. Ett exempel på detta är att en agent som använder sig av FSMs kan göra stundtals korkade val. Om vi till exempel har en agent som börjar i ett passivt state, vars reaktion på att den blir attackerad är att själv attackera. Detta är i många fall en rimlig reaktion, men säg att vår agent föreställer en höna, och agenten/spelaren som attackerar den är en räv. Helt plötsligt känns det inte som att en motattack vore den mest logiska reaktionen längre, här skulle det kännas betydligt mer realistiskt om hönan istället försökte fly. Den här sortens situationer kan inte FSMs hantera, förutsatt att det inte finns en specifik regel som säger att om en den som attackerar är en räv så bör hönan fly. Den har även en tendens att lätt bli förutsägbar, då den endast har en reaktion på en viss sorts input, vilket gör att det till slut blir väldigt lätt att förutspå hur den kommer reagera på en viss handling, till skillnad från en människa i riktiga världen där en mängd andra förutsättningar spelar in och har en avgörande roll. En annan nackdel är att det är väldigt svårt att ge agenten någon sorts känsla av individualism då alla states ligger på samma nivå (Eventhelix, Hierarchal State Machine Design Pattern) , det finns ingen högre state som ligger över de andra som kan fungera som en personlighet.

Som tur är finns det dock vad man skulle kunna kalla en uppgradering av FSM, nämligen HFSM. HFSM står i det här fallet för Hierarchical Finite-state Machines. Detta innebär att en HFSM består av

flera olika hierarkiskt ordnade FSMs, det vill säga, varje nod i en HFSM kan i sig själv vara en HFSM. Att HFSMs states är hierarkiskt ordnade och tillåter oss att ge agenterna en ”internal state” (Funge, 2010, Reactive Behavious Rules) möjliggjör skapandet av mycket mer avancerade och sofistikerade beteendemönster hos en agent vilket har bidragit till att den har blivit en av de överlägset mest poplära metoderna för att programmera beteende i dagens läge.


2.2 Genetiska algoritmer

I naturen utvecklas arter, om än väldigt sakta, ständigt för att bättre anpassa sig efter den omgivning de lever i. Detta sker genom naturligt urval, eller ”survival of the fittest” (Darwin, 1859), vilket helt enkelt går ut på att de exemplar av en art som är bäst anpassad för miljön överlever och får föra sina gener vidare, medan de sämre anpassade dör ut. På så sätt så främjas de egenskaper hos djuren som de har nytta av, medan de som de inte behöver dör ut, och på så sätt ökar chansen för artens överlevnad. Principen illustreras i Bild 2 nedan, där kromosomerna hos föräldrarna (här i form av blommor) representeras av slumpmässiga bokstäver

Bild 2.

Genetiska algoritmer bygger på just den här principen, där målet alltid är att producera avkomma som är bättre anpassade än sina föräldrar. Processen för att hitta nya bättre lösningar delas ofta upp i fyra steg.

Den första, kallad 2.2.1 First Generation, går helt enkelt ut på att man skapar en population fylld av ”individuals” (Russel and Norvig, 2010), eller individer, som alla har olika egenskaper. Dessa individer representerar de olika lösningar som finns till det problem som vi försöker lösa. I många fall inom AI så är dessa individers egenskaper helt slumpmässiga, men eftersom en spelutvecklare ofta har en relativt god uppfattning om vilka egenskaper som kommer att producera en lämplig individ så kan de ibland ha ett finger med i spelet, utan att för den sortens skull helt skräddarsy dem då det skulle göra utgallringsprocessen vi vill ska ta plats mindre effektiv. Därefter måste man göra något som kallas för ”encoding” ( Seamann och Bourg, 2004, 424), vilket innebär att man sparar kromosomerna som varje individ bär på på ett sätt så att datorn kan arbeta med dem, vilket vanligtvis innebär strängar, listor eller träd.


Bild 3.

Eftersom alla individers egenskaper kommer att vara olika väl anpassade för problemet som vi vill lösa måste vi skapa någon sorts system tillåter oss att gradera individerna och deras egenskaper. Det är det andra steget och kallas här för 2.2.2 Evaluating Fitness (Hsiung and Matthews, 2000). Varje individ tilldelas här ett värde vars storlek avgörs av hur lämpad individen är för att agera i världen den befinner sig i och om de har de egenskaper som vi vill föra vidare till nästa generation.

Bild 4.

Därefter kommer vi till 2.2.3 Selection där de individer som fick högst värde i Evaluating Fitness-fasen väljs ut för att senare få föröka sig. Värt att nämna är att trots att genetiska algoritmer har väldigt mycket gemensamt med naturlig evolution så är de inte bundna till samma begränsningar, vilket innebär att vi kan kombinera kromosomer från fler än två individer, om vi skulle känna att det gynnade ändamålet (Seamann och Bourg, 2004).


Bild 5.

Till sist har vi nått själva evolutionen, 2.2.4 Evolution, där skapandet av nya individer sker. I det här steget tar vi de individer som bedömts lämpliga i Selection-steget och utför på dem en crossover. En crossover innebär att vi tar kromosomerna från de individer som valts ut i 2.2.3 och slår ihop dem för att skapa en ny individ, något som illustreras i ”Bild 2”. Här introducerar vi även slumpmässiga mutationer, något som är en mycket viktig del inom evolutionen. Mutationer innebär att i varje ny individ införs, förutom de från föräldrarna nedärvda kromosomerna, ett fåtal nya kromosomer. Detta görs för att evolutionen inte ska stanna upp utan fortsätta att utveckla nya förmågor som kommer att nedärvas till framtida generationer om de skulle visa sig vara användbara, och i annat fall dö ut. När allt detta sedan skett så skickas den nya individen iväg till Evaluating Fitness-steget för att tillsammans med andra nya individer utvärderas för att se om de har de egenskaper som krävs för att föröka sig, och på så sätt börjar hela processen om tills en lösning har nåtts. Det kretsloppet som uppstår illstrureras i Bild 6 nedan och avslutar de fyra steg som beskrivits.

Bild 6.


Genetiska algoritmer är icke-deterministiska och klarar därför av en hel del saker som deterministiska metoder såsom FSM inte klarar av, till exempel när ett problems struktur är mer eller mindre oförutsägbar, men lider även av andra brister. Eftersom agenter som använder sig av genetiska algortimer inte är förkodade, det vill säga har en förbestämd respons på en viss input, på samma sätt som deterministiska agenter så har de möjligheten att göra val som är bättre anpassade efter förutsättningarna. En stor del av de problem spelutvecklare har är att det är svårt att förutse hur en spelare kommer att agera i ett visst läge, vilket kan vara väldigt problematiskt för en deterministisk agent, något som genetiska algoritmer är väldigt bra på att hantera, då de anpassar sig efter spelaren. Om vi återvänder till exemplet med hönan och räven så hade en höna vars beteende bestäms av genetiska algoritmer mest troligt valt att fly fältet om den skulle bli attackerad av en räv men attackera om den anfölls av en daggmask, till skillnad från en höna var beteende bestäms av skript som skulle kunna gå till motattack oavsett vem som attackerade, om det var dess respons på en attack. På så sätt är en agent som använder sig av genetiska algoritmer bättre anpassad till sin omgivning, vilket enligt författaren bidrar något enormt till inlevelsen för spelaren.

Avancerade strategispel, till exempel, kan dra stor nytta av genetiska algoritmer. De kan i många fall spara information från tidigare spelomgångar och lära sig spelarens strategier. Säg, till exempel, att en spelare alltid attackerar datorns bas med hjälp av pilbågsskyttar, som den sedan låter skjuta på basen tills datorn skickar ut en motattack, för att sedan snabbt backa tillbaka utom räckhåll för datorns enheter. En genetisk algoritm skulle till slut kunna lära sig att motarbeta den här sortens taktiker genom att, till exempel, träna ryttare, som rör sig snabbare än spelarens bågskyttar, och på så sätt kunna rida ikapp dem innan de hann retirera. Detta bidrar till ett mycket mer intelligent beteende från datorns sida, jämfört med om den gång på gång försökt skicka ut långsamma fotsoldater som aldrig hinner ikapp.

Även genetiska algoritmer har dock sina nackdelar, oavsett hur överlägsna de kan verka enklare deterministiska metoder vid en första blick. Eftersom en utvecklare aldrig i förväg kan veta hur en agent kommer att ”utvecklas” för varje enskild spelare finns det en stor risk att komplikationer kommer att uppstå. Bland dessa finns risken för så kallade ”buggar”, oförutsedda felaktigheter i agenternas beteende som kan få dem att uppträda på ett oönskat sätt, vilka är svåra att testa och motverka då agenten som sagt kan bete sig helt olika till för varje speltillfälle. En annan faktor som försvårar deras användande är även en av deras största styrkor; nämligen de slumpmässiga mutationerna. Utan dessa hade metoden varit mycket mindre effektiv, men det faktum att slumpmässiga element införs gång på gång gör att slutresultatet av algoritmen kan bli något helt annat än det man eftersträvat. Lägg därtill att de är väldigt tids och-prestandakrävande, vilket kan vara ett stort problem då de datorer spelen är tänka att köras på ofta har väldigt begränsad prestanda, olikt de genetiska algoritmer som utförs i rent forskningssyfte inom den akademiska världen. Detta innebär att spelen kan bli sega och agenterna kan framstå som långsamma, vilket är något man som spelutvecklare vill undvika till varje pris.


Med dessa nackdelar i åtanke är det förståeligt att många utvecklare ännu drar sig för att använda genetiska algoritmer och iställer väljer att fokusera på enklare metoder som FSMs och scripts.En utvecklares mål är trots allt att sälja så många exemplar som möjligt, och om de kan få ett mer stabilt resultat genom att använda enklare metoder väljer många att göra det, hellre än att gräva ner sig i de mer instabila algoritmerna. Detta är dock mycket tråkigt enligt författaren, då de utvecklare som väljer att faktiskt lägga ner mycket tid och energi på att få en bra fungerande AI har visar upp mycket imponerande resultat, till exempel det tidigare nämnda Black & White och Black & White 2, som använde sig av genetiska algoritmer. Ett mer flitigt användande av metoden skulle även troligtvis leda till att utvecklare fick bättre förståelse för hur de bör implementeras och hur fel kan förebyggas, vilket skulle kunna leda till att de blev allt mer vanligt förekommande, vilket inte bara skulle vara roligt för oss som är intresserade utav AI utan i längden göra upplevelsen roligare för samtliga spelare.


2.3 Artificiella neruala nätverk

Artificiella neural nätverk är även den en metod som har naturen som förebild, men den här gången är det inte naturlig evolution utan den mänskliga hjärnan som får stå modell.

Vår modell, hjärnan, är uppbyggd av cirka 10^11 neuroner, där varje enskild neuron är kopplad till tusentals andra, som i sin tur är kopplade till tusentals andra, som bildar ett enormt nätverk. Neuronerna använder detta nätverk för att skicka information, i form av elektricitet, mellan sig med hjälp av så kallade axoner och dendriter, som är de kopplingar som leder från en neuron till en annan. Var och en av dessa dendriter har en ”voltage potential” (Seamann och Bourg, 2004, 356) som går från en aktiverad neuron till de anslutna neuronerna. Varje neuron får via dessa input från cirka 10^4 andra neuroner, och det är när den samlade effekten från dessa neuroner blir tillräckligt stark som neuronen avfyrar och skickar vidare sin voltage potential till de andra och på så sätt sprids information.

Artificiella neurala nätverk är en icke-deterministisk metod som fungerar på ungefär samma sätt, men som tur är så behöver våra de inte innehålla tillnärmelsevis lika många neuroner, på sin topp handlar det om cirka tusen neuroner, men oftast stannar siffran betydligt närmare tiotalet. Neurala nätverk har väldigt många användningsområden inom spelutveckling, beroende på vilken typ av nätverk man använder, och kan användas till att från att understödja komplexa state machines, då genom att låta specialtränade neurala nätverk sköta vissa specifika beslut, vilket ger dem en relativt liten roll, till att styra i princip allt i hela spelvärlden. Kort sagt, neurala nätverk kan, i rätt händer, programmeras att sköta i princip allt vi vill ska hända i spelvärlden, men att gå igenom alla användningsområden här skulle ta alldeles för lång tid, och den här artikeln kommer därför fokusera på den sorts nätverk som är mest användbar för det relevanta ämnet; nämligen multilayer, feed-forward network(Seamann och Bourg, 2004, 357). Dessa nätverk är mycket mångsidiga och kan därför hantera en mängd olika problem utan att för den sakens skull vara så komplicerade att de är omöjliga att implementera.

Som exempel tar vi ett neuralt feed-forward nätverk med tre lager. Det är uppbyggt på så sätt att vi har tre lager av neuroner, ett för input, ett dolt och ett för output, där det kan finnas ett obegränsat antal neuroner i varje lager. Varje enskild neuron i input-lagret är kopplat till samtliga av neuronerna i det dolda lagret, och samma sak gäller för neuronerna i det dolda lagret när de leder till output-lagret. Den aktivitet som sker i input-lagret representerar som en följd av detta den data som matas in i nätverket, medan aktiviteten i det dolda-lagret avgörs av aktiviteten i inputen och vikterna som finns i kopplingarna mellan dem, och output-lagrets uppförande kommer sedan att bero på aktiviteten i det dolda-lagret och vikten på de kopplingar som går från det till output-lagret. Bild 7 på nästa sida illustrerar hur det skulle kunna se ut.


Bild 7.

Det finns en hel del saker som måste tas i beaktning när man skapar ett neuralt nätverk i ett spel. Det första är hur man ska hantera inputen, vilket givetvis är väldigt viktigt då ett nätverk som inte får någon input inte kommer att ha någon information att arbeta med. Vilken input nätverket får är ofta väldigt beroende av vad det är vi vill upnå. Vi kan föreställa oss att vi har en båt vars rörelser styrs av ett neuralt nätverk. Båten är på väg att lägga till vid en hamn, och då finns det givetvis en hel del parametrar att ta i beaktning, till exempel båtens fart, dess massa och planetens dragningskraft. Om vi vill att dessa ska vara vår input så skulle vi kunna ge dem varsin neutron i nätverket, men då vi som sagt vill hålla nära antalet neutron så mycket som möjligt kan vi istället välja att lägga båtens massa och multiplicera den med båtens fart som tar gravitationen i beaktning, och lägga allt detta i en enda neuron. På så sätt har vi skapat ett mycket mer kompakt nätverk, och även om det givetvis finns andra parametrar som måste tas i beaktning och som behöver en egen neutron så kan vi på det här sättet minska antalet neuroner drastiskt (O’Reilly, 2004).

Oavsett vad det är vi tar som 2.3.1 input, vilket kan vara allt från en agents ålder till dess hårfärg så måste den här informationen representeras i siffror, då är det som nätverken kommer att arbeta med. Medan det inte kommer att ha något problem med att arbeta med en siffra som reprsenterar en ålder så kan det vara svårare för den att arbeta med en hårfärg, vilket gör att vi bör skapa en fördefinerad vector, till exempel {0, 1, 0, 0, 0, 0, 0}, där ettans placering i listan indikerar att agenten har svart hår, och en annan placering hade indikerat en annan färg.

En annan viktig del av ett neuralt nätverk är de 2.3.2 vikter som finns i kopplingarna mellan neuronerna, det är nämligen vikterna som avgör hur ett nätverk kommer att bete sig. De har förmågan att reducera eller förstärka styrkan hos en inkommande input, vilket kan göra en väldigt stor skillnad i resten av nätverket. Vikterna mellan input-lagret och det dolda lagret avgör när de dolda neuronerna kommer att vara aktiva, och bestämmer på så sätt vad de kommer att representera. Ofta talar man om att ett neutralt nätverk måste ”tränas” för att kunna utföra de uppgifter vi vill att den ska utföra, och det är under denna träning som vikterna justeras för att passa ändamålet. För varje neuron som har en koppling till en annan så finns det alltså en vikt som avgör vad som släpps igenom, och den input som når en neuron från en annan är då summan av vikten på den input den får från varje neuron multiplicerat med input-värdet plus en så kallad ”bias”, vilket är ytterligare en sorts vikt som varje koppling har, men som inte kommer att beskrivas i någon större


detalj här, vi nöjer oss med att säga att den kan skifta mellan 1 och -1, och justeras på samma sätt som resten av vikterna.

Vi har även ett 2.3.3 dolt lager, som behandlar informationen som kommer från input-lagret. Som tidigare nämnt så kopplas varje enskild neuron i input-lagret till samtliga neuroner i det dolda lagret, och varje neuron i det dolda lagret är kopplad till samtliga neuroner i output-lagret. Detta lager är absolut nödvändigt för att ge nätverket möjligheten att bearbeta information från inputen. Som regel gäller att ju fler neuroner vi har i det här lagret desto mer information kan nätverket behandla, och desto mindre ”brus” i datan behöver vi ta hänsyn till. Fler neuroner innebär dock att datorn kräver mer processorkraft, något man försöker hålla till ett minimum, så därför är målet alltid att ha tillräckligt många neuroner, men inte fler än nödvändigt, och att hitta den här balansen kan kräva en del arbete. Det är värt att nämna att man kan använda sig av flera dolda lager om det tros gynna ens syfte, men då det vanligaste inom spelutveckling är att man har ett så är det det vi utgår från här.

Till sist återstår bara en viktig del av det neurala nätverket; nämligen 2.3.4 output. Precis som för inputen försöker vi här hålla antalet neuroner till ett minimum i syfte att hålla tränings och beräkningstiden så låg som möjligt. Det fungerar på så sätt att vi har ett antal neuroner som markerar de olika alternativ som nätverket kan ge, vilket så klart är väldigt beroende av vilket storts problem det är vi försöker lösa. Om vi föreställer oss att vi har ett nätverk med en output-neuron som opererar i ett rollspel vars jobb är att avgöra om spelarens yrke är snickare, utifrån att vi berättar om några av de färdigheter spelaren besitter. Låt säga att nätverket får reda på att spelaren är ohändig, har benskörhet och ogillar fysiskt arbete. I det fallet skulle antagligen nätverket göra bedömningen att spelaren inte är en snickare, och den ensamma output-neuronen skulle därför inte aktiveras. Om vi istället föreställer oss att nätverket får inputen att spelaren är duktig med händerna, stark och gärna arbetar utomhus så skulle neuronen antagligen aktiveras, och på så sätt markera att den gjort bedömningen att spelaren faktiskt är en snickare.

Det kan även hända att vi har en logistisk funktion som avgör när en output-neuron ska aktiveras. Nätverket kommer då att returnera en siffra mellan 1 och 0, där en siffra nära 1 skulle innbära att neuronen aktiveras, medan en siffra nära 0 innebär att den förblir inaktiv. I själva verket kommer siffrorna som returneras antagligen inte att vara så exakta, och vi måste därför sätta ett tröskelvärde som måste överstigas för att nätverket ska kunna avgöra om siffran är hög nog för att neuronen ska aktiveras. Ett annat möjligt scenario är att vi har flera alternativ som en input skulle kunna falla under, och då krävs det att vi har mer än en output-neuron. Om vi än en gång föreställer oss att nätverket operarar i ett rollspel, och dess uppgift är att avgöra vilken klass en fientlig agent utgör, där de tre alternativen är bågskytt, fotsoldat eller magiker så behöver var och en av dessa klasser en egen neuron. Här gäller att ett högt värde för en neuron implicerar att den bör aktiveras, medan ett lågt värde implicerar att den icke bör aktiveras. Nätverket kommer då att välja att aktivera den neuron med högst värde, och på så sätt göra bedömningen att den fientliga agenten tillhör den klassen och inte någon av de andra. Detta kallas ibland för ”winner take all-approach” (O’Reilly, 2004, 368).

Som förhoppningsvis framgått av texten ovan så har neurala nätverk flera olika användningsområden inom spel-AI. Ett av dem är när vi vill att nätverket ska kontrollera hur ett datorstyrt fordon rör sig i världen. Låt säga att det i det här fallet handlar om ett flygplan. Nätverket skulle då kunna ha tre neuroner i input-lagret, en som kontrollerar ifall det finns något ett hiner framför planet, och en för


varje sida. Outputen skulle bestå av två neuroner, en för vilket håll planet bör svänga åt för att väja. De möjliga outputsen skulle då bli att antingen så aktiveras den ena neuronen i output-lagret, vilket betyder att planet bör svänga åt höger, eller den andra, vilket betyder att planet bör svänga vänster. Det kan även hända att ingen av dem aktiveras, och då fortsätter planet att färdas rakt fram. En simpel illustration av hur nätverket skulle se ut återfinns nedan.

Bild 8.

Ett annat användningsområde där neurala nätverk kan göra mycket bra ifrån sig är om det används för att avgöra om en NPC bör attackera eller fly när den ställs inför en främmande agent. Nätverket tar fyra neuroner som input; antalet agenter i närheten som är allierade med den främmande agenten, den främmande agentens hotbild (hur stort hot utgör den mot agenten, detta kan mätas i hälsopoäng eller attackpoäng), avstånd till den främmande agenten samt om den för tillfället befinner sig i strid med en annan agent. Om den främmande agenten beräknas utgöra ett hot mot agenten med det neurala nätverket samt har flera allierade agenter med sig så kommer nätverket göra bedömningen att den bör retirera, och därför aktiveras vår neuron i outputen som representerar just det valet, istället för någon av de två andra neuronerna som representerar valen ”flock” (O’Reilly, 2004, 387), vilket i det här fallet innebär att ansluta sig till sina allierade för att söka skydd, och attack, som visas i bilden nedan.

Bild 9.

Källa för kapitlet är Seamann och Bourg (2004) om inte annat anges


3. Diskussion

Den här artikeln har till största del inriktat sig på hur spelutvecklare går till väga för att definera hur en intelligent agent ska uppföra sig i olika situationer och hur de bär sig åt för att komma fram till vilka val de bör göra givet situationen. Den har beskrivit tre popelära metoder för att göra detta: Finite State Machines (FSM), Genetiska Algoritmer och Neurala Nätverk. En av dessa är deterministisk, FSM, medan de två andra är icke-deterministiska. Det finns metoder som är både enklare och mer vanligt förekommande inom spel än de som diskuteras i den här artikeln, men författaren har valt att inrikta sig på dessa då de till skillnad från vissa andra är intressanta ur en synvinkel där vi ser till deras komplexitet och vad de kan åstadkomma rent teoretiskt, och inte bara till deras lättillgänglighet.

På grund av deras låga prestandrakrav och enkla implementation så har FSM och andra deterministiska metoder såsom Scripting blivit mycket populära inom branschen och är bland de absolut vanligaste metoderna. Icke-deterministiska metoder såsom genetiska algoritmer och neurala nätverk är inte fullt lika vanliga, men de spel som använder dem tenderar att gå i det främsta ledet när det gäller standarden på den artificiella intelligensen inom spelbranschen. Det är därför författarens åsikt att det är mycket tråkigt att så många spelstudios väljer att fokusera på primitiva men presterande metoder såsom scripting. Om fler utvecklare skulle ta sig an utmaningen att skapa riktigt avancerad AI med icke-deterministiska metoder, till exempel de som tagits upp i den här artikeln, så skulle användandet snabbt sprida sig vilket skulle leda till att allt fler utvecklare blev kunniga inom ämnet och på så sätt skulle det till slut vara i princip lika enkelt att implementera dessa metoder som de mer primitiva, men resultaten skulle vara otroligt mycket mer givande, både ur spelarens och ur de som är intresserade av artificiell intelligens perspektiv.

Författaren anser även att trots det faktum att AI inom spel ofta har begränsad prestanda att röra sig med och därför vanligtvis inte bidrar till utvecklingen av nya metoder för att skapa den sorts AI som det vanligtvis pratas om inom den akademiska världen så bidrar ändå industrin på ett positivt sätt till skolan om artificiell intelligens. Spelutvecklares vanligaste mål är att använda AI på ett sådant sätt att den ger ett intryck av intelligens, och behovet av detta är något som kommer bli allt vanligare i vår vardag, åtminstone om vi antar att världen kommer utvecklas på ett sätt som liknar det scenario som ofta målas upp i futuristiska böcker och filmer, där intelligenta robotar som uppför sig på ett mänskligt sätt och går att interagera med är en viktig del av ett fungerande samhälle.

Med detta i åtanke är det inte otroligt att de akademiska och de underhållnings-inriktade grenarna inom artificiell intelligens kan komma att växa allt närmare varandra i framtiden, speciellt med tanke på att hemdatorerna hela tiden blir allt mer kraftfulla i relation till så kallade ”superdatorer”, och kan därför köra allt mer avancerade program. För de har ju trots allt väldigt mycket att ge till varandra, den akademiska AIn med sin ständiga forskning och spel-AIn med sitt sina nya användsningsområden och stora strävan att göra dem mer lättillgängliga.


4. Referenser

Böcker: Bourg, David M. & Seeman, Glenn. (2004). “AI for Game Developers” O’Reilly

Internetartiklar: Funge, John. (2010). “AI for Games and Animation: A Cognitive Modeling Approach”: http://www.gamasutra.com/view/feature/3405/ai_for_games_and_animation_a_.php?print=1

Nareyek, Alexander. (2004). ”AI in Computer Games”: http://dl.acm.org/citation.cfm?id=971593&bnc=1

Champandard, A.J. (2007). ” On Finite State Machines and Reusability”: http://aigamedev.com/open/articles/fsm-reusable/ EventHelix. Hierarchal State Machine Design Pattern: http://www.eventhelix.com/realtimemantra/hierarchicalstatemachine.htm

Hsiung, Sam och Matthews, James. (2000). ” An Introduction to Genetic Algorithms”: http://www.generation5.org/content/2000/ga.asp

Spelreferenser: Pac-Man (1980), Namco

Black & White (2001), Lionhead Studios

Black & White 2 (2004), Lionhead Studios

Victor Sjölin, [email protected]...

Documents

Transcript of Victor Sjölin, [email protected]...