Characterization of single-agent search algorithms with generalized start and goal nodes

Transcription

1 Characterization of single-agent search algorithms with generalized start and goal nodes Carlos Linares López Asunción Gómez-Pérez Laboratorio de Inteligencia Artificial Departamento de Inteligencia Artificial Facultad de Informática Universidad Politécnica de Madrid

2 Exposition (I) The N-Puzzle problem Discrete domain NP-hard (1986) Irregular branching factor (1998) Size of the state space: 16!/2 (1994) Heuristics: Manhattan distance (and others, 1966) Linear conflict (1992)

3 Exposition (II) Searching in graphs A Information level: +100 B C E A Infomation level: +0 B C D F E D F Continuous domain. Heuristic: euclidean distance.

4 Objectives Study of the behaviour of various one-agent search algorithms in different domains, under a computational environment which guarantees the same conditions for all of them. Consideration of the bidirectional approach (pure/perimeter) to improve unidirectional algorithms. Generalization of start and goal nodes: AND, OR, NOT.

5 Hypotheses Graph: Edge costs are constant. Positive information levels. Generalization: NOT is applied to other nodes than the start or goal node. AND is not applied to the start node. The logical formulas have to be in Skolem s normal form Heuristic functions: Always return a numerical value (not states).

6 Research (I) New perimeter search algorithms: n DFBnB (1966) RBFS (1992) DFBnBPS* t RBFPS* New bidirectional search algorithms: RBFS (1992) BRBFS* s IBRBFS* t s

7 RBFPS* RBFPS* (n,f(n),ηn, F) RBFPS *(s, +, Pd) is a complete algorithm IF f(n) > ηn THEN RETURN f(n) IF n F THEN EXIT RBFPS* RBFPS *(s, +, Pd) is IF SCS(n)= THEN RETURN + an admissible algorithm FOR ni SCS(n) Compute P(ni, ηn) = {m F g(ni) + h(ni,m)+h*(m) ηn} IF P(ni, ηn) = THEN RETURN f(n) IF f(n) < F(n) THEN F(ni) = max {F(n), f(ni)} ELSE F(ni) = f(ni) Sort ni in ascending order of F(ni) IF SCS(n) = 1 THEN F(n2)=+ WHILE (F(n1) ηn AND F(n1) < + ) F(n1) = RBFPS * (n1, F(n1), min {ηn, F(n2)}, P(n1, ηn)) Insert n1 in ascending order of F(ni) RETURN F(n ) 1

8 DFBnBPS* DFBnBPS* (n, η, F) IF n F THEN EXIT DFBnBPS * IF SCS(n)= THEN RETURN + FOR ni SCS(n) Compute P(ni, η) = {m F g(ni) + h(ni,m)+h*(m) η} IF P(ni, η) = THEN RETURN η IF f(ni) < η IF (ni F) η = f(ni) ELSE DFBnBPS* (ni, η, F) ELSE RETURN η DFBnBPS *(s, +, Pd) is a complete algorithm DFBnBPS *(s, +, Pd) is an admissible algorithm

9 BRBFS* (I) BUSCAR (n,f(n),ηn, F) IF f(n) > ηn THEN RETURN f(n) IF n F THEN EXIT BUSCAR IF SCS(n)= THEN RETURN + FOR ni SCS(n) Compute P(ni, ηn) = {m F g(ni) + h(ni,m)+h*(m) ηn} IF P(ni, ηn) = THEN Add ni to Q IF f(n) < F(n) THEN F(ni) = max {F(n), f(ni)} ELSE F(ni) = f(ni) Insert ni in ascending order of F(ni) IF SCS(n) = 1 THEN F(n2)=+ WHILE (F(n1) ηn AND F(n1) < + ) F(n1) = BUSCAR (n1, F(n1), min {ηn, F(n2)}, P(n1, ηn)) Insert n1 in ascending order of F(ni) RETURN F(n1)

10 BRBFS* (II) BRBFS* (s,t) F={t}, Q=, Π=hs (s) WHILE (Π is not a solution) Π = BUSCAR (s, Π, Π, F) Swap s and t F=Q, Q= RETURN Π BRBFS *(s, t) perform various best first searches BRBFS *(s, t) is an admissible algorithm

11 IBRBFS* IBRBFS* (s,t) Fs={s}, Ft={t}, Q=, Π=hs (s) WHILE (Π no sea solución) DO Tomar el siguiente nodo ni de Fs Πi = BUSCAR (ni,f(ni), Π, Ft) WHILE (Πi no sea un camino solución) Fs={Q}, Q=, Π=min{Πi} Intercambiar Fs y Ft RETURN Π IBRBFS *(s, t) is an admissible algorithm

12 Research (II) Generalization (I): Negation n Purpose: NOT n Do not consider the generated NOT nodes. n Technique

13 Research (III) Generalization (II): Generalization of the start node Disjunction: t Depth-first: s1 Breadth-first: s2 sn Insert at the end of the queue all the successors of the expanded nodes. Complexity overload: Purpose: (s1 or s2 or sn) Brute force: Handle the stack as a queue. Heuristic search: Create a unique fictitious node. Constant. Technique

14 Research (IV) Generalization (III): Generalization of the goal state (I): t1 t2 t3 t4 t5 Define the goal state with the aid of a binary tree. t6 O O s Y t1 Purpose: (t1 and t2) or (t3 and t4) or (t5 and t6) Y t2 t3 Y t4 t5 Technique t6

