IA Busca Informada

Estratgias de Busca Informada
Nesta aula so descritas algumas estratgias de busca informada em espaos de estados que so usadas quando h informaes especficas sobre o problema Em geral, as informaes especficas tendem a melhorar o processo de busca
augusto@usp.br http://dcm.fmrp.usp.br/~augusto
Inteligncia Artificial
Jos Augusto Baranauskas Departamento de Computao e Matemtica FFCLRP-USP
Busca Informada
A busca em grafos pode atingir uma complexidade elevada devido ao nmero de alternativas Estratgias de busca informada utilizam conhecimento especfico do problema (alm da definio do prprio problema) para encontrar solues de forma mais eficiente do que a busca sem informaes A abordagem geral que utilizaremos denominada busca pela melhor escolha (best-first search) O termo busca pela melhor escolha tem seu uso consagrado mas ele inexato
Se fosse realmente possvel expandir o melhor n primeiro, no haveria a necessidade de se realizar uma busca; seria um caminho direto ao objetivo O que podemos fazer escolher o n que parece ser o melhor de acordo com a funo de avaliao Se a funo de avaliao for precisa, esse ser de fato o melhor n; caso contrrio, a busca pode se perder
2
Busca Informada
Na busca best-first, a escolha do n n a ser expandido efetuada com base em uma funo de avaliao f(n)
Em geral, o n n com o menor valor f(n) selecionado para a expanso, uma vez que a funo de avaliao mede a distncia de n at o objetivo, ou seja, at um n final
A forma mais comum de adicionar conhecimento do problema ao algoritmo de busca (da o nome busca informada) e, portanto, um componente fundamental dos algoritmos de busca best-first uma funo heurstica, denotada por h(n)
h(n) = custo estimado do caminho mais econmico partindo do n n e chegando a um n final
As funes heursticas so especficas do problema, exceto pela seguinte restrio que se aplica a todos
h(n)=0 se n um n final
Funo Heurstica
Heurstica (arte de descobrir): conhecimentos que permitem uma soluo rpida para algum problema
Heureca (Eu encontrei, Arquimedes)
Uma heurstica uma funo que quando aplicada a um estado retorna um nmero que corresponde a uma estimativa da qualidade (mrito) do estado atual em relao a um estado final Em outras palavras, a heurstica nos informa aproximadamente quo longe o estado atual est de um estado final
Heursticas podem subestimar ou superestimar a qualidade de um estado Heursticas que apenas subestimam so altamente desejveis e so chamadas admissveis
i.e. nmero menores so melhores
Heursticas admissveis so otimistas, pois estimam que o custo da soluo de um problema seja menor do que na realidade
4
Funo Heurstica: Distncia em Linha Reta

Por exemplo, em um mapa contendo cidades e estradas que as interconectam, poderamos estimar o custo do caminho mais curto (econmico) entre duas cidades como sendo a distncia em linha reta Esta heurstica admissvel pois o caminho mais curto entre dois pontos quaisquer no plano uma linha reta e, portanto, no pode ser uma superestimativa
h(n)
Funo Heurstica I para o QuebraCabea de 8 Peas

Nmero de peas fora do lugar (sem incluir o espao vazio) Nesta situao, apenas a pea 8 est fora do lugar; portanto a funo heurstica igual a 1 Em outras palavras, a heurstica nos informa que ela estima que uma soluo pode estar disponvel em apenas mais um movimento
h(estado atual) = 1
6
Estado Atual
1 2 4 5 7 1 4 7 2 5 8
3 6 8 3 6 = = = = = = =
Estado Final
Funo Heurstica II para o QuebraCabea de 8 Peas

Distncia Manhattan (sem incluir o espao vazio) Nesta situao, apenas as peas 1, 3 e 8 esto fora do lugar por 2, 3 e 3 posies, respectivamente; portanto a funo heurstica igual a 8 Em outras palavras, a heurstica nos informa que ela estima que uma soluo pode estar disponvel em apenas mais 8 movimentos
h(estado atual) = 8 Estado Atual
3
2 posies
3 2 4 5 7 1 1 4 7 2 5 8
8 6 8 3 6 1
3 posies 3 posies
Estado Final
Busca Gulosa pela Melhor Escolha

A busca gulosa pela melhor escolha (greedy best-first search) tenta expandir o n mais prximo ao n final, assumindo que isso provavelmente levar a uma soluo rpida Dessa forma, a busca avalia os ns utilizando apenas a funo heurstica
f(n) = h(n)
Greedy best-first semelhante busca em profundidade

Prefere seguir um nico caminho at o objetivo, retrocedendo somente se encontrar um beco sem sada Mesmo defeitos da busca em profundidade: no tima, nem completa (pode entrar em um caminho infinito e nunca retornar para testar outras possibilidades) Complexidade de tempo e espao no pior caso so iguais a O(bm), onde m a profundidade mxima do espao de busca
Exerccio
Encontre o caminho de s at t usando busca gulosa pela melhor escolha
h(s)=9 2
h(e)=7
s
2 5 h(a)=5
a
2 h(f)=4 2
h(c)=4 3
b
h(b)=4
f
2
d
h(d)=3 3
g
2
h(g)=2
h(t)=0
9

s
h(s)=9 2
h(e)=7
s
2 5 h(a)=5
a
2 h(f)=4 2
h(c)=4 3
b
h(b)=4
f
2
d
h(d)=3 3
g
2
h(g)=2
h(t)=0
10

s
h(s)=9 2
h(e)=7
s
h(a)=5
h(e)=7
2 5 h(a)=5
a
2 h(f)=4 2
h(c)=4 3
b
h(b)=4
f
2
d
h(d)=3 3
g
2
h(g)=2
h(t)=0
11

s
h(s)=9 2
h(e)=7
s
h(a)=5
h(e)=7
2 5 h(a)=5
a
2 h(f)=4 2
h(b)=4
b
h(c)=4 3
b
h(b)=4
f
2
d
h(d)=3 3
g
2
h(g)=2
h(t)=0
12

s
h(s)=9 2
h(e)=7
s
h(a)=5
h(e)=7
2 5 h(a)=5
a
2 h(f)=4 2
h(b)=4
b
h(c)=4
c
3
b
h(b)=4
f
2
h(c)=4
d
h(d)=3 3
g
2
h(g)=2
h(t)=0
13

s
h(s)=9 2
h(e)=7
s
h(a)=5
h(e)=7
2 5 h(a)=5
a
2 h(f)=4 2
h(b)=4
b
h(c)=4
c
3
b
h(b)=4
f
2
h(c)=4
h(d)=3
d
h(d)=3 3
g
2
h(g)=2
h(t)=0
14

s
h(s)=9 2
h(e)=7
s
h(a)=5
h(e)=7
2 5 h(a)=5
a
2 h(f)=4 2
h(b)=4
b
h(c)=4
c
3
b
h(b)=4
f
2
h(c)=4
h(d)=3
d
h(d)=3 3
g
2
h(g)=2
h(t)=0
Custo da soluo encontrada s-a-b-c-d-t = 12 Custo da soluo tima s-e-f-g-t = 11
h(t)=0
15
Busca Gulosa pela Melhor Escolha: Encontre o caminho de Arad at Bucharest

Oradea 71 h(n) Arad 87 Zerind Bucharest 151 75 Craiova Iasi Dobreta Arad 140 92 Eforie Sibiu Fagaras Fagaras 99 Vaslui Giurgiu 118 80 Hirsova Rimnieu Iasi Timisoara Vilcea Lugoj 142 Mehadia 211 111 Pitesti Lugoj Neamt 97 Hirsova Oradea 70 98 Pitesti 85 146 Mehadia 101 Urziceni Rimnieu Vilcea 86 75 138 Sibiu Bucharest Timisoara Dobreta 120 90 Urziceni Eforie Craiova Vaslui Giurgiu Zerind Neamt
Assuma que os sucessores de um n so definidos em ordem alfabtica
Distncia em linha reta at Bucharest

366 0 160 242 161 176 77 151 226 244 241 234 380 100 193 253 329 80 199 374 16
Encontre o caminho de Arad at Bucharest

