KAPPA

Tcnicas de Inteligencia Artificial
Escuela Tcnica Superior de INGENIERA INFORMTICA
PRCTICA 1
Diseo, Implementacin y Evaluacin de
un Sistema Basado en el Conocimiento
Departamento de Sistemas Informticos y Computacin- UPV
1.- Introduccin. ................................................................................................................................ 1

1.1.- KAPPA-PC. Aspectos Generales............................................................................................ 1
1.2.- Inicio de KAPPA-PC: Ventanas de la aplicacin ................................................................... 2
2. Creacin de Clases, Subclases e Instancias. Slots....................................................................... 3
2.1.- Creacin de clases................................................................................................................... 3
2.2.- Creacin de instancias............................................................................................................. 3
2.3.- Creacin de slots. .................................................................................................................... 4
2.5.- Propiedades de los slots: Facetas ............................................................................................ 5
2.6.- Herencia. ................................................................................................................................. 8
2.7.- Mtodos y Monitores. ............................................................................................................. 9
2.7.1.- Mtodos y Mensajes. Programacin Orientada a Objetos. .............................................. 9
2.7.2.- Monitores. ...................................................................................................................... 11
3.- KAL: KAPPA-PC Application Language. .............................................................................. 13
3.1.- Sintxis KAL ........................................................................................................................ 13
3.2.- Funciones. ............................................................................................................................. 16
Entrega-1: objetos, mtodos. .......................................................................................................... 18
4.- Creacin de Reglas..................................................................................................................... 19
Editor de reglas.............................................................................................................................. 19
5.- Razonamiento en KAPPA PC ................................................................................................... 21
5.1.- Razonamiento hacia delante (Forward chaining): ................................................................ 21
5.2.- Razonamiento hacia atrs (Backward chaining) ................................................................... 23
5.3.- Traza y depuracin del proceso inferencial. ......................................................................... 25
5.4.- Control Forward: Agenda y Rule Mode................................................................................ 28
Entrega-2: reglas, inferencia. ......................................................................................................... 30
6.- Interfaz de usuario en KAPPA-PC: Session............................................................................ 31
6.1.- Ventana de Sesin................................................................................................................. 31
6.2.- Funciones de Interface. ......................................................................................................... 34
Entrega-3: Interfaz.......................................................................................................................... 35
1.- Introduccin.
El objetivo de esta prctica es aplicar las tcnicas y metodologas de la Ingeniera del Conocimiento en el
diseo y construccin de un prototipo de Sistema Basados en el Conocimiento (Sistema Experto), para
aplicar los conocimientos sobre representacin del conocimiento, razonamiento basado en reglas,
inferencia y control. Adicionalmente, esta prctica permitir conocer un entorno de desarrollo de Sistemas
Basados en el Conocimiento (KAPPA-PC).
Las etapas de la prctica son:
1.- Conocimiento del entorno de desarrollo de Sistemas Basados en el Conocimiento (KAPPA).
a) Representacin conocimiento: frames, herencia, mtodos, monitores y objetos. Lenguaje
KAL.
b) Reglas en kappa-pc
c) Inferencia: Razonamiento hacia delante, hacia atrs. Control Inferencial.
d) Interfaz grfica de usuario
2.- Diseo, Implementacin y evaluacin de un Sistema Basado en el Conocimiento (SBC)
En este documento, se describen las principales funcionalidades de KAPPA-PC que sern desarrolladas en
sucesivas sesiones de prcticas. El objetivo de estas sesiones es familiarizarse con las diversas
funcionalidades del entorno de desarrollo y poder desarrollar un prototipo de SBC sobre dicho entorno (que
constituye la evaluacin principal de la prctica).
Adems de la informacin contenida en este documento, se recomienda acceder a la ayuda interna contenida
en el propio entorno KAPPA-PC.
Para cualquier consulta adicional sobre una caracterstica concreta
de KAPPA existe un manual "on-line" en la misma carpeta
Esta ayuda se puede activar pulsando la opcin HELP que aparece a
la derecha de la ventana principal de KAPPA.
1.1.- KAPPA-PC. Aspectos Generales.

KAPPA-PC es una herramienta para el desarrollo de Sistemas Expertos creada por INTELLICORP y es un
entorno liberado (de dominio pblico) que ha sido utilizado con xito en distintos tipos de aplicaciones.
KAPPA-PC est desarrollado en C y se ejecuta bajo WINDOWS (16-32 bits), o bajo emulacin de Windows
en linux, y sus principales caractersticas y componentes son:
Objetos
Reglas
KAPPA-PC
Grficos
Leng. Aplicacin: KAL

Interfaz
Desarrollo
Explicacin
Interfaz
Usuario
Librera
Funciones
Help
Tcnicas de Inteligencia Artificial. Prctica 1: Diseo, implementacin y evaluacin de un SBC - 1
1. Desarrollo orientado a objetos: los componentes de la aplicacin se representan como objetos.

Los procesos de la aplicacin se representan mediante mtodos y monitores.
2. El lenguaje de KAPPA-PC se llama KAL y permite trabajar a un alto nivel de abstraccin.
3. Sistemas de representacin del conocimiento basado en reglas.
4. Posibilidad de hacer inferencias hacia delante y hacia atrs. Mecanismos de control.
5. Entorno grfico, con facilidades de edicin.
6. Herramientas de depuracin y traza. Acceso y actualizacin de datos externos.
1.2.- Inicio de KAPPA-PC: Ventanas de la aplicacin

a) Inicio desde emulacin de Windows en linux:
1. Abrir sesin en Linux (en la primera sesin, la contrasea es el DNI (sin letra). Los extranjeros tienen un cdigo
identificativo que si lleva letra del estilo X5567322. La primera vez que inicien sesin el sistema pide el cambio de la
contrasea y se reinicia la sesin del usuario con la nueva contrasea.)
2. Abrir Terminal (Aplicaciones/Herramientas/Terminal, o botn derecho abrir terminal))

3. Lanzar KAPPA: > kappa
b)
Inicio desde Windows (16-32 bits)

KAPPA se lanza desde el programa instalado en men de inicio de Windows.
Tambin se puede lanzar Kappa desde el entorno MS-DOS > c:\kappa\kappa
Notas importantes:
Limitar nombres en ficheros e indentificativos a 8 caracteres.

Las teclas abreviadas para cortar y pegar no son ctr-C ni ctrl-V. Su reiteracin
causar errores de teclado.
Kappa es sensible a maysculas y minsculas
Cuando se abre la aplicacin KAPPA-PC aparecen tres ventanas:

- Main KAPPA Window
- Object Browser
- EditTools window.
Todas las ventanas siguen los standards de Windows para abrir, cerrar, generar tamao mximo, etc.
Main KAPPA Window muestra los iconos de las otras 7 herramientas existentes:
Object Browser: Para crear, mostrar y modificar objetos (frames).
Session: Para crear, mostrar y modificar la interface con el usuario.
Edit Tools: Editores para clases, instancias, funciones reglas y objetivos.
KAL Interpreter: Para introducir expresiones en lenguaje KAL (modo programado).
KAL View Debugger: Depuracin de cdigo KAL.
Find/ Replace: Busca y reemplaza cadenas de texto en la aplicacin.
Rule Relations, Rule Trace, Inference Brower: Herramientas para depurar, relacionar y
realizar trazas en las reglas y encadenamiento inferencial.
KAPPA permite trabajar en dos posibles modos:
modo interactivo, a travs de la interface de mens y ratn,
modo programado, introduciendo los datos en el intrprete KAL.
Dado que el modo interactivo es ms rpido para estudiar los distintos tpicos de KAPPA-PC, seguiremos
este mtodo a partir de ahora.
2. Creacin de Clases, Subclases e Instancias. Slots.

En KAPPA, los objetos se definen como clases o instancias. Las clases siempre representan objetos ms
generales, un grupo o coleccin de objetos. Una instancia es un objeto especfico.
Supongamos que queremos representar informacin sobre vehculos y queremos asignarlos a una de las
dos categoras: Coches o Motos. Tambin queremos representar informacin sobre personas.
Crearemos una clase "Vehiculos" con dos subclases "Coches" y "Motos", y una clase Personas.
Adems, tenemos informacin de 2 coches (Coche1 y Coche2) y una moto (Moto1), y Pepe, por lo que
crearemos las instancias correspondientes en cada una de las subclases:
2.1.- Creacin de clases.

1. En la ventana Object Browser, ponerse sobre Root y activar "Add Subclass" desde la opcin "Edit"
del men.
2. Introducir "Vehiculos" como nombre de la clase.
3. Situarse sobre la clase "Vehiculos" y repetir la operacin anterior para crear las subclases "Coches"
y "Motos". Cread tambin la clase Personas.
4. Para salvar la nueva configuracin, escoger la opcin "Save as ..." de la opcin File del men de la
ventana principal de KAPPA. Esta opcin puede realizarse en cualquier momento a lo largo del
desarrollo del ejemplo.
En la ventana Object Browser veremos la nueva jerarqua de clases con el resultado de las modificaciones
que hemos realizado.
NOTA IMPORTANTE: KAPPA es case-sensitive, es decir hay que tener mucho cuidado con las
maysculas y minsculas a la hora de escribir los nombres de las funciones, slots, clases y valores. Los
identificadores deben limitarse a 8 caracteres.
2.2.- Creacin de instancias.

