D EEP L EARNING I S TARCRAFT 2
– A UTOENCODERS FÖR ATT FÖRBÄTTRA
E ND - TO -E ND LEARNING
VT 2018:KSAI04 Examensarbete Systemarkitekturutbildningen
Victor Frick Kristoffer Mattsson
I
Systemarkitekturutbildningen är en kandidatutbildning med fokus på programutveckling. Utbildningen ger studenterna god bredd inom traditionell program- och systemutveckling, samt en spets mot modern utveckling för webben, mobila enheter och spel. Systemarkitekten blir en tekniskt skicklig och mycket bred programutvecklare. Typiska roller är därför programmerare och lösningsarkitekt. Styrkan hos utbildningen är främst bredden på de mjukvaruprojekt den färdige studenten är förberedd för. Efter examen skall systemarkitekter fungera dels som självständiga programutvecklare och dels som medarbetare i en större utvecklingsgrupp, vilket innebär förtrogenhet med olika arbetssätt inom programutveckling.
I utbildningen läggs stor vikt vid användning av de senaste teknikerna, miljöerna, verktygen och metoderna.
Tillsammans med ovanstående teoretiska grund innebär detta att systemarkitekter skall vara anställningsbara som programutvecklare direkt efter examen. Det är lika naturligt för en nyutexaminerad systemarkitekt att arbeta som programutvecklare på ett stort företags IT-avdelning, som en konsultfirma. Systemarkitekten är också lämpad att arbeta inom teknik- och idédrivna verksamheter, vilka till exempel kan vara spelutveckling, webbapplikationer eller mobila tjänster.
Syftet med examensarbetet på systemarkitekturutbildningen är att studenten skall visa förmåga att delta i forsknings- eller utvecklingsarbete och därigenom bidra till kunskapsutvecklingen inom ämnet och avrapportera detta på ett vetenskapligt sätt. Således måste de projekt som utförs ha tillräcklig vetenskaplig och/eller innovativ höjd för att generera ny och generellt intressant kunskap.
Examensarbetet genomförs vanligen i samarbete med en extern uppdragsgivare eller forskningsgrupp. Det huvudsakliga resultatet utgörs av en skriftlig rapport på engelska eller svenska, samt eventuell produkt (t.ex.
programvara eller rapport) levererad till extern uppdragsgivare. I examinationen ingår även presentation av arbetet, samt muntlig och skriftlig opposition på ett annat examensarbete vid ett examinationsseminarium.
Examensarbetet bedöms och betygssätts baserat på delarna ovan, specifikt tas även hänsyn till kvaliteten på eventuell framtagen mjukvara. Examinator rådfrågar handledare och eventuell extern kontaktperson vid betygssättning.
BESÖKSADRESS:JÄRNVÄGSGATAN 5·POSTADRESS:ALLÉGATAN 1,50190BORÅS TFN:033-4354000·E-POST: INST.HIT@HB.SE ·WEBB: WWW.HB.SE/HIT
II Svensk titel: Deep Learning i Starcraft 2 Engelsk titel: Deep Learning in Starcraft 2 Utgivningsår: 2018
Författare: Victor Frick & Kristoffer Mattsson Handledare: Patrick Gabrielsson
Abstract
A problem for deep learning has for a long time been complex environments. Recently end-to- end learning agents have been used to master Atari games by processing raw pixel data into features and using these features to make good decisions. This method has not had the same success in the real time strategy game Starcraft 2 and the authors of this paper decided to investigate the possibility of using autoencoders to train feature extractors and thereby improving the rate of learning for reinforcement learning agents. Asynchronous Advantage Actor Critic agents are used for investigating the difference and the use of the PySC2 API enables tests in the Starcraft 2 environment. The results show that the agents need more training to be able to evaluate the pros and cons of an pretrained feature extractor. However, the training time of the autoencoder was short and if it turns out to improve the performance the authors see no arguments not to use an autoencoder to pretrain a feature extractor in Starcraft 2.
Keywords: Deep learning, Autoencoders, End-to-end learning, A3C
III Sammanfattning
Komplexa miljöer har varit svåra för deep learning att hantera. End-to-end learning har använts för att bemästra Atari-spel genom att ta in rå pixelinput, lära sig att tolka den och utföra bra handlingar utifrån informationen. I real time strategy-spelet Starcraft 2 har denna metod inte gett samma goda resultat och författarna av detta arbete avser att undersöka om det går att använda autoencoders för att förträna en feature extractor och därmed förbättra en reinforcement learning-agents träning. Asynchronous Advantage Actor Critic agenter används för att undersöka skillnaderna och PySC2-APIt utnyttjas för att möjliggöra tester i Starcraft 2- miljön. Resultaten visar att agenterna tränats på för kort tid för att med säkerhet kunna visa på eventuella för och nackdelar. Det gick fort att träna en autoencoder i Starcraft 2 och om det visar sig att den förbättrar prestandan anser författarna att det inte finns några nackdelar med förträning i Starcraft 2.
Nyckelord: Deep learning, Autoencoders, End-to-end learning, A3C
IV
Innehållsförteckning
1 Inledning ... - 1 -
1.1 Bakgrund ... - 2 -
1.2 Problem och frågeställning ... - 3 -
2 Teori... - 3 -
2.1 Deep learning ... - 3 -
2.2 End-to-end ... - 6 -
2.3 Autoencoder ... - 6 -
2.4 Markov Decision Process... - 7 -
2.5 A3C ... - 8 -
2.6 Starcraft 2 ... - 8 -
2.7 PySC2 ... - 11 -
2.8 Tidigare forskning ... - 11 -
3 Metod ... - 12 -
3.1 Metodval ... - 12 -
3.2 Avgränsningar ... - 13 -
3.3 Implementation och modifikation av kod ... - 13 -
3.4 Metodreflektion ... - 14 -
4 Experiment ... - 14 -
5 Resultat ... - 15 -
5.1 Collect mineral shards ... - 15 -
5.2 Defeat Roaches ... - 17 -
5.3 Move to beacon ... - 18 -
6 Analys ... - 20 -
7 Diskussion ... - 21 -
7.1 Slutsatser ... - 21 -
7.2 Problem ... - 22 -
7.3 Fortsatt forskning ... - 22 -
- 1 -
1 Inledning
Forskningsområdet Artificiell intelligens (AI) har under de senaste åren gjort stora framsteg.
1992 uppnådde en AI mästarnivå i Dam (Schaeffer et al. 1992), 1999 bemästrade en AI Othello (Buro 1999) och 1997 slog Deep Blue schackvärldsmästaren Kasparov (Campbell, Hoane &
Hsu 2002). Dessa prestationer uppnåddes tack vare tillståndsrymdssökningar, då miljöerna är fullt observerbara och att programmen hade kapacitet att evaluera miljontals tillstånd varje sekund.
Nästa stora framsteg inom AI var Deep learning (Benigo, Courville & Goodfellow 2016). Med hjälp av djupa neurala nätverk har AI lyckats klara av ännu svårare uppgifter, då nätverken inte är lika prestandakrävande minnesmässigt jämfört med tidigare metoder. 2013 släppte Deepmind en publikation (Mnih et al. 2013) där de presenterade ett Deep Q Network (DQN), som kombinerade den tidigare starka Q-learning algoritmen och deep learning. De testade DQN på sju olika Atari 2600-spel. I sex av spelen presterade DQN bättre än alla tidigare implementationer och i tre av dem presterade DQN bättre än den mänskliga mästarnivån. 2015 släppte de en till publikation där 49 Atari 2600-spel testas (Mnih et al. 2015). 43 av spelen presterade DQN bättre än de bästa linjära algoritmerna och i 22 av dem presterade DQN bättre än den mänskliga mästarnivån.
2016 blev en av världens bästa Go-spelare besegrad av deep learning agenten AlphaGo (Silver et al. 2016). I en match över fem spel vann AlphaGo med fyra-ett och blev därmed det första programmet att besegra en professionell Go-spelare utan handikapp och på ett fullstort spelbräde. Trots att Go är över 2 500 år gammalt upptäckte AlphaGo nya öppningsdrag som proffsen sedan börja använda.
Alla dessa förbättringar inom AI har påverkat många olika områden, till exempel inom sjukvården där bland annat forskare från Sutter Health och Georgia Institute of Technology lyckats förutspå hjärtfel nio månader innan doktorer som har använt traditionella metoder, och denna metod tror forskarna går att använda även på andra sjukdomar (Beckett 2016). Inom området självkörande bilar har deep learning lett till stora framsteg, till exempel i mjukvaran PilotNet som kan hålla bilen inom en fil även om vägmarkeringar inte syns (Bojarski et al.
2017).
Även inom värmehanteringssystem har AI och deep learning fungerat bra. Deepmind samarbetade med Google för att minska kylningskostnaderna för Googles datacenter. Detta med hjälp av en deep learning algoritm som framgångsrikt minskade kostnaderna dramatiskt (Gao 2014).
En bra testbädd för AI och machine learning är real time strategy-spel (RTS-spel), på grund av att det är en digital miljö där det är enkelt att implementera AI jämfört med verkligheten, där robotar både är dyra och besvärliga för gemene man att bygga. Det är även en komplexare miljö än tidigare bemästrade områden, till exempel schack och Go, med större antal möjliga tillstånd (Malý 2017). Starcraft 2 är ett modernt RTS-spel som nyligen har öppnats upp för forskare med hjälp av ett API från skaparna, vilket möjliggör för fler att använda Starcraft 2 som en testmiljö för olika AI-experiment (Blizzard 2017).
Deepmind som även skapade agenten som slog världsmästaren i Go, har använt Starcraft 2 API för att implementera och testa ett antal agenter (Vinyals et al. 2017). Dessa agenter använder rå
- 2 -
pixeldata, samt ett antal icke spatiala (rumsbestämda) data som en spelare förväntas känna till, som input och returnerar handlingar i spelets miljö som output. Problemet med agenterna är de tar väldigt lång tid att träna samtidigt som deras färdighet inte räcker till för att slå ens den enklaste inbyggda motståndaren. Denna rapport syftar till att undersöka om det går att förbättra träningstiden för en agent i Starcraft 2.
1.1 Bakgrund
Två stora discipliner inom machine learning, därmed också inom deep learning, är övervakad inlärning (supervised learning), där nätverket hela tiden jämför sig med en mängd märkt data under träningen och reinforcement learning, där nätverket tränar sig själv med hjälp av en belöningsfunktion (Benigo, Courville & Goodfellow 2016). Supervised learning är ett bra sätt att snabbt träna ett nätverk för att få nästan mänsklig förmåga för att bedöma till exempel vad en bild innehåller (Carneiro et al. 2007), eller vilket drag som är bäst i det nuvarande läget.
Nackdelen med supervised learning är att det krävs en stor mängd märkt data som nätverket kan använda för att träna. Det kan kräva mycket resurser att märka all data som behövs och nätverket har också en maxgräns på hur bra det kan bli med en begränsad datamängd. Ett exempel på hur bra supervised learning fungerar inom vissa områden finner vi inom bildigenkänning där djupa neurala nätverk med hjälp av supervised learning kan tränas till att känna igen siffror, skrivna av människor, med en säkerhet på upp till 99 % (Wu & Chen 2015).
Reinforcement learning kan däremot träna utan att det behövs någon data. Nätverket jämför sig istället med en belöningsfunktion som avgör hur bra nätverket presterade (Russel & Norving 2010). Belöningsfunktionen hos ett nätverk som ska lära sig att spela Pac-Man kan till exempel ta hänsyn till hur många punkter som finns kvar, hur långt det är till närmsta spöke och hur många spöken som Pac-Man har ätit. Dessa egenskaper värderas olika i belöningsfunktionen och beteendet hos Pac-Man agenten påverkas av hur egenskaperna viktas mot varandra. Till exempel blir agenten väldigt rädd om avståndet till närmaste spöke viktas högt i belöningsfunktionen medans de andra egenskaperna viktas lågt. Därför är det viktigt att belöningsfunktionen är bra viktad för att uppnå det önskade beteendet för agenten. Detta kan var väldigt svårt i komplexa miljöer där belöningsfunktionen ej är uppenbar.
De agenter som Deepmind implementerar använder end-to-end learning, vilket innebär att de inte använder sig av några förtränade delar till nätverket. De förlitar sig istället på att träna hela nätverket på en gång. Enligt Andrew Ng (2018) är detta ett praktiskt tillvägagångsätt om man har en stor mängd data att träna på. Ng säger dock att vid en mindre mängd data presterar ett nätverk bättre genom att förtränade de olika nätverksdelarna. En del som går att träna i förväg är en feature extractor, den delen av nätverket som omvandlar inputen till ett antal egenskaper (features) som sedan används i nätverket för att utvinna en handling (Guyon et al. 2006).
Agenterna som Deepmind implementerar använder Asynchronous Advantage Actor Critic (A3C), vilket är en state-of-the-art teknik för att träna djupa neuronnät (Mnih et al. 2016).
Ett sätt att träna en feature extractor är med hjälp av en autoencoder. En autoencoder består av två nätverk, ett encoder-nätverk och ett decoder-nätverk (Benigo, Courville & Goodfellow 2016). Encoder-nätverket omvandlar inputen till ett önskat antal features och decoder-nätverket försöker återskapa inputen med hjälp av de features som encoder-nätverket har skapat. Dessa två tränas tillsammans tills skillnaden mellan den faktiska inputen och den återskapade inputen är tillräckligt låg. För att använda feature extractorn behålls sedan endast encoder-nätverket.
- 3 -
1.2 Motivation och frågeställning
För spelindustrin är machine learning fortfarande ett outforskat område. Det ses som en stor risk att lägga ner mycket tid och pengar på ett spel som den genomsnittliga spelaren inte lägger mycket tid på. Det finns inte tillräckligt mycket forskning om lärande agenter i komplexa spel för att spelföretagen ska kunna implementera en agent som erbjuder bättre prestanda än de scriptade botar som används i nuläget. Samtidigt finns det stora potentiella vinster i att implementera machine learning i spel. Återspelbarheten ökar dramatiskt om spelet har förmågan att lära sig hur spelaren agerar. För de spelare som gillar svåra utmaningar blir lärande spel ännu mer attraktiva då spelens agenter skulle uppnå riktigt hög svårighetsgrad.
Genom att kombinera en kraftfull teknik, A3C (Mnih et al. 2016), och autoencoders, som har bevisats fungera väl inom andra områden, som bildigenkänning (Masci, J., Meier, U., Cireşan, D., & Schmidhuber, J. 2011), kan det finns en möjlighet till att förbättra prestandan för nätverket i en komplex miljö. Vidare kan denna metod appliceras på problem inom andra områden än spel.
Både end-to-end learning och autoencoders är kraftfulla deep learning tekniker, men vilken fungerar bäst till komplexa strategispel? Rapportens författare ska försöka demonstrera att autoencoders är ett legitimt val. Frågan vi ställer oss är:
Hur presterar en agent med en förtränad autoencoder jämfört med en agent som använder end- to-end learning med avseende på total erhållen belöning efter likvärdig träningstid, i en komplex miljö som Starcraft 2?
Ytterligare intressanta frågor är, om autoencoders förbättrar prestandan, med avseende på förbättrad träningstid för likvärdig prestanda, samt hur bra generaliseringsförmåga en autoencoder har, där olika delar av Starcraft 2 testas som separata problem.
2 Teori
2.1 Deep learning
Inom deep learning används neurala nätverk med flera lager. Varje lager i ett neuralt nätverk innehåller ett flertal noder, där en nod har ett antal input, en vikt för varje input, en biasterm, en output och en aktiveringsfunktion som transformerar nodens input till dess output (Benigo, Courville & Goodfellow 2016). Det första lagret kallas för inputlagret, det sista för outputlagret och alla lager däremellan kallas för gömda lager, vilket återges i Figur 2–1. En fördel med att ha många dolda lager är att de oftast kräver färre noder per lager och att de oftast generaliseras till testdatan, dock är de svårare att optimera (Benigo, Courville & Goodfellow 2016).
- 4 -
Figur 2–1 En visuell representation av ett neuralt nätverk med ett gömt lager. Alla lager i detta nätverk är fullt kopplade.
Varje nod skapar en viktad summa av dess input, som skickas genom en aktiveringsfunktion.
Aktiveringsfunktionens output blir input till andra noder i efterföljande lager eller om noden ligger i det sista lagret blir det en del av nätverkets output.
Aktiveringsfunktionen används för att nätverket ska kunna lösa mer än bara linjära problem.
Några olika aktiveringsfunktioner är den logistiska sigmoid-funktionen, den hyperboliska tangent-funktionen (tanh) och den rektifierande linjära funktionen (relu), vilka visas i Figur 2–
2. Den sistnämnda föreslogs för att den har bättre empiriska konvergeringegenskaper.
Figur 2–2 Bilden till vänster visar hur sigmoid-funktionen ser ut och hur den beräknas. Tanh-funktionen liknar sigmoid-funktionen i form men går från -1 till 1 istället för 0 till 1 som sigmoid-funktionen gör. Till höger visas
relu-funktionens kurva och hur den räknas ut. (Shamra 2017)
En aktiveringsfunktion som fungerar bra i sista lagret i ett klassificeringsnätverk, där outputen är en lista av vad en bild kan innehålla, är softmax (Benigo, Courville & Goodfellow 2016).
Softmax styrka är att den både normaliserar outputen och ger en kategorisk sannolikhets distribution, en lista med sannolikheter för att inputbilden tillhör de kategorierna som har definierats. För matematisk definition se Formel 2–1.
- 5 -
σ(z) j = e z
j∑ K k=1 e z
kFormel 2–1 Softmax aktiveringsfunktion.
Ett neuralt nätverk tränas under supervised learning, vilka är fallen i denna undersökning, genom att under många iterationer (epoker) behandla inputen och beräkna felet mellan den faktiska outputen och den önskade outputen (loss) (Benigo, Courville & Goodfellow 2016).
Därefter beräknas gradienten (partiella derivatan) av loss-funktionen med avseende på nätverkets vikter, som bakåtpropageras genom nätverket. En optimeringsalgoritm använder sig sedan av de bakåtpropagerade gradienterna för att uppdatera nätverksvikterna på ett sådant sätt att loss-funktionens fel minskas. Nästa epok tar vid och minskar ytterligare loss-funktionens fel på samma sätt. Målet med hela träningen är att minimera loss-funktionens fel.
Standardarkitekturen för ett nätverkslager är ofta att alla dess noder är kopplade till alla noders output i det föregående lagret. Detta kallas att lagret är fullt kopplat (fully connected layer). Ett fully connected layer presterar ofta bra men kräver mycket minne då varje koppling har en egen vikt. Om det finns två lager med tio noder var krävs 100 vikter för kopplingarna. (Benigo, Courville & Goodfellow 2016)
En nätverkstyp som har lyckats bra med bildigenkänning är ett faltningsnätverk (eng.
Convolutional Neural Network – CNN). Faltning (eng. Convolution) kan förklaras genom att man låter ett filter (kernel) traversera en, två- eller tredimensionell input (till exempel en rektangulär bild av pixlar), där filtret multipliceras med dess input för att bilda dess output. I en bildigenkänningstävling 2012 kom ett CNN nätverk på första plats och presterade mycket bättre än tidigare state-of-the-art algoritmer (Krizhevsky, Sutskever & Hinton 2012). Principen som den följer är inspirerad av det mänskliga visuella nervsystemet. Varje inputnod letar efter en egenskap i inputen, till exempel en vågrät linje. Detta gör den genom att svepa ett filter (kernel) över inputen, alltså matematiskt multiplicera nodens vikter med inputen, se Figur 2–3. En kernel med storlek fyra betyder att varje nod ser 4x4 punkter av inputen i en del av svepningen.
Tillsammans med kernel används hyperparametern stride som bestämmer hur mycket (till exempel pixlar) filtret förflyttar över dess input vid varje faltning. Om kernel är fyra och stride är fyra sker ingen överlappning mellan två faltningar. Parametern padding kan användas för att behålla samma spatiala dimensioner hos outputen som hos inputen.
Figur 2–3 Här visas en av faltningarna för en CNN-nod med kernel 4, stride 2, utan padding, på en input av storlek 6x6.
- 6 -
För att kunna träna och testa stora nätverk under många epoker krävs mycket beräkning. Många av de operationer som utförs inom deep learning passar väldigt bra till GPU(er) då det är stora vektorer och matriser som ska beräknas. Ett sådant verktyg är Tensorflow som används väldigt ofta inom deep learning och några av de största AI-företagen använder sig av Tensorflow (2018). Detta verktyg erbjuder ett kraftfullt sätt att bygga upp ett nätverk. Det är enkelt att definiera olika sorters lager och koppla samman dem. Tensorflow har de vanligaste aktiveringsfunktionerna fördefinierade, till exempel de som används i detta arbete. Det finns även funktioner för att träna nätverket en omgång (epok), genom att definiera det värde som skall optimeras, till exempel att minimera lossen.
2.2 End-to-end
När man tränar hela nätverket samtidigt, från input till output, kallas det för end-to-end learning.
Det har applicerats framgångsrik inom olika områden, till exempel för att låta en agent lära sig spela Atari-spel (Mnih et al 2013), där pixlar omvandlas till features via ett CNN, efterföljt av ett fully-connected feed-forward neural network, vars output representerar handlingar för en reinforcement learning agent. Det finns dock nackdelar med end-to-end learning inom komplexare problem, till exempel argumenterar Glasmacher (2017) att om det krävs flera icke- triviala moduler för att lösa ett problem, till exempel en modul för att hantera språk eller en modul för att hantera bilder, kan prestandan för end-to-end learning var mycket sämre än om förtränade moduler hade använts.
2.3 Autoencoder
En vanlig och viktig modul i ett nätverk som hanterar visuell input är en feature extractor (Guyon 2006) i form av en autoencoder, en idé som enligt Benigo, Courville & Goodfellow (2016) kommer från Yann L. som 1987 publicerade idén i Modèles connexionistes de l’apprentissage. Benigo, Courville och Goodfellow beskriver autoencoders tydligt i sin bok Deep Learning (2016) och hela detta kapitel tar stöd från den beskrivningen. Dess uppgift är att hitta olika features i inputen, till exempel i ansiktsigenkänning kan features i det första dolda lagret i en faltnings-autoencoder representera simpla geometriska objekt (till exempel horisontell linje, vågrät linje, övre-vänster hörn och cirkel), features i senare lager kan bilda mer komplexa geometriska objekt genom att kombinera features från tidigare lager (till exempel näsa, mun och öga) samt features i det sista lagret kan representera ett helt ansikte. Med hjälp av dessa sista features kan nätverket sedan ta välinformerade beslut, till exempel genom att lägga på efterföljande fully-connected feed-forward lager som klassificerar personer i inputbilden.
Ett sätt att träna en feature extractor är med hjälp av en autoencoder. En autoencoder består av två delar, ett encoder-nätverk och ett decoder-nätverk, se Figur 2-4. Encoder-nätverket behandlar inputen och ger ett antal features som output. Dessa blir inputen till decoder-nätverket vars uppgift är att försöka återskapa inputen utifrån den givna inputen. Felet mellan den återskapade inputen och den faktiska inputen är det mått som används för att bedöma hur väl autoencodern presterar. Målet under träningen är att minska felet (loss). Ett vanligt sätt att beräkna felet är genom att använda mean-squared error funktionen (MSE). MSE jämför inputen med den återskapade datan genom att bilda den kvadratiska skillnaden mellan varje element i den faktiska inputen och den återskapade inputen. Resultaten summeras ihop och ett medelvärde räknas ut, där resultatet blir lossen.
- 7 -
För att ta fram intressanta features och inte bara återspegla inputen, bör varje lager i encodern innehålla ett mindre antal noder än dess föregångare. Decoder-nätverket måste spegla encoder- nätverket formmässigt. Denna typ av autoencoder kallas för underkomplett (undercomplete autoencoder).
Figur 2-4 En visuell representation av en simpel autoencoder.
2.4 Markov Decision Process
Många problem inom AI kan beskrivas som Markov Decision Processes (MDPs) (Russel &
Norvig 2010). En MDP innehåller en mängd tillstånd S, en mängd handlingar som kan utföras i varje tillstånd A, en övergångsfunktion T(s’|a, s) som anger sannolikheten att hamna i tillståndet s’ om handlingen a utförs i tillstånd s, samt en belöningsfunktion R(s,a,s’) som anger en omedelbar belöning om handlingen a utförs i tillståndet s varpå agenten hamnar i tillståndet s’. Slutligen används en diskonteringsfaktor γ, som gör det möjligt att lösa icke-episodiska MDP-problem samt för att bestämma vikten av kortsiktiga jämfört med långsiktiga belöningar.
Ett MDP-problem representeras därför av 5-tupeln (S, A, T, R, γ). Ett tillstånd är en intern representation av miljön som agenten befinner sig i, till exempel för en Go-agent är brädet miljön och pjäsernas position är tillståndet. Handlingarna är helt enkelt de handlingar som agenten kan utföra i miljön. Dessa kopplas dessutom samman med det efterföljande tillståndet.
Om miljön är deterministisk finns det enbart ett efterföljande tillstånd, men om miljön är stokastisk finns ett antal möjliga tillstånd samt sannolikheten att agenten hamnar i det tillståndet.
I reinforcement learning finns ingen modell, det vill säga ingen fördefinierad T(s’|a, s) eller R(s, a, s’), varför agenten måste interagera med sin miljö för att lära sig att bete sig på ett optimalt sätt genom att lära sig vilka handlingar som ger högst total belöning. En reinforcement learning agent visas i Figur 2-5.
- 8 -
Figur 2-5 Här visas hur agenten interagerar med miljön. A är vilken handling agenten tar, S är ett tillstånd, R är belöningen och t är tidssteget som agenten befinner sig i. (Skymind 2017)
2.5 A3C
Actor-Critic är en algoritm inom deep learning för att lösa MDP-problem (Konda & Tsitsiklis 2000). Den består av två delar, en actor som utför handlingar inom den givna miljön genom att följa en policy 𝜋(a|s), och en critic, som bedömer hur bra det nuvarande tillståndet är med hjälp av en advantage funktion A(s, a) = V(s) – Q(s, a). Tidigare algoritmer använder oftast bara en av dessa två och det har visats att det är effektivare att kombinera dem (Konda & Tsitsiklis 2000).
Actor-Critic algoritmen har sedan utvecklats vidare av Deepmind (Mnih et al. 2016) och är nu asynkron, det vill säga att flera delagenter, arbetare, tränas samtidigt, och använder sig av tidigare erfarenhet för att bedöma om handlingarna var bra. Den nya algoritmen kallas för Asynchronous Advantage Actor-Critic eller A3C. De asynkrona agenterna interagerar med var sin miljö och uppdaterar vikterna, baserat på en advantage-funktion, i ett gemensamt nätverk som alla agenter sedan kopierar. Detta gör att träningen får större spridning av erfarenheter.
Advantage-funktionen i A3C skiljer sig från den vanliga advantage-funktionen i en Actor-Critic algoritm. Den beräknar skillnaden mellan det faktiska värdet av ett tillstånd och det förväntade värdet av samma tillstånd (V(s)), istället för att beräkna skillnaden mellan policyns förväntade värde (Q(s, a)) och V(s).
2.6 Starcraft 2
Starcraft 2 är ett RTS-spel som innehåller tre olika raser, Protoss, Terran och Zerg (Blizzard 2018). Dessa tre raser är väldigt olika men ändå balanserade, det vill säga att ingen ras har ett övertag på någon annan. Varje ras har tillgång till olika enheter, byggnader och uppgraderingar.
Varje enhet har en unik uppsättning av egenskaper och några gemensamma förmågor. Spelet har flera olika spellägen där det vanligaste läget är en spelare mot en annan spelare, där målet är att förstöra den andra spelarens bas och döda alla dess enheter. Efter en match sparas en repris av matchen (replay) och det ges även en poäng som reflekterar hur väl spelaren har presterat under matchen.
Som många andra RTS-spel innehåller Starcraft 2 även en ekonomisk del, som innebär att en agent måste samla mineraler och gas för att kunna producera enheter eller byggnader. Detta betyder att komplexiteten i spelet är väldigt hög och det krävs planering över en lång tid framöver vilket anses vara ett svårt område för AI.
Till skillnad från turbaserade strategispel, som ofta har ett rutnät på spelplanen och därmed förflyttar enheter med hela rutor, förflyttas enheter i RTS-spel i en riktning. Längden som
- 9 -
enheten förflyttas beror på enhetens hastighet och tiden sedan förra tidssteget. Tidsstegens längd beror på hur snabb dator Starcraft 2 körs på.
Starcraft 2 innehåller en stor mängd möjliga handlingar som en agent kan utföra. Till exempel kan en enhet flyttas till en annan position, en byggnad kan börja producera en enhet och en enhet kan attackera en annan enhet. Det finns cirka 500 grundhandlingar i en vanlig match, men beroende på vilken upplösning spelet körs i har de spatiala handlingarna många möjliga värden.
Om upplösningen är 64x64 pixlar finns det 4 096 olika positioner att flytta en enhet till på skärmen och de flesta spelar med en betydligt högre upplösning till exempel 1920x1080.
Dessutom finns det en karta (mini-map) över hela banan, i det nedre vänstra hörnet på skärmen, vilken en agent också kan interagera med och utföra handlingar på.
Då Starcraft 2 har väldigt hög komplexitet jämfört med de problem AI tidigare lyckas lösa och lägg därtill att en vanlig match kan vara 30-40 minuter lång, har det skapats ett antal mini- games för att bryta ner Starcraft 2 i mindre delar, som är enklare att lösa individuellt. De mini- games som har använts i denna undersökning är Collect minerals shards, Defeat roaches och Move to beacon (Deepmind 2017a).
I Collect mineral shards, se Figur 2-6, är agentens uppgift att samla ihop mineraler med hjälp av de två enheterna (marines). Ett antal mineralkluster slumpas ut på kartan när mini-gamet börjar. När en marine når ett mineralkluster försvinner det och en poäng ges till agenten.
Tidsgränsen är två minuter. Om agenten lyckas samla in alla mineralkluster som finns på kartan kommer nya kluster fram.
Figur 2-6 En skärmdump av Collect mineral shards.
Defeat roaches, Figur 2-7, går ut på att agenten ska döda roaches med ett antal marines. För varje roach som dör får agenten 10 poäng och för varje marine som dör blir agenten av med ett poäng. Om alla roaches dör kommer det ett gäng nya och agenten får tillbaka sina marines
- 10 -
som har dött. Här spelar agenten antingen tills alla marines är döda, eller tills två minuter har gått.
Figur 2-7 En skärmdump av Defeat roaches
Det sista mini-game som användes var Move to beacon där agentens mål är att förflytta en marine till en markering på kartan, se Figur 2-8. Markeringens position slumpas fram när mini-gamet börjar. När marinen är i markeringen försvinner den och kommer fram på ett slumpmässigt ställe på kartan, en poäng ges också till agenten. Tidsgränsen är även här på två minuter.
- 11 -
Figur 2-8 En skärmdump av Move to beacon
2.7 PySC2
Det verktyg som gjort denna undersökning möjlig är PySC2, ett Python API som kopplas till Blizzards maskininlärningsmiljö för Starcraft 2 (Deepmind 2017b). PySC2 tar hand om all mellanhantering och det enda som agenten behöver göra är att skicka in vilken handling som den tar, och då får den tillbaka nästa tillstånd. Tidsstegen är till skillnad från det vanliga Starcraft 2 fixerade och därför kan en Starcraft 2 klient körs mycket snabbare eller långsammare än Starcraft 2 kan i vanliga fall. Många forskare arbetade med PySC2 vilket gjorde att det fanns ett stort nätverk av människor som gav viktig input till arbetet.
Den mellanhantering som sker är bland annat att miljön (en Starcraft 2 klient) startas. Den väntar sedan på att agenten ska anropa en step-funktion där den valda handlingen skickas med som en parameter. Sedan bearbetas handlingen av miljön och returnerar en observation av miljön. Observationen består av punkter från skärmen och mini-mapen samt ett antal icke spatiala egenskaper. För att underlätta för agenterna är det inte RGB-pixlar som returneras, utan PySC2 ger ett antal feature layers, som till exempel visar vilket lag enheterna på skärmen tillhör.
Skärmen har 17 feature layers och mini-mapen har 7 feature layers. Hade en vanlig Starcraft 2 klient använts hade mycket mer arbete krävts. En vanlig klient väntar inte på agenten, all data hade varit tvungen att bearbetas visuellt (via PySC2 får agenten ta del data på ett enklare sätt) och det hade varit mycket mer invecklat att skapa tillståndsrepresentationer ur replays.
2.8 Tidigare forskning
Så vitt författarna vet finns ingen tidigare forskning som jämför prestandan hos en feature extractor, som tagits fram med hjälp av en autoencoder, med en feature extractor som tagits fram av end-to-end learning. End-to-end learning har använts framgångsrikt i flera områden, till exempel i energinätverk (Belanger, Yang, & McCallum 2017). Däremot framställer Glasmachers (2017) att end-to-end learning kanske inte alls kommer att vara en genomförbar metod i framtiden då nätverken kommer att innehålla mer moduler än de gör i nuläget. Då
- 12 -
feature extractorn är en slags modul borde detta gälla även här och därför blir resultatet i denna rapport intressant.
Forskningen som Deepmind genomförde 2017 är högst relevant eftersom denna undersökning till stor del grundar sig på deras framgång. De presenterade tre olika agenter som följde två olika modeller (Vinyals et al. 2017). En AtariNet-agent som följer samma principer som Deepminds DQN-agent vilken bemästrade ett antal Atari 2600-spel (Mnih et al. 2013). Den har två CNN-lager för att behandla skärm och mini-map-input, där det första lagret har 16 filter med storlek 8x8 samt med stride 4 och det andra lagret har 32 filter med en storlek på 4x4 och en stride på 2. De icke spatiala egenskaperna behandlas i ett fully connected layer med tanh aktivering och 32 outputs. Outputen från CNN-lagren och det icke spatiala lagret konkateneras sedan och behandlas i ett fully connected layer med 256 outputs och relu-aktivering. Denna output används sedan för att beräkna värdet, vilken handling som ska utföras och vilka argument handlingen ska använda. Värdet räknas ut med ett fully connected layer som har 1 output utan aktiveringsfunktion. Handlingarna beräknas med ett fully connected layer med softmax-aktivering där handlingarna är outputen. Även argumenten för handlingarna beräknas med ett fully connected layer per argument med en softmax-aktivering.
FullyConv-agenten i rapporten (Vinyals et al. 2017) är strukturerad på ett liknande sätt, skillnaden är att FullyConv-agenten försöker behålla de spatiala egenskaperna genom att använda CNN-lager utan stride och med padding för att behålla dimensionerna. Detta för att de spatiala egenskaperna är viktiga i Starcraft 2, till exempel för att ge order till en position på skärmen.
De presenterar även FullyConvLSTM där en long short term memory-modul (LSTM). En LSTM-modul ger agenten möjlighet att minnas tidigare handlingar för hjälpa till i beslutsfattandet, dock kommer denna undersökning inte ge en exakt förklaring till hur LSTM fungerar då det inte tillhör undersökningens omfattning.
Resultaten för de tre agenterna visar att FullyConvLSTM-agenten presterade lika bra eller bättre än de två andra agenterna i de flesta mini-games. AtariNet-agenten visade en medelprestanda och var enkel att implementera vilket bidrog till att den används i denna undersökning.
Värt att nämna är att agenterna från Deepminds rapport (Vinyals et al. 2017) tränades under 600 000 000 steg i Starcraft 2. I denna undersökning har den tillgängliga hårdvaran varit kapabel att träna ca 1 000 000 steg på fem timmar, vilket betyder att det inte är rimligt att försöka uppnå samma resultat som i Deepminds rapport.
3 Metod
Detta kapitel kommer att gå igenom det experiment som genomförts och avgränsningarna som tagits. Sedan behandlas APIt PySC2, modifikationer i kod samt hur autoencodern har implementerats. Sist reflekteras metodvalet och eventuella nackdelar.
3.1 Metodval
Denna undersökning använder sig av en experiment-metod för att samla in kvantitativa data.
Enligt Recker (2013) passar kvantitativa metoder väl då nya fakta skall undersökas. Valet att använda ett experiment gjordes då denna metod lämpar sig ypperligt till att ta fram den data som undersökningen kräver för att svara på forskningsfrågorna. Möjligheten att kontrollera alla delar av experimentet ger en god validitet till undersökningen (Recker 2013).
- 13 -
Experimentet startade med att det skapades en replay per mini-game som skulle testas. Detta gjordes av författarna för att alla delar av mini-gamet skulle bli representerat. Ur dessa framtogs ett stort antal tillståndsrepresentationer (ca 2500 per replay) som användes för att träna olika autoencoders. Dessa autoencoders användes sedan för att utvinna feature extractors, genom att spara encoder-nätverket. Sedan tränades AtariNet-agenter på de tre mini-games som skulle testas. De följer den struktur som presenterades i kapitel 2.8. Efter det tränades tre AtariNet- agenter med förtränade feature extractors på samma mini-games. Skillnaderna i input mellan agenterna var att de utan autoencoders använde rådata från observationer av spelet och att de med autoencoders använde outputen från autoencodern som input. Under båda dessa träningar stoppades utforskningen i fem episoder var hundrade episod, för att spara poängen som den optimala policyn gav vid det tillfället. Sedan undersöktes autoencodernas loss-kurvor för att se hur lång tid det tog för dem att konvergera. Denna tid användes sedan för att förskjuta AtariNet- agenterna med förtränade feature extractors resultat, då de redan blivit tränade en tidsperiod.
Till sist tränades också en AtariNet-agent med en feature extractor från Collect mineral shards på Move to beacon för att kunna undersöka generaliteten hos en feature extractor framtagen av en autoencoder. All data som samlades in sammanställdes sedan till grafer där den totala belöningen visades.
Resultaten analyserades på följande sätt. Den optimala policyn för AtariNet-agenten och AtariNet-agenten med förtränad feature extractor jämfördes genom att medelvärdet beräknades på de fem episoderna utan utforskning. Detta gav ett värde för hur den optimala policyn utvecklades var hundrade episod. Resultaten från agenten med förtränad feature extractor försköts för att faktorisera in tiden som autoencodern tränade. Sedan undersöktes skillnaden mellan agenterna för att klargöra skillnaden mellan agenternas poäng.
3.2 Avgränsningar
Då Starcraft 2 har en hög komplexitet har bara ett antal mini-game testats. De tre mini-games som testades var Collect mineral shards, Defeat Roaches och Move to beacon, vilka beskrivs noggrannare i kapitel 2.6. Undersökningen avgränsade också hur många episoder agenterna tränades under, på grund av undersökningens tidsram. För att kunna se hur agenternas totala träningstid hade påverkats av en förtränad autoencoder hade i många mini-games krävt minst 600 000 000 steg, det antal steg som Deepmind tränade sina agenter på (Vinyals et al. 2017).
600 000 000 steg motsvarar ungefär 4 månaders träning med den tillgängliga hårdvaran.
3.3 Implementation och modifikation av kod
För att gå igenom replays användes Nårstad (2017) kodbas. Den modifierades för att samla in och spara ut all information om tillstånden. Tidsmässigt tar det lika lång tid att exportera tillstånden som att spela upp en replay i vanliga fall. Autoencondern implementerades med hjälp av Tensorflow enligt de inputlager som finns definierade för AtariNet i kapitel 2.8. Det tog ungefär 8–10 timmar att träna autoencodern med optimeringsalgoritm RMSprop, vilken är en vanlig optimeringsalgoritm att använda (Benigo, Courville & Goodfellow 2016), i 10 000 epoker. A3C-agenten som användes kom från Kiat L. S. (2017). Kiats agent följer AtariNet- strukturen, vilken presenterades i kapitel 2.8, och här modifierades koden för att kunna ladda in en färdigtränad feature extractor och för att kunna spara resultatet. Feature extractorn laddades in genom att använda de lager som tränades i autoencodern istället för att initialisera dem som nya lager. Resultaten sparades genom att en lyssnare, som kördes på en egen tråd, tog emot meddelanden från arbetarna som innehöll episoden nummer och poäng. Detta skrev
- 14 -
lyssnaren till ett Excel-dokument. Det tog mellan 5–10 timmar att träna en agent, med den robusta optimeringsalgoritmen AdamOptimizer (Kingma & Ba 2014), på 10 000 episoder.
Detta ansåg författarna vara en rimlig mängd tid att lägga på varje test för att testen inte skulle ta för lång tid samtidigt som de skulle ge relevanta resultat. Tiden varierade beroende på hur lång tid varje mini-game tog.
3.4 Metodreflektion
Frågeställningen är av kvantitativ karaktär då den kräver statistiskt underlag för att besvaras.
Hade syftet med rapporten varit att ta fram en ny metod för att skapa en feature extractor hade en designforskningsmetod passat bättre. Enligt Recker (2013) är det viktigt att den data som samlas in verklig kan användas för att besvara forskningsfrågan, vilket är fallet i denna undersökning då den uppmätta belöningen i de episoder utan utforskning är ett tydligt resultat på vilken agent som presterat bäst under testet, då detta är när agenten använder den optimala policyn som den har lärt sig. Då resultaten tar hänsyn till den tid som autoencodern har tränats i, blir resultaten rättvist redovisade.
En fara är att agenten kanske är för svag generellt för att det ska gå att se någon skillnad på prestandan mellan end-to-end och autoencoder. Detta verkar dock inte vara fallet då Deepminds rapport presenterar två andra agenter som trots små skillnader i implementationen visar tydliga skillnader i resultatet. Då träningstiderna i denna undersökning inte motsvarar de träningstider som Deepmind använt finns risken fortfarande kvar att agenten är för svag för att det ska gå att se någon skillnad.
Som alltid när det handlar om att träna agenter över tid, går det att lägga fram argumentet att de borde ha tränats längre, då detta ofta ger tydligare resultat. Men författarna anser att den träningstid som är lagd motsvarar undersökningens omfattning, på grund av att det annars skulle ta flera månader att träna en agent.
För stärkt validitet testades olika typer av mini-games. Om det skulle visa sig att ett mini-game var för simpelt och att båda agenterna nådde upp i toppresultat på lika kort tid skulle resultatet inte bidra till undersökningen, därför testades flera mini-games.
En variabel som var svår att avväga var hur många episoder som skulle köras utan utforskning, för att mäta resultatet. Då miljön generas slumpmässigt är det en fördel att testa ett antal episoder och räkna ut ett medelvärde för dessa. Om fler episoder används för att ta fram medelvärdet blir resultatet säkrare, men samtidigt minskar antalet episoder där agenten utforskar nya lösningar. Det betyder att agentens träning tar längre tid om många episoder körs utan utforskning. Författarna valde att låta fem av hundra episoder köras utan utforskning för att inte hindra agentens lärande för mycket.
Om undersökningens resultat visar på att det är bättre att använda förtränade delar av nätverk i komplexa miljöer, kan det appliceras även inom andra maskininlärningsområden där end-to- end learning används. Däremot om resultatet inte tyder på någon fördel med att använda en autoencoder, betyder det troligtvis inte att inga andra förträningsmetoder fungerar bättre än end- to-end learning.
4 Experiment
En replay sparas i vanliga fall bara som en lista av de handlingar som togs under spelets gång, för att spara plats. För att kunna träna en autoencoder krävs en tillståndsrepresentation, vilket
- 15 -
alltså inte sparas i replayen och därför simulerades replayen och tillståndsrepresentationen sparades ut för varje steg i replayen. Detta gjorde att autoencodern hade en stor mängd data, minst tusen olika tillstånd, att träna på.
Sedan tränades autoencodern under 10 000 episoder. För att minska overfitting användes en batchsize på 100, alltså att 100 stycken olika tillstånd, som slumpades fram, användes som input under en episod. Encoder-nätverket följer samma struktur som presenterades för AtariNet- agenten i Deepminds rapport (Vinyals et al 2017), med ett fully connected lager med 32 outputs och aktiveringsfunktionen tanh som tar hand om icke spatiala features, till exempel hur mycket mineraler spelaren har och hur mycket liv den markerade enheten har (Deepmind 2017c). Det finns två CNN lager med 8 i kernel, 4 i stride, 32 filter och aktiveringsfunktionen relu, där ett tar hand om inputen från skärmen och ett tar hand om inputen från kartan. Efter det kommer två CNN lager med 4 i kernel, 2 i stride, 16 filter och aktiveringsfunktionen relu för att vidare behandla datan. Antalet episoder valdes då ett flertal olika värden testades och 10 000 ansågs vara det bästa alternativet med hänsyn till både hastighet och precision.
Efter att autoencodern tränats exporterades encoder-nätverket och lades in i en AtariNet-agent.
AtariNet-agenten tränades i sin tur med 10 000 episoder och belöningen sparades i 5 episoder per 100 episoder för rapportens jämförelser. Sedan kördes en AtariNet-agent utan en autoencoder med 10 000 episoder där belöningen också sparades. Belöningsfunktionerna agenterna använder motsvarar poängsystemen i de olika mini-games som testats, se kapitel 2.6.
Till sist testades även generaliteten hos autoencodern genom att en förtränad modell av autoencodern för mini-gamet Collect mineral shards användes på det liknande problemet Move to beacon. Denna tränades på 10 000 episoder och jämfördes med en agent, vars autoencoder tränades på Move to beacon, som också tränats i 10 000 episoder, samt en AtariNet-agent utan en feature extractor från en autoencoder, även denna tränades under 10 000 episoder.
5 Resultat
I detta kapitel kommer resultatet av experimenten att redovisas, grupperat i de mini-games som testats. Först visas resultaten för autoencoderns träning, sedan hur AtariNet och AtariNet Autoencoder presterat under träningen. Sist visas skillnaden mellan agenternas prestanda sett till insamlad poäng. När resultaten i Move To Beacon presenteras kommer ytterligare en agent presenteras vars autoencoder har tränats på Collect Mineral Shards.
5.1 Collect mineral shards
Figur 5-1 visar att autoencodern för Collect Mineral Shards konvergerar efter ca 200 episoder, vilket motsvarar ungefär 20 minuter träning. Därför har resultatet för AtariNet Autoencoder förskjutits i Figur 5-2 med 20 minuters träning som motsvarar ca 200 episoder i Collect Mineral Shards.
- 16 -
Figur 5-1 Loss-kurvan för autoencodern som tränat på Collect Mineral Shards. X-axeln visar episoder och Y- axeln visar loss.
I Figur 5-2 visas hur mycket poäng agenterna har lyckats samla under de episoder som kördes utan utforskning, det vill säga när en agent använder den optimala policyn som den hittills har lärt sig. Det som syns är att det är stora skillnader på hur bra agenten fungerar under träningen.
Till exempel får AtariNet agenten 13,2 poäng vid 2100 episoder och 1,6 poäng bara 100 episoder senare. Detta kan tyda på att för få episoder användes för att ta fram ett medelvärde.
Agenterna tränads i 10 000 episoder vilket motsvarar ca 2 300 000 steg. Träningen tog lika lång tid för agenterna, ungefär 10 timmar var.
Figur 5-2 X-axeln representerar episoder i Starcraft 2 och Y-axeln representerar belöning.
För att enklare se om det finns någon skillnad mellan agenterna visar Figur 5-3 just skillnaden i varje steg i grafen. Även här märks stora skillnader och det svänger rejält under träningen. En tendens som går att se är att under de sista 2 000 episoderna presterar AtariNet Autoencoder bättre än AtariNet vid 17 av 20 tillfällen.
0 1000 2000 3000 4000 5000 6000
1 359 717 1075 1433 1791 2149 2507 2865 3223 3581 3939 4297 4655 5013 5371 5729 6087 6445 6803 7161 7519 7877 8235 8593 8951 9309 9667
0 2 4 6 8 10 12 14 16
0 400 800 1200 1600 2000 2400 2800 3200 3600 4000 4400 4800 5200 5600 6000 6400 6800 7200 7600 8000 8400 8800 9200 9600 10000
AtariNet AtariNet Autoencoder
- 17 -
Figur 5-3 Skillnaden mellan linjerna i Figur 5-2. X-axeln är episoder i Starcraft 2 och Y-axeln representerar skillnaden i belöning. När linjen är blå är AtariNet bättre och när linjen är röd är AtariNet Autoencoder bättre.
5.2 Defeat Roaches
Autoencodern för Defeat Roaches konvergerar efter ungefär 200 episoder, vilket syns i Figur 5-4. Detta motsvarar 20 minuters träning vilket är ungefär 400 episoders träning i Defeat Roaches, vilket är antalet episoder AtariNet Autoencoder har förskjutits i Figur 5-5.
Figur 5-4 Loss-kurva för autoencoder i Defeat Roaches. X-axeln visar episoder och Y-axeln visar loss.
Agenternas prestanda i Defeat Roaches visas i Figur 5-5. Denna visar samma spretiga typ av resultat som Figur 5-2 visade. Ingen av agenterna verkar lära sig mycket mer än den andra men båda visar på en viss förbättring. Intressant är de två toppar agenterna har. AtariNet har sitt bästa resultat efter 2 900 episoder och AtariNet Autoencoder har sitt efter 6 900 episoder. Vi närmare studerande av rådata visas att dessa två toppar beror på att två superresultat som agenterna inte lyckas komma i närheten av igen. Träningen av agenterna tog ca 5 timmar var och de 10 000 episoderna motsvarade ca 1 000 000 steg.
0 10 20 30 40 50 60 70 80
1 346 691 1036 1381 1726 2071 2416 2761 3106 3451 3796 4141 4486 4831 5176 5521 5866 6211 6556 6901 7246 7591 7936 8281 8626 8971 9316 9661
- 18 -
Figur 5-5 Y-axeln representerar belöning och x-axeln representerar episoder.
Resultaten i Figur 5-6 visar att AtariNet är bättre i majoriteten av episoderna. Anledningen till att AtariNet Autoencoder verkar vara bättre än AtariNet i den första punkten trots att den inte började förens efter 400 episoder är att AtariNet hade en negativ poäng. Detta sker endast i detta mini-game då de andra inte har möjlighet att ge negativa poäng.
Figur 5-6 Skillnaden mellan linjerna i Figur 5-5. När linjen är blå är AtariNet bättre och när linjen är röd är AtariNet Autoencoder bättre.
5.3 Move to beacon
Figur 5-7 visar att autoencodern för Move To Beacon konvergerar efter 200 episoder. Detta motsvarar ca 20 minuter träning och i Move To Beacon är det ungefär 200 episoder. Denna autoencoder har minst skillnad i loss när den väl konvergerar vilket beror på att det inte finns många entiteter, max två.
-20 -10 0 10 20 30 40 50 60 70
0 400 800 1200 1600 2000 2400 2800 3200 3600 4000 4400 4800 5200 5600 6000 6400 6800 7200 7600 8000 8400 8800 9200 9600 10000
AtariNet AtariNet Autoencoder
- 19 -
Figur 5-7 Loss-kurvan för autoencoder i Move To Beacon. X-axeln visar episoder och Y-axeln visar loss.
Figur 5-8 visar inte bara AtariNet och AtariNet Autoencoder, utan också AtariNet Autoencoder CMS vars autoencoder har tränats på Collect Mineral Shards. Autoencodern för Collect Mineral Shards och Move To Beacon tog båda två ca 20 min att träna och därför har deras resultat förskjutits och börjar på episod 200. Det som syns är att AtariNet har svårt att ta poäng efter 4 000 episoder och AtariNet Autoencoder CMS följer det mönstret, då den tar mycket poäng i början men senare har svårare för det. AtariNet Autoencoder lyckas däremot att lära sig att samla mer poäng än de andra och efter 4 800 episoder är det den bästa agenten. Intressant är att AtariNet Autoencoder CMS presterar sämre än AtariNet Autoencoder men bättre än AtariNet.
Alla agenter tog ca 10 timmar att träna i 10 000 episoder, vilket motsvarar ca 2 300 000 steg.
Figur 5-8 Y-axeln representerar belöning och x-axeln representerar episoder.
Skillnaden mellan AtariNet och de två andra agenterna syns tydligt i Figur 5-9 och Figur 5-10.
AtariNet samlar en del poäng i början men lyckas inte prestera bättre än de andra agenterna efter 5 300 episoder.
0 50 100 150 200 250 300 350
1 346 691 1036 1381 1726 2071 2416 2761 3106 3451 3796 4141 4486 4831 5176 5521 5866 6211 6556 6901 7246 7591 7936 8281 8626 8971 9316 9661
0 0,2 0,4 0,6 0,8 1 1,2 1,4 1,6 1,8 2
0 400 800 1200 1600 2000 2400 2800 3200 3600 4000 4400 4800 5200 5600 6000 6400 6800 7200 7600 8000 8400 8800 9200 9600 10000
AtariNet AtariNet Autoencoder AtariNet Autoencoder CMS
- 20 -
Figur 5-9 Skillnaden mellan AtariNet och AtariNet Autoencoder i Move To Beacon. X-axeln visar episoder och Y-axeln visar poäng.
Figur 5-10 Skillnaden mellan AtariNet och AtariNet Autoencoder CMS i Move To Beacon. X-axeln visar episoder och Y-axeln visar poäng.
6 Analys
En första analys som bör lyftas är att antalet episoder vilka användes för att testa den optimala policyn verkar ha varit för få. Detta syns i alla resultat genom att det är stor skillnad mellan intilliggande punkter. Detta påverkar undersökningen mycket då det inte ger säkra resultat.
Något som syns tydligt och säkert är att de olika autoencoders alla konvergerar efter ca 200 episoder, eller 20 minuter. Detta tyder på att det går relativt snabbt att träna en feature extractor och att det inte verkar spela någon större roll vilket mini-game det är. I resultaten syns att lossen i Collect Mineral Shards är mycket högre, ca 600, än i Move To Beacon och Defeat Roaches, ca 30. Detta beror på att det finns fler entiteter än i Move To Beacon och att de är inte grupperade tillsammans som de är i Defeat Roaches. AtariNet Autoencoder-agenten kan ha påverkats av Collect Mineral Shards mer varierade tillståndsmiljö. Trots detta presterar AtariNet Autoencoder till stor del bättre än AtariNet under de sista 2 000 episoderna.
- 21 -
Det som syns i autoencodernas loss-kurvor är den stora skillnaden mellan startfelet och felet efter ett antal episoder. Detta måste även end-to-end learning metoden ta hand om, vilket kan ta längre tid då den har fler parametrar att ta hänsyn till.
Defeat Roaches var det mini-game där poängen varierade mest. Det beror på att i Defeat Roaches finns en risk för att agenten kan förlora sina enheter. Detta är såklart dåligt och det representeras med negativa poäng. Samtidigt finns stor belöning att hämta om agenten lyckas döda roaches. Det ligger alltså i mini-gamets natur att poängen har en stor variation. Detta mini- game har störst potential att visa om en agent har lärt sig en god policy då poängen kan bli mycket hög.
I Defeat Roaches presterade AtariNet bättre och det tror författarna beror på att det inte är stor variation i starttillståndet. Det innebär att det inte är lika viktigt för agenterna att kunna läsa av miljön, istället är det viktigare att lära sig bra handlingar. Under träningen observerades att agenterna lyckades döda mer roaches om de använde sig av handlingen ”patrullera”, med denna order attackerar enheterna fiender direkt när de ser dem istället för att gå till en position och sedan attackera eventuella fiender. Med dessa observationer anser författarna att en agent tjänar mer på att få träna handlingarna istället för att träna på att bearbeta miljön. Dock bör det nämnas att detta kanske endast är fallet kortsiktigt. Vid längre träning kan det visas sig att agenten tjänar mer på att kunna läsa av miljön och göra informerade handlingar.
Resultaten från Move To Beacon visar att AtariNet Autoencoder lär sig mycket bättre än AtariNet. I början utför båda slumpmässiga handlingar men efter halva träningen syns det att AtariNet Autoencoder presterar mycket bättre. Detta beror antagligen på att den har lättare att läsa av miljön, vilket är viktigt i detta mini-game på grund av att det är svårt att samla poäng med slumpmässiga handlingar.
Även AtariNet Autoencoder CMS presterar bättre än AtariNet vilket pekar på att den till viss del har lärt sig att läsa av miljön. Feature extractorn är inte medveten om vad en markör är för något då den inte har sett den innan, men resten av miljön har den lärt sig att tolka. Detta verkar stämma då den presterar bättre än AtariNet men sämre än AtariNet Autoencoder.
7 Diskussion
I detta kapitel kommer slutsatser dras från analysen och resultaten, problem som uppstod under undersökningen kommer att tas upp och möjliga framtida studier kommer att diskuteras.
7.1 Slutsatser
Författarna anser att de resultat som presenterats har svårt att definitivt svara på undersökningens huvudfrågeställning. Detta på grund av de osäkra resultaten och den knapphändiga träningen jämfört med vad som tidigare krävts för att uppnå god prestanda. För att kunna svara på frågeställningen tror författarna inte att en träning med 600 000 000 steg hade krävts för att se skillnad, men mer än vad denna undersökning hade möjlighet att genomföra. Tendensen var dock att agenter med autoencoder presterade lite bättre.
Undersökningen visar däremot att det inte tar lång tid att träna en feature extractor och att det därmed inte ökar träningstiden markant. Detta betyder att om en förtränad feature extractor ökar inlärningsförmågan bör det inte finns några anledningar att inte förträna.
- 22 -
Angående generaliteten hos en autoencoder anser författarna att det inte finns tillräckligt starka bevis för att svara på om den finns. Dock visar det resultat där en agent fick del av en feature extractor förtränad på ett annat mini-game att prestandan ökade. Detta skedde däremot i två miljöer som var väldigt lika, vilket inte alltid är fallet i verkligheten.
Eftersom att forskningsfrågorna inte kunde besvaras påverkas inget av denna undersökning.
Men om undersökningen hade dragit slutsatsen att förtränade moduler ökar prestandan hade det gett uppmaningar till alla vidare undersökningar och implementationer att utnyttja förtränade moduler och därmed förbättrat prestandan vid inlärning.
7.2 Problem
De största problem som har uppstått under arbetets gång är bristen på tid och rätt hårdvara.
Deepmind (Vinyals 2017) tränade alla sina agenter på 600 000 000 steg i spelet. De agenter som presenterats i den här undersökningen har tränats på drygt 2 000 000 steg och det har tagit ca 10 timmar per agent. För att nå upp till Deepminds nivå krävs alltså ungefär 100 dagars körning på de maskiner som använts i undersökningen. Dessutom har träningen avbrutits ett antal gånger på grund av att internminnet tagit slut eller att processorn inte lyckades att uppdatera spelen tillräckligt snabbt. Detta har såklart medfört att de agenter som tränats i undersökningen inte alls motsvarar de agenter Deepmind tränade och därmed blir resultaten inte lika säkra.
Ett problem som blev tydligt när resultaten analyserades var att mängden episoder som testades utan utforskning var för få för att ge ett rättvist medelvärde. Det borde ha varit en större mängd tillstånd men då hade träningen hindrats i för stor utsträckning. I undersökningen användes 5%
av episoderna till denna testning, vilket motsvarar 15–30 minuter, beroende på mini-game.
Hade det ökats till 10% hade det varit motsvarat 30–60 minuter, vilket inte var aktuellt då träningstiden var kort till att börja med. Ett alternativ hade varit att ha större intervall mellan testen, men det hade gett väldigt få datapunkter att analysera.
För att öka tillförlitligheten på de resultat som tas fram i undersökningen hade det varit bättre att upprepa experimenten flera gånger för att säkerställa att resultaten upprepas. Det var inte möjligt under denna undersökning på grund av att träningstiden var för lång.
7.3 Fortsatt forskning
Författarna uppmanar till fortsatt forskning på förtränade moduler, för att uppnå säkrare resultat.
Genom att träna agenterna längre borde säkra resultat kunna utvinnas. Detta skulle vara ett stort bidrag till Deep Learning och Machine Learning-fälten.
Ytterligare en intressant forskning hade varit att undersöka om det går att dela upp Starcraft 2- problemet i fler moduler som går att träna var för sig och därmed möjligtvis ge en ytterligare förbättra inlärningsförmågan för reinforcement learning agenter.
- 23 -
Källförteckning
Beckett, J (2016) Change of Heart: How AI Can predict Cardiac Failure Before It’s Diagnosed https://blogs.nvidia.com/blog/2016/04/11/predict-heart-failure/ [2018-01-19]
Belanger, D., Yang, B., & McCallum, A. (2017). End-to-End Learning for Structured Prediction Energy Networks. arXiv preprint arXiv: 1703.05667.
Benigo, Y., Courville, A., Goodfellow, I. (2016). Deep Learning. Cambridge: MIT Press
Blizzard (2017) The Starcraft II Has Arrived. http://us.battle.net/sc2/en/blog/20944009 [2018- 01-19]
Blizzard (2018) What is Starcraft II? http://eu.battle.net/sc2/en/game/guide/whats-sc2 [2018- 03-21]
Bojarski, M., Yeres, P., Choromanska, A., Choromanski, K., Firner, B., Jackel, L., & Muller, U. (2017). Explaining How a Deep Neural Network Trained with End-to-End Learning Steers a Car. arXiv preprint arXiv: 1704.079111.
Buro, M. (1999). From simple features to sophisticated evaluation functions. Lecture Notes in Computer Science (including Subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), 1558, 126-145.
Campbell, Hoane, Hsu. (2002). Deep Blue. Artificial Intelligence, 134(1), 57-83.
Carneiro, Gustavo, Chan, Antoni B., Moreno, Pedro J., & Vasconcelos, Nuno. (2007).
Supervised learning of semantic classes for image annotation and retrieval. (Author abstract).
IEEE Transactions on Pattern Analysis and Machine Intelligence, 29(3), 394-410.
Deepmind (2017a) DeepMind Mini Games https://github.com/deepmind/pysc2/blob/master/
docs/mini_games.md [2018-03-21]
Deepmind (2017b) PySC2 - Starcraft II Learning Environment https://github.com/deepmind/
pysc2 [2018-03-23]
Deepmind (2017c) Environment https://github.com/deepmind/pysc2/blob/master/docs/
environment.md [2018-03-06]
Gao J. (2014) Machine Learning Applications for Data Center Optimization. Google White Paper.
Glasmachers, T. (2017). Limits of End-to-End Learning. arXiv preprint arXiv: 1704.08305.
Guyon, I., Nikravesh, I., Gunn, M., Zadeh, S., Nikravesh, Masoud, Gunn, Steve, & Zadeh, Lotfi A. (2006). Feature Extraction Foundations and Applications (Studies in Fuzziness and Soft Computing, 207).
Kiat L. S. (2017) PySC2-RLagents https://github.com/greentfrapp/pysc2-RLagents [2018-03- 07]