Oradea 71 75 Arad 118 80 Timisoara 111 70 Mehadia 75 Dobreta 120 Craiova h(n) Arad Bucharest Craiova Dobreta Eforie Fagaras Giurgiu Hirsova Iasi Lugoj Mehadia Neamt Oradea Pitesti Rimnieu Vilcea Sibiu Timisoara Urziceni Vaslui Zerind 366 0 160 242 161 176 77 151 226 244 241 234 380 100 193 253 329 80 199 374 146 138 101 85 Bucharest 90 Giurgiu Eforie Urziceni Lugoj Rimnieu Vilcea 97 Pitesti 211 142 98 Hirsova 86 Zerind 140 Sibiu 99 Fagaras Vaslui 151 Neamt 87 Iasi 92
f(Arad)=h(Arad)
Arad 366
17

Arad 366
Sibiu 253
Timisoara 329
Zerind 374
18

Arad 366
Sibiu 253
Timisoara 329
Zerind 374
Fagaras 176
Oradea 380
Rimnieu Vilcea 193
19

Arad 366
Sibiu 253
Timisoara 329
Zerind 374
Fagaras 176
Oradea 380
Rimnieu Vilcea 193
Bucharest 0
Custo da soluo encontrada A-S-F-B = 450 Custo da soluo tima A-S-RV-P-B = 418
20
O que sabemos?
Busca de custo uniforme (uniform cost)
Similar busca em largura Mede o custo de cada n, desde a raiz da busca tima e completa Pode ser muito lenta
Busca Gulosa pela Melhor Escolha (greedy best-first)

Similar busca em profundidade Mede o custo estimado de cada n at um n final No tima nem completa Pode ser muito rpida, dependendo da qualidade da heurstica e do problema especfico
Seria possvel combinar estas estratgias para criar um algoritmo timo e completo que seja tambm muito rpido?
21
Busca de Custo Uniforme

Coloque os estados na fila em ordem de custo
s
g(a)=2 a
s e g(e)=2
g(a)=2 a g(b)=4 b
s e g(e)=2
g(a)=2 a g(b)=4 b
s e g(e)=2 f g(f)=7
Intuio: Expanda o n mais barato, onde o custo o custo do caminho g(n)

Coloque os estados na fila em ordem de distncia estimada at o objetivo
s
h(a)=5 a
s e h(e)=7
h(a)=5 a h(b)=4 b
s e h(e)=7
h(a)=5 a h(b)=4 b h(c)=4 c
s e h(e)=7
Intuio: Expanda o n que aparenta ser o mais prximo do objetivo, onde a estimativa da distncia at o objetivo h(n)
22
Busca A*
Coloque os estados na fila em ordem de custo total at o objetivo, f(n)
Resumidamente:
g(n) o custo at chegar ao n n h(n) a distncia estimada do n n at um n final f(n) = g(n) + h(n)
Podemos imaginar f(n) como uma estimativa de custo da soluo mais barata que passa pelo n n Note que possvel usar os algoritmos de busca em largura ou de custo uniforme alterando apenas a estratgia na qual os ns so colocados na fila Se a heurstica utilizada nunca superestima a distncia at o n final (heurstica otimista), ento o algoritmo A* timo e completo
23
Busca A*
conveniente relembrar que uma estratgia de busca definida por meio da ordem de expanso dos ns Na estratgia de busca best-first a idia bsica prosseguir com a busca sempre a partir do n mais promissor A Busca pela Melhor Escolha (best-first) um refinamento da busca em largura, que em sua forma completa tambm conhecido como busca A*
Ambas estratgias comeam pelo n inicial e mantm um conjunto de caminhos candidatos Busca em largura expande o caminho candidato mais curto Best-First refina este princpio calculando uma estimativa heurstica para cada candidato e escolhe expandir o melhor candidato segundo esta estimativa
24
A*
Vamos assumir que h um custo envolvido entre cada arco:
s(X,Y,C) que verdadeira se h um movimento permitido no espao de estados do n X para o n Y ao custo C; neste caso, Y um sucessor de X
s
g(n)
Sejam dados um n inicial s e um n final t Seja o estimador heurstico a funo f tal que para cada n n no espao, f(n) estima a dificuldade de n, ou seja, f(n) o custo do caminho mais barato de s at t via n A funo f(n) ser construda como: f(n) = g(n) + h(n)
g(n) uma estimativa do custo do caminho timo de s at n h(n) uma estimativa do custo do caminho timo de n at t
n
h(n)
25
A*
Quando um n n encontrado pelo processo de busca temos a seguinte situao
Um caminho de s at n j foi encontrado e seu custo pode ser calculado como a soma dos custos dos arcos no caminho
Este caminho no necessariamente um caminho timo de s at n (pode existir um caminho melhor de s at n ainda no encontrado pela busca) mas seu custo serve como uma estimativa g(n) do custo mnimo de s at n
O outro termo, h(n) mais problemtico pois o mundo entre n e t no foi ainda explorado
Portanto, h(n) tipicamente uma heurstica, baseada no conhecimento geral do algoritmo sobre o problema em questo Como h depende do domnio do problema, no h um mtodo universal para construir h
26
A*
Vamos estudar o algoritmo best-first em sua forma completa A* que minimiza o custo total estimado da soluo O processo de busca pode ser visto como um conjunto de sub-processos, cada um explorando sua prpria alternativa, ou seja, sua prpria sub-rvore Sub-rvores tm sub-rvores que so exploradas por subprocessos dos sub-processos, etc Dentre todos os processos apenas um encontra-se ativo a cada momento: aquele que lida com a alternativa atual mais promissora (aquela com menor valor f) Os processos restantes aguardam silenciosamente at que a estimativa f atual se altere e alguma outra alternativa se torne mais promissora Ento, a atividade comutada para esta alternativa
27
A*
Podemos imaginar o mecanismo de ativaodesativao da seguinte forma
O processo trabalhando na alternativa atual recebe um oramento limite Ele permanece ativo at que o oramento seja exaurido Durante o perodo em que est ativo, o processo continua expandindo sua sub-rvore e relata uma soluo caso um n final seja encontrado O oramento limite para essa execuo definido pela estimativa heurstica da alternativa competidora mais prxima
28
A*
9 2
s
Distncia entre duas cidades atravs de um caminho (rodovia) 2 5 5
a
2 2
4 Distncia entre a cidade em questo e a cidade destino (t) em linha reta 3 3
f
2
d
3
g
2
t
29
A*
Dado um mapa, o objetivo encontrar o caminho mais curto entre a cidade inicial s e a cidade destino t Para estimar o custo do caminho restante da cidade X at a cidade t utilizaremos a distncia em linha reta denotada por dist(X,t) f(X) = g(X) + h(X) = = g(X) + dist(X,t) Note que quando X cidade inicial (X=s) ento g(s)=0
f(s)=0+9=9 9 2
s
2 5 5
a
2 2
4 3 3
f
2
d
3
g
2
O primeiro n a ser expandido o n inicial (raiz da busca)
t
30
A*
Neste exemplo, podemos imaginar a busca A* consistindo em dois processos, cada um explorando um dos caminhos alternativos Processo 1 explora o caminho via a Processo 2 explora o caminho via e
9 2
s
2 5 5
a
2 2
4 3 3
f
2
d
3
g
2
t
31
A*
f(a)=g(a)+dist(a,t)=2+5=7 f(e)=g(e)+dist(e,t)=2+7=9 Como o valor-f de a menor do que de e, o processo 1 (busca via a) permanece ativo enquanto o processo 2 (busca via e) fica em estado de espera
3 9 2
f(e)=9
s
2 5 5
f(a)=7 2
4 3
f
2
d
3
g
2
t
32
A*
f(a)=g(a)+dist(a,t)=2+5=7 f(e)=g(e)+dist(e,t)=2+7=9 Como o valor-f de a menor do que de e, o processo 1 (busca via a) permanece ativo enquanto o processo 2 (busca via e) fica em estado de espera f(b)=g(b)+dist(b,t)=4+4=8
9 2
f(e)=9
s
2 5 5
f(a)=7 2
4 3 3
b
f(b)=8
f
2
d
3
g
2
t
33
A*
e 7 f(e)=9 f(a)=g(a)+dist(a,t)=2+5=7 s f(e)=g(e)+dist(e,t)=2+7=9 2 Como o valor-f de a menor do 5 que de e, o processo 1 (busca 5 a f(a)=7 via a) permanece ativo 2 enquanto o processo 2 (busca via e) fica em estado de espera 2 4 f 4 b 4 c f(b)=g(b)+dist(b,t)=4+4=8 f(c)=g(c)+dist(c,t)=6+4=10 f(b)=8 f(c)=10 2 3 Como f(e)<f(c) agora o processo 2 prossegue para a 2 g 3 d cidade f 2
3 9 2
t
34
A*
f(f)=g(f)+dist(f,t)=7+4=11 Como f(f)>f(c) agora o processo 2 espera e o processo 1 prossegue
9 2
f(e)=9
s
2 5 5
f(a)=7 2 f(f)=11
4 f(c)=10 3 3
b
f(b)=8
f
2
d
3
g
2
t
35
A*
f(f)=g(f)+dist(f,t)=7+4=11 Como f(f)>f(c) agora o processo 2 espera e o processo 1 prossegue f(d)=g(d)+dist(d,t)=9+3=12 Como f(d)>f(f) o processo 2 reinicia
9 2
f(e)=9
s
2 5 5
f(a)=7 2 f(f)=11
4 f(c)=10 3 3
b
f(b)=8
f
2
d
3 f(d)=12
g
2
t
36
A*
f(f)=g(f)+dist(f,t)=7+4=11 Como f(f)>f(c) agora o processo 2 espera e o processo 1 prossegue f(d)=g(d)+dist(d,t)=9+3=12 Como f(d)>f(f) o processo 2 reinicia chegando at o destino t f(g)=g(g)+dist(g,t)=9+2=11
3 9 2
f(e)=9
s
2 5 5
f(a)=7 2 f(f)=11
4 f(c)=10 3
b
f(b)=8
f
2
d
3 f(d)=12
g
2 f(g)=11
t
37
A*
f(f)=g(f)+dist(f,t)=7+4=11 Como f(f)>f(c) agora o processo 2 espera e o processo 1 prossegue f(d)=g(d)+dist(d,t)=9+3=12 Como f(d)>f(f) o processo 2 reinicia chegando at o destino t f(g)=g(g)+dist(g,t)=9+2=11 f(t)=g(t)+dist(t,t)=11+0=11
9 2
f(e)=9
s
2 5 5
f(a)=7 2 f(f)=11
4 f(c)=10 3 3
b
f(b)=8
f
2
d
3 f(d)=12
g
2 f(g)=11
f(t)=11
38
A*
A busca, comeando pelo n inicial continua gerando novos ns sucessores, sempre expandindo na direo mais promissora de acordo com os valores-f Durante este processo, uma rvore de busca gerada tendo como raiz o n inicial e o algoritmo A* continua expandindo a rvore de busca at que uma soluo seja encontrada
39
A*
s
9 2
s
2 5 5
a
2 2
4 3 3
f
2
d
3
g
2
t
40
A*
s
9 2
s
2 f(a)=7
f(e)=9 5
a
2 2
4 3 3
f
2
d
3
g
2
t
41
A*
s
9 2
s
2 f(a)=7
f(e)=9 5
a
2 2
f(b)=8
4 3 3
f
2
d
3
g
2
t
42
A*
s
9 2
s
2 f(a)=7
f(e)=9 5
a
2 2
f(b)=8
4 3 3
f
2
f(c)=10
c d
g
3 2
t
43
A*
s
9 2
s
2 f(a)=7
f(e)=9 5
a
2 2
f(b)=8
f(f)=11
4 3 3
f
2
f(c)=10
c d
g
3 2
t
44
A*
s
9 2
s
2 f(a)=7
f(e)=9 5
a
2 2
f(b)=8
f(f)=11
4 3 3
f
2
f(c)=10
c d
g
3 2
f(d)=12
t
45
A*
s
9 2
s
2 f(a)=7
f(e)=9 5
a
2 2
f(b)=8
f(f)=11
4 3
f
2
f(c)=10
f(g)=11 3
d
3
g
2
f(d)=12
t
46
A*
s
9 2
s
2 f(a)=7
f(e)=9 5
a
2 2
f(b)=8
f(f)=11
4 3
f
2
f(c)=10
f(g)=11 3
d
3
g
2
f(d)=12
f(t)=11
t
47
A*: Encontre o caminho de Arad at Bucharest

