INSTITUTO TECNOLÓGICO DE CHETUMALBúsqueda de amplitud

Castillo Olivera Ricardo Orlando

Inteligencia artificial

ÍNDICE

INTRODUCCION...............................................................................................................3

BÚSQUEDA DE AMPLITUD...............................................................................................4

ALGORITMO PARA BÚSQUEDA EN AMPLITUD. NIVEL DE CONOCIMIENTO.......................6

ANÁLISIS DEL ALGORITMO. NIVEL DE CONOCIMIENTO....................................................8

ALGORITMO PARA BÚSQUEDA EN AMPLITUD. NIVEL SIMBOLICO...................................9

ANÁLISIS DEL ALGORITMO. NIVEL SIMBOLICO...............................................................11

CONCLUSIONES.............................................................................................................12

CODIGO EN PYTHON......................................................................................................13

2

INTRODUCCION

La búsqueda sin información del dominio, también llamada ciega o exhaustiva es:

• Sistemática.- No deja sin explorar ningún nodo y lo explora sólo una vez.

• Objetiva.- Pues no depende del dominio del problema.

Estas técnicas son poco eficientes, aunque, en coste promedio, son mejores que

las que utilizan el conocimiento del dominio del problema. Se caracterizan, entre

otras cosas, porque la aplicación de los operadores a los estados se realiza de

manera sistemática, uno detrás de otro (estrategia de control no informada).

Además todas ellas son búsquedas por tentativas y utilizan un esquema de

producción (búsqueda en el espacio de estados).

Como criterio para diferenciarlas, se utilizará el orden en que se recorren los

estados. Así., para el espacio de estados, tendremos:

• Búsqueda en amplitud

• Búsqueda en profundidad

• Búsqueda con retroceso

• Otras estrategias derivadas de las anteriores

Búsqueda en profundidad progresiva

Búsqueda bidireccional

Se ha dicho que para representar el proceso de búsqueda se van a utilizar grafos.

Para explicar estas técnicas no se va a entrar en temas específicos de

implementación. De momento vamos a limitarnos a utilizar árboles de exploración:

no vamos a tener en cuenta los casos en los que, cuando se expande un estado,

se produce un estado que ya estaba anteriormente en el grafo de búsqueda (el

caso general lo veremos al final, con el algoritmo general de búsqueda en grafos).

Así. mismo, para el análisis de coste, se va a considerar que cada operador tiene

un coste unitario. Esto, en un problema real, es poco probable ya que unos

operadores supondrán más esfuerzo que otros. También vamos a considerar que

el número máximo de hijos de un nodo es finito.

3

BÚSQUEDA DE AMPLITUD

Igualmente denominada en anchura. Dado un nivel de profundidad N, se revisan

todas las trayectorias (se aplican todos los operadores e instanciaciones de los

mismos) antes de revisar trayectorias más profundas. Es decir, no se expanden

nodos del nivel N+1 hasta que no se hayan expandido todos los estados del nivel

N. El proceso termina con error si no hay más nodos que expansionar sin

encontrar una meta.

Para almacenar la evolución de la búsqueda, vamos a definir una estructura de

datos del TDA14 cola (estructura FIFO), que llamaremos ABIERTA, donde va a

almacenar todos los estados abiertos (frontera de expansión). Cada celda de

ABIERTA almacenará el estado y un apuntador a su precedesor15 (padre).

Según vamos aplicando el algoritmo, vamos dibujando el grafo de exploración.

Dependiendo de la solución requerida tendremos dos variantes: Que la solución

sea la meta, cuyo caso la solución es inmediata o que sea la secuencia de

operaciones hasta una meta, en cuyo caso seguimos el camino más corto de la

meta a la raíz en el grafo de exploración obtenido (árbol implícito con la solución).

Ejemplo 1:

Supongamos que la descripción del problema es el estado e0 (raíz del

grafo) y se le pueden aplicar dos operadores y uno de ellos con dos

instanciaciones, lo que nos da tres estados de nivel 1: e1 e2 e3. A e1 se

puede aplicar un operador, a e2 tres operadores e3 dos operadores, que

nos da seis estados de nivel 2: e4, e5, e6, e7, e8, e9. En nivel 3, a e5 se

puede aplicar 1 operador....

En el grafo explícito (de exploración) de la secuencia de acciones en la

tarea de búsqueda que tenemos a continuación, vemos en rojo el orden en

el que se generan los estados a partir del padre (de izquierda a derecha,

primero el nivel 0, luego el 1, luego el 2,..... y así. sería hasta que se

encuentre una solución), y que es el mismo orden de expansión. Podemos

