KAPPA

Técnicas de Inteligencia Artificial Escuela Técnica Superior de INGENIERÍA INFORMÁTICA

PRÁCTICA 1 Diseño, Implementación y Evaluación de un Sistema Basado en el Conocimiento Departamento de Sistemas Informáticos y Computación- UPV

1.- Introducción. ................................................................................................................................ 1 1.1.- KAPPA-PC. Aspectos Generales............................................................................................ 1 1.2.- Inicio de KAPPA-PC: Ventanas de la aplicación ................................................................... 2 2. Creación de Clases, Subclases e Instancias. Slots....................................................................... 3 2.1.- Creación de clases................................................................................................................... 3 2.2.- Creación de instancias............................................................................................................. 3 2.3.- Creación de slots. .................................................................................................................... 4 2.5.- Propiedades de los slots: Facetas ............................................................................................ 5 2.6.- Herencia. ................................................................................................................................. 8 2.7.- Métodos y Monitores. ............................................................................................................. 9 2.7.1.- Métodos y Mensajes. Programación Orientada a Objetos. .............................................. 9 2.7.2.- Monitores. ...................................................................................................................... 11 3.- KAL: KAPPA-PC Application Language. .............................................................................. 13 3.1.- Sintáxis KAL ........................................................................................................................ 13 3.2.- Funciones. ............................................................................................................................. 16 Entrega-1: objetos, métodos. .......................................................................................................... 18 4.- Creación 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 atrás (Backward chaining) ................................................................... 23 5.3.- Traza y depuración 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 Sesión................................................................................................................. 31 6.2.- Funciones de Interface. ......................................................................................................... 34 Entrega-3: Interfaz.......................................................................................................................... 35

1.- Introducción. El objetivo de esta práctica es aplicar las técnicas y metodologías de la Ingeniería del Conocimiento en el diseño y construcción de un prototipo de Sistema Basados en el Conocimiento (Sistema Experto), para aplicar los conocimientos sobre representación del conocimiento, razonamiento basado en reglas, inferencia y control. Adicionalmente, esta práctica permitirá conocer un entorno de desarrollo de Sistemas Basados en el Conocimiento (KAPPA-PC). Las etapas de la práctica son: 1.- Conocimiento del entorno de desarrollo de Sistemas Basados en el Conocimiento (KAPPA). a) Representación conocimiento: frames, herencia, métodos, monitores y objetos. Lenguaje KAL. b) Reglas en kappa-pc c) Inferencia: Razonamiento hacia delante, hacia atrás. Control Inferencial. d) Interfaz gráfica de usuario 2.- Diseño, Implementación y evaluación de un Sistema Basado en el Conocimiento (SBC) En este documento, se describen las principales funcionalidades de KAPPA-PC que serán desarrolladas en sucesivas sesiones de prácticas. 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 evaluación principal de la práctica). Además de la información contenida en este documento, se recomienda acceder a la ayuda interna contenida en el propio entorno KAPPA-PC. Para cualquier consulta adicional sobre una característica concreta de KAPPA existe un manual "on-line" en la misma carpeta Esta ayuda se puede activar pulsando la opción 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 público) 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 emulación de Windows en linux, y sus principales características y componentes son:

Objetos Reglas

KAPPA-PC

Gráficos

Leng. Aplicación: KAL Interfaz Desarrollo

Explicación Interfaz Usuario

Librería Funciones

Help

Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 1

1. Desarrollo orientado a objetos: los componentes de la aplicación se representan como objetos. Los procesos de la aplicación se representan mediante métodos y monitores. 2. El lenguaje de KAPPA-PC se llama KAL y permite trabajar a un alto nivel de abstracción. 3. Sistemas de representación del conocimiento basado en reglas. 4. Posibilidad de hacer inferencias hacia delante y hacia atrás. Mecanismos de control. 5. Entorno gráfico, con facilidades de edición. 6. Herramientas de depuración y traza. Acceso y actualización de datos externos.

1.2.- Inicio de KAPPA-PC: Ventanas de la aplicación a) Inicio desde emulación de Windows en linux: 1. Abrir sesión en Linux (en la primera sesión, la contraseña es el DNI (sin letra). Los extranjeros tienen un código identificativo que si lleva letra del estilo X5567322. La primera vez que inicien sesión el sistema pide el cambio de la contraseña y se reinicia la sesión del usuario con la nueva contraseña.)