Oradea 71 h(n) Arad 87 Zerind Bucharest 151 75 Craiova Iasi Dobreta Arad 140 92 Eforie Sibiu Fagaras Fagaras 99 Vaslui Giurgiu 118 80 Hirsova Rimnieu Iasi Timisoara Vilcea Lugoj 142 Mehadia 211 111 Pitesti Lugoj Neamt 97 Hirsova Oradea 70 98 Pitesti 85 146 Mehadia 101 Urziceni Rimnieu Vilcea 86 75 138 Sibiu Bucharest Timisoara Dobreta 120 90 Urziceni Eforie Craiova Vaslui Giurgiu Zerind Neamt
Assuma que os sucessores de um n so definidos em ordem alfabtica

366 0 160 242 161 176 77 151 226 244 241 234 380 100 193 253 329 80 199 374 48
Oradea 71 Zerind 75 Arad 140 Sibiu 118 80 Timisoara 111 70 Mehadia 75 Dobreta h(n) Arad Bucharest Craiova Dobreta Eforie Fagaras Giurgiu Hirsova Iasi Lugoj Mehadia Neamt Oradea 120 Craiova 366 0 160 242 161 176 77 151 226 244 241 234 380 146 138 101 85 Urziceni 86 Lugoj Rimnieu Vilcea 97 Pitesti 211 142 98 Hirsova 99 Fagaras Vaslui 151 Neamt 87 Iasi 92
Arad 366=0+366
Bucharest 90 Giurgiu
Eforie
Pitesti 100 Rimnieu Vilcea 193 Sibiu Timisoara Urziceni Vaslui Zerind 253 329 80 199 374
49
Arad 366=0+366 140 118 75
Eforie
Sibiu 393=140+253
Timisoara 447=118+329
Zerind 449=75+374
50
Arad 366=0+366 140 118 75
Eforie
Sibiu 393=140+253 99 151 80
Zerind 449=75+374
Fagaras 415=239+176
Oradea 671=291+380
Rimnieu Vilcea 413=220+193
51
Arad 366=0+366 140 118 75
Eforie
Sibiu 393=140+253 99 151 80
Zerind 449=75+374
Fagaras 415=239+176
Oradea 671=291+380 146
97 Pitesti 417=317+100
Craiova 526=366+160
52
Arad 366=0+366 140 118 75
Eforie
Sibiu 393=140+253 99 151 80
Zerind 449=75+374
Fagaras 415=239+176 211 Bucharest 450=450+0
Oradea 671=291+380 146
97 Pitesti 417=317+100
Craiova 526=366+160
53
Arad 366=0+366 140 118 75
Eforie
Sibiu 393=140+253 99 151 80
Zerind 449=75+374
Fagaras 415=239+176 211 Bucharest 450=450+0
Oradea 671=291+380 146
97 Pitesti 417=317+100 101 Bucharest 418=418+0 138 Craiova 615=455+160
Craiova 526=366+160
54
A*: Contornos em f=380, f=400 e f=420 (ns no interior do contorno tm valores-f menores ou iguais aos do contorno)
Oradea 71 Neamt

366 0 160 242 161 176 77 151 226 244 241 234 380 100 193 253 329 80 199 374 55
h(n) Arad 87 Zerind Bucharest 151 75 Craiova Iasi Dobreta Arad 140 92 Eforie Sibiu 380 Fagaras Fagaras 99 Vaslui Giurgiu 118 80 Hirsova Rimnieu 400 Iasi Timisoara Vilcea Lugoj 142 Mehadia 211 111 Pitesti Lugoj Neamt 97 Hirsova Oradea 70 98 Pitesti 85 146 Mehadia 101 Urziceni Rimnieu Vilcea 86 75 138 Sibiu Bucharest Timisoara Dobreta 120 420 90 Urziceni Eforie Craiova Vaslui Giurgiu Zerind
A*
A rvore de busca ser representada de duas formas:
l(N,F/G) representa um nico n folha (leaf)
N um n do espao de estados G g(N), custo do caminho encontrado desde o n inicial at N F f(N) = G + h(N)
t(N,F/G,Subs) representa uma rvore com sub-rvores no vazias

