Tema 2: Técnicas básicas de búsqueda

(1)

Introducci´on a la Inteligencia Artificial Curso 2003–2004

Tema 2: T´

ecnicas b´

asicas de

b´

usqueda

Jos´e A. Alonso Jim´enez Francisco J. Mart´ın Mateos

Jos´e L. Ruiz Reina

Dpto. de Ciencias de la Computaci´on e Inteligencia Artificial

Universidad de Sevilla

(2)

B´

usqueda de soluciones en espacios de estados

x

_{Objetivo: encontrar una secuencia de operadores que, partiendo del}

es-tado inicial, obtenga un eses-tado final

x

_{Idea b´}

_{asica: exploraci´}

_{on del}

_grafo

_{del espacio de estados}

u _{En cada momento se analiza un estado actual (en un principio, el inicial)} u _{Si el estado actual es final, acabar (recopilando la sucesi´}_{on de operadores)} u _{En caso contario, obtener los sucesores del estado actual (}_expandir₎

u _Elegir _{un nuevo estado actual,} _dejando _{los restantes para analizarlos} posterior-mente (si fuera necesario)

u _{Repetir el proceso mientras haya estados por analizar}

x

_{La elecci´}

_{on del estado actual en cada momento determina una}

_estrategia

(3)

´

Arboles de b´

usqueda

x

_{El proceso anterior puede verse como la construcci´}

_{on incremental de un}

´

arbol de b´

usqueda

x

_{Ejemplo en el problema de las jarras:}

(0 0) (4 3) (1 0) (1 3) (3 0) (3 3) (4 0) (0 3)

(4)

´

Arboles de b´

usqueda

x

_{Nodo de un ´}

_{arbol de b´}

_{usqueda, componentes:}

u _Estado

u _{Secuencia de operadores que conducen al estado desde el inicial (}_camino₎ x

_{Nodo ra´ız del ´}

_{arbol de b´}

_{usqueda: estado inicial + secuencia vac´ıa}

x

_{Nodos hoja del ´}

_{arbol de b´}

_usqueda:

u _{Nodos cuya expansi´}_{on no ha producido sucesores nuevos} u _{Nodos pendientes de considerar (y expandir en su caso)}

x

_{Diferencias entre el espacio de estados y el ´}

_{arbol de b´}

_usqueda:

u _Arbol _vs. _grafo

u _{Nodos del ´}_{arbol de b´}_{usqueda: estado + camino}

(5)

Implementaci´

on de un problema de espacio de estados

x

_Elecci´

_{on de una representaci´}

_{on (estructura de datos):}

u _{para los estados}

u _{para los operadores}

x

_{La implementaci´}

_{on de un problema como espacio de estados consta de:}

u _{Una variable global} _{*ESTADO-INICIAL*}

u _{Una funci´}_on _{ES-ESTADO-FINAL(ESTADO)} u _{Una variable global} _*OPERADORES*_.

u _{Una funci´}_on _{APLICA(OPERADOR, ESTADO)} x

_{La funci´}

_on

_{APLICA(ESTADO,OPERADOR)}

_:

u _Devuelve _NO-APLICABLE _si _OPERADOR _{no es aplicable a} _ESTADO

u _{En caso contrario, devuelve el estado resultante de aplicar} _OPERADOR _a _ESTADO

(6)

Implementaci´

on de la b´

usqueda (funciones auxiliares)

x

_{Nodo de b´}

_{usqueda: estado + camino}

u _{Funciones de acceso:} _ESTADO(NODO) _y _CAMINO(NODO) x

_{Sucesores de un nodo}

FUNCION SUCESOR(NODO,OPERADOR)

1. Hacer ESTADO-SUCESOR igual a APLICA(ESTADO(NODO),OPERADOR) 2. Si ESTADO-SUCESOR=NO-APLICABLE

devolver NO-APLICABLE en caso contrario,

devolver un nodo cuyo estado es ESTADO-SUCESOR y cuyo camino es el resultado de a~nadir OPERADOR a CAMINO(NODO)

FUNCION SUCESORES(NODO) 1. Hacer SUCESORES vac´ıo

2. Para cada OPERADOR en *OPERADORES*,

(7)

Implementaci´

on de un procedimiento general de b´

usqueda

FUNCION BUSQUEDA-GENERAL()

1. Hacer ABIERTOS la "cola" formada por el nodo inicial (es decir, el nodo cuyo estado es *ESTADO-INICIAL* y cuyo camino es vac´ıo);

Hacer CERRADOS vac´ıo

2. Mientras que ABIERTOS no est´e vac´ıa,

2.1 Hacer ACTUAL el primer nodo de ABIERTOS 2.2 Hacer ABIERTOS el resto de ABIERTOS

2.3 Poner el nodo ACTUAL en CERRADOS. 2.4 Si ES-ESTADO-FINAL(ESTADO(ACTUAL)),

2.4.1 devolver el nodo ACTUAL y terminar. 2.4.2 en caso contrario,

2.4.2.1 Hacer NUEVOS-SUCESORES la lista de nodos de SUCESORES(ACTUAL) cuyo estado no est´a ni en ABIERTOS ni en CERRADOS

2.4.2.2 Hacer ABIERTOS igual a GESTIONA-COLA(ABIERTOS,NUEVOS SUCESORES) 3. Devolver FALLO.

(8)

Implementaci´

on de un procedimiento general de b´

usqueda

x

_{La implementaci´}

_{on anterior es independiente del problema}

x

_ABIERTOS

_{puede verse como una “cola” en la que esperan los nodos para}

ser analizados

x

_CERRADOS

_{contiene los nodos ya analizados}

u _{Nos permite evitar ciclos en el proceso de b´}_usqueda u _{En determinados problemas es prescindible}

x

_{La funci´}

_on

_{GESTIONA-COLA(ABIERTOS,NUEVOS SUCESORES)}

_:

u _A˜_nade _{NUEVOS-SUCESORES} _a _ABIERTOS_{, reordenando seg´}_{un alg´}_{un criterio concreto}

x

_{Distintas concrecciones de esta funci´}

_{on dan lugar a distintos algoritmos}

(9)

Propiedades de los algoritmos de b´

usqueda

x

_{Propiedades a estudiar sobre los algoritmos de b´}

_usqueda:

u _{Completitud: si existe soluci´}_{on, ¿la encuentra?}

u _{Optimalidad o minimalidad de la soluci´}_{on: ¿obtiene la soluci´}_{on de menor n´}_umero de pasos o de menor coste?

u _{Complejidad en tiempo: ¿cu´}_{anto se tarda en encontrar una soluci´}_on? u _{Complejidad en espacio: ¿cu´}_{anta memoria necesitamos?}

(10)

B´

usqueda en anchura

x

_{Arbol de b´}

_{usqueda en anchura en el problema de las jarras:}

(0 0) 1 (4 3) 4 5 (1 0) 7 (0 1) 9 (4 1) 11 (1 3) (3 0) 6 (3 3) 8 (4 2) (0 2) 12 10 (4 0) 2 _{(0 3)} 3

(11)

B´

usqueda en anchura

x

_{Tabla de b´}

_{usqueda en anchura para el problema de las jarras:}

Nodo Actual Sucesores Abiertos ((0 0)) 1 (0 0) ((4 0) (0 3)) ((4 0) (0 3)) 2 (4 0) ((4 3) (1 3)) ((0 3) (4 3) (1 3)) 3 (0 3) ((3 0)) ((4 3) (1 3) (3 0)) 4 (4 3) () ((1 3) (3 0)) 5 (1 3) ((1 0)) ((3 0) (1 0)) 6 (3 0) ((3 3)) ((1 0) (3 3)) 7 (1 0) ((0 1)) ((3 3) (0 1)) 8 (3 3) ((4 2)) ((0 1) (4 2)) 9 (0 1) ((4 1)) ((4 2) (4 1)) 10 (4 2) ((0 2)) ((4 1) (0 2)) 11 (4 1) ((2 3)) ((0 2) (2 3)) 12 (0 2) ((2 0)) ((2 3) (2 0)) 13 (2 3)

(12)

Implementaci´

on de la b´

usqueda en anchura

x

_{En la b´}

_{usqueda en anchura,}

_ABIERTOS

_{se gestiona como una cola (FIFO):}

FUNCION BUSQUEDA-EN-ANCHURA()

1. Hacer ABIERTOS la cola formada por el nodo inicial (es decir, el nodo cuyo estado es *ESTADO-INICIAL* y cuyo camino es vac´ıo);

(13)

Soluciones mediante b´

usqueda anchura

x

_{Problema de las jarras:}

> (load "p-jarras-1.lsp") T > (load "b-anchura.lsp") T > (busqueda-en-anchura) #S(NODO :ESTADO (2 3) :CAMINO (LLENAR-JARRA-3-CON-JARRA-4 LLENAR-JARRA-4 VACIAR-JARRA-4-EN-JARRA-3 VACIAR-JARRA-3 LLENAR-JARRA-3-CON-JARRA-4 LLENAR-JARRA-4))

(14)

Soluciones mediante b´

usqueda en anchura

> (trace es-estado-final) > (busqueda-en-anchura) 1. Trace: (ES-ESTADO-FINAL ’(0 0)) 1. Trace: (ES-ESTADO-FINAL ’(4 0)) 1. Trace: (ES-ESTADO-FINAL ’(0 3)) 1. Trace: (ES-ESTADO-FINAL ’(4 3)) 1. Trace: (ES-ESTADO-FINAL ’(1 3)) 1. Trace: (ES-ESTADO-FINAL ’(3 0)) 1. Trace: (ES-ESTADO-FINAL ’(1 0)) 1. Trace: (ES-ESTADO-FINAL ’(3 3)) 1. Trace: (ES-ESTADO-FINAL ’(0 1)) 1. Trace: (ES-ESTADO-FINAL ’(4 2)) 1. Trace: (ES-ESTADO-FINAL ’(4 1)) 1. Trace: (ES-ESTADO-FINAL ’(0 2)) 1. Trace: (ES-ESTADO-FINAL ’(2 3)) > (untrace)

(15)

Soluciones mediante b´

usqueda en anchura

> (time (busqueda-en-anchura)) Real time: 0.416386 sec.

Run time: 0.41 sec. Space: 7236 Bytes #S(NODO :ESTADO (2 3) :CAMINO (LLENAR-JARRA-3-CON-JARRA-4 LLENAR-JARRA-4 VACIAR-JARRA-4-EN-JARRA-3 VACIAR-JARRA-3 LLENAR-JARRA-3-CON-JARRA-4 LLENAR-JARRA-4))

(16)

Soluciones mediante b´

usqueda en anchura

x

_{Estad´ıstica de b´}

_{usqueda en anchura:}

Tiempo Espacio

Nodos

M´

aximo en Profundidad

(seg.)

(bytes) analizados

abiertos

m´

axima

Viaje

0.18

3.260

8

4

3 Granjero

0.18

3.432

10

2

7 Jarras

0.41

7.236

13

3

6

(17)

Propiedades de la b´

usqueda en anchura

x

_Complejidad:

u _r_{: factor de ramificaci´}_on.

u _p_{: profundidad de la soluci´}_on. u _{Complejidad en tiempo:} _O₍_rp_).

u _{Complejidad en espacio:} _O₍_rp_).