Crearemos 2 instancias de la clase "Coches" y una instancia de la clase Motos. Tambin creamos la
instancia Pepe.
1. En la ventana Object Browser, situarse sobre la clase "Coches" y seleccionar "Add instance"
desde la opcin "Edit" del men.
2. Teclear el identificador de la instancia (Ej. Coche1).
3. Repetir los pasos anteriores para el resto de las instancias.
En la ventana Object Browser veremos el resultado obtenido (las relaciones 'instancias' se representan con
una lnea discontinua:
Nota: Los nombres de las clases e instancias son nicos en toda la jerarqua y no pueden
repetirse. Es habitual indicar el nombre de las instancias en singular y las clases en plural.
2.3.- Creacin de slots.

Los slots se utilizan para describir caractersticas especficas de los objetos. En general, se definen en las
clases y toman valor en las clases (se heredaran a todas las instancias) o en la instancias.
Supongamos que las propiedades que definen a los Vehiculos son la 'matrcula', 'propietario', 'modelo, tipo
y color. Particularmente, para los Coches nos interesa saber adems el 'nmero de puertas'. Para las
Personas conoceremos su nombre, apellidos, direccin y edad.
Coche1
Coches
Vehiculos
matricula
propietario
modelo
tipo
color
* matricula
* propietario
* modelo
* tipo
* color
num_puertas
Coche2
Moto1
Motos
* matricula
* propietario
* modelo
* tipo
* color
Personas
Pepe
nombre
apellidos
direccion
edad
Para ver y editar los slots de un objeto hay que activar el "Editor de Clases / Instancias" (existen dos
formas de hacerlo):
1.- Abrir el editor de clases. Hay dos formas de hacerlo:
a) En la ventana Object Browser, situarse sobre la clase "Vehiculos" y seleccionar "Edit"
desde la opcin "Edit" del men.
b) Situarse sobre la clase "Vehiculos" y pulsar dos veces sobre la clase activada.
2.- Seleccionar "Slots" desde el men y luego la opcin "New" desde el men de "Slots".
3.- Teclear el nombre del slot a introducir. Salvar los cambios.
Con ello, creamos los slots correspondientes en la clase Vehiculo y los slots de la clase Personas.
Tambin debemos crear el slot 'nmero de puertas' en la clase Coches.
Al crear los slots en la clase Vehiculos, podemos comprobar que se han heredado automticamente a las
subclases e instancias inferiores en la jerarqua. Los asteriscos (*) que aparecen al lado del nombre del slot
significan que dichos slots se han heredado de la jerarqua establecida (Herencia).
2.5.- Propiedades de los slots: Facetas

En este apartado veremos como caracterizar los slots y como manejar el modo en el que los valores de los
slots son heredados.
Los slots se describen en trminos de facetas. Las facetas de los slots se pueden ver y modificar desde el
Editor de Slots. Existen dos formas de abrir el editor de slots:
a) Seleccionar "Slots" desde el men y luego "Edit" desde dicho men.
b) Situarse sobre el slot deseado y pulsar dos veces sobre el slot activado.
Las facetas de los slots son (en kappa):
Valor: Valor del slot. Cuando un slot no tiene valor, KAPPA le asigna el valor NULL.
Cardinality: Los slots pueden contener uno o ms de un valor. Los posibles valores para esta
opcin de slot son:
-
Single: el slot slo puede tener un valor. Es la opcin por defecto.

Multiple: el slot puede tener varios valores. Los valores se indican uno tras otro en la
interfaz, o mediante AppendToList (Instancia:Slot, v1, v2, );
Value Type: Especifica el tipo de valores del slot. Los tipos de valores que puede tomar un slot son:
- Text: cadena de caracteres, por defecto.
- Number: nmero entero o en coma flotante.
- Boolean: TRUE o FALSE.
- Object: nombre de una clase o instancia.
Allowable Values: Especifica los posibles valores de los slots. Por ejemplo:
Tipo Text: cualquier lista de cadenas de caracteres. Ejemplo: rojo amarillo verde
Si quiero considerar una cadena con espacios en blanco como una nica cadena, hay que
ponerla entre " ". Ejemplo: "rojo amarillo verde"
Tipo Number: Cuando el tipo del slot es numrico se puede especificar un rango para los
valores que puede tomar el slot, delimitando el valor mnimo y mximo.
Tipo Boolean: los lmites en los valores son los propios valores TRUE, FALSE.
Tipo Object: cualquier lista de nombres de CLASES. El valor del slot debe ser el nombre de
un descendiente de una de las clases que aparece en dicha lista.
Slot Inheritance: Full / No Inheritance. Indica si el slot se hereda o no a los objetos inferiores en la
jerarqua. Por efecto es Full.
Monitores:
Valores activos asociados al slot (If Needed, When Accessed, Before Change, After
Change). Se ver en el punto correspondiente a los monitores.
Editor de slots de KAPPA

Para el ejemplo que estamos siguiendo, estableced la siguiente caracterizacin de los slots:
Slot
matrcula
TEXT
Value Type
modelo
numpuertas
color
propietario
edad
tipo
TEXT
NUMBER
TEXT
OBJECT
NUMBER
TEXT
Allowable Values Range

(se podra especificar un conjunto de matrculas)
Min Value: 2
Max Value: 5
(se podra especificar un conjunto de colores)
Personas
Nota: La especificacin de los slots como tipo OBJECT permite crear una "Red de Objetos":
El slot 'propietario' es de tipo OBJECT. Eso significa que el valor del mismo ser una instancia (o
simplemente un descendiente) de una clase (Personas) que se ha especificado en el campo
Allowable Values.
Los slots de la clase Personas son todo de tipo TEXT, excepto edad de tipo Number.
RESTRICCIONES SOBRE LA CLASE DE VALORES
Las restricciones sobre la clase de valores en Kappa no tienen efecto automtico y no se aplican al
desarrollador del sistema, pero en cambio s se aplican al usuario del mismo.
El desarrollador del sistema puede introducir valores:
a) En la edicin, por la interfaz interactiva de desarrollo: NO se limita el valor del slot y no se produce
ningn mensaje de aviso.
b) En la asignacin de valores mediante expresiones KAL (utilizadas habitualmente aplicacin de
reglas en el proceso inferencial) se puede limitar mediante un monitor (Ver: Monitor tipo Before
Change).
En la introduccin de valores en la interfaz grfica del usuario S se puede limitar a la clase de valores
especificada, utilizando por ejemplo:
a) PostInputForm, que indicar solo los valores posibles de la clase de valores del slot,
b) Imgenes activas de tipo slider, por ejemplo, en las que se puede delimitar los valores a introducir
por el usuario.
Valores de Slots
Los valores de los slots se pueden introducir desde el Editor de Slots:
1.- Desde el Editor de clases/instancias, abrir el editor de slots. Existen dos formas de hacerlo:
a) Seleccionar "Slots" desde el men y luego "Edit" desde dicho men.
b) Situarse sobre el slot deseado y pulsar dos veces sobre el slot activado.
2.- Introducir el valor y tipo del slot.
3.- Selecciona "Update" desde el editor de clases y luego la opcin "Close" desde dicho men.
Guardar los cambios.
De esta forma, introducimos los valores de slots indicados en la figura:

Personas
Pepe
* nombre Jose
* apellidos Fernandez Bou
* direccion Calle .....
* edad
27
nombre
apellidos
direccion
edad
Coche1
Coches
Vehiculos
matricula
propietario
modelo
tipo locomocin
color
* matricula
* propietario
* modelo
* tipo *locomocin
* color
numpuertas
Motos
Coche2
* matricula
V-5544-CL
* propietario
Pepe
* modelo
SEAT
* tipo
* locomocion
* color
rojo
* numpuertas 3
Moto1
* matricula
* propietario
* modelo
* tipo *locomocin
* color
Estructura jerrquica y valores de los objetos

Notas:
Cuando de introduce un valor en el slot de una clase, puede comprobarse que todas las
instancias de la clase heredan dicho valor para el slot ( el cual aparece con *).
El valor Pepe del slot propietario permite crear una red de objetos, donde el valor de un slot
representa otro objeto. De esta forma, mediante la expresin KAL:
Coche2:propietario: edad;
podemos obtener la edad del propietario del Coche1.
Introduccin Interactiva de Valores

Como hemos visto, la introduccin de valores de slots puede hacerse editando el slot. Tambin se pueden
poner valores mediante expresiones KAL:
Pepe:edad= 25;
Sin embargo, estas dos formas no son las habituales en el uso del sistema. Lo normal es que (salvo slots
con valores iniciales) sea el usuario del sistema el que introduzca los valores de los slots. Para ello, hay dos
formas bsicas:
Expresiones PostInputForm. Por ejemplo:
PostInputForm("Entrada de Datos", Pepe, edad,"Dime la edad", Coche1, color, "Dime el color");
Podemos comprobar que con esta forma de introducir datos, los valores de los slots deben limitarse
a la clase de valores indicada.
Mediante la interfaz grfica de usuario, que se ver en un punto posterior.
2.6.- Herencia.
Hay dos tipos de herencia:
a) Herencia de slots: Una subclase hereda los slots de la clase en los que se haya especificado la
opcin 'Full Inheritance to Subclasses and Instances'. Los slots heredados van precedidos por un
asterisco (*).
Si se quiere que un slot no sea heredado por los objetos o frames descendientes, entonces hay
que especificar 'No Inheritance' en el slot correspondiente (excepcin a la herencia). Son
llamados slots propios.
En la Figura previa, el slot 'num_puertas' aparece con (*) en la instancia coche2 porque dicho
atributo se ha definido como heredable en su clase inmediatamente superior (Coche).
El slot 'tipo' se define en la clase Vehiculos y es heredado por todos sus objetos descendientes.
b) Herencia de valores: Si se define un valor en un slot de un objeto y dicho valor es heredado por
los objetos descendendientes, entonces ste valor aparecer precedido por un asterisco (*) en
los objetos donde es heredado.
Si queremos que un slot heredado de una clase superior no tome el valor heredado, sino que
tenga un valor local, basta con definir el nuevo valor del slot en el campo "Value" para el objeto
local concreto. Este nuevo valor se heredar a todas las subclases o instancias que dependan del
objeto al cual se est modificando el valor del slot. En el ejemplo de la Fig.7. si se definiera un
valor distinto para el slot 'tipo' de la clase Coche, ste sera heredado por todas sus instancias.
Si queremos que el valor de un slot heredado vuelva a ser el valor heredado de una clase
superior, basta con presionar el botn (*) situado en el campo "Value" del slot determinado y
todas las instancias y subclases dependientes volvern a tomar el correspondiente valor
heredado.
2.7.- Mtodos y Monitores.

Los mtodos y monitores son funciones que realizan tareas concretas:
Mtodos: medio para definir un comportamiento de las clases o instancias que existan.
Monitores: tipo especial de mtodo que se activan automticamente cuando se accede al slot
de un objeto. Por ejemplo, podemos querer que se realicen ciertas tareas automticamente
cuando se modifica el slot (en respuesta a ciertos datos), cuando se accede a l, etc.
2.7.1.- Mtodos y Mensajes. Programacin Orientada a Objetos.

