729G43 Artificiell intelligens Sökning

Transkript

1 729G43 Artificiell intelligens Sökning Arne Jönsson HCS/IDA Problemformulering Ø Ø Ex. Hitta bästa vägen från Arad till Bukarest Returnera en sekvens av handlingar till en intelligent agent Oradea 71 Neamt 75 Zerind Iasi Arad 140 Sibiu 99 Fagaras 92 Vaslui 118 Timisoara Dobreta 80 Lugoj Mehadia 120 Rimnicu Vilcea 97 Pitesi Craiova Bukarest 90 Giurgiu 142 Urziceni Eforie Linköpings universitet 1

2 Tillståndsrymd Initialtillstånd In(Arad) Handlingar {Go(Sibiu), Go(Zerind), Go(Timisoara)} Övergångsmodell Operationer som beskriver effekten av en handling som en funktion av tillståndsförändringar Result(In(Arad), Go(Sibiu)) = In(Sibiu) Måltest {In(Bukarest)} Vägkostnad Arad Timisoara Lugoj = =229 Problemformulering Datastruktur: problem = [intialtillstånd operatorer måltest vägkostnadsfunktion] Effektivitet Nås målet? Till vilken kostnad? Hur bra är lösningen? Totalkostnaden = vägkostnaden + sökkostnaden Linköpings universitet 2

3 Exempel Vattenhinksproblemet 2 hinkar, en 4-liter, en 3-liter En kran att fylla med Problem: att få exakt 2 liter i 4-litershinken Extraantaganden Inget litersmått Vatten i kranen Kan hälla vatten mellan hinkar Vattenhinksproblemet Tillstånd: X = 4-litershinken Y = 3-litershinken Initialtillstånd (X=0, Y=0) Måltillstånd: (2, Y) Kostnad: 1 per operation Operatorer: Fyll en hink Töm en hink Fyll från en hink till en annan Häll ut lite vatten Linköpings universitet 3

4 Vattenhinksproblemet Operationer: (X,Y: X < 4) (4,Y) (X,Y: Y < 3) (X,3) (X,Y: X > 0) (0,Y) (X,Y: Y > 0) (X,0) (X,Y: X+Y ³ 4 Ù Y>0) (4, Y-(4-X)) (X,Y: X+Y ³ 3 Ù X>0) (X-(3-Y),3) (X,Y: X+Y =< 4 Ù Y>0) (X+Y,0) (X,Y: X+Y =< 3 Ù X>0) (0,X+Y) Sökning Datastrukturer och operationer Värdering av sökstrategier Blind sökning Heuristisk sökning Genetiska algoritmer Constraint satisfaction Spelförande program Linköpings universitet 4

5 Sökning Datastruktur: nod = [tillstånd, förälder, operator, djup, vägkostnad] Expandera varje nod Applicera operatorer på ett tillstånd och generera alla nya tillstånd Ex: Initialtillståndet (0, 0) expanderas till (4, 0) och (0, 3) (4, 0) expanderas till (0, 0) (4, 3) (1, 3) (0, 3) expanderas till (0, 0) (4, 3) (3, 0) etc. Sökstrategi avgör vilken nod som skall expanderas Köoperationer Sökalgoritmer sparar noder som skall expanderas i en kö Typiska köoperationer: empty?(queue) pop(queue) insert(element, queue) Linköpings universitet 5

6 Generell sökalgoritm def treesearch(problem): frontier = insert(initialstate(problem), frontier) while true: if empty?(frontier): return failure node = pop(frontier) if goaltest(problem, state(node)): return solution(node) frontier = insert(expand(node, problem), frontier) Nodexpansion Expand(node, problem) Skapa en lista av noder, s, som är efterföljare till en nod, n, där: state[s] = tillståndet efter uförd legal handling i n parent-node[s] = n action[s] = handlingen som utfördes vägkostnad[s] = vägkostnad[n] + kostnad från n till s djup[s] = djup[n] + 1 Linköpings universitet 6