x

_{Es completa.}

x

_{Es minimal.}

(18)

Limitaciones de la b´

usqueda en anchura

> (load "p-8-puzzle.lsp") T > (load "b-anchura.lsp") T > (setf *estado-inicial* (make-array ’(3 3) :initial-contents ’((4 8 1) (3 H 2) (7 6 5)))) #2A((4 8 1) (3 H 2) (7 6 5)) > (time (busqueda-en-anchura)) ** - EVAL: User break

Real time: 100.43055 sec. Run time: 96.08 sec.

Space: 1457680 Bytes

(19)

Limitaciones de la b´

usqueda en anchura

x

_{Tiempo y espacio exponenciales}

x

_{Suponiendo ramificaci´}

_{on 10, 1000 nodos por seg. y 100 bytes por nodo:}

Profundidad Nodos

Tiempo

Espacio

0

1 1 ms.

100 b

2

111 0.1 seg.

11 Kb

4 11111

11 seg.

1 Mb

6

10

6

18 min.

11 Mb

8

10

8

31 horas

11 Gb

10

128 d´ıas

1 Tb

12

10

12

33 a˜

nos

11 Tb

14

10

14

3500 a˜

nos 11.111 Tb

(20)

B´

usqueda en profundidad

x

_{Arbol de b´}