2. Abrir Terminal (Aplicaciones/Herramientas/Terminal, o botón 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. También 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 reiteración causará errores de teclado. Kappa es sensible a mayúsculas y minúsculas

Cuando se abre la aplicación KAPPA-PC aparecen tres ventanas: - Main KAPPA Window

- Object Browser

- EditTools window.

Todas las ventanas siguen los standards de Windows para abrir, cerrar, generar tamaño máximo, etc.

Main KAPPA Window muestra los iconos de las otras 7 herramientas existentes: Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 2

•

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: Depuración de código KAL.

•

Find/ Replace: Busca y reemplaza cadenas de texto en la aplicación.

•

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 través de la interface de menús y ratón,

•

modo programado, introduciendo los datos en el intérprete KAL.

Dado que el modo interactivo es más rápido para estudiar los distintos tópicos de KAPPA-PC, seguiremos este método a partir de ahora.

2. Creación de Clases, Subclases e Instancias. Slots. En KAPPA, los objetos se definen como clases o instancias. Las clases siempre representan objetos más generales, un grupo o colección de objetos. Una instancia es un objeto específico. Supongamos que queremos representar información sobre vehículos y queremos asignarlos a una de las dos categorías: Coches o Motos. También queremos representar información sobre personas. Crearemos una clase "Vehiculos" con dos subclases "Coches" y "Motos", y una clase “Personas”. Además, tenemos información 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.- Creación de clases. 1. En la ventana Object Browser, ponerse sobre Root y activar "Add Subclass" desde la opción "Edit" del menú. 2. Introducir "Vehiculos" como nombre de la clase. 3. Situarse sobre la clase "Vehiculos" y repetir la operación anterior para crear las subclases "Coches" y "Motos". Cread también la clase “Personas”. 4. Para salvar la nueva configuración, escoger la opción "Save as ..." de la opción File del menú de la ventana principal de KAPPA. Esta opción puede realizarse en cualquier momento a lo largo del desarrollo del ejemplo. En la ventana Object Browser veremos la nueva jerarquía 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 mayúsculas y minúsculas a la hora de escribir los nombres de las funciones, slots, clases y valores. Los identificadores deben limitarse a 8 caracteres.

2.2.- Creación de instancias. Crearemos 2 instancias de la clase "Coches" y una instancia de la clase “Motos”. También creamos la instancia “Pepe”.


1. En la ventana Object Browser, situarse sobre la clase "Coches" y seleccionar "Add instance" desde la opción "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 línea discontinua:

Nota: Los nombres de las clases e instancias son únicos en toda la jerarquía y no pueden repetirse. Es habitual indicar el nombre de las instancias en singular y las clases en plural.

2.3.- Creación de slots. Los slots se utilizan para describir características específicas de los objetos. En general, se definen en las clases y toman valor en las clases (se heredarían a todas las instancias) o en la instancias. Supongamos que las propiedades que definen a los Vehiculos son la 'matrícula', 'propietario', 'modelo’, ‘tipo’ y ‘color’. Particularmente, para los Coches nos interesa saber además el 'número de puertas'. Para las Personas conoceremos su ‘nombre’, ‘apellidos’, ‘dirección’ 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 opción "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 opción "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’. También debemos crear el slot 'número de puertas' en la clase ‘Coches’. Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 4

Al crear los slots en la clase ‘Vehiculos’, podemos comprobar que se han heredado automáticamente a las subclases e instancias inferiores en la jerarquía. Los asteriscos (*) que aparecen al lado del nombre del slot significan que dichos slots se han heredado de la jerarquía 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 términos 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 más de un valor. Los posibles valores para esta opción de slot son: -

•

Single: el slot sólo puede tener un valor. Es la opción 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: número 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 numérico se puede especificar un rango para los valores que puede tomar el slot, delimitando el valor mínimo y máximo.

•

Tipo Boolean: los límites 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 jerarquía. 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 caracterización de los slots: Slot matrícula

TEXT

Value Type

modelo numpuertas color propietario edad tipo

TEXT NUMBER TEXT OBJECT NUMBER TEXT

Allowable Values ó Range (se podría especificar un conjunto de matrículas) Min Value: 2 Max Value: 5 (se podría especificar un conjunto de colores) Personas

Nota: La especificación 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. Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 6

RESTRICCIONES SOBRE LA CLASE DE VALORES

Las restricciones sobre la clase de valores en Kappa no tienen efecto automático 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 edición, por la interfaz interactiva de desarrollo: NO se limita el valor del slot y no se produce ningún mensaje de aviso. b) En la asignación de valores mediante expresiones KAL (utilizadas habitualmente aplicación de reglas en el proceso inferencial) se puede limitar mediante un monitor (Ver: Monitor tipo Before Change). En la introducción de valores en la interfaz gráfica 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) Imágenes 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 opción "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 locomoción color