15 Research (V) Generalization (IV): Generalization of the goal state (II): Disjunction: t1 t2 tn Reformulate the heuristic function. t1 t2 tn s Purpose: (t1 or t2 or tn) Technique

16 Research (VI) Generalization (V): Generalization of the goal state (III): Conjunction: t1 t2 tn Reformulate the heuristic function : Number of evaluations: C Ni i=1 C s i =1 Purpose: (t1 and t2 and tn) Number of min/max operations: N i C Technique

17 Research (VII) Search Algorithms Library: Components: Manager: Unidirectional, bidirectional and perimeter search algorithms. Generic definition of nodes. Perimeter handling and binary trees. Statistics handling (steps, triggers and limits). Provides mechanisms for: Running tests under the same conditions (fair comparisons). Programming any type of cost function (e.g., multiobjective search). Defining any domain. Design: UML. Programming: C++ and STL.

18 SAL - Manager Bidirectional Search Algorithms General solver Base class Provides general services Unidirectional and Perimeter Search Algorithms

19 SAL - Nodes Basic definition of node Information about nodes

20 SAL - Perimeter Perimeter implementation Unique location of the perimeter Perimeter Set of perimeter nodes Perimeter nodes along with their information

21 SAL - Binary Trees General solver Binary tree Provide means for handling any logical description of start and goal nodes.

22 SAL - Statistics Manager Provide access to this general services Base definition of stats

23 Using SAL Basic definition of node Specialized definition of node It implements the domain New cost type (Bidimensional)

24 Tests Algorithms tested: Unidirectional search: IDA*, RBFS and DFBnB. Bidirectional search: BRBFS* and IBRBFS*. Perimeter search: BIDA*, RBFPS* and DFBnBPS*. Contrast hypothesis over the mean for comparing the time spent or the number of nodes generated/expanded. Test sets: Richard Korf s 100 test set. 48 cases randomly generated in graphs with 6000, 13500, and nodes with information levels: +0, +50 and Sun Ultra 5 (SunOS 5.8), 450 Mhz, 256 Mb RAM and 512Mb Swap.

25 RBFS - 15-Puzzle

26 IDA* - 15-Puzzle

27 BIDA* - 15-Puzzle

28 RBFPS* - 15-Puzzle

29 BRBFS* - 15-Puzzle

30 IDA* - Graph

31 RBFS - Graph

32 DFBnB - Graph

33 BRBFS* - Graph

34 IBRBFS* - Graph

35 Theoretical considerations (I) Overall distribution (1998): 15 Puzle Graph

36 Theoretical considerations (II) Depth of the search tree, d (1988): Minimum number of edges: Minimum number of edges: h n, m 3h n, m 2 id max 15 Puzle Graph The precisition of the heuristic distance matters.

37 Theoretical considerations (III) Variability of the cost function (1989): Manhattan distance: h n,t h ni,t =1, n i SCS n Cost of the edges: Likelihood of selecting the closer node as a neighbor: 2γ b, γ= 2 πn i c n, ni =1 Variability: {0, +2} 15 Puzle Graph

38 Conclusions (I) RBFS(I): 15-Puzle: it does not generate less nodes than IDA*. Graph: it generates less nodes than IDA*, the more nodes IDA* generates, the greater the difference is.

39 Conclusions (II) RBFS(II): The number of nodes generated or the time spent can be successfully explained by means of the number of F updates.

40 Conclusions (III) Algorithms that use thresolds: 15-Puzle: good performance, but DFBnB. Graph: Bad performance. IDA* (39) #h t #g IDA* (20) Media , , ,256 Media Varianza 4, ,376 1, Varianza 1, RBFS (21) #h t #g RBFS (42) #h ,3 t 37, ,8 #g ,65 2, #h t #g Media ,45 810, ,45 Media ,047 35, ,047 Varianza 5, ,21 1, Varianza 1, ,062 1, Puzle Graph

41 Conclusions (IV) Bidirectional search algorithms (I): 15-Puzle: High memory-demanding. Far better in the easiest instances and worse in the most difficult ones.

42 Conclusions (V) Bidirectional search algorithms(ii): Graph: Excellent performance in all cases: BRBFS* does not lead to a significance improvement (hypothesis contrast with significance level 0,05). IBRBFS* solves 41 out of the 48 cases: It solves 95,23% more cases than RBFS. It generates 99,14% less nodes than RBFS. It consumes 78,32% less time than RBFS. It performs 99,14% less F updates than RBFS. It performs 45,43% less heuristic evaluations than RBFS.

43 Conclusions (VI) Perimeter search: 15-Puzle: Excellent performance, but DFBnBPS*. Graph: Very bad performance. Generation of useless perimeter nodes (1993).

44 Future work (I) Mathematical characterization: Time spent and nodes generated (1985, 1998). Estimation of the best perimeter depth (1994). Unidirectional search: Research into new selective search algorithms (1998). Resolution of problems type-not. Bidirectional search: Generalization of start and goal nodes multidirectional search Parallel implementation. Perimeter search: Lazy evaluation.

45 Future work (II) Improvement of the heuristic estimation (1984, 1996, 1997). Time-dependent search: Edges can be traversed without spending time. Each edge consumes a different amount of time for being traversed. It is possible to wait any amount of time before traversing an edge.

46 Future work (III) Learning methods (1981, 1985). Voice recognition (1983). Job scheduling (1983). Artificial vision (1983). Onthologies. Clustering. Neural networks. Genetic algorithms. Search algorithms are reasoning models