_{usqueda en profundidad para el problema de las jarras:}

(0 0) 1 (4 3) (1 0) (0 1) (4 1) (1 3) (4 0) 2 _{(0 3)} 3 4 6 7 5

(21)

B´

usqueda en profundidad

x

_{Tabla de b´}

_{usqueda en profundidad para el problema de las jarras:}

Nodo Actual Sucesores Abiertos ((0 0)) 1 (0 0) ((4 0) (0 3)) ((4 0) (0 3)) 2 (4 0) ((4 3) (1 3)) ((4 3) (1 3) (0 3)) 3 (4 3) () ((1 3) (0 3)) 4 (1 3) ((1 0)) ((1 0) (0 3)) 5 (1 0) ((0 1)) ((0 1) (0 3)) 6 (0 1) ((4 1)) ((4 1) (0 3)) 7 (4 1) ((2 3)) ((2 3) (0 3)) 8 (2 3)

(22)

Implementaci´

on de la b´

usqueda en profundidad

x

_B´

_{usqueda en profundidad,}

_ABIERTOS

_{se gestiona como una pila (LIFO):}

FUNCION BUSQUEDA-EN-PROFUNDIDAD()

1. Hacer ABIERTOS la pila formada por el nodo inicial (es decir, el nodo cuyo estado es *ESTADO-INICIAL* y cuyo camino es vac´ıo);

