Vous êtes sur la page 1sur 166

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


Inteligncia Artificial

Jos Augusto Baranauskas


Departamento de Computao e Matemtica FFCLRP-USP

augusto@usp.br
http://dcm.fmrp.usp.br/~augusto

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

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
3

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

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

Estado
Atual

1 2

4 5

= =

= =

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

4 5

3
2 posies

7 1
1

8
Estado
Final

3 posies

8
1
3 posies

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

h(e)=7

s
2
5
h(a)=5

a
2

h(c)=4

b
h(b)=4

d
h(d)=3

h(f)=4

h(g)=2

h(t)=0
9

Busca Gulosa pela Melhor Escolha


s

h(s)=9

h(e)=7

s
2
5
h(a)=5

a
2

h(c)=4

b
h(b)=4

d
h(d)=3

h(f)=4

h(g)=2

h(t)=0
10

Busca Gulosa pela Melhor Escolha


h(s)=9

h(e)=7

s
h(a)=5

h(e)=7

5
h(a)=5

a
2

h(c)=4

b
h(b)=4

d
h(d)=3

h(f)=4

h(g)=2

h(t)=0
11

Busca Gulosa pela Melhor Escolha


h(s)=9

h(e)=7

s
h(a)=5

h(e)=7

5
h(a)=5

h(b)=4

a
2

b
c

h(c)=4

b
h(b)=4

d
h(d)=3

h(f)=4

h(g)=2

h(t)=0
12

Busca Gulosa pela Melhor Escolha


h(s)=9

h(e)=7

s
h(a)=5

h(e)=7

5
h(a)=5

h(b)=4

a
2

b
c

h(c)=4
h(c)=4

b
h(b)=4

d
h(d)=3

h(f)=4

h(g)=2

h(t)=0
13

Busca Gulosa pela Melhor Escolha


h(s)=9

h(e)=7

s
h(a)=5

h(e)=7

5
h(a)=5

h(b)=4

a
2

b
c

h(c)=4
h(c)=4

d
h(d)=3

b
h(b)=4

3
h(d)=3

h(f)=4

h(g)=2

h(t)=0
14

Busca Gulosa pela Melhor Escolha


h(s)=9

h(e)=7

s
h(a)=5

h(e)=7

5
h(a)=5

h(b)=4

a
2

b
c

h(c)=4
h(c)=4

h(t)=0

Custo da soluo encontrada s-a-b-c-d-t = 12


Custo da soluo tima s-e-f-g-t = 11

d
h(d)=3

b
h(b)=4

3
h(d)=3

h(f)=4

h(g)=2

h(t)=0
15

Busca Gulosa pela Melhor Escolha:


Encontre o caminho de Arad at Bucharest
Oradea
71

Assuma que os sucessores


de um n so definidos em
ordem alfabtica

Distncia em linha
reta at Bucharest

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

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

Neamt

Zerind

75

87

151

f(Arad)=h(Arad)

Iasi

Arad

140
Sibiu

92
99

Fagaras
Vaslui

118
80
Timisoara
111

Lugoj

Rimnieu
Vilcea
97

Pitesti

142

211

70
Mehadia

146

75
Dobreta

138
120

85

101

Bucharest

98
Urziceni

Hirsova

Arad
366

86

90
Craiova

Giurgiu

Eforie

h(n)
Arad

366

Bucharest

Craiova

160

Dobreta

242

Eforie

161

Fagaras

176

Giurgiu

77

Hirsova

151

Iasi

226

Lugoj

244

Mehadia

241

Neamt

234

Oradea

380

Pitesti

100

Rimnieu Vilcea

193

Sibiu

253

Timisoara

329

Urziceni

80

Vaslui

199

Zerind

374

17

Encontre o caminho de Arad at


Bucharest
Oradea
71

Neamt

Zerind

75

87

151

Iasi

Arad

140
Sibiu

92
99

Fagaras
Vaslui

118
80
Timisoara
111

Lugoj

Rimnieu
Vilcea
97

Pitesti

70
Mehadia

146

75
Dobreta

h(n)

Bucharest

98
Urziceni

Hirsova
86

90
Craiova

Arad

85

101
138

120

Arad
366

142

211

Giurgiu

Eforie

Sibiu
253

Timisoara
329

Zerind
374

366

Bucharest

Craiova

160

Dobreta

242

Eforie

161

Fagaras

176

Giurgiu

77

Hirsova

151

Iasi

226

Lugoj

244

Mehadia

241

Neamt

234

Oradea

380

Pitesti

100

Rimnieu Vilcea

193

Sibiu

