técnicas de búsquedas informada

ESCUELA POLITÉCNICA NACIONAL

FACULTAD DE INGENIERÍA DE SISTEMAS

INGENIERÍA EN SISTEMAS INFORMÁTICOS Y COMPUTACIÓN

INTELIGENCIA ARTIFICIAL

ALMENDÁRIZ VANESSA

MOLINA SAMANTHA

IMPLEMENTACIÓN DE LA TÉCNICA DE BÚSQUEDA

01 DE DICIEMBRE DEL 2014

Pepe

Nota adhesiva

Buen trabajo, felicidades 100/100

ÍNDICE pág.

Contenidos ÍNDICE ................................................................................................................................................2

Tabla de Figuras .........................................................................................................................2

Introducción ...................................................................................................................................3

Marco Teórico ................................................................................................................................3

Búsqueda no informada .............................................................................................................3

Problema ....................................................................................................................................4

Implementación Conceptual ..........................................................................................................4

Diagrama de estados completos ................................................................................................5

Implementación Computacional ....................................................................................................5

Resultados ......................................................................................................................................8

Conclusiones ..................................................................................................................................9

Anexos ..........................................................................................................................................10

Tabla de Figuras

Figura 1: Generar estados. .................................................................................................................6

Figura 2: Método clone implementado para las funciones regresar y enviar. ...................................6

Figura 3: Comprobación del número de caníbales y de misioneros. ..................................................6

Figura 4: Función sucesor. ..................................................................................................................7

Figura 5: Función Arbol en la Clase Arbol ...........................................................................................7

Figura 6: Árbol que contiene los estados alcanzables por el agente. .................................................8

Figura 7: Resultado de la búsqueda primero en profundidad con profundidad iterativa...................9

Introducción Uno de los problemas que se analiza en Inteligencia Artificial es el problema de los caníbales y los misioneros, en el cual se parte de un estadio inicial con tres caníbales y tres misioneros en una orilla y el estado objetivo es llevar a los seis a la otra orilla. Para hallar la solución de este problema se ha usado la búsqueda primero en profundidad con profundidad iterativa, que es una estrategia de la búsqueda no informada, con la eliminación de estados repetidos.

Marco Teórico

Búsqueda no informada

La búsqueda no informada, también conocida como búsqueda a ciegas, es un tipo de búsqueda que consiste en partir de un estado inicial para generar todos los estados posibles mediante los cuales se pueda encontrar la solución, cada vez que genera un estado lo compara con el estado objetivo. Si el estado actual es el estado objetivo encuentra solución, caso contrario genera un nuevo estado [1]. La búsqueda no informada posee cinco estrategias, estas son [1]:

a) Búsqueda en anchura b) Búsqueda de costo uniforme c) Búsqueda primero en profundidad d) Búsqueda de profundidad limitada e) Búsqueda primero en profundidad, con profundidad iterativa.

Búsqueda primero en profundidad con profundidad iterativa

La búsqueda primero en profundidad con profundidad iterativa, también conocida como búsqueda con profundidad iterativa, es una de las mejores estrategias que ofrece la búsqueda no informada. Esto debido a que combina las ventajas que ofrecen la búsqueda por anchura y búsqueda primero en profundidad [1]. Consiste en ir aumentando gradualmente el límite del árbol, comienza desde el nivel 0 y en cada iteración aumenta un nivel, en cada uno de estos se genera el árbol nuevamente. Esta estrategia es usada, especialmente, cuando el espacio de búsqueda es grande y no se conoce la profundidad de la solución [1].

Estados repetidos

Uno de los problemas que enfrenta este tipo de búsqueda es la generación de estados repetidos, para que este inconveniente se resuelve es conveniente llevar un registro de los estados visitados y comparar con el estado a generar para agregarlo, en el caso de que no esté presente en la lista, o para excluirlo, en el caso de que se encuentre dentro de la lista.

Problema

El problema de los tres misioneros y los tres caníbales radica en un estado inicial, donde los seis se encuentran en un lado de la orilla, y un estado objetivo que consiste en llevar a los seis al otro lado de la orilla. Para el transporte se tiene una canoa, en la cual pueden viajar dos personas (puede ser un misionero y un caníbal, o dos caníbales o dos misioneros) o una (un misionero o un caníbal). También se debe considerar las restricciones, en estas se establece que el número de caníbales no puede superar al número de misioneros debido a que los caníbales devorarán al misionero y ya no se podría llegar al estado objetivo.

