1

Univers idad de Burgos

F a c u l t a d d e I n f o r m á t i c a

Sistemas Expertos e Inteligencia Artificial

CLIPS

Ricardo Alanis Barrera

Burgos CyL., Febrero 14 de 2005

2

Índice Motivación ........................................................................................................4 Desarrollo .........................................................................................................5 Principales Características ...................................................................................7 Base Teórica ......................................................................................................8

Sistemas de Producción............................................................................................................ 8

Algoritmo RETE .................................................................................................................... 11

Características de los Sistemas de Producción....................................................................... 12

CLIPS ............................................................................................................13 Representación del conocimiento........................................................................................... 13

Estructura de un programa en CLIPS..................................................................................... 13

PROGRAMACIÓN BÁSICA EN CLIPS ............................................................................. 13

MEMORIA DE TRABAJO (MT).......................................................................................... 13

BASE DE CONOCIMIENTO (BC) ...................................................................................... 17

MOTOR DE INFERENCIA .................................................................................................. 21

EJECUCIÓN DE PROGRAMAS .......................................................................................... 22

PROGRAMACIÓN ORIENTADA A OBJETOS EN CLIPS: COOL.................................. 22

Ejemplos de CLIPS ...........................................................................................24 Ventajas..........................................................................................................27 Desventajas .....................................................................................................27 BIBLIOGRAFÍA..............................................................................................28

3

Los sistemas expertos son programas que reproducen el proceso intelectual de un experto

humano en un campo particular, pudiendo mejorar su productividad, ahorrar tiempo y dinero,

conservar sus valiosos conocimientos y difundirlos más fácilmente.

Juan José Samper Márquez

CLIPS es un entorno completo para la construcción de SE basados en reglas y/o objetos. La

versión estándar de CLIPS proporciona un entorno de desarrollo interactivo orientado a

texto, incluyendo una herramienta de depuración, ayuda on-line y un editor integrado,

aunque se han desarrollado interfaces visuales para plataformas Macintosh, Windows 3.x y el

sistema X Window.

4

Motivación

Los orígenes del "C Language Integrated Production System" (CLIPS) data de 1984. Es una

herramienta para el desarrollo de sistemas expertos (SE) creada por la Software Technology

Branch (STB), NASA/Lyndon B. Johnson SpaceCenter.

En este tiempo, la sección de inteligencia artificial se había interiorizado sobre el uso de las

docenas de prototipos, usando el hardware y software disponible para la época. Sin embargo,

a pesar de las demostraciones extensas del potencial de los sistemas expertos, pocos de estos

usos fueron puestos en forma regular. Esta falta de tecnología de los sistemas expertos dentro

de los apremios operacionales de la NASA, se podía remontar en gran parte al uso del lisp

como lenguaje para casi todas las herramientas del software en aquella época. En detalle, tres

problemas obstaculizaron el uso de las herramientas basadas en lisp dentro de la NASA: la

disponibilidad baja del lisp en una variedad amplia de computadoras convencionales, el alto

costo de herramientas avanzadas y de hardware de lisp, y de la integración pobre del lisp con

otros lenguajes. Dado estos problemas era más que evidente que se debería desarrollar una

propia herramienta para la construcción de Sistemas Expertos.

La versión del prototipo de CLIPS fue desarrollada en 1985 en dos meses. La atención

particular fue dada a hacer la herramienta compatible con los sistemas expertos usados en

inteligencia artificial.

La sintaxis de CLIPS fue hecha para asemejarse muy de cerca a la sintaxis de un subconjunto

de la herramienta del sistema experto del ART desarrollada por Inference Corporation.

Aunque estuvieron modelados originalmente de ART, CLISP fue desarrollado enteramente

sin ayuda de la inferencia o del acceso al código de fuente del ART.

El intento original para CLISP era ganar la penetración y el conocimiento útil sobre la

construcción de las herramientas y poner la base para la construcción de una herramienta de

reemplazo para las herramientas comerciales que eran utilizadas por aquel entonces.

5

Desarrollo

Versión

Descripción

La versión 1,0 demostró la viabilidad del

concepto del proyecto.

Después del desarrollo adicional, llegó a ser

evidente que CLIPS sería una herramienta de

bajo costo ideal para los propósitos del

entrenamiento. Otro año del desarrollo y del

uso interno mejoraban su portabilidad,

funcionamiento, funcionalidad, y

documentación de soporte.

La versión 3,0 de CLIPS fue puesta a

disposición fuera de la NASA en el verano de

1986.

Otros realces transformaron CLISP de una

herramienta de entrenamiento en una

herramienta útil para el desarrollo.

Versiones 4,0 y 4,1 de CLIPS Manual de referencia lanzado de CLISP

respectivamente en el verano y a finales de

1987.

La versión 4,2 de CLIPS, lanzada en el

verano de 1988

Reescritura completa de CLIPS para la

modularidad del código. También fueron

incluidos con este lanzamiento un manual de

la arquitectura que proporcionaba una

descripción detallada de la arquitectura del

software de CLIPS y un programa utilitario

para ayudar en la verificación y la validación

de programas basados en las reglas.

La versión 4,3 de CLIPS, lanzada en el

verano de 1989

Agregó más funcionalidad. Originalmente,

la metodología primaria de la representación

en CLIPS era un lenguaje basado en el

algoritmo de Rete.

6

La versión 5,0 de CLIPS, lanzada en 1991 Introdujo dos nuevos paradigmas de

programación: programación procedural

(según lo encontrado en lenguajes tales como

C y Ada) y programación orientada a

objetos.

La versión 5,1 de CLIPS, lanzada a fines de

1991,

Mejora del software requerida para apoyar

las interfaces desarrolladas y/o realzadas de

Windows, de MSDOS, y de Macintosh .

Versión 6,0 de CLIPS, lanzada en 1993 Ayuda para el desarrollo de programas

modulares e integración entre las

capacidades de programación orientadas a

objetos y basadas en las reglas de CLIPS.