Un programa orientado a objetos, se compone de un conjunto de estructuras de datos llamadas
objetos (frames). Cada objeto contiene dos tipos bsicos de informacin:
a) informacin que describe las caractersticas del objeto (slots y propiedades de slots).
b) informacin que especifica lo que el objeto puede hacer (su comportamiento): Mtodos. Cada
accin que puede realizar un objeto se representa mediante un MTODO. Los mtodos son
procedimientos que se representan como atributos de los objetos. Al proceso de activar un
mtodo en un objeto particular se le denomina PASO O ENVO DE MENSAJE.
Cuando un objeto recibe un mensaje que se corresponde con uno de sus mtodos, dicho mtodo se
activa y el objeto ejecuta el procedimiento asociado a dicho mtodo. Tpicamente, los mtodos
emplean uno o ms valores de slots del objeto a medida que se va ejecutando el procedimiento.
Edicin de Mtodos.
En general, lo ms cmodo es utilizar el editor de mtodos para crear y editar los mtodos:
1. Selecciona la clase a la cual se quiere definir el mtodo.
2. Selecciona New desde el men de Mtodos.
3. Escribe el nombre del mtodo en el campo Name. El editor de mtodos aparecer
automticamente.
4. Si el mtodo requiere algn argumento, escribirlo en la ventana Arguments.
5. Escribe el cuerpo del procedimiento en la ventana Body.
6. Selecciona el comando Check Syntax desde la opcin Update del men (o presiona F2) para
comprobar si la sintxis del mtodo es correcta.
Por ejemplo, si tuviramos un slot compra en la clase Vehiculos que indicara el ao de compra y un
slot edad que indicara la edad del vehiculo (ambos slots deben ser de tipo Number), podramos
definir el siguiente mtodo para calcular la edad de cada vehiculo a partir de su ao de compra:
De esta forma, si Coche1:compra es 2001, la siguiente llamada al mensaje calculara pondra el valor
al slot Coche1:edad=9.
Mediante el lenguaje KAL, se pueden utilizar funciones MakeMethod.

MakeMethod (objName, methodName, [arg1 arg2 ], bodyExp)
La expresin para mandar un mensaje al mtodo existente en un objeto es:
SendMessage (objName, methodName, x, y, )
Donde x, y, son los argumentos especficos del mtodo que se activa
Un mtodo puede consistir de una o varias funciones KAL.

En caso de varias funciones, deben ir todas encerradas entre {}
{ expresin1;
expresion2;
expresionN};
Existen tres variables predefinidas dentro de un mtodo:

- Self: es una variable que representa el objeto que recibe el mensaje. Como los mtodos se
heredan de un modo similar a otros valores de slots, el objeto que recibe un mensaje con
frecuencia no es el mismo objeto en el que se ha definido el mtodo.
- TheParent: es la variable que hace referencia al padre del objeto.
- TheOwner: objeto (clase o instancia) donde se ha definido.
Los mtodos pueden ser heredados, al igual que los slots. Se puede anular el comportamiento
heredado de un objeto y hacer un mtodo local al mismo. Para hacer un mtodo local:
1. Abrir el Editor de Clases o Instancias para el objeto en el cual quiere definirse el mtodo.
2. Seleccionar el mtodo que se desea hacer local.
3. Seleccionar MakeLocal desde el men de Mtodos. Una vez que el mtodo es local, el
asterisco (*) desaparece.
Utilizacin de los mtodos.

Los mtodos sirven para realizar distintas tareas, fundamentalmente:
Asignar valores a otros slots del mismo objeto. Para cualquier modificacin fuera del
mbito del objeto, hay que enviar los mensajes apropiados a los objetos necesarios.
Enviar mensajes, bien al mismo objeto o a otros objetos. A continuacin se muestra un
ejemplo de un mtodo INIT para inicializacin de instancias. Este mtodo, definido en la clase
Coches, inicializa todos sus slots, eliminando los valores que se hayan podido poner en un
razonamiento.
MakeMethod (Coches,INIT,[],
{
GetSlotList (Self, Global:TempList);
EnumList (Global:TempList, SlotName, ResetValue (Self:SlotName));
PostMessage ("Inicializacin Completa");
} );
El slot 'TempList' tiene que ser creado, como TEXT multivaluado, previamente por el usuario
en la clase Global.
Cuando la instancia 'Coche1' recibe el mensaje INIT SendMessage (Coche1, INIT); todos
los valores de sus slots vuelve a su estado original (valores iniciales que se han dado en la
definicin de la clase). La funcin GetSlotList obtiene y guarda todos los nombres de slots del
objeto instanciado en la variable Self, en el slot multivaluado (TempList) de la instancia
general Global.
Activar otras funcionalidades de KAPPA-PC: lanzamiento de interfaces, lanzar proceso
de razonamiento, etc..
2.7.2.- Monitores.
Los monitores pueden ser:
If Needed: El mtodo se ejecuta automticamente cuando se solicita el valor del slot y no existe valor
para dicho slot. El mtodo toma como argumento el nombre del slot.
When Accessed: El mtodo se ejecuta cuando se accede al slot. La diferencia de este mtodo con el
anterior es que When Accessed se dispara incluso si el valor del slot es conocido.
Estos dos monitores no pueden lanzar un razonamiento backward,
ya que se creara un bucle infinito
Before Change: El mtodo se ejecuta automticamente justo antes de que se asigne un nuevo valor
al slot y toma como argumentos el nombre del slot y el nuevo valor que se le quiere asignar. Un
mtodo Before Change puede utilizarse para darle al usuario la opcin de cancelar el valor que
pretende asignarle al slot si entra en conflicto con su clase de valores..
After Change: El mtodo se ejecuta automticamente justo despus de asignarle un nuevo valor al
slot y toma como argumentos el nombre del slot y el antiguo valor del mismo. Un mtodo After
Change se podra utilizar para forzar el clculo de otro slot.
En los mtodos y monitores se pueden utilizar los argumentos indicados en cada caso:
Self: Hace referencia al objeto (instancia) que recibe el mensaje. De esta forma, podemos acceder
al valor de otros slots del objeto (Self:slot)
newvalue: Nuevo/antiguo valor que se quiere introducir al valor
El valor final que quedar en el slot es lo que devuelve el monitor, por ello, se debe
poner habitualmente: newvalue
Ejemplo Monitor Before Change

Supongamos que la clase Personas representa aquellas personas que tienen carnet de conducir.
Queremos por tanto que la edad mnima de estas personas sea 18 aos. Para ello, ponemos el slot
'edad' de tipo NUMBER y un Min. Value de 18.
Adems queremos especificar un mtodo que impida introducir edades de personas menores de 18
aos. Para ello hacemos lo siguiente:
- Abrimos la clase Personas
- Seleccionamos Methods / New desde el men. Le damos nombre al mtodo.
- En la ventana de argumentos ponemos: slot newvalue
- En la ventana 'body' ponemos:
If (newvalue < 18)
Then { PostMessage (" No se pueden introducir personas menores de 18 ");
Self:edad; }
Else
{ PostMessage (" Edad correcta ");
newvalue;
};
Salvamos el mtodo. Aparecer en la lista de mtodos de la clase.
Ahora ya tenemos un mtodo definido para la clase "Personas". Para convertir dicho mtodo en
un monitor asociado a un slot, se debe hacer:
- Abrimos el slot edad
- Especificamos el mtodo como monitor Before Change del slot edad
- Grabamos y cerramos
Ahora:
o si introducimos la expresin KAL Pepe:edad=10; obtendremos una ventana de aviso y el valor no
se actualizar.
o si introducimos la expresin Pepe:edad=30; el valor del slot se actualizar con dicho valor.
NOTA: Los mtodos solo pueden tener una expresin KAL la cual debe ser finalizada por ;
Para poder poner ms de una expresin, debe ir enmarcada entre llaves:
{expresion1;
expresion2;
..
expresinN };
Esto tambin sirve para las funciones que se definan y en expresiones de la parte
derecha de las reglas.
o Debe tenerse en cuenta que un monitor actuar solo de forma programada (KAL o interfaz usuario).
NOTA: Los mtodos y monitores slo se activan cuando las modificaciones se hacen en
modo programado (leguaje KAL) o durante la ejecucin de reglas.
No funcionan si se modifican los valores en modo interactivo (browser).
3.- KAL: KAPPA-PC Application Language.

KAL es el lenguaje de reglas, mtodos y funciones de KAPPA-PC. A travs de dicho lenguaje se puede
aadir, modificar, interrogar o eliminar informacin de la base de conocimientos.
KAL permite:
Realizar muchas de las operaciones explicadas anteriormente (creacin de clases, subclases, slots,
instancias, definicin de valores de slots ) en modo "programado" en vez de "interactivo".
Aadir nueva informacin a la base de conocimientos. Esta funcionalidad permite crear un nuevo
objeto, aadir un valor a un slot o crear un enlance entre dos objetos.
Borrar informacin de la base de conocimientos. Se puede borrar un valor de un slot o un enlance
existente entre dos objetos.
Realizar preguntas sobre qu informacin est almacenada en la base de conocimientos. Se puede
recuperar el valor de un slot, averiguar que slots tienen un cierto valor, recuperar la clase padre o
instancias de un objeto o hacer preguntas sobre qu hechos estn almacenados en la base de
conocimientos.
KAPPA proporciona un mecanismo para definir expresiones, similares a un lenguaje de programacin
clsica. Las expresiones deben seguir el formato del lenguaje KAL y sern evaluadas directamente por el
intrprete KAL.
Las expresiones KAL ser el lenguaje utilizado en la parte izquierda y parte derecha de las reglas.
Todas las expresiones finalizan con ;
NOTA: KAL es case-sensitive, es decir hay que tener cuidado con las maysculas y minsculas a
la hora de escribir los nombres de las funciones, slots, clases y valores.
3.1.- Sintxis KAL

Expresiones Bsicas: Pares <objeto>:<slot>
Coche1: color;
coche1:propietario:edad;
Pepe:edad;
para acceder al color del coche1