Implementación Conceptual El objetivo del problema es pasar a todos a la otra orilla. La condición que se pone es que sólo se puede pasar a dos personas a la vez y que no debe ocurrir nunca que en una de las orillas haya un número mayor de caníbales que de misioneros, ya que se los comerían.

Estado inicial:

I D

M:3;C:3 M:0;C:0

Estado objetivo:

I D

M:0;C:0 M:3;C:3

Condición: No debe existir #caníbales > #misioneros en cualquier orilla. Estados:

Parámetros: Número de misioneros a la izquierda, número de caníbales a la izquierda, número de misioneros a la derecha, número de caníbales a la derecha, posición bote.

Operaciones:

Transportar 2 misioneros.

Transportar 2 caníbales.

Transportar 1 misionero y 1 caníbal.

Diagrama de estados completos

Implementación Computacional

Para resolver el problema de manera óptima se ha utilizado un algoritmo con búsqueda en profundidad en el lenguaje de programación JAVA en Eclipse Luna. Se creó una clase estado, donde se definió el número de misioneros a la izquierda, número de caníbales a la izquierda, número de misioneros a la derecha, número de caníbales a la derecha y posición bote (1: derecha, 0: izquierda. ). Los estados se implementan en una lista.

M:3;C:3 M:0;C:0

M:2;C:2 M:1;C:1 M:3;C:1 M:0;C:2 M:1;C:3 M:2;C:0

M:2;C:2 M:1;C:1 M:3;C:2 M:0;C:1

M:2;C:1 M:1;C:2 M:3;C:0 M:0;C:3 M:1;C:2 M:2;C:1

M:3;C:1 M:0;C:2

M:1;C:1 M:2;C:2 M:2;C:0 M:1;C:3

M:2;C:2 M:1;C:1

M:2;C:2 M:1;C:1

M:2;C:2 M:1;C:1

M:0;C:2 M:3;C:1

M:0;C:3 M:3;C:0 M:1;C:2 M:2;C:1

M:0;C:1 M:3;C:2

M:0;C:2 M:3;C:1 M:1;C:1 M:2;C:2

M:0;C:0 M:3;C:3 M:0;C:0 M:3;C:3

Para la generación de estados se crea dos funciones: enviar y regresar.

Figura 1: Generar estados.

En estas dos funciones se implementa un clonable para poder clonar los estados. El método clone copia y regresa un clón del objeto. [2]

Figura 2: Método clone implementado para las funciones regresar y enviar.

Después se comprueba que los caníbales no sean mayores a los misioneros en cada orilla, para evitar un error (que se coman los misioneros).

Figura 3: Comprobación del número de caníbales y de misioneros.

Se crea una función sucesor que es una función recursiva. Ayuda a comprobar si el estado está en la lista y si ha aparecido para evitar que se repitan los estados que ya han pasado. Se establece el estado objetivo al que tiene que llegar (0, 0, 3, 3, 0 ). Si, no cumple con las condiciones, salta al siguiente elemento de la lista de nodos hijos, el else if es igual al estado objetivo. Para la ejecución, el else es la parte recursiva que manda a generar estados de ese nodo, verifica si esta a la izquierda o a la derecha y en función de eso, envía o regresa. Puede enviar o regresar 2 caníbales, 2 misioneros o 1 caníbal y 1 misionero.

Figura 4: Función sucesor.

Mientras va buscando el estado objetivo, existe un caso especial en el que regresa 1 misionero o 1 caníbal, sino nunca pasa y se repite mientras no llegue a la solución. Para generar el árbol de forma gráfica, se creó una clase Arbol y se usó los métodos para hacer árboles de JAVA.

Figura 5: Función Arbol en la Clase Arbol

Resultados Para realizar la búsqueda no informada, con la estrategia primero en profundidad con profundidad iterativa, es necesario generar un árbol de los estados alcanzables por el agente; en este árbol se han eliminado los estados repetidos, esto debido a que ayuda a optimizar los la búsqueda. En la Figura 6 se muestra el árbol generado, en el cual se muestra los posibles caminos que puede seguir el agente para cumplir el objetivo. Tanto los estados repetidos como los estados que no permiten cumplir con el objetivo son nodos hoja. Una vez generados los estados posibles, se procede a realizar la búsqueda, el resultado de esta se muestra en la Figura 7. La búsqueda se realiza por niveles hasta encontrar llegar al objetivo, “PASA DE NODO” cuando ha llegado a un estado que no le permite cumplir con el objetivo y “ENCUENTRA EL OBJETIVO”, cuando ha llegado al estado deseado.