Versión 6,1 de CLIPS, lanzada en 1998 Mejora para compiladores NO-ANSI C y

para los compiladores de C++.

CLIPS ahora se mantiene independientemente de la NASA como software de "public

domain".

Debido a su portabilidad, extensibilidad, capacidades, y costo, CLIPS ha recibido la

aceptación extensa a través del gobierno y de la industria. El desarrollo de CLIPS ha

ayudado a mejorar la capacidad de entregar tecnología a los sistemas expertos a través de los

sectores públicos y privados para una amplia gama de usos y de ambientes.

7

Principales Características

• Representación del Conocimiento: CLIPS provee una herramienta cohesiva para manejar una variedad amplia de conocimiento, soporta tres diversos paradigmas de programación: basado en las reglas, orientado al objeto y procedural. La programación basada en las reglas permite que el conocimiento sea representado como heurística, que especifica un sistema de acciones que se realizarán para una situación dada. La programación orientada a objeto permite que los sistemas complejos sean modelados como componentes modulares (que se puedan reutilizar fácilmente para modelar otros sistemas o para crear nuevos componentes). Las capacidades de programación procedurales proveídas por CLIPS son similares a las capacidades encontradas en lenguajes tales como C, Java, Ada, y lisp.

• Portabilidad: CLIPS es escrito en C, para la portabilidad y la velocidad ha estado instalado en diversos sistemas operativos sin cambios del código. Se ha probado en sistemas operativos como Windows 95/98/NT, MacOS X, y Unix. CLIPS puede ser portado hacia cualquier sistema que tenga un compilador ANSI de C o de C++. CLIPS vienen con el código fuente para que pueda ser modificado o adaptado a las necesidades de un usuario.

• Integración/Extensibilidad: CLIPS puede ser embebido en código procedural, ser llamado como un subprograma e integrarse en lenguajes como C, Java, FORTRAN y ADA. CLIP se puede ampliar fácilmente por un usuario con el uso de varios protocolos bien definidos.

• Desarrollo Interactivo: La versión estándar de CLIPS proporciona un ambiente interactivo, texto orientado al desarrollo, incluyendo ayudas de eliminación de errores, ayuda en línea, y un editor integrado. Las interfaces que proporcionaban características tales como menús pulldown, editores integrados, y ventanas múltiples se han desarrollado para el MacOS, Windows 95/98/NT, y los ambientes Windows X.

• Verificación/Validación: CLIPS incluye un número de características para apoyar la verificación y la validación de los sistemas expertos incluyendo ayuda para el diseño modular y repartir la base de conocimiento, la comprobación estática y dinámica de limites de los argumentos de función, y el análisis semántico de los patrones de reglas para determinarse si las inconsistencias podrían prevenir una regla disparando o generando un error.

• Documentado Completamente: CLIPS viene con la documentación extensa incluyendo una guía del manual de referencia y usuario.

• Bajo Costo: CLIP se mantienen como software de public domain.

• Motor de inferencia con encadenamiento progresivo

• Implementación en C del algoritmo de RETE (eficiente)

8

Base Teórica

Sistemas de Producción

Un Sistema de Producción ofrece un mecanismo de control dirigido por patrones para la

resolución de problemas. Representación del conocimiento experto.

Se puede apreciar que las nubes están oscuras y está levantándose viento, y cuando se dan

estos hechos siempre llueve copiosamente.

Requisitos para un sistema de producción:

• Herramienta para implementar búsquedas en el espacio de estados

o Representación del estado del sistema

o Estado Inicial

o Estado Final

o OPERADORES: Reglas de producción actuando sobre estados

Dentro de esta definición general de sistema de producción, se incluyen:

• Lenguajes básicos para sistemas de producción (LISP, CLIPS, PROLOG). También

se les conoce como lenguajes de Inteligencia Artificial.

• Sistemas híbridos y sistemas vacíos (shells) para producción de sistemas basados en

conocimientos (VP-Expert, Expert Teach, Personal Consultant, Intelligence

Compiler, EXSYS).

• Arquitecturas generales para resolución de problemas (máquinas LISP, máquinas

PROLOG).

Un sistema de producción proporciona una estructura que facilita la descripción y la

ejecución de un proceso de búsqueda. Un sistema de producción consiste de:

9

• Memoria de producción: Conjunto de reglas que representan el conocimiento. Las

Reglas consisten de un conjunto de premisas o condiciones (lado izquierdo) y una o

más acciones o conclusiones.

Si P1 & ... & Pn entonces Q1 & ... * Qn

• Interprete de reglas: Decide cuando y como aplicar las reglas.

• Memoria de trabajo: Contiene los datos y resultados intermedios. Memoria de

Trabajo contiene los datos de entrada y resultados intermedios y finales, generalmente

en forma de objeto-atributo-valor.

El intérprete realiza el proceso de inferencia mediante la realización de un ciclo repetitivo

que consiste de tres etapas:

• Realiza el apareamiento de los elementos de las reglas con lo que se encuentra en la

memoria de trabajo para determinar que regla(s) aplica(n).

• Si hay más de una regla que aplique, selecciona una de estas (resolución de conflicto).

• Aplica la regla, modifica la memoria de trabajo y regresa al paso 1.

Si tenemos una serie de reglas encadenadas estas pueden ser "ejecutadas" de diversas

maneras, es decir, la máquina de inferencia puede seleccionar o encadenar (chaining) las

reglas de diferentes formas. Existen dos formas básicas de encadenamiento:

• Encadenamiento hacia adelante (forward chaining): Se va de las condiciones (datos)

hacia las conclusiones (resultados o metas), es decir, se recorre el árbol de abajo hacia

arriba.

• Encadenamiento hacia atrás (backward chaining): Se va de las conclusiones (metas)

hacia las condiciones, es decir, se recorre el árbol de arriba hacia abajo.

En ambos casos podemos tener prioridad lateral o prioridad por profundidad. También se

pueden combinar ambas estrategias (encadenamiento mezclado) o utilizar formas de control

10