7 Värdering av sökstrategi Komplett hittar lösning om den finns Optimal hittar bästa lösningen Tidsåtgång Minnesåtgång Blind sökning Ingen information om hur långt det är kvar till målet Bredden först Uniform cost Djupet först Djupbegränsad sökning Iterativ fördjupning Dubbelriktad sökning Linköpings universitet 7

8 Bredden först Expandera alla noder på en nivå innan nästa nivå Implementeras med insert som en FIFO-kö Bredden först Komplett Optimal Komplexitet ett problem Förgreningsfaktor b Sökdjup d Ex b=2 1 d=0, en nod, b d=1, b 1 noder d=2, b 2 noder d=3, b 3 noder Linköpings universitet 8

9 Bredden först Antag lösning på djupet d, då har vi expanderat: 1+b+b 2 +b 3 +b 4 +b 5 +..b d noder Vid komplexitetsanalys säger vi att vi har O(b d ), dvs exponentiell tillväxt T d Bredden först, tids- och minneskomplexitet Djup Noder Tid Minne ,11 ms 0,1 MB ms 10,6 MB s 1 GB min 103 GB timmar 10 TB dagar 1 PetaByte ,5 år 99 PetaByte år 10 ExaByte Förgreningsfaktor = 10, 1 miljon noder/sekund, 1000 bytes/nod Linköpings universitet 9

10 Uniform Cost Om inte alla operatorer har samma kostnad Expandera billigaste vägen längs frontier S S S A S B 15 5 C M A B C A B C 5 15 M 11 A B C 15 M M Optimal och komplett om det inte finns negativa kostnader I princip O(b d ) för tids- och minneskomplexitet Djupet först Följer alltid en väg till slutet, om inte en lösning backa upp Implementeras med insert som en LIFO-kö, STACK Linköpings universitet 10

11 Djupet först Kräver mindre minne, m*b där m=maxdjup. Jämför b=10, m=12, djupet först = 10*12=120, bredden först = Samma tidskomplexitet O(b m ) Inte optimal Inte komplett, kan dyka ner i en oändligt lång sökväg Djupbegränsad sökning Lägg in ett maxdjup, l, för djupet först Tidskomplexitet fortfarande exponentiell, O(b l ) Minneskomplexitet O(b*l) Inte komplett om man inte kan skatta ett sökdjup som garanterar en lösning, jfr, rumäniengrafen, max 20 städer, dvs l=20 ger komplett Inte optimal Linköpings universitet 11

12 Iterativ fördjupning Låt sökdjupet, h, öka från 0 till det djup, d, där en lösning finns h=0 h=1 h=2 h=3 Iterativ fördjupning Optimal och komplett Minneskomplexitet, O(b*d) Tidskomplexitet, O(b d ) Expanderar dock noderna flera gånger Bredden-först 1+b+b 2 +b 3 +b 4 +b 5 +..b d Iterativ fördjupning db+(d-1)b 2 +(d-2)b b d-2 +2b d-1 +b d Men antal noder på nivå d många fler än resten Ex b=10, d=5 Bredden först: = Iterativ fördjupning: = Linköpings universitet 12

13 Dubbelriktad sökning Sök bredden-först från start och mål samtidigt Inte alltid möjligt Komplett och optimal Tids- och minneskomplexitet, lösning djup d 2b d/2, dvs O(b d/2 ) Ex b=10, d=6 Bredden först, O(b d ) = 10 6 = Dubbelriktad sökning = 10 6/2 = 10 3 = 1000 Egenskaper hos sökstrategier Kriterium Bredden först Uniform Cost Djupet först Djupbegränsad Komplett? Ja Ja Nej Nej Ja Ja Iterativ fördjupning Dubbelriktad sökning Optimal? Ja Ja Nej Nej Ja Ja Tid O(b d ) O(b C*/e ) O(b m ) O(b l ) O(b d ) O(b d/2 ) Minne O(b d ) O(b C*/e ) O(bm) O(bl) O(bd) O(b d/2 ) Linköpings universitet 13