Figura 6: Árbol que contiene los estados alcanzables por el agente.

Figura 7: Resultado de la búsqueda primero en profundidad con profundidad iterativa.

La eliminación de estados repetidos del árbol permite obtener una solución óptima mediante la disminución de la utilización de recursos, tales como memoria y tiempo. Los estados repetidos pueden demorar el hallazgo de la solución cuando esta no se encuentre en el inicio del árbol. Esto se debe a que tiene que recorrer todo el árbol inclusive con estados ya visitados, la eliminación de estos disminuye el tiempo en el cual se realizará la misma, al igual que el uso de la memoria ya que sólo almacena los estados no repetidos. A pesar de ser un problema “simple” el agente afronta ciertos problemas durante la resolución del mismo, esto se debe a que existe una cantidad considerable de estados posibles y él debe ir evaluando cada uno de ellos considerando las restricciones del problema.

Conclusiones

En este tipo de problemas de búsqueda no informada es de importancia para el agente tener una meta específica, y determinar las posibles estrategias u acciones.

Si se establece condiciones o información sobre los estados sucesores, es posible que no afecte de forma importante el número de movimientos para llegar al estado objetivo. Sin embargo, cuando se analiza cada movimiento pueden existir nodos que provoquen un bucle infinito y por lo tanto es necesario reducir o quitar esos estados.

Una manera eficiente para resolver este problema es que no tenga ciclos y estados repetidos. Estos deben ser eliminados. El nivel al que llega el árbol para su solución es el nivel 11.

Referencias

[1] M. Rouse, «SearchSecurity,» Julio 2006. [En línea]. Available:

http://searchsecurity.techtarget.com/definition/Transport-Layer-Security-TLS. [Último acceso:

13 octubre 2014].

[2] Tutorialspoint, «Java - Methods,» 2009. [En línea]. Available:

http://www.tutorialspoint.com/java/lang/object_clone.htm. [Último acceso: 30 noviembre

2014].

Anexos CLASE ARBOL package artificial;

import java.awt.*;

import java.util.ArrayList;

import javax.swing.*;

import javax.swing.event.TreeSelectionListener;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.tree.*;

public class Arbol extends JFrame {

private JTree tree;

public static void main(String[] args) {

Arbol a = new Arbol();

}

public Arbol() {

Estado estadoInicial = new Estado(3, 3, 1);

estadoInicial.generarEstados();

java.util.List<Estado> estadosObtenidos = new ArrayList<>();

estadosObtenidos.add(estadoInicial);

DefaultMutableTreeNode raiz = new

DefaultMutableTreeNode(estadoInicial);

funcionSucesor(estadoInicial, estadosObtenidos, raiz);

Container content = getContentPane();

tree = new JTree(raiz);

ToolTipManager.sharedInstance().registerComponent(tree);

content.add(new JScrollPane(tree), BorderLayout.CENTER);

setSize(900, 900);

setVisible(true);

}

public static void funcionSucesor(Estado estadoActual,

java.util.List<Estado> estadosObtenidos, DefaultMutableTreeNode padre) {

Estado objetivo = new Estado(0, 0, 3, 3, 0);

for (Estado e : estadoActual.getEstados()) {

if (!estadosObtenidos.contains(e)) {

if ((e.getNumeroCanibalesDerecha() >

e.getNumeroMisionerosDerecha() && e.getNumeroMisionerosDerecha() != 0) ||

(e.getNumeroCanibalesIzquierda() > e.getNumeroMisionerosIzquierda() &&

e.getNumeroMisionerosIzquierda() != 0)) {

estadosObtenidos.add(e);

DefaultMutableTreeNode nodo = new

DefaultMutableTreeNode(e);

padre.add(nodo);

System.out.println("PASA DE NODO: " + e.toString());

//continue;

} else if (e.equals(objetivo)) {



padre.add(nodo);

System.out.println("ENCONTRO EL OBJETIVO");

break;

} else {

estadosObtenidos.add(e);

System.out.println(e.toString());



padre.add(nodo);

e.generarEstados();

funcionSucesor(e, estadosObtenidos, nodo);

}

}

}

}

private class MyTreeRenderer extends DefaultTreeCellRenderer {

public Component getTreeCellRendererComponent(JTree tree, Object

value, boolean sel, boolean expanded, boolean leaf, int row, boolean

hasFocus) {

JComponent component = (JComponent)

super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row,

hasFocus);

Object selected = ((DefaultMutableTreeNode)

value).getUserObject();

if (selected instanceof MyTreeClass) {

component.setToolTipText(((MyTreeClass)

selected).getToolTip());

}

return component;

}

}