más especificas para el problema. La selección de la forma de encadenamiento depende de

varios factores:

• El tipo de aplicación (diagnóstico, diseño, planificación)

• La forma como el "experto" normalmente resuelve el problema.

• La forma de la base de conocimiento, es decir, la configuración del árbol.

• Los mecanismos que soporta la herramienta utilizada.

El conjunto de reglas en la Base de Conocimiento puede ser de dos tipos:

• Determinístico - en cada ciclo del intérprete sólo hay una regla que se puede ejecutar,

es decir hay un "camino" único para la solución de problemas.

• No-determinístico - en cada ciclo puede haber varias reglas que pueden ejecutarse, es

decir que hay varios "caminos" o soluciones posibles.

Los sistemas "reales" son generalmente no-determinísticos, por lo que tiene que haber una

estrategia para seleccionar una regla cuando varias se apliquen, o estén en conflicto en cierto

instante. A este mecanismo se le conoce como resolución de conflicto. Este mecanismo es

muy importante para la efectividad de los sistemas expertos. Se debe basar en dos principios

fundamentales:

• Sensibilidad- responder a los cambios en el medio ambiente.

• Estabilidad - mostrar cierta continuidad en su forma de razonamiento.

Aunque varían las formas de resolución de conflicto, casi todas combinan tres técnicas:

1. Reglas no-repetidas (refratoriness)- no seleccionar las reglas que ya hayan disparado.

Esto generalmente se limita a uno o pocos ciclos y sirve para evitar ciclos.

11

2. Reglas recientes (recency) - seleccionar las reglas que involucren datos mas recientes

en la memoria de trabajo. Para esto se indica el tiempo de llegada de cada elemento en la

MT y sirve para mantenerse en la frontera de la solución.

3. Reglas especificas (specificity) - seleccionar reglas mas específicas, es decir, aquellas

con más condiciones satisfechas. Esto puede servir para manejar excepciones.

Estas técnicas son genéricas y aunque no garantizan la mejor solución, proveen generalmente

una solución adecuada.

La otra alternativa es usar técnicas más específicas para el problema, aunque se pierde

generalidad en el intérprete.

Meta-reglas son reglas que permiten controlar el razonamiento del problema (meta-reglas),

diferenciándose de las reglas que resuelven el problema (reglas a nivel objeto), pueden ser de

dos tipos:

• Específicas para el dominio - solo se aplican a un problema en particular.

• Independientes del dominio - se aplican a cualquier problema o a un tipo de

problemas.

Desde luego que las segundas son más difíciles de encontrar y existe investigación para

encontrar meta-reglas o formas de razonamiento que se apliquen a clases de problemas

diagnóstico, diseño, planificación)

Algoritmo RETE

El apareamiento de patrones (pattern-matching) es costoso computacionalmente. Tiene que

decidir si una lista arbitraria coincide con otra y depende del tamaño y número de variables

en la lista. El algoritmo RETE hace más eficiente este proceso. Para ello elimina dos fuentes

principales de ineficiencia:

12

1. Las reglas generalmente comparten condiciones y es ineficiente tratar de aparear todas

las condiciones con los elementos en la Memoria de Trabajo (ciclos dentro de la iteración

o internos)

2. La Memoria de Trabajo cambia poco cada ciclo y es ineficiente revisar nuevamente

todos los elementos (ciclos entre iteraciones o externos)

Para hacer esto más eficiente, el algoritmo construye una red ordenada en forma de árbol que

contiene todos los patrones en las condiciones (sólo una vez) y se usa para revisar contra la

Memoria de Trabajo evitando los ciclos internos. Se tiene un conjunto de identificadores que

indican que elementos de la MT coinciden con las reglas y este solo se actualiza cada ciclo,

evitando los ciclos externos.

Características de los Sistemas de Producción

Un sistema de producción, al igual que los problemas, puede ser descrito por un conjunto de

características que permiten visualizar la mejor forma en que puede ser implementado.

Un sistema de producción se dice que es monotónico si la aplicación de una regla nunca evita

que más tarde se pueda aplicar otra regla que también pudo ser aplicada al momento en que

la primera fue seleccionada.

Un sistema de producción es parcialmente conmutativo si existe un conjunto de reglas que al

aplicarse en una secuencia particular transforma un estado A en otro B, y si con la aplicación

de cualquier permutación posible de dichas reglas se puede lograr el mismo resultado.

Un sistema de producción es conmutativo, si es monotónico y parcialmente conmutativo.

SISTEMA DE PRODUCCIÓN MONOTÓNICO NO-MONOTÓNICO

PARCIALMENTE CONMUTATIVO

Demostración de Teoremas

Navegación Robótica

PARCIALMENTE NO CONMUTATIVO

Síntesis Química Juego de Ajedrez

13

CLIPS CLIPS ofrece paradigmas heurísticos y procedurales para representar el conocimiento.

Representación del conocimiento. A) Conocimiento heurístico: reglas

• Las reglas se utilizan para representar heurísticas que especifican un conjunto de acciones a realizar para una situación dada.

• El creador del SE define una colección de reglas que, en conjunto, resuelven un problema. • Se puede pensar que las reglas son como sentencias IF-THEN de lenguajes procedurales como C

o Ada. Sin embargo, las reglas actúan más bien como sentencias SIEMPRE QUE-ENTONCES. B) Conocimiento procedural: funciones y objetos. Este tipo de conocimiento se expresa mediante funciones definidas por el usuario (deffunctions), funciones genéricas y la programación orientada a objetos (POO). CLIPS soporta las cinco características generalmente aceptadas: clases, mensajes, abstracción, encapsulamiento, herencia y polimorfismo. Es posible desarrollar software utilizando sólo reglas, sólo objetos, o una mezcla de ambos.