notar que los hijos de e0 y e3 no se generan correlativos: esto es por el

orden no informado de aplicación de los operadores (otro orden también es

4

válido). En el momento de terminar el nivel 2, mostrado en el grafo, el

estado de ABIERTA y CERRADA sería:

ABIERTA : e5, e4, e6, e8, e7 e9

CERRADA: e1, e3, e2, e0

Y el siguiente paso sería expandir e5:

ABIERTA : e4, e6, e8, e7 e9, e10 CERRADA: e5, e1, e3, e2, e0

5

ALGORITMO PARA BÚSQUEDA EN AMPLITUD. NIVEL DE CONOCIMIENTO

Crear la lista ABIERTA y poner en su primer elemento el nodo raíz (descripción del

problema).

HASTA que ABIERTA esté vacía (error) o el estado sea META

Extraer (eliminar) de ABIERTA el primer nodo de la lista, y asignarlo a

‘t’(temporal) //expandimos ‘t’16

PARA cada operador y cada instanciación de operador aplicable a ‘t’:

Aplicar el operador a ‘t’. Obtendremos un nuevo estado ‘s’ (sucesor). A este

le asignamos como padre a ‘t’ (apuntador).

SI‘s’esmeta:

Terminar con la expansión de nodos

SINO

Incluir ‘s’ al final de ABIERTA. (1)

//fin PARA cada operador

//fin HASTA que ABIERTA está vacía (error) o el estado es META

SI es META

Devolver la solución (2)

SINO //ABIERTA está vacía = error

Mensaje de error. No se ha encontrado una solución posible.

(1) Se podría pensar en este punto en no añadir ‘s’ si este es un callejón sin

salida. Pero en una búsqueda ciega ¿Cómo comprobamos que es un punto

sin retorno? Este estado se eliminará cuando se vaya a expansionar y no

haya operadores para aplicar. Complicarlo para no añadirlo a ABIERTA

según se genera, no merece la pena porque el número de estos estados es

muy pequeño con respecto al número total de estos, por lo que no afecta a

la eficiencia espacial, pero la comprobación adicional sí puede afectarla.

(2) Si la solución es la meta, se devuelve ‘s’ y si es la secuencia de

operaciones damos el camino más corto de la meta ‘s’ a la raíz en el grafo

de exploración obtenido.

6

7

ANÁLISIS DEL ALGORITMO. NIVEL DE CONOCIMIENTO

• Completo.- Es completo, pues si hay una solución, esta estrategia la

encuentra (siempre con los recursos disponibles).

• Óptimo.- Hemos dicho que si hay solución, esta estrategia la encuentra;

pero además va a encontrar la de menor coste, si consideramos que los

operadores tienen el mismo coste unitario, y en todo caso la solución con el

menor número de operaciones (la de menor nivel).

• Complejidad temporal.- El tiempo de ejecución dependerá. del factor de

ramificación y de la profundidad. Si el número de operadores es n y la

solución está en la profundidad p, el tiempo necesario será.

1+n+n2+n3....+np; el coste temporal está en O(np).

• Complejidad espacial.- Al terminar la expansión de los estados de un nivel

de profundidad (p-1) tendremos almacenados en ABIERTA todos los

estados del nivel p. Si el número de operadores es n y estamos a

profundidad p, tendremos almacenados np estados. El caso peor será.

cuando la meta esté en el último estado generable de un nivel p. Así. el

coste espacial está en O(np).

8

ALGORITMO PARA BÚSQUEDA EN AMPLITUD. NIVEL SIMBOLICO

Si la solución requerida es el estado meta, el algoritmo descrito anteriormente

funciona al nivel simbólico. Pero si la solución buscada es el camino desde la meta

hasta la raíz ¿Cómo representamos el grafo explícito en el nivel simbólico? Porque

hasta ahora lo hemos dibujado. Para dar una solución (no la mejor) se puede

definir otra estructura de datos del TDA pila, que llamaremos CERRADA, donde va

a almacenar los estados cerrados. Como en ABIERTA, cada celda de las

estructuras de datos almacenará el estado y un apuntador a su predecesor

(padre). Si se encuentra la meta, la solución estará. en CERRADA, en el árbol

implícito que resulta de seguir los punteros desde la meta hasta la raíz.

Crear la lista ABIERTA y poner en su primer elemento el nodo raíz (descripción del

problema).

Crear la lista CERRADA, que inicialmente estará. vacía. (1)

HASTA que ABIERTA esté vacía o el estado sea META