private class MyTreeClass {

private Estado estado;

public MyTreeClass(Estado estado) {

this.estado = estado;

}

public Estado getEstado() {

return estado;

}

public void setEstado(Estado estado) {

this.estado = estado;

}

public String getToolTip() {

return "hijo";

}

}

}

CLASE ESTADO package artificial;

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Level;

import java.util.logging.Logger;

public class Estado implements Cloneable {

/**

* Numero de misioneros en el lado izquierdo.

*/

private int numeroMisionerosIzquierda;

/**

* Numero de canibales en el lado izquierdo.

*/

private int numeroCanibalesIzquierda;

/**

* Numero de misioneros en el lado izquierdo.

*/

private int numeroMisionerosDerecha;

/**

* Numero de canibales en el lado izquierdo.

*/

private int numeroCanibalesDerecha;

/**

* Posicion 0: derecha, 1: izquierda.

*/

private int posicion;

/**

* Lista de estados hijos.

*/

private List<Estado> estados;

public Estado() {

}

public Estado(int numeroMisioneros, int numeroCanibales, int

posicion) {

this.numeroMisionerosIzquierda = numeroMisioneros;

this.numeroCanibalesIzquierda = numeroCanibales;

this.posicion = posicion;

}

public Estado(int numeroMisionerosIzquierda, int

numeroCanibalesIzquierda, int numeroMisionerosDerecha, int

numeroCanibalesDerecha, int posicion) {

this.numeroMisionerosIzquierda = numeroMisionerosIzquierda;

this.numeroCanibalesIzquierda = numeroCanibalesIzquierda;

this.numeroMisionerosDerecha = numeroMisionerosDerecha;

this.numeroCanibalesDerecha = numeroCanibalesDerecha;


}

public void generarEstados() {

setEstados(new ArrayList<Estado>());

if (posicion == 1) {

enviar();

} else {

regresar();

}

}

public void enviar() {

List<Estado> es = new ArrayList<>();

Estado e1 = new Estado();



try {

e1 = this.clone();

e2 = this.clone();

e3 = this.clone();

} catch (CloneNotSupportedException ex) {

Logger.getLogger(Estado.class.getName()).log(Level.SEVERE,

null, ex);

}

if (numeroCanibalesIzquierda >= 2) {

e1.setNumeroCanibalesIzquierda(numeroCanibalesIzquierda - 2);

e1.setNumeroCanibalesDerecha(numeroCanibalesDerecha + 2);

e1.setPosicion(0);

es.add(e1);

}

if (numeroCanibalesIzquierda >= 1) {

if (numeroMisionerosIzquierda >= 1) {

e2.setNumeroCanibalesIzquierda(numeroCanibalesIzquierda -

1);

e2.setNumeroMisionerosIzquierda(numeroMisionerosIzquierda

- 1);

e2.setNumeroCanibalesDerecha(numeroCanibalesDerecha + 1);

e2.setNumeroMisionerosDerecha(numeroMisionerosDerecha +

1);

e2.setPosicion(0);

es.add(e2);

}

}

if (numeroMisionerosIzquierda >= 2) {

e3.setNumeroMisionerosIzquierda(numeroMisionerosIzquierda -

2);

e3.setNumeroMisionerosDerecha(numeroMisionerosDerecha + 2);

e3.setPosicion(0);

es.add(e3);

}

this.setEstados(es);

}

public void regresar() {

Estado e = new Estado();


List<Estado> es = new ArrayList<>();

try {

e = this.clone();

e2 = this.clone();

} catch (CloneNotSupportedException ex) {

Logger.getLogger(Estado.class.getName()).log(Level.SEVERE,

null, ex);

}

if (numeroMisionerosDerecha > numeroCanibalesDerecha) {

e.setNumeroMisionerosDerecha(numeroMisionerosDerecha - 1);

e.setNumeroMisionerosIzquierda(numeroMisionerosIzquierda +

1);

e.setPosicion(1);

es.add(e);

e2.setNumeroCanibalesDerecha(numeroCanibalesDerecha - 1);

e2.setNumeroCanibalesIzquierda(numeroCanibalesIzquierda + 1);

e2.setPosicion(1);

es.add(e2);

} else if (numeroMisionerosDerecha == numeroCanibalesDerecha) {

e.setNumeroMisionerosDerecha(numeroMisionerosDerecha - 1);

e.setNumeroMisionerosIzquierda(numeroMisionerosIzquierda +

1);

e.setNumeroCanibalesDerecha(numeroCanibalesDerecha - 1);

e.setNumeroCanibalesIzquierda(numeroCanibalesIzquierda + 1);

e.setPosicion(1);

es.add(e);

} else {

e.setNumeroCanibalesDerecha(numeroCanibalesDerecha - 1);

e.setNumeroCanibalesIzquierda(numeroCanibalesIzquierda + 1);

e.setPosicion(1);

es.add(e);

}

this.setEstados(es);

}

@Override

public String toString() {

StringBuilder s = new StringBuilder();

s.append("M: ");

s.append(numeroMisionerosIzquierda);

s.append("; C: ");

s.append(numeroCanibalesIzquierda);

s.append(" | M: ");

s.append(numeroMisionerosDerecha);

s.append("; C: ");

s.append(numeroCanibalesDerecha);

s.append(" | Posicion: ");

s.append(posicion);

return s.toString();

}

@Override

protected Estado clone() throws CloneNotSupportedException {

try {

return (Estado) super.clone();

} catch (Exception e) {

throw new CloneNotSupportedException();

}

}

@Override

public boolean equals(Object obj) {

if (obj == null) {

return false;

}

if (getClass() != obj.getClass()) {

return false;

}

final Estado other = (Estado) obj;

if (this.numeroMisionerosIzquierda !=

other.numeroMisionerosIzquierda) {

return false;

}

if (this.numeroCanibalesIzquierda !=

other.numeroCanibalesIzquierda) {

return false;

}

if (this.numeroMisionerosDerecha !=

other.numeroMisionerosDerecha) {

return false;

}

if (this.numeroCanibalesDerecha != other.numeroCanibalesDerecha)

{

return false;

}

if (this.posicion != other.posicion) {

return false;

}

return true;

}

/**

* @return the numeroMisionerosIzquierda

*/

public int getNumeroMisionerosIzquierda() {

return numeroMisionerosIzquierda;

}

/**

* @param numeroMisionerosIzquierda the numeroMisionerosIzquierda to

set

*/

public void setNumeroMisionerosIzquierda(int

numeroMisionerosIzquierda) {

this.numeroMisionerosIzquierda = numeroMisionerosIzquierda;

}

/**

* @return the numeroCanibalesIzquierda

*/

public int getNumeroCanibalesIzquierda() {

return numeroCanibalesIzquierda;

}

/**

* @param numeroCanibalesIzquierda the numeroCanibalesIzquierda to

set

*/

public void setNumeroCanibalesIzquierda(int numeroCanibalesIzquierda)

{

this.numeroCanibalesIzquierda = numeroCanibalesIzquierda;

}

/**

* @return the numeroMisionerosDerecha

*/

public int getNumeroMisionerosDerecha() {

return numeroMisionerosDerecha;

}

/**

* @param numeroMisionerosDerecha the numeroMisionerosDerecha to set

*/

public void setNumeroMisionerosDerecha(int numeroMisionerosDerecha) {

this.numeroMisionerosDerecha = numeroMisionerosDerecha;

}

/**

* @return the numeroCanibalesDerecha

*/

public int getNumeroCanibalesDerecha() {

return numeroCanibalesDerecha;

}

/**

* @param numeroCanibalesDerecha the numeroCanibalesDerecha to set

*/

public void setNumeroCanibalesDerecha(int numeroCanibalesDerecha) {

this.numeroCanibalesDerecha = numeroCanibalesDerecha;

}

/**

* @return the posicion

*/

public int getPosicion() {

return posicion;

}

/**

* @param posicion the posicion to set

*/

public void setPosicion(int posicion) {


}

/**

* @return the estados

*/

public List<Estado> getEstados() {

return estados;

}

/**

* @param estados the estados to set

*/

public void setEstados(List<Estado> estados) {

this.estados = estados;

}

}

técnicas de búsquedas informada

Documents

Transcript of técnicas de búsquedas informada