Estructura de un programa en CLIPS El shell (parte de CLIPS que realiza inferencias o razonamiento) provee los elementos básicos de un SE: 1. memoria global de datos (memoria de trabajo, MT): conocimiento factual (fact-list e instance-list). 2. base de conocimiento (knowledge base): contiene las reglas de la base de reglas. 3. motor de inferencia (inference engine): controla la ejecución global de las reglas: decide qué reglas deben ejecutarse y cuándo. Un programa escrito en CLIPS puede consistir en reglas, hechos y objetos. Un SE basado en reglas escrito en CLIPS es un programa dirigido por los datos (data driven), es decir, hechos y objetos. Las reglas pueden coincidir con objetos y hechos, aunque los objetos pueden usarse por sí solos (mediante el envío de mensajes) sin utilizar el motor de inferencia.

PROGRAMACIÓN BÁSICA EN CLIPS

MEMORIA DE TRABAJO (MT) Estructura: lista de hechos y lista de instancias Todos los elementos de la memoria de trabajo (MT) son entidades que corresponden o bien a hechos o bien a instancias de una clase de objetos.

14

La MT consta de una lista de hechos (fact-list) y de una lista de instancias (instance-list). Un hecho es una forma básica de alto nivel para representar información. Es la unidad de datos fundamental utilizada en las reglas. Un hecho se compone de una serie de campos(slots). Un campo es un lugar, con o sin nombre, que puede llevar asociado un valor. Elementos básicos de programación: tipos de datos, funciones y constructores CLIPS proporciona tres elementos básicos para escribir programas:

• Tipos primitivos de datos; para representar información. • Funciones; para manipular los datos. • Constructores; para añadir conocimiento a la BC.

Tipos primitivos de datos también llamados valores de un único campo (single-field values) INFORMACIÓN SIMBÓLICA

• Símbolos (SYMBOL); cualquier secuencia de caracteres ASCII imprimibles. • Cadenas de caracteres (STRING); un conjunto de cero o más caracteres ASCII imprimibles

encerrados entre comillas dobles (").

INFORMACIÓN NUMÉRICA • Enteros (INTEGER). • Punto flotante (FLOAT).

DIRECCIONES (cada elemento de la MT tiene su dirección)

• externa (EXTERNAL-ADDRESS): Dirección de una estructura de datos externa devuelta por alguna función (escrita en otro lenguaje, como C o Ada) que ha sido integrada con CLIPS.

• de hechos (FACT-ADDRESS). • de instancias (INSTANCE-ADDRESS).

Funciones. Una función es un fragmento de código ejecutable (identificado por un nombre) que devuelve un valor o que tiene un efecto lateral útil. Distinguiremos ambos tipos de funciones denominando comandos o acciones a aquellas funciones que no devuelven valores, pero que generalmente tendrán algún efecto lateral útil. Hay varios tipos de funciones: a) funciones (predefinidas) del sistema: definidas internamente por el entorno de CLIPS. b) funciones definidas por el usuario. Se distinguen:

• funciones externas: escritas en otro lenguaje (C, Ada) y ligadas con el entorno de CLIPS. • funciones definidas directamente en CLIPS utilizando sintaxis de CLIPS (deffunctions). • funciones genéricas: son funciones que permiten ejecutar diferentes fragmentos de código

dependiendo del tipo y número de parámetros.

Las llamadas a funciones usan notación prefija: los argumentos de una función aparecen después del nombre de ésta y todo ello entre paréntesis (al estilo de LISP).

15

Constructores. Son estructuras sintácticas identificadas por una palabra reservada del lenguaje que permiten definir funciones, reglas, hechos, clases, etc., que alteran el entorno de CLIPS añadiéndolas a la base de conocimiento. Los constructores no devuelven ningún valor. Su sintaxis también es similar a la definición de funciones. Abstracción de datos: hechos, objetos y variables globales Existen tres formas de representar la información en CLIPS: hechos, objetos y variables globales Hechos: ordenados y no ordenados. Un hecho es una lista de valores atómicos que pueden ser referenciados por la posición que ocupan dentro del hecho (hechos ordenados) o bien por un nombre (hechos no ordenados). La forma de acceder a un hecho de la MT es mediante un índice o dirección (fact index). Un hecho puede ser añadido a la MT, eliminado, modificado o duplicado ya sea directamente por el usuario a través de comandos o mediante un programa CLIPS. HECHOS ORDENADOS

• Secuencia de cero o más campos separados por espacios y delimitados por paréntesis. • El campo inicial suele expresar una relación entre los campos siguientes.

Ejemplo (lista-de-la-compra pan leche arroz) • Los campos de un hecho ordenado pueden ser de cualquier tipo primitivo de datos, excepto el

primero, que debe ser un símbolo. • No es necesario declararlos. • No existe restricción alguna en el orden de los campos. • Para coincidir con una regla sus campos deben aparecer en el mismo orden que indique la regla.

Es decir, los hechos ordenados “codifican” la información según la posición. Para acceder a esa información el usuario debe saber la información que almacena el hecho y qué campo la contiene. HECHOS NO ORDENADOS

• Los hechos no ordenados proporcionan al usuario la habilidad de abstraerse de la estructura del hecho, asignando un nombre a cada campo del mismo De esta forma, podemos acceder a los diferentes campos por su nombre.

• Un hecho no ordenado es una secuencia de cero o más campos con nombres separados por espacios y delimitados por paréntesis.

• El constructor deftemplate crea una plantilla o patrón que se usa para acceder, por su nombre, a los campos (campos) de un hecho no ordenado. Este constructor es análogo a la definición de un registro en lenguajes como Ada o las estructuras de C.

• Sintaxis: (deftemplate <nombre> [<comentario>] <definición-campo>*)

16

