UNIVERSIDAD NACIONAL DEL ALTIPLANO - PUNO

PRACTICA DIRIGIDA 11; ASIGNATURA: Taller de Inteligencia Artificial

ESCUELA PROFESIONAL: Ingeniería de Sistemas, Semestre Vacacional 2006

Apellidos/Nombres/Código:_________________________________________________________________

TEMA: Sistema Experto, Laberinto

En esta practicas se mostrara como ver si existe un camino de salida o no en un laberinto en base la deducción,
para esto la computadora lograra buscar si existe una salida o no de un laberinto en base a descarte, para esto se
utilizara la recursividad y otros conocimientos de Prolog.

PARTE 1: Entendiendo el Problema.

CASO: Dado un determinado laberinto por ejemplo
Inicio
---| |-----------
| 1| 2 3 4| 5 6|
| | | | --|
| 7| 8 9|10|11|12|
| -----| | | |
|13 14 15|16|17|18|
|--| | | | | |
|19|20|21 22|23|24|
| | |-----| | |
|25|26 27 28 29|30|
| |-----| |--| |
|31 32 33 34 35 36|
--| |------------
Final Respuesta: Si existe un camino para salida
Inicio
----| |------
| A B C D|
| | | |
| E| F G| H|
|---------| |
Final Respuesta: Si existe un camino para salida
Inicio
---| |---------
| 1| 2 3 4| 5|
| | | | |_
| 7| 8 9|10|11 Final
| -----| | |-
|13 14 15|16|17|
|--| | | | |
|19|20|21 22|23|
---------------
Respuesta: No existe un camino para salida
PARTE 2: Estructurando el conocimiento.
La idea es sencilla dado un laberinto hay que encontrar la salida si existe ó no, en base a la búsqueda de un
camino. Entonces lo primero es estructurar el conocimiento, lo lógico es utilizar una database para definir el
conocimiento que consiste en saber que numero esta unido con cual (conectado); Para esto y como ejemplo se
utilizará el siguiente baberito y debajo su estructuración de conocimiento:
Inicio
----| |------
| A B C D|
| | | | |
| E| F G H|
|---------| |
Final
Domains
esp = symbol
Database
conecta(esp,esp)
Clauses
conecta("Inicio","B"). conecta("B","A").
 conecta("A","E"). conecta("B","F").
conecta("B","C"). conecta("C","G").
conecta("C","D"). conecta("F","G").
conecta("D","H"). conecta("H","Final").
conecta("G","H").
Se debe notar que para cualquier cláusula solo se ubica una vez la relación y de la forma que mejor convenga, así
por ejemplo vendría a ser lo mismo escribir conecta("Inicio","B") que conecta("B","Inicio"), se debería poder
ubicar cualquiera con cualquiera de las dos formas; si se colocaran ambas se considerara repetido, en
consecuencia el sistema deberá controlarlo, lo mejor seria evitarlo.

PARTE 3: Proponiendo la solución primaria.

La primera idea a resolver son los caminos posibles, por ende por ejemplo si se ubica en B se podría ir a A, C,
Inicio y F; si se encuentra ubicado en A, se puede ir a B y E entonces se tiene que crear un primer predicado.
conectado_a(A,B):-conecta(A,B);conecta(B,A). %defina el predicado
Goal conectado_a("B",PuedeIr). Respuesta:_________________________________________
Goal conectado_a("A",PuedeIr). Respuesta:_________________________________________

Note que para ir a “B”, la variable a conocer es PuedeIr y muestra los posibles lugares a ir, y además el
predicado concetado_a llama a la estructura de conocimiento con dos variables de dos maneras conecta(A,B) ó
conecta(B,A) de manera que se evita repetir dos veces la definición de conecta (por ejemplo
conecta("Inicio","B") se colocara una vez y ya no conecta("B","Inicio")).
¿Qué dificultades tendría si en ves de colocar ó(;) coloca y (,) en el predicado conecta? Y que resultados muestra