253

Timisoara

329

Urziceni

80

Vaslui

199

Zerind

374

18

Encontre o caminho de Arad at


Bucharest
Oradea
71

Neamt

Zerind

75

87

151

Iasi

Arad

140
Sibiu

92
99

Fagaras
Vaslui

118
80
Timisoara
111

Lugoj

Rimnieu
Vilcea
97

Pitesti

70
Mehadia

146

75
Dobreta

85

101
138

120

Bucharest

98
Urziceni

Hirsova
86

90
Craiova

Giurgiu

Eforie

h(n)
Arad

Arad
366

142

211

Sibiu
253

Timisoara
329

Zerind
374

366

Bucharest

Craiova

160

Dobreta

242

Eforie

161

Fagaras

176

Giurgiu

77

Hirsova

151

Iasi

226

Lugoj

244

Mehadia

241

Neamt

234

Oradea

380

Pitesti

100

Rimnieu Vilcea

193

Sibiu

253

Timisoara

329

Urziceni

80

Vaslui

199

Zerind

374

Fagaras
176

Oradea
380

Rimnieu Vilcea
193

19

Encontre o caminho de Arad at


Bucharest
Oradea
71

Neamt

Zerind

75

87

151

Iasi

Arad

140
Sibiu

92
99

Fagaras
Vaslui

118
80
Timisoara
111

Lugoj

Rimnieu
Vilcea
97

Pitesti

70
Mehadia

146

75
Dobreta

85

101
138

120

Bucharest

98
Urziceni

Hirsova
86

90
Craiova

Giurgiu

Eforie

h(n)
Arad

Arad
366

142

211

Sibiu
253

Timisoara
329

Zerind
374

366

Bucharest

Craiova

160

Dobreta

242

Eforie

161

Fagaras

176

Giurgiu

77

Hirsova

151

Iasi

226

Lugoj

244

Mehadia

241

Neamt

234

Oradea

380

Pitesti

100

Rimnieu Vilcea

193

Sibiu

253

Timisoara

329

Urziceni

80

Vaslui

199

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

g(a)=2 a

e g(e)=2

g(a)=2 a

e g(e)=2

g(b)=4 b

g(a)=2 a

e g(e)=2

g(b)=4 b

f g(f)=7

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

Busca Gulosa pela Melhor Escolha


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

e h(e)=7

h(a)=5 a

e h(e)=7

h(b)=4 b
h(c)=4 c

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




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)

s
g(n)

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

s
Distncia entre duas
cidades atravs de um
caminho (rodovia)

2
5
5

a
2

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

3
3

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


O primeiro n a ser expandido


o n inicial (raiz da busca)

s
2
5
5

a
2

3
3

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

s
2
5
5

a
2

3
3

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

f(e)=9

s
2
5
5

f(a)=7
2

3
3

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

f(e)=9

s
2
5

f(a)=7
2

f(b)=8

3
3

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

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

f(e)=9

s
2
5

f(a)=7
2

f(f)=11

f(b)=8

f(c)=10

3
3

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

f(e)=9

s
2
5

f(a)=7
2

f(f)=11

f(b)=8

f(c)=10

3
3

3
f(d)=12

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

f(e)=9

s
2
5

f(a)=7
2

f(f)=11

f(b)=8

f(c)=10

3
3

f(g)=11

f(d)=12

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

f(e)=9

s
2
5

f(a)=7
2

f(f)=11

f(b)=8

f(c)=10

3
3

f(g)=11

f(d)=12

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

s
2
5
5

a
2

3
3

t
40

A*
9

s
2
f(a)=7

f(e)=9
5

a
2

3
3

t
41

A*
9

s
2
f(a)=7

f(e)=9
5

a
2

f(b)=8

3
3

t
42

A*
9

s
2
f(a)=7

f(e)=9
5

a
2

f(b)=8

f(c)=10

c
3

t
43

A*
9

s
2
f(a)=7

f(e)=9
5

a
2

f(b)=8

f(c)=10

f(f)=11

c
3

t
44

A*
9

s
2
f(a)=7

f(e)=9
5

a
2

f(b)=8

f(c)=10

f(f)=11

3
3

f(d)=12

t
45

A*
9

s
2
f(a)=7

f(e)=9
5

a
2

f(b)=8

f(c)=10

f(f)=11

f(g)=11

3
3

f(d)=12

t
46

A*
9

s
2
f(a)=7

f(e)=9
5

a
2

f(b)=8

f(c)=10

f(f)=11

f(g)=11

f(t)=11

3
3

f(d)=12

t
47

A*: Encontre o caminho de Arad at