Los hechos no ordenados se distinguen de los ordenados mediante el primer campo. El primer campo de cualquier hecho debe ser un símbolo, pero si éste coincide con el nombre de un constructor deftemplate, entonces se considera no ordenado. No importa el orden en el que se referencia el campo y/o el orden en el que aparezcan los campos. Además, podemos restringir el tipo, valor y rango numérico, entre otros, de los campos de un hecho no ordenado: son los atributos de los campos ATRIBUTOS DE LOS CAMPOS Se puede restringir su tipo, valor, rango numérico y la cardinalidad (el número mínimo y máximo de valores para un campo); se pueden especificar valores por defecto. Todas estas características ayudan en el desarrollo y mantenimiento de un SE proporcionando un fuerte tipado y comprobación de restricciones. Atributo type (type <especificación-tipo>) Define el tipo de datos que puede tener el slot. Los tipos válidos son: SYMBOL, STRING, LEXEME, INTEGER, FLOAT, NUMBER. Atributo allowed- Especifica los valores concretos permitidos para un tipo específico. Existen siete atributos de esta clase: allowed-symbols, allowed-strings, allowed-lexemes, allowed-integers, allowed-floats, allowed-numbers y allowed-values (deftemplate persona (slot sexo (type SYMBOL)(allowed-symbols hombre mujer))) Atributo range (range <límite-inferior> <límite-superior>) Permite restringir los valores legales de un tipo numérico a un rango determinado. Tanto el límite inferior como el límite superior pueden ser un valor numérico o ?VARIABLE. Atributo cardinality (cardinality <límite-inferior> <límite-superior>) Permite especificar el número mínimo y máximo que un slot puede contener. Ambos límites pueden ser un entero positivo ó ?VARIABLE, que indica que no hay número mínimo o máximo de valores que el slot puede contener. Atributo default (default <especificación>) Permite especificar un valor por defecto para un slot cuando no se añade o especifica explícitamente. La <especificación> puede ser: ?DERIVE, ?NONE ó una o varias expresiones simples. Definición de hechos iniciales. El constructor deffacts permite especificar un conjunto de hechos como conocimiento inicial. Sintaxis: (deffacts <nombre-colección-hechos> [<comentario>] <patrón-RHS>*) Los hechos de las sentencias deffacts son añadidas a la MT utilizando el comando reset. El comando reset elimina todos los hechos que hubiera en la lista de hechos actual, y a continuación añade los hechos correspondientes a sentencias deffacts. Un programa CLIPS puede ser ejecutado mediante el comando run. Pero puesto que las reglas requieren de hechos para ejecutarse, el comando reset es el método clave para iniciar o reiniciar un sistema experto

17

en CLIPS. Así, el comando reset provoca la activación de algunas reglas, y el comando run inicia la ejecución del programa. Objetos Una instancia es una instanciación o ejemplo específico de una clase (que representa un conjunto de objetos con las mismas propiedades). En CLIPS un objeto puede ser cualquier valor de un tipo primitivo de datos (un entero, un string, un símbolo, una dirección externa, etc.) o una instancia de una clase definida por el usuario. Los objetos vienen descritos por sus propiedades y su conducta. Clase: patrón para propiedades comunes y conducta de los objetos que son instancias. Los objetos se dividen en dos categorías: tipos primitivos e instancias de clases definidas por el usuario. Estos dos tipos difieren en la forma en que se referencian, en cómo se crean y se borran, y en cómo se especifican sus propiedades. Herencia: permite definir las propiedades y conducta de una clase en función de otras clases mientras los hechos no tienen herencia.

BASE DE CONOCIMIENTO (BC) Estructura de las reglas: construcción defrule

o Una regla consta de un antecedente -también denominado parte “si” o parte izquierda de la regla (LHS –left hand side -) y de un consecuente -también denominado parte “entonces” o parte derecha de la regla (RHS – right hand side-).

o El antecedente está formado por un conjunto de condiciones -también denominadas elementos condicionales (EC)- que deben satisfacerse para que la regla sea aplicable. (Existe un and implícito entre todas las condiciones en la parte izquierda de la regla).

¿Cómo se satisfacen los EC de una regla? La satisfactibilidad de un EC se basa en la existencia o no existencia en la MT de los hechos especificados o las instancias de clases definidas por el usuario en la regla. El consecuente de una regla es un conjunto de acciones a ser ejecutadas cuando la regla es aplicable. Estas acciones se ejecutan cuando el motor de inferencia de CLIPS es instruido para que comience la ejecución de las reglas aplicables. Una regla CLIPS es una entidad independiente: no es posible el paso de datos entre dos reglas.

Sintaxis: (defrule <nombre-regla> [<comentario>] [<declaración>] <elemento-condición>* ; Parte izquierda (LHS) => <acción>*) ; Parte dcha. (RHS) de la regla

Si se introduce en la base de reglas una nueva regla con el mismo nombre que el de una existente, la nueva regla reemplazará a la antigua.

18

El comentario, que debe ser un string, se usa normalmente para describir el propósito de la regla o cualquier otra información que el programador desee. Estos comentarios pueden ser visualizados junto con el resto de la regla usando el comando ppdefrule :

Sintaxis: (ppdefrule <nombre-regla>) Si una regla no tiene parte izquierda, es decir, no tiene elementos condicionales, entonces el hecho (initial-fact) actuará como el elemento condicional para ese tipo de reglas, y la regla se activará cada vez que se ejecute un comando reset. Elementos condicionales (EC) Elemento condicional (EC) especifica restricciones sobre elementos de las listas de hechos e instancias: sólo se satisface si existe una entidad (hecho o instancia) que cumple las restricciones expresadas. Una regla se ejecuta cuando:

1. todos sus elementos condición son satisfechos por la lista de hechos y/o la lista de instancias. 2. el motor de inferencia la selecciona.

Tipos de elementos condicionales Colección de restricciones de campos, comodines, y variables que se usan para restringir el conjunto de hechos o instancias que satisfacen el pattern.

Ej.: Con restricciones literales. (altitud es 1000 metros)

Ej.: Con comodines simples y multicampo. (altitud es ? metros)

Ej.: Con variables simples y multicampo. (altitud es ?x metros)

Variables Operadores lógicos: Predicados: Sintaxis: ?<símbolo> Negación: ~ De tipo (todos terminan en p):

numberp, floatp , symbolp, ... No se declaran. Disyunción: | Comparaciones numéricas: =,