Ahora es necesario definir la búsqueda para lo que se aplicara recursividad, primero se ha de definir predicados
de manejo que encuentre los siguientes elementos a buscar:
solucion(R):-camino("Inicio",R).
camino(ViejaPos,NuevasPos):-conectado_a(ViejaPos,NuevasPos),write("De: ",ViejaPos," a ",NuevasPos),nl.
Goal solucion(R).
Esto encuentra las alternativas que se tenga después de la Posición Inicial, en R se devuelven las posibles
soluciones. Muestre las Respuesta(s) encontradas

Que sucedería si en vez de “Inicio” se ubica “C”, muestre respuestas:

Notar que solo se devuelven las primeras soluciones por lo que es necesario buscar la siguientes entonces es
necesario encontrar los siguientes etapas del camino para esto es necesario utilizar la recursividad, entonces
reemplace el predicado camino de la siguiente forma:
camino(ViejaPos,NuevasPos):-conectado_a(ViejaPos,NuevasPos),write("De: ",ViejaPos," a ",NuevasPos),nl,
camino(NuevasPos,_).
¿Qué resultados tiene?, Explíquelo (Para parar la recursividad CTROL+Pausa+Pausa)

Si se ah dado cuenta se ah pasado de “Inicio” a “B” y con la recursividad de ”B” a “A” y al utilizar nuevamente
la recursividad “A” a “E”, luego “E” a “A” y nuevamente “A” a “E” y así recursivamente sin parar; ¿Que
sucede? Es que el camino escogido para el siguiente vuelve a ser el mismo y entra en un ciclo repetitivo; pero la
idea es no volver al mismo sitio si no a otro lugar y así al siguiente y al siguiente hasta terminar en final, para
esto cuando se busca conectado_a(ViejaPos,NuevasPos) las Nuevas Posiciones no deberían de ser las recorridas
anterioremente entonces ¿que hacer? La respuesta es eliminar las cláusulas de las bases de datos que estén
relacionadas al lugar pero las que nos llevaron a la posición en la que se está; entonces se propone los ejemplos:
Inicio
----| |------
| A B C D|
| | | | |
| E| F G H|
|---------| |
Final
Si "A" nos llevo a "E" con (conecta("A","E").) esta deberá ser eliminada, de manera que cuando “E”
busque el siguiente que debería de encontrar “A” (por conecta("A","E")), pero como de “A” se llevo a “E” y
esta fue eliminada (retract(conecta(“A”,”E”))) ya no exista ningún camino posible y se lleve al error final.
Si "Inicio" nos llevo a "B" con (conecta("Inicio","B").) esta deberá ser eliminada, de manera que cuando
“B” busque el siguiente que debería de encontrar “A”,”F”,”C” y “Inicio” (por conecta("B","A").
conecta("B","F"). conecta("B","C"). conecta("Inicio","B")), pero como de “Inicio” llevo a “B” y esta fue
eliminada (retract(conecta(“Inicio”,”B”))) ya no exista ningún camino posible y solo podrá existir 3 caminos no
cuatro a “A”, “F”, “C” y ya no “Inicio”.

Para lograr lo anterior Reemplace y cree lo siguiente:

elimina(A,B):-retract(conecta(A,B));retract(conecta(B,A)).
camino(ViejaPos,NuevasPos):-conectado_a(ViejaPos,NuevasPos),write("De: ",ViejaPos," a ",
NuevasPos), nl, elimina(ViejaPos,NuevasPos),camino(NuevasPos,_).
Note que elimina se coloca antes de la recursividad: camino(NuevasPos,_).
Con: Goal solucion(R). ¿qué produce?(Mostrar Resultado)

No Solution

Hasta este punto ya se puede identificar el camino y las alternativas no validas y como se llego al final
se supone que existe solución (puede asumirse el trabajo como terminado), pero como la parada a la recursividad
se produce por que ya no se encuentra ninguna opción de continuar en conectado_a(A,B):-
conecta(A,B);conecta(B,A). y esta devuelve falso por no encontrar ninguna cláusula conecta(...,...) valida, esto
conduce a que al final aparece: No Solution (por ser el resultado falso).
Otra dificultad es que se puede ver dos soluciones y solo se supone una y sobre todo se muestra No
Solution