Bucharest
Oradea
71

Assuma que os sucessores


de um n so definidos em
ordem alfabtica

Distncia em linha
reta at Bucharest

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

366
0
160
242
161
176
77
151
226
244
241
234
380
100
193
253
329
80
199
374
48

Oradea
71

Neamt

Zerind

87

151

75

Iasi

Arad

140
Sibiu

92
99

Fagaras
Vaslui

118
80
Timisoara
111

Lugoj

Rimnieu
Vilcea
97

Pitesti

142

211

70

98
Mehadia

146

75
Dobreta

366

Bucharest
Craiova

0
160

Dobreta
Eforie

242
161

Fagaras
Giurgiu

176
77

Hirsova
Iasi

151
226

Lugoj
Mehadia

244
241

Neamt
Oradea

234
380

Hirsova

Urziceni

Bucharest

Arad
366=0+366

86

90
Craiova

h(n)
Arad

101
138

120

85

Giurgiu

Eforie

Pitesti
100
Rimnieu Vilcea 193
Sibiu
Timisoara

253
329

Urziceni
Vaslui

80
199

Zerind

374

49

Oradea
71

Neamt

Zerind

87

151

75

Iasi

Arad

140
Sibiu

92
99

Fagaras
Vaslui

118
80
Timisoara
111

Lugoj

Rimnieu
Vilcea
97

Pitesti

142

211

70

98
Mehadia

146

75
Dobreta

366

Bucharest
Craiova

0
160

Dobreta
Eforie

242
161

Fagaras
Giurgiu

176
77

Hirsova
Iasi

151
226

Lugoj
Mehadia

244
241

Neamt
Oradea

234
380

Hirsova

Bucharest

Giurgiu

Arad
366=0+366

Urziceni
86

140

90
Craiova

h(n)
Arad

101
138

120

85

118

75

Eforie

Sibiu
393=140+253

Timisoara
447=118+329

Zerind
449=75+374

Pitesti
100
Rimnieu Vilcea 193
Sibiu
Timisoara

253
329

Urziceni
Vaslui

80
199

Zerind

374

50

Oradea
71

Neamt

Zerind

87

151

75

Iasi

Arad

140
Sibiu

92
99

Fagaras
Vaslui

118
80
Timisoara
111

Lugoj

Rimnieu
Vilcea
97

Pitesti

142

211

70

98
Mehadia

146

75
Dobreta

366

Bucharest
Craiova

0
160

Dobreta
Eforie

242
161

Fagaras
Giurgiu

176
77

Hirsova
Iasi

151
226

Lugoj
Mehadia

244
241

Neamt
Oradea

234
380

Hirsova

Arad
366=0+366

Urziceni

Bucharest

86

140

90
Craiova

h(n)
Arad

101
138

120

85

Giurgiu

118

75

Eforie

Sibiu
393=140+253
99

Fagaras
415=239+176

151

Oradea
671=291+380

Timisoara
447=118+329

Zerind
449=75+374

80

Rimnieu Vilcea
413=220+193

Pitesti
100
Rimnieu Vilcea 193
Sibiu
Timisoara

253
329

Urziceni
Vaslui

80
199

Zerind

374

51

Oradea
71

Neamt

Zerind

87

151

75

Iasi

Arad

140
Sibiu

92
99

Fagaras
Vaslui

118
80
Timisoara
111

Lugoj

Rimnieu
Vilcea
97

Pitesti

142

211

70

98
Mehadia

146

75
Dobreta

366

Bucharest
Craiova

0
160

Dobreta
Eforie

242
161

Fagaras
Giurgiu

176
77

Hirsova
Iasi

151
226

Lugoj
Mehadia

244
241

Neamt
Oradea

234
380

Hirsova

Arad
366=0+366

Urziceni

Bucharest

86

140

90
Craiova

h(n)
Arad

101
138

120

85

Giurgiu

118

75

Eforie

Sibiu
393=140+253
99

Fagaras
415=239+176

151

Timisoara
447=118+329

Zerind
449=75+374

80

Oradea
671=291+380

Rimnieu Vilcea
413=220+193

146
Craiova
526=366+160

97
Pitesti
417=317+100

Pitesti
100
Rimnieu Vilcea 193
Sibiu
Timisoara

253
329

Urziceni
Vaslui

80
199

Zerind

374

52

Oradea
71

Neamt

Zerind

87

151

75

Iasi

Arad

140
Sibiu

92
99

Fagaras
Vaslui

118
80
Timisoara
111

Lugoj

Rimnieu
Vilcea
97

Pitesti