N a raiz da rvore Subs uma lista de suas sub-rvores (em ordem crescente de valores-f das sub-rvores) G g(N) F o valor-f atualizado de N, ou seja, o valor-f do sucessor mais promissor de N
56
A*
s
l(s,0/0)
57
A*
s
f(a)=7
f(e)=9
t(s,7/0, [ l(a,7/2), l(e,9/2) ] )
O valor-f da raiz s f(s)=7 pois o valor-f do sucessor mais promissor de s
58
A*
s
f(a)=7
f(e)=9
t(s,7/0, [ l(a,7/2), l(e,9/2) ] )
O competidor mais prximo de a e, com f(e)=9 Portanto, a permitido expandir enquanto f(a) no exceder 9
59
A*
s
f(a)=7
f(e)=9
f(b)=8
60
A*
s
f(a)=7
f(e)=9
f(b)=8
t(s,9/0, [ l(e,9/2), t(a,10/2, [ t(b,10/4, [l(c,10/6)]) ] ) ] ) Os ns b e c so expandidos e como f(c)=10 o limite de expanso atingido e ento a sub-rvore via a no tem mais permisso para expandir
61
f(c)=10
A*
s
f(a)=7
f(e)=9
f(b)=8
f(c)=10
t(s,9/0, [ l(e,9/2), t(a,10/2, [ t(b,10/4, [l(c,10/6)]) ] ) ] ) Note que agora f(a)=10 enquanto f(s)=9 Os valores foram atualizados devido ao fato que novos ns, b e c, foram gerados Agora o sucessor mais promissor de s e com f(e)=9
62
A*
A atualizao dos valores-f necessrio para permitir o programa reconhecer a subrvore mais promissora em cada nvel da rvore de busca (a rvore que contm o n mais promissor) Este atualizao leva a uma generalizao da definio da funo f de ns para rvores
63
A*
Para um nico n (folha) n, temos a definio original
f(n) = g(n) + h(n)
Para uma rvore T, cuja raiz n e as subrvores de n so S1, S2, ..., Sk