* matricula * propietario * modelo * tipo *locomoción * color numpuertas

Motos

Coche2 * matricula V-5544-CL * propietario Pepe * modelo SEAT * tipo * locomocion * color rojo * numpuertas 3

Moto1

* matricula * propietario * modelo * tipo *locomoción * color

Estructura jerárquica y valores de los objetos Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 7

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 expresión KAL: Coche2:propietario: edad; podemos obtener la ‘edad’ del ‘propietario’ del ‘Coche1’.

Introducción Interactiva de Valores Como hemos visto, la introducción de valores de slots puede hacerse ‘editando’ el slot. También 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 básicas: 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 gráfica 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 opción '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 (excepción 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 sería 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 botón (*) situado en el campo "Value" del slot determinado y todas las instancias y subclases dependientes volverán a tomar el correspondiente valor heredado.


2.7.- Métodos y Monitores. Los métodos y monitores son funciones que realizan tareas concretas: •

Métodos: medio para definir un comportamiento de las clases o instancias que existan.

•

Monitores: tipo especial de método que se activan automáticamente cuando se accede al slot de un objeto. Por ejemplo, podemos querer que se realicen ciertas tareas automáticamente cuando se modifica el slot (en respuesta a ciertos datos), cuando se accede a él, etc.

2.7.1.- Métodos y Mensajes. Programación 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 básicos de información: a) información que describe las características del objeto (slots y propiedades de slots). b) información que especifica lo que el objeto puede hacer (su comportamiento): Métodos. Cada acción que puede realizar un objeto se representa mediante un MÉTODO. Los métodos son procedimientos que se representan como atributos de los objetos. Al proceso de activar un método en un objeto particular se le denomina PASO O ENVÍO DE MENSAJE. Cuando un objeto recibe un mensaje que se corresponde con uno de sus métodos, dicho método se activa y el objeto ejecuta el procedimiento asociado a dicho método. Típicamente, los métodos emplean uno o más valores de slots del objeto a medida que se va ejecutando el procedimiento.

Edición de Métodos. En general, lo más cómodo es utilizar el editor de métodos para crear y editar los métodos: 1. Selecciona la clase a la cual se quiere definir el método. 2. Selecciona New desde el menú de Métodos. 3. Escribe el nombre del método en el campo Name. El editor de métodos aparecerá automáticamente. 4. Si el método requiere algún argumento, escribirlo en la ventana Arguments. 5. Escribe el cuerpo del procedimiento en la ventana Body. 6. Selecciona el comando Check Syntax desde la opción Update del menú (o presiona F2) para comprobar si la sintáxis del método es correcta. Por ejemplo, si tuviéramos un slot ‘compra’ en la clase Vehiculos que indicara el año de compra y un slot ‘edad’ que indicara la edad del vehiculo (ambos slots deben ser de tipo ‘Number’), podríamos definir el siguiente método para calcular la edad de cada vehiculo a partir de su año de compra:

De esta forma, si Coche1:compra es 2001, la siguiente llamada al mensaje calcularía pondría el valor al slot Coche1:edad=9. Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 9

Mediante el lenguaje KAL, se pueden utilizar funciones MakeMethod. MakeMethod (objName, methodName, [arg1 arg2 …], bodyExp) La expresión para mandar un mensaje al método existente en un objeto es: SendMessage (objName, methodName, x, y, …) Donde x, y, … son los argumentos específicos del método que se activa

Un método puede consistir de una o varias funciones KAL. En caso de varias funciones, deben ir todas encerradas entre {} { expresión1;

expresion2;

…….

expresionN};

Existen tres variables predefinidas dentro de un método: - Self: es una variable que representa el objeto que recibe el mensaje. Como los métodos 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 método. - TheParent: es la variable que hace referencia al padre del objeto. - TheOwner: objeto (clase o instancia) donde se ha definido. Los métodos pueden ser heredados, al igual que los slots. Se puede anular el comportamiento heredado de un objeto y hacer un método local al mismo. Para hacer un método local: 1. Abrir el Editor de Clases o Instancias para el objeto en el cual quiere definirse el método. 2. Seleccionar el método que se desea hacer local. 3. Seleccionar MakeLocal desde el menú de Métodos. Una vez que el método es local, el asterisco (*) desaparece.

