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