<>, <, <=, >, >= El ámbito de una variable es la regla donde se utiliza.

Conjunción: &

Igualdad (desigualdad) en tipo y valor: eq (neq)

Se instancia la primera vez que aparece en una regla y mantiene su valor instanciado en sucesivas apariciones (dentro de la misma regla).

Predicados definidos por el usuario

Se utilizan para relacionar diferentes entidades de las listas de hechos o instancias

test (test <llamada-a-función>)

19

Se usa para evaluar expresiones en la parte izquierda de una regla, interviniendo en el proceso de pattern-matching. El EC test se satisface si la llamada a la función que aparezca dentro de él devuelve cualquier valor distinto de FALSE; en caso contrario, este EC no se satisface.

Ej.: (defrule ejemplo-test (datos ?x) (valor ?y) (test (>= (abs (- ?y ?x)) 3)) =>)

and (and <elemento-condicional>+) Recuérdese que CLIPS supone que todas las reglas tienen un and implícito que rodea todos los elementos condicionales de la LHS. Esto significa que todos los EC que aparezcan en la LHS de la regla deben satisfacerse para que la regla se active. exists (exists <elemento-condicional>+) Este EC permite que se produzca el pattern matching cuando al menos exista un hecho que satisfaga la regla, sin tener en cuenta el número total de hechos que pudiesen matchear. Esto permite una sola activación para una regla con la que matcheen un conjunto de hechos. El EC exists está implementado mediante una combinación de and’s y not’s. Los EC’s dentro de un exists se incluyen dentro de un and y luego dentro de dos not. forall (forall <primer-EC> <resto-de-ECs>+) Permite el matching basado en un conjunto de EC’s que son satisfechos por cada ocurrencia de otro EC. Su funcionamiento es el contrario que el de exists. Para que el EC forall se satisfaga, todo lo que matchee con <primer-EC> debe tener hechos que matcheen todos los demás EC que aparecen acontinuación de <primer-EC>. Comandos (acciones) predefinidos Las acciones o comandos (para distinguirlas de las funciones) son operaciones que no devuelven un valor, pero tienen algún efecto lateral útil. Para crear hechos (assert <hecho>+)

(duplicate <especificador-hecho>)

Para borrar hechos (retract <especificador-hecho>) Para modificar elementos (modify <especificador-hecho> <RHS-slot>*)donde <especificador-hecho> puede ser:

a) una variable previamente ligada a la dirección del hecho a duplicar, borrar o modificar, ó b) un índice de hecho (aunque generalmente éste no se conoce durante la ejecución de un programa).

Acciones procedurales.

20

Ligaduras. La función bind sirve para asignar un valor a una variable, es decir, su efecto es el de una asignación, similar a la que permiten otros lenguajes con el símbolo “:=“.

Sintaxis: (bind <variable> <expresión>*) if - then - else: (if <expresión> then <acción>+ [else <acción>+]) while: (while <expresión> [do] <acción>*) loop-for-count: (loop-for-count (<var> <inicio> <final>) [do] <acción>*) progn$: permite realizar un conjunto de acciones sobre cada campo de un valor multicampo.

Sintaxis: (progn$ <expresión-lista> <expresión>*) return: termina la ejecución de la función actual; si se incluye un argumento, devuelve un valor.

Sintaxis: (return [<expresión>]) break: terminación del ciclo actual: (break) switch: procedimiento de selección múltiple (=?case) Para mayor información puede referirse a las sitios recomendados en la sección de enlaces. Funciones predefinidas

o E/S o Matemáticas o Conversión o de strings o de manejo de valores multicampo o funciones de entorno.

Nombres lógicos. Los nombres lógicos permiten referenciar un dispositivo de E/S sin tener que entender los detalles de la implementación de la referencia. Muchas funciones en CLIPS usan nombres lógicos. Un nombre lógico puede ser un símbolo, un número, ó un string. A continuación se muestra una lista de los nombres lógicos predefinidos en CLIPS: Funciones definidas por el usuario: constructor deffunction Sintaxis: (deffunction <nombre> [<comentario>]

(<parámetro>* [<parámetro-comodín>]) <acción>*)

Una deffunction se compone de cinco elementos: 1) un nombre (que debe ser un símbolo), 2) un comentario opcional, 3) una lista de cero o más parámetros requeridos (variables simples), 4) un parámetro comodín opcional que sirve para manejar un número variable de argumentos (variable multicampo), 5) una secuencia de acciones o expresiones que serán ejecutadas en orden cuando se llame a la función. El valor devuelto por la función es la última acción o expresión evaluada dentro de la función. Si una deffunction no tiene acciones, devolverá el símbolo FALSE. Si se produce algún error mientras se ejecuta la función, cualquier otra acción de la función aún no ejecutada se abortará, y la función devolverá el símbolo FALSE.

21

MOTOR DE INFERENCIA Ciclo básico 1. Si se ha alcanzado el número de ciclo de desencadenamiento expresados o no hay foco actual, entonces PARAR.

Si no, seleccionar para ejecutar la regla tope de la agenda del módulo actual. Si no hay reglas en dicha agenda, entonces eliminar el foco actual de la pila de focos y actualizar al siguiente de la pila. Si la pila de focos está vacía, entonces PARAR, si no ejecutar 1. de nuevo.

2. Se ejecutan las acciones de la parte derecha de la regla seleccionada. Incrementar el nº de reglas desencadenadas.

Si se usa return, entonces eliminar el foco actual de la pila de focos.

3. Como resultado de 2., se activan o desactivan nuevas reglas. Las reglas activadas se sitúan en la agenda del módulo en el que están definidas. La situación concreta depende de la prioridad de la regla (salience) y de la estrategia de resolución de conflictos actual. Las reglas desactivadas salen de la agenda.

4. Si se utiliza prioridad dinámica (dynamic salience), entonces se reevalúan los valores de prioridad de las reglas de la agenda. Ir al paso 1. Filtrado (match) “Construye una instanciación para cada conjunto de elementos que satisfacen una regla” Instanciación: <prioridad> <nombre-regla> : fact-index* Fact index Formato: f-<número-entero>