Utilización de los métodos. Los métodos sirven para realizar distintas tareas, fundamentalmente: Asignar valores a otros slots del mismo objeto. Para cualquier modificación 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 continuación se muestra un ejemplo de un método INIT para inicialización de instancias. Este método, 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 ("Inicialización Completa"); } ); Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 10

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 definición de la clase). La función 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 método se ejecuta automáticamente cuando se solicita el valor del slot y no existe valor para dicho slot. El método toma como argumento el nombre del slot. When Accessed: El método se ejecuta cuando se accede al slot. La diferencia de este método 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 crearía un bucle infinito Before Change: El método se ejecuta automáticamente 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 método Before Change puede utilizarse para darle al usuario la opción de cancelar el valor que pretende asignarle al slot si entra en conflicto con su clase de valores.. After Change: El método se ejecuta automáticamente justo después de asignarle un nuevo valor al slot y toma como argumentos el nombre del slot y el antiguo valor del mismo. Un método After Change se podría utilizar para forzar el cálculo de otro slot. En los métodos 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 mínima de estas personas sea 18 años. Para ello, ponemos el slot 'edad' de tipo NUMBER y un Min. Value de 18. Además queremos especificar un método que impida introducir edades de personas menores de 18 años. Para ello hacemos lo siguiente: - Abrimos la clase Personas - Seleccionamos Methods / New desde el menú. Le damos nombre al método. - 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 método. Aparecerá en la lista de métodos de la clase. Ahora ya tenemos un método definido para la clase "Personas". Para convertir dicho método en un monitor asociado a un slot, se debe hacer: - Abrimos el slot edad - Especificamos el método como monitor Before Change del slot edad - Grabamos y cerramos

Ahora: o si introducimos la expresión KAL “Pepe:edad=10;” obtendremos una ventana de aviso y el valor no se actualizará. o si introducimos la expresión “Pepe:edad=30;” el valor del slot se actualizará con dicho valor.

NOTA: Los métodos solo pueden tener una expresión KAL la cual debe ser finalizada por ; Para poder poner más de una expresión, debe ir enmarcada entre llaves: {expresion1; expresion2; ………….. expresiónN }; Esto también 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 métodos y monitores sólo se activan cuando las modificaciones se hacen en modo programado (leguaje KAL) o durante la ejecución 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, métodos y funciones de KAPPA-PC. A través de dicho lenguaje se puede añadir, modificar, interrogar o eliminar información de la base de conocimientos. KAL permite: Realizar muchas de las operaciones explicadas anteriormente (creación de clases, subclases, slots, instancias, definición de valores de slots …) en modo "programado" en vez de "interactivo". Añadir nueva información a la base de conocimientos. Esta funcionalidad permite crear un nuevo objeto, añadir un valor a un slot o crear un enlance entre dos objetos. Borrar información de la base de conocimientos. Se puede borrar un valor de un slot o un enlance existente entre dos objetos. Realizar preguntas sobre qué información 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 están almacenados en la base de conocimientos. KAPPA proporciona un mecanismo para definir expresiones, similares a un lenguaje de programación clásica. Las expresiones deben seguir el formato del lenguaje KAL y serán evaluadas directamente por el intérprete 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 mayúsculas y minúsculas a la hora de escribir los nombres de las funciones, slots, clases y valores.

3.1.- Sintáxis KAL Expresiones Básicas: Pares : Coche1: color; coche1:propietario:edad; Pepe:edad;

para acceder al color del coche1 para acceder a la edad del propietario del coche1 devolvería 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: Asignación 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 año más Operadores aritméticos: +, -, *, /, ^ Ejemplos: => 5+2; 7

=> 5 ^2; 25

Operadores relacionales aritmeticos: <, >, <=, >=, == (igual?), != (distinto?) Cualquier operación con dichos operadores devolverá TRUE/FALSE. Operador para concatenación de texto: # Ejemplo:

=> coche#4;

devolvería 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 condición sobre desigualdad de texto hay que utilizar not() Ejemplo:

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

Operadores lógicos: And, Or, Xor Ejemplo: => 33 < 55 And coche2:color #= rojo;

devuelve: TRUE

"Not" no es realmente un operador lógico sino una función. Por tanto su argumento debe ir encerrado entre paréntesis. 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 condición 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 añadir un objeto o activar un método se puede hacer de forma rápida y eficiente con las funciones de KAPPA. KAPPA proporciona unas 300 funciones predefenidas de las cuales existe un manual on-line en la opción "Help" que aparece en la "Main KAPPA Window". Se pueden usar estas funciones para definir expresiones, otras funciones o combinar funciones standard. Definición 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 métodos que se definan en las clases o instancias.