14 Undvika loopar Ex vattenhinksproblemet (0,0) (4,0) (0,3) (0,0) (4,3) (1,3) (0,0) (4,3) (3,0) Generera inte tillstånd som är lika med fadertillståndet Generera inte vägar med cykler Behöver bara leta från noden som genererats upp till startnoden Generera inte ett tillstånd som genererats förut Varje tillstånd måste lagras i minnet, O(b d ) Heuristisk sökning Antar att vi har någon information om vilken nod som är bäst att expandera Greedy search A* Heuristik Hill Climbing Linköpings universitet 14

15 Greedy Search Minimera uppskattad kostnad till målet, dvs expandra den nod som verkar vara närmast målet Inför h(n)= heuristisk funktion som uppskattar kostnaden från nod n till målet h(n) = 0 betyder att n är målnod Ex Rumänienkartan Fågelavståndet ett exempel på heuristik h(n)= Arad 366 Bukarest 0 Craiova 160 Dobreta 242 Eforie 161 Fagaras 178 Giurgiu 77 Hirsova 151 Iasi 226 Lugoj 244 Mehadia 241 Neamt 234 Oradea 380 Pitesi 98 Rimnicu V. Sibiu 253 Tisioara 329 Urzicen Oradea i Neamt Vasliu 199 Zerind 374 Zerind Iasi Arad Sibiu Fagaras Vaslui Timisoara Rimnicu Vilcea Lugoj Pitesi Urziceni Mehadia Bukarest Dobreta Craiova Giurgiu Eforie Linköpings universitet 15

16 Greedy Search, Arad Bukarest Arad Zerind (374) Sibiu (253) Timisoara (329) Oradera (380) Fagaras (178) Rimnicu Vilcea (193) Bukarest (0) Greedy Search Liknar djupet först och kan råka ut för samma problem Inte optimal Inte komplett Tids- och minneskomplexitet O(b d ) men kan ofta bli bättre med god heuristik Jämför Uniform Cost Komplett och optimal men ineffektiv Inför g(n) för kostnad från start för nod n Linköpings universitet 16

17 A* Inför f(n) = g(n) + h(n), dvs tillryggalagd kostnad + uppskattad återstående kostnad Kräv också att h(n) aldrig överskattar den verkliga kostnaden h(n) kallas då tillåten (admissible), ex fågelavståndet h(n)= Arad 366 Bukarest 0 Craiova 160 Dobreta 242 Eforie 161 Fagaras 178 Giurgiu 77 Hirsova 151 Iasi 226 Lugoj 244 Mehadia 241 Neamt 234 Oradea 380 Pitesi 98 Rimnicu V. 193 Sibiu 253 Tisioara 329 Urziceni 80 Vasliu 199 Zerind Oradea Neamt 75 Zerind Iasi Arad 140 Sibiu 99 Fagaras 92 Vaslui 118 Timisoara Dobreta 80 Lugoj Mehadia 120 Rimnicu Vilcea 97 Pitesi Craiova Bukarest 90 Giurgiu Urziceni 86 Eforie Linköpings universitet 17

18 A*, Arad Bukarest Arad Zerind f(zerind) = = 449 Sibiu f(sibiu) = =393 Timisoara f(timisoara) = =447 Oradera ( =671) Fagaras ( =417) Rimnicu Vilcea ( =413) Bukarest ( =450) Pitesi( =415) Craiova ( =526) Bukarest ( =418) Craiova ( =518) A* är optimal Antag: lösningsnoden G optimum med kostnad f* och G 2 lösning men med kostnad g(g 2 ) > f* För att A* skall välja G 2 måste det finnas en nod, n, på vägen till G som inte expanderats n G 2 G f* f(n) eftersom h aldrig överskattar (tillåten) f(n) f(g 2 ) eftersom A* expanderat till G 2 dvs f* f(g 2 ) Eftersom G 2 målnod så h(g 2 ) = 0 f(g 2 ) = g(g 2 ) dvs f* g(g 2 ) vilket motsäger antagandet Linköpings universitet 18