Entero único asignado por CLIPS a cada entidad (hecho) de la memoria de trabajo. Se crea en tiempo de ejecución. Representa el orden temporal en el que ha sido incorporado a la memoria de trabajo.

La agenda es la lista de todas las reglas cuyas condiciones se satisfacen y todavía no se han ejecutado. Proceso de filtrado de una regla.

Fase 1: Se toman todos los elementos que satisfacen cada una de sus condiciones. Fase 2: Se toman las combinaciones de elementos que satisfacen la restricción impuesta por las variables que relacionan condiciones.

La agenda es la lista de todas las reglas cuyas condiciones se satisfacen y todavía no se han ejecutado. Cada módulo tiene su propia agenda, y su funcionamiento es similar al de una pila: la regla tope de la agenda es la primera que se ejecuta. Cuando una regla se activa de nuevo, se sitúa en la agenda en base a los siguientes factores:

a) las nuevas reglas activadas se sitúan por encima de todas las reglas de menor prioridad (salience) y por debajo de todas las reglas de mayor prioridad. b) entre las reglas de igual prioridad, se utiliza la estrategia de resolución de conflictos actual para determinar su situación relativa.

22

c) si los pasos (a) y (b) no son suficientes para determinar el orden, las reglas se colocan arbitrariamente en relación con las otras reglas (no aleatoriamente, sino que depende de la implementación de las reglas).

CLIPS posee siete estrategias: profundidad (depth), anchura (breadth), simplicidad (simplicity), complejidad (complexity), aleatoria (random), orden lexicográfico (lex), y means-end analysis.

Sintaxis: (set-strategy <nombre-estrategia>) Ejecución (act) Una vez seleccionada una regla, ésta se ejecuta. Las acciones se ejecutan en el orden en el que han sido escritas. A los elementos creados o modificados, se les asigna un índice de hecho (fact index) mayor que todos los existentes. Las modificaciones realizadas en la MT son propagadas al conjunto conflicto (agendas).

EJECUCIÓN DE PROGRAMAS

Un programa CLIPS se ejecuta de la siguiente forma: 1. Se carga en el entorno mediante una instrucción load. 2. Se ejecuta un comando reset. 3. Se lanza el comando run.

A partir del momento en el que se ejecuta el comando run, empiezan a activarse reglas y, posteriormente, se ejecutan. La inicialización de la MT se lleva a cabo de las siguientes formas: Mediante comandos assert No práctico, salvo casos excepcionales.

CLIPS> (assert ...) Inicialización mediante deffacts: incorporación del conocimiento inicial.