PARTE 4: Mejorando la aplicación

Para evitar esos errores debemos crear una parada adecuada de la recursividad, para esto pude ubicar antes de la
definición de la definición del predicado camino:
camino(A,B):-conecta(AF,"Final"),AF=A,B="Final",write("Respuesta:Se llego al Final, si existe salida"),nl,!.
Habría que resaltar que sí ubica este predicado después de la definición recursiva de camino esta parada nunca
será consultada, cuando este predicado se ubica primero es la primera en revisarse y producirá la esperada
paradas de recursividad. Es necesario también mencionar que se utiliza conecta(AF,"Final"), lo que indica que si
se propone la cláusula conecta("Final",.....), no se encontrara la parada.
Con esas salvedades pruebe.
Goal solucion(R).

Goal solucion(_). % Propuesta que muestra la solución a priori unica

Comente las Diferencias

Ahora es necesario comentar algunas ideas:

Inicio
----| |------
| A B C D|
| | | | |
| E| F G H|
|---------| |
Final
Los cuatro caminos que existe para las salidas sin utilizar ciclos repetitivos son:
Inicio,B,F,G,C,D,H,Final
Inicio,B,C,D,H, Final
Inicio,B,C,G,H, Final
Inicio,B,F,G,H, Final
Porque al desarrollar Goal solucion(R). Solo da dos soluciones, comente

Entendiendo Nuevas Ideas:

Como se estuvo comentando conectado_a(A,B):-conecta(A,B);conecta(B,A)., conduce a falsedad esta se pude
mejorar de manera que no devuelva falso y además se indique donde se truncan los caminos cambiando el
predicado por:
conectado_a(A,B):-conecta(A,B);conecta(B,A);write("Fin de Camino:").
Explique lo que sucede con Goal solucion(R).:
TRABAJO APLICATIVO: PRACTICA NRO 11:

1. Presente en impreso o en un disquete el desarrollo de la practica 11.

2. Liste los programas que realizo en la practica Nro 11

3. Proponga el siguiente laberinto:

Inicio
---| |-----------
| 1| 2 3 4| 5 6|
| | | | --|
| 7| 8 9|10|11|12|
| -----| | | |
|13 14 15|16|17|18|
|--| | | | | |
|19|20|21 22|23|24|
| | |-----| | |
|25|26 27 28 29|30|
| |-----| |--| |
|31 32 33 34 35 36|
--| |------------
Final Respuesta: Si existe un camino para salida
conecta("Inicio","2").
conecta("2","3").
conecta("3","9").
conecta("3","4").
conecta("9","8").
conecta("4","10").
conecta("10","16").
conecta("16","22").
conecta("22","21").
conecta("21","15").
conecta("15","14").
conecta("14","13").
conecta("13","7").
conecta("7","1").
conecta("14","20").
conecta("20","26").
conecta("26","27").
conecta("27","28").
conecta("28","29").
conecta("29","23").
conecta("23","17").
conecta("17","11").
conecta("11","5").
conecta("5","6").
conecta("28","34").
conecta("34","35").
conecta("35","36").
conecta("36","30").
conecta("30","24").
conecta("24","18").
conecta("18","12").
conecta("34","33").
conecta("33","32").
conecta("32","31").
conecta("31","25").
conecta("25","19").
conecta("32","Final").
3.1. Muestre los resultado
3.2. Muestre el programa desarrollado

4. Proponga el siguiente laberinto:

 Inicio
---| |---------
| 1| 2 3 4| 5|
_| | | | |_
Inicio 7| 8 9|10|11 Final
-| -----| | |-
|13 14 15|16|17|
|--| | | | |
|19|20|21 22|23|
---------------

4.1. Muestre los resultado

