Universidad de Burgos

Facultad de Informática

Sistemas Expertos e Inteligencia Artificial

CLIPS

Ricardo Alanis Barrera

Burgos CyL., Febrero 14 de 2005

1
Í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

2
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.

3
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.

4
Desarrollo

Versión Descripción

La versión 1,0 demostró la viabilidad del Después del desarrollo adicional, llegó a ser
concepto del proyecto. 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 Otros realces transformaron CLISP de una
disposición fuera de la NASA en el verano de herramienta de entrenamiento en una
1986. 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 Reescritura completa de CLIPS para la

verano de 1988 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 Agregó más funcionalidad. Originalmente,

verano de 1989 la metodología primaria de la representación
en CLIPS era un lenguaje basado en el
algoritmo de Rete.

5
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 Mejora del software requerida para apoyar
1991, 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.

6
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)

7
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:

8
 • 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

9
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.

10
 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:

11
 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 Demostración Navegación Robótica

CONMUTATIVO de Teoremas

PARCIALMENTE Síntesis Química Juego de Ajedrez

NO CONMUTATIVO

12
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ístic as
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.
13
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); cualquie r 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).

14
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>*)

15
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
16
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.

17
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 Conjunción: & Igualdad (desigualdad) en tipo y
regla donde se utiliza. valor: eq (neq)
Se instancia la primera vez que Predicados definidos por el
aparece en una regla y mantiene usuario
su valor instanciado en sucesivas
apariciones (dentro de la misma
regla).
Se utilizan para relacionar
diferentes entidades de las listas
de hechos o instancias

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

18
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.

19
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.

20
MOTOR DE INFERENCIA

Ciclo básico
1. Si se ha alcanzado el número de ciclo de desencadenamie nto 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.
21
 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).

22
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.

23
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)))

24
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) )

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

26
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.

27
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

28