(deffacts <nombre> Mediante una regla, que se suele llamar regla de inicio (start-up rule):

PROGRAMACIÓN ORIENTADA A OBJETOS EN CLIPS: COOL Objeto es la colección de información (los datos) que representa una entidad del mundo real y la forma de manipularla (el código asociado). Los objetos vienen descritos por sus propiedades y conducta. Propiedades son especificadas en términos de los atributos (slots) de la clase del objeto. Conducta es en términos de código procedural (gestores de mensajes) asociado a la clase del objeto.

Proporciona mecanismos de abstracción de datos y representación del conocimiento. Es un híbrido de las características de varios lenguajes orientados a objetos y nuevas ideas:

encapsulación similar a la de SmallTalk, reglas de herencia múltiple similares a las de CLOS (Common Lisp Object System).

23

La definición de nuevas clases permite la abstracción de nuevos tipos de datos. Los slots y los gestores de mensajes de las clases describen las propiedades y la conducta de un nuevo grupo de objetos. COOL soporta la encapsulación: requiere el paso de mensajes para manipular las instancias de las clases definidas por el usuario. Una instancia no puede responder a un mensaje para el que no tenga definido el correspondiente gestor de mensajes. COOL permite especificar las propiedades y la conducta de una clase en términos de una o más superclases no relacionadas: herencia múltiple . Para cada nueva clase, COOL utiliza la jerarquía de clases existente para establecer un orden lineal llamado lista de precedencia de clases. Las instancias de estas clases pueden heredar propiedades (slots) y conducta (gestores de mensajes) de cada una de las clases en la lista de precedencia. COOL proporciona 17 clases predefinidas que no pueden ser ni eliminadas ni modificadas por el usuario. El esquema de la jerarquía de las clases es el siguiente:

El uso de objetos en CLIPS es el mismo que el hecho para otros programas de programación, la forma en

que son invocados los mensajes o las consultas varían, pero tienen su uso análogo por lo que habrá gran

tiempo en el uso de ellos. Para mayor información consulte referencias.

24

Ejemplos de CLIPS Los sistemas expertos han existido desde más de 30 años con una amplia gama de estudios y aplicaciones

incluyendo control y gestión del ambiente. Se puede considerar el aire normal si contiene más del 99%

de los siguientes gases: nitrógeno 79.9% oxígeno 19.4%, argón 0.84 y dioxido de carbono en 0.03%. En

Malasia a partir de la regulación de 1995 existe el compromiso de mejora, se reportaron datos de la

contaminación donde la contaminación del aire ocupa el 69%. Esto motivo al desarrollo de estudios para

evaluar la calidad del aire para tomar medidas correctivas.

El sistema Expert System for Air Pollution Management -ES-APM –, fue creado para ayudar a los

administradores del proyecto en estados de planeación, identificación, predicción y evaluación del

impacto ambiental si aplicarán un determinado plan de corrección. Los objetivos del proyecto son

realizar reportes de concernientes a la contaminación del aire, extraer reglas de expertos y literatura. Usar

estas reglas para producir un SE y desarrollar un SE que pueda usarse para producir reportes.

El sistema ES-APM es un sistema experto basado en reglas de soporte a las decisiones en la predicción de

la contaminación aérea debida al desarrollo. El sistema fue construido con CLIPS, una variedad de

metodologías fueron integradas para su construcción, se tomaron las reglas de expertos, se adoptaron para

representar factores de incertidumbre y finalmente el sistema es usado para la predicción precisa de la

contaminación aérea.

Para mayor información de características técnicas, módulos de desarrollo, arquitectura y conclusiones se

pueden dirigir a http://eng.iiu.edu.my/seminar/archive/Air%20pollution%20forecasting.ppt.

El mundo de bloques (deftemplate objeto

(slot nombre (type SYMBOL) (default ?NONE)) (slot localizacion (type SYMBOL) (default almacen)))

(deftemplate robot (slot nombre (type SYMBOL) (default ?NONE)) (slot localizacion (type SYMBOL) (default hangar)) (slot sostiene (type SYMBOL) (default ?DERIVE)))

(deffacts hechos-iniciales (robot (nombre Roby)) (objeto (nombre cubo)) (objetivo Roby coger cubo))

(defrule crea-objetivo-ir-hacia “Crea un subobjetivo ir-hacia a partir de un objetivo coger" (objetivo ?robot coger ?objeto) (objeto (nombre ?objeto) (localizacion ?loc)) => (assert (objetivo ?robot ir-hacia ?loc)))

25

CLIPS> (reset) CLIPS> (facts) f-0 (initial-fact) f-1 (robot (nombre Roby) (localizacion hangar) (sostiene nil)) f-2 (objet (nombre cube) (localizacion almacen)) f-3 (objetivo Roby coger cubo) For a total of 4 facts. CLIPS> (agenda) 0 crea-objetivo-ir-hacia: f-3,f-2 For a total of 1 activation. CLIPS> (run) CLIPS> (facts) f-0 (initial-fact) f-1 (robot (nombre Roby) (localizacion hangar) (sostiene nil)) f-2 (objeto (nombre cube) (localizacion almacen)) f-3 (objetivo Roby coger cubo) f-4 (objetivo Roby ir-hacia almacen) For a total of 5 facts.

EJEMPLO CONCRETO

"Pepe es una persona" "Pepe vive en Toledo"

"Toda persona que viva en Toledo es española" "Toda persona que viva en España es Europea"

persona(pepe) toledano(pepe)

español(x) :- toledano(x) europeo(x) :- español(x)

CLIPS> (reset) CLIPS> (assert (persona pepe)) <f-1> CLIPS> (assert (toledano pepe)) <f-1> CLIPS> (defrule español

persona ?x) (toledano ?x)

=> (assert (español ?x)) (printout t ?x " es español." crlf) )

26

CLIPS> (defrule europeo (persona ?x) (español ?x) => (europeo ?x) (printout t ?x " es europeo." crlf) )

CLIPS> (run)

27

Ventajas

• Modularidad: Los lenguajes basados en reglas son muy modulares.

• Cada regla es una unidad del conocimiento que puede ser añadida, modificada o eliminada independientemente del resto de las reglas.

• – Se puede desarrollar una pequeña porción del sistema, comprobar su correcto funcionamiento y añadirla al resto de la base de conocimiento.

• – Uniformidad: Todo el conocimiento es expresado de la misma forma.

• – Naturalidad: Las reglas son la forma natural de expresar el conocimiento en cualquier dominio de aplicación.

• – Explicación: La traza de ejecución permite mostrar el proceso de razonamiento (watch rules)

• Simplicidad.

• Expresibilidad.

Desventajas • Ineficiencia: La ejecución del proceso de reconocimiento de patrones es muy ineficiente.

• Opacidad: Es difícil examinar una base de conocimiento y determinar que acciones van a ocurrir.

• La división del conocimiento en reglas hace que cada regla individual sea fácilmente tratable, pero se pierde la visión global.

• Dificultad en cubrir todo el conocimiento: Aplicaciones como el control de tráfico aéreo implicarían una cantidad de reglas que no serían manejables.

• Difícil de predecir el resultado de la competencia entre alternativas y depende mucho de los mecanismos de control.

• Difícil expresar conocimiento más estructurado y relaciones entre objetos.

• Decisiones basadas en información local limitada.

• Difícil implementar ciertas construcciones convencionales como ciclos y recursión.

28

BIBLIOGRAFÍA

Descripción

What´s CLIPS, http://www.ghg.net/clips/WhatIsCLIPS.html, 8-feb-05

Historia de CLIPS

Historia del CLIPS, http://gigiman.epublish.cl/articles/epublish_20021211145455.html

CLIPS History, http://202.41.85.117/courses/AAI/CD-1/CLIPS/History.html

Ejemplos de Aplicaciones http://tryke.elcurriculum.com/2004/12/00015.html

http://www.ghg.net/clips/OtherWeb.html

http://tryke.blogcindario.com/ficheros/html/clips.html#indice1

http://eng.iiu.edu.my/seminar/archive/Air%20pollution%20forecasting.ppt

Base Teórica y CLIPS

http://iaaa.cps.unizar.es/docencia/IA/aiSP8_03.pdf http://www.uco.es/grupos/eatco/informatica/ia/tema1.pdf http://scalab.uc3m.es/~docweb/ia/practicas/ReglasConClips.pdf

Para mayor Información

http://www.ghg.net/clips/CLIPS.html

http://www.gsi.dit.upm.es/~cif/cursos/ssii/

Manual de Referencia y Tutoriales CLIPS Basic Reference Manual , http://www.ghg.net/clips/download/documentation/bpg.pdf --Muy bueno pdf CLIPS Advanced Reference Manual, http://scalab.uc3m.es/~docweb/ia/clips_doc/apg.pdf Tutoriales de CLIPS, http://iweb.tntech.edu/bhuguenard/ds6530/ClipsTutorial/tableOfContents.htm Reference Manual Syntax, http://www.csie.ntu.edu.tw/~sylee/courses/clips/bpg/node2.2.html Reference Manual, http://scalab.uc3m.es/~docweb/ia/CLIPS_REFERENCIA/, Muy completo html Practicas de CLISP, http://uco.isoplut.com/ia/publicado.html