(23)

Soluciones mediante b´

usqueda en profundidad

x

_{Problema de las jarras:}

> (load "p-jarras-1.lsp") T > (load "b-profundidad.lsp") T > (busqueda-en-profundidad) #S(NODO :ESTADO (2 3) :CAMINO (LLENAR-JARRA-3-CON-JARRA-4 LLENAR-JARRA-4 VACIAR-JARRA-4-EN-JARRA-3 VACIAR-JARRA-3 LLENAR-JARRA-3-CON-JARRA-4 LLENAR-JARRA-4))

(24)

Soluciones mediante b´

usqueda en profundidad

> (trace es-estado-final) (ES-ESTADO-FINAL) > (busqueda-en-profundidad) 1. Trace: (ES-ESTADO-FINAL ’(0 0)) 1. Trace: (ES-ESTADO-FINAL ’(4 0)) 1. Trace: (ES-ESTADO-FINAL ’(4 3)) 1. Trace: (ES-ESTADO-FINAL ’(1 3)) 1. Trace: (ES-ESTADO-FINAL ’(1 0)) 1. Trace: (ES-ESTADO-FINAL ’(0 1)) 1. Trace: (ES-ESTADO-FINAL ’(4 1)) 1. Trace: (ES-ESTADO-FINAL ’(2 3)) #S(NODO :ESTADO (2 3)

:CAMINO (LLENAR-JARRA-3-CON-JARRA-4 LLENAR-JARRA-4 VACIAR-JARRA-4-EN-JARRA-3 VACIAR-JARRA-3 LLENAR-JARRA-3-CON-JARRA-4 LLENAR-JARRA-4))

(25)

Soluciones mediante b´

usqueda en profundidad

x

_{Estad´ıstica de b´}

_{usqueda en profundidad:}

Tiempo Espacio

Nodos

M´

aximo en Profundidad

(seg.)

(bytes) analizados

abiertos

m´

axima

Viaje

0.1

1.968

5

4

3 Granjero

0.14

2.800

8

3

7 Jarras

0.19

3.576

8

3

6 8-puzzle

—

(26)

Propiedades de la b´

usqueda en profundidad

x

_Complejidad:

u _m_{: m´}_{axima profundidad de la b´}_usqueda. u _{Complejidad en tiempo:} _O₍_rm_).

u _{Complejidad en espacio:} _O₍_rm_). x

_{No es completa.}

(27)

Limitaciones de la b´

usqueda en profundidad