Extraer (eliminar) de ABIERTA el primer nodo de la lista, y asignarlo a

‘t’(temporal), y a su vez lo copiaremos en la siguiente posición de

CERRADA.

//expandimos ‘t’

PARA cada operador y cada instanciación de operador aplicable a ‘t’:

Aplicar el operador a ‘t’. Obtendremos un nuevo estado ‘s’ (sucesor). A este

le asignamos como padre a ‘t’ (apuntador).

SI‘s’esmeta:

Asignar ‘s’ a CERRADA y terminar con la expansión de nodos

SINO

Incluir ‘s’ al final de ABIERTA. (2)

//fin PARA cada operador

//fin HASTA que ABIERTA está vacía o el estado es META

SI es META

9

La solución estará. en CERRADA. Se visita la pila desde el estado meta

hasta el raíz en el orden dado por el campo de puntero al estado padre,

siendo la profundidad del árbol solución el número de estados en la

secuencia y el coste la suma de las aristas del árbol.

SINO

Mensaje de error. No se ha encontrado una solución posible.

(1) Si solo se pide la meta como solución, no se necesitaría la estructura

CERRADA.

(2) Se podría pensar en este punto en no añadir ‘s’ si este es un callejón sin

salida. Pero en una búsqueda ciega ¿Cómo comprobamos que es un

punto sin retorno? Este estado se eliminará cuando en su expansión no

haya operadores para aplicar.

10

ANÁLISIS DEL ALGORITMO. NIVEL SIMBOLICO

• Completo.- Es completo, pues si hay una solución, esta estrategia la

encuentra (siempre con los recursos disponibles).

• Óptimo.- Hemos dicho que si hay solución, esta estrategia la encuentra;

pero además va a encontrar la de menor coste, si consideramos que los

operadores tienen el mismo coste unitario, y en todo caso la solución con el

menor número de operaciones (la de menor nivel). Veremos formalmente

esta propiedad cuando veamos, en el siguiente capítulo, el algoritmo

heurístico A*.

• Complejidad temporal.- El tiempo de ejecución dependerá. del factor de

ramificación (no medio de operadores) y de la profundidad. Si el número de

operadores es n y la solución está en la profundidad p, el tiempo necesario

será 1+n+n2+n3....+np; el coste temporal está en O(np).

• Complejidad espacial.- Si se juntan los estados que almacena ABIERTA

(los que están pendientes de expandir) con los que almacena CERRADA

(los que ya están expandidos), resulta que necesitamos almacenamiento

para todos los estados que se vayan a generar en la búsqueda de la

solución. Este número será. la suma de cada nivel que será. de

1+n+n2+n3....+np; el coste espacial está en O(np).

11

CONCLUSIONES

Podemos decir que tiene como ventaja la de que si existe una solución, siempre la

encuentra y que además es la de menor coste (si son costes uniformes) y en todo

caso la de menor profundidad. Como desventajas están la complejidad espacial y

temporal que son de orden exponencial (si el factor de ramificación es muy

grande, se pueden almacenar innecesariamente muchos estados).

12

CODIGO EN PYTHON

arbol=[]

lista=[]

def rama(tree, raiz, adds):

expandir=[]

recorrido=0

if(len(tree)!=0):

while (len(tree)>recorrido and recorrido!=None):

if (raiz!=tree[recorrido]):

recorrido+=2

expandir+=tree[recorrido-1]

else:

tree[recorrido+1].append(adds)

tree[recorrido+1].append([])

recorrido=None

if(recorrido!=None):

rama(expandir, raiz, adds)

else:

print "La raiz no esta en el arbol"

def crearraiz (arbol, raiz):

arbol.append(raiz)

arbol.append([])

crearraiz(arbol, "a")

rama(arbol, "a", "b")

rama(arbol, "a", "c")

rama(arbol, "a", "d")

rama(arbol, "a", "f")

rama(arbol, "f", "g")

rama(arbol, "f", "h")

def buscar_ancho(tree, letra):

13

expandir=[]

recorrido=0

if(len(tree)!=0):

while (len(tree)>recorrido and recorrido!=None):

if (letra!=tree[recorrido]):

lista.append(tree[recorrido])

recorrido+=2

expandir+=tree[recorrido-1]

print lista

else:

print "Encontrado la letra " +'"'+letra+'"'

recorrido=None

if(recorrido==None):

while (len(lista)!=0):

del lista[0]

print lista

else:

buscar_ancho(expandir, letra)

else:

print "No esta en el arbol"

buscar_ancho(arbol,"f")

14