para acceder a la edad del propietario del coche1
devolvera el valor del slot.
Acceso a valores
GetInstanceList (Clase, Objeto:Slot);

Almacena todas las instancias directas de la clase Clase en Objeto:Slot
GetParent (Objeto);
Devuelve la clase superior inmediata de un objeto (clase o instancia);
GetValue (Objeto:Slot);
Devuelve el valor del slot
SetValue (Objeto:Slot, valor); o bien SetValue (Objeto, Slot, valor);

Almacena en el slot un valor (o en multivaluados, conjunto de valores separaos por comas).
Expresiones infijas: para comprobar y modificar valores:

Asignacin de valores: = , +=
coche1:propietario:edad=23;
para dar el valor 23 a la edad del propietario del coche1
coche2:propietario:edad += 1; pepe ha cumplido un ao ms
Operadores aritmticos: +, -, *, /, ^
Ejemplos:
=> 5+2;
7
=> 5 ^2;
25
Operadores relacionales aritmeticos: <, >, <=, >=, == (igual?), != (distinto?)

Cualquier operacin con dichos operadores devolver TRUE/FALSE.
Operador para concatenacin de texto: #
Ejemplo:
=> coche#4;
devolvera coche4
Operador relacionales de strings: #=

Ejemplo:
=> coche1:propietario:nombre #= coche2:propietario:nombre;

