Y ademásProgramación orientada al acceso
¿Como se consigue la funcionalidad de los facets?Invocaciones procedurales declarativas
Proporciona un mecanismo que permite a las funciones definidas por el usuario manipular los valores de los slots cuando son necesarios, y chequear restricciones.
Procedimientos IF-NEEDED, IF-ADDED, …
demons
(Gp:) se disparan al acceder a los slots
(Gp:) al leer
(Gp:) al sustituir
(Gp:) al borrar
(Gp:) al añadir
Comparación con el Paradigma orientado a objeto
OBJETOS Y ESPECIALIZACION (Definición de clases)
=
Clases + Instancias + Atributos
+
Relaciones, herencia
+
Razonamiento por defecto, por herencia (evita herencia múltiple)
ENCAPSULACION (Definición de tipos, interface)
=
Estructuras de datos ocultas
+
Implementación Operaciones ocultas
+
Acceso exclusivo por envío de mensajes
Implementaciones de frames
Pronto se dearrollaron algunas implementaciones de la teoría de frames. Uno de los primeros, un lenguaje llamado FRL (Frame Representation Language), fué desarrollado por Roberts y Goldstein del MIT.
Implementaciones más recientes de frames:
KLONE, KRL, SRL, CRL
units (KEE)
objects (LOOPS)
schemata (Knowledge Craft)
CLOS (Common Lisp Objects), fuertemente influenciado por las ideas de los lenguajes de frames.
CLIPS, fuertemente inspirado en CLOS y en los lenguajes orientados a objeto.
Conclusiones sobre frames
Ventajas
Incluye provisión para la asociación de conocimiento procedural con el conocimiento declarativo almacenado como valores de slots (esto permite permite expresar conocimiento más allá del puramente lógico)
Estructura de control flexible; el comportamiento de FRL es facil de extender
Desventajas
Conduce a una frágil teoría de la representación; hace difícil la especificación de la "corrección" del sistema.
Evolución de los lenguajes basados en frames
Frames: Representación del conocimiento directamente en terminos de grafos. Se definen los frames (que representan clases o instancias) y se relacionan entre ellos. Los frames se definen directamente en terminos de un conjunto de propiedades (slots) y propiedades (facets).
Description Logics (inspirados en KLONE) es una familia de lenguajes que formalmente expresan ciertas restricciones sobre la representación del conocimiento. Tienen una semántica precisa y se puede automatizar su procesamiento. Description logics comienza con conceptos primitivos y sigue con la definición de conceptos en términos de descripciones formales. La Subsumption, esto es la jerarquía de especialización entre conceptos, se puede determinar de la descripción de los conceptos.
Description logic determina si un concepto es redundante o está relacionado con otros conceptos.
Integración de paradigmas
Selección de formalismo para representar conocimientos del dominio
Redes semánticas y Frames, para representar el conocimiento profundo del dominio (los mecanismos)
Permiten construir taxonomías de conceptos por especialización de conceptos generales en conceptos más específicos
La herencia permite compartir propiedades y evita la presencia de conocimiento redundante.
Las propiedades se pueden representar de forma declarativa o procedimental.
La estructura interna de los marcos permite mantener internamente las restricciones de integridad semántica que existen entre los elementos de un dominio.
Facilitan el diseño y mantenimiento de la BC
Permiten representar valores por omisión y excepciones.
Las redes semánticas no incorporan información procedural, y son difíciles de comprender y mantener cuando aumenta la BC.
Reglas y Frames
Reglas para representar conocimiento de tipo superficial, conocimientos sobre la resolución del problema
Este conocimiento también se puede representar con frames
Los sistemas basados en frames, pueden inferir dinámicamente en tiempo de ejecución, el valor de una propiedad utilizando valores de otras propiedades utilizando demonios
Los frames hacen uso de demonios y la sobrecarga de operadores (selección de métodos en función de los argumentos) para especificar acciones que deberían realizarse frente a ciertas circunstancias/valores
Los demonios permanecen inactivos hasta que se solicitan sus servicios
Las reglas son chequeadas continuamente
Resumen:
Frames apropiados para representar conocimiento PROFUNDO estructura y forma de resolver pb. con algoritmos (incluyendo inferencias/aspectos declarativos)
Reglas para representar conocimiento SUPERFICIAL
Integración
Es difícil que un único esquema de representación sea adecuado para representar todos los tipos de conocimiento
Ventajas de la Integración
Permite construir modelos del comportamiento de dominios que incluyen descripciones estructurales y especificaciones declarativas de:
El comportamiento de los objetos del dominio (Conocimiento profundo)
En lugar de extraer reglas (causa-efecto) de un experto en un sistema que para nosotros es una caja negra, nos creamos un modelo del sistema.
El comportamiento de los expertos que trabajan con los objetos del dominio (Conocimiento superficial)
La combinación de reglas y objetos ofrece un método versátil y natural de modelar los estados y la composición de un sistema.
Ejemplos de lenguajes y entornos de desarrollo que integran distintos formalismos
CLIPS, KEE
CLIPS
CLIPS fue diseñado por el centro espacial Jonshon (NASA) con los siguientes propósitos:
Herramienta de desarrollo de sistemas expertos portable y de bajo costo
Fácil integración con otros sistemas.
Hoy CLIPS es una de las herramientas más difundidas para el desarrollo de sistemas expertos
Los ejecutables, los programas fuentes en C y la documentación de CLIPS son públicos, y existen implementaciones de CLIPS en otros lenguajes (Ada, y Java).
Integración con otras herramientas:
CLISP puede ser llamado como una subrutina (en C) a la que se puede pasar y/o de la que se puede recibir información.
CLIPS puede utilizar funciones externas definidas en otro lenguaje (en C).
Esencialmente es un sistema de Producción de encadenamiento progresivo con una sintaxis extendida del OPS5, y permite utilizar el paradigma de programación estructurada y OO cuando éstos sean más apropiados.
2. Acciones Procedimentales y Funciones
Función if and read
(defrule eleccion-humana
?turno <- (turno h)
? pila <- (numero-de-piezas ?n&(> ?n 1))
=>
(retract ?turno)
(printput t “Escribe el numero de piezas que coges: “)
(bind ?m (read))
(if (and (integerp ?m) (>= ?m 1) (<= ?m 3) (< ?m ?n))
then (retract ?pila)
(bind ?nuevo-numero-de-piezas (- ?n ?m))
(assert (numero-de-piezas ?nuevo-numero-de-piezas))
(printout t “Quedan “ ?nuevo-numero-de-piezas
“ pieza(s)” crlf)
(assert (turno c))
else (printout t “Tiene que elegir un numero entre 1 y 3”
crlf)
(assert (turno h))))
La función while
(While [do] *)
(defrule elige-jugador
?fase <- (fase elige-jugador)
=>
(retract ?fase)
(printout “Elige quien empieza, computadora o humano (c/h):“)
(bind ?jugador (read))
(while (not (or (eq ?jugador c) (eq jugador h))) do
(print t ?jugador “ es distinto de c y h” crlf)
(print t “Elige quien empieza, computadora o humano (c/h):“)
(bind ?jugador (read)))
(assert (turno ?jugador))
(assert (fase elige-numero-de-piezas)))
Definición de funciones
Deffunction
(deffunction turno-de-jugador-elegido ()
(printout “Elige quien empieza, computadora o humano (c/h):“)
(bind ?jugador (read))
(while (not (or (eq ?jugador c) (eq jugador h))) do
(print t ?jugador “ es distinto de c y h” crlf)
(print t “Elige quien empieza, computadora o humano (c/h):“)
(bind ?jugador (read)))
(assert (turno ?jugador)))
(defrule elige-jugador
?fase <- (fase elige-jugador)
=>
(turno-de-jugador-elegido)
(assert (fase elige-numero-de-piezas)))
Relación de funciones procedimentales
Funciones procedimentales definidas
(bind *)
(if then * [else *])
(while [do] *)
(loop-for-count [do] accion*)
(progn *)
(return [])
(break)
Funciones E/S I
(Assert-string )
CLIPS>(defrule inserta-hecho
=>
(print-out t “Escribe un hecho como cadena” crlf)
(assert-string (read)))
CLIPS>(reset)
CLIPS>(run)
Escribe un hecho como cadena
“(color verde)”
CLIPS>(facts)
f-0 (initial-facts)
f-1 (color-verde)
For a total of 2 facts
CLIPS>
Funciones E/S II
(readline) (str-cat *)
CLIPS>(defrule lee-linea
=>
(printout t “Introduce datos.” crlf)
(bind ?cadena (readline))
(assert-string (str-cat “(“ ?cadena “)”)))
CLIPS>(reset)
CLIPS>(run)
Introduce datos.
colores verde azul ambar rojo
CLIPS>(facts)
f-0 (initial-fact)
f-1 (colores verde azul ambar rojo)
For a total of 2 facts
Otras funciones
Funciones de cadenas:
str-cat, sym-cat, substring, str-index, eval, build, etc.
Funciones de campos múltiples:
create, nth, member, delete, explode, implode, etc.
Funciones matemáticas
Trigonométricas: acos, acosh, acot, acoth, acsc, acsh, etc.
Básicas: +, -, *, /, div, max, min, abs, float, integer, deg-grad, deg-rad, grad-deg, rad-deg, pi, **, sqrt, exp, log, log1-, round, mod
Otras:
gensym, random, length
Documentación funciones:
(help)
COOL (CLIPS Object Oriented Language)
Características del la POO en CLIPS
Abstracción
La definición de una nueva clase crea (implementa) un nuevo TAD
Encapsulación
Instancias de clases definidas por el usuarios deben ser accedidas a través de mensajes (Excepto en la lectura de atributos en la LHS de las reglas y en preguntas sobre conjuntos de instancias)
Herencia
Una clase puede definirse a partir de otra u otras
Polimorfismo
La implementación de un mensaje puede ser diferente para distintas clase
Ligadura dinámica
Variables y referencias a instancias pueden referirse dinámicamente a diferentes objetos.
Modelo de objetos inspirado en CLOS y en el modelo clásico.
Desviaciones de la POO pura en CLIPS
No todo es un objeto en CLIPS:
Hechos y reglas se manipulan de la forma tradicional
Preguntas sobre conjuntos de instancias y reglas pueden acceder directamente al valor de los atributos (sin necesidad de mensajes), comprometiendo de esta forma la encapsulación
El beneficio son mayores prestaciones
El paso de mensajes se seguirá utilizando para invocar servicios de instancias ligadas en la RHS de las reglas, o como acciones invocadas a los objetos resultantes de instance-set queries
Estructura de los objetos
La construcción defclass especifica los slots de una nueva clase de objetos,
Los facets permiten especificar propiedades del slot, tal como acceso para lectura y escritura, o reactividad ante reconocimiento de patrones
La construcción defmessage-handler permite definir los métodos para una clase de objetos
La herencia múltiple permite especializar una clase existente
La nueva clase hereda sus slots y sus métodos
Ejemplo de Objetos
(defclass POSESION (is-a USER)
(role concrete)
(pattern-match reactive)
(slot localizacion
(type STRING)
(create-accessor read-write))
(slot valor
(type NUMBER)
(create-accessor read-write))
(defclass COCHE (is-a USER)
(slot color
(type STRING)
(create-accessor read-write))
(slot velocidad-maxima
(type NUMBER)
(create-accessor read-write))
(defclass UTILITARIO (is-a POSESION COCHE)
(slot no-licencia (type SYMBOL) (create-accessor read-write)))
Acceso a objetos (Paso de mensajes)
Sólo se puede acceder a los slots mediante los métodos para leer o escribir en ellos.
CLIPS puede crear estos métodos si se indica en el facet create-accessor
CLIPS es una mezcla de lenguajes OO como Smalltalk y CLOS
Permite enviar mensajes a una instancia: send.
Permite distintos tipos de métodos: primario, before, after y around
Programación declarativa e imperativa
Permite definir funciones genéricas
Los nombres de instancias se indican entre []
Una instancia se crea mediante la función make-instance, la cual envía al nuevo objeto el mensaje init.
Las instancias pueden ser referenciadas por nombre o dirección
Ejemplo acceso a objetos
CLIPS> (make-instance [oc1] of UTILITARIO)
[oc1]
CLIPS> (send [oc1] print)
[oc1] of UTILITARIO
(color nil)
(velocidad-maxima 0)
(localizacion ““)
(valor 0)
(np-licencia nil)
CLIPS> (send [oc1] put-color VERDE)
VERDE
CLIPS> (send [oc1] get-color)
VERDE
CLIPS>
DEFMESSAGE-HANDLER
Defmessage no es para definir los métodos de una función genérica, sino los métodos de una clase.
Métodos after y before (DEMONS —> Igual que en CLOS)
CLIPS> (clear)
CLIPS> (defclass A (is-a USER) (role concrete))
CLIPS> (defmessage-handler A delete before ()
(printout t “Borrando una instancia de la clase A” crlf))
CLIPS>(defmessage-handler A delete after ()
(printout t “Se ha borrado una instancia de la clase A” crlf))
CLIPS>(watch instances)
CLIPS>(make-instance a of A)
==> instance [a] of A
[a]
CLIPS>(send [a] delete)
Borrando una instancia de la clase A
<== instance [a] of A
Se ha borrado una instancia de la clase A
(Gp:) !
Instancia activa y parámetros
self designa la instancia que recibe el mensaje
CLIPS> (clear)
CLIPS> (defclass A (is-a USER) (role concrete))
CLIPS> (make-instance a of A)
[a]
CLIPS> (defmessage-handler A print-args(?a ?b $?c)
(printout t (instance-name ?self) ““ ?a ““ ?b “ y “
(length$ ?c) “ extras: “ ?c crlf))
CLIPS>(send [a] print-args a b c d)
[a] a b y 2 extras: (c d)
CLIPS>
 Página anterior | Volver al principio del trabajo | Página siguiente  |