f(T) = min f(Si) 1 <= i <= k
64
A*
O predicado principal
expandir(P,rvore,Limite,rvore1,Resolvido,Soluo)
Este predicado expande uma (sub)rvore atual enquanto o valor-f dela permanea inferior ou igual Limite Argumentos:
P: caminho entre o n inicial e rvore rvore: atual (sub)rvore Limite: valor-f limite para expandir rvore rvore1: rvore expandida dentro de Limite; assim o valor-f de rvore1 maior que Limite (a menos que um n final tenha sido encontrado durante a expanso) Resolvido: Indicador que assume sim, no ou nunca Soluo: Um caminho (soluo) do n inicial atravs de rvore1 at um n final dentro de Limite (se existir tal n)
65
A*
Os argumentos de entrada so P, rvore e Limite expandir/6 produz trs tipos de resultados, indicados pelo valor do argumento Resolvido
1. Resolvido = sim 2. 3.
Soluo = uma soluo encontrada expandindo rvore dentro de Limite rvore1 = no instanciada Resolvido = no rvore1 = rvore expandida de forma que seu valor-f exceda Limite (vide slide seguinte) Soluo = no instanciada Resolvido = nunca rvore1 e Soluo = no instanciadas
O ltimo caso indica que rvore uma alternativa invivel e nunca deve ter outra chance de crescer; isto ocorre quando o valor-f de rvore <= Limite mas as rvore no pode crescer porque nenhuma folha dela possui sucessor ou o sucessor existente criaria um ciclo
66
A Relao expandir/6
N inicial P (caminho)
n
Expandindo rvore at que seu valor-f exceda Limite resulta em rvore1
rvore rvore1
f > Limite
67
Algoritmo A*
% Assuma que 9999 maior que qualquer valor-f resolvai1(No,Solucao) :expandir([],l(No,0/0),9999,_,sim,Solucao). % % % % expandir(P,Arvore,Limite,Arvore1,Resolvido,Solucao) P um caminho entre n inicial da busca e subrvore Arvore, Arvore1 Arvore expandida at Limite. Se um n final encontrado ento Solucao a soluo e Resolvido = sim
% Caso 1: n folha final, construir caminho da soluo expandir(P,l(N,_),_,_,sim,[N|P]) :final(N). % Caso 2: n folha, valor-f <= Limite. Gerar sucessores e expandir dentro de Limite expandir(P,l(N,F/G),Limite,Arvore1,Resolvido,Solucao) :F =< Limite, (findall(M/Custo, (s(N,M,Custo), \+ pertence(M,P)),Vizinhos), Vizinhos \= [], % n N tem sucessores !, avalie(G,Vizinhos,Ts), % crie subrvores melhorf(Ts,F1), % valor-f do melhor sucessor expandir(P,t(N,F1/G,Ts),Limite,Arvore1,Resolvido,Solucao) ; Resolvido = nunca % N no tem sucessores beco sem sada ).
68
Algoritmo A* (cont.)
% Caso 3: no-folha, valor-f <= Limite. Expanda a subrvore mais % promissora; dependendo dos resultados, o predicado continue % decide como proceder expandir(P,t(N,F/G,[T|Ts]),Limite,Arvore1,Resolvido,Solucao) :F =< Limite, melhorf(Ts,MF), min(Limite,MF,Limite1), % Limite1 = min(Limite,MF) expandir([N|P],T,Limite1,T1,Resolvido1,Solucao),
continue(P,t(N,F/G,[T1|Ts]),Limite,Arvore1,Resolvido1,Resolvido,Solucao).
% Caso 4: no-folha com subrvores vazias % Beco sem sada que nunca ser resolvido expandir(_,t(_,_,[]),_,_,nunca,_) :- !. % Caso 5: valor f > Limite, rvore no pode crescer expandir(_,Arvore,Limite,Arvore,nao,_) :f(Arvore,F), F > Limite.
69
% continue(Caminho,Arvore,Limite,NovaArvore,SubarvoreResolvida,ArvoreResolvida,Solucao)
continue(_,_,_,_,sim,sim,_). % soluo encontrada % Limite ultrapassado, procurar outra subrvore para expandir continue(P,t(N,F/G,[T1|Ts]),Limite,Arvore1,nao,Resolvido,Solucao) :inserir(T1,Ts,NTs), melhorf(NTs,F1), expandir(P,t(N,F1/G,NTs),Limite,Arvore1,Resolvido,Solucao). % abandonar T1 pois beco sem sada continue(P,t(N,F/G,[T1|Ts]),Limite,Arvore1,nunca,Resolvido,Solucao) :melhorf(Ts,F1), expandir(P,t(N,F1/G,Ts),Limite,Arvore1,Resolvido,Solucao). % avalie(G0,[No1/Custo1,...],[l(MelhorNo,MelhorF/G,...]) % ordena a lista de folhas pelos seus valores-f avalie(_,[],[]). avalie(G0,[N/C|NaoAvaliados],Ts) :G is G0 + C, h(N,H), F is G + H, avalie(G0,NaoAvaliados,Avaliados), inserir(l(N,F/G),Avaliados,Ts).
70
% insere T na lista de rvore Ts mantendo a ordem dos valores-f inserir(T,Ts,[T|Ts]) :f(T,F), melhorf(Ts,F1), F =< F1, !. inserir(T,[T1|Ts],[T1|Ts1]) :inserir(T,Ts,Ts1). % Obter o valor f f(l(_,F/_),F). f(t(_,F/_,_),F). melhorf([T|_],F) :f(T,F). melhorf([],9999). min(X,Y,X) :X =< Y, !. min(X,Y,Y). pertence(E,[E|_]). pertence(E,[_|T]) :pertence(E,T).
71
% valor-f de uma folha % valor-f de uma rvore % melhor valor-f de uma lista de rvores % Nenhuma rvore: definir valor-f ruim
Admissibilidade de A*
Um algoritmo de busca chamado de admissvel se ele sempre produz uma soluo tima (caminho de custo mnimo), assumindo que uma soluo exista A implementao apresentada, que produz todas as solues por meio de backtracking e pode ser considerada admissvel se a primeira soluo encontrada tima Para cada n n no espao de estados vamos denotar h*(n) como sendo o custo de um caminho timo de n at um n final Um teorema sobre a admissibilidade de A* diz que um algoritmo A* que utiliza uma funo heurstica h tal que para todos os ns no espao de estados h(n) <= h*(n) admissvel Este resultado tem grande valor prtico
Mesmo que no conheamos o exato valor de h*, ns s precisamos achar um limite inferior para h* e utiliz-la como h em A* Isto suficiente para garantir que A* ir encontrar uma soluo tima
72
H um limite inferior trivial
h(n) = 0 para todo n no espao de estados
Embora este limite trivial garanta admissibilidade sua desvantagem que no h nenhuma heurstica e assim no h como fornecer nenhum auxlio para a busca, resultando em alta complexidade
A* usando h(n)=0 comporta-se de forma similar busca em largura e igual busca de custo uniforme De fato, A* se comporta exatamente igual busca em largura se todos os arcos entre ns tm custo unitrio, ou seja, s(X,Y,1)
73
Portanto interessante utilizar h>0 para garantir admissibilidade e h o mais prximo possvel de h* (h<=h*) para garantir eficincia Se mltiplas heursticas esto disponveis:
h(n) = mximo {h1(n), h2(n), , hm(n)}
De maneira ideal, se h* conhecida, podemos utilizar h* diretamente

A* utilizando h* encontra uma soluo tima diretamente, sem nunca precisar realizar backtracking
74
A*: Funo de Avaliao

A funo heurstica h monotnica (consistente) se
h(n) >= h(sucessor(n))
isso se aplica maioria das funes heursticas Toda heurstica consistente admissvel
Transferindo esse resultado para a funo de avaliao f=g+h:

f(sucessor(n)) >= f(n)
uma vez que g no decrescente
Em outras palavras, o custo de cada n gerado no mesmo caminho nunca diminui Se h no monotnica, para se garantir a monotonicidade de f:
quando f(suc(n)) < f(n) usa-se f(suc(n)) = max( f(n), g(suc(n))+h(suc(n)) )
75
Complexidade de A*
A utilizao de heurstica para guiar o algoritmo A* reduz a busca a apenas uma regio do espao do problema Apesar da reduo no esforo da busca, a ordem de complexidade ainda exponencial na profundidade de busca O(bd)
Isso vlido para tempo e memria uma vez que o algoritmo mantm todos os ns gerados
Em situaes prticas o espao de memria mais crtico e A* pode utilizar toda a memria disponvel em questo de minutos
76
Complexidade de A*
A* o algoritmo de busca mais rpido, ou seja, para uma dada heurstica, nenhum outro algoritmo pode expandir menos ns que A* A velocidade de A* depende da qualidade da heurstica
Se a heurstica desprezvel (por exemplo, h(n)=0 para todo n) o algoritmo degenera para a busca de custo uniforme Se a heurstica perfeita (h=h*) no h busca de fato; o algoritmo marcha diretamente at o objetivo
Geralmente, os problemas reais se encontram entre as duas situaes acima e, portanto, o tempo de execuo de A* vai depender da qualidade da heurstica
77
Complexidade de A*
Algumas variaes de A* foram desenvolvidas para utilizar menos memria, penalizando o tempo
A idia bsica similar busca em profundidade iterativa O espao necessrio reduz de exponencial para linear na profundidade de busca O preo a re-expanso de ns j expandidos no espao de busca
Veremos duas dessas tcnicas:

IDA* (Iterative Deepening A*) RBFS (Recursive Best-First Search)
78
IDA*
IDA* similar busca em profundidade iterativa
Na busca em profundidade iterativa as buscas em profundidade so realizadas em limites crescentes de profundidade; em cada iterao a busca em profundidade limitada pelo limite de profundidade atual Em IDA* as buscas em profundidade so limitadas pelo limite atual representando valores-f dos ns
79
IDA*
procedure idastar(Inicio,Solucao) Limite f(Inicio) repeat Iniciando no n Incio, realize busca em profundidade sujeita condio que um n N expandido apenas se f(N) <= Limite if busca em profundidade encontrou n final then indique Soluo encontrada else Calcule NovoLimite como o mnimo valor-f dos ns alcanados ao ultrapassar Limite, ou seja, NovoLimite min{f(N): N gerado pela busca e f(N) > Limite} endif Limite NovoLimite until Soluo encontrada
80
IDA*
s
f(s)=6
Efetue busca em profundidade limitada por f<=6, iniciando no n s
Limite = 6
81
IDA*
s
f(s)=6
f(a)=7 > Limite
Limite = 6
82
IDA*
s
f(s)=6
f(a)=7 > Limite
f(e)=9 > Limite
Limite = 6
83
IDA*
s
f(s)=6
f(a)=7 > Limite
f(e)=9 > Limite
NovoLimite = mn{7,9} = 7 Efetue busca em profundidade limitada por f<=7, iniciando pelo n s
Limite = 7
84
IDA*
s
f(s)=6
Limite = 7
85
IDA*
s
f(s)=6
f(a)=7
Limite = 7
86
IDA*
s
f(s)=6
f(a)=7
f(b)=8 > Limite
Limite = 7
87
IDA*
s
f(s)=6
f(a)=7
f(e)=9 > Limite
f(b)=8 > Limite
Limite = 7
88
IDA*
s
f(s)=6
f(a)=7
f(e)=9 > Limite
f(b)=8 > Limite
Limite = 8
89
IDA*
s
f(s)=6
Limite = 8
90
IDA*
s
f(s)=6
f(a)=7
Limite = 8
91
IDA*
s
f(s)=6
f(a)=7
f(b)=8
Limite = 8
92
IDA*
s
f(s)=6
f(a)=7
f(b)=8
f(c)=10 > Limite
Limite = 8
93
IDA*
s
f(s)=6
f(a)=7
f(e)=9 > Limite
f(b)=8
f(c)=10 > Limite
Limite = 8
94
IDA*
s
f(s)=6
f(a)=7
f(e)=9 > Limite
f(b)=8
f(c)=10 > Limite
Limite = 9
95
IDA*
s
f(s)=6
Limite = 9
96
IDA*
s
f(s)=6
f(a)=7
Limite = 9
97
IDA*
s
f(s)=6
f(a)=7
f(b)=8
Limite = 9
98
IDA*
s
f(s)=6
f(a)=7
f(b)=8
f(c)=10 > Limite
Limite = 9
99
IDA*
s
f(s)=6
f(a)=7
f(e)=9
f(b)=8
f(c)=10 > Limite
Limite = 9
100
IDA*
s
f(s)=6
f(a)=7
f(e)=9
f(b)=8
f(f)=11 > Limite
f(c)=10 > Limite
Limite = 9
101
IDA*
s
f(s)=6
f(a)=7
f(e)=9
f(b)=8
f(f)=11 > Limite
f(c)=10 > Limite
Limite = 10
102
IDA*
s
f(s)=6
Limite = 10
103
IDA*
s
f(s)=6
f(a)=7
Limite = 10
104
IDA*
s
f(s)=6
f(a)=7
f(b)=8
Limite = 10
105
IDA*
s
f(s)=6
f(a)=7
f(b)=8
f(c)=10
Limite = 10
106
IDA*
s
f(s)=6
f(a)=7
f(b)=8
f(c)=10
f(d)=12 > Limite
Limite = 10
107
IDA*
s
f(s)=6
f(a)=7
f(e)=9
f(b)=8
f(c)=10
f(d)=12 > Limite
Limite = 10
108
IDA*
s
f(s)=6
f(a)=7
f(e)=9
f(b)=8
f(f)=11 > Limite
f(c)=10
f(d)=12 > Limite
Limite = 10
109
IDA*
s
f(s)=6
f(a)=7
f(e)=9
f(b)=8
f(f)=11 > Limite
f(c)=10
f(d)=12 > Limite
Limite = 11
110
IDA*
s
f(s)=6
Limite = 11
111
IDA*
s
f(s)=6
f(a)=7
Limite = 11
112
IDA*
s
f(s)=6
f(a)=7
f(b)=8
Limite = 11
113
IDA*
s
f(s)=6
f(a)=7
f(b)=8
f(c)=10
Limite = 11
114
IDA*
s
f(s)=6
f(a)=7
f(b)=8
f(c)=10
f(d)=12 > Limite
Limite = 11
115
IDA*
s
f(s)=6
f(a)=7
f(e)=9
f(b)=8
f(c)=10
f(d)=12 > Limite
Limite = 11
116
IDA*
s
f(s)=6
f(a)=7
f(e)=9
f(b)=8
f(f)=11
f(c)=10
f(d)=12 > Limite
Limite = 11
117
IDA*
s
f(s)=6
f(a)=7
f(e)=9
f(b)=8
f(f)=11
f(c)=10
f(g)=11
f(d)=12 > Limite
Limite = 11
118
IDA*
s
f(s)=6
f(a)=7
f(e)=9
f(b)=8
Com a busca em profundidade com Limite = 11 uma soluo encontrada
f(f)=11
f(c)=10
f(g)=11
f(d)=12 > Limite
Limite = 11
f(t)=11
119
IDA*
% Assuma que 9999 maior que qualquer valor-f :- dynamic proximo_limite/1,solucao/1. resolvai2(No,Solucao) :retract(proximo_limite(_)), % limpa proximo limite fail ; assert(proximo_limite(0)), % inicializa proximo limite idastar(l(No,0/0),Solucao). idastar(l(N,F/G),Solucao) :retract(proximo_limite(Limite)), assert(proximo_limite(9999)), df(l(N,F/G),[N],Limite,Solucao). idastar(No,Solucao) :proximo_limite(Limite), Limite < 9999, idastar(No,Solucao).
120
IDA*
% % % % df(No,Caminho,Limite,Solucao) Realiza busca em profundidade dentro de Limite Caminho um caminho entre n inicial ate o No atual F e' o valor-f do no atual que se encontra no inicio do Caminho
% Caso 1: n N final dentro de Limite, construir caminho da solucao df(l(N,F/G),[N|P],Limite,[N|P]) :F =< Limite, final(N). % Caso 2: n N com valor-f <= Limite % Gerar sucessor de N e expandir dentro de Limite df(l(N,F/G),[N|P],Limite,Solucao) :F =< Limite, s(N,M,Custo), \+ pertence(M,P), Gm is G + Custo, % avaliar no' M h(M,Hm), Fm is Gm + Hm, df(l(M,Fm/Gm),[M,N|P],Limite,Solucao).
121
IDA*
% Caso 3: valor f > Limite, atualizar proximo limite % e falhar df(l(N,F/G),_,Limite,_) :F > Limite, atualize_proximo_limite(F), fail. atualize_proximo_limite(F) :proximo_limite(Limite), Limite =< F, ! ; retract(proximo_limite(Limite)),!, assert(proximo_limite(F)). pertence(E,[E|_]). pertence(E,[_|T]) :pertence(E,T).
% nao altere proximo limite % diminua proximo limite
122
IDA*
Uma propriedade interessante de IDA* refere-se sua admissibilidade
Assumindo f(n) = g(n)+h(n), se h admissvel (h(n) <= h*(n)) ento garantido que IDA* encontre uma soluo tima
Entretanto, no garantido que IDA* explore os ns mesma ordem que A* (ou seja, na ordem de valores-f crescentes)
Quando f no da forma f=g+h e f no monotnica
123
RBFS
Vimos que IDA* possui uma implementao simples Entretanto, no pior caso, quando os valores-f no so compartilhados entre vrios ns ento muitos limites sucessivos de valores-f so necessrios e a nova busca em profundidade expandir apenas um novo n enquanto todos os demais so apenas re-expanses de ns expandidos e esquecidos Nessa situao existe uma tcnica para economizar espao denominada RBFS (recursive best-first search)
124
RBFS
RBFS similar a A*, mas enquanto A* mantm em memria todos os ns expandidos, RBFS apenas mantm o caminho atual assim como seus irmos Quando RBFS suspende temporariamente um subprocesso de busca (porque ele deixou de ser o melhor), ela esquece a subrvore de busca para economizar espao Assim como IDA*, RBFS apenas linear na profundidade do espao de estados em quantidade de memria necessria
125
RBFS
O nico fato que RBFS armazena sobre a subrvore de busca abandonada o valor-f atualizado da raiz da subrvore Os valores-f so atualizados copiando-se os valores-f de forma similar ao algoritmo A* Para distinguir entre os valores-f estticos e aqueles copiados, usaremos:
f(n) = valor-f do n n utilizando a funo de avaliao (sempre o mesmo valor durante a busca) F(n) = valor-f copiado ( alterado durante a busca uma vez que depende dos ns descendentes de n)
F(n) definida como:

F(n) = f(n) se n nunca foi expandido durante a busca F(n) = mn{F(ni) : ni um sucessor de n}
126
RBFS
Assim como A*, RBFS explora subrvores dentro de um limite de valor-f O limite determinado pelos valores-F dos filhos ao longo do caminho atual (o melhor valor-F dos filhos, ou seja, o valor-F do competidor mais promissor do n atual) Seja n o melhor n (aquele com menor valor-F)
Ento n expandido e seus filhos so explorados at algum limite de valor-f Quando o limite excedido (F(n) > Limite) ento todos os ns expandidos a partir de n so esquecidos Entretanto, o valor F(n) atualizado retido e utilizado na deciso em como a busca deve continuar
127
RBFS
Os valores-F so determinados no apenas copiando os valores obtidos a partir de um dos filhos mas tambm so herdados dos ns pais da seguinte forma Seja n um n que deve ser expandido pela busca Se F(n)>f(n) ento sabemos que n deve ter sido expandido anteriormente e que F(n) foi determinado a partir dos filhos de n, mas os filhos foram removidos da memria Suponha que um filho ni de n seja novamente expandido e o valor esttico f(ni) seja calculado novamente Ento F(ni) determinado como sendo
if f(ni)<F(n) then F(ni) F(n) else F(ni) f(ni) F(ni) mx{F(n), f(ni)}
que pode ser escrito como:
128
RBFS
s
129
RBFS
s
F(a)=7
F(e)=9
O melhor candidato o n a, pois F(a)<F(e). A busca prossegue via a
Limite = 9
130
RBFS
s
F(a)=7
F(e)=9
F(b)=8
Limite = 9
131
RBFS
s
F(a)=7
a
Como F(c) > Limite, o caminho s-a-b-c temporariamente abandonado e os ns b e c so removidos da memria; o valor F(c)=10 ento copiado para o n a, ou seja, F(a) = 10
F(e)=9
F(b)=8
F(c)=10 > Limite
Limite = 9
132
RBFS
s
F(a)=10
F(e)=9
Limite = 10
133
RBFS
s
F(a)=10
a
Como F(f) > Limite, o caminho s-e-f temporariamente abandonado e o n f removido da memria; o valor F(f)=11 ento copiado para o n e, ou seja, F(e) = 11
F(e)=9
F(f)=11 > Limite
Limite = 10
134
RBFS
s
F(a)=10
F(e)=11
Limite = 11
135
RBFS
s
F(a)=10
F(e)=11
F(b)=10
Limite = 11
136
RBFS
s
F(a)=10
F(e)=11
F(b)=10
F(c)=10
Limite = 11
137
RBFS
s
F(a)=10
a
Como F(d) > Limite, o caminho s-a-b-c-d temporariamente abandonado e os ns b, c e d so removidos da memria; o valor F(d)=12 ento copiado para o n a, ou seja, F(a)=12
F(e)=11
F(b)=10
F(c)=10
F(d)=12 > Limite
Limite = 11
138
RBFS
s
F(a)=12
F(e)=11
Limite = 12
139
RBFS
s
F(a)=12
F(e)=11
F(f)=11
Limite = 12
140
RBFS
s
F(a)=12
F(e)=11
F(f)=11
F(g)=11
Limite = 12
141
RBFS
s
F(a)=12
F(e)=11
f
Com a busca com Limite = 12 uma soluo encontrada
F(f)=11
F(g)=11
Limite = 12
F(t)=11
142
RBFS
rbfs(Caminho,Filhos,Limite,NovoMelhorFF,Resolvido, Solucao):
Caminho = caminho at ento na ordem reversa Filhos = filhos da cabea do Caminho Limite = limite superior no valor-F da busca para os Filhos NovoMelhorFF = melhor valor-f justamente quando busca ultrapassa Limite Resolvido = sim, no, nunca Solucao = caminho da soluao, se Resolvido = sim
Representacao dos nos: No = l(Estado,G/F/FF)

G o custo at Estado F o valor-f esttico de Estado FF o valor-f de Estado copiado
143
RBFS
% Assuma que 9999 maior que qualquer valor-f resolvai3(No,Solucao) :rbfs([],[l(No,0/0/0)],9999,_,sim,Solucao). % rbfs(Caminho,Filhos,Limite,NovoMelhorFF,Resolvido,Solucao) rbfs(Caminho,[l(No,G/F/FF)|Nos],Limite,FF,nao,_) :FF > Limite, !. rbfs(Caminho,[l(No,G/F/FF)|_],_,_,sim,[No|Caminho]) :F = FF, % Mostrar solucao apenas uma vez,quando F=FF final(No). rbfs(_,[],_,_,nunca,_) :- !. % Sem candidatos,beco sem saida rbfs(Caminho,[l(No,G/F/FF)|Ns],Limite,NovoFF,Resolvido,Sol) :FF =< Limite, % Dentro de Limite: gerar filhos findall(Filho/Custo, (s(No,Filho,Custo),\+ pertence(Filho,Caminho)), Filhos), herdar(F,FF,FFherdado), % Filhos podem herdar FF avalie(G,FFherdado,Filhos,Sucessores), % Ordenar filhos melhorff(Ns,ProximoMelhorFF), % FF do competidor mais promissor dos filhos min(Limite,ProximoMelhorFF,Limite2), !, rbfs([No|Caminho],Sucessores,Limite2,NovoFF2,Resolvido2,Sol), continue(Caminho,[l(No,G/F/NovoFF2)|Ns],Limite, NovoFF,Resolvido2,Resolvido,Sol).
144
RBFS
% continue(Caminho,Nos,Limite,NovoFF,FilhoResolvido,Resolvido,Solucao) continue(Caminho,[N|Ns],Limite,NovoFF,nunca,Resolvido,Sol) :!, rbfs( Caminho,Ns,Limite,NovoFF,Resolvido,Sol). % N um beco sem saida continue(_,_,_,_,sim,sim,Sol). continue(Caminho,[N|Ns],Limite,NovoFF,nao,Resolvido,Sol) :inserir(N,Ns,NovoNs), !,% Assegurar que filhos sao ordenados pelos valores rbfs(Caminho,NovoNs,Limite,NovoFF,Resolvido,Sol). avalie(_,_,[],[]). avalie(G0,FFherdado,[No/C|NCs],Nos) :G is G0 + C, h(No,H), F is G + H, max(F,FFherdado,FF), avalie(G0,FFherdado,NCs,Nos2), inserir(l(No,G/F/FF),Nos2,Nos). herdar(F,FF,FF) :FF > F, !. herdar(F,FF,0). % Filho herda FF do pai se % FF do pai e' maior que F do pai
145
RBFS
inserir(l(N,G/F/FF),Nos,[l(N,G/F/FF)|Nos]) :melhorff(Nos,FF2), FF =< FF2, !. inserir(N,[N1|Ns],[N1|Ns1]) :inserir(N,Ns,Ns1). melhorff([l(N,F/G/FF)|Ns],FF). melhorff([],9999). pertence(E,[E|_]). pertence(E,[_|T]) :pertence(E,T). min(X,Y,X) :X =< Y, !. min(X,Y,Y). max(X,Y,X) :X >= Y, !. max(X,Y,Y).
146
% Primeiro no' = melhor FF % Sem nos FF = "infinito"
Algoritmos de Busca Local

Os algoritmos de busca (informada ou no) exploram sistematicamente o espao de busca, mantendo um ou mais caminhos na memria
Quando um n final encontrado, o caminho at ele constitui uma soluo para o problema
Todavia, em algumas situaes, o caminho at o n final irrelevante

No problema da 8-rainhas o que importa a configurao final no tabuleiro e no a ordem em que as rainhas so acrescentadas Outros exemplos incluem projetos de circuitos integrados, otimizao de rede de comunicao, roteamento de veculos, etc
147

Dessa forma, se o caminho no importante, podemos considerar uma classe diferente de algoritmos de busca Os algoritmos de busca local trabalham usando um nico estado corrente (ao invs de vrios caminhos) e, em geral, se movem apenas para os vizinhos desse estado
Normalmente, os caminhos no so armazenados
Embora os algoritmos de busca local no sejam sistemticos, eles apresentam vantagens:

Utilizam pouca memria (em geral, um valor constante) Podem encontrar solues razoveis em espaos muito grande ou infinito, para os quais os algoritmos sistemticos no so adequados
Alm de encontrar estados finais, os algoritmos de busca local so teis para resolver problemas de otimizao, nos quais o objetivo encontrar o melhor estado de acordo com uma funo objetivo
148

Uma forma de entender os algoritmos de busca local consiste em considerar a topologia do espao de estados definida pela posio no espao de estados versus a elevao, definida pelo valor da funo de avaliao
Se a elevao corresponder ao custo, o objetivo ser encontrar um mnimo global (vale) Se a elevao corresponder a uma funo objetivo que deve ser maximizada, ento o objetivo ser encontrar um mximo global (pico) funo de avaliao
mximo global
mnimo global
estado atual
espao de estados
149
Algoritmo de Subida de Encosta

O algoritmo de subida de encosta (hill-climbing) se move de forma contnua no sentido crescente da funo de avaliao, ou seja, encosta acima; o algoritmo termina ao encontrar um pico (um mximo)
O algoritmo tambm conhecido como gradiente descendente, se o objetivo minimizar a funo de avaliao
O algoritmo no mantm uma rvore de busca mas somente o estado atual e o valor de sua funo de avaliao O algoritmo no explora valores da funo de avaliao alm dos vizinhos imediatos ao estado atual
como escalar o monte Everest em um nevoeiro denso com amnsia como usar culos que limitam sua viso a 3 metros
150

O algoritmo tambm chamado de busca gulosa local, pois captura um bom estado vizinho sem decidir com antecedncia para onde ir em seguida O algoritmo tende a ser rpido ao encontrar uma soluo pois sempre fcil melhorar um estado ruim Problemas
Mximo local: uma vez atingido, o algoritmo termina mesmo que a soluo esteja longe de ser satisfatria Plats (regies planas): regies onde a funo de avaliao essencialmente plana; isso pode impedir o algoritmo de encontrar uma sada do plat Picos: vrios mximos locais no interligados no espao de estados, o que dificulta a navegao pelo algoritmo
151

funo de avaliao
ombro mximo global
mximo local
mximo local plano
estado atual
espao de estados
152
153

1. 2. 3. 4. 5.
Escolha um estado inicial do espao de busca (pode ser escolhido de forma aleatria) Considere todos os vizinhos (sucessores) no espao de busca Escolha o vizinho com a melhor qualidade (funo de avaliao) e mova para aquele estado Repita os passos de 2 at 4 at que todos os estados vizinhos tenham qualidade menor que o estado atual Retorne o estado atual como sendo a soluo Se h mais de um vizinho com a melhor qualidade:
Escolher o primeiro melhor Escolher um entre todos de forma aleatria
154

O algoritmo dado a seguir consiste numa extenso do algoritmo bsico de subida de encosta
Detectando ciclos Retrocedendo se no encontrar uma soluo
O algoritmo foi deixado o mais prximo possvel aos j vistos, mas pode ser otimizado de vrias formas
O retrocesso pode ser eliminado (por exemplo, por um corte) A fila de prioridade pode ser substituda por um algoritmo de ordenao (por exemplo, quicksort) De fato, a fila de prioridade pode ser eliminada, pois o que importa somente o sucessor de melhor qualidade (entretanto, se a fila for removida isso tambm elimina a possibilidade de retrocesso) Tais otimizaes so deixadas como exerccios
155
Hill-Climbing (com retrocesso e deteco de ciclos)

resolvai4(No,Solucao) :hillclimbing([No]:0,Solucao). hillclimbing([No|Caminho]:H,[No|Caminho]) :final(No). hillclimbing(Caminho:H,Solucao) :estender(Caminho,NovosCaminhos), fila_prioridade(NovosCaminhos,[],Caminhos1), pertence(Melhor,Caminhos1), hillclimbing(Melhor,Solucao).
% ordenacao por h % seleciona melhor vizinho % e continua a partir dele
estender([No|Caminho],NovosCaminhos) :findall([NovoNo,No|Caminho]:H, (s(No,NovoNo), \+ pertence(NovoNo,[No|Caminho]), h(NovoNo,H)), NovosCaminhos). % fila_prioridade(NovosCaminhos,CaminhosExistentes,CaminhosOrdenados) % concatena (com prioridade) os NovosCaminhos em CaminhosExistenes formando CaminhosOrdenados % assumindo que CaminhosExistentes ja esta ordenado por prioridade (ou seja, por h) fila_prioridade([],L,L). fila_prioridade([Caminho:H|Caminhos],Existente,Final) :insert(Caminho:H,Existente,ExistenteAumentado), fila_prioridade(Caminhos,ExistenteAumentado,Final). insert(Caminho:H,[Path:Hs|Paths],[Path:Hs|NewPaths]) :H > Hs, !, insert(Caminho:H,Paths,NewPaths). insert(C,Paths,[C|Paths]).
156
2 8 6 2 8 6 2 8
Exemplo 1
1 2 8 6 3 5
4 7 1
5
5 3 5 1 2 6 3 8 5
h(n)
Neste exemplo, a heurstica distncia Manhattan permite encontrar uma soluo rapidamente por hill-climbing
4 7
4 7 1 4 7
4 7
3 5 6 1 2 8 2 4 7 8 3 5 6 3 5 6 1 3 2 8 5 6
1 4
2 8 7
3 5 6 3
4 7 1
1 4 7 1 4 7 2 5 8 3 6
2 5 8
1
6 1 2 5 8 3 6
4 7
4 7
2
157
Exemplo 2
Neste exemplo, com a mesma heurstica, hillclimbing no consegue encontrar uma soluo Todos os ns vizinhos (sucessores) tm valores maiores (mnimo local) Observe que este jogo tem soluo em apenas mais 12 movimentos
1 4 6 1 4 6 2 5 3 8 7 2 5 7 1 2 5 7 8 3 3 8
h(n)
4 6
1 4 6
2 7
3 5 8
2 5 7 3 8
4 6
158
Hill-Climbing: Variaes
Hill-Climbing Estocstico
Nem sempre escolha o melhor vizinho
Hill-Climbing Primeira Escolha

Escolha o primeiro bom vizinho que encontrar
til se grande o nmero de sucessores de um n
Hill-Climbing Reincio Aleatrio

Conduz uma srie de buscas hill-climbing a partir de estados iniciais gerados aleatoriamente, executando cada busca at terminar ou at que no exista progresso significativo O melhor resultado de todas as buscas armazenado
159
Hill-Climbing Reincio Aleatrio

funo de avaliao
espao de estados
160
Hill-Climbing: Variaes
Tmpera Simulada (Simulated Annealing)
Termo utilizado em metalurgia No estratgia best-first mas uma derivao O objetivo que as molculas de metal encontrem uma localizao estvel em relao aos seus vizinhos O aquecimento provoca movimento das molculas de metal para localizaes indesejveis Durante o resfriamento, as molculas reduzem seus movimentos e situam-se em uma localizao mais estvel Tmpera o processo de aquecer um metal e deix-lo esfriar lentamente de forma que as molculas fiquem em localizaes estveis
161
Tmpera Simulada
1. 2. 3. 4. 5. 6. 7.
8. 9. 10. 11.
Escolha um estado inicial do espao de busca de forma aleatria i 1 T Temperatura(i) Enquanto (T > Tf) Faa Escolha um vizinho (sucessor) do estado atual de forma aleatria deltaE energia(vizinho) energia(atual) Se (deltaE > 0) Ento o movimento aceito (mova para o vizinho de melhor qualidade) Seno o movimento aceito com probabilidade exp(deltaE/T) Fim Se i i+1 T Temperatura(i) Fim Enquanto Retorne o estado atual como sendo a soluo energia(N) uma funo que calcula a energia do estado N e pode ser vista como qualidade Temperatura(i) uma funo que calcula a temperatura na iterao i, assumindo sempre valores positivos Tf a temperatura final (por exemplo, Tf = 0)
162
Tmpera Simulada
No incio qualquer movimento aceito Quando a temperatura reduzida, probabilidade de aceitar um movimento negativo reduzida Movimentos negativos so as vezes essenciais para escapar de mximos locais Movimentos negativos em excesso afastam do mximo global
163
Busca em Feixe Local

O algoritmo de busca em feixe local (beam search) mantm k estados em memria Inicialmente, os k estados so escolhidos de forma aleatria Em cada passo, so gerados todos os sucessores de todos os k estados
Se algum deles for o estado final, ento o algoritmo termina Caso contrrio, o algoritmo seleciona apenas os k melhores sucessores a partir da lista completa e repete o processo
164
Resumo
Vimos que os algoritmos IDA* e RBFS necessitam de quantidade de espao linear na profundidade da busca Diferentemente de IDA* e como A*, RBFS expande ns na ordem best-first mesmo no caso de uma funo f no monotnica
165
Slides baseados nos livros: Bratko, I.; Prolog Programming for Artificial Intelligence, 3rd Edition, Pearson Education, 2001. Clocksin, W.F.; Mellish, C.S.; Programming in Prolog, 5th Edition, Springer-Verlag, 2003.
Material elaborado por Jos Augusto Baranauskas Reviso 2009
166

IA Busca Informada

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

IA Busca Informada

Uploaded by

Copyright:

Available Formats

Estratgias de Busca Informada

Jos Augusto Baranauskas Departamento de Computao e Matemtica FFCLRP-USP

Funo Heurstica: Distncia em Linha Reta

Funo Heurstica I para o QuebraCabea de 8 Peas

Funo Heurstica II para o QuebraCabea de 8 Peas

Busca Gulosa pela Melhor Escolha

Greedy best-first semelhante busca em profundidade

Busca Gulosa pela Melhor Escolha

Busca Gulosa pela Melhor Escolha

Busca Gulosa pela Melhor Escolha

Busca Gulosa pela Melhor Escolha

Busca Gulosa pela Melhor Escolha

Busca Gulosa pela Melhor Escolha

Custo da soluo encontrada s-a-b-c-d-t = 12 Custo da soluo tima s-e-f-g-t = 11

Busca Gulosa pela Melhor Escolha: Encontre o caminho de Arad at Bucharest

Assuma que os sucessores de um n so definidos em ordem alfabtica

Distncia em linha reta at Bucharest

Encontre o caminho de Arad at Bucharest

Encontre o caminho de Arad at Bucharest

Encontre o caminho de Arad at Bucharest

Rimnieu Vilcea 193

Encontre o caminho de Arad at Bucharest

Rimnieu Vilcea 193

Busca Gulosa pela Melhor Escolha (greedy best-first)

Busca de Custo Uniforme

Intuio: Expanda o n mais barato, onde o custo o custo do caminho g(n)

Busca Gulosa pela Melhor Escolha

4 Distncia entre a cidade em questo e a cidade destino (t) em linha reta 3 3

O primeiro n a ser expandido o n inicial (raiz da busca)

A*: Encontre o caminho de Arad at Bucharest

Assuma que os sucessores de um n so definidos em ordem alfabtica

Distncia em linha reta at Bucharest

Arad 366=0+366 140 118 75

Arad 366=0+366 140 118 75

Sibiu 393=140+253 99 151 80

Rimnieu Vilcea 413=220+193

Arad 366=0+366 140 118 75

Sibiu 393=140+253 99 151 80

Oradea 671=291+380 146

Rimnieu Vilcea 413=220+193

Arad 366=0+366 140 118 75

Sibiu 393=140+253 99 151 80

Fagaras 415=239+176 211 Bucharest 450=450+0

Oradea 671=291+380 146

Rimnieu Vilcea 413=220+193

Arad 366=0+366 140 118 75

Sibiu 393=140+253 99 151 80

Fagaras 415=239+176 211 Bucharest 450=450+0

Oradea 671=291+380 146

Rimnieu Vilcea 413=220+193

97 Pitesti 417=317+100 101 Bucharest 418=418+0 138 Craiova 615=455+160

Distncia em linha reta at Bucharest

t(N,F/G,Subs) representa uma rvore com sub-rvores no vazias

t(s,7/0, [ l(a,7/2), l(e,9/2) ] )

O valor-f da raiz s f(s)=7 pois o valor-f do sucessor mais promissor de s

t(s,7/0, [ l(a,7/2), l(e,9/2) ] )

Para uma rvore T, cuja raiz n e as subrvores de n so S1, S2, ..., Sk

De maneira ideal, se h* conhecida, podemos utilizar h* diretamente

A*: Funo de Avaliao

Transferindo esse resultado para a funo de avaliao f=g+h:

Veremos duas dessas tcnicas:

Efetue busca em profundidade limitada por f<=6, iniciando no n s

f(a)=7 > Limite

Efetue busca em profundidade limitada por f<=6, iniciando no n s