FALSE
(suponiendo que los nombres de los propietarios de coche1 y coche2 sean distintos)
Para condicin sobre desigualdad de texto hay que utilizar not()
Ejemplo:
=> Not(coche1:propietario:nombre #= coche2:propietario:nombre);

TRUE
Operadores lgicos: And, Or, Xor

Ejemplo: => 33 < 55 And coche2:color #= rojo;
devuelve: TRUE
"Not" no es realmente un operador lgico sino una funcin. Por tanto su argumento debe ir
encerrado entre parntesis.
Ejemplo:
=> Not (TRUE);

FALSE
Expresiones especiales:
For:
For counter [start end interval] expression;
Ejemplos:
For x [1 10] PostMessage (x);

For counter [1 10 0.5]
{
MakeInstance (Obj#10*counter, Root);
MakeSlot (Obj#10*counter, Size);
SetValue (Obj#10*counter, Size, counter);
};
Crea 19 instancias Obj10, Obj15, Obj20 Obj100 que dependen de la clase Root. Crea para cada
instancia el slot Size y le da el valor del contador.
ForAll:
ForAll [x|className1 y|className2] expression;
Ejemplo:
ForAll [x|Personas]
PostMessage (" El nombre de la persona es " #x:Nombre);
While:
While (testExpression) expression;
Let:
Let [x xExpression] [y yExpression] expression;
If:
If (testExpression)
;no debe evaluarse a NULL y todos los
Then thenExpression
valores deben ser conocidos
Else elseExpression;
Null? (objeto:slot);
Para establecer la condicin sobre si un slot no tiene valor ( es Null), debe usarse:
Null? (objeto:slot);
PostInputForm:
PostInputForm ( Texto inicial
Obj1 , slot1 , texto1 ,

.
ObjN , slotN , textoN );
3.2.- Funciones.
Todo lo que se puede hacer desde el men de KAPPA-PC, como aadir un objeto o activar un mtodo se
puede hacer de forma rpida y eficiente con las funciones de KAPPA.
KAPPA proporciona unas 300 funciones predefenidas de las cuales existe un manual on-line en la opcin
"Help" que aparece en la "Main KAPPA Window". Se pueden usar estas funciones para definir expresiones,
otras funciones o combinar funciones standard.
Definicin de Funciones
Las Funciones definidas son siempre globales. Pueden definirse en:
a) En Edit Tools: 'Edicion de Funciones'
Se indica el nombre, los argumentos y el cuerpo de la funcion
b) Mediante la ventana del interprete KAL:
MakeFunction (Nombre-Funcion, [arg1 arg2 ... argn], Accion);
O bien:
MakeFunction (Nombre-Funcion, [arg1 arg2 ... argn], {Ac1; Ac2; ...Acn});
Las funciones definidas se pueden llamar (son accesibles globalmente):
En la ventana del interprete KAL: Nombre-Funcion (argumentos);
En mtodos que se definan en las clases o instancias.
Asociadas a imgenes (botones, etc.).
La librera de funciones que provee KAPPA permite realizar distintas operaciones:

crear, acceder y modificar la base de conocimiento.
evaluar expresiones matemticas, lgicas y de cadenas de caracteres.
manipular listas, ficheros, bases de datos ...
controlar el procesamiento del conocimiento y el interface grfico.
Sintxis general de una funcin.
function name (argument1, argument2, );
Algunos ejemplos de funciones.
MakeInstance (Usados, Coche);
Crea la instancia Usados bajo la clase Coche.
MakeClass (CochesDeporte, Coche);
Crea la nueva clase CochesDeporte bajo la clase Coche.
SetValue (Coche2:color, rojo);
Pone el valor del slot de Coche1 a rojo. Esta expresin es equivalente a Coche2:color = rojo;
GetParent (Coche1);
Encuentra el padre de Coche1.
LengthList (Coche2:color);
Devolvera 1. (si 'color' fuera un slot multivaluado).
AppendToList (Coche2:color, verde);
Devolvera LIST:rojo verde. Para ello el slot 'color' de la clase Coche debera ser multivaluado.
(cardinalidad mltiple).
Member? (Coche1:color, azul);

FALSE. (si 'color' fuera un slot multivaluado).
Not (Coche2:numpuertas #= 10);
TRUE porque el Coche2 tiene 3 puertas.
MakeFunction (Cuadrado, [x], (x*x));
Funcin definida por el usuario. Para utilizar dicha funcin hacer la llamada cuadrado(5) y devolvera el
valor 25.
Algunas funciones pueden servir para realizar consultas sobre la base de conocimientos:
GetValue (objeto, slot);
Devuelve el valor o valores del slot en el objeto.
Ejemplo:
=> GetValue (Coche2:propietario, edad);
27
PostMessage (text1, text2, , textN);
Muestra una ventana con un mensaje para el usuario, donde text es un texto, o un par texto-valor.
Ejemplo:
PostMessage ("El color del Coche de Pepe es " #Coche1:color);
donde se concatenan strings. O bien,
PostMessage ("El color del Coche de " #Coche1:propietario , " es " #Coche1:color);
Si actua como mtodo, es til poner: PostMessage ("El color del Coche de Pepe es " #Self:color);
Tambin puede utilizarse como:
PostMessage ("El color del Coche de Pepe es "; Coche1:color);
SelectList (aList, item, pattern);
Selecciona el primer elemento de la lista que cumple el patrn.
aList: valor lista de un slot multicampo o cualquier otra expresin que se evale a una lista.
item: argumento que se unifica a cada elemento de la lista.
pattern: test que se aplica sobre el argumento.
Ejemplo:
Supongamos que en la clase Personas tenemos un slot "Asignaturas" que nos dice las asignaturas
de las que est matriculada una persona. Y supongamos que a su vez una asignatura es una
instancia de una clase "MATERIAS" que tiene entre otros slots el Aula donde se imparte dicha
asignatura y el Nombre de la asignatura. Queremos saber alguna asignatura que se imparta en el
aula 'Aula21'. La funcin SelectList nos devolver la primera asignatura de la lista que cumpla el
requisito.
=> SelectList (Pepe:asignaturas, x, x:Aula #= Aula21);
EnumList (aList, item, action);
Juanla la expresin que viene representada por el parmetro 'action' para cada uno de los
elementos de la lista.
Ejemplo:
=> EnumList (GetValue (Pepe,asignaturas), x,
If (x:Aula #= Aula21)
Then PostMessage (" La asignatura que se imparte en el Aula21 es" #x:Nombre ));
Para cada asignatura que se imparta en el Aula21 obtendremos una ventana con un mensaje
tipo:
La asignatura que se imparte en el Aula21 es Inteligencia Artificial
del
Entrega-1: objetos, mtodos.

Entregar el cdigo correspondiente.
a) Implementar la informacin descrita en los puntos anteriores, incluyendo valores en los atributos
de las instancias:
Personas (instancias Pepe, Juan, Maria.):
Nombre
Edad
Coches y Motos son Vehculos
Coches (instancias: Coche1, Coche2, Coche3.)
Matrcula
Modelo
Puertas
Color
Propietario
Motos (instancias: Moto1, Moto2)

Matrcula
Modelo
Edad
Color
Propietario
Y particularmente, incluir valores para los slots de las instancias creadas. Por ejemplo:
"Juan es el dueo del coche3", "Pepe es el dueo del coche1 y coche 2",
"Mara es la duea de las motos moto-1 y moto-2", etc.
b) Sobre la estructura anterior implementar las expresiones, funciones o mtodos para:

1. Devuelve en una ventana el color del coche1 y su nmero de puertas. Utiliza PostMessage
2. Devuelve en una ventana el color del coche1 y de la moto2. Utiliza PostMessage
3. Devuelve la matrcula de todas las motos. Utiliza ForAll
4. Devuelve la Edad del propietario/s de la moto 1 si su nombre es Mara
5. Devuelve el color de los coches con ms de 3 puertas
6. Devuelve la edad del propietario del coche3
7. Introducir la edad de una persona mediante PostInputForm
c) Hacer un valor activo (monitor BeforeChange) que avise si una persona tiene menos de 18 aos.
d) Hacer un valor activo que avise si la edad de un coche es mayor que la de su dueo.
IMPORTANTE
Al finalizar el punto c y d, eliminad la asociacin de los monitores introducidos
4.- Creacin de Reglas.

Al desarrollar una aplicacin en KAPPA-PC se pueden utilizar los tres paradigmas de programacin
que ofrece esta herramienta (programacin orientada a objetos, razonamiento basado en reglas,
programacin tradicional) o una combinacin de las tres.
La sintaxis de las reglas en KAPPA-PC se ajusta al formato convencional de reglas de cualquier
herramienta para desarrollo de Sistemas Expertos. Para crear una regla, hay que abrir el Editor de
Reglas que aparece en la ventana EditTools.
Los ejemplos que veremos se ajustarn a la representacin del conocimiento utilizada hasta ahora:
Con los siguientes valores iniciales:

Slot
Vehiculos
matrcula
modelo
color
propietario
aocompra
edadcoche
bujias
estado
bateria
pasajeros
tipo
Coches
numpuertas
Value Type
Allowable Values
Coche-1
TEXT
TEXT
TEXT
OBJECT
NUMBER
NUMBER
TEXT
TEXT
TEXT
NUMBER
TEXT
NUMBER
Coche-2
Coche3
Personas
ok, nook
ok
cargada
cargada
Min Value: 2
Max Value: 5
CLASE Personas
Slot
nombre
apellidos
direccion
edad
vehiculo
Value Type
TEXT
TEXT
TEXT
Number
OBJECT
Allowable Values
Min-Val:0 Ma-Val=100
VEHICULOS
Editor de reglas.
Para crear una regla, abrir el Editor de Reglas, seleccionar New y dar nombre a la nueva regla que se
va a crear. A continuacin aparecer una pantalla como la de la Figura:
REGLA1
Patterns: Variable|Clase que se va a emplear dentro de la regla.

El pattern [coche|Coches] representa instancias (coche) de la clase (Coches). Por convencin, el
nombre de una variable se pone en minscula aunque no es necesario. En cada instancia de
regla, la variable coche se instancia sobre una instancia de la clase COCHES.
Mltiples Patrones en las reglas
En general, se pueden poner mltiples patrones en las reglas, separados por espacios:
Var1|clase1 Var2|clase2 . Var-n|Clase-n
Pero, los patrones mltiples solo son soportados en un encadenamiento hacia delante.
Hacia atrs, solo se puede poner UN PATRN.
Priority: La prioridad de una regla tambin es opcional, por defecto 0. [-32.000 32.000]
If Then: Las reglas se escriben en lenguaje KAL y deben seguir la sintaxis correcta.
Las expresiones (predicados) de la premisa de las reglas puede separarse por And (y Or, aunque
no es recomendable). Los hechos que aparecen en la parte izquierda (LHS) como en la parte
derecha (RHS) de una regla se refieren a valores de slots de objetos.
La parte If y la parte Then siempre acaba con ;
Se pueden poner varias conclusiones en la parte Then, agrupndolas mediante {}:
{ expresion1;
expresion2;
-------expresionN};
Ojo!: No separar con And!
Despus de escribir la regla, es conveniente pulsar F2 o Check Syntax (men Update). No se debe cerrar
el Editor de Reglas a no ser que la regla sea totalmente correcta. Una vez editada la regla, seleccionar
Close desde el men Update para salvar la regla y cerrar el editor.
Nota: La premisa de una regla (IF) debe evaluarse True/False. No puede evaluarse a NULL, o
tener algn valor desconocido.
Las reglas tambin se pueden crear alternativamente desde el intrprete KAL:
=> MakeRule (Regla1, [Coche|Coches] ,
Coche: bateria #= cargada And
Coche:bujias #= ok,
Coche:estado = bien);
De forma similar a la regla Regla1, crear las dos reglas siguientes:
REGLA2
=> MakeRule (Regla2, [coche|Coches],
coche:estado #= Bien,
PostMessage ("El Sistema Electrico esta Bien del Coche: " #coche));
REGLA3
=> MakeRule (Regla3, [Coche |Coches],
Coche:estado #= bien,
Coche:propietario = Juan);
5.- Razonamiento en KAPPA PC

KAPPA-PC ofrece los dos tipos de encadenamiento bsicos en un sistema basado en reglas:
Hacia delante (Forward chaining): Acta desde las premisas de una regla hacia las conclusiones.
Por ejemplo, con los datos actuales y la Regla.1, y desencadenando un razonamiento hacia
delante, el motor de Inferencia de KAPPA-PC se activa y descubre que las premisa de la regla
unifica con los valores actualmente existentes en la instancia Coche1. La regla se dispara y el slot
'estado' adopta el valor de 'bien'.
En concreto, la regla se activar para todas las instancias de la clase COCHES que satisfagan las
premisas correspondientes.
Hacia atrs (Backward chaining): Acta desde la conclusin de una regla hacia las premisas.
Este tipo de razonamiento se desencadena preguntando siempre por un hecho (objetivo). El motor
de inferencia debe encontrar reglas cuya conclusin unifique con la pregunta u objetivo (goal) que se
est buscando.
Por ejemplo, con los datos actuales y la Regla1 y Regla3, podramos preguntar al sistema el
propietario del Coche1 (goal). El sistema podra obtenerlo con los datos disponibles y deducir que es
Juan. Alternativamente, si preguntamos el propietario del Coche2 (goal), el sistema podra obtenerlo
tras preguntarnos la situacin de las bujas (preguntas al usuario).
5.1.- Razonamiento hacia delante (Forward chaining):

La llamada a un proceso de razonamiento forward es:
ForwardChain ([NOASSERT], goalName, ruleName or ruleList)
Ejemplo: ForwardChain (NULL, Rule1, Rule4, etc.)
[NOASSERT]: Debe ponerse tal cual.

o
Indica que el proceso de razonamiento debe comenzar de inmediato con los datos
actualmente existentes en la base de conocimientos (si no se pusiera, se efectuara un
razonamiento de tipo event-driven, que se lanzara a partir de un nuevo dato Assert
(<object-name>,<slot-name>) que desencadenara el razonamiento hacia delante).
El segundo argumento es el objetivo, que en el caso de ForwardChain suele ponerse NULL.
Los siguientes argumentos son las reglas o conjunto de reglas que estn involucradas en el
encadenamiento hacia delante. Hay que indicar explcitamente una clase de reglas o bien una
lista de reglas: Regla1, Regla2, .
Clases de Reglas
En KAPPA-PC hay que especificar explcitamente la Lista de Reglas, o Clase de Reglas a utilizar en
cada proceso de encadenamiento. En general, se pueden utilizar todas las reglas, pero se puede dirigir
ms eficientemente el proceso de razonamiento lanzando un proceso inferencial con subconjuntos de
reglas. Esto se puede hacer de dos formas:
a) El subconjunto de reglas se puede establecer cuando se lanza el proceso:
ForwardChain (NULL, Rule1, Rule4, etc.);
BackwardChain (Goal1, Rule2, Rule3, etc.);
b) Se pueden definir Clases de Reglas (en la instancia Global): Para crear un conjunto de
reglas:
1.- Abrir la instancia Global (de Root) y crear un slor multivaluado.
2.- Poner los nombres de las reglas que se desean agrupar como valores de dicho slot.
Una regla puede estar en ms de un conjunto de reglas. Posteriormente se pueden invocar los
distintos grupos de reglas en un encadenamiento hacia delante o hacia atrs.
Por ejemplo, si el slot de la instancia Global donde se han agrupado un conjunto de reglas se
llama ReglasCoche, se podra invocar este grupo de reglas de la siguiente forma:
ForwardChain (NULL, Global:ReglasCoche);
BackwardChain (Goal1, Global:ReglasCoche);
Tarea a Realizar: Lanzar procesos de razonamiento hacia delante con las reglas
anteriores y comprobar su resultado:
ForwardChain ([NOASSERT], NULL, Regla1, Regla2, Regla3)
Despus, volver a la base de hechos inicial (puede usarse una funcin especfica).
Inicializacion de una base de hechos tras un razonamiento

No hay una funcin global de inicializacin de toda la BH una vez se ha hecho un razonamiento.
Un mtodo habitual es eliminar las instancias del problema: Al volverlas a crear todos los slots quedarn
con el valor por defecto (heredado). Las clases suelen quedarse (informacin del dominio)
Alternativamente, el siguiente mtodo inicializa las instancias, eliminando los valores locales de sus slots y
dejando solo los heredados. Previamente se debe:
1. Crear una instancia 'Auxiliar' (de la clase Root), con un slot 'Clases', de tipo OBJ multivaluado que
contenga como valores todas las clases cuyas instancias directas que queremos inicializar
(Coches, Motos, Personas en los ejemplos anteriores).
2. Crear, en la instancia Auxiliar , dos slots multivaluados: "Instancias" y "Slots", de tipo OBJ y TEXT,
respectivamente.
3. La funcin inicializa los slots de las instancias inmediatamente sucesoras de las clases
especificadas en Auxiliar:Clases.
EnumList (Auxiliar:Clases, c,
{ GetInstanceList(c, Auxiliar:Instancias);
GetSlotList(c,Auxiliar:Slots);
Para cada elemento 'c' de la lista Auxiliar:Clases

Coloca sus instancias en Auxiliar:Instancias
Coloca sus slots en Auxiliar:Slots
EnumList (Auxiliar:Instancias, x, EnumList (Auxiliar:Slots, y, ResetValue(x:y)));

Inicializa 'todos' los slots de
'todas' las instancias
ResetValue(Auxiliar:Instancias);
ResetValue(Auxiliar:Slots) } );
Limpia Auxiliar:Instancias
Limpia Auxiliar:Instancias
5.2.- Razonamiento hacia atrs (Backward chaining)

La llamada a un proceso de razonamiento backward es mediante la funcin KAL:
BackwardChain ([NOASK], goalName, <ruleName or ruleList>)
Ejemplos: BackwardChain (Goal1, Regla1, Regla2, Regla3)
BackwardChain (Goal1, Global:Reglas)
[NOASK]: Argumento opcional que si se especifica se indica al proceso que no debe efectuar
preguntas al usuario.
goalName: es el objetivo del razonamiento. Se debe haber especificado previamente (Edit
Tools / Goal).
ruleName or ruleList: reglas o conjunto de reglas que estn involucradas en el encadenamiento
hacia atrs. Hay que indicar explcitamente una clase de reglas o bien una lista de reglas (Regla1,
Regla2, .).
Los objetivos (Goals) que se pueden establecer en KAPPA-PC son del tipo:
<objeto:slot>
(preferentemente), o
<objeto:spot#=valor>
No se pueden establecer objetivos de la forma objeto:objeto:slot.

Tampoco se puede realizar un encadenamiento hacia atrs a travs de dichas
expresiones en las reglas (si funcionara en el caso forward), salvo que los valores
fueran conocidos previamente (por ejemplo, objeto:objeto:valor#=5).
El motor de inferencia busca todas aquellas reglas que en la conclusin de las mismas aparezca el par
<objeto:slot> y trata entonces de establecer la verdad de las premisas de dichas reglas. El
razonamiento acabar cuando se encuentre una regla cuyas premisas sean ciertas.
Un razonamiento hacia atrs requiere un objetivo, y solo se disparan las reglas que conducen a dicho
objetivo. Pueden haber diversas formas (caminos) para obtener el objetivo y se permiten preguntas
sobre hechos no conocidos (NULL), que no tengan un valor previo,
Las Reglas en un Razonamiento Hacia atrs, solo pueden tener UN PATRN.

Una forma de poner varios patrones hacia atrs es mediante la funcion IsThereAny?:
Regla:
Patrn: x|Clase1
Parte IF: x:slot1 > 10 And
IsThereAny?( [ y | Clase2 ], y:slot2 < 20 );
Parte THEN: x:slot3 = 20;
Pero en un razonamiento backward, si es necesario, no preguntaria por y:slot2, al no ser un patrn
de la regla. Esto se puede evitar asociando a Slot2 de la Clase2 un valor activo que pregunte u
obtenga por su valor Si es Necesario.
Pero en cambio, no se puede utilizar la variable y en la parte derecha de la regla, al no ser una
variable-patrn de la regla.
Objetivos (Goal)
Los objetivos, al igual que las reglas, se escriben en lenguaje KAL. Los objetivos se escriben en el
Editor de Objetivos (ventana EditTools/Goal). Despus de escribir el objetivo, seleecionar Save y
luego Close desde el men Update.
Los objetivos se pueden utilizar tanto en el encadenamiento hacia delante como hacia atrs. Son
obligatorios para desencadenar un razonamiento hacia atrs pero tambin se pueden emplear para
detener un proceso de razonamiento hacia delante en un punto especfico. Cuando el test se satisface,
el encadenamiento hacia delante se detiene.
Para obtener una meta (o premisa/subobjetivo), se aplican los siguientes pasos:
1. el dato ya es conocido en el problema (est en la base de hechos)
2. el dato puede deducirse a partir de una regla. Se permiten preguntas al usuario, si se
requiere el valor (no conocido) de un slot.
3. se pregunta al usuario por el valor del dato si:
en el slot correspondiente se ha seleccionado la opcin "Ask Value if NULL in

Backward Chaining".
No se ha establecido la opcin NOASK en la llamada al proceso backwardchaining.
En caso de que el dato no pueda deducirse por ninguno de los pasos anteriores, el sistema concluye
que el objetivo no se puede demostrar.
Ejemplo de encadenamiento hacia atrs

Consideremos el objetivo:
Tambin podramos haber hecho una pregunta ms concreta, por ejemplo: Coche2:propietario #=
Juan
Al lanzar un razonamiento hacia atrs con el objetivo de la figura:
BackwardChain (meta1, Regla1, Regla2, Regla3);
La nica regla cuya parte derecha se instancia con el objetivo es la Regla3, tal que la variable de la
conclusin se unifica con el patrn 'Coche2'. El motor de inferencia trata de establecer el valor de
verdad de las premisas:
Coche2:estado #= bien,
El valor del slot no es conocido, pero puede obtenerse a partir de la Regla.1. La variable local de la
regla se instancia tambin con Coche2. De esta forma, se intenta establecer su premisa:
Coche2: bateria #= cargada And
Coche2:bujias #= ok,
Dados los hechos iniciales, el valor de Coche2: bateria es cargada, pero no hay valor para el slot
bujias. De esta forma preguntar al usuario. Dependiendo del valor que se responda, podr o no
asertar la meta.
Tarea a realizar: Realizar el Razonamiento hacia atrs con las metas:

Nota: Reiniciar la Base de Hechos antes de lanzar cada razonamiento!
Coche2:propietario
Coche3:propietario #= Juan
Coche1:propietario #= Juan
Y comprobar los resultados.
5.3.- Traza y depuracin del proceso inferencial.

KAPPA-PC ofrece diversas utilidades grficas para facilitar el control y depuracin de un proceso de
razonamiento basado en reglas.
Relaciones entre Reglas: Rule Relations Window

Esta utilidad sirve para mostrar las relaciones que existen entre las reglas. Al abrir la ventana Rule
Relations Window (el icono est en la ventana principal de KAPPA), aparecer la lista de reglas
disponibles, pudiendo seleccionar la regla en la que estamos interesados.
Para cada reglas seleccionada aparecern dos listas:
If Dependencies: Esta es la lista de reglas (si existe alguna) cuyas conclusiones unifican las
premisas de la regla seleccionada.
Then Dependencies: Esta es la lista de reglas (si existe alguna) cuyas premisas unifican la
conclusin de la regla seleccionada.
Por ejemplo, en el caso de mostrar la Regla3, aparecer:
Con cada una de las reglas se pueden hacer una serie de operaciones:
o
Edit: Muestra la regla en el Editor de Reglas.
List Slots: Lista los slots que tienen en comn la regla seleccionada y la regla dependiente
(en la parte Then).
Traceado de Reglas: Rule Trace Window

El icono de esta utilidad tambin se encuentra en la ventana principal de KAPPA-PC. Permite lanzar el
proceso de razonamiento, ver las reglas que invoca el motor de inferencia, y realizar una traza de todo
el proceso tanto hacia delante como hacia atrs. En dicha traza se puede ver cmo el sistema genera
nuevas conclusiones, los posibles errores que existen en la base de conocimientos de nuestra
aplicacin etc.
Para lanzar un tracear un proceso inferencial, los pasos son (Si solo se desea lanzar un proceso
inferencial, se debe seguir el descrito previamente):
1. Lanzar la utilidad. En Options activar el modo Active Trace. Aparecer la ventana:
2. Seleccionar Rule Trace desde Trace/Break.

3. Transferir las reglas de las que se desea hacer una traza de la lista Available Rules a la lista
Selected Rules. (Tambin se pueden tracear slots).
4. Seleccionar el tipo de encadenamiento (Forward o Backward chaining) que se quiere realizar
desde el men Control. Aparece una ventana con el esquema de la llamada al proceso
inferencial, el cual se debe modificar de acuerdo a la aplicacin
ForwardChain ([NOASSERT], goalName, ruleName or ruleList)

Por ejemplo: ForwardChain ([NOASSERT], NULL, Rule1, Rule4, etc.);
BackwardChain ([NOASK], goalName, <ruleName or ruleList>)

Por ejemplo: BackwardChain (Goal1, Rule2, Rule3, etc.);
EJEMPLO: Para lanzar un encadenamiento hacia delante con la Regla1:
A continuacin se pondr en marcha el motor de inferencia, y tras comprobar que todas las premisas
de la regla se cumplen, pondr el valor del slot estado del 'Coche1' a bien.
Otras opciones de esta utilidad aparecen en los diferentes mens de la ventana:

Men Control:
Start: esta opcin permite llamar a una funcin definida por el usuario que se llame Start. Esta
funcin podra emplearse, por ejemplo, para iniciar el proceso de razonamiento.
Assert : esta opcin llama a la funcin Assert del lenguaje KAL. Se puede por tanto insertar
un dato <objeto:slot > directamente desde la ventana de trazas en lugar de tener que ir al
intrprete KAL.
SetForwardChainMode : Este item permite seleccionar el control del encadenamiento hacia

delante Es equivalente a utilizar la funcin KAL SetForwardChainMode.
ForwardChain : Esta opcin inicia el encadenamiento hacia delante llamando a la funcin

KAL ForwardChain.
BackwardChain: Esta opcin inicia el encadenamiento hacia atrs llamando a la funcin

KAL BachwardChain.
ResetForwardChain: Esta opcin vaca la Agenda y la Rule List. Es equivalente a una llamada
a la funcin KAL ResetForwardChain.
Call Function: Esta opcin permite llamar a cualquier funcin KAL definida por el usuario.
Explain: Carga la utilidad Explain de KAPPA-PC.
Men Options:
Active Trace: Esta opcin permite ver la Agenda y la Rule List durante el encadenamiento
hacia delante. Cualquier par <objeto:slot> que se inserte se listar en la ventana de la Agenda.
Cuando se inicia el encadenamiento hacia delante, los pares <objeto:slot> se van aadiendo y
borrando de la Agenda al igual que las reglas de la Rule List. Si se quieren ver con detalle los
distintos pasos que se van siguiendo, selecciona Step Mode.
Step Mode: Este item slo se puede seleccionar si previamente se ha activado Active Trace.
Step Mode funciona automticamente con ForwardChain.
IMPORTANTE: Para que se active el Step Mode, hay que hacer un Assert especfico, o se debe
seleccionar [NOASSERT] en el ForwardChain.
Despus de especificar los argumentos de ForwardChain, el botn Step mostrar una flecha
para indicar cual ser el siguiente paso a ejecutar. Los contenidos de la Agenda y la Rule List
se van mostrando en las respectivas ventanas.
Inference Browser
Es de utilidad fundamentalmente en el encadenamiento backward. La ventana Inference Browser
permite ver de forma grfica las reglas que el motor de inferencia va invocando, pudiendo comprobar
como el sistema infiere las conclusiones y examinando las lneas de razonamiento.
Por ejemplo, lanzando esta ventana con la Base de Hechos inicial y el encadenamiento hacia atrs:
BackwardChain (meta1, Regla1, Regla2, Regla3);
Podemos ver que se activa la Regla3, la Regla1 y nos pregunta por el valor de Coche2:bujias:
Una vez asertado un valor ok, nos muestra la inferencia final:
En color verde nos muestra los datos satisfechos, mientras que en color rojo nos mostrara las
premisas que no se han satisfecho.
5.4.- Control Forward: Agenda y Rule Mode.

Las opciones de control del Razonamiento Hacia delante (ForwardChainning) se pueden seleccionar
desde el men SetForwardChainMode de la ventana RuleTrace, o bien, mediante la funcin KAL
SetForwardChainMode ( RuleMode, AgendaMode).
Nota importante: El modo Selective no es completo!
La Agenda en el Razonamiento Forward

La Agenda es una cola de pares <objeto:slot> que referencian a slots cuyos valores cambian como
resultado de aplicar una regla. La agenda puede verse en la ventana RuleTrace.
La Agenda puede trabajar de dos modos en un encadenamiento hacia delante:

IGNORE (valor por defecto): Un item (objeto:slot) de la Agenda se ignorar si existe una
versin ms reciente de ese item en la Agenda. Es asimilable a un razonamiento de tipo
irrevocable, donde los hechos modificados son eliminados.
NOIGNORE: Un item de la Agenda se procesar sin tener en cuenta versiones posteriores de
dicho item que puedan existir en la Agenda. Por lo tanto, permite duplicidades. Corresponde a
una bsqueda en grafos, donde los antiguos hechos permanecen.
La Lista de Reglas
La Lista de Reglas (RuleList en la Ventana RuleTrace) muestra las reglas relevantes (tienen una
premisa que unifica con un item de la Agenda <objeto:slot>), y en espera de ser testeadas en un
proceso inferencial forward.
Importante: La Rule List no contiene el conjunto de reglas que son aplicables, es decir
aquellas reglas cuyas LHS se satisface, sino aquel subconjunto de reglas que son
SUSCEPTIBLES de cumplirse (reglas RELEVANTES).
El lugar donde se inserta cada regla en la Rule List depende de la estrategia determinada por el
encadenamiento hacia delante y la Agenda. Por defecto, el proceso de razonamiento hacia delante
contina hasta que no hay ms items en la agenda o en la lista de reglas.
Control Encadenamiento (Rule Mode)

Hay cuatro diferentes estrategias para determinar qu regla debe probarse primero del conjunto de
reglas RELEVANTES (unifica con un item de la Agenda):
SELECTIVE: es la estrategia por defecto y es la ms eficiente porque slo sigue una
nica lnea de razonamiento. Cuando una regla se comprueba que es cierta (sus
premisas se satisfacen) se ejecuta, el resto de las reglas se borran y solo se aaden las
nuevas reglas que se refieren al nuevo hecho asertado (de acuerdo a su prioridad):
NO es completa!, es decir, no obtiene todo lo posible. Particularmente, cuando los

nuevos hechos asertados en la aplicacin de una regla no lanzan nuevas reglas, el
proceso de encadenamiento se para.
DEPTHFIRST: Las nuevas reglas 'relevantes' se aaden al principio de la Rule List de
acuerdo a su prioridad. No borra la Rule List despus de encontrar una regla que se
cumple.
BREADTHFIRST: Las nuevas reglas 'relevantes' se aaden al final de la Rule List, de
acuerdo a su prioridad. No borra la Rule List despus de encontrar una regla que se
cumple.
BESTFIRST: Las nuevas reglas 'relevantes' se entremezclan con las reglas ya
existentes en la Rule List de acuerdo a su prioridad. No borra la Rule List despus de
encontrar una regla que se cumple.
Estas estrategias pueden establecerse en la ventana RuleTrace, o mediante la funcin:
SetForwardChainMode (SELECTIVE | DEPTHFIRST | BREADTHFIRST | BESTFIRST);
Nota: Es importante que en ForwardChain el control no sea SELECTIVE!, ya que es muy

restrictivo y no completo
Entrega-2: reglas, inferencia.

Entregar el cdigo correspondiente.
1) Aadir las siguientes reglas a las ya creadas:
Regla-4) Todos los coches de 4 puertas son de color blanco

Regla-5) Todos los dueos de coches blancos tienen 30 aos.
Regla-6) Todos los coches blancos son del modelo turismo.
Regla-7) Todas las motos cuyo modelo es sidecar tienen una edad de 20 aos
Regla-8) Todas las motos cuyo matricula es mayor que 5555 son de color blanco
Regla-9) Todas las motos de color blanco y cuyo modelo sea sport tienen una edad de 10 aos.
2) Aplicacin Backward:
A partir de una BH con al menos una nueva instancia de motos (sin ningn valor en sus slots!), intentar
obtener la edad de la moto-instancia concreta.
Al preguntar valores durante el encadenamiento, probar al menos con: modelo=sport y
matricula=10000 y comprobar el resultado obtenido.
Comprobar la utilidad de las ventanas RuleTrace e inference Browser
3) Aplicacin Forward
A partir de una BH, en la que existan los nuevos hechos (creando las instancias Coche4 y Luis):
Coche4:puertas=4;
Coche4:propietario=Luis;
Lanzar un razonamiento hacia delante y comprobar los resultados inferidos. Comprobad que en control
no sea SELECTIVE!
De acuerdo a las reglas del sistema, debe obtenerse al menos:
Coche4:color=blanco, Coche4:modelo=turismo, Luis:edad=30,
Comprobar la utilidad de las ventanas RuleTrace e inference Browser
4) Sobre metodos y monitores

