DEEP LEARNING I STARCRAFT 2 AUTOENCODERS FÖR ATT FÖRBÄTTRA END-TO-END LEARNING

Transkript

1 DEEP LEARNING I STARCRAFT 2 AUTOENCODERS FÖR ATT FÖRBÄTTRA END-TO-END LEARNING Examensarbete Systemarkitekturutbildningen Victor Frick Kristoffer Mattsson VT 2018:KSAI04

2 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, BORÅS TFN: E-POST: INST.HIT@HB.SE WEBB: I

3 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-toend 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 II

4 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 III

5 Innehållsförteckning 1 Inledning Bakgrund Problem och frågeställning Teori Deep learning End-to-end Autoencoder Markov Decision Process A3C Starcraft PySC Tidigare forskning Metod Metodval Avgränsningar Implementation och modifikation av kod Metodreflektion Experiment Resultat Collect mineral shards Defeat Roaches Move to beacon Analys Diskussion Slutsatser Problem Fortsatt forskning IV

6 1 Inledning Forskningsområdet Artificiell intelligens (AI) har under de senaste åren gjort stora framsteg 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 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 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 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 å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å - 1 -

7 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 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

8 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 endto-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)

9 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

10 σ(z) j = ez j K e z k k=1 Formel 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 6x

11 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 icketriviala 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

12 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 encodernä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

13 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 - 8 -

14 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 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 minuter lång, har det skapats ett antal minigames för att bryta ner Starcraft 2 i mindre delar, som är enklare att lösa individuellt. De minigames 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 - 9 -

15 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

16 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å

17 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 steg i Starcraft 2. I denna undersökning har den tillgängliga hårdvaran varit kapabel att träna ca 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)

18 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 AtariNetagenter 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 AtariNetagenterna 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 steg, det antal steg som Deepmind tränade sina agenter på (Vinyals et al. 2017) 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 epoker. A3C-agenten som användes kom från Kiat L. S. (2017). Kiats agent följer AtariNetstrukturen, 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

19 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å 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-toend 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 endto-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

20 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 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 AtariNetagenten 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 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 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 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å episoder och jämfördes med en agent, vars autoencoder tränades på Move to beacon, som också tränats i episoder, samt en AtariNet-agent utan en feature extractor från en autoencoder, även denna tränades under 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

21 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 episoder vilket motsvarar ca steg. Träningen tog lika lång tid för agenterna, ungefär 10 timmar var AtariNet AtariNet Autoencoder 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 episoderna presterar AtariNet Autoencoder bättre än AtariNet vid 17 av 20 tillfällen

22 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 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 episoder och AtariNet Autoencoder har sitt efter 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 episoderna motsvarade ca steg

23 AtariNet AtariNet Autoencoder 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å

24 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 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 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 episoder, vilket motsvarar ca steg. 2 1,8 1,6 1,4 1,2 1 0,8 0,6 0,4 0,2 0 AtariNet AtariNet Autoencoder AtariNet Autoencoder CMS 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 AtariNet samlar en del poäng i början men lyckas inte prestera bättre än de andra agenterna efter episoder