4.2. Comente sus resultados
4.3. Muestre el programa desarrollado
REFERENCIA TEORICA: DE LA PRACTICA 11:

1. Sistemas Expertos
Un sistema experto es un programa de computadora que trata de emular la acción de un experto en un campo
dado. El programa trabaja en un dominio limitado (micro-cosmos). Ejemplos:

Medicina
Infección en sangre (Mycin)
Enfermedades pulmonares (Infermo)
Geología
Prospector. Encontró molibdeno con valor de 6 mdd.
Computadoras
R. Un sistema de Digital que propone sistemas de redes. Tiene 7000 reglas.
Reconocer fallas en equipos
Administración
HearSay. Reconocimiento de voz y escritura
Partes de un sistema experto
Interfaz con el usuario. Es la manera con la que se comunica con el usuario
Motor de inferencias (lógica)
Base de conocimientos
Un sistema experto debe explicar sus diagnósticos y conocimientos. También debe poder trazar su línea de
razonamiento (inferencias).
Antecedentes de sistemas expertos
Parry (paranóico) y Eliza (psicologo) Usaban palabras claves y preguntaban por palabras relacionadas.
SHRLOU (Escrito por Winograd y Weizenbaum en 1972) Entendía semántica y
sintáxis, es decir lenguaje natural. Realizaba acciones sobre su microcosmos: "Poner
un cubo sobre la esfera", "poner una pirámide bajo la mesa".
La simulación de la inteligencia es sencilla.
Motor de inferencias
Blackboard: "Módulos" expertos que se ayudan entre sí hasta conseguir la respuesta. HearSay no los
usa.
Reglas de producción: Backward chaining (encadenamiento hacia atrás) y Forward
chaining (encadenamiento hacia adelante). Siguen los If-Then es decir causas y
efectos.
Frames (Minsk.) Se topa con el problema de ramificación de información.
Información arquetípica. No se puede describir algo al 100%. No se usa ya que puede
dar información irrelevante.
Las formas de llegar al resultado:
Backward: Intenta llegar al resultado usando las preguntas como guía.
Forward: Intenta comprobar un resultado a base de preguntas.
Base de conocimientos
Información relevante para la solución de un problema. La debe de proporcionar un humano experto en la
materia. La diferencia entre un sistema experto y un humano radica en que a mayor datos un sistema experto
toma más tiempo para analizarlos todos, el humano necesita menos tiempo porque se concentra en los datos más
relevantes según su experiencia.
El sistema experto debe poder decir qué hizo y cómo lo hizo. Debe ser capaz de "recordar" los datos ya dados y
usarlos; ya sean estos atemporales (nombre) o temporales (temperatura).

2. VENTAJAS DE PROLOG
Prolog, y en general los lenguajes de programación lógica, tienen las siguientes ventajas frente a los
lenguajes clásicos (procedimentales):
Expresividad: un programa (base de conocimiento) escrito en prolog puede ser leído e interpretado
intuitivamente. Son, por tanto, más entendibles, manejables y fáciles de mantener.
Ejecución y búsqueda incorporada en el lenguaje: dada una descripción prolog válida de un
problema, automáticamente se obtiene cualquier conclusión válida.
Modularidad: cada predicado (procedimiento) puede ser ejecutado, validado y examinado
independiente e individualmente. Prolog no tiene variables globales, ni asignación. Cada relación está
autocontenida, lo que permite una mayor modularidad, portabilidad y reusabilidad de relaciones entre
programas.
Polimorfismo: se trata de un lenguaje de programación sin tipos, lo que permite un
alto nivel de abstracción e independencia de los datos (objetos).
Manejo dinámico y automático de memoria.

3. RECOPILACIÓN DE REFERENCIAS TEÓRICA :

1. Ayuda de Visual Prolog 5.0
2. Lógica de primer orden, lógica computacional y ampliación de lógica, trabajo con SWI Prolog, Internet.
3. Tutorial básico de programación en Prolog, Autor: Angel Fernández Pineda
4. Documentos de Internet diversos autores