142

211

70

98
Mehadia

146

75
Dobreta

366

Bucharest
Craiova

0
160

Dobreta
Eforie

242
161

Fagaras
Giurgiu

176
77

Hirsova
Iasi

151
226

Lugoj
Mehadia

244
241

Neamt
Oradea

234
380

Hirsova

Arad
366=0+366

Urziceni

Bucharest

86

140

90
Craiova

h(n)
Arad

101
138

120

85

Giurgiu

118

75

Eforie

Sibiu
393=140+253
99

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

151

Timisoara
447=118+329

Zerind
449=75+374

80

Oradea
671=291+380

Rimnieu Vilcea
413=220+193

146
Craiova
526=366+160

97
Pitesti
417=317+100

Pitesti
100
Rimnieu Vilcea 193
Sibiu
Timisoara

253
329

Urziceni
Vaslui

80
199

Zerind

374

53

Oradea
71

Neamt

Zerind

87

151

75

Iasi

Arad

140
Sibiu

92
99

Fagaras
Vaslui

118
80
Timisoara
111

Lugoj

Rimnieu
Vilcea
97

Pitesti

142

211

70

98
Mehadia

146

75
Dobreta

366

Bucharest
Craiova

0
160

Dobreta
Eforie

242
161

Fagaras
Giurgiu

176
77

Hirsova
Iasi

151
226

Lugoj
Mehadia

244
241

Neamt
Oradea

234
380

Pitesti
100
Rimnieu Vilcea 193
Sibiu
Timisoara

253
329

Urziceni
Vaslui

80
199

Zerind

374

Hirsova

Arad
366=0+366

Urziceni

Bucharest

86

140

90
Craiova

h(n)
Arad

101
138

120

85

Giurgiu

118

75

Eforie

Sibiu
393=140+253
99

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

151

Timisoara
447=118+329

Zerind
449=75+374

80

Oradea
671=291+380

Rimnieu Vilcea
413=220+193

146

97

Craiova
526=366+160

Pitesti
417=317+100
101

Bucharest
418=418+0

138
Craiova
615=455+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)
Distncia em linha
reta at Bucharest

Oradea
71

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
Neamt

366
0
160
242
161
176
77
151
226
244
241
234
380
100
193
253
329
80
199
374
55

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(b)=8

f(e)=9

60

A*
s

f(a)=7

f(b)=8

f(c)=10

f(e)=9

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

A*
s

f(a)=7

f(b)=8

f(c)=10

f(e)=9

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)

rvore

Expandindo rvore at
que seu valor-f exceda
Limite resulta em
rvore1

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

Algoritmo A* (cont.)
% 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

Algoritmo A* (cont.)
% 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).

% valor-f de uma folha


% valor-f de uma rvore
% melhor valor-f de uma lista de rvores
% Nenhuma rvore: definir valor-f ruim

min(X,Y,X) :X =< Y, !.
min(X,Y,Y).
pertence(E,[E|_]).
pertence(E,[_|T]) :pertence(E,T).
71

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

Admissibilidade de A*
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

Admissibilidade de A*
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))



Transferindo esse resultado para a funo de avaliao


f=g+h:
 f(sucessor(n)) >= f(n)





isso se aplica maioria das funes heursticas


Toda heurstica consistente admissvel

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(a)=7 > Limite

f(s)=6

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

Limite = 6
82

IDA*
s

f(a)=7 > Limite

f(s)=6

f(e)=9 > Limite

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

Limite = 6
83

IDA*
s

f(a)=7 > Limite

f(s)=6

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(a)=7

f(s)=6

Limite = 7
86

IDA*
s

f(a)=7

f(b)=8 > Limite

f(s)=6

Limite = 7
87

IDA*
s

f(a)=7

f(b)=8 > Limite

f(s)=6

f(e)=9 > Limite

Limite = 7
88

IDA*
s

f(a)=7

f(b)=8 > Limite

f(s)=6

f(e)=9 > Limite

NovoLimite = mn{8,9} = 8
Efetue busca em
profundidade limitada por
f<=8, iniciando pelo n s

Limite = 8
89

IDA*
s

f(s)=6

Limite = 8
90

IDA*
s

f(a)=7

f(s)=6

Limite = 8
91

IDA*
s

f(a)=7

f(b)=8

f(s)=6

Limite = 8
92

IDA*
s

f(a)=7

f(b)=8

f(c)=10 > Limite

f(s)=6

Limite = 8
93

IDA*
s

f(a)=7

f(b)=8

f(c)=10 > Limite

f(s)=6

f(e)=9 > Limite