x

_Enunciado:

u _{Una persona puede moverse en l´ınea recta dando cada vez un paso hacia la} derecha o hacia la izquierda.

u _{Representamos su posici´}_{on mediante un n´}_{umero entero.} u _{La posici´}_{on inicial es 0.}

u _{La posici´}_{on aumenta en 1 por cada paso a la derecha.} u _{La posici´}_{on decrece en 1 por cada paso a la izquierda.} u _{El problema consiste en llegar a la posici´}_{on -3.}

(28)

Problema sin soluci´

on en profundidad

x

_{Representaci´}

_{on de los estados: x un n´}

_{umero entero.}

x

_N´

_{umero de estados: infinito.}

x

_{Estado inicial: 0.}

x

_{Estado final: -3.}

x

_Operadores:

u _{Moverse un paso a la derecha.} u _{Moverse un paso a la izquierda.}

(29)

Problema sin soluci´

on en profundidad

x

_Resoluci´

_{on del problema del paseo}

> (load "p-paseo.lsp") T > (load "b-profundidad.lsp") T > (trace es-estado-final) (ES-ESTADO-FINAL) > (busqueda-en-profundidad) 1. Trace: (ES-ESTADO-FINAL ’0) 1. Trace: (ES-ESTADO-FINAL ’1) 1. Trace: (ES-ESTADO-FINAL ’2) 1. Trace: (ES-ESTADO-FINAL ’3) *** - PRINT: User break

1. Break> abort

(30)

Problema sin soluci´

on en profundidad

> (load "b-anchura.lsp") T > (busqueda-en-anchura) 1. Trace: (ES-ESTADO-FINAL ’0) 1. Trace: (ES-ESTADO-FINAL ’1) 1. Trace: (ES-ESTADO-FINAL ’-1) 1. Trace: (ES-ESTADO-FINAL ’2) 1. Trace: (ES-ESTADO-FINAL ’-2) 1. Trace: (ES-ESTADO-FINAL ’3) 1. Trace: (ES-ESTADO-FINAL ’-3) #S(NODO :ESTADO -3

(31)

Problema resoluble por profundidad y no por anchura

> (load "p-8-puzzle.lsp") T > (load "b-profundidad.lsp") T > (setf *estado-inicial* (make-array ’(3 3) :initial-contents ’((4 8 1) (3 H 2) (7 6 5)))) #2A((4 8 1) (3 H 2) (7 6 5)) > (time (busqueda-en-profundidad)) Real time: 0.709987 sec.

Run time: 0.71 sec. Space: 10660 Bytes

#S(NODO :ESTADO #2A((1 2 3) (8 H 4) (7 6 5))

:CAMINO (MOVER-IZQUIERDA MOVER-ABAJO MOVER-DERECHA MOVER-DERECHA MOVER-ARRIBA MOVER-IZQUIERDA MOVER-IZQUIERDA MOVER-ABAJO MOVER-DERECHA MOVER-DERECHA MOVER-ARRIBA MOVER-IZQUIERDA))

(32)

Implementaci´

on de la b´

usqueda en profundidad acotada

FUNCION BUSQUEDA-EN-PROFUNDIDAD-ACOTADA(COTA)

1. Hacer ABIERTOS la pila formada por el nodo inicial (es decir, el nodo cuyo estado es *ESTADO-INICIAL* y cuyo camino es vac´ıo);

2.4.1 devolver el nodo ACTUAL y terminar.

2.4.2 en caso contrario, si la profundidad del ACTUAL es menor que la cota, 2.4.2.1 Hacer NUEVOS-SUCESORES la lista de nodos de SUCESORES(ACTUAL)

cuyo estado no est´a ni en ABIERTOS ni en CERRADOS 2.4.2.2 Hacer ABIERTOS el resultado de incluir

NUEVOS-SUCESORES al principio de ABIERTOS 3. Devolver FALLO.

(33)

Propiedades de la b´

usqueda en profundidad acotada

x

_Complejidad:

u _r_{: factor de ramificaci´}_on u _c_{: cota de la profundidad} u _{Complejidad en tiempo:} _O₍_rc₎ u _{Complejidad en espacio:} _O₍_rc₎ x