19 Evalueringsfunktionen i A* f(n) = g(n) + h(n) där f(n) = totalkostnad g(n) = kostnad hittills h(n) = uppskattad återstående kostnad (måste underskatta) g(n) = 0 Greedy search h(n) = 0 Uniform Cost g(n) = 1 och h(n) = 0 f(n) = 1, dvs Bredden först Heuristik Heuristiska sökmetoder bättre med bättre heuristik, dvs bättre skattning av kostnaden Ex. 15-spel Linköpings universitet 19

20 Heuristik, 1 Antal brickor som ligger fel : (1,3,4,5,6,7,8,9,10,11,12,13,14,15)=14 8: (1,3,4,5,6,7,8,9,10,11,13,14,15)=13 Heuristik, 2 Manhattanavståndet : =29 8: =27 Linköpings universitet 20

21 Heuristik konstruktion Förenklade problem kan användas för automatisk konstruktion av heuristik En optimal lösning för ett förenklat problem är en tillåten heuristik för orginalproblemet Hill Climbing Om varje nytt tillstånd innehåller all nödvändiginformation för att gå vidare, dvs vi kan utvärdera en nod utan hänsyn till varifrån vi kom och vägen mindre viktig S Linköpings universitet 21

22 Hill Climbing def hillclimbing (problem): current = makenode(initialstate(problem)) while True: next = highestvaluedsuccessor(current) if (value next) <= (value current): return current current = next Problem för hill climbing Lokal metod, hittar lokalt optimum Lokalt maximum Platå Globalt maximum Ås Linköpings universitet 22

23 Genetiska algoritmer Iterativ metod som utgår från de bästa tillstånden och förbättrar dessa Naturligt urval Operatorer inspirerade från naturlig genetisk variation Arbetar parallellt med flera sökrymder Genetiska algoritmer Initialt ett antal slumpmässiga tillstånd, populationen Ett tillstånd, en individ, representeras som en sträng från ett ändligt alfabet (vanligtvis 0 och 1) En funktion, lämplighetsfunktionen, som ger högt värde för bra tillstånd och lågt för dåliga tillstånd Nya tillstånd generas genom att kombinera individer som har höglämplighet, samt genom mutationer Linköpings universitet 23

24 Enkel genetisk algoritm initialisera populationen utvärdera populationen while intetillfredställande resultat: välj ut föräldrar för reproduktion korsa och mutera utvärdera populationen Rouletthjul Bättre fitnessvärde ger större chans att överleva men slump finns kvar Exempel Kromosom A, fitness 4 Kromosom B, fitness 10 Kromosom C, fitness 5 Kromosom D, fitness 1 Linköpings universitet 24

25 Exempel, 1 Handelsresandeproblemet 3 A B 2 C 4 D Exempel, 2 Korsning Två gener. Ta första från första, andra från andra, tredje från första etc och bilda en ny gen. Om elementet redan finns ta nästa. Sluta med samma som start Mutation Byt slumpmässigt två element Fitness Totalavstånd Starttillstånd A B C D A B C D A B C D A B C D A B C D Linköpings universitet 25

26 Exempel, 3 Korsa de två första: A B C D A B C D A B A C D eftersom C som är tredje från första genen redan finns B eftersom A redan finns Ny gen A C D B A Korsa de två sista: C D A B C D A B C D Ny gen: C A B D C Exempel, 4 Mutera första genen slumpmässigt A B C D A Ny population A D C B A A 1 B 2 C 4 D 5 A = 12 B 2 C 4 D 5 A 1 B = 12 C 4 D 5 A 1 B 2 C = 12 D 5 A 1 B 2 C 4 D = 12 A 3 C 4 D 2 B 1 A = 10 C 3 A 1 B 2 D 4 C = 10 A 5 D 4 C 1 B 1 A = 11 Behåll de fyra bästa Linköpings universitet 26