Limite = 8
94

IDA*
s

f(a)=7

f(b)=8

f(c)=10 > Limite

f(s)=6

f(e)=9 > Limite

NovoLimite = mn{10,9} = 9
Efetue busca em
profundidade limitada por
f<=9, iniciando pelo n s

Limite = 9
95

IDA*
s

f(s)=6

Limite = 9
96

IDA*
s

f(a)=7

f(s)=6

Limite = 9
97

IDA*
s

f(a)=7

f(b)=8

f(s)=6

Limite = 9
98

IDA*
s

f(a)=7

f(b)=8

f(c)=10 > Limite

f(s)=6

Limite = 9
99

IDA*
s

f(a)=7

f(b)=8

f(c)=10 > Limite

f(s)=6

f(e)=9

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(a)=7

f(b)=8

f(c)=10 > Limite

f(s)=6

NovoLimite = mn{10,11} = 10
Efetue busca em
profundidade limitada por
f<=10, iniciando pelo n s

f(e)=9

f(f)=11 > Limite

Limite = 10
102

IDA*
s

f(s)=6

Limite = 10
103

IDA*
s

f(a)=7

f(s)=6

Limite = 10
104

IDA*
s

f(a)=7

f(b)=8

f(s)=6

Limite = 10
105

IDA*
s

f(a)=7

f(b)=8

f(c)=10

f(s)=6

Limite = 10
106

IDA*
s

f(a)=7

f(b)=8

f(c)=10

f(d)=12 > Limite

f(s)=6

Limite = 10
107

IDA*
s

f(a)=7

f(b)=8

f(c)=10

f(d)=12 > Limite

f(s)=6

f(e)=9

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(a)=7

f(b)=8

f(c)=10

f(d)=12 > Limite

f(s)=6

NovoLimite = mn{11,12} = 11
Efetue busca em
profundidade limitada por
f<=11, iniciando pelo n s

f(e)=9

f(f)=11 > Limite

Limite = 11
110

IDA*
s

f(s)=6

Limite = 11
111

IDA*
s

f(a)=7

f(s)=6

Limite = 11
112

IDA*
s

f(a)=7

f(b)=8

f(s)=6

Limite = 11
113

IDA*
s

f(a)=7

f(b)=8

f(c)=10

f(s)=6

Limite = 11
114

IDA*
s

f(a)=7

f(b)=8

f(c)=10

f(d)=12 > Limite

f(s)=6

Limite = 11
115

IDA*
s

f(a)=7

f(b)=8

f(c)=10

f(d)=12 > Limite

f(s)=6

f(e)=9

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(a)=7

f(b)=8

f(c)=10

f(d)=12 > Limite

f(s)=6

Com a busca em
profundidade com Limite = 11
uma soluo encontrada

Limite = 11

f(e)=9

f(f)=11

f(g)=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)).

% nao altere proximo limite


% diminua proximo limite

pertence(E,[E|_]).
pertence(E,[_|T]) :pertence(E,T).

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)
que pode ser escrito como:
 F(ni) mx{F(n), f(ni)}
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(b)=8

F(e)=9

Limite = 9
131

RBFS
s

F(a)=7

F(b)=8

F(c)=10 > Limite

F(e)=9

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

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(b)=10

F(e)=11

Limite = 11
136

RBFS
s

F(a)=10

F(b)=10

F(c)=10

F(e)=11

Limite = 11
137

RBFS
s

F(a)=10

F(b)=10

F(c)=10

F(d)=12 > Limite

F(e)=11

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

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(f)=11

F(g)=11

F(t)=11

Com a busca com Limite = 12


uma soluo encontrada

Limite = 12

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

% Primeiro no' = melhor FF


% Sem nos FF = "infinito"

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

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

Algoritmos de Busca Local





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

Algoritmos de Busca Local




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)
mximo
global

funo
de
avaliao

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

Algoritmo de Subida de Encosta







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

Algoritmo de Subida de Encosta


mximo
global

funo
de
avaliao

mximo
local

ombro

mximo
local plano

estado atual

espao de estados

152

Algoritmo de Subida de Encosta

153

Algoritmo de Subida de Encosta

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:

1.
2.
3.
4.




Escolher o primeiro melhor


Escolher um entre todos de forma aleatria
154

Algoritmo de Subida de Encosta




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

Exemplo 1


Neste exemplo, a
heurstica distncia
Manhattan permite
encontrar uma
soluo rapidamente
por hill-climbing

h(n)

5
1

3
8

1
6

3
5

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

4
6

3
5
8

h(n)

5
8

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


i1
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
ii+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