Celestino

Inteligencia de redes y comunicaciones
Celestino
Eduardo García Ballestero
Julio F. Borreguero Ballesteros
CELESTINO
1. Introducción
¿Cuántas de las personas que conocemos tienen pareja?, ¿cuántas tienen dificultades
para encontrarla?.......ya no es problema, hemos implementado... “el Celestino”.
El Celestino es un sistema experto que mediante una serie de preguntas al usuario le
aconseja la mujer que mejor se le adecua en el catálogo. Lo siento chicas, pero el
catálogo no incluye a chicos.
El sistema será implementado utilizando los entornos de sistemas expertos de Jess.
2. Nuestro sistema experto.
2.1 Nuestro problema.
El Celestino es un sistema experto de ayuda a encontrar la pareja ideal. Mediante una
serie de preguntas para averiguar las preferencias del usuario podremos asesorarle sobre
cuál de las mujeres de las que dispone el catálogo se adapta mejor a sus gustos.
Para clasificar a las mujeres hemos preguntado por su altura (si son altas o no), por su
color de pelo, por su edad (al ser de mala educación preguntar por la edad de una mujer,
hemos preguntado por la decena por la que rondan), si están delgadas, y por algún dato
adicional que quieran incluir (elegantes, universitarias, tímidas, hippies,....).
Las mujeres disponibles en el catálogo son las siguientes:
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Elena: muy muy alta, morena, alrededor de 40 años.
Lola: alta, morena, alrededor de 40 años, tímida.
Patricia: alta, morena, alrededor de 40 años.
Sandra: alta, morena, alrededor de 30 años.
Susana: alta, morena, alrededor de 20 años.
Julia: alta, morena, alrededor de 18 años, universitaria.
Cristina: alta, morena, alrededor de 18 años.
Ana: alta, pelirroja, alrededor de 18 años.
Silvia: alta, rubia, alrededor de 30 años.
María: alta, rubia, alrededor de 20 años.
Adelaida: baja, delgadita, alrededor de 40 años.
Paloma: baja, delgadita, alrededor de 20 años.
Alicia: baja, gordita, elegante, alrededor de 40 años.
Flor: baja, gordita, hippie, alrededor de 40 años.
África: baja, gordita, hippie, alrededor de 30 años.
Lorena: baja, gordita, alrededor de 40 años.
Sonia: baja, gordita, alrededor de 30 años.
Como podemos comprobar, el catálogo es muy amplio, 17 mujeres.
2.2 Implementación del sistema Celestino.
El sistema experto Celestino se implementó buscando la sencillez. Constará únicamente
de funciones y reglas que nos permitán llegar a la elección más adecuada para el
usuario. Básicamente el sistema funciona mediante una serie de reglas por las que nos
iremos desplazando según los valores que obtengamos de las diferentes funciones.
Las reglas se podrían dividir en tres grandes grupos.:
•
Tipo: conjunto de reglas para determinar las cualidades de la mujer que más se
asemeja a las preferencias del consumidor.
•
Edad: es una única regla en la que se realizan una serie de preguntas para
determinar qué edad prefiere el usuario que tenga su pareja. Puede ser
excluyente si el tipo de mujer no admite variedad de edad. Por ejemplo, si el
usuario elige el tipo “Muy alta”, la única mujer del catálogo es Elena, y no podrá
elegir la edad que le gustaría que tuviese su pareja.
•
Elección: Una vez que sabemos las preferencias del usuario respecto a la mujer
que le gusta, mediante estas reglas le asignamos la mujer del catálogo que mejor
se ajusta. Primero comprobaremos si existe una mujer con esas características.
2.2.1 Las funciones que emplearemos.
•
Opciones
Es la encargada de preguntar al usuario sobre sus preferencias. Todas las
preguntas que hagamos al usuario sólo admiten como respuesta “sí” o “no” (“s”
o “n” por defecto), ya que el sistema experto es el encargado de guiarle sobre la
elección de la mujer.
•
Respuesta es si
Función booleana según sea la respuesta del usuario sobre una característica de
su mujer ideal.
•
Respuesta es 40,30,20,18
Conjunto de funciones booleanas según la preferencia de edad que el usuario
desea que tenga su mujer ideal.
2.2.2 Las reglas que emplearemos.
LOLA
s
¿Tímida?
n
s
PATRICIA
ELENA
s
SANDRA
s
¿Sobre los 40?
n
¿Muy muy alta?
¿Sobre los 30?
s
n
¿Sobre los 20?
¿Morena?
n
s
s
SUSANA
s
n
ANA
n
s
JULIA
¿Universitaria?
¿Pelirroja?
NO
s
n
¿Sobre los 40?
n
SILVIA
s
n
¿Sobre los 30?
¿Te gusta una chica alta?
n
CRISTINA
n
s
MARIA
¿Sobre los 20?
n
ADELAIDA
s
NO
s
¿Sobre los 40?
n
PALOMA
s
¿Sobre los 30?
n
s
¿Sobre los 20?
n
¿Delgadita?
s
s
n
NO
NO
s
¿Sobre los 30?
s
NO
ALICIA
¿Sobre los 40?
n
s
NO
n
¿Sobre los 20?
n
¿Elegante?
s
n
FLOR
s
¿Sobre los 40?
s
n
n
¿Hippie?
s
LORENA
¿Sobre los 40?
n
AFRICA
¿Sobre los 30?
n
n
NO
NO
s
¿Sobre los 20?
n
s
SONIA
n
¿Sobre los 20?
¿Sobre los 30?
NO
s
NO
n
NO
•
Inicio
Presentación de Celestino.
•
Preferencia base
Como puede verse en el árbol que acabamos de mostrar, la preferencia inicial
sobre la que se pregunta al usuario es sobre si le gustan las mujeres altas. Si le
gustan altas le preguntaremos si le gustan muy muy altas. En caso afirmativo,
como hemos explicado antes no hay más opción que Elena, y ya tendremos el
tipo asignado “Muyalta”.
•
Altura Alta
Sabemos ya que la preferencia inicial es que le gustan las mujeres altas, no muy
altas. Le preguntaremos ahora sobre el color de pelo. Y una vez escogido el
color de pelo preguntaremos sobre la edad que le gustaría que tuviese.
•
Altura Baja
Sabemos que no le gustan las mujeres altas. Le preguntaremos ahora sobre su
constitución física, acerca de si le gustan las mujeres delgaditas. En caso
afirmativo le preguntaremos sobre la edad deseada. En caso negativo
intentaremos averiguar sus preferencias sobre rasgos particulares que nos han
definido las aspirantes (elegancia, hippies,..).
•
Edad
Una vez que sabemos el tipo (estatura, color de pelo, complexión,..), se le
pregunta sobre la edad deseada en un bucle de preguntas desde los 40 años hasta
los 18.
•
Tipo-(40/30/20/18)-edad
Comprueba que la mujer ideal definida a base de elecciones de preferencias,
tiene la edad requerida en el catálogo de aspirantes.
•
Tipo-Morena-(40/30/20/18)
Según la edad de la aspirante puede preguntar sobre características especiales
para discernir entre dos aspirantes (tímida, universitaria).
•
Tipo Muyalta
La única mujer disponible en el catálogo que reúna la característica de ser muy
alta, es Elena.
•
Tipo-Rubia-(30/20)
Cuando el usuario ha elegido que no le gustan las morenas ni las pelirrojas, por
defecto ya sabemos que le gustan las rubias. Hay definidas reglas para cada edad
especificada.
•
Tipo-Delgadas-(40/20)
Cuando ya sabemos que no le gustan las mujeres altas, se le preguntó sobre si le
gustaban delgadas. En caso afirmativo tenemos las mujeres que pertenecen a
este tipo.
•
Tipo-Hippie-(40/30)
Ya sabemos que no le gustan altas, ni delgaditas, ni elegantes, por lo que le
preguntaremos si le gustan hippies. Según la edad deseada se elegirá entre las
dos aspirantes disponibles.
•
Tipo-Pelirroja
La única aspirante disponible es Ana.
•
Tipo-Normal-(40/30)
Ya sabemos que no le gustan altas, ni delgaditas, ni elegantes, ni hippies, por lo
que concluiremos que le gustan las mujeres normales. En función de la edad
deseada le asignaremos a una de las dos aspirantes disponibles en esta categoría.
•
Tipo-Elegante
La única aspirante que se define como elegante es Alicia.
•
No-existe
En caso de que no exista ninguna mujer que se adapte a sus deseos.
•
Mostrar-tipo
Muestra por pantalla el nombre de la mujer que el sistema experto le
recomienda.
•
Final
Mensaje de despedida del sistema experto en el que se ruega que se nos invite a
la boda, de gorra por supuesto.
3. Simulaciones.
Vamos a proponer varias ejecuciones del Celestino para tratar de explicar mejor su
funcionamiento. Le cuestionaremos sobre unas determinadas preferencias para que nos
aconseje la mujer del catálogo que mejor se adapta a nuestra idea de pareja ideal.
3.1 Primer caso.
Al comenzar nuestro programa, lo primero que intentamos es averiguar la altura de
mujer ideal; para ello preguntamos primero que si nos gustan las chicas altas, en caso de
decir que si, nos vuelve a preguntar que si nos gustan muy altas. En caso de decir que
no, ya conocemos grosso modo la altura de la mujer a buscar, con lo que pasamos a otro
tipo de preguntas para averiguar el color del pelo.
Preguntamos ahora que si le gustan morenas, en caso afirmativo, preguntamos sobre la
edad, comenzando por los 40 años, y si obtenemos de nuevo una repuesta afirmativa,
preguntamos si le gustan tímidas. Si la respuesta es si, mostramos como elección final a
Lola.
Mostramos en la siguiente ilustración el proceso exacto de preguntas que seguiría
nuestro programa:
3.2 Segundo Caso.
Análogamente al ejemplo anterior, y en función de las respuestas que vayamos dando,
los resultados son diferentes. Si ahora nos gustan las chicas altas, rubias y de unos 30
años, la elección que hace nuestro programa es Silvia.
El proceso exacto de preguntas y respuestas se observa en la siguiente ilustración:
3.3 Tercer Caso.
Si preferimos las chicas bajas, delgadas y de unos 20 años, la nuestra elección es
Paloma, tal y como podemos apreciar en la siguiente ilustración:
3.4 Cuarto caso.
Como última simulación, mostramos la elección realizada cuando preferimos una chica
hippie de unos 30 años. Como siempre, mostramos una ilustración con el proceso de
preguntas realizado para llegar a la elección final.
4. Nuestro código fuente.
;;;======================================================
;;;
Sistema experto de Jess
;;;
(Java Expert System Shell)
;;;
;;;
CELESTINO:
;;;
encuentra tu pareja ideal
;;;======================================================
;;* Definimos las funciones necesarias *
;;*****************************************
(deffunction opciones (?opcion)
(printout t ?opcion)
(bind ?respuesta (read))
(if (lexemep ?respuesta)
then (bind ?respuesta (lowcase ?respuesta))
)
?respuesta
)
(do-backward-chaining opciones)
(deffunction respuesta-es-si (?opcion)
(bind ?respuesta (opciones ?opcion))
(if (eq ?respuesta "s")
then
TRUE
else
FALSE
)
)
(do-backward-chaining respuesta-es-si)
(deffunction respuesta-es-40 (?opcion)
(bind ?respuesta (opciones ?opcion))
(if (eq ?respuesta "40")
then
TRUE
else
FALSE
)
)
(do-backward-chaining respuesta-es-40)
(deffunction respuesta-es-30 (?opcion)
(bind ?respuesta (opciones ?opcion))
(if (eq ?respuesta "30")
then
TRUE
else
FALSE
)
)
(do-backward-chaining respuesta-es-30)
(deffunction respuesta-es-20 (?opcion)
(bind ?respuesta (opciones ?opcion))
(if (eq ?respuesta "20")
then
TRUE
else
FALSE
)
)
(do-backward-chaining respuesta-es-20)
(deffunction respuesta-es-18 (?opcion)
(bind ?respuesta (opciones ?opcion))
(if (eq ?respuesta "18")
then
TRUE
else
FALSE
)
)
(do-backward-chaining respuesta-es-18)
;;;* Reglas para realizar la selección
;;;***********************************
(defrule inicio ""
(declare (salience 10))
=>
(printout t crlf crlf)
(printout t "****** Encuentra tu pareja ideal
(printout t crlf crlf)
(printout t crlf)
)
(do-backward-chaining inicio)
*********")
(defrule preferencia-base ""
(not (tipo ?))
=>
(if (respuesta-es-si " te gusta una chica alta (si/no)? ")
then
(if (respuesta-es-si " muy, muy alta (si/no)? ")
then (assert (tipo Muyalta))
(assert (edad 40))
(assert (existe si))
else (assert (altura alta))
)
else
(assert (altura baja))
)
)
(do-backward-chaining preferencia-base)
(defrule altura-alta ""
(declare (salience 10))
(altura alta)
=>
(if (respuesta-es-si " morena (si/no)? ")
then
(assert (tipo Morena))
else
(if (respuesta-es-si " pelirroja (si/no)? ")
then (assert (tipo Pelirroja))
(assert (edad 18))
else (assert (tipo Rubia))
)
)
)
(do-backward-chaining altura-alta)
(defrule altura-baja ""
(declare (salience 10))
(altura baja)
=>
(if (respuesta-es-si " te gusta delgadita (si/no)? ")
then
(assert (tipo Delgada))
else
(if (respuesta-es-si " elegante (si/no)? ")
then
(assert (tipo Elegante))
else
(if (respuesta-es-si " Hippie (si/no)? ")
then (assert (tipo Hippie))
else
(assert (tipo Normal))
)
)
)
)
(do-backward-chaining altura-baja)
;; Regla para determinar la edad de tu pareja.
(defrule numero-edad ""
(declare (salience 10))
(tipo ?)
(not (edad ?))
=>
(if (respuesta-es-si " alrededor de los 40? ")
then
(assert (edad 40))
else
(if (respuesta-es-si " alrededor de 30? ")
then
(assert (edad 30))
else
(if (respuesta-es-si " alrededor de 20? ")
then
(assert (edad 20))
else
(assert (edad 18))
)
)
)
)
;; comprobamos que existe la aspirante segun la edad elegida.
(defrule tipo-18-edad ""
(declare (salience 10))
(or (tipo Morena) (tipo Pelirroja))
(edad 18 )
=>
(assert (existe si))
)
(do-backward-chaining tipo-18-edad)
(defrule tipo-20-edad ""
(declare (salience 10))
(or (tipo Morena) (tipo Rubia) (tipo Delgada))
(edad 20)
=>
(assert (existe si))
)
(do-backward-chaining tipo-20-edad)
(defrule tipo-30-edad ""
(declare (salience 10))
(or (tipo Morena) (tipo Rubia) (tipo Hippie) (tipo Normal))
(edad 30)
=>
(assert (existe si))
)
(do-backward-chaining tipo-30-edad)
(defrule tipo-40-edad ""
(declare (salience 10))
(or (tipo Morena) (tipo Delgada) (tipo Hippie) (tipo Normal) (tipo
Elegante)) (edad 40)
=>
(assert (existe si))
)
(do-backward-chaining tipo-40-edad)
;; Reglas para asignar a la chica según preferencias
(defrule tipo-Morena-18 ""
(declare (salience 10))
(tipo Morena)
(edad 18)
=>
(if (respuesta-es-si " universitaria (si/no)? ")
then
(assert (eleccion Julia))
else
(assert (eleccion Cristina))
)
)
(do-backward-chaining tipo-Morena-18)
(defrule tipo-Morena-20 ""
(declare (salience 10))
(tipo Morena)
(edad 20)
=>
(assert (eleccion Susana))
)
(do-backward-chaining tipo-Morena-20)
(defrule tipo-Morena-30 ""
(declare (salience 10))
(tipo Morena)
(edad 30)
=>
(assert (eleccion Sandra))
)
(do-backward-chaining tipo-Morena-30)
(defrule tipo-Morena-40 ""
(declare (salience 10))
(tipo Morena)
(edad 40)
=>
(if (respuesta-es-si " timida (si/no)? ")
then
(assert (eleccion Lola))
else
(assert (eleccion Patricia))
)
)
(do-backward-chaining tipo-Morena-40)
(defrule tipo-Muyalta-40 ""
(declare (salience 10))
(tipo Muyalta)
(edad 40)
=>
(assert (eleccion Elena))
)
(do-backward-chaining tipo-Muyalta-40)
(defrule tipo-Rubia-20 ""
(declare (salience 10))
(tipo Rubia)
(edad 20)
=>
(assert (eleccion Maria))
)
(do-backward-chaining tipo-Rubia-20)
(defrule tipo-Rubia-30 ""
(declare (salience 10))
(tipo Rubia)
(edad 30)
=>
(assert (eleccion Silvia))
)
(do-backward-chaining tipo-Rubia-30)
(defrule tipo-Delgada-20 ""
(declare (salience 10))
(tipo Delgada)
(edad 20)
=>
(assert (eleccion Paloma))
)
(do-backward-chaining tipo-Delgada-20)
(defrule tipo-Delgada-40 ""
(declare (salience 10))
(tipo Delgada)
(edad 40)
=>
(assert (eleccion Adelaida))
)
(do-backward-chaining tipo-Delgada-40)
(defrule tipo-Hippie-30 ""
(declare (salience 10))
(tipo Hippie)
(edad 30)
=>
(assert (eleccion Africa))
)
(do-backward-chaining tipo-Hippie-30)
(defrule tipo-Hippie-40 ""
(declare (salience 10))
(tipo Hippie)
(edad 40)
=>
(assert (eleccion Flor))
)
(do-backward-chaining tipo-Hippie-40)
(defrule tipo-Pelirroja ""
(declare (salience 10))
(tipo Pelirroja)
(edad 18)
=>
(assert (eleccion Ana))
)
(do-backward-chaining tipo-Pelirroja)
(defrule tipo-Normal-30 ""
(declare (salience 10))
(tipo Normal)
(edad 30)
=>
(assert (eleccion Sonia))
)
(do-backward-chaining tipo-Normal-30)
(defrule tipo-Normal-40 ""
(declare (salience 10))
(tipo Normal)
(edad 40)
=>
(assert (eleccion Lorena))
)
(do-backward-chaining tipo-Normal-40)
(defrule tipo-Elegante ""
(declare (salience 10))
(tipo Elegante)
(edad 40)
=>
(assert (eleccion Alicia))
)
(do-backward-chaining tipo-Elegante)
;; No hay pareja, lo sentimos
(defrule no-existe ""
(not (existe ?))
=>
(printout t crlf crlf)
(printout t " No hay ninguna chica que se adapte a tus preferencias")
(printout t crlf crlf)
)
(do-backward-chaining no-existe)
;; Regla para mostrar la chica sugerida por pantalla
(defrule mostrar-tipo ""
(eleccion ?final)
(existe ?)
=>
(printout t crlf crlf)
(printout t " Nuestra eleccion: ")
(printout t ?final crlf)
)
(do-backward-chaining mostrar-tipo)
;; Regla para despedir la aplicación
(defrule final " "
(declare (salience -20))
=>
(printout t crlf crlf)
(printout t crlf )
(printout t "****** INVITANOS A LA BODA !!!!
(printout t crlf )
(printout t crlf )
)
(do-backward-chaining final)
(reset)
(run)
*********" crlf)