Escribir un mtodo que, actuando como un monitor AfterChange, lance un proceso de
razonamiento forward en cuanto se modifique el valor del slot que esta siendo monitorizado.
Aplicarlo, por ejemplo, al nmero de puertas de un coche para lanzar el razonamiento forwardchain anterior.
Al finalizar el punto 4, eliminad la asociacin del monitor introducida
6.- Interfaz de usuario en KAPPA-PC: Session

Las herramienta Session de Kappa permite crear la interfaz grfica de usuario.
La interfaz de usuario consta de diversas ventanas (sessions). En cada una de ellas pueden aparecer
imgenes grficas que muestran el estado de la base de conocimientos, as como pueden interacturar
(modificar) con ella, mediante la activacin de funciones que modifican valores de slots, lanzan
razonamientos, etc.
Las diferentes sesiones que pueden haber en una determinada aplicacin se visualizan/ocultan por medio
de una funcin especfica, que muestra/oculta una u otra ventana (session):
ShowWindow(SessionN, NORESET);
HideWindow (SessionN);
Estas funciones pueden lanzarse interactivamente o automticamente (en mtodos, parte derecha de
reglas, etc.) segn como est el proceso.
6.1.- Ventana de Sesin

La Ventana de la Sesin es una interfaz donde se crean imgenes que permiten actuar interactivamente
con la base de conocimiento. Se pueden tener mltiples ventanas de Sesin, cada una sirve un propsito
especfico.
Se activan mediante la herramienta 'Session'. Cada Ventana de Sesin tiene dos modos principales
('Options'):
Layout Mode: En este modo se crean las imgenes y se conectan a la aplicacin. Pueden crearse,
revisarse, moverse, y redimensionarse las imgenes en este modo. A la izquierda de la ventana
aparecen un conjunto predefinido de imagenes
Modo Runtime: En el Modo Runtime se usan las imgenes que ya se han creado. Es el modo por
defecto y de uso de la interfaz grfica de KAPPA-PC.
Pueden crearse Sesiones Mltiples (mximo 64) y cada una se edita separadamente. La sesion principal
es 'SESSION' y las dems van numeradas 'SessionN'. Cada ventana de Sesin son objetos (instancias) en
KAPPA-PC y estn en la jerarqua de objetos: Cada ventana de cada 'Session' es una instancia de la
subclase KSession de la clase Kwindow. Para verlas en Object Brower: seleccionar objeto, Edit/Show
Subclasses, o Edit/Show Instances.
El men de 'Window' en un Ventana Session tiene las opciones principales siguientes:
New: Permite crear nuevas ventanas de la Sesin. Cada nueva ventana de la Sesin se numera
automticamente. Se debe estar en el Modo del Esquema para usar esta opcin.
Delete: Permite anular la ventana de la Sesin actualmente activa (y todos los objetos que la
ventana contiene). Se debe estar en el Modo del Esquema usar esta opcin.
Hide / Unhide: Muestra y oculta sesiones.
Attribute. Permite caracterizar la sesin o las imgenes contenidas en esa sesin (se debe estar
en el Modo del Esquema). Tambin se activa pulsando doble en la ventana de la Sesin o en una
imagen y permite:
Asignar un Ttulo a la Ventana/Imagen.
Asignar una Funcin de Accin a la imagen (por ejemplo, si es un boton). Debe haberse
definido previamente una funcin global (EditTools: Function) que se puede asociar a la
imagen y se activar cuando se hace un clic del ratn izquierdo. Asignacin de la funcin:
Indicar su nombre en la ventana 'Action' que aparece. Tambien se puede asignar una tecla
de funcion, que hace lo mismo que click izquierdo.
Tambin se pueden editar otras caracteristicas de la imagen o ventana 'session',

