INTELIGENCIA EN REDES DE COMUNICACIONES
INMACULADA LUENGO LÓPEZ Mª ESTHER MARTÍN REBOLLO
IRC
Práctica final
ÍNDICE
Introducción_______________________________________________3 Objetivo de la práctica _____________________________________3 Desarrollo de la práctica____________________________________4 Resultados obtenidos ______________________________________7 Aprendizaje _______________________________________________9 Código del programa______________________________________11 Bibliografía_______________________________________________15
Página 2 de 15
IRC
Práctica final
Introducción En esta práctica hemos decidido implementar un programa en PROLOG para adivinar animales a partir de preguntas que se le van haciendo al usuario. La decisión de utilizar PROLOG para el desarrollo de esta práctica se debe a que es un lenguaje sencillo que proporciona una sintaxis para la construcción de sistemas expertos (en nuestro caso un sistema experto que identifique a los animales a partir de sus características). PROLOG es un lenguaje lógico declarativo que se basa en cláusulas de Horn. Sus principales características son que se trata de una programación dinámica, y tanto las reglas como los objetivos, son también datos; y la asunción de un mundo cerrado, todo lo que no figura explícitamente como un hecho y tampoco se puede deducir es falso. Otra característica es que el orden de las cláusulas cambia el resultado final. En esta práctica vamos a analizar el problema de un árbol de decisión con aprendizaje.
Objetivo de la práctica El fin de esta práctica ha sido desarrollar un programa en PROLOG que adivine el animal que ha pensado el usuario mediante el empleo de una serie de preguntas sobre las características del mismo a las que el jugador debe responder afirmativa o negativamente. Para ello, hemos definido un conjunto de reglas que debe verificar cada uno de los animales que el programa conoce y, a partir de estas reglas, se le formularán al usuario preguntas sobre las características que tiene el animal que ha pensado. También se ha contemplado la posibilidad de que el programa aprenda nuevos animales, que el usuario podría introducir cuando el programa no adivinase el animal que éste había pensado. Para ello se debe introducir, además de dicho animal, una pregunta que lo diferencie del animal que ha respondido erróneamente el programa.
Página 3 de 15
IRC
Práctica final
Desarrollo de la práctica Para la implementación del programa deseado, en primer lugar nos tendremos que plantear la estructura que va a tener nuestra lista de animales. Esta estructura será un árbol, en el que en las hojas se encontraran los distintos animales, y llegaremos a ellos por medios de las distintas características diferenciadoras que tiene cada uno. Siendo una de las principales características su clasificación en: reptiles, anfibios, mamíferos, aves y peces. Para realizar esta clasificación se tienen que tener en cuenta que las preguntas a realizar nos tienen que caracterizar una de las hojas frente a otra, y así poder llegar a la hoja deseada sin ningún tipo de ambigüedad. La lista de los animales que se han tenido en cuenta para el desarrollo de esta práctica es: rana, salamandra, serpiente, tortuga, cocodrilo, jirafa, conejo, hombre, oso, tigre, león, águila, pato, gallina, avestruz, pingüino, carpa y pez espada. En primer lugar, y para mostrar con mayor claridad el fundamento del programa, mostramos el árbol que vamos a desarrollar:
Página 4 de 15
IRC
Práctica final
Página 5 de 15
IRC
Práctica final
Comenzamos analizando el código desarrollado. En primer lugar, vamos a utilizar una función que se llamará sera(Animal), que determinará principalmente el orden en el que se deben ir comprobando los distintos animales (¿será una rana?...), de izquierda a derecha en la figura del árbol. Para cada uno de los animales se realizarán las preguntas sobre las características que debe cumplir, comenzando por el animal situado más a la izquierda del árbol y por la pregunta del nodo raíz. Se seguirán verificando las características para un mismo animal siempre que se responda afirmativamente a las preguntas y se pasará a comprobar las características del animal siguiente (el situado inmediatamente a la derecha del animal actual) cada vez que se responda negativamente a una de las preguntas. De esta forma, cuando lleguemos a una hoja del árbol el programa dará como solución un animal que cumpla todas las preguntas anteriormente realizadas. El animal que no cumpla ninguna de las características preguntadas será el que está en la hoja situada más a la derecha del árbol, que en nuestro caso es el pez espada, y no necesitará verificar ninguna condición, ya que simplemente es el que no cumple ninguna de las anteriores. Mediante estas reglas podremos realizar una primera clasificación de los animales en anfibios, reptiles, mamíferos, aves y peces. Las características que nos permiten clasificarlos dentro de estos grupos se harán aparte para que el código del programa sea más claro y más general. Ahora pasamos a comentar la función verificar(caracteristica) que ya hemos nombrado anteriormente. En esta función decimos que si se cumple la característica el resultado será true, y si no se cumple será fail, y pasamos a llamar a la función preguntar(caracteristica). En la función preguntar será donde realizaremos la pregunta sobre la característica determinada a verificar y en la que almacenaremos la respuesta. Según ésta sea afirmativa o negativa, avanzaremos hacia una u otra rama del árbol. Esto lo implementaremos con la ayuda de la función assert, que nos ayudara a ir almacenando las respuestas a las distintas características, para evitar repetir al usuario preguntas ya realizadas anteriormente, como las relacionadas con el tipo de animal (anfibio, reptil…), y así poder seguir avanzando en el árbol. Debido a la utilización de la función assert en este punto, necesitaremos que las funciones cumple y no_cumple, con las que la utilizamos sean dinámicas. Además tendremos que borrar los valores almacenamos, con la ayuda
Página 6 de 15
IRC
Práctica final
de la función retract, una vez que hayamos mostrado al usuario el animal adivinado, para lo que llamaremos a la función borrar en la parte principal del programa. Si olvidásemos realizar este borrado, en la siguiente ejecución comenzaríamos directamente dando como animal adivinado el obtenido en el caso anterior, sin haber realizado ninguna pregunta. Además una vez adivinado el animal, se nos ofrecerá la oportunidad de seguir jugando, en lugar de tener que volver a ejecutar el programa.
Resultados obtenidos Ahora vamos a probar el funcionamiento de nuestro programa. Vamos a pensar un animal de los que conoce, por ejemplo la jirafa. El programa nos irá haciendo preguntas recorriendo el árbol de la siguiente forma:
Página 7 de 15
IRC
Práctica final
Página 8 de 15
IRC
Práctica final
La captura del programa obtenida es la siguiente:
Podemos ver que el programa va haciendo las preguntas en el orden indicado en el árbol hasta adivinar que el animal que se había pensado era la jirafa.
Aprendizaje Nos hemos planteado también la posibilidad de que el programa pueda aprender nuevos animales. Para implementarlo, hemos empleado la función asserta que nos permite introducir nuevas reglas al principio de la base de datos. El programa sólo podrá aprender cuando no acierte el animal que había pensado el usuario. Por lo tanto, lo primero que tenemos que hacer una vez identificado el animal por el programa es preguntarle si hemos acertado dicho animal. De no ser así, tendremos que preguntarle al usuario cuál era el animal que había pensado y que nos indique una característica de éste que permita al programa diferenciarlo del animal que el había ofrecido como solución. Una vez conocidos el animal y una característica que lo distinga, lo añadimos mediante la función asserta. Esta nueva regla se tratará de igual forma que las definidas de forma explícita en el programa.
Página 9 de 15
IRC
Práctica final
Veamos un ejemplo de aprendizaje de nuestro programa. Para ello, hemos pensado en el mono, que no está incluido en la base de datos del programa. La captura del programa es la siguiente:
Ahora podemos comprobar que ha insertado mono en la base de datos:
Página 10 de 15
IRC
Práctica final
Y además, que puede identificar este animal del ofrecido anteriormente como solución:
En mayor inconveniente que tiene el método que hemos seguido es que ya no nos permite realizar las preguntas en el orden inicial, pero no es demasiado importante porque sigue adivinando correctamente los animales inicialmente introducidos.
Código del programa /* ADIVINO EL ANIMAL EN EL QUE ESTAS PENSANDO Para empezar el juego, teclea: " ?- start."
*/
/*Comienza el juego*/ /*Para implementar el juego partiremos de un árbol en el que tendremos todos los animales que podemos adivinar y las relaciones entre ellos*/ start :nl, write('PARA ADIVINAR EL ANIMAL EN EL QUE ESTAS PENSANDO, '), nl, write('RESPONDE A LAS SIGUIENTES PREGUNTAS'), nl, nl, sera(Animal), /*En primer lugar llamamos a la función hipótesis.
Página 11 de 15
IRC
Práctica final Con esta función empezaremos en el nodo raíz e iremos avanzando en el árbol */ /*Cuando lleguemos a una hoja del árbol, habremos encontrado la respuesta*/ nl, nl, write('****************************************'), nl, write('Creo que el animal es '), write(Animal), nl, write('****************************************'), nl, nl, /*Aprendizaje de nuestro programa*/ /*Comprobamos si hemos acertado el animal*/ write('¿He acertado? (s/n) '), read(Respuesta), nl, /*En el caso de no haber acertado, intentamos introducir una regla para su aprendizaje*/ ( (Respuesta == s) -> borrar, seguir_jugando ; write('¿Qué animal es? '), read(Respuesta1), nl, write('Dime una pregunta para '), write(Respuesta1), write(' que lo diferencie de '), write(Animal), write(': '), read(Respuesta2), nl, nl, asserta( (sera(Respuesta1) :- Animal, verificar(Respuesta2)) ) , borrar, seguir_jugando).
/* Hipótesis de animales que se van a comprobar */ sera(rana) :- rana, !. sera(salamandra) :- salamandra, !. sera(serpiente) :- serpiente, !. sera(tortuga) :- tortuga, !. sera(cocodrilo) :- cocodrilo, !. sera(jirafa) :- jirafa, !. sera(conejo) :- conejo, !. sera(hombre) :- hombre, !.
Página 12 de 15
IRC
Práctica final
sera(oso) :- oso, !. sera(tigre) :- tigre, !. sera(leon) :- leon, !. sera(aguila) :- aguila, !. sera(pato) :- pato, !. sera(gallina) :- gallina, !. sera(avestruz) :- avestruz, !. sera(pinguino) :- pinguino, !. sera(carpa) :- carpa, !. sera(pez_espada):- pez_espada.
/* Reglas con las que identificaremos los distintos animales */ /*Anfibios*/ rana :- sangre_fria, anfibio, verificar(salta). salamandra :- sangre_fria, anfibio. /*Reptiles*/ serpiente :- sangre_fria, verificar(se_arrastra). tortuga :- sangre_fria, verificar(tiene_caparazon). cocodrilo :- sangre_fria. /*Mamíferos*/ jirafa :- mamifero, herbivoro, verificar(tiene_cuello_largo). conejo :- mamifero, herbivoro. hombre :- mamifero, omnivoro, verificar(razona). oso :- mamifero, omnivoro. tigre :- mamifero, verificar(tiene_rayas). leon :- mamifero. /*Aves*/
Página 13 de 15
IRC
Práctica final
aguila :- ave, voladora, verificar(es_ave_rapaz). pato :- ave, voladora. gallina :- ave, verificar(es_domestico). avestruz :- ave, verificar(corre_veloz). pinguino :- ave. /*Peces*/ carpa :- verificar(vive_rio). pez_espada.
/* Reglas con las que clasificaremos los animales en: anfibios, reptiles, mamíferos, aves y peces */ /* Para ello utilizaremos la función verificar */ sangre_fria :- verificar(tiene_sangre_fria). anfibio :- verificar(vive_tierra_y_agua). mamifero :- verificar(tiene_pelo). herbivoro :- verificar(es_herbivoro). omnivoro :- verificar(es_omnivoro). ave :- verificar(tiene_alas). voladora :- verificar(vuela).
/* Función verificar, desde aquí llamaremos a la función que preguntara por cada característica */ verificar(S) :(cumple(S) -> true ; (no_cumple(S) -> fail ; preguntar(S))).
/* Para avanzar por el árbol, se irán realizando preguntas con las distintas características. Esto lo haremos con la función preguntar*/ preguntar(Pregunta) :write('¿Tiene el animal la siguiente característica: '), write(Pregunta), write('? (s/n) '),
Página 14 de 15
IRC
Práctica final read(Respuesta), nl, /*Avanzamos en función de la respuesta a la característica, hacia una rama u otra del árbol */ /*Con assert, guardamos el camino seguido */ ( (Respuesta == s) -> assert(cumple(Pregunta)) ; assert(no_cumple(Pregunta)), fail).
seguir_jugando :/*Ofrecemos la oportunidad de volver a jugar otra vez*/ write('¿Quieres seguir jugando? '), read(Respuesta3), ( (Respuesta3 == s) -> start ; nl, nl, write('ESPERO QUE HAYAS DISFRUTADO JUGANDO CONMIGO'), nl, nl, write('ADIOS'), nl).
/*Hace dinámicas las funciones que se van a añadir con assert*/ :- dynamic cumple/1,no_cumple/1,sera/1,verificar/1. /* Borramos todos los valores almacenados con assert que indican el camino seguido en el árbol */ borrar :- retract(cumple(_)),fail. borrar :- retract(no_cumple(_)),fail. borrar.
Bibliografía -
Prolog Francis Giannesini, Henry Kanoui y otros. Ed. Addison-Wesley Iberoamericana, 1989
-
Manual online de swi-prolog Jan Wielemaker
-
Principles of programming languages XXI Wael Aboelsaadat
Página 15 de 15