•

Asociadas a imágenes (botones, etc.).

La librería de funciones que provee KAPPA permite realizar distintas operaciones: crear, acceder y modificar la base de conocimiento. evaluar expresiones matemáticas, lógicas y de cadenas de caracteres. manipular listas, ficheros, bases de datos ... controlar el procesamiento del conocimiento y el interface gráfico. Sintáxis general de una función. 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 expresión es equivalente a Coche2:color = rojo; GetParent (Coche1); Encuentra el padre de Coche1. LengthList (Coche2:color); Devolvería 1. (si 'color' fuera un slot multivaluado). AppendToList (Coche2:color, verde); Devolvería LIST:rojo verde. Para ello el slot 'color' de la clase Coche debería ser multivaluado. (cardinalidad múltiple). Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 16

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)); Función definida por el usuario. Para utilizar dicha función hacer la llamada cuadrado(5) y devolvería 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 método, es útil poner: PostMessage ("El color del Coche de Pepe es " #Self:color); También 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 patrón. aList: valor lista de un slot multicampo o cualquier otra expresión que se evalúe 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 función SelectList nos devolverá la primera asignatura de la lista que cumpla el requisito. => SelectList (Pepe:asignaturas, x, x:Aula #= Aula21); EnumList (aList, item, action); Juanlúa la expresión que viene representada por el parámetro '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, métodos. Entregar el código correspondiente. a) Implementar la información descrita en los puntos anteriores, incluyendo valores en los atributos de las instancias: Personas (instancias Pepe, Juan, Maria.): • Nombre • Edad Coches y Motos son Vehículos Coches (instancias: Coche1, Coche2, Coche3.) • Matrícula • Modelo • Puertas • Color • Propietario

Motos (instancias: Moto1, Moto2) • Matrícula • Modelo • Edad • Color • Propietario

Y particularmente, incluir valores para los slots de las instancias creadas. Por ejemplo: • •

"Juan es el dueño del coche3", "Pepe es el dueño del coche1 y coche 2", "María es la dueña de las motos moto-1 y moto-2", etc….

b) Sobre la estructura anterior implementar las expresiones, funciones o métodos para: 1. Devuelve en una ventana el color del coche1 y su número de puertas. Utiliza PostMessage 2. Devuelve en una ventana el color del coche1 y de la moto2. Utiliza PostMessage 3. Devuelve la matrícula de todas las motos. Utiliza ForAll 4. Devuelve la Edad del propietario/s de la moto 1 si su nombre es María 5. Devuelve el color de los coches con más 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 años. d) Hacer un valor activo que avise si la edad de un coche es mayor que la de su dueño.

IMPORTANTE Al finalizar el punto c y d, eliminad la asociación de los monitores introducidos


4.- Creación de Reglas. Al desarrollar una aplicación en KAPPA-PC se pueden utilizar los tres paradigmas de programación que ofrece esta herramienta (programación orientada a objetos, razonamiento basado en reglas, programación tradicional) o una combinación 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 ajustarán a la representación del conocimiento utilizada hasta ahora:

Con los siguientes valores iniciales: Slot Vehiculos matrícula modelo color propietario añocompra 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 continuación 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 convención, el nombre de una variable se pone en minúscula aunque no es necesario. En cada instancia de regla, la variable ‘coche’ se instancia sobre una instancia de la clase COCHES. Múltiples Patrones en las reglas En general, se pueden poner múltiples patrones en las reglas, separados por espacios: Var1|clase1 Var2|clase2 …. Var-n|Clase-n Pero, los patrones múltiples solo son soportados en un encadenamiento hacia delante. Hacia atrás, solo se puede poner UN PATRÓN.

•

Priority: La prioridad de una regla también 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, agrupándolas mediante {}: { expresion1; expresion2; -------expresionN};

Ojo!: No separar con And!