accediendo a la instancia que la representa (tamao, color, funcin para botn derecho del
raton, etc.)
Insercin de imgenes en una ventana Session.

Para la insercin y/o modificacion de imgenes de na ventana Session se debe esatr en el modo layout. En
dicho modo se pueden insertar en el panel las imgenes prediseadas de Kappa. Asimismo, se pueden
parametrizar las imgenes ya existentes en el panel.
Las posibles imgenes predefinidas se clasifican en:
Imgenes pasivas: Visualizan solo informacin de la aplicacin.
Imgenes activas. Permiten interactuar con la aplicacin: modificar valores, lanzar funciones,
procesos de razonamiento, etc.
Las imgenes prediseadas principales son:
Botn (activa): Si el usuario pulsa el botn del ratn izquierdo en la imagen se llama una
funcin asociada con el botn. En los atributos de la imagen se establece la funcin asociada
(action).
Texto (pasiva): Ventana de Texto donde se presenta el texto incluido en un fichero externo
(nombre limitado a 8 caracteres)..
Edit1 (activa): Presenta y permite cambiar el valor del slot asociado.
Transcript Images (pasiva): Ventana del texto en el que el usuario puede desfilar el texto en
la imagen (scroll). Usa las funciones DisplayText(image, text) o bien se accede al texto
incluido en un fichero.
BitMap (pasiva): Presenta una imagen BitMap prediseada (nombre limitado a 8 caracteres).
El nombre de la imagen max 8 caracteres
StateBox (pasiva). Permite monitorizar valores de slots monovaluado mientras se ejecuta la
aplicacion. En los atributos de la imagen se establece el slot asociado.
Meter (pasiva): permite supervisar el valor numrico de un slot de tipo Number monovaluado,
mientras una aplicacin est corriendo. Se asocia el slot que debe presentar el valor, as
como se pueden indicar los lmites mximo y mnimo. Cada vez el valor del slot cambia, la
aguja se mueve al valor apropiado.
Slider (activa): Permite monitorizar y cambiar valores de slots numericos monovaluados,
indicando adems el mximo y mnimo valor. En los atributos de la imagen se establece el slot
asociado. Por defecto presenta valores reales. Si se desean valores enteros se debe ajustar el
parmetro interval de la imagen.
SingleListBox (activa): Pone el valor a un slot monovaluado
MultipleListBox (activa): Pone los valores a un slot multivaluado, marcando los valores.
CheckBoxGroup (activa): Permite monitorizar y cambiar valores de slots multivaluados, entre