27 Exempel, 5 Ny population D 5 A 1 B 2 C 4 D = 12 A 3 C 4 D 2 B 1 A = 10 C 3 A 1 B 2 D 4 C = 10 A 5 D 4 C 1 B 1 A = 11 Korsa två första D C B A D Korsa två sista C D B A C Mutera första. Slumpen gav andra och tredje staden D B A C D Exempel, 6 Ny population D 5 A 1 B 2 C 4 D = 12 A 3 C 4 D 2 B 1 A = 10 C 3 A 1 B 2 D 4 C = 10 A 5 D 4 C 1 B 1 A = 11 D 4 C 2 B 1 A 5 D = 12 C 4 D 2 B 1 A 3 C = 10 D 2 B 1 A 3 C 4 D = 10 Behåll de fyra bästa A 3 C 4 D 2 B 1 A = 10 C 3 A 1 B 2 D 4 C = 10 C 4 D 2 B 1 A 3 C = 10 D 2 B 1 A 3 C 4 D = 10 etc Linköpings universitet 27

28 Genetisk programmering Genetiska algortimer med program som data Skapa program som löser given uppgift GP algoritm generera program slumpmässigt kör och utvärdera program med träningsdata while inte tillräckligt bra program välj ut program för reproduktion modifiera programmen kör och utvärdera program med träningsdata Linköpings universitet 28

29 Exempel, 1 Wumpus följa väggen Förflyttning och riktning: Norr, Söder, Väster, Öster and if return goöster norr not and return gosöder if if Ex. if norr and not bumpöster: return goöster if öster and not bumpsöder: return gosöder if söder and not bumpväster: return goväster return gonorr bumpöster öster not and return goväster return gonorr bumpsöder söder not bumpväster Exempel, 2 1. Skapa initial population, t.ex slumpmässigt skapade syntaktiskt korrekta träd if if and return gonorr if and return goväster return gonorr norr norr söder return gonorr söder not bumpväster 2. Fitness: Låt agenten starta 10 gånger, varje gång från en ny position. Låt agenten gå 60 steg och räkna antalet unika rutor som angränsar till en vägg Linköpings universitet 29

30 Exempel, 3 3. Skapa nya program genom att 1. Låta de 500 bästa överleva 2. Skapa ytterligare 4500 nya individer av dessa bästa genom slumpmässig korsning if if and return gonorr if and return goväster return gonorr norr norr söder return gonorr söder not bumpväster if if return goväster return gonorr söder return gonorr Exempel, 4 4. Mutera 50 program genom att byta ett delträd mot ett slumpmässigt skapat delträd if if and return goväster return gonorr and return goväster return gonorr söder not söder not bumpväster and bumpöster väster I en värld med 32 väggrutor får man fram ett perfekt program efter 10 generationer Linköpings universitet 30

31 Constraint satisfaction Givet: En mängd variabler X 1,X 2,.X n Med värden v i till X i ur domänen D i En mängd begränsningar C 1,C 2, C n Som talar om vilka värden som är tillåtna Mål: En tilldelning {X i =v i, X j =v j } som är konsistent med begränsningarna Ex. trefärgsproblemet Färga varje stat: Tre färger Grannstater olika färg Ex. {(WA=grön),(NT=blå), (Q=grön),(NSW=blå), (SA=röd),(V=grön),(T=blå)} Linköpings universitet 31

32 Constraint satisfaction sökning Bredden först skulle tilldela varje variabel ett värde generera ett stort sökträd Eftersom ordningen saknar betydelse kan man istället tilldela en variabel ett värde och sen backa tillbaka om det inte blev bra CSP - Sökproblem Tillståndsrymd Initialtillstånd Tom mängd {} Funktion för tillståndsförändringar Ett värde sätts för en variabel som saknar värde Måltest En mängd där alla variabler har tilldelats värden Vägkostand Konstant 1 Linköpings universitet 32