Después 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 algún valor desconocido. Las reglas también se pueden crear alternativamente desde el intérprete KAL: => MakeRule (Regla1, [Coche|Coches] , Coche: bateria #= cargada And Coche:bujias #= ok, Coche:estado = bien); Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 20

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 básicos en un sistema basado en reglas: Hacia delante (Forward chaining): Actúa 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 atrás (Backward chaining): Actúa desde la conclusión 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 conclusión unifique con la pregunta u objetivo (goal) que se está buscando. Por ejemplo, con los datos actuales y la Regla1 y Regla3, podríamos preguntar al sistema el propietario del Coche1 (goal). El sistema podría obtenerlo con los datos disponibles y deducir que es Juan. Alternativamente, si preguntamos el propietario del Coche2 (goal), el sistema podría obtenerlo tras preguntarnos la situación de las bujías (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 efectuaría un razonamiento de tipo event-driven, que se lanzaría a partir de un nuevo dato “Assert (,)” que desencadenaría 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 están involucradas en el encadenamiento hacia delante. Hay que indicar explícitamente una clase de reglas o bien una lista de reglas: Regla1, Regla2, …. Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 21

Clases de Reglas En KAPPA-PC hay que especificar explícitamente 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 más 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 más de un conjunto de reglas. Posteriormente se pueden invocar los distintos grupos de reglas en un encadenamiento hacia delante o hacia atrás. Por ejemplo, si el slot de la instancia Global donde se han agrupado un conjunto de reglas se llama ReglasCoche, se podría 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) Después, volver a la base de hechos inicial (puede usarse una función específica).

Inicializacion de una base de hechos tras un razonamiento No hay una función global de inicialización de toda la BH una vez se ha hecho un razonamiento. Un método habitual es eliminar las instancias del problema: Al volverlas a crear todos los slots quedarán con el valor por defecto (heredado). Las clases suelen quedarse (información del dominio) Alternativamente, el siguiente método 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 función 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 atrás (Backward chaining) La llamada a un proceso de razonamiento backward es mediante la función KAL: BackwardChain ([NOASK], goalName, ) 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 están involucradas en el encadenamiento hacia atrás. Hay que indicar explícitamente 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:

(preferentemente), o

No se pueden establecer objetivos de la forma objeto:objeto:slot. Tampoco se puede realizar un encadenamiento hacia atrás a través de dichas expresiones en las reglas (si funcionaría 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 conclusión de las mismas aparezca el par 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 atrás 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 atrás, solo pueden tener UN PATRÓN. Una forma de poner varios patrones hacia atrás es mediante la funcion IsThereAny?: Regla: Patrón: 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 patrón 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-patrón 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). Después 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 atrás. Son obligatorios para desencadenar un razonamiento hacia atrás pero también se pueden emplear para Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 23

detener un proceso de razonamiento hacia delante en un punto específico. 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 opción "Ask Value if NULL in Backward Chaining".

•

No se ha establecido la opción 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 atrás Consideremos el objetivo:

También podríamos haber hecho una pregunta más concreta, por ejemplo: “Coche2:propietario #= Juan” Al lanzar un razonamiento hacia atrás 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 conclusión se unifica con el patrón '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 también 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 atrás 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 depuración del proceso inferencial. KAPPA-PC ofrece diversas utilidades gráficas para facilitar el control y depuración 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 aparecerán 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 conclusión 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.

o

List Slots: Lista los slots que tienen en común la regla seleccionada y la regla dependiente (en la parte Then).

Traceado de Reglas: Rule Trace Window El icono de esta utilidad también 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 atrás. En dicha traza se puede ver cómo el sistema genera nuevas conclusiones, los posibles errores que existen en la base de conocimientos de nuestra aplicación 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. (También 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 aplicación

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

BackwardChain ([NOASK], goalName, ) Por ejemplo: BackwardChain (Goal1, Rule2, Rule3, etc.); EJEMPLO: Para lanzar un encadenamiento hacia delante con la Regla1:

A continuación 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 menús de la ventana: Menú Control: •

Start: esta opción permite llamar a una función definida por el usuario que se llame Start. Esta función podría emplearse, por ejemplo, para iniciar el proceso de razonamiento.

•

Assert …: esta opción llama a la función Assert del lenguaje KAL. Se puede por tanto insertar un dato directamente desde la ventana de trazas en lugar de tener que ir al intérprete KAL.

•

SetForwardChainMode …: Este item permite seleccionar el control del encadenamiento hacia delante Es equivalente a utilizar la función KAL SetForwardChainMode.

•

ForwardChain …: Esta opción inicia el encadenamiento hacia delante llamando a la función KAL ForwardChain.

•

BackwardChain…: Esta opción inicia el encadenamiento hacia atrás llamando a la función KAL BachwardChain.

•

ResetForwardChain: Esta opción vacía la Agenda y la Rule List. Es equivalente a una llamada a la función KAL ResetForwardChain.

•

Call Function…: Esta opción permite llamar a cualquier función KAL definida por el usuario.

•

Explain: Carga la utilidad Explain de KAPPA-PC.

Menú Options: •

Active Trace: Esta opción permite ver la Agenda y la Rule List durante el encadenamiento hacia delante. Cualquier par que se inserte se listará en la ventana de la Agenda. Cuando se inicia el encadenamiento hacia delante, los pares se van añadiendo 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 sólo se puede seleccionar si previamente se ha activado Active Trace. Step Mode funciona automáticamente con ForwardChain. IMPORTANTE: Para que se active el Step Mode, hay que hacer un Assert específico, o se debe seleccionar [NOASSERT] en el ForwardChain. Después de especificar los argumentos de ForwardChain, el botón 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 gráfica las reglas que el motor de inferencia va invocando, pudiendo comprobar como el sistema infiere las conclusiones y examinando las líneas de razonamiento. Por ejemplo, lanzando esta ventana con la Base de Hechos inicial y el encadenamiento hacia atrás: 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 mostraría 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 función 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 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 versión más 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 búsqueda 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 ), 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 continúa hasta que no hay más 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 más eficiente porque sólo sigue una única línea 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 añaden 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 aplicación de una regla no lanzan nuevas reglas, el proceso de encadenamiento se para. DEPTHFIRST: Las nuevas reglas 'relevantes' se añaden al principio de la Rule List de acuerdo a su prioridad. No borra la Rule List después de encontrar una regla que se cumple. BREADTHFIRST: Las nuevas reglas 'relevantes' se añaden al final de la Rule List, de acuerdo a su prioridad. No borra la Rule List después 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 después de encontrar una regla que se cumple. Estas estrategias pueden establecerse en la ventana RuleTrace, o mediante la función: 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 código correspondiente. 1) Añadir las siguientes reglas a las ya creadas:

Regla-4) Todos los coches de 4 puertas son de color blanco Regla-5) Todos los dueños de coches blancos tienen 30 años. Regla-6) Todos los coches blancos son del modelo ‘turismo’. Regla-7) Todas las motos cuyo modelo es ‘sidecar’ tienen una edad de 20 años 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 años.

2) Aplicación Backward: A partir de una BH con al menos una nueva instancia de motos (sin ningún 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) Aplicación 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 método 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 número de puertas de un coche para lanzar el razonamiento forwardchain anterior.

Al finalizar el punto 4, eliminad la asociación del monitor introducida


6.- Interfaz de usuario en KAPPA-PC: Session Las herramienta “Session” de Kappa permite crear la interfaz gráfica de usuario. La interfaz de usuario consta de diversas ventanas (sessions). En cada una de ellas pueden aparecer imágenes gráficas que muestran el estado de la base de conocimientos, así como pueden interacturar (modificar) con ella, mediante la activación de funciones que modifican valores de slots, lanzan razonamientos, etc. Las diferentes sesiones que pueden haber en una determinada aplicación se visualizan/ocultan por medio de una función específica, que muestra/oculta una u otra ventana (session): ShowWindow(SessionN, NORESET); HideWindow (SessionN); Estas funciones pueden lanzarse interactivamente o automáticamente (en métodos, parte derecha de reglas, etc.) según como esté el proceso.

6.1.- Ventana de Sesión La Ventana de la Sesión es una interfaz donde se crean imágenes que permiten actuar interactivamente con la base de conocimiento. Se pueden tener múltiples ventanas de Sesión, cada una sirve un propósito específico. Se activan mediante la herramienta 'Session'. Cada Ventana de Sesión tiene dos modos principales ('Options'): •

Layout Mode: En este modo se crean las imágenes y se conectan a la aplicación. Pueden crearse, revisarse, moverse, y redimensionarse las imágenes en este modo. A la izquierda de la ventana aparecen un conjunto predefinido de imagenes

•

Modo Runtime: En el Modo Runtime se usan las imágenes que ya se han creado. Es el modo por defecto y de uso de la interfaz gráfica de KAPPA-PC.

Pueden crearse Sesiones Múltiples (máximo 64) y cada una se edita separadamente. La sesion principal es 'SESSION' y las demás van numeradas 'SessionN'. Cada ventana de Sesión son objetos (instancias) en KAPPA-PC y están en la jerarquía 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. Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 31

El menú de 'Window' en un Ventana Session tiene las opciones principales siguientes: •

New: Permite crear nuevas ventanas de la Sesión. Cada nueva ventana de la Sesión se numera automáticamente. Se debe estar en el Modo del Esquema para usar esta opción.

•

Delete: Permite anular la ventana de la Sesión actualmente activa (y todos los objetos que la ventana contiene). Se debe estar en el Modo del Esquema usar esta opción.

•

Hide / Unhide: Muestra y oculta sesiones.

