Sammenligning af tre typer neurale netværks indlæringsmetoder Lasse Dahl Ebert 20020867 pulver@daimi.au.dk Aarhus Universitet Datalogisk Institut 5. december 2007
Resumé Dette speciale analyserer, eksperimenterer med og sammenligner tre indlæringsmetoder til kunstige neurale netværk. Et neuralt netværk kan opfattes som et orakel, der givet en observation kan lave en forudsigelse. Vi tager udgangspunkt i en bestemt type problemer, nemlig dem hvor der er en serie af observationer, før man ved om forudsigelsen er rigtig. Som eksempel kan nævnes backgammon. Der er i backgammon en serie af brætstillinger og kun én forudsigelse: Resultatet af spillet. Backgammon er desuden et godt eksempel, da dette spil er tilpas komplekst, og det derfor er svært at kende den optimale strategi. Vi vil derfor bruge backgammon som praktisk eksempel. Igennem rapporten skal vi se hvordan indlæringsmetoderne mutation, backpropagation og temporal difference learning hver især udvikler et neuralt netværk. Specielt vil vi prøve at genskabe Tesauros TD-Gammon version 0.0, en banebrydende kunstig intelligens til backgammon bygget op om temporal difference learning.
Indhold 1 Indledning 4 1.1 Introduktion til neurale netværk.................. 4 1.2 Introduktion til TD-Gammon.................... 5 1.3 Introduktion til backgammon.................... 6 1.4 Formålet med dette speciale..................... 7 1.5 Termer................................. 8 1.6 Opbygning af specialet........................ 9 2 Temporal Difference Learning 11 2.1 Multilayer feedforward-netværk................... 11 2.2 Backpropagation........................... 12 2.2.1 Algortitme for backpropagation............... 14 2.2.2 Algoritme for træning.................... 14 2.3 Temporal difference learning..................... 15 2.3.1 TD(1)............................. 16 2.3.2 TD(λ)............................. 18 2.3.3 Algoritme for TD(λ)..................... 20 2.4 Evolution med mutation....................... 20 3 Framework 21 3.1 Klasser i Pulvergammon....................... 21 3.1.1 Pakken player......................... 21 3.1.2 Pakken model......................... 23 3.1.3 Pakken view......................... 23 4 Træning 25 4.1 Netværksstruktur........................... 25 4.1.1 Kommentarer til netværksstrukturen............ 26 4.2 Evalueringsfunktion......................... 27 4.3 α-justering.............................. 27 5 Eksperimenter 29 5.1 Hvor hurtigt gik det?......................... 29 5.2 Hvor gode er spillerne blevet?.................... 32 2
5.2.1 Den bedste spiller...................... 32 5.2.2 Sammenligning af alle spillerne............... 33 5.3 En menneskelig bedømmelse..................... 33 5.4 En anden netværksstruktur..................... 37 6 Konklusion 39 6.1 PulverGammon i fremtiden..................... 39 6.2 Tak til................................. 40 7 Kørsel 41 A Mail sendt til alle testere 42 3
Kapitel 1 Indledning Dette speciale er en undersøgelse af og eksperimenter med de kendte metoder til at lære et kunstigt neuralt netværk et komplekst spil som backgammon. Selve indlæringsprocessen er i fokus, hvorimod det er mindre vigtigt, om det handler om backgammon og spil i det hele taget. Specielt vil vi genskabe TD-Gammon version 0.0 [10]. 1.1 Introduktion til neurale netværk Et kunstigt neuralt netværk, her omtalt som et neuralt netværk, er et system, der meget løst modellerer en rigtig hjerne. Et neuralt netværk er en graf af neuroner og orienterede, vægtede forbindelser mellem disse neuroner. Et neuron kan ses som en funktion, der summer alle inputs fra de indgående forbindelser og påfører en funktion til denne sum. Resultatet af dette er så det, som neuronet sender ud af sine udgående forbindelser. På figur 1.1 ses en illustration af et neuron. Det får tre inputværdier fra tre forbindelser med hver sin vægt og outputter en værdi y. Denne er beregnet som y = f( n i=1 x iw i ), hvor f i princippet kan være en vilkårlig funktion. De mest { benyttede funktioner for 0 for x 0 f i neurale netværk er indikatorfunktionen f(x) =, og sigmoidfunktionen f(x) = 1 1+e 1 for x > 1. Begge funktioner har den egenskab, at de begrænser x outputtet til intervallet [0, 1], hvilket ser ud til at være standarden for værdier i neurale netværk. Der er flere slags prototyper for, hvordan et neuralt netværk opbygges. Det vi kommer til at se på i dette speciale, er multilayer feedforward network [2] eller blot layered network. Her er netværket opdelt i lag af neuroner. Alle neuroner i et lag har i denne model en udgående forbindelse til alle neuroner i det næste lag. Det første lag kaldes inputlaget, det sidste lag kaldes outputlaget og alle lag imellem input- og outputlaget kaldes skjulte lag. Når man giver et input til et neuralt netværk, vil hele netværket have et output, som er den samlede mængde af outputs fra neuroner i outputlaget. Man 4
Figur 1.1: Et neuron kan tænke på et neuralt netværk som en funktion, der prøver at approksimere en mere kompleks funktion. Som eksempel kan nævnes et neuralt netværk, der tager en backgammonstilling som input og som output approksimerer hvor stor chance den ene spiller har for at vinde. Brugen af en ikke-lineær funktion på outputtet af hvert neuron, som f.eks. sigmoid-funktionen beskrevet ovenfor, gør at outputtet af hele netværket kan være en ikke-lineær kombination af dets inputs. Som beskrevet i artiklen Multilayer feedforward networks are universal approximators [2], kan man med et multilayer-netværk med et tilstrækkeligt antal skjulte neuroner approksimere en vilkårlig funktion til vilkårlig nøjagtighed. Det er altså i princippet muligt at skabe en perfekt backgammonspiller på denne måde. Indlæringsprocessen af et neuralt netværk foregår ved, at man indstiller vægtene i netværket, så netværket giver en bedre approksimation. Der er mange måder, hvorpå man kan ændre vægtene. Vi vil i dette speciale eksperimentere med de tre kendte metoder backpropagation[3], temporal difference learning [6] og mutation [4]. 1.2 Introduktion til TD-Gammon Gerald Tesauros TD-Gammon [10] er et program, der ved hjælp af et neuralt netværk kan lære at spille backgammon. TD står for Temporal Difference Learning som beskrevet af Richard Sutton i artiklen Learning to Predict by the Methods of Temporal Differences [6]. Det der er helt specielt ved TD-Gammon er, at den lærte at spille backgammon på højt plan uden på forhånd at kende nog- 5
le af de strategier, som mennesket har udviklet gennem tiderne. TD-Gammon starter simpelthen bare med et neuralt netværk med tilfældige vægte og dermed en tilfældig strategi. Den seneste version af TD-Gammon, version 3.0, spiller på niveau med topeliten af mennesker [7]. TD-Gammon har flere gange forbløffet backgammon-verdenen ved at foreslå træk i backgammon, som indtil da ikke var anset som de optimale træk, men som efter mange simulationer og diskussioner blev den nye spillestil. TD-Gammon har altså ikke kun spillet lige op med mestrene, den har også kunnet lære dem noget. Jeg vil i specialet forsøge at efterligne en mere simpel udgave af TD-Gammon som er dens version 0.0. Denne version er så vidt vi ved udelukkende bygget op om et neuralt netværk. Der er altså ikke sat ekstra funktioner på, såsom at kunne se flere træk frem. 1.3 Introduktion til backgammon Backgammon er et spil med forholdsvis få og simple regler, men samtidig et spil, der er så komplekst at verdensmestrene i spillet nogle gange ændrer opfattelse af, hvad der er korrekt spil. Her opsummeres ganske kort og i få detaljer hvordan backgammon spilles: Backgammon er et spil for to spillere. Hver spiller har 15 brikker fordelt på 24 felter, nummereret 1 til 24. Felterne kan opfattes som værende på én lang række efter hinanden, selv om de normalt er opstillet som på billedet på figur 1.2. På billedet er de sorte og hvide trekanter de normale 24 felter med felt nummer 1 i nederste højre hjørne, felt 12 i nederste venstre hjørne, felt 13 i øverste venstre hjørne og felt 24 i øverste højre hjørne. Grøn rykker mod øverste højre hjørne, rød rykker mod nederste højre hjørne, og brættet hænger sammen i venstre side. Spillerne skiftes til at slå med to terninger og rykke deres brikker. Den ene spiller rykker i retning mod felt 1, mens den anden spiller rykker mod felt 24. Formålet med spillet er at være den første til at få alle brikker til sin egen ende af brættet, for derefter at tage dem af brættet. Hvis en brik står alene på et felt kan den slås hjem af modspilleren, hvis han flytter en af sine brikker til dette felt. Når en brik slås hjem, flyttes den til det specielle felt fængslet, og skal flyttes ud af fængslet før spilleren må flytte nogle af de andre brikker. En brik der flyttes ud af fængslet lander i modstanderens hjemme-område. Altså længst fra, hvor spilleren skal have sine brikker hen. Hvis man vinder i backgammon, får man 1, 2 eller 3 point. 3 point, kaldet backgammon, gives hvis modstanderen stadig har brikker i ens eget hjemmeområde eller i fængsel. Dette sker yderst sjældent blandt gode spillere. 2 point, gammon, gives, hvis modstanderen endnu ikke har rykket brikker af brættet, og 1 point gives i alle andre tilfælde. Der er i backgammon desuden en double-terning. Denne bruges til at fordoble indsatsen nul eller flere gange i løbet af spillet. I eksperimenterne udført i dette speciale vil vi spille uden denne double-terning, da det er en videnskab i sig selv, 6
(a) Billedet er lavet i Blender, et opensource 3D-modellerings- og renderingsprogram. Figur 1.2: Et backgammonbræt. hvornår man skal tilbyde og acceptere doubling. Vi har altså udeladt den for at holde det så simpelt som muligt og fokusere på selve indlæringen. For en fuldstændig beskrivelse af reglerne for backgammon henvises til dette website [1]. Backgammon er et spil, der er velegnet til dette speciale af flere årsager. Spillet er simpelt og komplekst, forstået på den måde at det er simpelt at beskrive for en computer, hvilke træk der er lovlige, men det er komplekst at afgøre, hvilket træk der er det bedste. Det er nemt at afgøre, hvilken af flere kunstige intelligenser til spillet, der er den bedste ved at lade dem spille mange spil mod hinanden. Spillet er probabilistisk, hvilket gør at et neuralt netværk, der spiller mod sig selv i en indlæringsproces får set mange forskellige brætstillinger. Dette er vigtigt, da indlæringen derved ikke bliver låst fast i de samme træk. Hvis spillet ikke er probabilistisk, ville man muligvis blive nødt til at tvinge den kunstige intelligens til at eksperimentere lidt med forskellige ryk, som den ikke opfatter som optimale ryk. 1.4 Formålet med dette speciale Som beskrevet i starten af dette kapitel er formålet med dette speciale at sammenligne kendte indlæringsmetoder: 7
Formålet med dette speciale er at implementere og sammenligne de tre indlæringsmetoder mutation, backpropagation og temporaldifference learning på den type problemer, hvor udfaldet først er kendt efter en serie af observationer. Som praktisk eksempel bruges backgammon. Vi vil desuden genskabe det matematiske grundlag for backpropagation og temporal difference learning. Jeg vil lægge mest vægt på Suttons metode temporal difference learning [6] som Tesauro bruger i TD-Gammon, da metoden er skræddersyet til denne type af problemer. De to andre metoder kan ses som sammenligningsgrundlag. Tesauro beskriver i artiklen om TD-Gammon [10] den overordnede strategi for hvordan og hvorfor TD-Gammon virker og i en anden artikel [8] beskriver han de generelle praktiske detaljer for temporal difference learning. Dog skriver han ikke noget sted om alle detaljer af selve TD-Gammon, så det er ikke trivielt at genskabe hans program. TD-Gammon har udviklet sig fra version 0.0 til version 3.0 på følgende måde: 0.0 Det neurale netværk får som input den rå brætstilling og intet andet. 1.0 Det neurale netværk får, udover den rå brætstilling, nogle strategiske inputs såsom om brikkerne har passeret hinanden, så det ikke længere er muligt at slå hinanden hjem. 2.0 TD-Gammon ser 2 træk frem. 2.1 Det neurale netværk udvides med flere skjulte neuroner. 3.0 Det neurale netværk udvides igen og TD-Gammon ser nu 3 træk frem. For hver ny version blev TD-gammon tydeligt bedre til at spille backgammon [7]. Vi vil i dette speciale implementere TD-Gammon 0.0. 1.5 Termer Der vil i løbet af rapporten blive brugt termer fra backgammon, som alle måske ikke kender. Her er en komplet liste over alle backgammonrelaterede ord i rapporten: Backgammon Udover at spillet hedder backgammon, så kaldes det også backgammon, når en spiller vinder med 3 point. Se afsnit 1.3 Blokade Når en spiller har mindst to brikker på et felt kaldes det en blokade, da modspilleren ikke kan rykke hen til det felt. Brik Hver spiller har 15 brikker, som de kan flytte med. Målet i spillet er at tage alle brikker af brættet. Bræt Brættet er den spilleplade, der spilles på. Et bræt består af 24 felter samt to specielle felter kaldet fængsel og hjem. 8
Double-terning Man kan udfordre modspilleren til at spille om det dobbelte antal point ved at benytte double-terningen. Hvis modstanderen afviser, så vinder man automatisk 1 point gange med, hvad double-terningen stod på før. I implementeringen vil vi, for at holde det simplere, ikke bruge double-terningen. Fængsel Fængsel er et specielt felt. Brikker der slås hjem af modstanderen bliver flyttet til fængsel. Gammon Hvis man vinder med 2 point, kaldes dette gammon. Se afsnit 1.3. Hjem Hjem er et specielt felt, hvor brikker der tages af brættet rykker hen. Disse brikker er ikke længere i spil. Når en spiller har alle brikker på hjem-feltet, har han vundet. PPG Points Per Game er en målestok for, hvor god en spiller A er mod en spiller B over flere spil. PPG for A udregnes som differensen mellem A s og B s point delt med antal spil. PPG er altså positiv, hvis man har vundet flere point end modstanderen og negativ, hvis man har tabt flest. I denne rapport bruger vi PPG til at sammenligne spillere. Race-situation Et spil betegnes som værende i race-situation, hvis den ene spillers brikker alle er rykket forbi modspillerens brikker. Der er i så fald ikke længere mulighed for at slå modstanderen hjem, så begge spillere racer mod hjem-feltet uden at skulle tænke på blokader og andre strategier. Runde En runde består af at en spiller kaster med sine terninger og rykker sine brikker. En runde slutter enten hvis spilleren har brugt alle sine træk i henhold til terningerne, eller hvis der ikke findes flere legale træk. Hvis man spiller med double-terningen, kan en spiller vælge at bruge denne, før der slås med terningerne. 1.6 Opbygning af specialet Her er en kort beskrivelse af hver af de resterende kapitler i specialet. Kapitel 2, Temporal Difference Learning beskriver teorien og metoderne i TD. TD er en udvidelse af backpropagation, så backpropagation beskrives først. Til sidst beskriver vi de ideer, der ligger til grundlag for Mutation Kapitel 3, Framework beskriver det framework, der bruges i projektet til at udvikle og teste de neurale netværk. Kapitel 4, Træning beskriver de træningsmetoder, der er brugt. Kapitel 5, Eksperimenter viser resultaterne af træningen. Kapitel 6, Konklusion. Afsluttende konklusion. 9
Kapitel 7, Kørsel. Vejledning i hvordan læseren kan spille mod den bedste spiller udviklet i projektet. 10
Kapitel 2 Temporal Difference Learning I dette kapitel gøres rede for hvordan TD matematisk fungerer. Jeg tager udgangspunkt i backpropagation og går over i TD, da TD kan ses som en udvidelse eller en udvikling af backpropagation. Dette er altså et rent teoretisk kapitel. Til sidst i kapitlet er nogle få kommentarer til Mutation-metoden. 2.1 Multilayer feedforward-netværk I dette afsnit beskriver jeg termerne i et almindeligt multilayer feedforwardnetværk, herefter blot betegnet som netværk. Netværket kan ses som en orienteret graf med vægtede kanter. Hvert neuron i netværket er en knude i grafen. Netværket består af flere lag af neuroner; et inputlag, nul eller flere skjulte lag og et outputlag. Mængden af neuroner i inputlaget betegnes I og mængden af neuroner i outputlaget betegnes O. Alle neuroner i inputlaget og de skjulte lag har en kant til alle neuroner i det næste lag. Vægten på kanten mellem neuron j og neuron i betegnes w ji. Netværket får som input en vektor x og giver som output en vektor y. Alle neuroner j i netværket har et output o j. For neuronerne i inputlaget gælder det, at outputtet er lig det tilsvarende input til netværket. For alle andre neuroner gælder j / Input : o j = sig (z j ) hvor sig er sigmoidfunktionen sig(x) = 1 1+e og z x j = i fi(j) w ijo i er den vægtede sum af alle inputs til neuronet. Her er fi(j), fan-in, mængden af neuroner i laget før j, altså dem der har en kant til j. Mængden af neuroner i næste lag kaldes f o(j), fan-out. Sigmoidfunktionen har denne egenskab for dens afledede: sig(x) x = sig(x)(1 sig(x)), hvilket vi kommer til at bruge i beregningerne i dette kapitel. Outputtet af netværket er den samlede mængde af outputs fra neuroner i outputlaget. 11
2.2 Backpropagation Backpropagation [3] er en metode til at justere vægtene i et neuralt netværk, således at outputtet y af et bestemt input nærmer sig en ønsket værdi q. Et klassisk eksempel er, at man vil bruge et neuralt netværk til at genkende bogstaver i et billede. Billedet af bogstavet bliver kodet til nogle inputværdier, og netværket giver en outputværdi. Hvis denne outputværdi ikke stemmer overens med den ønskede outputværdi, altså det rigtige bogstav, så justerer man vægtene i netværket ved at propagere fejlen tilbage til alle neuroner i netværket. Denne metode har vist sig meget effektiv til mange virkelige problemer. Her følger den matematiske baggrund for backpropagation-algoritmen. Fejlen i outputværdien betegnes E, og vi vil gerne bruge denne til at beregne den værdi vi skal justere vægtene med w ij for alle vægte i netværket. w ij er E propertional til w ij [5], så vi kan skrive: w ij = α E w ij, α > 0 hvor α er en konstant, også kaldet indlæringsraten. Da z j er en funktion af w ij kan vi bruge kædereglen: w ij = α E w ij = α E z j = α E z j = α E z j o i z j w ij w ij k fi(j) w kj o k Bemærk at E z j kun er afhængig af, hvilket neuron vi kigger på, ikke af hvilken vægt, vi opdaterer. Vi definerer derfor δ j = E z j, så vi får w ij = αδ j o i Vi skal altså nu beregne δ j for alle neuroner i netværket. Vi starter med neuronerne i outputlaget. Fejlen kan beregnes som E = 1 (q k o k ) 2 2 k O Da o k for alle k j er uafhængig af w ij kan vi udelade disse i summen og kun kigge på k = j 12
δ j = E z j = z j 1 2 (q j o j ) 2 = o j 1 2 (q j o j ) 2 o j z j = (q j o j ) o j z j = (q j o j ) sig(z j) z j = (q j o j )(1 sig(z j ))sig(z j ) = (q j o j )(1 o j )o j Alle disse værdier er kendte, så vi er nu færdige med at beregne δ j for neuronerne i outputlaget. Nu til neuronerne i de skjulte lag. For disse kan vi ikke bruge q, da denne på en anden måde. Da E er en funktion af z k for alle k fo(j) og disse z k alle er en funktion af z j kan vi bruge kædereglen således skal sammenlignes med outputtet af netværket, så vi må finde δ j = E z j δ j = E z j = k fo(j) E z k z k z j Vi bemærker, at o j er en funktion af z j og bruger kædereglen igen δ j = k fo(j) Disse tre led kan udregnes hver især: E z k z k z j = k fo(j) E z k z k o j o j z j E = δ k pr. definition z k z k = w ik o i = w jk o j o j i fi(k) o j = sig(z j) = sig(z j ) (1 sig(z j )) = o j (1 o j ) z j z j Ved at indsætte disse får vi: δ j = k fo(j) E z k z k o j o j z j 13
= k fo(j) = o j (1 o j ) δ k w jk o j (1 o j ) k fo(j) δ k w jk Hvis vi beregner δ j baglæns i netværket, altså starter med outputlaget og derefter de skjulte lag i rækkefølge fra sidste til første, så kender vi også alle værdierne i denne formel, da vi skal bruge δ k hvor k fo(j). Vi kan altså nu beregne δ j for alle neuroner og dermed w ij for alle vægte. 2.2.1 Algortitme for backpropagation Med de beskrevne metoder til at udregne w er vi nu parate til at stille en algoritme op for backpropagation, givet at vi kender den ønskede værdi q: 1. Aktivér neuronerne i inputlaget med det givne input til netværket. o j sættes for disse neuroner til det tilsvarende input. ( ) 2. Udregn o j = sig i fi(j) w ijo i for alle neuroner i de resterende lag i rækkefølge fra første skjulte lag til outputlaget. 3. Udregn δ j = o j (1 o j )(q j o j ) for alle neuroner i outputlaget. 4. Udregn δ j = o j (1 o j ) k fo(j) δ kw jk for alle neuroner i de resterende lag i rækkefølge fra sidste skjulte lag til første skjulte lag. Der skal ikke udregnes δ for neuroner i inputlaget, da disse ikke har indgående forbindelser og altså ingen vægte at justere. 5. Juster alle vægte w ij med w ij = αδ j o i Dette er altså den kendte metode til at opdatere vægtene i et neuralt netværk. Men hvordan bruger vi dette til at træne et neuralt netværk i at spille backgammon? 2.2.2 Algoritme for træning Vi bruger netværket som evalueringsfunktion for en given brætstilling. Brætstillingen kodes til input til netværket og outputtet tolkes på en måde, så man kan afgøre, hvilken af to brætstillinger der er bedst. På den måde kan man med et givent terningeslag vurdere alle lovlige træk og vælge det bedste. Outputtet kunne f.eks. tolkes som hvids chance for at vinde. På den måde vil spiller hvid vælge den største værdi og spiller sort vælge den laveste værdi. For at bruge backpropagationalgoritmen til at opdatere vægtene har vi brug for et træningssæt bestående af mange par af observationer og ønskede ouputs. Vi har en masse observationer, brætstillingerne, men vi kender kun det ønskede output for den sidste brætstilling i hvert spil, da vi der kender udfaldet af 14
spillet. Hvad hvis vi bruger dette ønskede output som ønsket output for alle observationer gennem spillet? For at tænke over dette så lad en brætstilling være givet hvor spillet er helt lige. Med denne brætstilling som udgangspunkt, vinder den ene spiller halvdelen af gangene, og den anden spiller vinder halvdelen af gangene. Når vi justerer netværket med denne brætstilling som input, justerer vi altså mod den enes sejr halvdelen af gangene og mod den andens sejr resten af gangene. Intuitivt burde det gå lige op, og netværket vil forhåbentligt til sidst give et output der indikerer en helt lige stilling. Vi mener derfor det er rimeligt at bruge det endelige resultat af et spil som ønsket output for alle brætstillinger gennem spillet. Træningsmetoden for backpropagation er derfor således: 1. Initialisér et netværk med tilfældige vægte 2. Start et backgammonspil 3. For hvert terningekast bestemmes alle lovlige træk, og det bedste bliver valgt ved at bruge netværket som evalueringsfunktion 4. Den valgte nye brætstilling gemmes i en liste med alle brætstillinger i spillet 5. Når spillet er slut, defineres q 6. For hver gemt brætstilling køres backpropagationalgoritmen med q som ønsket output 7. Gå til 2. 2.3 Temporal difference learning Problemstillingen fra backpropagation i afsnit 2.2 om at bruge det endelige resultat som ønsket output for alle brætstillinger fører til temporal difference learning også kaldet TD(λ)-algoritmen. TD(λ) tildeler hver observation en vigtighedsgrad sådan at de observationer der findes tidligt i sekvensen ikke er med til at ændre netværket så meget som observationer sidst i sekvensen. På den måde vil de sene brætstillinger, hvor udfaldet er næsten sikkert have stor indflydelse og de tidlige brætstillinger, hvor udfaldet ofte er mere åbent have lille indflydelse. Dette passer godt sammen med, at de tidlige brætstillinger justeres i flere retninger, som beskrevet ovenfor. Vi beskriver TD-algoritmen i to skridt: Først beskrives specialtilfældet TD(1) og dernæst udvider vi til den mere generelle TD(λ). 15
2.3.1 TD(1) Vi laver lidt om i variabelnavnene i forhold til sidste afsnit, da vi nu har at gøre med en ordnet liste af observationer eller brætstillinger: Sekvensen af observationer hedder x 1, x 2, x 3,..., x m. Outputtet af netværket for x t kaldes y t. Vægtene i netværket til tid t kaldes w t ij Outputtet af neuron j til tid t kaldes o t j På samme måde tilføjes et tids-indeks til alle de resterende variable. Vi starter med at udregne wij t på en lidt anden måde end ved backpropagation. Vi bruger igen at w t ij = α Et w t ij Fejlen E t afhænger af alle outputs fra neuronerne i outputlaget og disse afhænger hver især af w ij, så vi bruger kædereglen således: Fejlen udregnes igen som w t ij = α Et w t ij Denne indsættes i udregningen: E t = 1 2 w t ij = α k O = α k O = α k Outputs ( qk o t 2 k) k O E t o t k o t k o t k wij t 1 2 k O E t o t k o t k wij t ( qk o t k ) 2 o t k w t ij Da (q k o t k )2 kun er afhængig af de o t k hvor k = k kan vi udelade k -summen og kun beregne den for o t k : w t ij = α k O = α k O o t k o t k 1 2 1 2 k O ( qk o t k = α k O(q k o t k) ot k w t ij ( qk o t k ) 2 o t k w t ij ) 2 o t k w t ij 16
Idet vi definerer o m+1 k til at være q k kan vi lave følgende substitution: q k o t k = som indsættes i formlen for w t ij : m n=t ( o n+1 k o n ) k wij t = α k O(q k o t k) ot k wij t m = α k O n=t ( o n+1 k o n ) o t k k wij t Den samlede ændring i vægt w ij over alle observationer kan udregnes som summen af alle w t ij : w ij = m t=1 w t ij m m ( = α o n+1 k = α = = t=1 k O n=t m n n=1 t=1 k O m ( o n+1 k α n=1 k O m α ( o t+1 k t=1 k O ( o n+1 k o n ) o t k k wij t o n ) o t k k wij t o n ) n k t=1 o t ) t k p=1 o t k wij t o p k w p ij Vi kan nu regne tilbage til w t ij ved at fjerne den yderste sum: w t ij = α k O ( o t+1 k Bemærk to ting ved denne formel for w t ij : o t ) t k p=1 o p k w p ij 1. Den er udregnet efter de samme antagelser som den ved backpropagation. Denne metode gør altså præcis det samme. 2. Kun ved t = m, altså ved det sidste skridt, skal vi bruge q for at beregne wij t. Vi kan altså ændre vægtene i netværket for hver ny brætstilling i spillet og få samme resultat som ved backpropagation, hvor vi skal gemme 17
alle brætstillingerne og ændre vægtene til sidst. Bemærk at vi med denne metode stadig skal gemme information fra en observation til den næste, men vi skal ikke længere gemme en liste af observationer. Vi skal se senere i dette afsnit, hvordan den gemte information kan opdateres løbende. Man kan sige at summen t p=1 de tidligere inputs til netværket. o p k w p ij fra formlen husker, hvad der skal gøres ved 2.3.2 TD(λ) Det specielle ved TD(λ)-algoritmen er, at den kan vægte vigtigheden af en observation i forhold til, hvornår den skete. I TD(1) i forrige afsnit bliver netværket ændret lige meget for hver observation. Med TD(λ) vægter vi observationerne eksponentielt, sådan at observationer der er k gamle kun bliver vægtet λ k for 0 λ 1: w t ij = α k O ( o t+1 k o t ) t k p=1 λ t p op k w p ij Bemærk at for λ = 1 får vi samme formel som ved TD(1), deraf navngivningen. Vi vil nu udregne alle de størrelser, der skal til for at kunne beregne wij t. Vi definerer en ny variabel e t ijk til at være så vi kan udtrykke w t ij som e t ijk = t p=1 w t ij = α k O λ t p op k w p ij ( o t+1 k o t k) e t ijk Vi ønsker at udregne e t ijk e t+1 ijk = løbende, så vi udregner her et+1 ijk t+1 λ t+1 p op k w p ij p=1 = ot+1 k w t+1 ij + t p=1 λ t+1 p op k w p ij = ot+1 k w t+1 + λe t ijk ij = ot+1 z t+1 k j z t+1 j w t+1 + λe t ijk ij = ot+1 k z t+1 j o t+1 i 18 + λe t ijk ved hjælp af et ijk
hvor vi definerer δ jk = ot k z t j så vi får e t+1 ijk = λet ijk + δ t+1 jk ot+1 i Vi skal altså nu udregne δik t for alle neuroner i for alle outputneuroner k. Bemærk at δik t ikke er den samme variabel som δ j i backpropagation. Vi deler op i 3 tilfælde: Hvis i O og i k: δ t ik = ot k z t i Hvis i O og i = k = 0, da z t i ikke har indflydelse på o t k δ t ik = ot k z t i = ot k z t k = o k (1 o k ) Hvis i er et neuron i de skjulte lag, bruger vi kædereglen for at komme frem til nogle størrelser, vi kender. Dette minder meget om nogle af udregningerne i backpropagation. δ t ik = ot k = = = z t i j F O(i) j F O(i) j F O(i) = o t i(1 o t i) o t z k j t zj t zi t o t z k j t yi t zj t yi t zi t δ t jkw t ijo t i(1 o t i) j F O(i) δ t jkw t ij Vi kan altså nu beregne alle de størrelser, der skal til for at ændre vægtene vha. TD(λ)-algoritmen. 19
2.3.3 Algoritme for TD(λ) 1. Aktivér neuronerne i inputlaget med det givne input til netværket. o j sættes for disse neuroner til inputtet. ( ) 2. Udregn o t j = sig i fi(j) wt ij ot i for alle neuroner i de resterende lag i rækkefølge fra første skjulte lag til outputlaget. 3. Udregn δjk t = ot j (1 ot j ) for alle neuroner i outputlaget hvor j = k. De restrende δjk t i outputlaget sættes til 0. 4. Udregn δ t ik = ot i (1 ot i ) j fo(i) δ jkw ij for alle neuroner i de resterende lag i rækkefølge fra sidste skjulte lag til første skjulte lag. 5. Udregn e t ijk = λet 1 k ijk +δt jk ot i 6. Juster alle vægte w t ij med wt ij = α k O for alle forbindelser ij for alle outputneuroner ( o t+1 k o t k) e t ijk Træningsalgoritmen er den samme som for backpropagation, på nær at man justerer vægtene ved hver ny brætstilling. 2.4 Evolution med mutation Inspireret af artiklen Co-Evolution in the Successful Learning of Backgammon Strategy[4] af Pollack og Blair er den tredje indlæringsmetode, vi vil implementere, simpel mutation. Dette skal forstås som et sammenligningsgrundlag, for at se om det er TD-algoritmen, der virker godt eller, som Pollack og Blair antyder, at det er nogle specielle spilmæssige ting i backgammon der gør, at det virker. Pollack og Blair tester denne hypotese ved at træne et neuralt netværk i backgammon ved hjælp af simpel mutation. De starter med en mester som har alle vægte sat til nul. Denne mester mutereres lidt og mutanten spiller et antal spil mod mesteren. Hvis mutanten vinder, justeres mesteren i retning af mutanten. Pollack og Blair mener at have vist deres hypotese med de resultater, de kommer frem til. Vi vil forsøge at skabe en god backgammonspiller ved hjælp af nogle af de samme ideer som Pollack og Blair, dog med lidt forskelle: Pollack og Blair lader mesteren spille et antal spil mod mutanten. Hvis mutanten vinder mere end halvdelen af spillene, justeres mesteren i retning af mutanten. Dette mener vi er en forkert fremgangsmåde, da det i backgammon ikke gælder om at vinde flest spil, men at vinde flest point. Vi vil derfor lade pointene tælle frem for antal vundne spil. Pollack og Blair muterer mesteren med gaussisk støj af fast størrelse til trods for, at vægtenes absolutte størrelse ændres. Vi vil normalisere vægtene efter hver ændring af mesteren, sådan at alle vægte er i intervallet [ 1; 1]. Dette sikrer, at en tidlig justering ændrer netværket lige så meget som en sen justering. Vi normaliserer dog kun, hvis mindst én vægts absolutte værdi er større end 1, da de tidlige ændringer i netværket ellers ville få meget stor indflydelse. 20
Kapitel 3 Framework Til dette projekt har vi brug for et framework, hvor computerspillere kan kobles til og spille mod hinanden, og hvor et menneske kan spille mod en computerspiller. At computerspillere skal kunne spille mod hinanden er åbenlyst, da vi derved kan træne dem samt teste, hvor gode de er i forhold til hinanden. At et menneske skal kunne spille mod en computerspiller er ikke nødvendigt for projektet, men giver blot en god ide om, hvilke taktikker spilleren har udviklet. Dette er altså ikke særlig videnskabeligt, men giver måske nogle hints til, hvad der er godt og skidt i udviklingen af en spiller. Vi har til formålet udviklet frameworket PulverGammon. Læseren kan afprøve PulverGammon som kan hentes i en jar-fil. Se mere om dette i kapitel 7. 3.1 Klasser i Pulvergammon På figur 3.1 ses klassediagrammet for PulverGammon. Det er designet til, at man nemt kan skrive nye spillere og sætte dem ind. 3.1.1 Pakken player Pakken player indeholder klasser der repræsenterer backgammonspillere. Alle klasser i pakken implementerer interfacet Player. Der findes i PulverGammon to typer spillere; computer- og menneskespillere. Menneskespillere er repræsenteret i klassen HumanPlayer og computerspillere er repræsenteret i den abstrakte klasse AIPlayer. Når man skriver en ny computerspiller, skal den altså udvide AIPlayer. Alle computerspillere fungerer ved, at de ud fra terningerne finder alle de mulige backgammonstillinger, man kan flytte til. Den vurderer så hver af disse stillinger med metoden score og vælger den bedst mulige stilling at flytte til. Hvis flere stillinger deles om førstepladsen, tager den en af disse tilfældigt. En computerspiller er altså blot repræsenteret ved metoden score. 21
Figur 3.1: Klassediagram for PulverGammon Der er allerede implementeret nogle computerspillere, som kan bruges til at sammenligne med de tre neurale netværk, vi vil implementere i projektet: Pubeval er en Java-implementering af Tesaurus Pubeval [9]. Tesauro beskrver Pubeval som en god middelklasse-spiller. Pubeval er udviklet netop for at folk, der skriver kunstige intelligenser til backgammon, kan sammenligne med Pubeval. RandomAI returnerer altid 0 i metoden score. Dette bevirker, at alle stillinger deles om førstepladsen, og der vælges en tilfældig af disse. Simple_001 har kun én taktik; at få så mange blokader som muligt. Det er velkendt i simpel backgammonstrategi, at det ofte er bedre at have blokader end frie brikker, da det både gør, at man ikke kan slås hjem og at modstanderen ikke kan rykke til feltet med blokaden. Simple_002 er en udvidelse af den forrige ved, at den også fokuserer på at blokaderne er i sammenhæng med hinanden. Dette gør det sværere for modstanderen at komme forbi blokaderne. Simple_003 gør det samme som toeren, men har en anden taktik i slutspillet, når det ikke længere er muligt at slå hjem. Her er det ikke længere nødvendigt at have blokader. I stedet skal man fokusere på at få brikkerne af brættet hutigst muligt. 22
PPG over 10.000 spil RndAI Simple Pubeval RandomAI - -1,57-2,50 Simple_003 1,57 - -1,37 Pubeval 2,50 1,37 - Tabel 3.1: Sammenligning af de tre spillere i PulverGammon De tre simple-spillere er ikke så forskellige i spilleevne, dog er det klart, at Simple_003 klarer sig bedst. Jeg vil derfor kun bruge denne samt RandomAI og Pubeval til at sammenligne med. På tabel 3.1 ses en sammenligning af disse tre. Som målestok bruger jeg PPG, Points Per Game, der normalt bruges til at sammenligne spillere i backgammonverdenen. Man er tydeligt bedre end en anden spiller, hvis man kan vinde med mindst ca. 0,2 PPG. Det ses af tabellen, at der er kæmpe forskel på de tre spillere. Simple_003 vinder stort over RandomAI, og Pubeval vinder stort over Simple_003. Forskellen mellem spillerne gør dem til udmærkede sammenligningsgrundlag i dette speciale. 3.1.2 Pakken model Pakken model indeholder de klasser, der repræsenterer selve backgammonspillet, som f.eks. brættet og terningerne. BoardModel repræsenterer backgammonbrættet. Denne klasse har metoder til at flytte brikker og evaluerer om træk er lovlige. DiceModel repræsenterer to terninger. Denne klasse bruger en pseudorandom Java-generator til at kaste terningerne. Game repræsenterer, som navnet antyder, et spil backgammon. Et spil består af et bræt, nogle terninger og to spillere. Game har en metode play, som udfører et helt spil med de to spillere. GameListener er et interface, der gør det muligt for klasser at registrere sig som listener på et spil. Dette er både brugt af den grafiske brugerflade, som skal have opdateringer og af HumanPlayer, der skal vide, hvornår turen er slut. Beskeder om opdateringer af spiller sendes som GameState- ChangeEvent. 3.1.3 Pakken view Pakken view indeholder klasser, der grafisk viser et backgammonspil. Den er implementeret i javax.swing. Klassen GameGUI er hovedklassen i pakken. GameGUI udvider javax.swing.jframe og er således et vindue. I vinduet vises brættet, to par terninger og spillernavne på de to spillere. Vi bruger et lytterinterface mellem view og model, sådan at klasserne i view får besked fra model, hver gang der sker noget, der skal opdateres på brugergrænsefladen. 23
Figur 3.2: Skærmbillede af PulverGammon på Mac OS X BoardGUI gør det også muligt for en menneskespiller at bruge træk-og-slip på brikkerne for at rykke. På figur 3.2 ses et skærmbillede af PulverGammon. 24
Kapitel 4 Træning Der er stor forskel på, hvor gode de neurale spillere bliver alt efter, hvordan man træner dem. Vi har derfor brugt en blanding af egne eksperimenter og de tilgængelige artikler til at bestemme, hvorledes træningen skulle foregå. Det første man skal beslutte som træner er strukturen af netværket. Her betegner netværksstruktur både hvor mange neuroner der er i hvert lag af netværket samt hvordan input og output bliver kodet. Især kodningen af inputtet samt antallet af skjulte neuroner ser ud til at have stor indflydelse. 4.1 Netværksstruktur Vi bruger netværksstrukturen fra Tesuaros TD-Gammon 0.0, som består af 198 inputneuroner, 40 skjulte neuroner og 4 outputneuroner. En illustration af netværksstrukturen kan ses på figur 4.1. Inputtet bliver kodet således: For hver spiller bliver de 24 normale felter kodet med 4 inputs. Ialt 192 inputs: Første input sættes til 1 hvis der er mindst 1 brik af spillerens farve på feltet Andet input sættets til 1 hvis der er mindst 2 brikker af spillerens farve på feltet Tredje input sættes til 1 hvis der er mindst 3 brikker af spillerens farve på feltet Fjerde input sættes til (n 3)/2 hvis der er n 4 brikker af spillerens farve på feltet Hver spillers fængsel kodes med 1 input som sættes til n/2, hvor n er antal brikker, som spilleren har i fængsel. Ialt 2 inputs. 25
Figur 4.1: Et neuralt netværk med 198 inputneuroner, 40 skjulte neuroner og 4 outputneuroner Hver spillers hjem kodes med 1 input som sættes til n/15, hvor n er antal brikker, som spilleren har rykket hjem. Ialt 2 inputs. De sidste to inputs kodes som 01, hvis det er hvids tur til at kaste terningerne, og 10 hvis det er sorts tur. De 4 outputs af netværket tolkes således: Første output tolkes som chancen for, at hvid vinder Andet output tolkes som chancen for, at sort vinder Tredje output tolkes som chancen for, at hvid vinder med gammon eller backgammon Fjerde output tolkes som chancen for, at sort vinder med gammon eller backgammon 4.1.1 Kommentarer til netværksstrukturen Der er nogle interessante ting at bemærke ved Tesuaros netværksstruktur. Hvis vi først kigger på, hvordan inputtet kodes, bemærkes det, at der ikke gives nogle strategiske inputs overhovedet. Kun den rå brætstilling er repræsenteret. Dette er vigtigt for projektet, da det er meningen, at de neurale netværk skal trænes uden anden hjælp end selve træningen. Vi ser også, at Tesauro har normaliseret inputværdierne til mellem 0 og 1, hvilket også er det interval, outputtet af hver neuron ligger i. Det ser ud til at være standard i neurale netværk, at man 26
forsøger at holde inputværdierne mellem 0 og 1. Dette er, så vidt vi ved, blot en formalitet. Hvis vi kigger på det skjulte lag, bemærker vi først, at der kun er ét skjult lag. Man kunne godt forestille sig, at det måske ville give en større spillestyrke at have flere skjulte lag. Tesauro valgte i TD-Gammon 0.0 at have 40 skjulte neuroner. Han har dog vist, at med flere skjulte neuroner kan man lave stærkere spillere [8]. Et netværk med 80 skjulte neuroner viste sig at klare sig bedre end det samme netværk bare med færre neuroner. Outputtet virker måske lidt ulogisk. Der er et output, der angiver chancen for at hvid vinder og et andet output, der angiver chancen for, at sort vinder. Ville man ikke bare kunne nøjes med den ene og så udregne den anden? Jo, det ville man kunne. Tesauro har måske bygget outputtet på denne måde for at have et bedre grundlag for at studere vægtændringerne i netværket. Outputtet giver ikke mulighed for at skelne mellem gammon og backgammon. Tesauro forklarer dette ved at backgammon sker så sjældent, at det ikke er nødvendigt at kode det selvstændigt. 4.2 Evalueringsfunktion Med en given netværksstruktur skal vi finde en måde at udregne det tal, som metoden score skal returnere. Hvis der kun er ét output af netværket, og dette tolkes som hvids chance for at vinde, så er det trivielt at lave score. Med Tesauros struktur har vi fire outputs. Tesauro beskriver ikke, hvordan han laver sin evalueringsfunktion med disse outputs. De fire outputs var har er sandsynligheden for at hhv. hvid og sort vinder og sandsynligheden for at hhv. hvid og sort vinder med gammon. Vi kan udregne det forventede antal point for den ene spiller med disse sandsynligheder. Hvis vi i første omgang ser bort fra at man kan vinde med gammon, så er hvids forventede antal point lig Pr(hvid vinder) Pr(sort vinder) da man vinder 1 point når man vinder. Da det giver 2 point at vinde med gammon, altså 1 point mere, kan vi bruge denne formel for at udregne hvids forventede antal point: Pr(hvid vinder)+pr(hvid laver gammon) Pr(sort vinder) Pr(sort laver gammon) For at udregne sorts forventede antal point skifter man selvfølgelig bare fortegn. Vi har altså nu en fornufitg evalueringsfunktion med det givne netværk. 4.3 α-justering Vi har følgende parametre at skrue på: For backpropagation har vi α 27
For TD har vi α og λ For mutation har vi α og mutationsfaktoren Vi har valgt at fastholde λ = 0, 7 da det er den værdi Tesauro bruger. Mutationsfaktoren fastholder vi på 0, 05 da det er værdien brugt af Pollack og Blair. Derimod vil vi for alle tre algoritmer variere α. For alle algoritmerne kan α opfattes som indlæringsraten, altså hvor meget netværket justeres. En meget brugt metode er at starte med en høj α og gradvist mindske den, da netværket i starten skal indstilles groft og senere finindstilles. Der er dog en del valg, der skal foretages med denne metode: Hvad skal startværdien være? Hvornår skal α mindskes? Hvor meget skal α mindskes? I nogle af de tidlige eksperimenter forsøgte vi med forskellige værdier af α mellem 0, 05 og 0, 5. Resultatet blev for alle tre indlæringsmetoder at en lavere α gav en bedre backgammonspiller, men desværre mindskes hastigheden af indlæringen tilsvarende. Det vil derfor være oplagt at mindske α når netværket ikke kan lære mere med det nuværende α. Vi skal derfor teste, hvor meget netværket har lært det sidste stykke tid og mindske α hvis netværket ikke er blevet bedre. Vi kan ikke bare teste netværket mod en yngre udgave af sig selv, og hvis den taber så mindske α, da det netværk vi tester kan være uheldigt at være blevet dårligere, end de netværk umiddelbart før. Vi tager derfor et gennemsnit af sådanne tests. Vi gør dette ved for hvert 1000 spil at lade netværket spille mod det samme netværk, bare 25000 spil yngre. Disse to spiller 200 spil mod hinanden og der gemmes hvor mange points den gamle har flere end den unge. Hvis summen af 25 af sådanne point i træk er mindre end nul, så mindsker vi α. Vi starter med α = 0, 25, da det gennem vores tidlige eksperimenter ser ud til at være en tilpas høj indlæringsrate. Når vi mindsker α virker det passende at gøre α halvt så stor for hvert skridt. Af praktiske årsager vil vi dog gerne have at α er et pænt tal med ikke alt for mange decimaler, så vi har valgt at α følger denne udvikling i størrelse: 0,25-0,1-0,05-0,025-0,01-0,005-0,0025-0,001. Nu mangler der kun en problemstilling: Hvornår stopper træningen? Vi vil helst ikke stoppe træningen, hvis netværket bliver bedre, hvis vi ikke stopper. På den anden side vil vi ikke lade netværket træne i en uendelighed med håb om, at det bliver bedre. Vi vil derfor vurdere for hver træning, hvornår den skal stoppes ved bl.a. at teste den mod andre spillere. 28
Kapitel 5 Eksperimenter Vi gennemførte træningen med metoden beskrevet i sidste afsnit og gemte en kopi af de neurale netværk for hvert 1000 spil. Vi har derfor nu tre puljer af spillere, én for hver indlæringsmetode. De tre indlæringsmetoder brugte mellem 700.000 og 1.200.000 spil på at gennemføre træningen. TD-algoritmen brugte færrest spil og afsluttede træningen på lidt over 700.000 spil. Både Mutation og Backpropagation brugte over 1.100.000 spil inden træningen blev afsluttet. Det var forventet, at TD-algoritmen ville lære hurtigere end Backpropagation, pga. den måde Backpropagtion justerer netværket på. Vi vil i dette kapitel måle to faktorer ved træningen: Hvor gode er spillerne blevet, og hvor hurtigt gik det? Til slut i kapitlet lader vi den bedste spiller der er blevet udviklet i specialet spille mod eliten af danske backgammonspillere. 5.1 Hvor hurtigt gik det? For at måle hastigheden af indlæringen lader vi alle de netværk, der blev gemt for hvert 1000 spil spille mod hver af de tre benchmarks der blev beskrevet i afsnit 3.1.1, RandomAI, Simple_003 og Pubeval, og udregner Points Per Game, eller PPG. Hvert af de gemte netværk spiller 200 spil mod et benchmark og vi tager så gennemsnittet af 10 af sådanne 200 spil og tegner gennemsnittet ind i en graf. Grunden til at vi bruger gennemsnit er, at grafen ellers ville blive ulæselig med alt for store udsving. På figur 5.1 ses en graf for, hvor godt de tre netværk klarer sig mod RandomAI. Det ses, at alle tre meget tidligt vinder stort over RandomAI og ved alle tre glatter kurven ud ved ca. 2,5 PPG. Forskellen på de tre kurver ligger i, hvor mange spil der går, før kurven glatter ud. Ved Mutation går der ca. 200.000 spil, ved Backpropagation ca. 400.000 og ved TD er kurven glattet ud helt fra starten. Dette er faktisk mod vores forventninger, da vi havde regnet med at en metode som Backpropagation, der målrettet indordner sig, skulle klare sig bedre end mutation, som søger tilfældigt rundt. Dette viser Backpropagation-algoritmens 29
Figur 5.1: Test mod RandomAI svaghed i denne type problemer, hvor det forventede output først kommer efter mange observationer. Det var forventningen, at TD-algoritmen ville klare sig bedst, men slet ikke så mærkbart som dette. Testen mod Simple_003, som ses på figur 5.2, afslører Mutation-algoritmens svaghed i forhold til Backpropagation. Mutation lærer igen hurtigere i starten, men bliver overhalet af Backpropagation ved ca. 350.000 spil. Dette skyldes, at Mutation-algoritmen ikke bliver meget bedre end ved 350.000 spil mens Backpropagation slet ikke har nået toppen endnu. Igen er TD overlegen på indlæringstiden. Kurven for TD glatter igen ud allerede fra starten, hvor det først er ved ca. 600.000 spil for Mutation og Backpropagation. Testen mod Pubeval, som ses på figur 5.3, viser næsten samme resultat som testen mod Simple_003. Mutation er bedre end Backpropagation i starten, men bliver overhalet, da den ikke bliver bedre. TD er igen klart den hurtigste til at lære og har næsten nået den maksimale PPG mod Pubeval ved 200.000 spil. Mutation og Backpropagation når toppen ved hhv. 500.000 spil og 700.000 spil. Indlæringshastigheden for TD er altså som forventet større end Backpropagation. Det interessante er, at den også lærer hurtigere end Mutation, da vi ikke havde nogen forventninger om dette. Før eksperimenterne var det ikke klart, hvilken af TD og Mutation der ville lære hurtigst, da man sagtens kunne forestille sig at Mutation ikke bliver bedre end TD, men til gengæld når toppen meget hurtigt. Det er ligeledes interessant at Mutation lærer hurtigere end Backpropagation og faktisk er en bedre spiller de første mange spil. 30
Figur 5.2: Test mod Simple_003 Figur 5.3: Test mod Pubeval 31
Indlæringsmetode Mutation Backpropagation TD Bedste spiller ved 829.000 spil 823.000 spil 611.000 spil Tabel 5.1: Tidspunkt for bedste spiller. Den bedste spiller blev fundet gennem en vind-eller-forsvind-turnering. 5.2 Hvor gode er spillerne blevet? For at finde ud af hvor gode spillerne er blevet, skal vi først finde den bedste spiller for hver indlæringsmetode. Dvs. vi skal finde den bedste af alle de gemte kopier for hver metode. Derefter kan vi sammenligne de bedste spillere med hinanden. 5.2.1 Den bedste spiller Vi har for hver indlæringsmetode en pulje bestående af mellem 700 og 1.200 spillere, da vi vi trænede netværkene 700.000 til 1.200.000 spil og gemt en kopi for hvert 1000 spil. Som vi kan se på graferne i afsnit 5.1, er der forholdsvis store udsving i spilleevnen fra en spiller til den lige efter. Det er altså ikke nødvendigvis den ældste spiller der er den bedste. Vi har derfor brug for en metode til at afgøre hvilken af spillerne i en pulje der er den bedste. Den naive måde at finde den bedste spiller på er, at lade alle i puljen spille mange spil mod alle de andre. Den der vinder flest point er med stor sandsynlighed den bedste spiller. Dette ville dog kræve alt for mange spil og for meget tid. Lad os antage at der er 1.000 spillere i puljen og hver af dem spiller 1.000 spil mod hver af de andre. Dette kræver ca. 500.000.000 spil. En hurtig computer kan med det givne framework spille et spil på ca. 40 ms. Hvis man ganger ud, får man at det tager over et halvt år! Vi bliver nødt til at finde en anden metode at finde den bedste spiller på. Vi laver en vind-eller-forsvind-turnering, hvor alle spiller mod hinanden parvist. Når en spiller er bagud med 50 point, ryger den ud af turneringen. Når alle har spillet første runde, begynder den næste og puljen bliver igen halveret. Således fortsætter vi indtil der kun er én spiller tilbage. Det er vores vurdering at det i gennemsnit tager 200 spil før den ene er bagud med 50 point. Med denne type turnering reducerer vi altså antallet af spil til ca. 200.000 hvilket svarer til 2-3 timer på en hurtig computer. Den spiller der bliver valgt som den bedste spiller er stadig med stor sandsynlighed blandt de bedste i puljen. Hvis den ikke er blandt de bedste, så skal den være heldig gennem ca. 2.000 spil, hvilket er meget usandsynligt. Vi mener dette er en fornuftig og hurtig metode til at finde den bedste spiller i hver pulje. På figur 5.1 ses en tabel for hvilke spillere der blev valgt som den bedste spiller for hver indlæringsmetode. 32
5.2.2 Sammenligning af alle spillerne Vi har nu at gøre med seks spillere vi vil sammenligne: De tre som er blevet valgt til bedste spiller for hver indlæringsmetode og de tre spillere, der allerede er implemementeret i PulverGammon, og som blev præsenteret i afsnit 3.1.1, RandomAI, Simple_003 og Pubeval. De tre sidsnævnte skal kun opfattes som sammenligningsgrundlag eller benchmark. Som måleenhed bruger vi PPG, Points Per Game, altså det gennemsnitlige antal point en spiller har mere end den anden over flere spil. Vi lod hver spiller spille 10.000 spil mod hver af de andre og regnede PPG ud fra disse spil. Resultatet af dette kan ses i tabel 5.2. Det ses at TD-algoritmen er den eneste, der kan slå Pubeval som Tesauro beskriver som decent intermediate level of play [9]. Jeg gennemgår her hver af de seks spillere. RandomAI bliver slået stort af alle de andre, hvilket er godt for projektet, da de andre spillere helst skulle være bedre end en spiller, der rykker tilfældigt. Simple_003 taber stort til alle andre end RandomAI. Det er bemærkelsesværdigt at en så simpel spiller som Simple_003 kan vinde så stort over en spiller, der rykker tilfældigt. Pubeval bygger på et lineært neuralt netværk, men er til trods for det en god spiller i forhold til de andre. Den taber kun mod TD og med en PPG på -0,26. Til sammenligning kan en søgning på forskellige internetforums afsløre at de bedste backgammonprogrammer spiller ca. 0,75 PPG mod Pubeval. Mutation klarer sig lige så godt som de andre indlæringsmetoder mod RandomAI. Den slår stadig Simple_003 stort, men slet ikke lige så stort som Pubeval, Backpropagation og TD. Mod disse tre klarer RandomAI sig meget dårligt med ca. -1 PPG. Backpropagation klarer sig godt i denne test i betragtning af, at algoritmen ikke er designet til at træne netværket med en serie af observationer og kun ét forventet output i slutningen. Backpropagation taber mod Pubeval, men kun med -0,18 PPG. TD er klart den bedste af disse spillere. Den vinder med 0,26 PPG over Pubeval, hvilket viser et rimeligt forspring. Den vinder stort over de fire andre. Det er næsten klart at TD ville vinde over Backpropagation, da TD er skabt til denne type problemer med flere observationer før et resultat, men TD klarer sig endnu bedre mod de andre spillere. 5.3 En menneskelig bedømmelse TD-metoden var helt klart bedst af de tre indlæringsmetoder til at træne et netværk i at være en backgammon-evalueringsfunktion. Det kan dog være svært 33
PPG over 10.000 spil RndAI Simple Pubeval Mutation Back TD RandomAI - -1,57-2,50-2,58-2,63-2,57 Simple_003 1,57 - -1,37-0,82-1,35-1,46 Pubeval 2,50 1,37-0,91 0,18-0,26 Mutation 2,58 0,82-0,91 - -0,80-1,14 Backpropagation 2,63 1,35-0,18 0,80 - -0,53 TD 2,57 1,46 0,26 1,14 0,53 - Tabel 5.2: Sammenligning af alle seks spillere: Den bedste spiller for hver af de tre indlæringsmetoder samt de tre benchmarks implemeneteret i PulverGammon. Måleenheden er Points Per Game, altså det gennemsnittelige antal points som en spiller vinder over en anden. at forholde sig til hvor godt det er, at den kan slå Pubeval med 0,26 PPG. Er det godt eller skidt set fra en backgammonspillers synspunkt? For at få svar på dette har vi brug for hjælp af nogle rigtige backgammonspillere. Med nogle forumindlæg på to internetfora fik vi kontakt med flere backgammonspillere, der gerne ville hjælpe med at spille nogle spil mod den bedste TD-spiller. Testerne fik alle tilsendt den samme e-mail med instruktioner til at downloade en Java-pakke med PulverGammon samt nogle spørgsmål, der giver os et indtryk af, hvor gode spillere de er. Java-pakken starter automatisk et spil mellem brugeren og den bedste TD-spiller. Mailen der bev sendt kan ses i appendix A. Her følger uddrag af af de svar jeg fik tilbage. Andreas Andreas er danmarksmester i backgammon 2007 og må således betragtes som elitespiller. Han vandt over TD med scoren 13-5 på 10 spil, hvilket svarer til 0,8 PPG. Andreas siger: Havde ingen problemer med at få applikationen igang. Den grafiske brugerflade virker stabil og fornuftig. Hvad angår programmets spilleevne, så synes jeg at den spillede fornuftigt. Den spiller på begynderniveau, tror jeg. Det er åbenlyst at den ikke kender til gammon/backgammon, hvilket måske gør måden du tæller point på lidt unfair. Jeg havde f.eks. et spil hvor den vælger at lade være at redde backgammon. Andreas har helt ret i at TD ikke kender forskel på gammon og backgammon, der giver hhv. 2 og 3 point. Dette sker pga. netværksstrukturen, hvor gammon kodes på samme måde som backgammon. 34
Christian Christian er en elitespiller, der spiller på holdet Kolding. Holdet vandt danmarksmesterskabet i 2005 og sølv i 2006. Han vandt over TD med scoren 25-12 på 22 spil, hvilket svarer til 0,59 PPG. Christian siger: Claus Jeg er sikker på, at botten spillemæssigt mangler en del endnu, før den er at betragte som en god spiller. Som jeg vurderer det, spiller den lidt som en begynder, der spiller meget stift og "sikkert" i forhold til første sekvens (et rul til hver side). Den forstår ikke, at nogle gange betaler det sig at tage en chance mod til gengæld at have en mere fleksibel stilling i de kommende rul. Overordnet set er jeg imponeret over dit program, og det er interessant hvor god en spiller det ville blive med f.eks. 3.000.000 træningsspil. Claus spiller ikke seriøst backgammon, men betragter sig selv som et godt stykke over middel, dog langt fra eliten. Claus vandt over TD med en score på 7-4 på 10 spil, hvilket svarer til 0,3 PPG. Claus siger: Jeg synes GUI en er fint lavet og spillet flyder fint. Den laver nogle store fejl, når den er langt foran og skal holde spillet lukket, synes jeg det ser ud til. Det er dog et ret pænt niveau den spiller taget i betragtning at du ikke har "lært den spillet". Jeg vil tro at jeg i længden slår den lidt mere end 2 til 1 som de 7-4 angiver, men den kan vist vinde et spil i ny og næ over de fleste. Christian Christian er en stærk spiller som i 2006 blev nr. 2 ved DM. Christian vandt over TD med scoren 13-12 på 19 spil, altså en PPG på 0,053. Dette er ikke meget, men 19 spil er også få nok spil til at heldfaktoren kan spille ind. Christian siger: Jeg spiller kun mod stærkere bot er som Snowie og her laver din udgave jo en del fejl. Gav mig f.eks. et frivilligt dobbelt-skud hvor den ikke havde behøvet det. Jeg forstod først nu at man kunne vinde gammons (troede det var en række 1-points kampe) så jeg har spillet noget strategi forkert. Synes iøvrigt den var meget heldig et par gange, så hvis der ikke er snyd med i spillet så har jeg bare ramt en unlucky streak (tabte 3 gammons i træk). Har noteret mig i denne periode at når jeg ryger på baren mod 2- eller 3-punktsborde så danser jeg (kommer ikke ud) 35
ca. 80% af gangene og det burde snarere være hhv. 11% og 25% af gangene. Michael Michael har vundet BG Cup i 2004 og træner ofte mod Snowie, som er en stærk backgammoncomputer. Michael vandt 42-24 på 45 spil, hvilket er en PPG på 0,4. Michael siger: Allan Brugerfladen: Den manglende mulighed for at omgøre brikflyt indebærer, at jeg har spillet dårligere end jeg ellers ville have gjort i nogle af spillene. AI en: Den er elendig i bearoff (udtagning), hvor den ofte undlager at tage en brik ud. Den spiller ikke for at undgå at tabe backgammon; i stedet for at flytte brikker fra mit "hjembord" foretager den ligegyldige flyt andetsteds på brættet. Allan er formand for Cube Action Backgammon Klub, har vundet DM i double 2004 og fik en 4. plads i Nordic Open 2007. Han spiller dagligt backgammon online og ugentligt i klub. Han ligger nr. 168 på den danske rangliste. Allan endte lige mod TD med scoren 6-6 på 10 spil. Allan siger: Jeg vandt seks spil, men programmet vandt to gammons. Spilniveauet er pænt højt, men jeg har på fornemmelsen, at programmet var ret "heldig" uden at det skal lyde som en undskyldning for at jeg ikke vandt :-) Lasse, specialeforfatter Jeg betragter mig selv som middel eller lidt over middel backgammonspiller. Jeg har aldrig spillet seriøst backgammon, men jeg har en god opfattelse af spillet og dets strategier. Jeg tabte mod TD med scoren 8-14 på 15 spil, altså -0.4 PPG. Jeg har disse kommentarer til TD-spilleren: Den spiller overraskende godt og ser ud til at lave det optimale træk i mange situationer. Dog er det helt åbenlyst, at den ikke kan se forskel på gammon og backgammon, da den taber med backgammon hvor den kunne have undgået det. I spillets slutfase hvor strategien er mere simpel laver den også nogle småfejl, men alt i alt er det en god spiller. Med nogle justeringer der kan rette disse problemer ville den helt sikkert blive bedre! 36
Opsamling Alle testerne, på nær specialeforfatteren, er at betragte som gode spillere og alle vandt eller spillede lige op mod TD. De der kun vandt med nogle få PPG påpegede at computeren var heldig, hvilket også er sandsynligt på så få spil. Desuden kunne næsten alle testere fortælle, at der er en fejl i programmet, da det i backgammon ikke er muligt at starte med dobbeltslag. Dette var ikke implementeret i PulverGammon, hvilket giver nogle situationer, som testerne normalt ikke er ude for. Det skal selvfølgelig rettes i en evt. senere version. Alt i alt ser det ud til, at gode spillere kan vinde over TD med mellem 0,3 og 0,6 PPG i det lange løb. 5.4 En anden netværksstruktur For at se hvor stor indflydelse det har, hvordan man koder inputtet, vil vi prøve at træne TD-algoritmen med en anden netværksstruktur. Vi prøver med et input af længde 212. De første 198 inputs er de samme som før. Derudover kommer 2 inputs, der betegner om spillet er i race-situation, altså om det ikke længere er muligt at slå brikker hjem, og 6 inputs der koder maksimal blokstørrelse for hver spiller. Med maksimal blok-størrelse menes den længste serie af blokader, som en spiller har. Både race-situation og maksimal blokstørrelse er en funktion af de første 198 inputs, men forhåbningen er, siden begge dele har strategisk værdi, at det vil hjælpe netværket på vej, enten ved at det bliver bedre eller ved at det lærer hurtigere. For at kunne adskille de to typer netværk, vi nu arbejder med, kalder vi den første TD_Gammon og den nye Extra. Vi lod TD-algoritmen træne med Extra i lidt over 1.000.000 spil og fandt den bedste spiller, på samme måde som ved de andre typer netværk, ved spil nr. 701.000. Denne lod vi spille 10.000 spil mod spilleren, der er trænet med TD-algoritmen med TD_Gammon-strukturen. Resultatet blev skuffende 7082-7236 til TD_Gammon, altså en PPG på 0, 0154, hvilket er stort set det samme som en lige stilling. Det lader altså ikke til, at den nye netværksstruktur har forbedret spilleevnen. Lad os nu kigge på, hvor hurtigt TD-algoritmen lærer med Extra i forhold til TD_Gammon. For at teste dette, lader vi for hvert 1000 spil Extra spille mod den tilsvarende TD_Gammon. På figur 5.4 ses grafen for, hvordan det gik. Y-aksen betegner Extras PPG over TD_Gammon. Grafen viser, at der faktisk ikke er nogen mærkbar forskel over så mange spil. Dog, hvis man kun kigger på de første 5.000 spil, hvor vi altså kun har en backup for hvert 1.000 spil, tyder det på, at Extra lærer hurtigere end TD_Gammon i starten. De ændringer vi lavede i netværksstrukturen, havde altså ikke rigtig nogen indflydelse på hverken spilleevne eller indlæringshastighed. Måske ville de ekstra inputs i Extra gøre en forskel med flere skjulte neuroner. 37
Figur 5.4: Extra mod TD_Gammon 38