33 CSP - Sökning Djupet först Lokal sökning Backtracking Väljer en variabel och expanderar, dvs prövar olika värden Om inget värde kan användas backar algoritmen CSP Sökning Exempel {} {NT=Röd} {NT=Blå} {NT=Grön} {NT=Röd, Q=Röd} {NT=Röd, Q=Blå} {NT=Röd, Q=Blå, NSW=Grön} {NT=Röd, Q=Blå, NSW=Blå} {NT=Röd, Q=Blå, NSW=Grön, SA=Röd} {NT=Röd, Q=Blå, NSW=Grön, SA=Blå} {NT=Röd, Q=Blå, NSW=Grön, SA=Grön} Linköpings universitet 33

34 Algoritm def backtrackingsearch(csp): return recursivebacktracking([ ], csp) def recursivebacktracking(assignment, csp): if complete(assignment): return assignment var = selectunassignedvariable(variables(csp),assignment,csp) for value in orderdomainvalues(var,assignment,csp): if consistent(value,assignment,constraint(csp)): add {var=value} to assignment result = recursivebacktracking(assignment,csp) if result!= failure: return result remove {var=value} from assignment return failure Algoritm Variabler = [NT, Q, NSW, SA, V, T, WA] Värden = [Röd, Blå, Grön] Initialt assignment = { } selectunassignedvariable väljer variabel Ex var = NT orderdomainvalues väljer värden enligt någon heuristik Ex assignment = {NT = röd} Nytt anrop recursivebacktracking({nt=röd}, csp}) selectunassignedvariable väljer var = Q orderdomainvalues väljer röd. Inte konsistent Linköpings universitet 34

35 Algoritm, forts väljer nytt värde i for-loopen assignment = {Q=blå} recursivebacktracking({nt=röd, Q=blå}, csp} etc {NT=röd, Q=blå, NSW=grön} var=sa går inte utan det rekursiva anropet ger ett failure remove {var=value} from assignment tar bort något värde, t.ex. det sista NSW=grön och sen fortsätter algoritmen med ny variabel Heuristik Val av variabel och värde selectunassignedvariable bör välja den variabel som är mest begränsad och först väljs den som har flest begränsningar, SA orderdomainvalues välj det minst begränsande värdet Constraint propagation Propagera effekten av en variabels begränsningar till de andra variablerna Backtrackingstrategier Ta bort det värde, eller den variabel, som orsakade konflikten Linköpings universitet 35

36 Spelförande program Minimax Evalueringsfunktioner alfa-beta cutoff Minimax X X X X X X X X X O O O X X X X O X O X O X X O X X O X O X e(x,,,x,o,,,, )=4-4=0 e(,x,,x,o,,,,, )=0 e(,,,x,o,,,,x)=4-3=1 Applicera evaluaeringsfunktion, t.ex.: e(p)=n(vinstdrag för mig) n(vinstdrag för motståndaren) Linköpings universitet 36

37 Ett sökträd Max 84 5 Min Max Evalueringsfunktion Linjär n e(p) = w i f i i=0 Ex: e(p)=1*n(vinst för mig)-1*n(motståndarvinst) e(p)=π*n(vinst för mig)-2,18*n(motståndarvinst)+1*n(diagonaler) Icke-linjär n e(p) = f i 2 i=1 Inlärning Vikter och funktioner lärs in automatiskt utifrån gamla spel Credit assignmentproblemet Linköpings universitet 37

38 alfa-beta cutoff, 1 Två tröskelvärden a och b: a representerar det lägsta värdet en maxnod kan få, dvs en undre gräns för MAX b representerar det högsta värdet en minnod kan få, dvs en övre gräns för MIN alfa-beta cutoff, 2 Initiering: a = sämsta värdet; b = bästa värdet Tilldelning: a = bästa efterföljare hitills, på MAX-nivå b = sämsta efterföljare hitills, på MIN-nivå Regler: Avbryt MIN-sökning vid nod med värde mindre än a Avbryt MAX-sökning vid nod med värde större än b Linköpings universitet 38

39 Ett sökträd Max 84 5 Min Max Linköpings universitet 39