_{En general, no es completa}

u _{Es completa cuando la cota es mayor que la profundidad de la soluci´}_on x

_{No es minimal}

(34)

8-puzzle: b´

usqueda en profundidad acotada

x

_Soluci´

_{on del 8-puzzle por profundidad acotada:}

> (load "p-8-puzzle.lsp") T

> (load "b-profundidad-acotada.lsp") T

> (time (busqueda-en-profundidad-acotada)) Real time: 1.212106 sec.

#S(NODO :ESTADO #2A((1 2 3) (8 H 4) (7 6 5)) :CAMINO (MOVER-DERECHA

MOVER-ABAJO

MOVER-IZQUIERDA MOVER-ARRIBA MOVER-ARRIBA))

(35)

8-puzzle: b´

usqueda en profundidad acotada

> (setf *estado-inicial* (make-array ’(3 3) :initial-contents ’((4 8 1) (3 H 2) (7 6 5)))) #2A((4 8 1) (3 H 2) (7 6 5)) > (time (busqueda-en-profundidad-acotada)) Real time: 3.242785 sec.

Run time: 3.25 sec. Space: 45796 Bytes NIL

(36)

8-puzzle: b´

usqueda en profundidad acotada

> (time (busqueda-en-profundidad-acotada :cota 12)) Real time: 0.739477 sec.

#S(NODO :ESTADO #2A((1 2 3) (8 H 4) (7 6 5)) :CAMINO (MOVER-IZQUIERDA MOVER-ABAJO

MOVER-DERECHA MOVER-DERECHA MOVER-ARRIBA MOVER-IZQUIERDA MOVER-IZQUIERDA MOVER-ABAJO

MOVER-DERECHA MOVER-DERECHA

(37)

Tabla de comparaci´

on

x

_{Estad´ısticas de soluciones del 8-puzzle:}

Anchura Profundidad Profundidad cota = 5

Profundidad cota = 12 Estado Tiempo Espacio Tiempo Espacio Tiempo Espacio Tiempo Espacio

inicial (seg.) (bytes) (seg.) (bytes) (seg.) (bytes) (seg.) (bytes)

7 5 2 8 3 1 6 4

4.51

68.292 —

—

1.21 17.704 134.42 940.096

5 8 4 1 3 2 7 6

—

0.71

10.660 —

—

0.72

10.756

(38)

Busqueda en profundidad iterativa

x

_{Arbol de b´}

_{usqueda en profundidad iterativa (problema de las jarras):}

(0 0) (4 0) 1,2,5,11,19,29,41 3,6,12,20,30,42 (4 3) 7,13,21,31,43 (1 0) (0 1) (4 1) (1 3) 8,14,22,32,44 15,23,33,45 24,34,46 (3 0) (3 3) (4 2) (0 2) (0 3) 10,17,26,37 18,27,38 40 28,39 35,47 4,9,16,25,36

(39)

Implementaci´

on de la b´

usqueda en profundidad iterativa

FUNCION BUSQUEDA-EN-PROFUNDIDAD-ITERATIVA(COTA-INICIAL) 1. Hacer N=COTA-INICIAL

2. Si BUSQUEDA-EN-PROFUNDIDAD-ACOTADA(N) no devuelve fallo, 2.1 devolver su resultado y terminar.

2.2 en caso contrario, hacer N igual a N+1 y volver a 2

(40)

Aplicaci´

on al problema de las jarras

> (load "p-jarras-1.lsp") T

> (load "b-profundidad-iterativa.lsp") T

> (time (busqueda-en-profundidad-iterativa :cota-inicial 0)) Real time: 0.178446 sec.

Run time: 0.18 sec. Space: 18288 Bytes #S(NODO :ESTADO (2 3) :CAMINO (LLENAR-JARRA-3-CON-JARRA-4 LLENAR-JARRA-4 VACIAR-JARRA-4-EN-JARRA-3 VACIAR-JARRA-3 LLENAR-JARRA-3-CON-JARRA-4 LLENAR-JARRA-4))

(41)

Propiedades de la b´

usqueda en profundidad iterativa

x

_Complejidad:

u _r_{: factor de ramificaci´}_on. u _p_{: profundidad de soluci´}_on. u _{Complejidad en tiempo:} _O₍_rp_).

u _{Complejidad en espacio:} _O₍_rp_). x

_{Es completa.}

x

_{Es minimal.}

(42)

Propiedades de la b´

usqueda en profundidad iterativa

x

_{La b´}

_{usqueda iterativa es el m´}

_{etodo preferido si el espacio de b´}

_usqueda

es grande y no se conoce la profundidad de la soluci´

on

x

_{La redundancia en la expansi´}

_{on queda compensada con la completitud}

u _Adem´_{as, la redundancia no es significativa}

x

_Ejemplo,

_r

_{= 10}

_y

_p

_{= 5}

_:

u _B´_{usqueda acotada, nodos analizados:} _{1 + 10 + 100 + 1000 + 10000 + 100000 = 111111} u _B´_{usqueda iterativa, nodos analizados:} _{1 + 11 + 111 + 1111 + 11111 + 111111 = 123456} u _{Tan s´}_{olo un 10 % m´}_as

(43)

Tabla de comparaci´

on

x

_{Estad´ısticas de soluciones del 8-puzzle:}

Anchura Profundidad Profundidad iterativa

Estado Tiempo Espacio Tiempo Espacio Tiempo Espacio inicial (seg.) (bytes) (seg.) (bytes) (seg.) (bytes)

7 5 2 8 3 1 6 4

4.51

68.292 —

—

0.6

8.992

5 8 4 1 3 2 7 6

—

0.71 10.660 71.83 655.594

(44)

Tabla de comparaci´

on (procedimientos compilados)

x

_{Estad´ısticas del 8-puzzle con procedimientos compilados:}

Anchura Profundidad Profundidad iterativa

Estado Tiempo Espacio Tiempo Espacio Tiempo Espacio inicial (seg.) (bytes) (seg.) (bytes) (seg.) (bytes)

7 5 2 8 3 1 6 4

0.22

27.424 —

—

0.06

8.236

5 8 4 1 3 2 7 6

—

0.04

5.984 15.88 656.020

(45)

Comparaci´

on de procedimientos

Anchura Profundidad

Profundidad

acotada

Profundidad

iterativa

Tiempo

O(r

p

)

O(r

m

)

O(r

c

)

O(r

p

)

Espacio

O(r

p

)

O(rm)

O(rc)

O(rp)

Completa

S´ı

No

S´ı, si

c >=

p

S´ı

Minimal

S´ı

No

S´ı

u _p_{: profundidad de la soluci´}_on.

u _m_{: m´}_{axima profundidad de la b´}_usqueda. u _c_{: cota de la profundidad.}

(46)

Bibliograf´ıa

x

_{Borrajo, D. y otros}

_{Inteligencia artificial: M´}

_{etodos y t´}

_ecnicas

_(Centro

de estudios Ram´

on Areces, 1993).

u _{Cap. 4: “B´}_usqueda”.

x

_Cort´

_{es, U., B´}

_{ejar, J. y Moreno, A.}

_{Inteligencia artificial}

_(Ediciones

UPC, 1994).

u _{Cap. 4: “B´}_{usqueda y estrategias”.}

x

_{Mira, J.; Delgado, A.E.; Boticario, J.G. y D´ıez, F.J.}

_{Aspectos b´}

_asicos

de la Inteligencia Artificial

(Sanz y Torres, 1995)

(47)

Bibliograf´ıa

x

_{Rich, E. y Knight, K.}

_{Inteligencia artificial (segunda edici´}

_on)

(McGraw–Hill Interamericana, 1994).

u _{Cap. 2: “Problemas, espacios problema y b´}_usqueda”.

x

_{Russell, S. y Norvig, P.}

_{Inteligencia artificial: Un enfoque moderno}

(Prentice Hall, 1996).

u _{Cap. 3: “Soluci´}_{on de problemas mediante b´}_usqueda”

x

_{Winston, P.R. y Horn, B.K.}

_{LISP (3a. ed.)}

_{(Addison–Wesley, 1991).}

u _{Cap. 19: “Ejemplos que involucran b´}_usquedas”.