•

Attribute. Permite caracterizar la sesión o las imágenes contenidas en esa sesión (se debe estar en el Modo del Esquema). También se activa pulsando doble en la ventana de la Sesión o en una imagen y permite: •

Asignar un Título a la Ventana/Imagen.

•

Asignar una Función de Acción a la imagen (por ejemplo, si es un boton). Debe haberse definido previamente una función global (EditTools: Function) que se puede asociar a la imagen y se activará cuando se hace un clic del ratón izquierdo. Asignación de la función: Indicar su nombre en la ventana 'Action' que aparece. Tambien se puede asignar una tecla de funcion, que hace lo mismo que click izquierdo.

•

También se pueden editar otras caracteristicas de la imagen o ventana 'session', accediendo a la instancia que la representa (tamaño, color, función para botón derecho del raton, etc.)

Inserción de imágenes en una ventana Session. Para la inserción y/o modificacion de imágenes de na ventana Session se debe esatr en el modo layout. En dicho modo se pueden insertar en el panel las imágenes prediseñadas de Kappa. Asimismo, se pueden parametrizar las imágenes ya existentes en el panel. Las posibles imágenes predefinidas se clasifican en: Imágenes pasivas: Visualizan solo información de la aplicación. Imágenes activas. Permiten interactuar con la aplicación: modificar valores, lanzar funciones, procesos de razonamiento, etc. Las imágenes prediseñadas principales son: Botón (activa): Si el usuario pulsa el botón del ratón izquierdo en la imagen se llama una función asociada con el botón. En los atributos de la imagen se establece la función 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 prediseñada (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 numérico de un slot de tipo Number monovaluado, mientras una aplicación está corriendo. Se asocia el slot que debe presentar el valor, así como se pueden indicar los límites máximo y mínimo. 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 además el máximo y mínimo 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 parámetro ‘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 más imágenes en la ayuda de KAPPA. Para actualizar (refrescar) una imagen: Si una imagen no actualiza el slot del valor asociado: UpdateImage (); o bien ResetImage (); 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 interactúan con la aplicación mediante diálogos de ventana. Sirven para: •

Presentar información contenida en el sistema.

•

Obtener información del usuario y asignarla a slots.

Estas ventanas se sitúan en mitad de la pantalla y requieren la inmediata atención del usuario. PostMessage: Presenta un mensaje simple al usuario Esta función devuelve TRUE. Formato: PostMessage (string); Ejemplos: PostMessage ("Hola, ¿ como estas ?"); PostMessage ("El precio de la mesa es " # mesa:precio); SetPostMessageTitle: Cambia el título a una ventana de PostMessage Formato: SetPostMessageTitle (string); Sirve para modificar el título de una ventana PostMessage, que por defecto es KAPPA. Para cambiarlo hay que usar SetPostMessageTitle. Este título 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 función se utiliza para solicitar información. 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 línea de prompt del slot en el editor de slots. Si se ha especificado un conjunto de valores permitidos (Allowable Values- Min Max), la función 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 explícitamente declarados o el valor de una variable multicampo. Sólo se puede seleccionar una opción y es el valor que devuelve la función PostMenu. Se puede cambiar la posición donde aparece el menú, dándole 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 guardarán las opciones seleccionadas Técnicas de Inteligencia Artificial. Práctica 1: Diseño, implementación y evaluación de un SBC - 34

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 introducción de diversos datos. Permite dar formato a una pantalla para la introducción de datos. Esta función 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 aparecería una barra donde se podría seleccionar el nombre que se desea. Lo mismo si el slot edad tuviera un mínimo y un máximo.

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 botón para hacer una inicialización de la Base de Hechos (solo valores heredados). Utilizar la función previamente descrita en este documento: “Inicializacion de una base de hechos tras un razonamiento”). 4. Un botón para lanzar un encadenamiento hacia delante (por ejemplo el descrito en la Tarea 2.3). 5. Un botón para lanzar un encadenamiento hacia atrás, (por ejemplo el descrito en la Tarea 2.2) Tras diseñar esta interfaz, comprobar su funcionamiento para inicializar y dar valores a la BH y lanzar los dos tipos de razonamiento.

•

El botón de inicialización debe inicializar la Base de Hechos.

•

Dar los valores iniciales (Coche4:puertas=4; Coche4:propietario=Luis;) y apretar el botón para

lanzar un encadenamiento hacia delante.

•

Apretar el botón para lanzar un encadenamiento hacia atrás (y calcular la edad de la Moto1).


KAPPA

Recommend Documents