un conjunto de posibles valores predefinidos. En los atributos de la imagen se establece el slot
asociado.
RadioButtonGroup (activa): Pone el valor a un slot monovaluado, marcando casillas.
CheckBox (activa): Pone el valor True/False al slot asociado
ComboBox1 (activa): elige de una lista el valor a un slot monovaluado
Se recomienda ver ms imgenes en la ayuda de KAPPA.

Para actualizar (refrescar) una imagen: Si una imagen no actualiza el slot del valor asociado:
UpdateImage (<Instancia-Imagen>); o bien
ResetImage (<Instancia-Imagen>);
donde la instancia de la imagen se puede identificar desde las propiedades de la imagen (Layout Mode).
Como ejemplo de un panel (Session) podemos ver la siguiente figura:
6.2.- Funciones de Interface.

Las funciones predefinidas de interface en KAPPA-PC interactan con la aplicacin mediante dilogos de
ventana. Sirven para:
Presentar informacin contenida en el sistema.
Obtener informacin del usuario y asignarla a slots.
Estas ventanas se sitan en mitad de la pantalla y requieren la inmediata atencin del usuario.
PostMessage: Presenta un mensaje simple al usuario
Esta funcin devuelve TRUE. Formato: PostMessage (string);
Ejemplos:
PostMessage ("Hola, como estas ?");
PostMessage ("El precio de la mesa es " # mesa:precio);
SetPostMessageTitle: Cambia el ttulo a una ventana de PostMessage
Formato: SetPostMessageTitle (string);
Sirve para modificar el ttulo de una ventana PostMessage, que por defecto es KAPPA. Para
cambiarlo hay que usar SetPostMessageTitle. Este ttulo aparecer en todos los mensajes
PostMessage siguientes hasta que se modifique o se reinicie KAPPA-PC.
Ejemplo:
SetPostMessageTitle (Resultados del proceso );
PostMessage ( .. );
AskValue: AskValue (object:slot) AskValue (object, slot);
Esta funcin se utiliza para solicitar informacin. AskValue utiliza el texto definido en el prompt del
slot. El texto por defecto es:
Please, enter the value of object:slot
Para cambiar este mensaje, hay que modificar la lnea de prompt del slot en el editor de slots.
Si se ha especificado un conjunto de valores permitidos (Allowable Values- Min Max), la funcin
AskValue ofrece esta lista de valores permitidos como opciones en la ventana de solicitud.
PostMenu: Es una funcion de interrogacion al usuario que da opciones de respuesta definida.
Permite presentar una lista de opciones por pantalla. Devuelve el valor seleccionado.
Formato: PostMenu (title, opcion1, , opcionN);
title es el texto que aparecer en la ventana del men.
option1, , optionN pueden ser valores explcitamente declarados o el valor de una variable
multicampo.
Slo se puede seleccionar una opcin y es el valor que devuelve la funcin PostMenu.
Se puede cambiar la posicin donde aparece el men, dndole las coordenadas sobre la pantalla.
SetPostMenuPosition (integer, integer);
PostMultipleSelection
Es igual que PostMenu pero permite seleccionar una lista de opciones de valores de slot.
Las opciones seleccionadas se almacenan como el valor de un slot multivaluado.
Formato:
PostMultipleSelection (title, object:slot, option1,..., optionN)
object:slot es un slot multivaluado donde se guardarn las opciones seleccionadas
option1, , optionN son las opciones que aparecen en el men

Ejemplo:
PostMultipleSelection ("Elige algunos colores ",
persona:colores, rojo, verde, azul);
PostMultipleSelection ("Elige algunos colores ",
persona:colores, Coches:posiblescolores);
PostInputForm: Ventana con formato para la introduccin de diversos datos.
Permite dar formato a una pantalla para la introduccin de datos. Esta funcin almacena los
valores que el usuario especifica en los mencionados slots. El formato es:
PostInputForm (form_title, object1:slot1, title1,
objectN:slotN, titleN);
PostInputForm ("Datos de la persona",
persona:nombre, "Nombre:",
persona:edad, "Edad: ",
persona:direccion, "Direccion:");
Si persona:nombre fuera un slot multicampo aparecera una barra donde se podra seleccionar el
nombre que se desea. Lo mismo si el slot edad tuviera un mnimo y un mximo.
Entrega-3: Interfaz
Realizar una interfaz que incluya:
1. Una imagen activa para los slots numpuertas, modelo, matricula, propietario y color del
Coche4
2. Una imagen pasiva para el slot edad de Luis y para el slot edad de Moto1
3. Un botn para hacer una inicializacin de la Base de Hechos (solo valores heredados). Utilizar la
funcin previamente descrita en este documento: Inicializacion de una base de hechos tras un
razonamiento).
4. Un botn para lanzar un encadenamiento hacia delante (por ejemplo el descrito en la Tarea 2.3).
5. Un botn para lanzar un encadenamiento hacia atrs, (por ejemplo el descrito en la Tarea 2.2)
Tras disear esta interfaz, comprobar su funcionamiento para inicializar y dar valores a la BH y
lanzar los dos tipos de razonamiento.
El botn de inicializacin debe inicializar la Base de Hechos.
Dar los valores iniciales (Coche4:puertas=4; Coche4:propietario=Luis;) y apretar el botn para
lanzar un encadenamiento hacia delante.
Apretar el botn para lanzar un encadenamiento hacia atrs (y calcular la edad de la Moto1).

KAPPA

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

KAPPA

Încărcat de

Drepturi de autor:

Formate disponibile

Tcnicas de Inteligencia Artificial

Escuela Tcnica Superior de INGENIERA INFORMTICA

1.- Introduccin. ................................................................................................................................ 1

1.1.- KAPPA-PC. Aspectos Generales.

Leng. Aplicacin: KAL

Tcnicas de Inteligencia Artificial. Prctica 1: Diseo, implementacin y evaluacin de un SBC - 1

1. Desarrollo orientado a objetos: los componentes de la aplicacin se representan como objetos.

1.2.- Inicio de KAPPA-PC: Ventanas de la aplicacin

2. Abrir Terminal (Aplicaciones/Herramientas/Terminal, o botn derecho abrir terminal))

Inicio desde Windows (16-32 bits)

Limitar nombres en ficheros e indentificativos a 8 caracteres.

Cuando se abre la aplicacin KAPPA-PC aparecen tres ventanas:

Object Browser: Para crear, mostrar y modificar objetos (frames).

Session: Para crear, mostrar y modificar la interface con el usuario.

Edit Tools: Editores para clases, instancias, funciones reglas y objetivos.

KAL Interpreter: Para introducir expresiones en lenguaje KAL (modo programado).

KAL View Debugger: Depuracin de cdigo KAL.

Find/ Replace: Busca y reemplaza cadenas de texto en la aplicacin.

KAPPA permite trabajar en dos posibles modos:

modo interactivo, a travs de la interface de mens y ratn,

modo programado, introduciendo los datos en el intrprete KAL.

2. Creacin de Clases, Subclases e Instancias. Slots.

2.1.- Creacin de clases.

2.2.- Creacin de instancias.

Tcnicas de Inteligencia Artificial. Prctica 1: Diseo, implementacin y evaluacin de un SBC - 3

2.3.- Creacin de slots.

2.5.- Propiedades de los slots: Facetas

Single: el slot slo puede tener un valor. Es la opcin por defecto.

Tcnicas de Inteligencia Artificial. Prctica 1: Diseo, implementacin y evaluacin de un SBC - 5

Editor de slots de KAPPA

Allowable Values Range

RESTRICCIONES SOBRE LA CLASE DE VALORES

De esta forma, introducimos los valores de slots indicados en la figura:

Estructura jerrquica y valores de los objetos

Introduccin Interactiva de Valores

Tcnicas de Inteligencia Artificial. Prctica 1: Diseo, implementacin y evaluacin de un SBC - 8

2.7.- Mtodos y Monitores.

2.7.1.- Mtodos y Mensajes. Programacin Orientada a Objetos.

Mediante el lenguaje KAL, se pueden utilizar funciones MakeMethod.

Un mtodo puede consistir de una o varias funciones KAL.

Existen tres variables predefinidas dentro de un mtodo:

Utilizacin de los mtodos.

newvalue: Nuevo/antiguo valor que se quiere introducir al valor

Ejemplo Monitor Before Change

Tcnicas de Inteligencia Artificial. Prctica 1: Diseo, implementacin y evaluacin de un SBC - 11

Tcnicas de Inteligencia Artificial. Prctica 1: Diseo, implementacin y evaluacin de un SBC - 12

3.- KAL: KAPPA-PC Application Language.

3.1.- Sintxis KAL

para acceder al color del coche1

GetInstanceList (Clase, Objeto:Slot);

Devuelve el valor del slot

SetValue (Objeto:Slot, valor); o bien SetValue (Objeto, Slot, valor);

Tcnicas de Inteligencia Artificial. Prctica 1: Diseo, implementacin y evaluacin de un SBC - 13

Expresiones infijas: para comprobar y modificar valores:

Operadores relacionales aritmeticos: <, >, <=, >=, == (igual?), != (distinto?)

Operador relacionales de strings: #=

=> coche1:propietario:nombre #= coche2:propietario:nombre;

=> Not(coche1:propietario:nombre #= coche2:propietario:nombre);

Operadores lgicos: And, Or, Xor

=> Not (TRUE);

For x [1 10] PostMessage (x);

Tcnicas de Inteligencia Artificial. Prctica 1: Diseo, implementacin y evaluacin de un SBC - 14

;no debe evaluarse a NULL y todos los

valores deben ser conocidos