x

_{Winston, P.R.}

_{Inteligencia artificial (3a. ed.)}

_{(Addison–Wesley, 1994).}

u _{Cap. 4: “Redes y b´}_{usqueda b´}_asica”.

(48)

Introducci´on a la Inteligencia Artificial Curso 2003–2004

Tema 2 (anexo):

Implementaciones en Lisp

Dpto. de Ciencias de la Computaci´on e Inteligencia Artificial

(49)

Respresentaci´

on en Lisp de los nodos de b´

usqueda

x

_{Nodo = Estado + Camino}

x

_{Representaci´}

_{on de nodos en Lisp}

(defstruct (nodo (:constructor crea-nodo) (:conc-name nil))

estado camino)

(50)

Implementaci´

on Lisp: expansi´

on de nodos

(defun nuevos-sucesores (nodo abiertos cerrados)

(elimina-duplicados (sucesores nodo) abiertos cerrados)) (defun sucesores (nodo)

(let ((resultado ()))

(loop for operador in *operadores* do

(let ((siguiente (sucesor nodo operador)))

(when siguiente (push siguiente resultado)))) (nreverse resultado)))

(defun sucesor (nodo operador)

(let ((siguiente-estado (aplica operador (estado nodo)))) (when siguiente-estado

(crea-nodo :estado siguiente-estado :camino (cons operador

(51)

Implementaci´

on Lisp: expansi´

on de nodos

(defun elimina-duplicados (nodos abiertos cerrados) (loop for nodo in nodos

when (and (not (esta nodo abiertos)) (not (esta nodo cerrados))) collect nodo))

(defun esta (nodo lista-de-nodos) (let ((estado (estado nodo)))

(loop for n in lista-de-nodos

thereis (equalp estado (estado n)))))

(52)

Implementaci´

on en Lisp de la b´

usqueda en anchura

(defun busqueda-en-anchura ()

(let ((abiertos (list (crea-nodo :estado *estado-inicial* ;1.1 :camino nil)))

(cerrados nil) ;1.2

(actual nil) ;1.3

(nuevos-sucesores nil)) ;1.4

(loop until (null abiertos) do ;2

(setf actual (first abiertos)) ;2.1

(setf abiertos (rest abiertos)) ;2.2

(setf cerrados (cons actual cerrados)) ;2.3

(cond ((es-estado-final (estado actual)) ;2.4

(return actual)) ;2.4.1

(t (setf nuevos-sucesores ;2.4.2.1

(nuevos-sucesores actual abiertos cerrados))

(setf abiertos ;2.4.2.2

(53)

Implementaci´

on de la b´

usqueda en profundidad

(defun busqueda-en-profundidad ()

(let ((abiertos (list (crea-nodo :estado *estado-inicial* ;1.1 :camino nil)))

(cerrados nil) ;1.2

(actual nil) ;1.3

(t (setf nuevos-sucesores ;2.4.2.1

(setf abiertos ;2.4.2.2

(append nuevos-sucesores abiertos)))))))

(54)

Implementaci´

on en Lisp del problema del paseo

x

_{Problema sin soluci´}

_{on en profundidad}

(defparameter *estado-inicial* 0)

(defparameter *estado-final* -3)

(defun es-estado-final (estado) (= estado *estado-final*))

(defparameter *operadores* ’(mover-a-derecha

mover-a-izquierda))

(defun mover-a-derecha (estado) (+ estado 1))

(defun mover-a-izquierda (estado) (- estado 1))

(55)

Implementaci´

on en Lisp de la b´

usqueda acotada

(defun busqueda-en-profundidad-acotada (&key (cota 5))

(let ((abiertos (list (crea-nodo :estado *estado-inicial*

:camino nil))) ;1.1

(cerrados nil) ;1.2

(actual nil) ;1.3

((< (length (camino actual)) cota)

(setf nuevos-sucesores ;2.4.2.1

(setf abiertos (append nuevos-sucesores abiertos)))))))

(56)

Implementaci´

on de la b´

usqueda en profundidad iterativa

(defun busqueda-en-profundidad-iterativa (&key (cota-inicial 5)) (loop for n from cota-inicial