14/04/2015 1 implementación de un lenguaje basado en reglas. josé angel bañares. v-1998....
TRANSCRIPT
21/04/23 1Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas
Implementación de motores de inferencia dirigidos por patrones II
Implementación de motores de inferencia dirigidos por patrones II
Copyright © 1998 José Angel Bañares
Departamento de Informática e Ingeniería de SistemasC.P.S. Universidad de ZaragozaDepartamento de Informática e Ingeniería de SistemasC.P.S. Universidad de Zaragoza
Última revisión: Nov. 2004
21/04/23 2Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas
Índice
7. Diseño de un sistema de encadenamiento de reglas hacia adelante con mecanismo de contexto para establecer suposiciones.
8. Implementación de un JTMS
9. Integración del JTMS con un motor de inferencia.
10. Ejemplo, búsqueda dirigida por dependencias.
11. Comparación de resultados experimentales
Bibliografía
K.D. Forbus and J.de Kleer. “Building Problem Solvers”. The MIT Press, 1993.
21/04/23 3Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas
7. Un PDIS con mecanismo de manejo de contextos
Aserciones: se almacenan en la base de datos
Denominaremos aserción la estructura de datos asociada a la aserción para registrar si se cree o no en la afirmación y por qué.
(Tiene-Valor (ganancia ?amperios) ?beta)
Denominaremos forma a la lista registrada en la base de datos (BdD).
Interfaz:
assert!: Inserta una forma en la BdD
fetch: Recupera una aserción de la BdD
NO hay mecanismo para borrar aserciones
o Nuestro diseño hasta aquí no tiene una forma adecuada de eliminar las consecuencias de una creencia, por lo que no podemos manejar adecuadamente el borrado.
21/04/23 4Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Reglas
(rule <trigger> . <body>)
Trigger: Un patrón que especifica la clase de aserciones a las que la regla pretende responder
body: Código lisp evaluado en el entorno formado al unificar el patrón con una aserción particular.
(rule (foo ?x) (format t “foo(~A) ha sido asertado.” ?x))
Una regla con varias premisas se escribiría anidando varias reglas más simples:
(rule (sobre ?x mesa) (rule (sobre ?y ?x)
(rule (sobre ? z ?y) (assert! ‘(Torre-3 ,?x ,?y ,?z)))))
21/04/23 5Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas reglas anidadas
Cuando una regla contiene en su body otra regla, es decir formas que comienzan con rule, el resultado de la ejecución de la primera es la creación de una nueva regla que se añade a la base de reglas y se trata como cualquier otra.
o El trigger y el body de esta nueva regla tiene como entorno de ligaduras las introducidas por los triggers de las reglas que la contenían:
(sobre D MESA)(sobre E D)(sobre F E)
(rule (sobre ?x mesa) ; reconoce (sobre D MESA) (rule (sobre ?y ?x)
(rule (sobre ?z ?y) (asser! ‘(Torre-3 ,?x ,?y ,?z))))) Se inserta la regla --> (rule(sobre ?y D) ; reconoce (sobre E D) (rule (sobre ?z D)(asser! ‘(Torre-3 D E ,?z)))) Se inserta la regla --> (rule (sobre ?z E) ; Reconoce (sobre F E) (asser! ‘(Torre-3 D E F)))) Se inserta la aserción --> (Torre-3 D E F)
21/04/23 6Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Duración de las reglas
Las reglas creadas por anidación o sus progenitoras permanecen en la Base de reglas siempre(sobre D MESA)(sobre E D)(sobre F E)(sobre G E)
La regla más interna vuelve a dispararse
(rule (sobre ?z E) ; Reconoce (sobre G E) (asser! ‘(Torre-3 D E F)))) Se inserta la aserción --> (Torre-3 D E G)
o Beneficio de la permanencia de las reglas: El PDIS es independiente del orden de ejecución de las reglas
o Inconveniente: Es más fácil generar explosiones combinatorias y más difícil de mantener la eficiencia.
21/04/23 7Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas 7.1 Diseño de TRE (Tiny Rule Engine)
Organización de los cómputos
Cuando una aserción es añadida se debe chequear cada regla que podría reconocerla
Cuando se añade una regla, se debe chequear cada aserción que podría ser reconocida
o En ambos casos el body y su entorno se apilan para una ejecución eventual
BdDAserciones
BdDReglas
Cola
Aserciones y reglas suministradas por el usuario
Nuevas reglas
instanciadas
Nuevas asercionesderivadas
21/04/23 8Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Elecciones de diseño
Elecciones obvias
Aserciones: Implementadas como una lista
Pattern matching: Implementa el algoritmo de unificación
Elecciones no tan obvias
Bases de datos: ¿Cómo almacenar las reglas y las aserciones?
Reglas: ¿Cómo las representamos para que se ejecuten en el entorno adecuado?
Cola de reglas: ¿Qué debería ir exactamente a la cola y como servimos las instancias?
21/04/23 9Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Diseño de la BdD
Class Indexing:
Se parte las reglas y las aserciones en dbclasses que corresponden a los elementos que podrían reconocerse
o La clase de una aserción / trigger es el símbolo constante más a la izquierda
DBClass((implies foo bar)) = implies DBClass(foo) = foo DBClass(((grumbble mumble) bar)) = grumble
o Sólo una aserción y un trigger en la misma clase (dbclass) pueden reconocerse
o Si el símbolo más a la izquierda es una variable, tomaremos la dbclass del valor de la variable. Consideraremos un error si no tiene valor.
Si queremos saber todas las relaciones binarias entre A y B,
patrón (A ?rel B) relaciones (<1er arg> <Predicado> <2 arg>)
NO se puede patrón (?rel A B) relaciones (<Predicado> <1er arg> <2 arg>)
21/04/23 10Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas
7.2 Diseño de un FTRE (Faster Tiny rule Engine)
Mejoras:
Una sintaxis más “limpia” para escribir reglas
Mecanismo de manejo de contextos
1. Mejora de la sintaxis
Sintaxis más sencilla de las reglas anidadas
(rule (demuestra ?q)(rule (implica ? p ?q) (assert! ‘(demuestra ,?p))))
(rule ((demuestra ?q) ; (implica ? p ?q)) (assert! ‘(demuestra ?p))))
21/04/23 11Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas 7.2.1 Mejora de la sintaxis
:VAR y TEST en los triggers
o :VAR el siguiente elemento del trigger es una variable a la que se da el valor del patrón
o :TEST un predicado adicional sobre el patrón
(rule ((demuestra ?q) :test (not (fetch ?q)) (implica ? p ?q) :var ?imp) (DEBUG-ND “~% BC-CE: Buscando ~A para usar ~A.”
?p ?imp) (assert! ‘(demuestra ?p))))
21/04/23 12Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas 7.2.1 Manejo de contextos
Muchas formas de razonar conllevan hacer suposiciones
Una pila permite tener un contexto local en el cual las variables pueden tomar valores distintos durante un tiempo
(demuestra P)(not Q)(implica (not P) Q)(implica (not Q) R)
(demuestra P)(not Q)(implica (not P) Q)(implica (not Q) R)
(demuestra P)(not Q)(implica (not P) Q)(implica (not Q) R)
(demuestra P)(not Q)(implica (not P) Q)(implica (not Q) R)
(not P) (not P)Q¡Contradicción!
31 2 4
21/04/23 13Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Manejo de contextos
¿Cómo debemos organizar nuestras reglas y nuestro intérprete?
o 1. Distinguiremos entre reglas que hacen suposiciones de las que no las hacen.
Las reglas que no hacen suposiciones deben ejecutarse antes para asegurarnos de que las deducciones se hacen en el entorno lógico menor.
o 2. Debemos organizar la base de datos para apilar y desapilar aseciones e instancias.
Implícitamente estamos llevando a cabo una búsqueda en profundidad
o Pondremos un límite en la profundidad alcanzada
21/04/23 14Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas 7.3 Interfaz del FTRE
(defstruct (ftre (:PRINT-FUNCTION ftre-printer)) title ; String para impresión (dbclass-table nil) ; symbols --> classes (BdD global) (debugging nil) ; imprime info. extra si non-nil (debugging-contexts nil) (normal-queue nil) ; LIFO. Instancias que no hacen supos. (asn-queue nil) ; Instancias que hacen supos. (depth 0) ; Profundidad en curso (max-depth 5) ; Máxima profundidad de contextos (local-data nil) ; Contextos mantenidos por (local-rules nil) ; see-in-context y try-in-context (rule-counter 0) ; id unico para reglas (rules-run 0)) ; Estadísticas
(defun ftre-printer (ftre st ignore) (format st "<FTRE: ~A>" (ftre-title ftre)))
21/04/23 15Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Interfaz FTRE
(defun create-ftre (title &key (debugging nil) (debugging-contexts nil) (max-depth 5)) (make-ftre :TITLE title :DBCLASS-TABLE (make-hash-table :test #'eq) :DEBUGGING debugging :DEBUGGING-CONTEXTS debugging-contexts :MAX-DEPTH max-depth)); Invocar el motor de inferencia(defun run (&optional (*TRE* *TRE*)) (format T "~%>>") (do ((form (read) (read))) ((member form '(quit stop exit)) nil) (format t "~%~A" (eval form)) (run-rules *tre*) (format t "~%>>")))
; Muestra el contenido de afirmaciones y reglas(defun show (&optional (stream *standard-output*)) ;; Pass on the request to both modules of default TRE (show-data stream) (show-rules stream))
21/04/23 16Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Evaluando en un contexto
(defun try-in-context (assumption form &optional (*ftre* *ftre*) &aux (depth 0)) (setq depth (ftre-depth *ftre*)) (when (> depth (ftre-max-depth *ftre*)) (debugging-contexts "~% ~A(~D): Punting on trying ~A, too deep." *ftre* (ftre-depth *ftre*) assumption) (return-from TRY-IN-CONTEXT nil)) (let ((old-local-data (ftre-local-data *ftre*)) (old-local-rules (ftre-local-rules *ftre*)) (old-normal-queue (ftre-normal-queue *ftre*)) (old-asn-queue (ftre-asn-queue *ftre*)) (result nil)) (setf (ftre-normal-queue *ftre*) nil) (setf (ftre-asn-queue *ftre*) nil) (incf (ftre-depth *ftre*)) (push (ftre-depth *ftre*) (ftre-local-data *ftre*))
21/04/23 17Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Evaluando en un contexto
(debugging-contexts "~% ~A(~D): Trying ~A." *ftre* (ftre-depth *ftre*) assumption) (with-ftre *ftre* (if assumption (assert! assumption)) (run-rules *ftre*) (debugging-contexts "~% ~A(~D): Context ~A for ~A." *ftre* (ftre-depth *ftre*) assumption form) (debugging-contexts "~% ~D facts and ~D rules in local context." (- (length (ftre-local-data *ftre*)) (length old-local-data)) (- (length (ftre-local-rules *ftre*)) (length old-local-rules))) (setq result (eval form)) (setf (ftre-local-data *ftre*) old-local-data) (setf (ftre-local-rules *ftre*) old-local-rules) (setf (ftre-normal-queue *ftre*) old-normal-queue) (setf (ftre-asn-queue *ftre*) old-asn-queue) (decf (ftre-depth *ftre*)) result)))
21/04/23 18Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas 7.4 Data base
(defstruct (dbclass (:PRINT-FUNCTION print-dbclass-struct)) name ;Un símbolo ftre ;ftre al que pertenece facts ;Hechos en la dbclass rules) ;Reglas aplicables en esta dbclass
(defun show-data (&optional (stream *standard-output*) &aux counter) (setq counter 0) (format stream "~%In global context: ") (maphash #'(lambda (key dbclass) (dolist (datum (dbclass-facts dbclass)) (incf counter) (format stream "~%~A" datum))) (ftre-dbclass-table *ftre*)) (format stream "~% ~D assertions in global context." counter) (when (> (ftre-depth *ftre*) 0) (format stream "~% In current context:") (dolist (datum (reverse (ftre-local-data *ftre*))) (unless (numberp datum) (incf counter)) (format stream "~% ~A." datum))) counter)
21/04/23 19Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Insertando datos
(defun assert! (fact &optional (*ftre* *ftre*)) (when (insert fact *ftre*) (try-rules fact *ftre*)))
(defun insert (fact ftre &aux dbclass) (when (null fact) (error "~% Can't assert NIL.")) (setq dbclass (get-dbclass fact ftre)) (cond ((member fact (dbclass-facts dbclass) :TEST #'equal) nil) ((= (ftre-depth ftre) 0) (push fact (dbclass-facts dbclass))) ((member fact (ftre-local-data ftre) :TEST #'equal) nil) (t (push fact (ftre-local-data *ftre*)))))
21/04/23 20Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas get-dbclas
(defun get-dbclass (fact ftre &aux dbclass) (cond ((null fact) (error "~% NIL can't be a dbclass.")) ((listp fact) (get-dbclass (car fact) ftre)) ((variable? fact) (cond ((boundp fact) (get-dbclass (symbol-value fact) ftre)) (t (error "~%Dbclass unbound: ~A" fact)))) ((symbolp fact) (cond ((gethash fact (ftre-dbclass-table ftre))) (t (setq dbclass (make-dbclass :NAME fact :FTRE ftre :FACTS nil :RULES nil)) (setf (gethash fact (ftre-dbclass-table ftre)) dbclass) dbclass))) (t (error "Bad dbclass type: ~A" fact))))
21/04/23 21Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Recuperando datos
(defun fetch (pattern &optional (*ftre* *ftre*) &aux bindings unifiers) (dolist (candidate (get-candidates pattern *ftre*) unifiers) (setq bindings (unify pattern candidate)) (unless (eq bindings :FAIL) (push (sublis bindings pattern) unifiers))))
(defun get-candidates (pattern ftre) (append (ftre-local-data ftre) (dbclass-facts (get-dbclass pattern ftre))))
21/04/23 22Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas 7.5 Reglas
(defstruct (rule (:PRINT-FUNCTION ftre-rule-printer)) id ;"nombre" único Dbclass ;Dbclass con la que está relacionado matcher ;Procedimiento que realiza el matching body ;procedure que ejecuta el body assumption?) ;Establece suposición?
(defun run-rules (*ftre*) (do ((form (dequeue *ftre*) (dequeue *ftre*)) (counter 0 (1+ counter))) ((null form) (debugging-ftre "~% ~A(~A): ~A rules run." *ftre* (ftre-depth *ftre*) counter)) (incf (ftre-rules-run *ftre*)) (with-ftre *ftre*
(apply (car form) (cdr form)))))
21/04/23 23Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas try-rules
(defun try-rules (fact ftre) (dolist (rule (get-candidate-rules fact ftre)) (try-rule-on rule fact)))
(defun get-candidate-rules (fact ftre) (append (ftre-local-rules ftre) (dbclass-rules (get-dbclass fact ftre))))
(defun try-rule-on (rule fact) (with-ftre (dbclass-ftre (rule-dbclass rule)) (multiple-value-bind (okay? bindings) (funcall (rule-matcher rule) fact) (when okay? (enqueue *ftre* (cons (rule-body rule) bindings) (rule-assumption? rule))))))
21/04/23 24Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas 7.6 Ejemplo de las N-reinas
Dado un tablero de NxN cuantas formas hay de colocar N reinas en el tablero sin que se coman
Q
Q
Q
Q
Q
Q
Q
Q
Buena solución Mala solución
21/04/23 25Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Choice set
Conceptualmente podemos ver el conjunto de localizaciones alternativas como un conjunto de elecciones.
La idea de los choice sets como método para organizar la búsqueda es
o Cada choice set representa un factor/aspecto que puede aparecer en la solución
o Dentro de cada choice set, las elecciones son mutuamente excluyentes y exhaustivas
o Cada solución puede encontrarse por un conjunto de selecciones, una de cada choice set.
(defun Chrono (choice-sets)(if (null choice-sets)
(record-solution) ; Guarda el resultado (dolist (choice (first choice-sets))
(while-assuming choice ; Hace una suposición, y la retira
; una vez ejecutado el cuerpo(if (consistent?) ;Cheque la consistentcia
(Chrono (rest choice-sets)))))))
21/04/23 26Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Representación
(Queen ?I ?J) ; indica que la reina de la fila ?I está en la columna ?J
Regla que detecta dos reinas en peligro y aserta contradicción:
(rule ((queen ?column1 ?row1) (queen ?column2 ?row2) :TEST (not (or (= ?column1 ?column2) (queens-okay? ?column1 ?row1 ?column2 ?row2)))) (rassert! Contradiction))
(defun queens-okay? (x1 y1 x2 y2); Detecta si dos reinas están en mutuo peligro
(not (or (= y1 y2) (= (abs (- x1 x2)) (abs (- y1 y2))))))
21/04/23 27Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Crea el motor de inferencia
Creación de un motor de inferencia e inicio de la búsqueda:
;;; Estadísticas de la búsqueda(defvar *n-assumptions* 0) ;numero de suposiciones (defvar *placements* nil) ;Sóluciones encontradas
;;; Crea el motor de inferencia e inicia la búsqueda(defun n-queens (n &optional (debugging? nil)) (setup-queens-puzzle n debugging?) (solve-queens-puzzle (make-queens-choice-sets n)) (length *placements*))
(defun setup-queens-puzzle (n debugging?) (in-ftre (create-ftre (format nil "~D queens" n) :DEBUGGING debugging? :MAX-DEPTH (+ n 1))) (setq *placements* nil *n-assumptions* 0) (load-file *ftre-path* *fqueen-rule-file*)) ; Carga el fichero
; con la regla
21/04/23 28Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Búsqueda
Búsqueda(defun make-queens-choice-sets (n) (do ((column 1 (1+ column)) (column-queens nil nil) (choice-sets nil)) ((> column n) (nreverse choice-sets)) (dotimes (row n) (push `(Queen ,column ,(1+ row)) column-queens)) (push (nreverse column-queens) choice-sets)))
;;; Búsqueda cronológica(defun solve-queens-puzzle (choice-sets) (cond ((fetch 'contradiction) (return-from solve-queens-puzzle nil)) (choice-sets ;; Hace la siguiente elección (dolist (choice (car choice-sets)) (incf *n-assumptions*) (try-in-context choice `(solve-queens-puzzle ',(cdr choice-sets))))) (t ;; Guarda la solución en *placements* (gather-queens-solution))))
21/04/23 29Implementación de un lenguaje basado en reglas. José Angel Bañares. V-1998. LenguajeReglas.ppt
ImplementaciónImplementaciónReglasReglas Utilidades
Utilidades(defun gather-queens-solution () (push (fetch '(Queen ?x ?y) *ftre*) *placements*))
(defun show-queens-solution (solution n &aux l m) (setq solutions (length solution)) (dotimes (sol solutions) (terpri) (dotimes (l n) (terpri) (dotimes (m n) (setf i (1+ l) j (1+ m)) (format t "~A" (if (member `(queen ,i ,j) (nth sol solution) :TEST #'equal) "Q" "-"))))))
(defun n-reinas (n) (n-queens n) (show-queens-solution *placements* n))